diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 1508856eb4..d520621fc6 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -10,7 +10,6 @@ lib/compiler-cranelift             @syrusakbary
 lib/compiler-llvm                  
 lib/compiler-singlepass            @syrusakbary
 lib/deprecated                     
-lib/emscripten                     
 lib/engine                         @syrusakbary
 lib/engine-jit                     @syrusakbary
 lib/engine-native                  @syrusakbary
diff --git a/.github/cross-linux-riscv64/Dockerfile b/.github/cross-linux-riscv64/Dockerfile
index 47eb4b6e5d..94d091f3a6 100644
--- a/.github/cross-linux-riscv64/Dockerfile
+++ b/.github/cross-linux-riscv64/Dockerfile
@@ -28,7 +28,7 @@ RUN apt-get update  && \
 # install rust tools
 RUN curl --proto "=https" --tlsv1.2 --retry 3 -sSfL https://sh.rustup.rs | sh -s -- -y
 ENV PATH="/root/.cargo/bin:${PATH}"
-RUN rustup -v toolchain install 1.74
+RUN rustup -v toolchain install 1.84
 # add docker the manual way
 COPY install_docker.sh /
 RUN /install_docker.sh
@@ -61,7 +61,7 @@ ENV CARGO_TARGET_RISCV64GC_UNKNOWN_LINUX_GNU_LINKER="$CROSS_TOOLCHAIN_PREFIX"gcc
     RUST_TEST_THREADS=1 \
     PKG_CONFIG_PATH="/usr/lib/riscv64-linux-gnu/pkgconfig/:${PKG_CONFIG_PATH}"
 
-RUN rustup target add riscv64gc-unknown-linux-gnu --toolchain 1.74-x86_64-unknown-linux-gnu
+RUN rustup target add riscv64gc-unknown-linux-gnu --toolchain 1.84-x86_64-unknown-linux-gnu
 
 #compile libssl-dev for riscv64!
 COPY build_openssl.sh /
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 7339c70102..3d53f4dfad 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1,6 +1,6 @@
 <!-- 
 Prior to submitting a PR, review the CONTRIBUTING.md document for recommendations on how to test:
-https://github.com/wasmerio/wasmer/blob/main/CONTRIBUTING.md#pull-requests
+https://github.com/wasmerio/wasmer/blob/main/docs/CONTRIBUTING.md#pull-requests
 
 -->
 
diff --git a/.github/workflows/benchmark.yaml b/.github/workflows/benchmark.yaml
index 53b75bd202..d1843c3204 100644
--- a/.github/workflows/benchmark.yaml
+++ b/.github/workflows/benchmark.yaml
@@ -3,11 +3,11 @@ name: Run Benchmarks and upload results
 on:
   push:
     branches:
-    - benchmark  # TODO: change it back to main once we really track the results. We commented this as speed.wasmer.io is failing
+      - benchmark # TODO: change it back to main once we really track the results. We commented this as speed.wasmer.io is failing
 
 env:
   CARGO_REGISTRIES_CRATES_IO_PROTOCOL: git
-  MSRV: "1.74"
+  MSRV: "1.84"
 
 jobs:
   run_benchmark:
@@ -24,7 +24,7 @@ jobs:
       SCCACHE_AZURE_BLOB_CONTAINER: wasmerstoragesccacheblob
       SCCACHE_AZURE_CONNECTION_STRING: ${{ secrets.SCCACHE_AZURE_CONNECTION_STRING }}
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
@@ -72,4 +72,3 @@ jobs:
           git clone https://github.com/wasmerio/wasmer-bench
 
           python3 wasmer-bench/send_metrics.py
-
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 89c2e32f95..ab546fa51e 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -3,19 +3,23 @@ name: Builds
 env:
   RUST_BACKTRACE: 1
   CARGO_REGISTRIES_CRATES_IO_PROTOCOL: git
-  MSRV: "1.74"
+  MSRV: "1.84"
 
 on:
   push:
     branches:
-      - 'main'
+      - "main"
     tags:
       # this is _not_ a regex, see: https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions#filter-pattern-cheat-sheet
-      - '[0-9]+.[0-9]+.[0-9]+*'
+      - "[0-9]+.[0-9]+.[0-9]+*"
+  pull_request:
+    branches:
+      - "main"
   workflow_dispatch:
     inputs:
       release:
-          description: 'Make release'
+        description: "Make release"
+
 jobs:
   setup:
     name: Set up
@@ -37,74 +41,136 @@ jobs:
 
   build:
     name: Build on ${{ matrix.build }}
+    if: github.event_name != 'pull_request' || startsWith(github.head_ref, 'release-')
     runs-on: ${{ matrix.os }}
     needs: setup
     strategy:
       fail-fast: false
       matrix:
         include:
+          - build: linux-arm64
+            os: ubuntu-22.04-arm
+            artifact_name: "wasmer-linux-aarch64"
+            #llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-linux-aarch64.tar.xz"
+            cross_compilation_artifact_name: "cross_compiled_from_linux"
+            use_sccache: false
+            use_rustcache: false
+            build_wasm: true
+            enable_llvm: false
+            enable_v8: false
+            enable_wasmi: true
+            enable_wamr: true
           - build: linux-x64
-            os: ubuntu-20.04
-            artifact_name: 'wasmer-linux-amd64'
-            llvm_url: 'https://github.com/wasmerio/llvm-custom-builds/releases/download/15.x/llvm-linux-amd64.tar.xz'
-            cross_compilation_artifact_name: 'cross_compiled_from_linux'
+            os: ubuntu-22.04
+            artifact_name: "wasmer-linux-amd64"
+            llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-linux-amd64.tar.xz"
+            cross_compilation_artifact_name: "cross_compiled_from_linux"
             use_sccache: false
-            use_llvm: true
             build_wasm: true
+            enable_llvm: true
+            enable_v8: true
+            enable_wasmi: true
+            enable_wamr: true
           - build: macos-x64
-            os: macos-12
-            llvm_url: 'https://github.com/wasmerio/llvm-custom-builds/releases/download/15.x/llvm-darwin-amd64.tar.xz'
-            artifact_name: 'wasmer-darwin-amd64'
-            cross_compilation_artifact_name: 'cross_compiled_from_mac'
+            os: macos-13
+            llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-darwin-amd64.tar.xz"
+            artifact_name: "wasmer-darwin-amd64"
+            cross_compilation_artifact_name: "cross_compiled_from_mac"
             use_sccache: false
-            use_llvm: true
             build_wasm: false
+            enable_llvm: true
+            enable_v8: true
+            enable_wasmi: true
+            enable_wamr: true
           - build: macos-arm64
             os: macos-14
             target: aarch64-apple-darwin
-            artifact_name: 'wasmer-darwin-arm64'
+            artifact_name: "wasmer-darwin-arm64"
             use_sccache: false
-            use_llvm: false
             build_wasm: false
+            llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-darwin-aarch64.tar.xz"
+            enable_llvm: true
+            enable_v8: true
+            enable_wasmi: true
+            enable_wamr: true
           - build: windows-x64
-            os: windows-2019
-            artifact_name: 'wasmer-windows-amd64'
-            llvm_url: 'https://github.com/wasmerio/llvm-custom-builds/releases/download/15.x/llvm-windows-amd64.tar.xz'
-            cross_compilation_artifact_name: 'cross_compiled_from_win'
-            use_sccache: false
-            use_llvm: true
+            os: windows-2022
+            artifact_name: "wasmer-windows-amd64"
+            llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-windows-amd64.tar.xz"
+            cross_compilation_artifact_name: "cross_compiled_from_win"
             build_wasm: false
-          - build: linux-musl-x64
-            os: ubuntu-latest
-            artifact_name: 'wasmer-linux-musl-amd64'
-            #llvm_url: 'https://github.com/wasmerio/llvm-custom-builds/releases/download/15.x/llvm-linux-amd64.tar.xz'
-            container: alpine:latest
             use_sccache: false
-            use_llvm: false
-            build_wasm: true
+            enable_llvm: true
+            enable_v8: false
+            enable_wasmi: true
+            enable_wamr: false
+            #- build: linux-musl-x64
+            #  os: ubuntu-22.04
+            #  artifact_name: 'wasmer-linux-musl-amd64'
+            #  container: alpine:latest
+            #  build_wasm: true
+            #  use_sccache: false
+            #  enable_llvm: false
+            #  enable_v8: true
+            #  enable_wasmi: true
+            #  enable_wamr: false
+
     container: ${{ matrix.container }}
     env:
       SCCACHE_AZURE_BLOB_CONTAINER: wasmerstoragesccacheblob
       SCCACHE_AZURE_CONNECTION_STRING: ${{ secrets.SCCACHE_AZURE_CONNECTION_STRING }}
       TARGET: ${{ matrix.target }}
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
       - name: Set up base deps on musl
-        if: matrix.build == 'linux-musl-x64'
-        run: ./scripts/alpine-linux-install-deps.sh
+        if: startsWith(matrix.build, 'linux-musl-x64')
+        run: |
+          apk add bash mold make curl cmake ninja clang18 zstd-static llvm18-dev clang18-static llvm18-static ncurses-static zlib-static libxml2-dev libxml2-static xz-dev xz-static xz-libs libc++-dev libc++-static
+          ln -s /usr/bin/clang-18 /usr/bin/clang
+      - name: Install Linux tools
+        if: startsWith(matrix.build, 'linux-x64')
+        run: |
+          sudo apt install mold ninja-build
+      - name: Install Linux ARM tools
+        if: startsWith(matrix.build, 'linux-arm64')
+        run: |
+          sudo apt install mold ninja-build cmake make libzstd1 zstd libzstd-dev
+      - name: Install `ninja` on macOS
+        if: startsWith(matrix.build, 'macos-')
+        shell: bash
+        run: |
+          brew install ninja gcc
+      - name: Install `ninja` on Windows
+        if: startsWith(matrix.build, 'windows-')
+        shell: bash
+        run: |
+          choco install ninja
+      - name: Delete unwanted link to stop it from interfering (Windows)
+        if: startsWith(matrix.build, 'windows-')
+        shell: bash
+        run: rm /usr/bin/link.exe
+      - name: Install standard header files on macOS
+        if: startsWith(matrix.build, 'macos-')
+        shell: bash
+        run: |
+          sudo xcode-select -s /Library/Developer/CommandLineTools
+          echo "CPATH=/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include" >> $GITHUB_ENV
+      - name: Install MSVC dev-cmd (Windows)
+        uses: ilammy/msvc-dev-cmd@v1
+        if: startsWith(matrix.build, 'windows-')
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ env.MSRV }}
           target: ${{ matrix.target }}
       - uses: Swatinem/rust-cache@v2
-        if: matrix.use_sccache != true
+        if: ${{ matrix.use_sccache != true && matrix.use_rustcache != false }}
       - name: Install LLVM (macOS Apple Silicon)
-        if: matrix.os == 'macos-12' && !matrix.llvm_url
+        if: matrix.os == 'macos-13' && !matrix.llvm_url
         run: |
           brew install llvm
       - name: Install LLVM
-        if: matrix.llvm_url
+        if: ${{ matrix.llvm_url && matrix.enable_llvm == true }}
         shell: bash
         run: |
           LLVM_DIR=$(pwd)/${{ env.LLVM_DIR }}
@@ -115,28 +181,32 @@ jobs:
           LLVM_DIR: .llvm
       - name: Configure LLVM (Windows)
         # The Custom Windows build does not contains llvm-config.exe, so need to setup manualy here
-        if: matrix.build == 'windows-x64' && matrix.llvm_url
+        if: startsWith(matrix.build, 'windows-x64') && matrix.llvm_url
         shell: bash
         run: |
           LLVM_DIR=$(pwd)/${{ env.LLVM_DIR }}
-          echo LLVM_SYS_150_PREFIX="${LLVM_DIR}" >> $GITHUB_ENV
+          echo LLVM_SYS_180_PREFIX="${LLVM_DIR}" >> $GITHUB_ENV
           echo LLVM_ENABLE=1 >> $GITHUB_ENV
         env:
           LLVM_DIR: .llvm
+      - name: Add `brew` libraries (Apple Silicon)
+        run: |
+          echo "RUSTFLAGS=-L/opt/homebrew/lib" >> $GITHUB_ENV
+        if: matrix.os == 'macos-14'
       - name: Set up dependencies for Mac OS
         run: |
           brew install automake
           # using gnu-tar is a workaround for https://github.com/actions/cache/issues/403
           brew install gnu-tar
           echo PATH="/usr/local/opt/gnu-tar/libexec/gnubin:$PATH" >> $GITHUB_ENV
-        if: matrix.os == 'macos-12'
-      - uses: actions/cache@v2
+        if: startsWith(matrix.os, 'macos')
+      - uses: actions/cache@v4
         with:
           path: |
             ~/.cargo/registry
             ~/.cargo/git
           key: ${{ matrix.build }}-${{ matrix.target }}-cargo-${{ hashFiles('Cargo.lock') }}-v1
-      - uses: actions/cache@v2
+      - uses: actions/cache@v4
         if: matrix.use_sccache
         with:
           path: ${{ runner.tool_cache }}/cargo-sccache
@@ -187,39 +257,62 @@ jobs:
       - name: Build C API headless
         shell: bash
         run: |
-          make package-capi-headless
+          LLVM_CONFIG_PATH=/usr/bin/llvm-config-18 make package-capi-headless
       - name: Build C API
         shell: bash
         run: |
-          make build-capi
-      - name: Build Wasmer binary with LLVM
-        if: matrix.use_llvm
+          LLVM_CONFIG_PATH=/usr/bin/llvm-config-18 make build-capi
+      - name: Build Wasmer binary
+        if: ${{ !startsWith(matrix.build, 'linux-x64') && !startsWith(matrix.build, 'linux-musl') }}
         shell: bash
         run: |
           make build-wasmer
         env:
-          ENABLE_LLVM: 1
-      - name: Build Wasmer binary without LLVM
-        if: matrix.use_llvm != true
-        shell: bash
-        run: |
-          make build-wasmer
-     #- name: Build Wasmer binary on Wasm32-WASI without LLVM
-     #  if: matrix.build_wasm
-     #  shell: bash
-     #  run: |
-     #    make build-wasmer-wasm
+          ENABLE_LLVM: ${{ matrix.enable_llvm }}
+          ENABLE_V8: ${{ matrix.enable_v8 }}
+          ENABLE_WASMI: ${{ matrix.enable_wasmi }}
+          ENABLE_WAMR: ${{ matrix.enable_wamr }}
+      - name: Build Wasmer on linux-x64
+        if: ${{ startsWith(matrix.build, 'linux-x64') }}
+        run: |
+          RUSTFLAGS="-C linker=clang -C link-arg=-fuse-ld=mold" make build-wasmer
+        env:
+          ENABLE_LLVM: ${{ matrix.enable_llvm }}
+          ENABLE_V8: ${{ matrix.enable_v8 }}
+          ENABLE_WASMI: ${{ matrix.enable_wasmi }}
+          ENABLE_WAMR: ${{ matrix.enable_wamr }}
+      - name: Build Wasmer on linux-musl
+        if: ${{ startsWith(matrix.build, 'linux-musl') }}
+        run: |
+          echo "#!/bin/bash" >> /usr/bin/llvm-config
+          echo 'if [ "$1" = "--libs" ]; then' >> /usr/bin/llvm-config
+          echo 'llvm-config-18 "$@" "--link-static"' >> /usr/bin/llvm-config
+          echo "else" >> /usr/bin/llvm-config
+          echo 'llvm-config-18 "$@"' >> /usr/bin/llvm-config
+          echo 'fi' >> /usr/bin/llvm-config
+          cat /usr/bin/llvm-config
+          chmod +x /usr/bin/llvm-config
+          LLVM_CONFIG_PATH=/usr/bin/llvm-config RUSTFLAGS="-L/usr/lib64 -L/usr/lib -C linker=clang -C link-arg=-fuse-ld=mold -lzstd" make build-wasmer
+        env:
+          ENABLE_LLVM: ${{ matrix.enable_llvm }}
+          ENABLE_V8: ${{ matrix.enable_v8 }}
+          ENABLE_WASMI: ${{ matrix.enable_wasmi }}
+          ENABLE_WAMR: ${{ matrix.enable_wamr }}
+      #- name: Build Wasmer binary on Wasm32-WASI without LLVM
+      #  if: matrix.build_wasm
+      #  shell: bash
+      #  run: |
+      #    make build-wasmer-wasm
       - name: Install Nightly Rust for Headless
-        if: matrix.build != 'linux-musl-x64'
+        if: ${{ !startsWith(matrix.build, 'linux-musl-x64') }}
         uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: "nightly-2023-10-05"
+          toolchain: "nightly-2024-11-07"
           target: ${{ matrix.target }}
           components: "rust-src"
       - name: Build Minimal Wasmer Headless
-        if: matrix.build != 'linux-musl-x64'
+        if: ${{ !startsWith(matrix.build, 'linux-musl-x64') }}
         run: |
-          cargo install xargo
           echo "" >> Cargo.toml
           echo "[profile.release]" >> Cargo.toml
           echo "opt-level = 'z'" >> Cargo.toml
@@ -231,14 +324,12 @@ jobs:
           echo "incremental = false" >> Cargo.toml
           echo "codegen-units = 1" >> Cargo.toml
           echo "rpath = false" >> Cargo.toml
-          rustup override set nightly-2023-10-05
           make build-wasmer-headless-minimal
-          rustup override unset
       - name: Dist
         run: |
           make distribution
       - name: Upload Artifacts
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: ${{ matrix.artifact_name }}
           path: dist
@@ -247,9 +338,10 @@ jobs:
 
   windows_gnu:
     name: Windows GNU
+    if: github.event_name != 'pull_request' || startsWith(github.head_ref, 'release-')
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
       - name: Install Windows-GNU linker
         shell: bash
         run: |
@@ -271,11 +363,12 @@ jobs:
           cargo build --release --manifest-path=/tmp/xwin/Cargo.toml
           /tmp/xwin/target/release/xwin --accept-license --cache-dir /tmp/xwincache splat --output /tmp/xwindownload
           mkdir -p /tmp/winsdk
-          cp /tmp/xwindownload/sdk/lib/10.0.20348/um/x86_64/WS2_32.lib /tmp/winsdk/
-          cp /tmp/xwindownload/sdk/lib/10.0.20348/um/x86_64/KERNEL32.lib /tmp/winsdk/
-          cp /tmp/xwindownload/sdk/lib/10.0.20348/um/x86_64/BCRYPT.lib /tmp/winsdk/
-          cp /tmp/xwindownload/sdk/lib/10.0.20348/um/x86_64/ADVAPI32.lib /tmp/winsdk/
-          cp /tmp/xwindownload/sdk/lib/10.0.20348/um/x86_64/USERENV.lib /tmp/winsdk/
+          SDK_VERSION=$(ls /tmp/xwindownload/sdk/lib | head -n 1)
+          cp /tmp/xwindownload/sdk/lib/$SDK_VERSION/um/x86_64/WS2_32.lib /tmp/winsdk/
+          cp /tmp/xwindownload/sdk/lib/$SDK_VERSION/um/x86_64/KERNEL32.lib /tmp/winsdk/
+          cp /tmp/xwindownload/sdk/lib/$SDK_VERSION/um/x86_64/BCRYPT.lib /tmp/winsdk/
+          cp /tmp/xwindownload/sdk/lib/$SDK_VERSION/um/x86_64/ADVAPI32.lib /tmp/winsdk/
+          cp /tmp/xwindownload/sdk/lib/$SDK_VERSION/um/x86_64/USERENV.lib /tmp/winsdk/
           echo "WinSDK files:"
           ls -laH /tmp/winsdk
           echo ""
@@ -305,18 +398,19 @@ jobs:
           CARGO_TARGET: x86_64-pc-windows-gnu
           TARGET_DIR: target/x86_64-pc-windows-gnu/release
       - name: Upload Artifacts
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: 'wasmer-windows-gnu64'
+          name: "wasmer-windows-gnu64"
           path: dist
           if-no-files-found: error
           retention-days: 2
 
   darwin_aarch64_jsc:
     name: macOS aarch64 (JSC)
-    runs-on: macos-12
+    if: github.event_name != 'pull_request' || startsWith(github.head_ref, 'release-')
+    runs-on: macos-13
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
       - uses: dtolnay/rust-toolchain@stable
         with:
           target: aarch64-apple-darwin
@@ -338,18 +432,19 @@ jobs:
           CARGO_TARGET: aarch64-apple-darwin
           TARGET_DIR: target/aarch64-apple-darwin/release
       - name: Upload Artifacts
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: 'aarch64-apple-darwin-jsc'
+          name: "aarch64-apple-darwin-jsc"
           path: dist
           if-no-files-found: error
           retention-days: 2
 
   darwin_x86_64_jsc:
     name: macOS x86_64 (JSC)
-    runs-on: macos-12
+    if: github.event_name != 'pull_request' || startsWith(github.head_ref, 'release-')
+    runs-on: macos-13
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
       - uses: dtolnay/rust-toolchain@stable
         with:
           target: x86_64-apple-darwin
@@ -367,83 +462,19 @@ jobs:
           CARGO_TARGET: x86_64-apple-darwin
           TARGET_DIR: target/x86_64-apple-darwin/release
       - name: Upload Artifacts
-        uses: actions/upload-artifact@v3
-        with:
-          name: 'x86_64-apple-darwin-jsc'
-          path: dist
-          if-no-files-found: error
-          retention-days: 2
-
-  linux_aarch64:
-    name: Linux aarch64
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          target: aarch64-unknown-linux-gnu
-      - name: Build cross image
-        run: |
-          docker build -t wasmer/aarch64 ${GITHUB_WORKSPACE}/.github/cross-linux-aarch64/
-        env:
-          CROSS_DOCKER_IN_DOCKER: true
-      - name: Build Wasmer binary
-        run: |
-          make build-wasmer
-        env:
-          CARGO_BINARY: docker run -v /var/run/docker.sock:/var/run/docker.sock -v ${GITHUB_WORKSPACE}:/project -w /project wasmer/aarch64 cross
-          CROSS_DOCKER_IN_DOCKER: true
-          CARGO_TARGET: aarch64-unknown-linux-gnu
-          PKG_CONFIG_PATH: /usr/lib/aarch64-linux-gnu/pkgconfig
-          PKG_CONFIG_ALLOW_CROSS: true
-          ENABLE_LLVM: 0
-      - name: Build C API headless
-        shell: bash
-        run: |
-          make package-capi-headless
-        env:
-          CARGO_BINARY: docker run -v /var/run/docker.sock:/var/run/docker.sock -v ${GITHUB_WORKSPACE}:/project -w /project wasmer/aarch64 cross
-          CROSS_DOCKER_IN_DOCKER: true
-          CARGO_TARGET: aarch64-unknown-linux-gnu
-          PKG_CONFIG_PATH: /usr/lib/aarch64-linux-gnu/pkgconfig
-          PKG_CONFIG_ALLOW_CROSS: true
-          ENABLE_LLVM: 0
-          TARGET: aarch64-unknown-linux-gnu
-          TARGET_DIR: target/aarch64-unknown-linux-gnu/release
-      - name: Build C API
-        run: |
-          make build-capi
-        env:
-          CARGO_BINARY: docker run -v /var/run/docker.sock:/var/run/docker.sock -v ${GITHUB_WORKSPACE}:/project -w /project wasmer/aarch64 cross
-          CROSS_DOCKER_IN_DOCKER: true
-          CARGO_TARGET: aarch64-unknown-linux-gnu
-          PKG_CONFIG_PATH: /usr/lib/aarch64-linux-gnu/pkgconfig
-          PKG_CONFIG_ALLOW_CROSS: true
-          ENABLE_LLVM: 0
-      - name: Dist
-        run: |
-          make distribution
-        env:
-          CARGO_BINARY: docker run -v /var/run/docker.sock:/var/run/docker.sock -v ${GITHUB_WORKSPACE}:/project -w /project wasmer/aarch64 cross
-          CROSS_DOCKER_IN_DOCKER: true
-          CARGO_TARGET: aarch64-unknown-linux-gnu
-          PKG_CONFIG_PATH: /usr/lib/aarch64-linux-gnu/pkgconfig
-          PKG_CONFIG_ALLOW_CROSS: true
-          TARGET: aarch64-unknown-linux-gnu
-          TARGET_DIR: target/aarch64-unknown-linux-gnu/release
-      - name: Upload Artifacts
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wasmer-linux-aarch64
+          name: "x86_64-apple-darwin-jsc"
           path: dist
           if-no-files-found: error
           retention-days: 2
 
   linux_riscv64:
     name: Linux riscv64
+    if: github.event_name != 'pull_request' || startsWith(github.head_ref, 'release-')
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
       - uses: dtolnay/rust-toolchain@stable
         with:
           target: riscv64gc-unknown-linux-gnu
@@ -497,7 +528,7 @@ jobs:
           TARGET: riscv64gc-unknown-linux-gnu
           TARGET_DIR: target/riscv64gc-unknown-linux-gnu/release
       - name: Upload Artifacts
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: wasmer-linux-riscv64
           path: dist
@@ -505,12 +536,12 @@ jobs:
           retention-days: 2
 
   release:
-    needs: [setup, build, linux_aarch64, windows_gnu, linux_riscv64]
+    needs: [setup, build, windows_gnu, linux_riscv64]
     runs-on: ubuntu-latest
-    if: needs.setup.outputs.DOING_RELEASE == '1' || github.event.inputs.release != ''
+    if: (needs.setup.outputs.DOING_RELEASE == '1' || github.event.inputs.release != '') && github.event_name != 'pull_request'
     steps:
       - name: Download the Artifacts
-        uses: actions/download-artifact@v2
+        uses: actions/download-artifact@v4
         with:
           path: artifacts
       - name: Create Release
@@ -577,16 +608,16 @@ jobs:
           asset_path: artifacts/wasmer-windows-gnu64/wasmer.tar.gz
           asset_name: wasmer-windows-gnu64.tar.gz
           asset_content_type: application/gzip
-      - name: Upload Release Asset Linux amd64 (musl)
-        id: upload-release-asset-linux-musl-amd64
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: artifacts/wasmer-linux-musl-amd64/wasmer.tar.gz
-          asset_name: wasmer-linux-musl-amd64.tar.gz
-          asset_content_type: application/gzip
+          #- name: Upload Release Asset Linux amd64 (musl)
+          #  id: upload-release-asset-linux-musl-amd64
+          #  uses: actions/upload-release-asset@v1
+          #  env:
+          #    GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          #  with:
+          #    upload_url: ${{ steps.create_release.outputs.upload_url }}
+          #    asset_path: artifacts/wasmer-linux-musl-amd64/wasmer.tar.gz
+          #    asset_name: wasmer-linux-musl-amd64.tar.gz
+          #    asset_content_type: application/gzip
       - name: Upload Release Asset Mac amd64
         uses: actions/upload-release-asset@v1
         env:
diff --git a/.github/workflows/cache-bucket-cleanup.yaml b/.github/workflows/cache-bucket-cleanup.yaml
index 03ae072afd..224a2a94b4 100644
--- a/.github/workflows/cache-bucket-cleanup.yaml
+++ b/.github/workflows/cache-bucket-cleanup.yaml
@@ -18,7 +18,7 @@ jobs:
       - name: Install boto3 library
         run: pip install boto3
       - name: Clone repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v5
       - name: Run cleanup
         env:
           AWS_ENDPOINT: https://1541b1e8a3fc6ad155ce67ef38899700.r2.cloudflarestorage.com
diff --git a/.github/workflows/check-public-api.yaml b/.github/workflows/check-public-api.yaml
index fc47e79c5e..06d421295c 100644
--- a/.github/workflows/check-public-api.yaml
+++ b/.github/workflows/check-public-api.yaml
@@ -18,7 +18,7 @@ jobs:
     steps:
       
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v5
         with:
           fetch-depth: 0
 
@@ -38,7 +38,7 @@ jobs:
           cargo public-api --manifest-path=lib/api/Cargo.toml --diff-git-checkouts $LATEST_VERSION main > diff.txt
       
       - name: Archive change report
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: api-diff-report
           path: |
diff --git a/.github/workflows/cifuzz.yaml b/.github/workflows/cifuzz.yaml
new file mode 100644
index 0000000000..ef1b9dfc38
--- /dev/null
+++ b/.github/workflows/cifuzz.yaml
@@ -0,0 +1,32 @@
+# 
+# [todo] xdoardo (2024/10/17): 
+#
+#  We updated our MSRV and llvm, so we need to open a pr here
+#  https://github.com/google/oss-fuzz/blob/fb88de8bd2d220662271aabbe19427dc24134bf6/projects/wasmer/build.sh
+#  before re-enabling this.
+#
+#
+# name: CIFuzz
+# on: [pull_request]
+# jobs:
+#  Fuzzing:
+#    runs-on: ubuntu-latest
+#    steps:
+#    - name: Build Fuzzers
+#      id: build
+#      uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
+#      with:
+#        oss-fuzz-project-name: 'wasmer'
+#        language: rust
+#    - name: Run Fuzzers
+#      uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
+#      with:
+#        oss-fuzz-project-name: 'wasmer'
+#        language: rust
+#        fuzz-seconds: 300
+#    - name: Upload Crash
+#      uses: actions/upload-artifact@v4
+#      if: failure() && steps.build.outcome == 'success'
+#      with:
+#        name: artifacts
+#        path: ./out/artifacts
diff --git a/.github/workflows/cloudcompiler.yaml b/.github/workflows/cloudcompiler.yaml
index 22ac4b1e7d..3ab284dd67 100644
--- a/.github/workflows/cloudcompiler.yaml
+++ b/.github/workflows/cloudcompiler.yaml
@@ -2,13 +2,13 @@ name: Release cloudcompiler.wasm
 
 env:
   RUST_BACKTRACE: 1
-  MSRV: "1.74"
+  MSRV: "1.84"
 
 on:
   push:
     tags:
       # trigger action on release branch
-      - '[0-9]+.[0-9]+.[0-9]+*'
+      - "[0-9]+.[0-9]+.[0-9]+*"
   workflow_dispatch:
 
 jobs:
@@ -16,7 +16,7 @@ jobs:
     name: Set up
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
         with:
           fetch-depth: 0
       - name: Install Rust
@@ -24,19 +24,19 @@ jobs:
         with:
           toolchain: ${{ env.MSRV }}
           target: ${{ matrix.target }}
-      - name: Install wasm32-wasi target
+      - name: Install wasm32-wasip1 target
         shell: bash
         run: |
-          rustup target add wasm32-wasi
+          rustup target add wasm32-wasip1
       - name: Setup Wasmer
         uses: wasmerio/setup-wasmer@v1
       - name: Build cloudcompiler.wasm
         shell: bash
         run: |
           make build-wasmer-wasm &&
-          mkdir target/wasm32-wasi/release/cloudcompiler
-          cp target/wasm32-wasi/release/wasmer-compiler.wasm target/wasm32-wasi/release/cloudcompiler/cloudcompiler.wasm &&
-          cat << EOF > target/wasm32-wasi/release/cloudcompiler/wasmer.toml
+          mkdir target/wasm32-wasip1/release/cloudcompiler
+          cp target/wasm32-wasip1/release/wasmer-compiler.wasm target/wasm32-wasip1/release/cloudcompiler/cloudcompiler.wasm &&
+          cat << EOF > target/wasm32-wasip1/release/cloudcompiler/wasmer.toml
           [package]
           name = "${{ secrets.WAPM_DEV_USERNAME }}/cloudcompiler"
           version = "0.1.0"
@@ -61,18 +61,18 @@ jobs:
           echo $(git tag | tail -n1) > ./version.txt
           v=$(git describe --tags --abbrev=0) && \
           echo "version = ${v}" &&
-          sed -i "s/version = \".*\"/version = \"${v}\"/g" target/wasm32-wasi/release/cloudcompiler/wasmer.toml \
+          sed -i "s/version = \".*\"/version = \"${v}\"/g" target/wasm32-wasip1/release/cloudcompiler/wasmer.toml \
       - name: Build cloudcompiler.wasm
         shell: bash
         run: |
           git tag &&
-          cat target/wasm32-wasi/release/cloudcompiler/wasmer.toml &&
+          cat target/wasm32-wasip1/release/cloudcompiler/wasmer.toml &&
           echo "ls" &&
-          ls target/wasm32-wasi/release/cloudcompiler
+          ls target/wasm32-wasip1/release/cloudcompiler
       - name: Publish to WAPM
         uses: wasmerio/wapm-publish@v1
         with:
           registry: https://registry.wapm.dev
-          directory: target/wasm32-wasi/release/cloudcompiler
+          directory: target/wasm32-wasip1/release/cloudcompiler
           username: ${{ secrets.WAPM_DEV_USERNAME }}
           password: ${{ secrets.WAPM_DEV_PASSWORD }}
diff --git a/.github/workflows/documentation.yaml b/.github/workflows/documentation.yaml
index 7a023a4f5c..6dc04948f3 100644
--- a/.github/workflows/documentation.yaml
+++ b/.github/workflows/documentation.yaml
@@ -3,19 +3,19 @@ name: Documentation
 on:
   push:
     branches:
-      - 'main'
+      - "main"
     paths:
-      - 'lib/**'
+      - "lib/**"
 
 env:
-  MSRV: "1.74"
+  MSRV: "1.84"
 
 jobs:
   documentation:
     name: Documentation
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
@@ -27,10 +27,10 @@ jobs:
           mkdir ${{ env.LLVM_DIR }}
           tar xf llvm.tar.xz --strip-components=1 -C ${{ env.LLVM_DIR }}
           echo "${{ env.LLVM_DIR }}/bin" >> $GITHUB_PATH
-          echo "LLVM_SYS_120_PREFIX=${{ env.LLVM_DIR }}" >> $GITHUB_ENV
+          echo "LLVM_SYS_180_PREFIX=${{ env.LLVM_DIR }}" >> $GITHUB_ENV
         env:
-          LLVM_DIR: ${{ github.workspace }}/llvm-13
-          LLVM_URL: 'https://github.com/llvm/llvm-project/releases/download/llvmorg-13.0.0/clang+llvm-13.0.0-x86_64-linux-gnu-ubuntu-16.04.tar.xz'
+          LLVM_DIR: ${{ github.workspace }}/llvm-18
+          LLVM_URL: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-linux-amd64.tar.xz"
       - name: Build & package documentation
         run: make package-docs
       - name: Publish documentation
diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml
index f39c8b8fbd..c75a37cce8 100644
--- a/.github/workflows/test.yaml
+++ b/.github/workflows/test.yaml
@@ -4,14 +4,14 @@ on:
   push:
     branches:
       - main
-      - 'with-ci-.*'
-      - 'v3.0.x'
-      - 'v3.1.x'
+      - "with-ci-.*"
+      - "v3.0.x"
+      - "v3.1.x"
   pull_request:
   workflow_dispatch:
     inputs:
       release:
-          description: 'Make release'
+        description: "Make release"
 
 # Automatically cancel previous workflow runs when a new commit is pushed.
 concurrency:
@@ -24,7 +24,7 @@ env:
   # Rust, but it's not stable on 1.69 yet. By explicitly setting the protocol we
   # can override that behaviour
   CARGO_REGISTRIES_CRATES_IO_PROTOCOL: git
-  MSRV: "1.74"
+  MSRV: "1.84"
   NEXTEST_PROFILE: "ci"
   RUSTUP_WINDOWS_PATH_ADD_BIN: 1
   WASI_SDK_VERSION: "22"
@@ -52,7 +52,7 @@ jobs:
     name: Code lint
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
@@ -64,11 +64,11 @@ jobs:
           sudo apt install -y libtinfo5
       - name: Install LLVM (Linux)
         run: |
-          curl --proto '=https' --tlsv1.2 -sSf https://github.com/llvm/llvm-project/releases/download/llvmorg-15.0.6/clang+llvm-15.0.6-x86_64-linux-gnu-ubuntu-18.04.tar.xz -L -o /opt/llvm.tar.xz
-          mkdir -p /opt/llvm-15
-          tar xf /opt/llvm.tar.xz --strip-components=1 -C /opt/llvm-15
-          echo '/opt/llvm-15/bin' >> $GITHUB_PATH
-          echo 'LLVM_SYS_150_PREFIX=/opt/llvm-15' >> $GITHUB_ENV
+          curl --proto '=https' --tlsv1.2 -sSf https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-linux-amd64.tar.xz -L -o /opt/llvm.tar.xz
+          mkdir -p /opt/llvm-18
+          tar xf /opt/llvm.tar.xz --strip-components=1 -C /opt/llvm-18
+          echo '/opt/llvm-18/bin' >> $GITHUB_PATH
+          echo 'LLVM_SYS_180_PREFIX=/opt/llvm-18' >> $GITHUB_ENV
       - name: Cache
         uses: whywaita/actions-cache-s3@v2
         with:
@@ -97,8 +97,8 @@ jobs:
     name: cargo-deny
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v3
-      - uses: EmbarkStudios/cargo-deny-action@v1
+      - uses: actions/checkout@v5
+      - uses: EmbarkStudios/cargo-deny-action@v2
         with:
           log-level: error
 
@@ -106,15 +106,15 @@ jobs:
     name: Test on NodeJS
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ env.MSRV }}
       - name: Install NodeJS
-        uses: actions/setup-node@v2
+        uses: actions/setup-node@v4
         with:
-          node-version: 16
+          node-version: 22
       - name: Install wasm-pack
         run: |
           curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
@@ -126,15 +126,27 @@ jobs:
     name: Test wasi-fyi
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: nightly
-          targets: "wasm32-wasi"
+          targets: "wasm32-wasip1"
       - name: Install wasm-pack
         run: |
           curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
+      - name: Install LLVM 18
+        run: |
+          curl --proto '=https' --tlsv1.2 -sSf https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-linux-amd64.tar.xz -L -o llvm.tar.xz
+          LLVM_DIR=$(pwd)/${{ env.LLVM_DIR }}
+          mkdir ${LLVM_DIR}
+          tar xf llvm.tar.xz --strip-components=1 -C ${LLVM_DIR}
+          echo "ENABLE_LLVM=1" >> $GITHUB_ENV
+          echo "${LLVM_DIR}/bin" >> $GITHUB_PATH
+          echo "${LLVM_DIR}/usr/bin" >> $GITHUB_PATH
+          echo "LLVM_SYS_180_PREFIX=${LLVM_DIR}" >> $GITHUB_ENV
+        env:
+          LLVM_DIR: .llvm
       - name: make test-wasi-fyi
         run: |
           make test-wasi-fyi
@@ -148,43 +160,75 @@ jobs:
     name: Test WASIX
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ env.MSRV }}
       - name: Install Tools
+        # note: llvm-19 for building wasix-libc, llvm-18 later for building wasmer
         run: |
           sudo apt-get update
-          sudo apt-get install -y git llvm clang make lld curl
-      - name: Build wasix sysroot
-        run: |
-          cd ~
-          git clone --recurse-submodules https://github.com/wasix-org/wasix-libc
-          cd wasix-libc
-          ./build32.sh
-          rm -rf /opt/wasix-sysroot
-          cp -r sysroot32 ~/wasix-sysroot
-      - name: Install wasi-sdk Tools
-        run: |
-          cd ~
-          curl -L "https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-${{ env.WASI_SDK_VERSION }}/wasi-sdk-${{ env.WASI_SDK_VERSION }}.0-linux.tar.gz" -o wasi-sdk.tar.gz
-          tar -xzf wasi-sdk.tar.gz
-          cp -r wasi-sdk-${{ env.WASI_SDK_VERSION }}.0 ~/wasi-sdk
-      - name: Install wasm-opt
-        run: |
-          sudo apt-get install -y binaryen
+          sudo apt-get install -y git make lld curl
+
+      - name: Download binaryen
+        uses: dsaltares/fetch-gh-release-asset@1.1.2
+        with:
+          repo: WebAssembly/binaryen
+          version: tags/version_123
+          file: binaryen-version_123-x86_64-linux.tar.gz
+          target: binaryen/binaryen.tar.gz
+
+      - name: Unpack binaryen
+        run: |
+          tar -xf binaryen/binaryen.tar.gz -C binaryen --strip-components=1
+          chmod +x binaryen/bin/*
+          export BINARYEN_DIR=$(pwd)/binaryen
+          echo "$BINARYEN_DIR/bin" >> $GITHUB_PATH
+
+      - name: Install wasixcc, sysroot and LLVM
+        run: |
+          export RUST_LOG=wasixcc=trace
+          export GITHUB_TOKEN=${{ secrets.GITHUB_TOKEN }}
+          rustup toolchain install 1.89 --profile minimal --no-self-update
+          cargo +1.89 install wasixcc -F bin
+          mkdir wasixcc-install
+          wasixcc --install-executables ./wasixcc-install
+          echo "$(pwd)/wasixcc-install" >> $GITHUB_PATH
+          mkdir -p ~/.wasixcc/llvm
+          mkdir -p ~/.wasixcc/sysroot
+          wasixcc --download-all
+
+      - name: Tool versions
+        run: |
+          echo "wasixcc version: $(wasixcc --version)"
+          echo "llvm version: $(wasixcc -- --version)"
+          echo "wasm-opt version: $(wasm-opt --version)"
+
+      - name: Install LLVM 18 (for building Wasmer)
+        run: |
+          curl --proto '=https' --tlsv1.2 -sSf https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-linux-amd64.tar.xz -L -o llvm.tar.xz
+          LLVM_DIR=$(pwd)/${{ env.LLVM_DIR }}
+          mkdir ${LLVM_DIR}
+          tar xf llvm.tar.xz --strip-components=1 -C ${LLVM_DIR}
+          echo "ENABLE_LLVM=1" >> $GITHUB_ENV
+          echo "${LLVM_DIR}/bin" >> $GITHUB_PATH
+          echo "${LLVM_DIR}/usr/bin" >> $GITHUB_PATH
+          echo "LLVM_SYS_180_PREFIX=${LLVM_DIR}" >> $GITHUB_ENV
+        env:
+          LLVM_DIR: .llvm
+
       - name: make test-wasix
         run: |
-          WASI_SDK=~/wasi-sdk WASIX_SYSROOT=~/wasix-sysroot make test-wasix
+          WASI_SDK=~/wasi-sdk WASIX_SYSROOT=$(pwd)/sysroot/wasix-sysroot/sysroot make test-wasix
 
   test_wasm_build:
     name: Test wasm build
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v3
-      - name: rustup target add wasm32-wasi
-        run: rustup target add wasm32-wasi
+      - uses: actions/checkout@v5
+      - name: rustup target add wasm32-wasip1
+        run: rustup target add wasm32-wasip1
       - name: make build-wasmer-wasm
         run: make build-wasmer-wasm
 
@@ -192,13 +236,13 @@ jobs:
     name: Test JSC build
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ env.MSRV }}
           target: x86_64-unknown-linux-gnu
       - name: Install NodeJS
-        uses: actions/setup-node@v2
+        uses: actions/setup-node@v4
         with:
           node-version: 16
       - name: Install libjavascriptcoregtk-4.0-dev
@@ -206,39 +250,146 @@ jobs:
       - name: make build-wasmer-jsc
         run: make build-wasmer-jsc
 
+  test_interpreter_api:
+    name: ${{ matrix.build-what.name }} on ${{ matrix.metadata.build }}
+    runs-on: ${{ matrix.metadata.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        build-what:
+          [
+            {
+              key: wamr,
+              build-cmd: "make test-wamr-api",
+              name: "Test API for wamr feature",
+            },
+            {
+              key: wasmi,
+              build-cmd: "make test-wasmi-api",
+              name: "Test API for wasmi feature",
+            },
+            {
+              key: v8,
+              build-cmd: "make test-v8-api",
+              name: "Test API for v8 feature",
+            },
+          ]
+        metadata: [
+            { build: linux-x64, os: ubuntu-22.04 },
+            { build: macos-arm, os: macos-14 },
+            #{
+            #  build: windows-x64,
+            #  os: windows-2022,
+            #}
+          ]
+    container: ${{ matrix.metadata.container }}
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Setup MSVC (Windows)
+        uses: ilammy/msvc-dev-cmd@v1
+        if: matrix.metadata.build == 'windows-x64'
+
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ env.MSRV }}
+
+      - name: Install Nextest
+        uses: taiki-e/install-action@nextest
+
+      - name: Install `ninja`, clang`, `binutils` and `mold` on Ubuntu
+        if: startsWith(matrix.metadata.build, 'linux-')
+        shell: bash
+        run: |
+          sudo apt-get update -y && sudo apt-get install ninja-build clang mold binutils -y
+
+      - name: Install `ninja` and (brew's) `llvm` on macOS
+        if: startsWith(matrix.metadata.build, 'macos-')
+        shell: bash
+        run: |
+          brew install ninja llvm@18
+          echo "/opt/homebrew/opt/llvm@18/bin" >> $GITHUB_PATH
+          ls -laR /opt/homebrew/opt/llvm@18/bin/
+
+      - name: Install `ninja` on Windows
+        if: startsWith(matrix.metadata.build, 'windows-')
+        shell: bash
+        run: |
+          choco install ninja
+
+      - name: Delete unwanted link to stop it from interfering (Windows)
+        shell: bash
+        run: rm /usr/bin/link.exe
+        if: startsWith(matrix.metadata.build, 'windows-')
+
+      - name: Test WAMR API
+        if: ${{ matrix.build-what.key == 'wamr' }}
+        run: echo $GITHUB_PATH && ${{ matrix.build-what.build-cmd }}
+
+      - name: Test wasmi API
+        if: ${{ matrix.build-what.key == 'wasmi' }}
+        run: ${{ matrix.build-what.build-cmd }}
+
+      - name: Test v8 API (Linux + clang)
+        if: ${{ matrix.build-what.key == 'v8' && startsWith(matrix.metadata.build, 'linux-')}}
+        run: RUSTFLAGS="-C linker=clang -C link-arg=-fuse-ld=lld" CARGO_TERM_VERBOSE=true ${{ matrix.build-what.build-cmd }}
+
+      - name: Test v8 API
+        if: ${{ matrix.build-what.key == 'v8' && !startsWith(matrix.metadata.build, 'linux-')}}
+        run: ${{ matrix.build-what.build-cmd }}
+
   test_build_docs_rs:
     name: Test build docs rs
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
       - uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: "nightly-2023-10-05"
+          toolchain: "nightly-2025-02-09"
           target: x86_64-unknown-linux-gnu
-      - run: cargo install toml-cli # toml-cli is required to run `make test-build-docs-rs`
+      - run: cargo install toml-cli --locked # toml-cli is required to run `make test-build-docs-rs`
+
+      - name: Install `ninja` on Ubuntu
+        shell: bash
+        run: |
+          sudo apt-get install ninja-build -y
+
+      - name: Install LLVM 18
+        run: |
+          curl --proto '=https' --tlsv1.2 -sSf https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-linux-amd64.tar.xz -L -o llvm.tar.xz
+          LLVM_DIR=$(pwd)/${{ env.LLVM_DIR }}
+          mkdir ${LLVM_DIR}
+          tar xf llvm.tar.xz --strip-components=1 -C ${LLVM_DIR}
+          echo "ENABLE_LLVM=1" >> $GITHUB_ENV
+          echo "${LLVM_DIR}/bin" >> $GITHUB_PATH
+          echo "${LLVM_DIR}/usr/bin" >> $GITHUB_PATH
+          echo "LLVM_SYS_180_PREFIX=${LLVM_DIR}" >> $GITHUB_ENV
+        env:
+          LLVM_DIR: .llvm
       - name: make test-build-docs-rs-ci
         run: make test-build-docs-rs-ci
 
   build_linux_aarch64:
     name: ${{ matrix.build-what.name }} on linux-aarch64
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-22.04-arm
     strategy:
       fail-fast: false
       matrix:
-        build-what: [
-          {
-            key: capi,
-            build-cmd: 'make build-capi && make package-capi',
-            name: 'Build C-API'
-          },
-          {
-            key: wasmer,
-            build-cmd: 'make build-wasmer && make package-wasmer && make tar-wasmer',
-            name: 'Build wasmer-cli'
-          }
-        ]
+        build-what:
+          [
+            {
+              key: capi,
+              build-cmd: "make build-capi && make package-capi",
+              name: "Build C-API",
+            },
+            {
+              key: wasmer,
+              build-cmd: "make build-wasmer && make package-wasmer && make tar-wasmer",
+              name: "Build wasmer-cli",
+            },
+          ]
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ env.MSRV }}
@@ -252,27 +403,27 @@ jobs:
         run: |
           ${{ matrix.build-what.build-cmd }}
         env:
-          CARGO_BINARY: docker run -v /var/run/docker.sock:/var/run/docker.sock -v ${GITHUB_WORKSPACE}:/project -w /project wasmer/aarch64 cross
-          CROSS_DOCKER_IN_DOCKER: true
+          # CARGO_BINARY: docker run -v /var/run/docker.sock:/var/run/docker.sock -v ${GITHUB_WORKSPACE}:/project -w /project wasmer/aarch64 cross
+          # CROSS_DOCKER_IN_DOCKER: true
           CARGO_TARGET: aarch64-unknown-linux-gnu
-          PKG_CONFIG_PATH: /usr/lib/aarch64-linux-gnu/pkgconfig
-          PKG_CONFIG_ALLOW_CROSS: true
+          #PKG_CONFIG_PATH: /usr/lib/aarch64-linux-gnu/pkgconfig
+          #PKG_CONFIG_ALLOW_CROSS: true
           ENABLE_LLVM: 0
       - name: Dist
         if: ${{ matrix.build-what.key == 'capi' }}
         run: |
           make distribution
         env:
-          CARGO_BINARY: docker run -v /var/run/docker.sock:/var/run/docker.sock -v ${GITHUB_WORKSPACE}:/project -w /project wasmer/aarch64 cross
-          CROSS_DOCKER_IN_DOCKER: true
+          #CARGO_BINARY: docker run -v /var/run/docker.sock:/var/run/docker.sock -v ${GITHUB_WORKSPACE}:/project -w /project wasmer/aarch64 cross
+          #CROSS_DOCKER_IN_DOCKER: true
           CARGO_TARGET: aarch64-unknown-linux-gnu
-          PKG_CONFIG_PATH: /usr/lib/aarch64-linux-gnu/pkgconfig
-          PKG_CONFIG_ALLOW_CROSS: true
+          #PKG_CONFIG_PATH: /usr/lib/aarch64-linux-gnu/pkgconfig
+          #PKG_CONFIG_ALLOW_CROSS: true
           TARGET: aarch64-unknown-linux-gnu
           TARGET_DIR: target/aarch64-unknown-linux-gnu/release
       - name: Upload Artifacts
         if: ${{ matrix.build-what.key == 'capi' }}
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: capi-linux-aarch64
           path: dist
@@ -285,20 +436,21 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        build-what: [
-          {
-            key: capi,
-            build-cmd: 'make build-capi && make package-capi',
-            name: 'Build C-API'
-          },
-          {
-            key: wasmer,
-            build-cmd: 'make build-wasmer && make package-wasmer && make tar-wasmer',
-            name: 'Build wasmer-cli'
-          }
-        ]
+        build-what:
+          [
+            {
+              key: capi,
+              build-cmd: "make build-capi && make package-capi",
+              name: "Build C-API",
+            },
+            {
+              key: wasmer,
+              build-cmd: "make build-wasmer && make package-wasmer && make tar-wasmer",
+              name: "Build wasmer-cli",
+            },
+          ]
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
       #- uses: dtolnay/rust-toolchain@stable
       #  with:
       #    toolchain: ${{ env.MSRV }}
@@ -330,7 +482,7 @@ jobs:
           TARGET_DIR: target/riscv64gc-unknown-linux-gnu/release
       - name: Upload Artifacts
         if: ${{ matrix.build-what.key == 'capi' }}
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: capi-linux-riscv64
           path: dist
@@ -344,60 +496,87 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        build-what: [
-          {
-            key: capi,
-            build-cmd: 'make build-capi && make build-capi-headless && make package-capi && make tar-capi',
-            name: 'Build and test C-API'
-          },
-          {
-            key: wasmer,
-            build-cmd: 'make build-wasmer && make package-wasmer && make tar-wasmer',
-            name: 'Build wasmer-cli'
-          }
-        ]
+        build-what:
+          [
+            {
+              key: capi,
+              build-cmd: "make build-capi && make build-capi-headless && make package-capi && make tar-capi",
+              name: "Build and test C-API",
+            },
+            {
+              key: capi-v8,
+              build-cmd: "make test-capi-v8",
+              name: "Build and test C-API with v8",
+            },
+            {
+              key: wasmer,
+              build-cmd: "make build-wasmer && make package-wasmer && make tar-wasmer",
+              name: "Build wasmer-cli",
+            },
+            {
+              key: "api-feats",
+              build-cmd: "make check-api-features",
+              name: "Check wasmer API with all sys features enabled",
+            },
+          ]
         metadata: [
-          {
-            build: linux-x64,
-            os: ubuntu-22.04,
-            target: x86_64-unknown-linux-gnu,
-            llvm_url: 'https://github.com/llvm/llvm-project/releases/download/llvmorg-15.0.6/clang+llvm-15.0.6-x86_64-linux-gnu-ubuntu-18.04.tar.xz'
-          },
-          {
-            build: linux-musl,
-            target: x86_64-unknown-linux-musl,
-            os: ubuntu-22.04,
-            container: 'alpine:latest'
-          },
-          {
-            build: macos-x64,
-            os: macos-12,
-            target: x86_64-apple-darwin,
-            llvm_url: 'https://github.com/llvm/llvm-project/releases/download/llvmorg-15.0.7/clang+llvm-15.0.7-x86_64-apple-darwin21.0.tar.xz'
-          },
-          {
-            build: macos-arm,
-            os: macos-12,
-            target: aarch64-apple-darwin,
-          },
-          {
-            build: windows-x64,
-            os: windows-2019,
-            target: x86_64-pc-windows-msvc,
-            llvm_url: 'https://github.com/wasmerio/llvm-custom-builds/releases/download/15.x/llvm-windows-amd64.tar.xz'
-          },
-          {
-            build: windows-gnu,
-            target: x86_64-pc-windows-gnu,
-            os: ubuntu-22.04,
-          }
-        ]
+            {
+              build: linux-x64,
+              os: ubuntu-22.04,
+              target: x86_64-unknown-linux-gnu,
+              exe: "",
+              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-linux-amd64.tar.xz",
+              # Unfortunately, building a shared lib of the c_api with the v8
+              # backend does not work, due to unsupported relocations to hidden
+              # symbols in wee8.
+              supports_v8: false,
+            },
+            {
+              build: macos-x64,
+              os: macos-13,
+              target: x86_64-apple-darwin,
+              exe: "",
+              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-darwin-amd64.tar.xz",
+              supports_v8: true,
+            },
+            {
+              build: macos-arm,
+              os: macos-14,
+              target: aarch64-apple-darwin,
+              exe: "",
+              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-darwin-aarch64.tar.xz",
+              supports_v8: true,
+            },
+            {
+              build: windows-x64,
+              os: windows-2022,
+              target: x86_64-pc-windows-msvc,
+              exe: ".exe",
+              # For now, disable LLVM in `windows-x64.`
+              # llvm_url: 'https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-windows-amd64.tar.xz'
+              supports_v8: false,
+            },
+            {
+              build: windows-gnu,
+              target: x86_64-pc-windows-gnu,
+              os: ubuntu-22.04,
+              supports_v8: false,
+            },
+            {
+              build: linux-musl,
+              target: x86_64-unknown-linux-musl,
+              os: ubuntu-22.04,
+              exe: "",
+              container: "alpine:latest",
+              supports_v8: false,
+            },
+          ]
     container: ${{ matrix.metadata.container }}
     env:
       SCCACHE_AZURE_BLOB_CONTAINER: wasmerstoragesccacheblob
       SCCACHE_AZURE_CONNECTION_STRING: ${{ secrets.SCCACHE_AZURE_CONNECTION_STRING }}
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
       - name: Set up libstdc++ on Linux
         if: matrix.metadata.build == 'linux-x64'
         run: |
@@ -406,14 +585,18 @@ jobs:
           sudo apt-get install --reinstall g++
       - name: Set up base deps on musl
         if: matrix.metadata.build == 'linux-musl'
-        run: ./scripts/alpine-linux-install-deps.sh
+        run: |
+          ./scripts/alpine-linux-install-deps.sh 
+          echo "ENABLE_LLVM=0" >> $GITHUB_ENV
+          echo "LLVM_CONFIG_PATH=/usr/bin/llvm-config-18" >> $GITHUB_ENV
+        # echo "RUSTFLAGS=-L/usr/lib64 -L/usr/lib" >> $GITHUB_ENV
       - name: Set up dependencies for Mac OS
         run: |
           brew install automake
           # using gnu-tar is a workaround for https://github.com/actions/cache/issues/403
           brew install gnu-tar
           echo PATH="/usr/local/opt/gnu-tar/libexec/gnubin:$PATH" >> $GITHUB_ENV
-        if: matrix.metadata.os == 'macos-12'
+        if: matrix.metadata.os == 'macos-13'
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
@@ -421,6 +604,13 @@ jobs:
           target: ${{ matrix.metadata.target }}
       - name: Install Nextest
         uses: taiki-e/install-action@nextest
+      - name: Install MSVC dev-cmd (Windows)
+        uses: ilammy/msvc-dev-cmd@v1
+        if: ${{ matrix.metadata.build == 'windows-x64' }}
+      - name: Delete unwanted link to stop it from interfering (Windows)
+        shell: bash
+        run: rm /usr/bin/link.exe
+        if: ${{ matrix.metadata.build == 'windows-x64' }}
       - name: Install Windows-GNU linker
         if: ${{ matrix.metadata.build == 'windows-gnu' }}
         shell: bash
@@ -442,11 +632,12 @@ jobs:
           cargo build --release --manifest-path=/tmp/xwin/Cargo.toml
           /tmp/xwin/target/release/xwin --accept-license --cache-dir /tmp/xwincache splat --output /tmp/xwindownload
           mkdir -p /tmp/winsdk
-          cp /tmp/xwindownload/sdk/lib/10.0.20348/um/x86_64/WS2_32.lib /tmp/winsdk/
-          cp /tmp/xwindownload/sdk/lib/10.0.20348/um/x86_64/KERNEL32.lib /tmp/winsdk/
-          cp /tmp/xwindownload/sdk/lib/10.0.20348/um/x86_64/BCRYPT.lib /tmp/winsdk/
-          cp /tmp/xwindownload/sdk/lib/10.0.20348/um/x86_64/ADVAPI32.lib /tmp/winsdk/
-          cp /tmp/xwindownload/sdk/lib/10.0.20348/um/x86_64/USERENV.lib /tmp/winsdk/
+          SDK_VERSION=$(ls /tmp/xwindownload/sdk/lib | head -n 1)
+          cp /tmp/xwindownload/sdk/lib/$SDK_VERSION/um/x86_64/WS2_32.lib /tmp/winsdk/
+          cp /tmp/xwindownload/sdk/lib/$SDK_VERSION/um/x86_64/KERNEL32.lib /tmp/winsdk/
+          cp /tmp/xwindownload/sdk/lib/$SDK_VERSION/um/x86_64/BCRYPT.lib /tmp/winsdk/
+          cp /tmp/xwindownload/sdk/lib/$SDK_VERSION/um/x86_64/ADVAPI32.lib /tmp/winsdk/
+          cp /tmp/xwindownload/sdk/lib/$SDK_VERSION/um/x86_64/USERENV.lib /tmp/winsdk/
           echo "WinSDK files:"
           ls -laH /tmp/winsdk
           echo ""
@@ -454,12 +645,12 @@ jobs:
           mkdir -p package/winsdk
           cp -r /tmp/winsdk/* package/winsdk
       - name: Install LLVM (macOS Apple Silicon)
-        if: matrix.metadata.os == 'macos-12' && !matrix.metadata.llvm_url
+        if: matrix.metadata.os == 'macos-13' && !matrix.metadata.llvm_url
         run: |
           brew install llvm
       - name: Install LLVM
-        if: matrix.metadata.llvm_url
         shell: bash
+        if: matrix.metadata.llvm_url
         run: |
           curl --proto '=https' --tlsv1.2 -sSf ${{ matrix.metadata.llvm_url }} -L -o llvm.tar.xz
           LLVM_DIR=$(pwd)/${{ env.LLVM_DIR }}
@@ -468,9 +659,15 @@ jobs:
           echo "ENABLE_LLVM=1" >> $GITHUB_ENV
           echo "${LLVM_DIR}/bin" >> $GITHUB_PATH
           echo "${LLVM_DIR}/usr/bin" >> $GITHUB_PATH
-          echo "LLVM_SYS_150_PREFIX=${LLVM_DIR}" >> $GITHUB_ENV
+          echo "LLVM_SYS_180_PREFIX=${LLVM_DIR}" >> $GITHUB_ENV
         env:
           LLVM_DIR: .llvm
+      - name: Add `brew` libs to `RUSTFLAGS`
+        if: matrix.metadata.os == 'macos-14'
+        shell: bash
+        run: |
+          echo "RUSTFLAGS=-L/opt/homebrew/lib" >> $GITHUB_ENV
+          echo "RUSTDOCFLAGS=-L/opt/homebrew/lib" >> $GITHUB_ENV
       - name: Setup Rust target
         shell: bash
         run: |
@@ -512,6 +709,10 @@ jobs:
           TARGET: ${{ matrix.metadata.target }}
           TARGET_DIR: target/${{ matrix.metadata.target }}/release
           CARGO_TARGET: ${{ matrix.metadata.target }}
+      - name: Test C-API (v8)
+        shell: bash
+        run: ${{ matrix.build-what.build-cmd }}
+        if: ${{ matrix.build-what.key == 'capi-v8' && matrix.metadata.supports_v8 == true  }}
       - name: Build Wasmer
         shell: bash
         if: ${{ matrix.build-what.key == 'wasmer' && matrix.metadata.build != 'windows-gnu' }}
@@ -520,9 +721,13 @@ jobs:
           TARGET: ${{ matrix.metadata.target }}
           TARGET_DIR: target/${{ matrix.metadata.target }}/release
           CARGO_TARGET: ${{ matrix.metadata.target }}
+      - name: Check `wasmer` crate with all the `sys` features enabled
+        shell: bash
+        if: ${{ matrix.build-what.key == 'api-feats' && matrix.metadata.build != 'windows-gnu' }}
+        run: ${{ matrix.build-what.build-cmd }}
       - name: Test C-API
         shell: bash
-        if: ${{ matrix.build-what.key == 'capi' && !(matrix.metadata.build == 'linux-musl' || matrix.metadata.build == 'macos-arm' || matrix.metadata.build == 'windows-gnu') }}
+        if: ${{ matrix.build-what.key == 'capi' && !(matrix.metadata.build == 'linux-musl'  || matrix.metadata.build == 'windows-gnu') }}
         run: make test-capi-ci
         env:
           TARGET: ${{ matrix.metadata.target }}
@@ -531,21 +736,21 @@ jobs:
       # C-API tests were disabled for linux-musl and macos-arm (we can't run them)
       - name: Test C-API integration
         shell: bash
-        if: ${{ matrix.build-what.key == 'capi' && !(matrix.metadata.build == 'linux-musl' || matrix.metadata.build == 'macos-arm' || matrix.metadata.build == 'windows-gnu') }}
+        if: ${{ matrix.build-what.key == 'capi' && !(matrix.metadata.build == 'linux-musl' || matrix.metadata.build == 'windows-gnu') }}
         run: export WASMER_DIR=`pwd`/package && make test-stage-7-capi-integration-tests
         env:
           TARGET: ${{ matrix.metadata.target }}
           TARGET_DIR: target/${{ matrix.metadata.target }}/release
           CARGO_TARGET: ${{ matrix.metadata.target }}
       - name: Archive production artifacts
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: wasmer-cli-${{ matrix.metadata.build }}
           path: build-wasmer.tar.gz
           if-no-files-found: ignore
           retention-days: 2
       - name: Archive production artifacts
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: capi-${{ matrix.metadata.build }}
           path: build-capi.tar.gz
@@ -559,75 +764,77 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        stage: [
-          {
-            description: 'Run wast test suite for all compilers',
-            make: 'test-stage-0-wast',
-          },
-          {
-            description: 'Unit-test packages on std',
-            make: 'test-stage-1-test-all',
-          },
-          {
-            description: 'Unit-test cranelift on no-std',
-            make: 'test-stage-2-test-compiler-cranelift-nostd',
-          },
-          {
-            description: 'Unit-test singlepass on no-std',
-            make: 'test-stage-3-test-compiler-singlepass-nostd',
-          },
-          {
-            description: 'Unit-test wasmer-cli',
-            make: 'test-stage-4-wasmer-cli',
-          },
-          {
-            description: 'Unit-test examples',
-            make: 'test-stage-5-test-examples',
-          }
-        ]
+        stage:
+          [
+            {
+              description: "Run wast test suite for all compilers",
+              make: "test-stage-0-wast",
+            },
+            {
+              description: "Unit-test packages on std",
+              make: "test-stage-1-test-all",
+            },
+            {
+              description: "Unit-test cranelift on no-std",
+              make: "test-stage-2-test-compiler-cranelift-nostd",
+            },
+            {
+              description: "Unit-test singlepass on no-std",
+              make: "test-stage-3-test-compiler-singlepass-nostd",
+            },
+            {
+              description: "Unit-test wasmer-cli",
+              make: "test-stage-4-wasmer-cli",
+            },
+            {
+              description: "Unit-test examples",
+              make: "test-stage-5-test-examples",
+            },
+          ]
         metadata: [
-          # We cannot test on macos-arm since we don't have ARM runners
-          {
-            build: linux-x64,
-            os: ubuntu-22.04,
-            target: x86_64-unknown-linux-gnu,
-            exe: '',
-            llvm_url: 'https://github.com/llvm/llvm-project/releases/download/llvmorg-15.0.6/clang+llvm-15.0.6-x86_64-linux-gnu-ubuntu-18.04.tar.xz'
-          },
-          {
-            build: macos-x64,
-            os: macos-12,
-            target: x86_64-apple-darwin,
-            exe: '',
-            llvm_url: 'https://github.com/llvm/llvm-project/releases/download/llvmorg-15.0.7/clang+llvm-15.0.7-x86_64-apple-darwin21.0.tar.xz'
-          },
-          {
-            build: macos-arm64,
-            os: macos-14,
-            target: aarch64-apple-darwin,
-            exe: '',
-          },
-          {
-            build: windows-x64,
-            os: windows-2019,
-            target: x86_64-pc-windows-msvc,
-            exe: '.exe',
-            llvm_url: 'https://github.com/wasmerio/llvm-custom-builds/releases/download/15.x/llvm-windows-amd64.tar.xz'
-          },
-          {
-            build: linux-musl,
-            target: x86_64-unknown-linux-musl,
-            os: ubuntu-22.04,
-            exe: '',
-            container: 'alpine:latest'
-          }
-        ]
+            {
+              build: linux-x64,
+              os: ubuntu-22.04,
+              target: x86_64-unknown-linux-gnu,
+              exe: "",
+              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-linux-amd64.tar.xz",
+            },
+            {
+              build: macos-x64,
+              os: macos-13,
+              target: x86_64-apple-darwin,
+              exe: "",
+              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-darwin-amd64.tar.xz",
+            },
+            {
+              build: macos-arm,
+              os: macos-14,
+              target: aarch64-apple-darwin,
+              exe: "",
+              llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-darwin-aarch64.tar.xz",
+            },
+            {
+              build: windows-x64,
+              os: windows-2022,
+              target: x86_64-pc-windows-msvc,
+              exe: ".exe",
+              # For now, disable LLVM in `windows-x64.`
+              # llvm_url: 'https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-windows-amd64.tar.xz'
+            },
+            {
+              build: linux-musl,
+              target: x86_64-unknown-linux-musl,
+              os: ubuntu-22.04,
+              exe: "",
+              container: "alpine:latest",
+            },
+          ]
     container: ${{ matrix.metadata.container }}
     env:
       SCCACHE_AZURE_BLOB_CONTAINER: wasmerstoragesccacheblob
       SCCACHE_AZURE_CONNECTION_STRING: ${{ secrets.SCCACHE_AZURE_CONNECTION_STRING }}
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
       - name: Set up libstdc++ on Linux
         if: matrix.metadata.build == 'linux-x64'
         run: |
@@ -636,14 +843,26 @@ jobs:
           sudo apt-get install --reinstall g++
       - name: Set up base deps on musl
         if: matrix.metadata.build == 'linux-musl'
-        run: ./scripts/alpine-linux-install-deps.sh
+        run: |
+          ./scripts/alpine-linux-install-deps.sh
+          echo "ENABLE_LLVM=0" >> $GITHUB_ENV
+          echo "LLVM_CONFIG_PATH=/usr/bin/llvm-config-18" >> $GITHUB_ENV
+        # echo "RUSTFLAGS=-L/usr/lib64 -L/usr/lib" >> $GITHUB_ENV
+      - name: Install MSVC dev-cmd (Windows)
+        uses: ilammy/msvc-dev-cmd@v1
+        if: ${{ matrix.metadata.build == 'windows-x64' }}
+      - name: Delete unwanted link to stop it from interfering (Windows)
+        shell: bash
+        run: rm /usr/bin/link.exe
+        if: ${{ matrix.metadata.build == 'windows-x64' }}
+
       - name: Set up dependencies for Mac OS
         run: |
           brew install automake
           # using gnu-tar is a workaround for https://github.com/actions/cache/issues/403
-          brew install gnu-tar
+          brew install gnu-tar zstd
           echo PATH="/usr/local/opt/gnu-tar/libexec/gnubin:$PATH" >> $GITHUB_ENV
-        if: matrix.metadata.os == 'macos-12'
+        if: matrix.metadata.os == 'macos-13'
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
@@ -652,21 +871,30 @@ jobs:
       - name: Install Nextest
         uses: taiki-e/install-action@nextest
       - name: Install LLVM (macOS Apple Silicon)
-        if: matrix.metadata.os == 'macos-12' && !matrix.metadata.llvm_url
+        if: matrix.metadata.os == 'macos-13' && !matrix.metadata.llvm_url
         run: |
           brew install llvm
+          echo "/opt/homebrew/opt/llvm/bin" >> GITHUB_PATH
       - name: Install LLVM
-        if: matrix.metadata.llvm_url
         shell: bash
+        if: matrix.metadata.llvm_url
         run: |
           curl --proto '=https' --tlsv1.2 -sSf ${{ matrix.metadata.llvm_url }} -L -o llvm.tar.xz
           LLVM_DIR=$(pwd)/${{ env.LLVM_DIR }}
           mkdir ${LLVM_DIR}
           tar xf llvm.tar.xz --strip-components=1 -C ${LLVM_DIR}
           echo "${LLVM_DIR}/bin" >> $GITHUB_PATH
-          echo "LLVM_SYS_120_PREFIX=${LLVM_DIR}" >> $GITHUB_ENV
+          echo "${LLVM_DIR}/usr/bin" >> $GITHUB_PATH
+          echo "LLVM_SYS_180_PREFIX=${LLVM_DIR}" >> $GITHUB_ENV
+          echo "ENABLE_LLVM=1" >> $GITHUB_ENV
         env:
           LLVM_DIR: .llvm
+      - name: Add `brew` libs to `RUSTFLAGS`
+        if: matrix.metadata.os == 'macos-14'
+        shell: bash
+        run: |
+          echo "RUSTFLAGS=-L/opt/homebrew/lib" >> $GITHUB_ENV
+          echo "RUSTDOCFLAGS=-L/opt/homebrew/lib" >> $GITHUB_ENV
       - name: Setup Rust target
         shell: bash
         run: |
@@ -691,6 +919,7 @@ jobs:
           aws-s3-bucket-endpoint: false
           aws-s3-force-path-style: true
       - name: ${{ matrix.stage.description }}
+        shell: bash
         run: make ${{ matrix.stage.make }}
         env:
           TARGET: ${{ matrix.metadata.target }}
@@ -708,42 +937,48 @@ jobs:
           - build: linux-x64
             os: ubuntu-22.04
             target: x86_64-unknown-linux-gnu
-            llvm_url: 'https://github.com/llvm/llvm-project/releases/download/llvmorg-15.0.6/clang+llvm-15.0.6-x86_64-linux-gnu-ubuntu-18.04.tar.xz'
+            llvm_url: "https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-linux-amd64.tar.xz"
           - build: macos-x64
-            os: macos-12
+            os: macos-13
             target: x86_64-apple-darwin
-            llvm_url: 'https://github.com/llvm/llvm-project/releases/download/llvmorg-15.0.7/clang+llvm-15.0.7-x86_64-apple-darwin21.0.tar.xz'
           # we only build the integration-test CLI, we don't run tests
           - build: macos-arm
-            os: macos-12
+            os: macos-14
             target: aarch64-apple-darwin,
           - build: linux-musl
             target: x86_64-unknown-linux-musl
             os: ubuntu-22.04
             container: alpine:latest
           - build: windows-x64
-            os: windows-2019
+            os: windows-latest
             target: x86_64-pc-windows-msvc
+            # For now, disable LLVM in `windows-x64.`
+            # llvm_url: 'https://github.com/wasmerio/llvm-custom-builds/releases/download/18.x/llvm-windows-amd64.tar.xz'
+
     container: ${{ matrix.container }}
     env:
       SCCACHE_AZURE_BLOB_CONTAINER: wasmerstoragesccacheblob
       SCCACHE_AZURE_CONNECTION_STRING: ${{ secrets.SCCACHE_AZURE_CONNECTION_STRING }}
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
       - uses: goto-bus-stop/setup-zig@v2
         with:
           version: 0.10.0
       - name: Set up base deps on musl
         if: matrix.build == 'linux-musl'
-        run: ./scripts/alpine-linux-install-deps.sh
-      - uses: actions/download-artifact@v3
+        run: |
+          ./scripts/alpine-linux-install-deps.sh
+          echo "ENABLE_LLVM=0" >> $GITHUB_ENV
+          echo "LLVM_CONFIG_PATH=/usr/bin/llvm-config-18" >> $GITHUB_ENV
+        # echo "RUSTFLAGS=-L/usr/lib64 -L/usr/lib" >> $GITHUB_ENV
+      - uses: actions/download-artifact@v4
         id: download
         with:
           name: capi-${{ matrix.build }}
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
           name: wasmer-cli-${{ matrix.build }}
-      - name: 'Echo download path'
+      - name: "Echo download path"
         run: echo ${{steps.download.outputs.download-path}}
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
@@ -771,27 +1006,27 @@ jobs:
         run: |
           mkdir -p package
           mkdir -p package/cache
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
           name: capi-linux-aarch64
           path: package/cache/wasmercache1
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
-          name: capi-windows-gnu
+          name: capi-windows-x64
           path: package/cache/wasmercache2
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
           name: capi-macos-arm
           path: package/cache/wasmercache3
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
           name: capi-macos-x64
           path: package/cache/wasmercache4
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
           name: capi-linux-x64
           path: package/cache/wasmercache5
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
           name: capi-linux-riscv64
           path: package/cache/wasmercache6
@@ -809,27 +1044,27 @@ jobs:
           cp package/cache/wasmercache4/build-capi.tar.gz package/cache/wasmer-darwin-amd64.tar.gz
           cp package/cache/wasmercache5/build-capi.tar.gz package/cache/wasmer-linux-amd64.tar.gz
           cp package/cache/wasmercache6/wasmer.tar.gz package/cache/wasmer-linux-riscv64.tar.gz
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         if: ${{ matrix.build == 'windows-x64' }}
         with:
-          name: capi-windows-gnu
+          name: capi-windows-x64
           path: download_link
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         if: ${{ matrix.build == 'linux-musl' }}
         with:
           name: capi-linux-musl
           path: download_link
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         if: ${{ matrix.build == 'macos-arm' }}
         with:
           name: capi-macos-arm
           path: download_link
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         if: ${{ matrix.build == 'macos-x64' }}
         with:
           name: capi-macos-x64
           path: download_link
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         if: ${{ matrix.build == 'linux-x64' }}
         with:
           name: capi-linux-x64
@@ -846,75 +1081,58 @@ jobs:
         shell: bash
         run: |
           make untar-wasmer
-      - name: Test integration CLI
-        if: false # matrix.build != 'macos-arm'
-        shell: bash
-        run: |
-          export WASMER_PATH=`pwd`/target/${{ matrix.target }}/release/wasmer${{ matrix.exe }}
-          export WASMER_DIR=`pwd`/package && make test-integration-cli-ci
-        env:
-          TARGET: ${{ matrix.target }}
-          TARGET_DIR: target/${{ matrix.target }}/release
-          CARGO_TARGET: ${{ matrix.target }}
-          WAPM_DEV_TOKEN: ${{ secrets.WAPM_DEV_TOKEN }}
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-  # there is another set of integration tests in 'wasmer-integration-tests' repo. Run those
+          # Removed in favour of freestanding integration tests
+          #
+          # - name: Test integration CLI
+          #   if: false # matrix.build != 'macos-arm'
+          #   shell: bash
+          #   run: |
+          #     export WASMER_PATH=`pwd`/target/${{ matrix.target }}/release/wasmer${{ matrix.exe }}
+          #     export WASMER_DIR=`pwd`/package && make test-integration-cli-ci
+          #   env:
+          #     TARGET: ${{ matrix.target }}
+          #     TARGET_DIR: target/${{ matrix.target }}/release
+          #     CARGO_TARGET: ${{ matrix.target }}
+          #     WAPM_DEV_TOKEN: ${{ secrets.WAPM_DEV_TOKEN }}
+          #     GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+
+          # ---- 
+          # Note (xdoardo on 2024/10/07): 
+          # --- 
+          #  As of now the WAMR, WASMI (and V8) backends are not that mature enough. We will re-enable these tests 
+          #  when they've been used and matured. 
+          # ---- 
+          #
+          # - name: Test CLI integration (WAMR) 
+          #   shell: bash
+          #   run: |
+          #     export WASMER_PATH=`pwd`/target/${{ matrix.target }}/release/wasmer${{ matrix.exe }}
+          #     export WASMER_DIR=`pwd`/package && make test-integration-cli-wamr-ci
+          #   env:
+          #     TARGET: ${{ matrix.target }}
+          #     TARGET_DIR: target/${{ matrix.target }}/release
+          #     CARGO_TARGET: ${{ matrix.target }}
+          #     WAPM_DEV_TOKEN: ${{ secrets.WAPM_DEV_TOKEN }}
+          #     GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+          # - name: Test CLI integration (WASMI) 
+          #   shell: bash
+          #   run: |
+          #     export WASMER_PATH=`pwd`/target/${{ matrix.target }}/release/wasmer${{ matrix.exe }}
+          #     export WASMER_DIR=`pwd`/package && make test-integration-cli-wasmi-ci
+          #   env:
+          #     TARGET: ${{ matrix.target }}
+          #     TARGET_DIR: target/${{ matrix.target }}/release
+          #     CARGO_TARGET: ${{ matrix.target }}
+          #     WAPM_DEV_TOKEN: ${{ secrets.WAPM_DEV_TOKEN }}
+          #     GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
   test-wasmer-integration-tests:
     needs: [build]
-    runs-on: ubuntu-22.04
-    steps:
-    - name: Checkout wasmer-integration-tests repository
-      uses: actions/checkout@v3
-      with:
-        repository: wasmerio/wasmer-integration-tests
-        submodules: true
-        token: ${{ secrets.CLONE_WASMER_INTEGRATION_TESTS }}
-    - uses: actions/download-artifact@v3
-      with:
-        name: wasmer-cli-linux-x64 
-    - name: Cargo Registry Cache
-      uses: actions/cache@v3
-      with:
-        path: |
-          ~/.cargo/advisory-db
-          ~/.cargo/git
-          ~/.cargo/registry
-        key: cargo-registry-${{ hashFiles('**/Cargo.lock') }}
-    - name: Cargo target cache
-      uses: actions/cache@v3
-      with:
-        path: |
-          target/
-        key: cargo-release-${{ hashFiles('**/Cargo.lock') }}
-    - run: |
-        # install rust toolchain
-        curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
-        . "$HOME/.cargo/env"
-
-        # add wasmer cli to PATH
-        tar -xzf build-wasmer.tar.gz
-
-        docker build -t tmp .
-        docker run -v $PWD:/app -w /app tmp bash -c " \
-          cp ./bin/wasmer /root/.wasmer/bin/wasmer &&\
-          export MYSQL_HOST='${{ vars.INTEGRATION_TEST_MYSQL_HOST }}' &&\
-          export MYSQL_DBNAME='${{ vars.INTEGRATION_TEST_MYSQL_DBNAME }}' &&\
-          export MYSQL_USERNAME='${{ secrets.INTEGRATION_TEST_MYSQL_USERNAME }}' &&\
-          export MYSQL_PASSWORD='${{ secrets.INTEGRATION_TEST_MYSQL_PASSWORD }}' &&\
-          export MYSQL_PORT='${{ vars.INTEGRATION_TEST_MYSQL_PORT }}' &&\
-          export MYSQL_CERT='${{ secrets.INTEGRATION_TEST_MYSQL_CERT }}' &&\
-          export PG_HOST='${{ vars.INTEGRATION_TEST_PG_HOST }}' &&\
-          export PG_DBNAME='${{ vars.INTEGRATION_TEST_PG_DBNAME }}' &&\
-          export PG_USERNAME='${{ secrets.INTEGRATION_TEST_PG_USERNAME }}' &&\
-          export PG_PASSWORD='${{ secrets.INTEGRATION_TEST_PG_PASSWORD }}' &&\
-          export PG_PORT='${{ vars.INTEGRATION_TEST_PG_PORT }}' &&\
-          wasmer config set registry.url https://registry.wasmer.io/graphql &&\
-          wasmer login '${{ secrets.WAPM_PROD_TOKEN }}' &&\
-          wasmer config set registry.url https://registry.wasmer.wtf/graphql &&\
-          wasmer login '${{ secrets.WAPM_DEV_TOKEN }}' &&\
-          cargo test --no-fail-fast"      
-    - name: notify failure in slack
-      if: failure()
-      run: |
-        curl -X POST -H 'Content-type: application/json' --data '{"text":"Integration tests failed ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}"}' ${{ secrets.INTEGRATION_TEST_SLACK_WEBHOOK }}
+    uses: wasmerio/wasmer-integration-tests/.github/workflows/integration-test-workflow.yaml@main
+    with:
+      fetch_artifact: "wasmer-cli-linux-x64"
+    secrets:
+      token: ${{ secrets.WAPM_DEV_TOKEN }}
diff --git a/.github/workflows/wasmer-config.yaml b/.github/workflows/wasmer-config.yaml
index 9091574b1e..6ace3c11a8 100644
--- a/.github/workflows/wasmer-config.yaml
+++ b/.github/workflows/wasmer-config.yaml
@@ -20,7 +20,7 @@ jobs:
     name: Compile and Test
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v5
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
       - name: Setup Rust
@@ -41,11 +41,14 @@ jobs:
     name: Linting and Formatting
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v5
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
       - name: Setup Rust
         uses: dsherret/rust-toolchain-file@v1
+      - name: Ensure rustfmt and clippy are installed
+        run: |
+          rustup component add rustfmt clippy
       - name: Check Formatting
         run: |
           cd lib/config && cargo fmt --verbose --check
diff --git a/.github/workflows/wasmer-integration-tests.yaml b/.github/workflows/wasmer-integration-tests.yaml
deleted file mode 100644
index 8a079aed71..0000000000
--- a/.github/workflows/wasmer-integration-tests.yaml
+++ /dev/null
@@ -1,51 +0,0 @@
-name: test-sys
-
-on:
-  push:
-    branches:
-      - sre-383-re-enable-ignored-integration-test-test_php_extensions
-
-jobs:
-  # there is another set of integration tests in 'wasmer-integration-tests' repo. Run those
-  test-wasmer-integration-tests:
-    runs-on: ubuntu-22.04
-    steps:
-    - name: Checkout wasmer-integration-tests repository
-      uses: actions/checkout@v3
-      with:
-        repository: wasmerio/wasmer-integration-tests
-        submodules: true
-        token: ${{ secrets.CLONE_WASMER_INTEGRATION_TESTS }}
-    - name: Cargo Registry Cache
-      uses: actions/cache@v3
-      with:
-        path: |
-          ~/.cargo/advisory-db
-          ~/.cargo/git
-          ~/.cargo/registry
-        key: cargo-registry-${{ hashFiles('**/Cargo.lock') }}
-    - name: Cargo target cache
-      uses: actions/cache@v3
-      with:
-        path: |
-          target/
-        key: cargo-release-${{ hashFiles('**/Cargo.lock') }}
-    - run: |
-        docker build -t tmp .
-        docker run -v $PWD:/app -w /app tmp bash -c " \
-          export MYSQL_HOST='${{ vars.INTEGRATION_TEST_MYSQL_HOST }}' &&\
-          export MYSQL_DBNAME='${{ vars.INTEGRATION_TEST_MYSQL_DBNAME }}' &&\
-          export MYSQL_USERNAME='${{ secrets.INTEGRATION_TEST_MYSQL_USERNAME }}' &&\
-          export MYSQL_PASSWORD='${{ secrets.INTEGRATION_TEST_MYSQL_PASSWORD }}' &&\
-          export MYSQL_PORT='${{ vars.INTEGRATION_TEST_MYSQL_PORT }}' &&\
-          export MYSQL_CERT='${{ secrets.INTEGRATION_TEST_MYSQL_CERT }}' &&\
-          export PG_HOST='${{ vars.INTEGRATION_TEST_PG_HOST }}' &&\
-          export PG_DBNAME='${{ vars.INTEGRATION_TEST_PG_DBNAME }}' &&\
-          export PG_USERNAME='${{ secrets.INTEGRATION_TEST_PG_USERNAME }}' &&\
-          export PG_PASSWORD='${{ secrets.INTEGRATION_TEST_PG_PASSWORD }}' &&\
-          export PG_PORT='${{ vars.INTEGRATION_TEST_PG_PORT }}' &&\
-          wasmer config set registry.url https://registry.wasmer.io/graphql &&\
-          wasmer login ${{ secrets.WAPM_PROD_TOKEN }} &&\
-          wasmer config set registry.url https://registry.wasmer.wtf/graphql &&\
-          wasmer login ${{ secrets.WAPM_DEV_TOKEN }} &&\
-          cargo test --no-fail-fast"
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 9e6499be8a..f6deb5be7f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -29,3 +29,6 @@ lcov.info
 link/
 link.tar.gz
 .vscode
+# Ignore files used by the "direnv" tool.
+.direnv
+.envrc
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ae9d57a866..b8685b3211 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,9 +6,589 @@
 
 Looking for changes that affect our C API? See the [C API Changelog](lib/c-api/CHANGELOG.md).
 
-
 ## **Unreleased**
 
+## 6.1.0 - 08/10/2025
+
+This release adds:
+
+* The dynamic linker which, paired with [wasixcc](https://github.com/wasix-org/wasixcc),
+  can load DL modules at runtime
+* New WASIX syscalls for reflection, dynamic function invocation and closure creation;
+  this makes WASIX compatible with libffi
+* Better support for the Exception Handling proposal in the LLVM backend
+* The `--build-remote` flag for `wasmer deploy`, which lets you build packages in the
+  cloud rather than locally
+* And many more stability fixes and improvements.
+
+## Added
+
+  - [#5763](https://github.com/wasmerio/wasmer/pull/5763) chore(lib/vm): update `corosensei` to `0.3.0` to support AddressSanitizer
+  - [#5783](https://github.com/wasmerio/wasmer/pull/5783) chore(cli): package unpack command: add shortform -u
+  - [#5773](https://github.com/wasmerio/wasmer/pull/5773) feat(cli): Add loading spinner when compiling modules in TTY
+  - [#5775](https://github.com/wasmerio/wasmer/pull/5775) Add `/dev/shm` to the root filesystem
+
+## Changed
+
+  - [#5784](https://github.com/wasmerio/wasmer/pull/5784) Use wasmerignore for bundling and gitignore for remote builds
+  - [#5774](https://github.com/wasmerio/wasmer/pull/5774) SDK cleanup
+  - [#5770](https://github.com/wasmerio/wasmer/pull/5770) Make table methods don’t fail in the browser
+  - [#5776](https://github.com/wasmerio/wasmer/pull/5776) chore(cli): Provide fallback login instructions in login command
+  - [#5769](https://github.com/wasmerio/wasmer/pull/5769) Promote async-trait to a workspace dependency
+  - [#5743](https://github.com/wasmerio/wasmer/pull/5743) CLI: wasmer deploy --build-remote
+  - [#5526](https://github.com/wasmerio/wasmer/pull/5526) feat(wasix): Improve module loading performance and API correctness
+
+## Fixed
+
+  - [#5789](https://github.com/wasmerio/wasmer/pull/5789) fix(cli): Improve behaviour for deployments without wasmer.toml
+  - [#5761](https://github.com/wasmerio/wasmer/pull/5761) Fix deadlocks in Selector
+  - [#5780](https://github.com/wasmerio/wasmer/pull/5780) Fix/eh nested catch ref
+  - [#5779](https://github.com/wasmerio/wasmer/pull/5779) Linker: fix dlsym'ing functions from the main modules when there are …
+  - [#5757](https://github.com/wasmerio/wasmer/pull/5757) Fix order of arguments when spawning processes from WASI
+  - [#5756](https://github.com/wasmerio/wasmer/pull/5756) Fix stalling issue when using shared libraries
+  - [#5745](https://github.com/wasmerio/wasmer/pull/5745) fix(wasix): Linker must re-use the same Engine
+  - [#5752](https://github.com/wasmerio/wasmer/pull/5752) LLVM: Fix compilation breaking for modules with function names that have sp…
+
+## 6.1.0-rc.5 - 16/09/2025
+This release includes better support for the Exception Handling proposal in LLVM,
+as well as fixes to the linker and other stability fixes.
+
+## Added
+
+## Changed
+
+  - [#5724](https://github.com/wasmerio/wasmer/pull/5724) Singlepass: simplify dynamic regs usage
+  - [#5715](https://github.com/wasmerio/wasmer/pull/5715) feat(cli): App-specific SSH sessions
+  - [#5707](https://github.com/wasmerio/wasmer/pull/5707) compiler: Ensure unique function symbols by appending function index
+  - [#5703](https://github.com/wasmerio/wasmer/pull/5703) Simplify unwind
+  - [#5741](https://github.com/wasmerio/wasmer/pull/5741) Replace serde_yml with serde_yaml
+
+## Fixed
+
+  - [#5726](https://github.com/wasmerio/wasmer/pull/5726) Multiple fixes to EH codegen
+  - [#5736](https://github.com/wasmerio/wasmer/pull/5736) LLVM codegen: truncate stack to correct size when leaving a WASM block
+  - [#5701](https://github.com/wasmerio/wasmer/pull/5701) fix(config): Add missing skip_serializing_if for ssh capability
+  - [#5716](https://github.com/wasmerio/wasmer/pull/5716) Fix impossible relocation error in emit srem64, urem64 for singlepass compiler/Aarch64
+  - [#5700](https://github.com/wasmerio/wasmer/pull/5700) fix(DynamicFunction): allocate space for trap on host stack
+  - [#5706](https://github.com/wasmerio/wasmer/pull/5706) Fix caching dlsym results in the linker
+  - [#5699](https://github.com/wasmerio/wasmer/pull/5699) Fix synchronizing load of multiple modules with internal table space and GOT.func entries
+
+
+
+## 6.1.0-rc.3 - 20/08/2025
+This release introduces a new reflection syscall for WASIX, RUNTIME_PATH support for
+dynamically-loaded modules, as well as many fixes and improvements across the board.
+
+## Added
+
+  - [#5695](https://github.com/wasmerio/wasmer/pull/5695) Implement RUNTIME_PATH support in the linker
+  - [#5653](https://github.com/wasmerio/wasmer/pull/5653) Implement a reflection API in WASIX
+  - [#5697](https://github.com/wasmerio/wasmer/pull/5697) Add WASIX DL tests
+  - [#5689](https://github.com/wasmerio/wasmer/pull/5689) feat(config): Add CapabilitySshServerV1 to app config
+  - [#5618](https://github.com/wasmerio/wasmer/pull/5618) Add ModuleCache::contains() + make compilation opts hashable
+
+## Changed
+
+  - [#5634](https://github.com/wasmerio/wasmer/pull/5634) Improve thread error handling
+  - [#5679](https://github.com/wasmerio/wasmer/pull/5679) Call __wasm_apply_tls_relocs during first load of each module
+  - [#5693](https://github.com/wasmerio/wasmer/pull/5693) chore(ci): upgrade checkout to v5
+  - [#5673](https://github.com/wasmerio/wasmer/pull/5673) Enable the "all" feature for socket2.
+  - [#5515](https://github.com/wasmerio/wasmer/pull/5515) docs: remove consecutive duplicate words
+  - [#5629](https://github.com/wasmerio/wasmer/pull/5629) Make bundling webcs fail if there are major errors
+
+## Fixed
+
+  - [#5677](https://github.com/wasmerio/wasmer/pull/5677) Fix deadlock when loading shared libraries
+  - [#5670](https://github.com/wasmerio/wasmer/pull/5670) Fix segfault on unterminated eh_frame by validating the frame before passing it to `__register_function`.
+  - [#5690](https://github.com/wasmerio/wasmer/pull/5690) fix(lib/vm): vendor `compiler-builtins` to fix undefined symbol `__rust_probestack`
+  - [#5669](https://github.com/wasmerio/wasmer/pull/5669) Fix WASIX networking w.r.t. aiohttp
+  - [#5655](https://github.com/wasmerio/wasmer/pull/5655) Shamelessly fix multiple things in one PR
+  - [#5652](https://github.com/wasmerio/wasmer/pull/5652) fix(lib/api): make `Memory::new_from_existing(...)` compatible with wasmer 5.0
+  - [#5646](https://github.com/wasmerio/wasmer/pull/5646) fix: fix wat gating
+  - [#5635](https://github.com/wasmerio/wasmer/pull/5635) fix(wasix): make wasmer/wat & wasmer/js-serializable-module optional features
+
+
+
+## 6.1.0-rc.2 - 16/07/2025
+This is the first release of the linker, adding support for dynamic linking in WASIX.
+The linker, paired with [wasixcc](https://github.com/wasix-org/wasixcc), can load DL modules
+at runtime.
+
+This release also includes other updates to WASIX, as well as stability and performance
+improvements across the board.
+
+## Added
+
+  - [#5598](https://github.com/wasmerio/wasmer/pull/5598) Add syscalls required to support libffi
+  - [#5581](https://github.com/wasmerio/wasmer/pull/5581) Dynamic linking with support for threads
+  - [#5578](https://github.com/wasmerio/wasmer/pull/5578) feat(cranelift): Add num_threads setting for Cranelift
+  - [#5500](https://github.com/wasmerio/wasmer/pull/5500) docs: added a new tag badge
+  - [#5561](https://github.com/wasmerio/wasmer/pull/5561) Add support for proper time in virtual-fs when targeting js
+  - [#5617](https://github.com/wasmerio/wasmer/pull/5617) Implement Memory::size function
+  - [#5600](https://github.com/wasmerio/wasmer/pull/5600) Implement MSG_PEEK and MSG_DONTWAIT functionality for send*/recv* syscalls
+  - [#5586](https://github.com/wasmerio/wasmer/pull/5586) V8 full exceptions support
+
+## Changed
+
+  - [#5636](https://github.com/wasmerio/wasmer/pull/5636) Implement strict mode switch in call_dynamic
+  - [#5628](https://github.com/wasmerio/wasmer/pull/5628) Improve help messages for auth commands
+  - [#5621](https://github.com/wasmerio/wasmer/pull/5621) feat: support sys-minimal feature
+  - [#5615](https://github.com/wasmerio/wasmer/pull/5615) The cli binary should use correct target triple when compiling a wasm module
+  - [#5570](https://github.com/wasmerio/wasmer/pull/5570) Return 1 second past epoch even when an explicit zero timestamp exist…
+  - [#5607](https://github.com/wasmerio/wasmer/pull/5607) Make error messages for missing shared libraries more helpful
+  - [#5590](https://github.com/wasmerio/wasmer/pull/5590) chore(deps): Upgrade some dependencies
+  - [#5589](https://github.com/wasmerio/wasmer/pull/5589) Change intrinsics::transmute to mem::transmute
+  - [#5583](https://github.com/wasmerio/wasmer/pull/5583) feat(wasix): Extend BuiltinPackageLoader with cache scanning and purging
+  - [#5572](https://github.com/wasmerio/wasmer/pull/5572) Update C API examples link in README to current documentation
+  - [#5564](https://github.com/wasmerio/wasmer/pull/5564) build: Make `ureq` optional (build) dependency
+  - [#5566](https://github.com/wasmerio/wasmer/pull/5566) Always preserve preopened FDs when doing proc_spawn2 + warn when dup2…
+
+## Fixed
+
+  - [#5620](https://github.com/wasmerio/wasmer/pull/5620) Fix missing dependency in `wasmer-package` for `wasm` targets
+  - [#5616](https://github.com/wasmerio/wasmer/pull/5616) Fix threads breaking when dlsym is called before thread spawn
+  - [#5569](https://github.com/wasmerio/wasmer/pull/5569) Fix a couple of webc FS issues
+  - [#5585](https://github.com/wasmerio/wasmer/pull/5585) fix(lib/vm): update `corosensei` to `0.2.2` to fix UB on Windows
+  - [#5568](https://github.com/wasmerio/wasmer/pull/5568) Fix the WASIX FS failing to union with a WEBC's volumes when running …
+
+
+
+## 6.0.1 - 09/05/2025
+This patch release fixes an error in cached memory operations in LLVM, adds CLI
+commands to list databases tied to an app, and provides miscellaneous QoL
+improvements to LLVM and updates. It also fixes the build of Wasmer for
+linux-aarch64.
+
+## Added
+
+  - [#5546](https://github.com/wasmerio/wasmer/pull/5546) feat(llvm): Add `asm_memory_buffer` to `LLVMCallbacks`
+  - [#5548](https://github.com/wasmerio/wasmer/pull/5548) feat(llvm): Add the `debug_str` intrinsic function
+  - [#5538](https://github.com/wasmerio/wasmer/pull/5538) feat(cli): Add "app database list" command
+
+## Changed
+
+  - [#5553](https://github.com/wasmerio/wasmer/pull/5553) feat(singlepass): Update dynasm to 3.2.0
+
+## Fixed
+
+  - [#5556](https://github.com/wasmerio/wasmer/pull/5556) ci: fix build of Wasmer on linux-aarch64
+  - [#5555](https://github.com/wasmerio/wasmer/pull/5555) Fix docs build
+  - [#5554](https://github.com/wasmerio/wasmer/pull/5554) fix(api): Misc fixes to compile with v8 when targeting aarch64-linux-android
+  - [#5549](https://github.com/wasmerio/wasmer/pull/5549) fix(llvm): Correctly cache pointers to intrinsic memory operations
+
+
+
+## 6.0.0 - 24/04/2025
+
+This stable release adds support for the exception handling proposal on Linux
+and Darwin platforms when using LLVM, adds a new LLVM-specific optimization
+(`--enable-pass-params-opt`), allows for multiple heterogeneous backends to be
+embedded in the same Wasmer build (`--llvm`, `--cranelift`, `--singlepass`,
+`--v8`, `--wamr`, `--wasmi`), adds support for process spawning without
+asyncify via full support for posix_spawn in wasix-libc with the new
+proc_spawn2 syscall, a number of QoL improvements to CLI commands and WASIX and
+much more. 
+
+## Added
+
+  - [#5524](https://github.com/wasmerio/wasmer/pull/5524) feat(llvm): Add ability to select how many threads LLVM should use during compilation.
+  - [#5531](https://github.com/wasmerio/wasmer/pull/5531) feat: Add Features::extend()
+  - [#5504](https://github.com/wasmerio/wasmer/pull/5504) feat: Add support for `perfmap`-based profiler data generation
+  - [#5518](https://github.com/wasmerio/wasmer/pull/5518) feat: Add `SuggestedCompilerOptimization` type(s) to automatically infer when to enable g0m0 optimization
+  - [#5514](https://github.com/wasmerio/wasmer/pull/5514) Added support for tags in JS
+  - [#5485](https://github.com/wasmerio/wasmer/pull/5485) docs: added a shield and a link to twitter
+
+## Changed
+
+  - [#5532](https://github.com/wasmerio/wasmer/pull/5532) chore(compiler): Print only the `deterministic_id()` of the engine in `Debug` impl
+  - [#5528](https://github.com/wasmerio/wasmer/pull/5528) Update pre-release crate versions automatically
+  - [#5498](https://github.com/wasmerio/wasmer/pull/5498) Simplify object initialization path with relocations
+  - [#5503](https://github.com/wasmerio/wasmer/pull/5503) feat(llvm): Pass global #0 and memory #0 as parameters between guest functions
+  - [#5517](https://github.com/wasmerio/wasmer/pull/5517) Updated singlepass and llvm compilers to use newer license
+  - [#5513](https://github.com/wasmerio/wasmer/pull/5513) chore: Bump `crossbeam-channel`
+  - [#5501](https://github.com/wasmerio/wasmer/pull/5501) Report one v2 and one v3 package when mixed packages are encountered …
+  - [#5497](https://github.com/wasmerio/wasmer/pull/5497) Reject mixed webc v2 and v3 in the same dependency tree
+  - [#5488](https://github.com/wasmerio/wasmer/pull/5488) Make sure api crate builds without compiler's translator & compiler features
+  - [#5484](https://github.com/wasmerio/wasmer/pull/5484) Make snapshot triggers strongly typed in the app schema
+  - [#5482](https://github.com/wasmerio/wasmer/pull/5482) deps: Update to zip 2.4.x
+  - [#5483](https://github.com/wasmerio/wasmer/pull/5483) Let cronjobs be triggered on a timer
+  - [#5443](https://github.com/wasmerio/wasmer/pull/5443) Enable multiple backends supported by the api crate to be used in the c-api as well
+  - [#5469](https://github.com/wasmerio/wasmer/pull/5469) Use engine-specific default features
+
+## Fixed
+
+  - [#5523](https://github.com/wasmerio/wasmer/pull/5523) fix(types): Bump `CURRENT_VERSION`
+  - [#5525](https://github.com/wasmerio/wasmer/pull/5525) fix(wamr): Wamr zip folder not found
+  - [#5522](https://github.com/wasmerio/wasmer/pull/5522) fix(jsc): Export engine as `JSC`
+  - [#5512](https://github.com/wasmerio/wasmer/pull/5512) fix(create-exe): Misc fixes to make `create-exe` work on aarch64 targeting Mach-O object files
+  - [#5519](https://github.com/wasmerio/wasmer/pull/5519) fix: Allow `BUSL-1.1` license in `deny.toml`
+  - [#5506](https://github.com/wasmerio/wasmer/pull/5506) fix(compiler): Preserve original alignment of custom sections
+  - [#5505](https://github.com/wasmerio/wasmer/pull/5505) Wasmer-JS fixes
+  - [#5507](https://github.com/wasmerio/wasmer/pull/5507) Fix experimental attribute and support keyword in tests, update example comment
+  - [#5502](https://github.com/wasmerio/wasmer/pull/5502) fix(compiler-test-derive): Don't use "Universal" as engine name/feature
+  - [#5491](https://github.com/wasmerio/wasmer/pull/5491) fix(cli): Respect active backend in "wasmer ssh" command
+  - [#5489](https://github.com/wasmerio/wasmer/pull/5489) fix: Metadata symbol size calculation in create-exe command
+  - [#5487](https://github.com/wasmerio/wasmer/pull/5487) docs: fixed broken link
+  - [#5449](https://github.com/wasmerio/wasmer/pull/5449) fix(api): Check if `WasmSliceAccess` ptr is aligned before reading
+  - [#5468](https://github.com/wasmerio/wasmer/pull/5468) Journal fixes to enable PHP+proc_snapshot
+  - [#5470](https://github.com/wasmerio/wasmer/pull/5470) fix(swift): Don't use default features in `wasix`, use the `sys` feature only
+  - [#5471](https://github.com/wasmerio/wasmer/pull/5471) fix: Explicitly allow "paste - no longer maintained" advisory in `cargo-deny`
+  - [#5467](https://github.com/wasmerio/wasmer/pull/5467) fix(journal): Use `sys-default` feature from `wasmer`
+  - [#5466](https://github.com/wasmerio/wasmer/pull/5466) Fix feature flags to build packages when publishing crates
+
+
+
+## 6.0.0-beta.1 - 07/03/2025
+
+This first beta release fixes a bug in `virtual-fs` together with other fixes
+to WASIX, adds various functions to check the features of a WebAssembly module
+given its bytes, adds a mechanism to the CLI to automatically switch to a
+suitable engine when needed, such as running a module with exception handling
+without specifying `--llvm` and, finally, also adds QoL improvements to the
+`package unpack` command in the CLI.
+
+## Added
+
+  - [#5448](https://github.com/wasmerio/wasmer/pull/5448) Add tests for exec*p and posix_spawnp
+  - [#5439](https://github.com/wasmerio/wasmer/pull/5439) feat: Add `check-api-features` Makefile target
+  - [#5433](https://github.com/wasmerio/wasmer/pull/5433) fix(api): Add missing loupe::MemoryUsage impls
+
+## Changed
+
+  - [#5451](https://github.com/wasmerio/wasmer/pull/5451) Select engine based on WASM module feature requirements
+  - [#5458](https://github.com/wasmerio/wasmer/pull/5458) Select engine based on WASM module feature requirements (v2)
+  - [#5455](https://github.com/wasmerio/wasmer/pull/5455) Engine selection improved
+  - [#5454](https://github.com/wasmerio/wasmer/pull/5454) CLI: package unpack command improvements
+  - [#5415](https://github.com/wasmerio/wasmer/pull/5415) chore(wasix): Avoid redundant hashing when spawning commands
+  - [#5440](https://github.com/wasmerio/wasmer/pull/5440) Remove `unwrap` in code that instantiates a WASI module
+
+## Fixed
+
+  - [#5461](https://github.com/wasmerio/wasmer/pull/5461) fix: Bump `ring` to `0.17.12`
+  - [#5460](https://github.com/wasmerio/wasmer/pull/5460) fix(c-api): Adjust `wasix` features in the import in `wasmer-c-api`
+  - [#5452](https://github.com/wasmerio/wasmer/pull/5452) Fix CI
+  - [#5436](https://github.com/wasmerio/wasmer/pull/5436) Fix interacting with socket pairs through `send` and `recv`
+  - [#5438](https://github.com/wasmerio/wasmer/pull/5438) chore(wasix): Fix compilation warning when host-fs not enabled
+  - [#5446](https://github.com/wasmerio/wasmer/pull/5446) fix(virtual-fs): OverlayFs: don't copy files that are never written
+  - [#5435](https://github.com/wasmerio/wasmer/pull/5435) Fix polling duplex pipes
+
+
+
+## 6.0.0-alpha.2 - 25/02/2025
+
+This second alpha release notably fixes an out-of-bound memory access when
+using LLVM on aarch64. Furthermore, it adds proper support for the
+`posix_spawn` function without a need for asyncify.
+
+## Added
+
+  - [#5426](https://github.com/wasmerio/wasmer/pull/5426) Add proper posix_spawn support without needing asyncify
+
+## Changed
+
+  - [#5425](https://github.com/wasmerio/wasmer/pull/5425) chore: Update build docs
+  - [#5418](https://github.com/wasmerio/wasmer/pull/5418) chore: Bump `webc` version to `8.0.0`
+  - [#5408](https://github.com/wasmerio/wasmer/pull/5408) Updated registry token on integration test workflow
+  - [#5414](https://github.com/wasmerio/wasmer/pull/5414) LLVM: Use `Default` and `Static` code model and reloc mode when targeting Mach-O
+  - [#5409](https://github.com/wasmerio/wasmer/pull/5409) Properly close vfork FDs if exec is not called, report subprocess traps
+
+## Fixed
+
+  - [#5420](https://github.com/wasmerio/wasmer/pull/5420) Fix manually inserting an FD at the first free index in FdList
+  - [#5419](https://github.com/wasmerio/wasmer/pull/5419) fix(singlepass): Don't panic on `funcref` types
+  - [#5410](https://github.com/wasmerio/wasmer/pull/5410) fix(ci): bump cache@v2 to cache@v3, temporarily disable test.yaml
+
+
+
+## 6.0.0-alpha.1 - 18/02/2025
+
+This alpha release adds support for multiple heterogeneous backends to be
+enabled at the same time. For example, the `llvm`,  `v8` and `wamr` backends
+can be enabled in a single binary release. Furthermore, this release adds
+initial support for the exception handling proposal on linux-x64, linux-aarch64
+and macOS through LLVM. This release also contains improvements to process
+spawning in WASIX.
+
+## Added
+
+  - [#5396](https://github.com/wasmerio/wasmer/pull/5396) CI: Disable V8 for linux-aarch64, bump ubuntu version for linux-x64 and add search paths for linux-musl
+  - [#5347](https://github.com/wasmerio/wasmer/pull/5347) Add support for exceptions in LLVM
+  - [#5374](https://github.com/wasmerio/wasmer/pull/5374) Add VirtualFile::copy_from_owned_buffer, fixes running mounted comman…
+  - [#5312](https://github.com/wasmerio/wasmer/pull/5312) Forward reuse_port and reuse_addr when it's possible to
+  - [#5370](https://github.com/wasmerio/wasmer/pull/5370) utils: prompts: add prompt_for_app_ident
+  - [#5369](https://github.com/wasmerio/wasmer/pull/5369) fix(ci): Add `RUSTDOCFLAGS` env var to add brew's libs
+  - [#5365](https://github.com/wasmerio/wasmer/pull/5365) Add .wasmerignore
+
+## Changed
+
+  - [#5402](https://github.com/wasmerio/wasmer/pull/5402) Update integration tests
+  - [#5395](https://github.com/wasmerio/wasmer/pull/5395) examples: funcref: memory_grow: resolve warnings
+  - [#5391](https://github.com/wasmerio/wasmer/pull/5391) chore: Prepare build scripts for release
+  - [#5386](https://github.com/wasmerio/wasmer/pull/5386) Rework WASIX pipes to be simplex, implement proper closing semantics, implement SIGPIPE
+  - [#5383](https://github.com/wasmerio/wasmer/pull/5383) Merge wasmer-5.1.0
+  - [#5384](https://github.com/wasmerio/wasmer/pull/5384) Implement CLOEXEC and related syscalls
+  - [#5379](https://github.com/wasmerio/wasmer/pull/5379) Allow memory growing to exactly 65536 pages, as per the specification
+  - [#5367](https://github.com/wasmerio/wasmer/pull/5367) Also put commands from webc dependencies in /usr/bin
+  - [#5368](https://github.com/wasmerio/wasmer/pull/5368) make: cli-compiler: resolve build-doc errors
+  - [#5366](https://github.com/wasmerio/wasmer/pull/5366) Reduce memory usage when loading webc packages by ensuring binaries m…
+  - [#5364](https://github.com/wasmerio/wasmer/pull/5364) Follow up to #5363
+  - [#5360](https://github.com/wasmerio/wasmer/pull/5360) chore: inline format args to improve readability
+  - [#5362](https://github.com/wasmerio/wasmer/pull/5362) chore: inline format args to improve readability (3)
+  - [#5361](https://github.com/wasmerio/wasmer/pull/5361) chore: inline format args to improve readability (2)
+  - [#5355](https://github.com/wasmerio/wasmer/pull/5355) chore: remove lazy_static dependency, use std instead
+  - [#5352](https://github.com/wasmerio/wasmer/pull/5352) Rework cron expression parsing to use saffron
+  - [#5350](https://github.com/wasmerio/wasmer/pull/5350) Rework the action field in the Job yaml schema
+  - [#5284](https://github.com/wasmerio/wasmer/pull/5284) Take into account requirements for "isolate" or single-threaded runtimes
+  - [#5348](https://github.com/wasmerio/wasmer/pull/5348) Merge main into 5.1.0
+  - [#5346](https://github.com/wasmerio/wasmer/pull/5346) Implement the WASIX proc_snapshot syscall
+  - [#5334](https://github.com/wasmerio/wasmer/pull/5334) Implement app.yaml job schema
+  - [#5323](https://github.com/wasmerio/wasmer/pull/5323) Close host files when the last FD referencing them is closed
+  - [#5333](https://github.com/wasmerio/wasmer/pull/5333) build: Make build dependency on `zip` and `xz` optional
+  - [#5331](https://github.com/wasmerio/wasmer/pull/5331) Make memory access functions in WasiEnv public
+  - [#5327](https://github.com/wasmerio/wasmer/pull/5327) Make try_memory public
+
+## Fixed
+
+  - [#5406](https://github.com/wasmerio/wasmer/pull/5406) fix: Use the "Keep a changelog" spec for the changelog
+  - [#5401](https://github.com/wasmerio/wasmer/pull/5401) Fix returning from a failed exec + fix vfork
+  - [#5397](https://github.com/wasmerio/wasmer/pull/5397) fix: have wasmer-wasix (lib/wasix) compile with `cargo build`
+  - [#5400](https://github.com/wasmerio/wasmer/pull/5400) Fix build script
+  - [#5399](https://github.com/wasmerio/wasmer/pull/5399) fix(ci): use custom llvm build on linux-aarch64
+  - [#5398](https://github.com/wasmerio/wasmer/pull/5398) fix(ci): Use official ubuntu-arm64 runners and install libxml2 on musl-x64
+  - [#5393](https://github.com/wasmerio/wasmer/pull/5393) fix(make): Check whether `ENABLE_x` variables are `1` or `true`
+  - [#5392](https://github.com/wasmerio/wasmer/pull/5392) fix(ci): Use `${{}}` notation for env variables passed from matrix
+  - [#5390](https://github.com/wasmerio/wasmer/pull/5390) chore: Fix doc comments in the api crate
+  - [#5389](https://github.com/wasmerio/wasmer/pull/5389) fix(c_api): Feature gate compiler-related types and functions behind …
+  - [#5385](https://github.com/wasmerio/wasmer/pull/5385) Fix documentation comments in examples
+  - [#5363](https://github.com/wasmerio/wasmer/pull/5363) chore: fix all warnings
+  - [#5354](https://github.com/wasmerio/wasmer/pull/5354) Fix non-consistent hashing of webc's
+
+
+
+## 5.0.5-rc1 - 03/01/2025
+Fixed an error in `wasmer create-exe` that prevented the correct execution and various improvements to the FS in WASIX. 
+
+## Added
+
+  - [#5315](https://github.com/wasmerio/wasmer/pull/5315) Implement cross-FS file rename
+
+## Changed
+
+  - [#5321](https://github.com/wasmerio/wasmer/pull/5321) Flush before closing files to avoid missed writes
+
+## Fixed
+
+  - [#5320](https://github.com/wasmerio/wasmer/pull/5320) Fix "error: GitHub API: more that one release selected" in `create-exe`
+
+
+
+## 5.0.4 - 17/12/2024
+
+This release fixes minor bugs and adds spurious improvements. 
+
+## Added
+
+
+## Changed
+
+  - [#5305](https://github.com/wasmerio/wasmer/pull/5305) make `AppConfig.name` optional in wasmer-config
+  - [#5292](https://github.com/wasmerio/wasmer/pull/5292) Pass readme content instead of readme file name
+  - [#5300](https://github.com/wasmerio/wasmer/pull/5300) Refactor path_create_directory and path_remove_directory to…
+  - [#5277](https://github.com/wasmerio/wasmer/pull/5277) Rephrase the description for `--no-persist-id`
+  - [#5291](https://github.com/wasmerio/wasmer/pull/5291) chore(wasix): make Capabilities hashable
+  - [#5293](https://github.com/wasmerio/wasmer/pull/5293) LoongArch: Switch to the medium code model
+
+## Fixed
+
+  - [#5306](https://github.com/wasmerio/wasmer/pull/5306) Fix build for 32bit targets (usize == u32)
+  - [#5307](https://github.com/wasmerio/wasmer/pull/5307) A few WASIX FS-related fixes
+  - [#5285](https://github.com/wasmerio/wasmer/pull/5285) Fix handling of the root path in WasiFS resulting in a bad inode structure
+  - [#5294](https://github.com/wasmerio/wasmer/pull/5294) Fix typo in readme file
+
+
+
+## 5.0.3 - 07/12/2024
+
+This release adds support for a more fine-grained and flexible control over the network sandbox. Also, some bug fixes
+and improvements are included.
+
+## Added
+
+  - [#5274](https://github.com/wasmerio/wasmer/pull/5274) feat(config): Add (Named)PackageIdent::matches_id helpers
+
+## Changed
+
+  - [#5288](https://github.com/wasmerio/wasmer/pull/5288) Bump up macos runner versions
+  - [#5283](https://github.com/wasmerio/wasmer/pull/5283) Better network sandbox
+  - [#5243](https://github.com/wasmerio/wasmer/pull/5243) Support multiple heterogeneous backends at the same time
+  - [#5275](https://github.com/wasmerio/wasmer/pull/5275) Protect preopened inodes from being closed
+  - [#5264](https://github.com/wasmerio/wasmer/pull/5264) update running wasmer-integration-tests in CI
+
+## Fixed
+
+
+
+
+## 5.0.2 - 22/11/2024
+
+This release mostly consists of bug fixes and clean ups.
+
+## Added
+
+  - [#5259](https://github.com/wasmerio/wasmer/pull/5259) Fix alignment and padding of the WASIX snapshot type to align with wasix-libc
+  - [#5236](https://github.com/wasmerio/wasmer/pull/5236) feat(benches): Add compilation benches, use remote artifacts
+  - [#5230](https://github.com/wasmerio/wasmer/pull/5230) fix(llvm): Fix `ADD_ABS_LO12_NC` relocation
+  - [#5226](https://github.com/wasmerio/wasmer/pull/5226) Add make target for building `wasmer-api` with `js` feature as `cdylib`
+
+## Changed
+
+  - [#4997](https://github.com/wasmerio/wasmer/pull/4997) Rework WasiFs to use a "holey" FdList instead of hashmap + seed + fre…
+  - [#5257](https://github.com/wasmerio/wasmer/pull/5257) ci: update `CONTRIBUTING.md` reference
+  - [#5250](https://github.com/wasmerio/wasmer/pull/5250) deps: Remove usage of unmaintained derivative crate
+  - [#5256](https://github.com/wasmerio/wasmer/pull/5256) deps: Upgrade wcgi crates to 0.3.0
+  - [#5253](https://github.com/wasmerio/wasmer/pull/5253) chore(wasix): Downgrade debug logs to trace
+  - [#5245](https://github.com/wasmerio/wasmer/pull/5245) Relax `wat` version requirement
+  - [#5244](https://github.com/wasmerio/wasmer/pull/5244) Alias `.` to cwd in wasi env
+  - [#5225](https://github.com/wasmerio/wasmer/pull/5225) Move compilation types inside of wasmer compiler
+
+## Fixed
+
+  - [#5268](https://github.com/wasmerio/wasmer/pull/5268) Fix musl builds
+  - [#5231](https://github.com/wasmerio/wasmer/pull/5231) Fix LLVM detection
+  - [#5235](https://github.com/wasmerio/wasmer/pull/5235) c-api/README.md: Fix double include in usage section
+  - [#5238](https://github.com/wasmerio/wasmer/pull/5238) Revert "Fix handling of the root dir in `path_create_directory` and `get_inode_at_path_inner`"
+  - [#5237](https://github.com/wasmerio/wasmer/pull/5237) Fix handling of the root dir in `path_create_directory` and `get_inode_at_path_inner`
+
+
+
+## 5.0.1 - 06/11/2024
+
+This release adds LLVM support to MacOS ARM64 binaries and contains minor fixes and improvements.
+
+## Added
+
+  - [#5220](https://github.com/wasmerio/wasmer/pull/5220) fix(ci): Move addition of `brew` libs to other step
+  - [#5218](https://github.com/wasmerio/wasmer/pull/5218) fix(ci): Add `brew` libs to `RUSTFLAGS` in aarch64
+  - [#5129](https://github.com/wasmerio/wasmer/pull/5129) Experimental: Add support for WASMI
+  - [#5205](https://github.com/wasmerio/wasmer/pull/5205) Add LLVM to docs CI
+
+## Changed
+
+  - [#5216](https://github.com/wasmerio/wasmer/pull/5216) Bump up webc version
+  - [#5215](https://github.com/wasmerio/wasmer/pull/5215) Re-enable RISC-V
+  - [#5194](https://github.com/wasmerio/wasmer/pull/5194) build: Update nix flake devshell for LLVM 18
+  - [#5202](https://github.com/wasmerio/wasmer/pull/5202) chore: Remove `isle-in-source-tree` feature from `cranelift-codegen`
+
+## Fixed
+
+  - [#5210](https://github.com/wasmerio/wasmer/pull/5210) Fix(LLVM): Implement the missing relocations on aarch64, fix SIMD operations
+  - [#5209](https://github.com/wasmerio/wasmer/pull/5209) Revert "Fix(LLVM): Implement the missing relocations on aarch64, fix SIMD operations"
+  - [#5207](https://github.com/wasmerio/wasmer/pull/5207) Fix(LLVM): Implement the missing relocations on aarch64, fix SIMD operations
+  - [#5203](https://github.com/wasmerio/wasmer/pull/5203) Fix the wasmer-swift crate build
+
+
+
+## 5.0.0 - 29/10/2024
+
+The main star of this release is the experimental support for three new backends: v8, wamr and wasmi. Also, many dependencies, namely LLVM, Cranelift, and rkyv are updated
+which bring significant enhancements.
+
+## Added
+
+  - [#5185](https://github.com/wasmerio/wasmer/pull/5185) Add execution benchmarks
+  - [#5174](https://github.com/wasmerio/wasmer/pull/5174) chore(wasix): Additional logging in wasix HTTP client
+  - [#5152](https://github.com/wasmerio/wasmer/pull/5152) Experimental: add support for loongarch64 on LLVM
+
+## Changed
+
+  - [#5188](https://github.com/wasmerio/wasmer/pull/5188) feat: Rename `wasmer-api` to `wasmer-backend-api`
+  - [#5186](https://github.com/wasmerio/wasmer/pull/5186) Remove support for emscripten
+  - [#5181](https://github.com/wasmerio/wasmer/pull/5181) Sunset `wasmer-registry`, `wasmer-interface` and update misc dependencies
+  - [#5165](https://github.com/wasmerio/wasmer/pull/5165) 5.0.0-rc.1 post release
+  - [#5151](https://github.com/wasmerio/wasmer/pull/5151) Remove negative variant of exit code
+  - [#5153](https://github.com/wasmerio/wasmer/pull/5153) Terminate entire wasix process when a worker thread fails or calls exit
+  - [#5172](https://github.com/wasmerio/wasmer/pull/5172) chore(backend-api): Update GraphQL schema
+  - [#5176](https://github.com/wasmerio/wasmer/pull/5176) Remove unused edge-util dependency
+  - [#5171](https://github.com/wasmerio/wasmer/pull/5171) Refactor webc usage
+  - [#5144](https://github.com/wasmerio/wasmer/pull/5144) Implement app-deployment related CLI commands
+  - [#5163](https://github.com/wasmerio/wasmer/pull/5163) Correct the example of the README in the WASIX crate
+
+## Fixed
+
+  - [#5184](https://github.com/wasmerio/wasmer/pull/5184) fix(api/wamr): Build `wamr` on `iOS`
+  - [#5179](https://github.com/wasmerio/wasmer/pull/5179) Fix build CI
+  - [#5178](https://github.com/wasmerio/wasmer/pull/5178) Fix usage of exit code
+  - [#5162](https://github.com/wasmerio/wasmer/pull/5162) Fix append-ness of new fd affecting old fds
+  - [#5160](https://github.com/wasmerio/wasmer/pull/5160) Fix fd with append flag can't seek correctly
+
+
+
+## 5.0.0-rc.1 - 21/10/2024
+
+This is a release candidate as we are preparing for the final release of 5.0
+
+## Added
+
+  - [#5154](https://github.com/wasmerio/wasmer/pull/5154) Add build steps for interpreter backends
+  - [#5138](https://github.com/wasmerio/wasmer/pull/5138) Experimental: Add support for v8
+  - [#5129](https://github.com/wasmerio/wasmer/pull/5129) Experimental: Add support for WASMI
+  - [#4515](https://github.com/wasmerio/wasmer/pull/4515) Experimental: Add interpreter support for Wasmer
+
+## Changed
+
+  - [#5158](https://github.com/wasmerio/wasmer/pull/5158) path_create_directory shouldn't behave recursively
+  - [#5156](https://github.com/wasmerio/wasmer/pull/5156) Resolve double-free error in c-api
+  - [#5149](https://github.com/wasmerio/wasmer/pull/5149) Merge 5.0 release candidate into main
+  - [#5148](https://github.com/wasmerio/wasmer/pull/5148) Remove deprecated methods and types
+  - [#5147](https://github.com/wasmerio/wasmer/pull/5147) Feat(compiler/llvm): Replace runtime assertions (in debug mode) with errors
+  - [#5146](https://github.com/wasmerio/wasmer/pull/5146) feat(api/build/v8): Use blob to build v8
+  - [#5142](https://github.com/wasmerio/wasmer/pull/5142) Upgrade `rkyv`
+  - [#5098](https://github.com/wasmerio/wasmer/pull/5098) `js::module`: leave warning comment on the `Send` impl
+  - [#5139](https://github.com/wasmerio/wasmer/pull/5139) deps: Update corosensei
+  - [#5136](https://github.com/wasmerio/wasmer/pull/5136) Replace v3 usage of download-artifact
+  - [#5135](https://github.com/wasmerio/wasmer/pull/5135) Use upload/download artifact v4
+
+## Fixed
+
+  - [#4834](https://github.com/wasmerio/wasmer/pull/4834) Fix `path_open` trailing slash edge case
+  - [#4821](https://github.com/wasmerio/wasmer/pull/4821) Fix `path_open` sometimes ignoring trailing slash
+  - [#5137](https://github.com/wasmerio/wasmer/pull/5137) Trying to fix js build
+
+
+
+## 4.4.0 - 04/10/2024
+
+This release adds support for object size estimation, adds better proxy support, improves executable spawning, and contains various bug fixes.
+
+## Added
+
+  - [#5079](https://github.com/wasmerio/wasmer/pull/5079) Add feature for objects' sizes estimation
+  - [#5125](https://github.com/wasmerio/wasmer/pull/5125) oss-fuzz: add cifuzz
+  - [#5110](https://github.com/wasmerio/wasmer/pull/5110) Add new --invoke arg for choosing entry function for single WASM modules + fix --invoke not working for WASI(X) modules
+  - [#5090](https://github.com/wasmerio/wasmer/pull/5090) Add the right to fetch stats on pipes
+  - [#5088](https://github.com/wasmerio/wasmer/pull/5088) Various cleanup chores + add a new test
+
+## Changed
+
+  - [#5127](https://github.com/wasmerio/wasmer/pull/5127) Implement proper executable spawn
+  - [#5098](https://github.com/wasmerio/wasmer/pull/5098) `js::module`: leave warning comment on the `Send` impl
+  - [#5120](https://github.com/wasmerio/wasmer/pull/5120) Improve QueryError
+  - [#5118](https://github.com/wasmerio/wasmer/pull/5118) InMemory/MultiSource Improvements
+  - [#5104](https://github.com/wasmerio/wasmer/pull/5104) Transfer the file size when renamed
+  - [#5102](https://github.com/wasmerio/wasmer/pull/5102) chore(wasix): Reduce syscall instrumentation levels
+  - [#5096](https://github.com/wasmerio/wasmer/pull/5096) Update cargo-deny config
+  - [#4983](https://github.com/wasmerio/wasmer/pull/4983) deps: Upgrade some dependencies + lift to workspace root
+  - [#5092](https://github.com/wasmerio/wasmer/pull/5092) Replace `WASM_ANYREF` with `WASM_EXTERNREF`
+  - [#5091](https://github.com/wasmerio/wasmer/pull/5091) Apply the proxy setting in wasmer config
+  - [#5089](https://github.com/wasmerio/wasmer/pull/5089) feat(cli): Restore packages from webcs
+
+## Fixed
+
+  - [#5124](https://github.com/wasmerio/wasmer/pull/5124) Various fixes to get wasmer-js compiling
+  - [#5108](https://github.com/wasmerio/wasmer/pull/5108) Fix error in metering middleware
+
+
+
 ## 4.3.7 - 06/09/2024
 
 This release adds support for rotating secrets, fixes a regression with the filesystem, and contains other fixes and improvments.
@@ -1130,7 +1710,7 @@ Lots of new things in the release!
   - [#3665](https://github.com/wasmerio/wasmer/pull/3665) Fix doc, threads are enabled by default now
   - [#3662](https://github.com/wasmerio/wasmer/pull/3662) Why is it so difficult to type LLVM_SYS_140_PREFIX
   - [#3661](https://github.com/wasmerio/wasmer/pull/3661) [CI] New attempt at fixing the Windows build on the CI
-  - [#3659](https://github.com/wasmerio/wasmer/pull/3659) Fixed building with with just the sys feature
+  - [#3659](https://github.com/wasmerio/wasmer/pull/3659) Fixed building with just the sys feature
   - [#3648](https://github.com/wasmerio/wasmer/pull/3648) Fix CI and llvm detection
   - [#3643](https://github.com/wasmerio/wasmer/pull/3643) fix(wasi): Memory leak due to cyclical WasiControlPlane references
   - [#3639](https://github.com/wasmerio/wasmer/pull/3639) wasi: Thread Lifecycle Fix
diff --git a/Cargo.lock b/Cargo.lock
index 3849b3ec7b..4aa3620eb4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,21 +1,32 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "addr2line"
-version = "0.22.0"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e4503c46a5c0c7844e948c9a4d6acd9f50cccb4de1c48eb9e291ea17470c678"
+checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b"
 dependencies = [
- "gimli 0.29.0",
+ "gimli 0.32.3",
 ]
 
 [[package]]
-name = "adler"
-version = "1.0.2"
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
+[[package]]
+name = "aes"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+]
 
 [[package]]
 name = "ahash"
@@ -23,22 +34,21 @@ version = "0.7.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.16",
  "once_cell",
  "version_check",
 ]
 
 [[package]]
 name = "ahash"
-version = "0.8.11"
+version = "0.8.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
 dependencies = [
- "cfg-if 1.0.0",
- "getrandom",
+ "cfg-if",
  "once_cell",
  "version_check",
- "zerocopy",
+ "zerocopy 0.8.27",
 ]
 
 [[package]]
@@ -56,18 +66,6 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "250f629c0161ad8107cf89319e990051fae62832fd343083bea452d93e2205fd"
 
-[[package]]
-name = "allocator-api2"
-version = "0.2.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f"
-
-[[package]]
-name = "android-tzdata"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
-
 [[package]]
 name = "android_system_properties"
 version = "0.1.5"
@@ -85,9 +83,9 @@ checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
 
 [[package]]
 name = "anstream"
-version = "0.6.14"
+version = "0.6.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "418c75fa768af9c03be99d17643f93f79bbba589895012a80e3452a19ddda15b"
+checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -100,36 +98,37 @@ dependencies = [
 
 [[package]]
 name = "anstyle"
-version = "1.0.7"
+version = "1.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "038dfcf04a5feb68e9c60b21c9625a54c2c0616e79b72b0fd87075a056ae1d1b"
+checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"
 
 [[package]]
 name = "anstyle-parse"
-version = "0.2.4"
+version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c03a11a9034d92058ceb6ee011ce58af4a9bf61491aa7e1e59ecd24bd40d22d4"
+checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
 dependencies = [
  "utf8parse",
 ]
 
 [[package]]
 name = "anstyle-query"
-version = "1.1.0"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad186efb764318d35165f1758e7dcef3b10628e26d41a44bc5550652e6804391"
+checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.3"
+version = "3.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61a38449feb7068f52bb06c12759005cf459ee52bb4adc1d5a7c4322d716fb19"
+checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a"
 dependencies = [
  "anstyle",
- "windows-sys 0.52.0",
+ "once_cell_polyfill",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -140,24 +139,24 @@ checksum = "70033777eb8b5124a81a1889416543dddef2de240019b674c81285a2635a7e1e"
 
 [[package]]
 name = "anyhow"
-version = "1.0.86"
+version = "1.0.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3d1d046238990b9cf5bcde22a3fb3584ee5cf65fb2765f454ed428c7a0063da"
+checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61"
 
 [[package]]
 name = "arbitrary"
-version = "1.3.2"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d5a26814d8dcb93b0e5a0ff3c6d80a8843bafb21b39e8e18a6f05471870e110"
+checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
 dependencies = [
  "derive_arbitrary",
 ]
 
 [[package]]
 name = "arrayref"
-version = "0.3.8"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d151e35f61089500b617991b791fc8bfd237ae50cd5950803758a179b41e67a"
+checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
 
 [[package]]
 name = "arrayvec"
@@ -167,15 +166,56 @@ checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
 
 [[package]]
 name = "arrayvec"
-version = "0.7.4"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
-name = "ascii"
-version = "0.9.3"
+name = "askama"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b79091df18a97caea757e28cd2d5fda49c6cd4bd01ddffd7ff01ace0c0ad2c28"
+dependencies = [
+ "askama_derive",
+ "askama_escape",
+]
+
+[[package]]
+name = "askama_derive"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19fe8d6cb13c4714962c072ea496f3392015f0989b1a2847bb4b2d9effd71d83"
+dependencies = [
+ "askama_parser",
+ "basic-toml",
+ "mime",
+ "mime_guess",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "syn 2.0.106",
+]
+
+[[package]]
+name = "askama_escape"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "619743e34b5ba4e9703bba34deac3427c72507c7159f5fd030aea8cac0cfe341"
+
+[[package]]
+name = "askama_parser"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acb1161c6b64d1c3d83108213c2a2533a342ac225aabd0bda218278c2ddb00c0"
+dependencies = [
+ "nom 7.1.3",
+]
+
+[[package]]
+name = "assert-panic"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eab1c04a571841102f5345a8fc0f6bb3d31c315dec879b5c6e42e40ce7ffa34e"
+checksum = "763b2b82aee23fe46c14c792470080c26538396e9ea589f548298f26b22d7f41"
 
 [[package]]
 name = "assert_cmd"
@@ -193,107 +233,117 @@ dependencies = [
 
 [[package]]
 name = "assert_cmd"
-version = "2.0.14"
+version = "2.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed72493ac66d5804837f480ab3766c72bdfab91a65e565fc54fa9e42db0073a8"
+checksum = "2bd389a4b2970a01282ee455294913c0a43724daedcd1a24c3eb0ec1c1320b66"
 dependencies = [
  "anstyle",
- "bstr 1.9.1",
+ "bstr 1.12.0",
  "doc-comment",
- "predicates 3.1.0",
+ "libc",
+ "predicates 3.1.3",
  "predicates-core",
  "predicates-tree",
  "wait-timeout",
 ]
 
+[[package]]
+name = "async-channel"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2"
+dependencies = [
+ "concurrent-queue",
+ "event-listener-strategy",
+ "futures-core",
+ "pin-project-lite",
+]
+
 [[package]]
 name = "async-compression"
-version = "0.4.12"
+version = "0.4.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fec134f64e2bc57411226dfc4e52dec859ddfc7e711fc5e07b612584f000e4aa"
+checksum = "5a89bce6054c720275ac2432fbba080a66a2106a44a1b804553930ca6909f4e0"
 dependencies = [
- "flate2",
+ "compression-codecs",
+ "compression-core",
  "futures-core",
- "memchr",
  "pin-project-lite",
- "tokio 1.38.1",
+ "tokio",
 ]
 
 [[package]]
 name = "async-trait"
-version = "0.1.81"
+version = "0.1.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e0c28dcc82d7c8ead5cb13beb15405b57b8546e93215673ff8ca0349a028107"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
 [[package]]
 name = "async-tungstenite"
-version = "0.25.1"
+version = "0.28.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2cca750b12e02c389c1694d35c16539f88b8bbaa5945934fdc1b41a776688589"
+checksum = "1c348fb0b6d132c596eca3dcd941df48fb597aafcb07a738ec41c004b087dc99"
 dependencies = [
+ "atomic-waker",
+ "futures-core",
  "futures-io",
+ "futures-task",
  "futures-util",
- "log 0.4.22",
+ "log",
  "pin-project-lite",
  "rustls-native-certs",
  "rustls-pki-types",
- "tokio 1.38.1",
- "tokio-rustls 0.25.0",
- "tungstenite",
+ "tokio",
+ "tokio-rustls",
+ "tungstenite 0.24.0",
 ]
 
 [[package]]
-name = "atomic-polyfill"
-version = "1.0.3"
+name = "atomic-waker"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cf2bce30dfe09ef0bfaef228b9d414faaf7e563035494d7fe092dba54b300f4"
-dependencies = [
- "critical-section",
-]
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
 
 [[package]]
 name = "autocfg"
-version = "1.3.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
 name = "backtrace"
-version = "0.3.73"
+version = "0.3.76"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cc23269a4f8976d0a4d2e7109211a419fe30e8d88d677cd60b6bc79c5732e0a"
+checksum = "bb531853791a215d7c62a30daf0dde835f381ab5de4589cfe7c649d2cbe92bd6"
 dependencies = [
  "addr2line",
- "cc",
- "cfg-if 1.0.0",
+ "cfg-if",
  "libc",
  "miniz_oxide",
- "object 0.36.1",
+ "object 0.37.3",
  "rustc-demangle",
+ "windows-link",
 ]
 
 [[package]]
 name = "base64"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
-
-[[package]]
-name = "base64"
-version = "0.21.7"
+version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
 [[package]]
-name = "base64"
-version = "0.22.1"
+name = "basic-toml"
+version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+checksum = "ba62675e8242a4c4e806d12f11d136e626e6c8361d6b829310732241652a178a"
+dependencies = [
+ "serde",
+]
 
 [[package]]
 name = "beef"
@@ -311,39 +361,47 @@ dependencies = [
 ]
 
 [[package]]
-name = "bitflags"
-version = "1.3.2"
+name = "bindgen"
+version = "0.70.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+checksum = "f49d8fed880d473ea71efb9bf597651e77201bdd4893efe54c9e5d65ae04ce6f"
+dependencies = [
+ "bitflags 2.9.4",
+ "cexpr",
+ "clang-sys",
+ "itertools 0.13.0",
+ "log",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash 1.1.0",
+ "shlex",
+ "syn 2.0.106",
+]
 
 [[package]]
 name = "bitflags"
-version = "2.6.0"
+version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
-name = "bitvec"
-version = "1.0.1"
+name = "bitflags"
+version = "2.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
-dependencies = [
- "funty",
- "radium",
- "tap",
- "wyz",
-]
+checksum = "2261d10cca569e4643e526d8dc2e62e433cc8aba21ab764233731f8d369bf394"
 
 [[package]]
 name = "blake3"
-version = "1.5.3"
+version = "1.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9ec96fe9a81b5e365f9db71fe00edc4fe4ca2cc7dcb7861f0603012a7caa210"
+checksum = "3888aaa89e4b2a40fca9848e400f6a658a5a3978de7be858e209cafa8be9a4a0"
 dependencies = [
  "arrayref",
- "arrayvec 0.7.4",
+ "arrayvec 0.7.6",
  "cc",
- "cfg-if 1.0.0",
+ "cfg-if",
  "constant_time_eq",
 ]
 
@@ -369,12 +427,12 @@ dependencies = [
 
 [[package]]
 name = "bstr"
-version = "1.9.1"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05efc5cfd9110c8416e471df0e96702d58690178e206e61b7173706673c93706"
+checksum = "234113d19d0d7d613b40e86fb654acf958910802bcceab913a4f9e7cda03b1a4"
 dependencies = [
  "memchr",
- "regex-automata 0.4.7",
+ "regex-automata 0.4.11",
  "serde",
 ]
 
@@ -388,16 +446,21 @@ dependencies = [
 ]
 
 [[package]]
-name = "build_const"
-version = "0.2.2"
+name = "bumpalo"
+version = "3.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4ae4235e6dac0694637c763029ecea1a2ec9e4e06ec2729bd21ba4d9c863eb7"
+checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
 
 [[package]]
-name = "bumpalo"
-version = "3.16.0"
+name = "bus"
+version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
+checksum = "4b7118d0221d84fada881b657c2ddb7cd55108db79c8764c9ee212c0c259b783"
+dependencies = [
+ "crossbeam-channel",
+ "num_cpus",
+ "parking_lot_core",
+]
 
 [[package]]
 name = "bytecheck"
@@ -405,8 +468,20 @@ version = "0.6.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "23cdc57ce23ac53c931e88a43d06d070a6fd142f2617be5855eb75efc9beb1c2"
 dependencies = [
- "bytecheck_derive",
- "ptr_meta",
+ "bytecheck_derive 0.6.12",
+ "ptr_meta 0.1.4",
+ "simdutf8",
+]
+
+[[package]]
+name = "bytecheck"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0caa33a2c0edca0419d15ac723dff03f1956f7978329b1e3b5fdaaaed9d3ca8b"
+dependencies = [
+ "bytecheck_derive 0.8.2",
+ "ptr_meta 0.3.1",
+ "rancor",
  "simdutf8",
 ]
 
@@ -421,6 +496,17 @@ dependencies = [
  "syn 1.0.109",
 ]
 
+[[package]]
+name = "bytecheck_derive"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89385e82b5d1821d2219e0b095efa2cc1f246cbf99080f3be46a1a85c0d392d9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
 [[package]]
 name = "byteorder"
 version = "1.5.0"
@@ -429,46 +515,55 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "bytes"
-version = "0.4.12"
+version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "206fdffcfa2df7cbe15601ef46c813fce0965eb3286db6b56c583b814b51c81c"
+checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
 dependencies = [
- "byteorder",
- "iovec",
+ "serde",
 ]
 
 [[package]]
-name = "bytes"
-version = "1.6.1"
+name = "bytesize"
+version = "1.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a12916984aab3fa6e39d655a33e09c0071eb36d6ab3aea5c2d78551f1df6d952"
+checksum = "2e93abca9e28e0a1b9877922aacb20576e05d4679ffa78c3d6dc22a26a216659"
 dependencies = [
  "serde",
 ]
 
 [[package]]
-name = "bytesize"
-version = "1.3.0"
+name = "bzip2"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3e368af43e418a04d52505cf3dbc23dda4e3407ae2fa99fd0e4f308ce546acc"
+checksum = "49ecfb22d906f800d4fe833b6282cf4dc1c298f5057ca0b5445e5c209735ca47"
 dependencies = [
- "serde",
+ "bzip2-sys",
+]
+
+[[package]]
+name = "bzip2-sys"
+version = "0.1.13+1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "225bff33b2141874fe80d71e07d6eec4f85c5c216453dd96388240f96e1acc14"
+dependencies = [
+ "cc",
+ "pkg-config",
 ]
 
 [[package]]
 name = "camino"
-version = "1.1.7"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0ec6b951b160caa93cc0c7b209e5a3bff7aae9062213451ac99493cd844c239"
+checksum = "276a59bf2b2c967788139340c9f0c5b12d7fd6630315c15c217e559de85d2609"
 dependencies = [
- "serde",
+ "serde_core",
 ]
 
 [[package]]
 name = "cargo-platform"
-version = "0.1.8"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24b1f0365a6c6bb4020cd05806fd0d33c44d38046b8bd7f0e40814b9763cabfc"
+checksum = "e35af189006b9c0f00a064685c727031e3ed2d8020f7ba284d78cc2671bd36ea"
 dependencies = [
  "serde",
 ]
@@ -481,10 +576,10 @@ checksum = "eee4243f1f26fc7a42710e7439c149e2b10b05472f88090acce52632f231a73a"
 dependencies = [
  "camino",
  "cargo-platform",
- "semver 1.0.23",
+ "semver 1.0.27",
  "serde",
  "serde_json",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -495,62 +590,66 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cbindgen"
-version = "0.24.5"
+version = "0.27.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b922faaf31122819ec80c4047cc684c6979a087366c069611e33649bf98e18d"
+checksum = "3fce8dd7fcfcbf3a0a87d8f515194b49d6135acab73e18bd380d1d93bb1a15eb"
 dependencies = [
  "heck 0.4.1",
- "indexmap 1.9.3",
- "log 0.4.22",
+ "indexmap 2.11.4",
+ "log",
  "proc-macro2",
  "quote",
  "serde",
  "serde_json",
- "syn 1.0.109",
+ "syn 2.0.106",
  "tempfile",
- "toml 0.5.11",
+ "toml 0.8.23",
 ]
 
 [[package]]
 name = "cc"
-version = "1.1.6"
+version = "1.2.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2aba8f4e9906c7ce3c73463f62a7f0c65183ada1a2d47e397cc8810827f9694f"
+checksum = "e1d05d92f4b1fd76aad469d46cdd858ca761576082cd37df81416691e50199fb"
 dependencies = [
+ "find-msvc-tools",
  "jobserver",
  "libc",
+ "shlex",
 ]
 
 [[package]]
-name = "cfg-if"
-version = "0.1.10"
+name = "cexpr"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom 7.1.3",
+]
 
 [[package]]
 name = "cfg-if"
-version = "1.0.0"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+checksum = "2fd1289c04a9ea8cb22300a459a72a385d7c73d3259e2ed7dcb2af674838cfa9"
 
 [[package]]
 name = "cfg_aliases"
-version = "0.1.1"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
 [[package]]
 name = "chrono"
-version = "0.4.38"
+version = "0.4.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
+checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2"
 dependencies = [
- "android-tzdata",
  "iana-time-zone",
  "js-sys",
  "num-traits",
  "wasm-bindgen",
- "windows-targets 0.52.6",
+ "windows-link",
 ]
 
 [[package]]
@@ -577,7 +676,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
 dependencies = [
  "ciborium-io",
- "half 2.4.1",
+ "half 2.6.0",
 ]
 
 [[package]]
@@ -590,6 +689,17 @@ dependencies = [
  "inout",
 ]
 
+[[package]]
+name = "clang-sys"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
+dependencies = [
+ "glob",
+ "libc",
+ "libloading",
+]
+
 [[package]]
 name = "clap"
 version = "4.4.11"
@@ -630,7 +740,7 @@ dependencies = [
  "heck 0.4.1",
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
 [[package]]
@@ -641,28 +751,28 @@ checksum = "702fc72eb24e5a1e48ce58027a675bc24edd52096d5397d4aea7c6dd9eca0bd1"
 
 [[package]]
 name = "clap_mangen"
-version = "0.2.22"
+version = "0.2.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f50dde5bc0c853d6248de457e5eb6e5a674a54b93810a34ded88d882ca1fe2de"
+checksum = "27b4c3c54b30f0d9adcb47f25f61fcce35c4dd8916638c6b82fbd5f4fb4179e2"
 dependencies = [
  "clap",
  "roff",
 ]
 
 [[package]]
-name = "cloudabi"
-version = "0.0.3"
+name = "cmake"
+version = "0.1.54"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f"
+checksum = "e7caa3f9de89ddbe2c607f4101924c5abec803763ae9534e4f4d7d8f84aa81f0"
 dependencies = [
- "bitflags 1.3.2",
+ "cc",
 ]
 
 [[package]]
 name = "colorchoice"
-version = "1.0.1"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b6a852b24ab71dffc585bcb46eaf7959d175cb865a7152e35b348d1b2960422"
+checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
 
 [[package]]
 name = "colored"
@@ -672,42 +782,28 @@ checksum = "5a5f741c91823341bebf717d4c71bda820630ce065443b58bd1b7451af008355"
 dependencies = [
  "is-terminal",
  "lazy_static",
- "winapi 0.3.9",
+ "winapi",
 ]
 
 [[package]]
 name = "colored"
-version = "2.1.0"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbf2150cce219b664a8a70df7a1f933836724b503f8a413af9365b4dcc4d90b8"
+checksum = "117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c"
 dependencies = [
  "lazy_static",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "combine"
-version = "3.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da3da6baa321ec19e1cc41d31bf599f00c783d0517095cdaf0332e3fe8d20680"
-dependencies = [
- "ascii",
- "byteorder",
- "either",
- "memchr",
- "unreachable",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "comfy-table"
-version = "7.1.1"
+version = "7.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b34115915337defe99b2aff5c2ce6771e5fbc4079f4b506301f5cf394c8452f7"
+checksum = "4a65ebfec4fb190b6f90e944a817d60499ee0744e582530e2c9900a22e591d9a"
 dependencies = [
  "crossterm",
- "strum",
- "strum_macros",
- "unicode-width",
+ "unicode-segmentation",
+ "unicode-width 0.2.2",
 ]
 
 [[package]]
@@ -732,51 +828,61 @@ dependencies = [
  "getopts",
  "lazy_static",
  "libc",
- "log 0.4.22",
- "miow 0.3.7",
+ "log",
+ "miow",
  "regex",
  "rustfix",
  "serde",
  "serde_derive",
  "serde_json",
  "tester",
- "winapi 0.3.9",
+ "winapi",
 ]
 
 [[package]]
-name = "console"
-version = "0.15.8"
+name = "compression-codecs"
+version = "0.4.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb"
+checksum = "ef8a506ec4b81c460798f572caead636d57d3d7e940f998160f52bd254bf2d23"
 dependencies = [
- "encode_unicode",
- "lazy_static",
- "libc",
- "unicode-width",
- "windows-sys 0.52.0",
+ "compression-core",
+ "flate2",
+ "memchr",
 ]
 
 [[package]]
-name = "console_error_panic_hook"
-version = "0.1.7"
+name = "compression-core"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e47641d3deaf41fb1538ac1f54735925e275eaf3bf4d55c81b137fba797e5cbb"
+
+[[package]]
+name = "concurrent-queue"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
+checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
 dependencies = [
- "cfg-if 1.0.0",
- "wasm-bindgen",
+ "crossbeam-utils",
 ]
 
 [[package]]
-name = "constant_time_eq"
-version = "0.3.0"
+name = "console"
+version = "0.15.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7144d30dcf0fafbce74250a3963025d8d52177934239851c917d29f1df280c2"
+checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8"
+dependencies = [
+ "encode_unicode",
+ "libc",
+ "once_cell",
+ "unicode-width 0.2.2",
+ "windows-sys 0.59.0",
+]
 
 [[package]]
-name = "convert_case"
-version = "0.4.0"
+name = "constant_time_eq"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e"
+checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6"
 
 [[package]]
 name = "cooked-waker"
@@ -794,144 +900,156 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "core-foundation"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
 [[package]]
 name = "core-foundation-sys"
-version = "0.8.6"
+version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
 [[package]]
 name = "corosensei"
-version = "0.1.4"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80128832c58ea9cbd041d2a759ec449224487b2c1e400453d99d244eead87a8e"
+checksum = "878ba85678ef5d34ffe1b5da981b0828232b4c7f2726b20984f59c7e79f6d514"
 dependencies = [
  "autocfg",
- "cfg-if 1.0.0",
+ "cfg-if",
  "libc",
  "scopeguard",
- "windows-sys 0.33.0",
-]
-
-[[package]]
-name = "counter"
-version = "0.5.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d458e66999348f56fd3ffcfbb7f7951542075ca8359687c703de6500c1ddccd"
-dependencies = [
- "num-traits",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "cpufeatures"
-version = "0.2.12"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "cranelift-bforest"
-version = "0.91.1"
+version = "0.110.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a2ab4512dfd3a6f4be184403a195f76e81a8a9f9e6c898e19d2dc3ce20e0115"
+checksum = "305d51c180ebdc46ef61bc60c54ae6512db3bc9a05842a1f1e762e45977019ab"
 dependencies = [
  "cranelift-entity",
 ]
 
+[[package]]
+name = "cranelift-bitset"
+version = "0.110.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "690d8ae6c73748e5ce3d8fe59034dceadb8823e6c8994ba324141c5eae909b0e"
+
 [[package]]
 name = "cranelift-codegen"
-version = "0.91.1"
+version = "0.110.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98b022ed2a5913a38839dfbafe6cf135342661293b08049843362df4301261dc"
+checksum = "bd7ca95e831c18d1356da783765c344207cbdffea91e13e47fa9327dbb2e0719"
 dependencies = [
- "arrayvec 0.7.4",
  "bumpalo",
  "cranelift-bforest",
+ "cranelift-bitset",
  "cranelift-codegen-meta",
  "cranelift-codegen-shared",
- "cranelift-egraph",
+ "cranelift-control",
  "cranelift-entity",
  "cranelift-isle",
- "gimli 0.26.2",
- "hashbrown 0.12.3",
- "log 0.4.22",
+ "gimli 0.28.1",
+ "hashbrown 0.14.5",
+ "log",
  "regalloc2",
- "smallvec 1.13.2",
- "target-lexicon 0.12.15",
+ "rustc-hash 1.1.0",
+ "smallvec",
+ "target-lexicon 0.12.16",
 ]
 
 [[package]]
 name = "cranelift-codegen-meta"
-version = "0.91.1"
+version = "0.110.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "639307b45434ad112a98f8300c0f0ab085cbefcd767efcdef9ef19d4c0756e74"
+checksum = "f0a2d2ab65e6cbf91f81781d8da65ec2005510f18300eff21a99526ed6785863"
 dependencies = [
  "cranelift-codegen-shared",
 ]
 
 [[package]]
 name = "cranelift-codegen-shared"
-version = "0.91.1"
+version = "0.110.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "278e52e29c53fcf32431ef08406c295699a70306d05a0715c5b1bf50e33a9ab7"
+checksum = "efcff860573cf3db9ae98fbd949240d78b319df686cc306872e7fab60e9c84d7"
 
 [[package]]
-name = "cranelift-egraph"
-version = "0.91.1"
+name = "cranelift-control"
+version = "0.110.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "624b54323b06e675293939311943ba82d323bb340468ce1889be5da7932c8d73"
+checksum = "69d70e5b75c2d5541ef80a99966ccd97aaa54d2a6af19ea31759a28538e1685a"
 dependencies = [
- "cranelift-entity",
- "fxhash",
- "hashbrown 0.12.3",
- "indexmap 1.9.3",
- "log 0.4.22",
- "smallvec 1.13.2",
+ "arbitrary",
 ]
 
 [[package]]
 name = "cranelift-entity"
-version = "0.91.1"
+version = "0.110.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a59bcbca89c3f1b70b93ab3cbba5e5e0cbf3e63dadb23c7525cb142e21a9d4c"
+checksum = "a48cb0a194c9ba82fec35a1e492055388d89b2e3c03dee9dcf2488892be8004d"
+dependencies = [
+ "cranelift-bitset",
+]
 
 [[package]]
 name = "cranelift-frontend"
-version = "0.91.1"
+version = "0.110.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d70abacb8cfef3dc8ff7e8836e9c1d70f7967dfdac824a4cd5e30223415aca6"
+checksum = "8327afc6c1c05f4be62fefce5b439fa83521c65363a322e86ea32c85e7ceaf64"
 dependencies = [
  "cranelift-codegen",
- "hashbrown 0.12.3",
- "log 0.4.22",
- "smallvec 1.13.2",
- "target-lexicon 0.12.15",
+ "hashbrown 0.14.5",
+ "log",
+ "smallvec",
+ "target-lexicon 0.12.16",
 ]
 
 [[package]]
 name = "cranelift-isle"
-version = "0.91.1"
+version = "0.110.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "393bc73c451830ff8dbb3a07f61843d6cb41a084f9996319917c0b291ed785bb"
+checksum = "56b08621c00321efcfa3eee6a3179adc009e21ea8d24ca7adc3c326184bc3f48"
 
 [[package]]
 name = "crc"
-version = "1.8.1"
+version = "3.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d663548de7f5cca343f1e0a48d14dcfb0e9eb4e079ec58883b7251539fa10aeb"
+checksum = "9710d3b3739c2e349eb44fe848ad0b7c8cb1e42bd87ee49371df2f7acaf3e675"
 dependencies = [
- "build_const",
+ "crc-catalog",
 ]
 
 [[package]]
-name = "crc32fast"
-version = "1.4.2"
+name = "crc-catalog"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3"
-dependencies = [
- "cfg-if 1.0.0",
+checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5"
+
+[[package]]
+name = "crc32fast"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+dependencies = [
+ "cfg-if",
 ]
 
 [[package]]
@@ -945,11 +1063,14 @@ dependencies = [
  "ciborium",
  "clap",
  "criterion-plot",
+ "csv",
  "is-terminal",
  "itertools 0.10.5",
  "num-traits",
  "once_cell",
  "oorandom",
+ "plotters",
+ "rayon",
  "regex",
  "serde",
  "serde_derive",
@@ -968,55 +1089,23 @@ dependencies = [
  "itertools 0.10.5",
 ]
 
-[[package]]
-name = "critical-section"
-version = "1.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7059fff8937831a9ae6f0fe4d658ffabf58f2ca96aa9dec1c889f936f705f216"
-
 [[package]]
 name = "crossbeam-channel"
-version = "0.5.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33480d6946193aa8033910124896ca395333cae7e2d1113d1fef6c3272217df2"
-dependencies = [
- "crossbeam-utils 0.8.20",
-]
-
-[[package]]
-name = "crossbeam-deque"
-version = "0.7.4"
+version = "0.5.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c20ff29ded3204c5106278a81a38f4b482636ed4fa1e6cfbeef193291beb29ed"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
 dependencies = [
- "crossbeam-epoch 0.8.2",
- "crossbeam-utils 0.7.2",
- "maybe-uninit",
+ "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-deque"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
-dependencies = [
- "crossbeam-epoch 0.9.18",
- "crossbeam-utils 0.8.20",
-]
-
-[[package]]
-name = "crossbeam-epoch"
-version = "0.8.2"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "058ed274caafc1f60c4997b5fc07bf7dc7cca454af7c6e81edffe5f33f70dace"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
 dependencies = [
- "autocfg",
- "cfg-if 0.1.10",
- "crossbeam-utils 0.7.2",
- "lazy_static",
- "maybe-uninit",
- "memoffset 0.5.6",
- "scopeguard",
+ "crossbeam-epoch",
+ "crossbeam-utils",
 ]
 
 [[package]]
@@ -1025,57 +1114,35 @@ version = "0.9.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
 dependencies = [
- "crossbeam-utils 0.8.20",
-]
-
-[[package]]
-name = "crossbeam-queue"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "774ba60a54c213d409d5353bda12d49cd68d14e45036a285234c8d6f91f92570"
-dependencies = [
- "cfg-if 0.1.10",
- "crossbeam-utils 0.7.2",
- "maybe-uninit",
+ "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-queue"
-version = "0.3.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df0346b5d5e76ac2fe4e327c5fd1118d6be7c51dfb18f9b7922923f287471e35"
-dependencies = [
- "crossbeam-utils 0.8.20",
-]
-
-[[package]]
-name = "crossbeam-utils"
-version = "0.7.2"
+version = "0.3.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8"
+checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115"
 dependencies = [
- "autocfg",
- "cfg-if 0.1.10",
- "lazy_static",
+ "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.20"
+version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "crossterm"
-version = "0.27.0"
+version = "0.28.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f476fe445d41c9e991fd07515a6f463074b782242ccf4a5b7b1d1012e70824df"
+checksum = "829d955a0bb380ef178a640b91779e3987da38c9aea133b20614cfed8cdea9c6"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.9.4",
  "crossterm_winapi",
- "libc",
- "parking_lot 0.12.3",
- "winapi 0.3.9",
+ "parking_lot",
+ "rustix 0.38.44",
+ "winapi",
 ]
 
 [[package]]
@@ -1084,14 +1151,14 @@ version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "acdd7c62a3665c7f6830a51635d9ac9b23ed385797f70a83bb8bafe9c572ab2b"
 dependencies = [
- "winapi 0.3.9",
+ "winapi",
 ]
 
 [[package]]
 name = "crunchy"
-version = "0.2.2"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
 
 [[package]]
 name = "crypto-common"
@@ -1103,6 +1170,27 @@ dependencies = [
  "typenum",
 ]
 
+[[package]]
+name = "csv"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acdc4883a9c96732e4733212c01447ebd805833b7275a73ca3ee080fd77afdaf"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d02f3b0da4c6504f86e9cd789d8dbafab48c2321be74e9987593de5a894d93d"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "ctor"
 version = "0.1.26"
@@ -1115,9 +1203,9 @@ dependencies = [
 
 [[package]]
 name = "cynic"
-version = "3.7.3"
+version = "3.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "478c02b53607e3f21c374f024c2cfc2154e554905bba478e8e09409f10ce3726"
+checksum = "8b215a2d2bebcbbd3bd005b59f5b1b7dc5eb07343d64db80ec23aff9e7e1a2e2"
 dependencies = [
  "cynic-proc-macros",
  "ref-cast",
@@ -1125,48 +1213,47 @@ dependencies = [
  "serde",
  "serde_json",
  "static_assertions",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "cynic-codegen"
-version = "3.7.3"
+version = "3.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c0ec86f960a00ce087e96ff6f073f6ff28b6876d69ce8caa06c03fb4143981c"
+checksum = "9eeb2693bc9916fa694d2023bb1adc4356a8896b9b96478f23d51a263140811c"
 dependencies = [
- "counter",
  "cynic-parser",
- "darling 0.20.10",
+ "darling 0.20.11",
  "once_cell",
  "ouroboros",
  "proc-macro2",
  "quote",
  "strsim 0.10.0",
- "syn 2.0.72",
- "thiserror",
+ "syn 2.0.106",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "cynic-parser"
-version = "0.4.5"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "718f6cd8c54ae5249fd42b0c86639df0100b8a86eea2e5f1b915cde2e1481453"
+checksum = "3136ed6464e975162667c08092fcb54947ce08785fca301162fd614c4dfd974f"
 dependencies = [
- "indexmap 2.2.6",
+ "indexmap 2.11.4",
  "lalrpop-util",
  "logos",
 ]
 
 [[package]]
 name = "cynic-proc-macros"
-version = "3.7.3"
+version = "3.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25a69ecdf4aa110fed1c0c8de290bc8ccb2835388733cf2f418f0abdf6ff3899"
+checksum = "1c0b2eab13c954db96ae72db53b2d275c237f3197499212c4d55b5ae7418e5b2"
 dependencies = [
  "cynic-codegen",
- "darling 0.20.10",
+ "darling 0.20.11",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
 [[package]]
@@ -1181,12 +1268,22 @@ dependencies = [
 
 [[package]]
 name = "darling"
-version = "0.20.10"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc7f46116c46ff9ab3eb1597a45688b6715c6e628b5c133e288e709a29bcb4ee"
+dependencies = [
+ "darling_core 0.20.11",
+ "darling_macro 0.20.11",
+]
+
+[[package]]
+name = "darling"
+version = "0.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989"
+checksum = "9cdf337090841a411e2a7f3deb9187445851f91b309c0c0a29e05f74a00a48c0"
 dependencies = [
- "darling_core 0.20.10",
- "darling_macro 0.20.10",
+ "darling_core 0.21.3",
+ "darling_macro 0.21.3",
 ]
 
 [[package]]
@@ -1205,16 +1302,29 @@ dependencies = [
 
 [[package]]
 name = "darling_core"
-version = "0.20.10"
+version = "0.20.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95133861a8032aaea082871032f5815eb9e98cef03fa916ab4500513994df9e5"
+checksum = "0d00b9596d185e565c2207a0b01f8bd1a135483d02d9b7b0a54b11da8d53412e"
 dependencies = [
  "fnv",
  "ident_case",
  "proc-macro2",
  "quote",
  "strsim 0.11.1",
- "syn 2.0.72",
+ "syn 2.0.106",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1247195ecd7e3c85f83c8d2a366e4210d588e802133e1e355180a9870b517ea4"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
 ]
 
 [[package]]
@@ -1230,13 +1340,24 @@ dependencies = [
 
 [[package]]
 name = "darling_macro"
-version = "0.20.10"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead"
+dependencies = [
+ "darling_core 0.20.11",
+ "quote",
+ "syn 2.0.106",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
+checksum = "d38308df82d1080de0afee5d069fa14b0326a88c14f15c5ccda35b4a6c414c81"
 dependencies = [
- "darling_core 0.20.10",
+ "darling_core 0.21.3",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
 [[package]]
@@ -1245,63 +1366,57 @@ version = "5.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
  "hashbrown 0.14.5",
- "lock_api 0.4.12",
+ "lock_api",
  "once_cell",
- "parking_lot_core 0.9.10",
+ "parking_lot_core",
 ]
 
 [[package]]
 name = "dashmap"
-version = "6.0.1"
+version = "6.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "804c8821570c3f8b70230c2ba75ffa5c0f9a4189b9a432b6656c536712acae28"
+checksum = "5041cc499144891f3790297212f32a74fb938e5136a14943f338ef9e0ae276cf"
 dependencies = [
- "cfg-if 1.0.0",
- "crossbeam-utils 0.8.20",
+ "cfg-if",
+ "crossbeam-utils",
  "hashbrown 0.14.5",
- "lock_api 0.4.12",
+ "lock_api",
  "once_cell",
- "parking_lot_core 0.9.10",
+ "parking_lot_core",
 ]
 
 [[package]]
 name = "data-encoding"
-version = "2.6.0"
+version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8566979429cf69b49a5c740c60791108e86440e8be149bbea4fe54d2c32d6e2"
+checksum = "2a2330da5de22e8a3cb63252ce2abb30116bf5265e89c0e01bc17015ce30a476"
 
 [[package]]
-name = "deranged"
-version = "0.3.11"
+name = "deflate64"
+version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
-dependencies = [
- "powerfmt",
- "serde",
-]
+checksum = "26bf8fc351c5ed29b5c2f0cbbac1b209b74f60ecd62e675a998df72c49af5204"
 
 [[package]]
-name = "derivative"
-version = "2.2.0"
+name = "deranged"
+version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b"
+checksum = "a41953f86f8a05768a6cda24def994fd2f424b04ec5c719cf89989779f199071"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
+ "powerfmt",
 ]
 
 [[package]]
 name = "derive_arbitrary"
-version = "1.3.2"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67e77553c4162a157adbf834ebae5b415acbecbeafc7a74b0e886657506a7611"
+checksum = "1e567bd82dcff979e4b03460c307b3cdc9e96fde3d73bed1496d2bc75d9dd62a"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
 [[package]]
@@ -1337,15 +1452,34 @@ dependencies = [
 
 [[package]]
 name = "derive_more"
-version = "0.99.18"
+version = "0.99.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6edb4b64a43d977b8e99788fe3a04d483834fba1215a7e02caa415b626497f7f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
+[[package]]
+name = "derive_more"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f33878137e4dafd7fa914ad4e259e18a4e8e532b9617a2d0150262bf53abfce"
+checksum = "093242cf7570c207c83073cf82f79706fe7b8317e98620a47d5be7c3d8497678"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
 dependencies = [
- "convert_case",
  "proc-macro2",
  "quote",
- "rustc_version 0.4.0",
- "syn 2.0.72",
+ "syn 2.0.106",
+ "unicode-xid",
 ]
 
 [[package]]
@@ -1357,7 +1491,7 @@ dependencies = [
  "console",
  "shell-words",
  "tempfile",
- "thiserror",
+ "thiserror 1.0.69",
  "zeroize",
 ]
 
@@ -1399,7 +1533,7 @@ version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
  "dirs-sys-next",
 ]
 
@@ -1411,7 +1545,7 @@ checksum = "1b1d1d91c932ef41c0f2663aa8b0ca0342d444d842c06914aa0a7e352d0bada6"
 dependencies = [
  "libc",
  "redox_users",
- "winapi 0.3.9",
+ "winapi",
 ]
 
 [[package]]
@@ -1422,7 +1556,7 @@ checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
 dependencies = [
  "libc",
  "redox_users",
- "winapi 0.3.9",
+ "winapi",
 ]
 
 [[package]]
@@ -1433,7 +1567,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
 [[package]]
@@ -1450,9 +1584,9 @@ checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
 
 [[package]]
 name = "document-features"
-version = "0.2.10"
+version = "0.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb6969eaabd2421f8a2775cfd2471a2b634372b4a25d41e3bd647b79912850a0"
+checksum = "95249b50c6c185bee49034bcb378a49dc2b5dff0be90ff6616d31d64febab05d"
 dependencies = [
  "litrs",
 ]
@@ -1463,127 +1597,74 @@ version = "0.15.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b"
 
+[[package]]
+name = "downcast-rs"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2"
+
 [[package]]
 name = "dunce"
-version = "1.0.4"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56ce8c6da7551ec6c462cbaf3bfbc75131ebbfa1c944aeaa9dab51ca1c5f0c3b"
+checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
 
 [[package]]
 name = "dyn-clone"
-version = "1.0.17"
+version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d6ef0072f8a535281e4876be788938b528e9a1d43900b82c2569af7da799125"
+checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
 
 [[package]]
 name = "dynasm"
-version = "1.2.3"
+version = "4.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "add9a102807b524ec050363f09e06f1504214b0e1c7797f64261c891022dce8b"
+checksum = "6a31e49f416ec431ceef002ee220eee9da97687ec3ecea8040703edbaa75e157"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.9.4",
  "byteorder",
  "lazy_static",
- "proc-macro-error",
+ "proc-macro-error2",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.106",
 ]
 
 [[package]]
 name = "dynasmrt"
-version = "1.2.3"
+version = "4.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64fba5a42bd76a17cad4bfa00de168ee1cbfa06a5e8ce992ae880218c05641a9"
+checksum = "81897269eb88949825a9add5a33fb4456ba6a39811e0909172f21c841457d347"
 dependencies = [
  "byteorder",
  "dynasm",
- "memmap2 0.5.10",
-]
-
-[[package]]
-name = "edge-schema"
-version = "0.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "183ddfb52c2441be9d8c3c870632135980ba98e0c4f688da11bcbebb4e26f128"
-dependencies = [
- "anyhow",
- "bytesize",
- "once_cell",
- "parking_lot 0.12.3",
- "rand_chacha",
- "rand_core",
- "schemars",
- "serde",
- "serde_json",
- "serde_path_to_error",
- "serde_yaml 0.8.26",
- "sparx",
- "time 0.3.36",
- "url",
- "uuid",
- "wcgi-host 0.1.2",
-]
-
-[[package]]
-name = "edge-schema"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0966f1fd49610cc67a835124e6fb4d00a36104e1aa34383c5ef5a265ca00ea2a"
-dependencies = [
- "anyhow",
- "bytesize",
- "once_cell",
- "parking_lot 0.12.3",
- "rand_chacha",
- "rand_core",
- "schemars",
- "serde",
- "serde_json",
- "serde_path_to_error",
- "serde_yaml 0.8.26",
- "sparx",
- "time 0.3.36",
- "url",
- "uuid",
- "wcgi-host 0.1.2",
-]
-
-[[package]]
-name = "edge-util"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60d06780ae676369e0a9ac2c75f7d1a6d22e157ef5b10cfeda0ee6a465cf7337"
-dependencies = [
- "edge-schema 0.0.3",
- "http 0.2.12",
- "serde",
- "wasmparser 0.121.2",
+ "fnv",
+ "memmap2 0.9.8",
 ]
 
 [[package]]
 name = "educe"
-version = "0.4.23"
+version = "0.5.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f0042ff8246a363dbe77d2ceedb073339e85a804b9a47636c6e016a9a32c05f"
+checksum = "e4bd92664bf78c4d3dba9b7cdafce6fa15b13ed3ed16175218196942e99168a8"
 dependencies = [
  "enum-ordinalize",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.106",
 ]
 
 [[package]]
 name = "either"
-version = "1.13.0"
+version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
 
 [[package]]
 name = "encode_unicode"
-version = "0.3.6"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f"
+checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
 
 [[package]]
 name = "enum-iterator"
@@ -1607,43 +1688,75 @@ dependencies = [
 
 [[package]]
 name = "enum-ordinalize"
-version = "3.1.15"
+version = "4.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bf1fa3f06bbff1ea5b1a9c7b14aa992a39657db60a2759457328d7e058f49ee"
+checksum = "fea0dcfa4e54eeb516fe454635a95753ddd39acda650ce703031c6973e315dd5"
+dependencies = [
+ "enum-ordinalize-derive",
+]
+
+[[package]]
+name = "enum-ordinalize-derive"
+version = "4.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d28318a75d4aead5c4db25382e8ef717932d0346600cacae6357eb5941bc5ff"
 dependencies = [
- "num-bigint",
- "num-traits",
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
 [[package]]
 name = "enumset"
-version = "1.1.5"
+version = "1.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d07a4b049558765cef5f0c1a273c3fc57084d768b44d2f98127aef4cceb17293"
+checksum = "25b07a8dfbbbfc0064c0a6bdf9edcf966de6b1c33ce344bdeca3b41615452634"
 dependencies = [
  "enumset_derive",
 ]
 
 [[package]]
 name = "enumset_derive"
-version = "0.10.0"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59c3b24c345d8c314966bdc1832f6c2635bfcce8e7cf363bd115987bba2ee242"
+checksum = "f43e744e4ea338060faee68ed933e46e722fb7f3617e722a5772d7e856d8b3ce"
 dependencies = [
- "darling 0.20.10",
+ "darling 0.21.3",
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
+]
+
+[[package]]
+name = "env_filter"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "186e05a59d4c50738528153b83b0b0194d3a29507dfec16eccd4b342903397d0"
+dependencies = [
+ "log",
+]
+
+[[package]]
+name = "env_home"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7f84e12ccf0a7ddc17a6c41c93326024c42920d7ee630d04950e6926645c0fe"
+
+[[package]]
+name = "env_logger"
+version = "0.11.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c863f0904021b108aa8b2f55046443e6b1ebde8fd4a15c399893aae4fa069f"
+dependencies = [
+ "env_filter",
+ "log",
 ]
 
 [[package]]
 name = "equivalent"
-version = "1.0.1"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
 name = "erased-serde"
@@ -1656,31 +1769,46 @@ dependencies = [
 
 [[package]]
 name = "errno"
-version = "0.3.9"
+version = "0.3.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "fallible-iterator"
-version = "0.2.0"
+name = "event-listener"
+version = "5.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"
+checksum = "e13b66accf52311f30a0db42147dadea9850cb48cd070028831ae5f5d4b856ab"
+dependencies = [
+ "concurrent-queue",
+ "parking",
+ "pin-project-lite",
+]
 
 [[package]]
-name = "fallible-streaming-iterator"
-version = "0.1.9"
+name = "event-listener-strategy"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
+dependencies = [
+ "event-listener",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "fallible-iterator"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
+checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
 
 [[package]]
 name = "fastrand"
-version = "2.1.0"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fc0510504f03c51ada170672ac806f1f105a88aa97a5281117e1ddc3368e51a"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
 [[package]]
 name = "fern"
@@ -1689,7 +1817,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9f0c14694cbd524c8720dd69b0e3179344f04ebb5f90f2e4a440c6ea3b2f1ee"
 dependencies = [
  "colored 1.9.4",
- "log 0.4.22",
+ "log",
 ]
 
 [[package]]
@@ -1699,32 +1827,38 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "38e2275cc4e4fc009b0669731a1e5ab7ebf11f469eaede2bab9309a5b4d6057f"
 dependencies = [
  "memoffset 0.9.1",
- "rustc_version 0.4.0",
+ "rustc_version 0.4.1",
 ]
 
 [[package]]
 name = "filetime"
-version = "0.2.23"
+version = "0.2.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ee447700ac8aa0b2f2bd7bc4462ad686ba06baa6727ac149a2d6277f0d240fd"
+checksum = "bc0505cd1b6fa6580283f6bdf70a73fcf4aba1184038c90902b92b3dd0df63ed"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
  "libc",
- "redox_syscall 0.4.1",
- "windows-sys 0.52.0",
+ "libredox",
+ "windows-sys 0.60.2",
 ]
 
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0399f9d26e5191ce32c498bebd31e7a3ceabc2745f0ac54af3f335126c3f24b3"
+
 [[package]]
 name = "fixedbitset"
-version = "0.4.2"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
+checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
 
 [[package]]
 name = "flate2"
-version = "1.0.30"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f54427cfd1c7829e2a139fcefea601bf088ebca651d2bf53ebc600eac295dae"
+checksum = "dc5a4e564e38c699f2880d3fda590bedc2e69f3f84cd48b457bd892ce61d0aa9"
 dependencies = [
  "crc32fast",
  "miniz_oxide",
@@ -1739,6 +1873,15 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "float-cmp"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b09cf3155332e944990140d967ff5eceb70df778b34f77d8075db46e4704e6d8"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "fnv"
 version = "1.0.7"
@@ -1762,13 +1905,22 @@ checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
 
 [[package]]
 name = "form_urlencoded"
-version = "1.2.1"
+version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
 dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "fs-err"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88a41f105fe1d5b6b34b2055e3dc59bb79b46b48b2040b9e6c7b4b5de097aa41"
+dependencies = [
+ "autocfg",
+]
+
 [[package]]
 name = "fs_extra"
 version = "1.3.0"
@@ -1776,51 +1928,25 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
 
 [[package]]
-name = "fuchsia-zircon"
-version = "0.3.3"
+name = "fuser"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
+checksum = "2e697f6f62c20b6fad1ba0f84ae909f25971cf16e735273524e3977c94604cf8"
 dependencies = [
- "bitflags 1.3.2",
- "fuchsia-zircon-sys",
+ "libc",
+ "log",
+ "memchr",
+ "page_size",
+ "pkg-config",
+ "smallvec",
+ "zerocopy 0.7.35",
 ]
 
 [[package]]
-name = "fuchsia-zircon-sys"
-version = "0.3.3"
+name = "futures"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
-
-[[package]]
-name = "funty"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
-
-[[package]]
-name = "fuse"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80e57070510966bfef93662a81cb8aa2b1c7db0964354fa9921434f04b9e8660"
-dependencies = [
- "libc",
- "log 0.3.9",
- "pkg-config",
- "thread-scoped",
- "time 0.1.45",
-]
-
-[[package]]
-name = "futures"
-version = "0.1.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a471a38ef8ed83cd6e40aa59c1ffe17db6855c18e3604d9c4ed8c08ebc28678"
-
-[[package]]
-name = "futures"
-version = "0.3.30"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0"
+checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -1833,9 +1959,9 @@ dependencies = [
 
 [[package]]
 name = "futures-channel"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78"
+checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
 dependencies = [
  "futures-core",
  "futures-sink",
@@ -1843,15 +1969,15 @@ dependencies = [
 
 [[package]]
 name = "futures-core"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"
+checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
 
 [[package]]
 name = "futures-executor"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d"
+checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
 dependencies = [
  "futures-core",
  "futures-task",
@@ -1860,38 +1986,57 @@ dependencies = [
 
 [[package]]
 name = "futures-io"
-version = "0.3.30"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
+
+[[package]]
+name = "futures-lite"
+version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1"
+checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
+dependencies = [
+ "fastrand",
+ "futures-core",
+ "futures-io",
+ "parking",
+ "pin-project-lite",
+]
 
 [[package]]
 name = "futures-macro"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
 [[package]]
 name = "futures-sink"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5"
+checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
 
 [[package]]
 name = "futures-task"
-version = "0.3.30"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
+
+[[package]]
+name = "futures-timer"
+version = "3.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004"
+checksum = "f288b0a4f20f9a56b5d1da57e2227c661b7b16168e2f72365f57b63326e29b24"
 
 [[package]]
 name = "futures-util"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48"
+checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -1905,15 +2050,6 @@ dependencies = [
  "slab",
 ]
 
-[[package]]
-name = "fxhash"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"
-dependencies = [
- "byteorder",
-]
-
 [[package]]
 name = "generic-array"
 version = "0.14.7"
@@ -1926,146 +2062,115 @@ dependencies = [
 
 [[package]]
 name = "getopts"
-version = "0.2.21"
+version = "0.2.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14dbbfd5c71d70241ecf9e6f13737f7b5ce823821063188d7e46c41d371eebd5"
+checksum = "cfe4fbac503b8d1f88e6676011885f34b7174f46e59956bba534ba83abded4df"
 dependencies = [
- "unicode-width",
+ "unicode-width 0.2.2",
 ]
 
 [[package]]
 name = "getrandom"
-version = "0.2.15"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "wasi 0.11.1+wasi-snapshot-preview1",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
  "js-sys",
  "libc",
- "wasi 0.11.0+wasi-snapshot-preview1",
+ "r-efi",
+ "wasi 0.14.7+wasi-0.2.4",
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "ghost"
-version = "0.1.17"
+version = "0.1.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0e085ded9f1267c32176b40921b9754c474f7dd96f7e808d4a982e48aa1e854"
+checksum = "d1323e4e10ffd5d48a21ea37f8d4e3b15dd841121d1301a86122fa0984bedf0a"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
 [[package]]
 name = "gimli"
-version = "0.26.2"
+version = "0.28.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22030e2c5a68ec659fde1e949a745124b48e6fa8b045b7ed5bd1fe4ccc5c4e5d"
+checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
 dependencies = [
  "fallible-iterator",
- "indexmap 1.9.3",
+ "indexmap 2.11.4",
  "stable_deref_trait",
 ]
 
 [[package]]
 name = "gimli"
-version = "0.29.0"
+version = "0.32.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd"
+checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
 
 [[package]]
 name = "glob"
-version = "0.3.1"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
 
 [[package]]
 name = "globset"
-version = "0.4.14"
+version = "0.4.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57da3b9b5b85bd66f31093f8c408b90a74431672542466497dcbdfdc02034be1"
+checksum = "54a1028dfc5f5df5da8a56a73e6c153c9a9708ec57232470703592a3f18e49f5"
 dependencies = [
  "aho-corasick",
- "bstr 1.9.1",
- "log 0.4.22",
- "regex-automata 0.4.7",
- "regex-syntax 0.8.4",
-]
-
-[[package]]
-name = "graphql-introspection-query"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f2a4732cf5140bd6c082434494f785a19cfb566ab07d1382c3671f5812fed6d"
-dependencies = [
- "serde",
+ "bstr 1.12.0",
+ "log",
+ "regex-automata 0.4.11",
+ "regex-syntax",
 ]
 
 [[package]]
-name = "graphql-parser"
-version = "0.4.0"
+name = "goblin"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2ebc8013b4426d5b81a4364c419a95ed0b404af2b82e2457de52d9348f0e474"
+checksum = "1b363a30c165f666402fe6a3024d3bec7ebc898f96a4a23bd1c99f8dbf3f4f47"
 dependencies = [
- "combine",
- "thiserror",
+ "log",
+ "plain",
+ "scroll",
 ]
 
 [[package]]
 name = "graphql-ws-client"
-version = "0.8.2"
+version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db7802310624d21a55797a3bc442dbe405424e9b2c967f86fb415634976f9a97"
+checksum = "1aa2e818b9e62654f2039d524c92a19495fcc2b0139ffc0354956865b3c7e939"
 dependencies = [
- "async-trait",
- "futures 0.3.30",
- "graphql_client",
- "log 0.4.22",
+ "async-channel",
+ "cynic",
+ "futures-lite",
+ "futures-sink",
+ "futures-timer",
+ "log",
  "pin-project",
  "serde",
  "serde_json",
- "thiserror",
- "tungstenite",
-]
-
-[[package]]
-name = "graphql_client"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09cdf7b487d864c2939b23902291a5041bc4a84418268f25fda1c8d4e15ad8fa"
-dependencies = [
- "graphql_query_derive",
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "graphql_client_codegen"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a40f793251171991c4eb75bd84bc640afa8b68ff6907bc89d3b712a22f700506"
-dependencies = [
- "graphql-introspection-query",
- "graphql-parser",
- "heck 0.4.1",
- "lazy_static",
- "proc-macro2",
- "quote",
- "serde",
- "serde_json",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "graphql_query_derive"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00bda454f3d313f909298f626115092d348bc231025699f557b27e248475f48c"
-dependencies = [
- "graphql_client_codegen",
- "proc-macro2",
- "syn 1.0.109",
+ "thiserror 1.0.69",
+ "tungstenite 0.24.0",
 ]
 
 [[package]]
@@ -2096,11 +2201,11 @@ checksum = "1b43ede17f21864e81be2fa654110bf1e793774238d86ef8555c37e6519c0403"
 
 [[package]]
 name = "half"
-version = "2.4.1"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6dd08c532ae367adf81c312a4580bc67f1d0fe8bc9c460520283f4c0ff277888"
+checksum = "459196ed295495a68f7d7fe1d84f6c4b7ff0e21fe3017b2f283c6fac3ad803c9"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
  "crunchy",
 ]
 
@@ -2110,7 +2215,7 @@ version = "3.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4498fc115fa7d34de968184e473529abb40eeb6be8bc5f7faba3d08c316cb3e3"
 dependencies = [
- "log 0.4.22",
+ "log",
  "pest",
  "pest_derive",
  "quick-error",
@@ -2126,9 +2231,9 @@ checksum = "a6fce2283849822530a18d7d8eeb1719ac65a27cfb6649c0dc8dfd2d2cc5edfb"
 
 [[package]]
 name = "hash32"
-version = "0.2.1"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67"
+checksum = "47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606"
 dependencies = [
  "byteorder",
 ]
@@ -2147,8 +2252,14 @@ name = "hashbrown"
 version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+
+[[package]]
+name = "hashbrown"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e"
 dependencies = [
- "ahash 0.7.8",
+ "ahash 0.8.12",
 ]
 
 [[package]]
@@ -2157,29 +2268,28 @@ version = "0.14.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 dependencies = [
- "ahash 0.8.11",
- "allocator-api2",
+ "ahash 0.8.12",
 ]
 
 [[package]]
-name = "hashlink"
-version = "0.8.4"
+name = "hashbrown"
+version = "0.15.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8094feaf31ff591f651a2664fb9cfd92bba7a60ce3197265e9482ebe753c8f7"
-dependencies = [
- "hashbrown 0.14.5",
-]
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+
+[[package]]
+name = "hashbrown"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5419bdc4f6a9207fbeba6d11b604d481addf78ecd10c11ad51e76c2f6482748d"
 
 [[package]]
 name = "heapless"
-version = "0.7.17"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f"
+checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad"
 dependencies = [
- "atomic-polyfill",
  "hash32",
- "rustc_version 0.4.0",
- "spin",
  "stable_deref_trait",
 ]
 
@@ -2198,17 +2308,11 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
 
-[[package]]
-name = "heck"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
-
 [[package]]
 name = "hermit-abi"
-version = "0.3.9"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
 
 [[package]]
 name = "hex"
@@ -2217,32 +2321,30 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
 [[package]]
-name = "hmac"
-version = "0.12.1"
+name = "hexdump"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+checksum = "cf31ab66ed8145a1c7427bd8e9b42a6131bd74ccf444f69b9e620c2e73ded832"
 dependencies = [
- "digest",
+ "arrayvec 0.5.2",
 ]
 
 [[package]]
-name = "http"
-version = "0.2.12"
+name = "hmac"
+version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
 dependencies = [
- "bytes 1.6.1",
- "fnv",
- "itoa",
+ "digest",
 ]
 
 [[package]]
 name = "http"
-version = "1.1.0"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21b9ddb458710bc376481b842f5da65cdf31522de232c1ca8146abce2a358258"
+checksum = "f4a85d31aea989eead29a3aaf9e1115a180df8282431156e533de47660892565"
 dependencies = [
- "bytes 1.6.1",
+ "bytes",
  "fnv",
  "itoa",
 ]
@@ -2253,48 +2355,38 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
 dependencies = [
- "bytes 1.6.1",
- "http 1.1.0",
+ "bytes",
+ "http",
 ]
 
 [[package]]
 name = "http-body-util"
-version = "0.1.2"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "793429d76616a256bcb62c2a2ec2bed781c8307e797e2598c50010f2bee2544f"
+checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
 dependencies = [
- "bytes 1.6.1",
- "futures-util",
- "http 1.1.0",
+ "bytes",
+ "futures-core",
+ "http",
  "http-body",
  "pin-project-lite",
 ]
 
-[[package]]
-name = "http-serde"
-version = "1.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f560b665ad9f1572cfcaf034f7fb84338a7ce945216d64a90fd81f046a3caee"
-dependencies = [
- "http 0.2.12",
- "serde",
-]
-
 [[package]]
 name = "http-serde"
 version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0f056c8559e3757392c8d091e796416e4649d8e49e88b8d76df6c002f05027fd"
 dependencies = [
- "http 1.1.0",
+ "http",
  "serde",
 ]
 
 [[package]]
 name = "httparse"
-version = "1.9.4"
+version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fcc0b4a115bf80b728eb8ea024ad5bd707b615bfed49e0665b6e0f86fd082d9"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
 
 [[package]]
 name = "httpdate"
@@ -2304,46 +2396,47 @@ checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 
 [[package]]
 name = "humantime"
-version = "2.1.0"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+checksum = "135b12329e5e3ce057a9f972339ea52bc954fe1e9358ef27f95e89716fbc5424"
 
 [[package]]
 name = "hyper"
-version = "1.4.1"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50dfd22e0e76d0f662d429a5f80fcaf3855009297eab6a0a9f8543834744ba05"
+checksum = "eb3aa54a13a0dfe7fbe3a59e0c76093041720fdc77b110cc0fc260fafb4dc51e"
 dependencies = [
- "bytes 1.6.1",
+ "atomic-waker",
+ "bytes",
  "futures-channel",
- "futures-util",
- "http 1.1.0",
+ "futures-core",
+ "http",
  "http-body",
  "httparse",
  "httpdate",
  "itoa",
  "pin-project-lite",
- "smallvec 1.13.2",
- "tokio 1.38.1",
+ "pin-utils",
+ "smallvec",
+ "tokio",
  "want",
 ]
 
 [[package]]
 name = "hyper-rustls"
-version = "0.27.2"
+version = "0.27.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ee4be2c948921a1a5320b629c4193916ed787a7f7f293fd3f7f5a6c9de74155"
+checksum = "e3c93eb611681b207e1fe55d5a71ecf91572ec8a6705cdb6857f7d8d5242cf58"
 dependencies = [
- "futures-util",
- "http 1.1.0",
+ "http",
  "hyper",
  "hyper-util",
- "rustls 0.23.11",
+ "rustls",
  "rustls-pki-types",
- "tokio 1.38.1",
- "tokio-rustls 0.26.0",
+ "tokio",
+ "tokio-rustls",
  "tower-service",
- "webpki-roots",
+ "webpki-roots 1.0.2",
 ]
 
 [[package]]
@@ -2352,12 +2445,12 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0"
 dependencies = [
- "bytes 1.6.1",
+ "bytes",
  "http-body-util",
  "hyper",
  "hyper-util",
  "native-tls",
- "tokio 1.38.1",
+ "tokio",
  "tokio-native-tls",
  "tower-service",
 ]
@@ -2372,41 +2465,46 @@ dependencies = [
  "hyper",
  "hyper-util",
  "pin-project-lite",
- "tokio 1.38.1",
- "tokio-tungstenite",
- "tungstenite",
+ "tokio",
+ "tokio-tungstenite 0.21.0",
+ "tungstenite 0.21.0",
 ]
 
 [[package]]
 name = "hyper-util"
-version = "0.1.6"
+version = "0.1.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ab92f4f49ee4fb4f997c784b7a2e0fa70050211e0b6a287f898c3c9785ca956"
+checksum = "3c6995591a8f1380fcb4ba966a252a4b29188d51d2b89e3a252f5305be65aea8"
 dependencies = [
- "bytes 1.6.1",
+ "base64",
+ "bytes",
  "futures-channel",
+ "futures-core",
  "futures-util",
- "http 1.1.0",
+ "http",
  "http-body",
  "hyper",
+ "ipnet",
+ "libc",
+ "percent-encoding",
  "pin-project-lite",
- "socket2 0.5.7",
- "tokio 1.38.1",
- "tower",
+ "socket2 0.6.0",
+ "tokio",
  "tower-service",
  "tracing",
 ]
 
 [[package]]
 name = "iana-time-zone"
-version = "0.1.60"
+version = "0.1.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
+checksum = "33e57f83510bb73707521ebaffa789ec8caf86f9657cad665b092b581d40e9fb"
 dependencies = [
  "android_system_properties",
  "core-foundation-sys",
  "iana-time-zone-haiku",
  "js-sys",
+ "log",
  "wasm-bindgen",
  "windows-core",
 ]
@@ -2420,6 +2518,92 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "icu_collections"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3"
+
+[[package]]
+name = "icu_properties"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "potential_utf",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632"
+
+[[package]]
+name = "icu_provider"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "stable_deref_trait",
+ "tinystr",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
 [[package]]
 name = "id-arena"
 version = "2.2.1"
@@ -2434,36 +2618,36 @@ checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
 
 [[package]]
 name = "idna"
-version = "0.2.3"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
 dependencies = [
- "matches",
- "unicode-bidi",
- "unicode-normalization",
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
 ]
 
 [[package]]
-name = "idna"
-version = "0.5.0"
+name = "idna_adapter"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
 dependencies = [
- "unicode-bidi",
- "unicode-normalization",
+ "icu_normalizer",
+ "icu_properties",
 ]
 
 [[package]]
 name = "ignore"
-version = "0.4.22"
+version = "0.4.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b46810df39e66e925525d6e38ce1e7f6e1d208f72dc39757880fcb66e2c58af1"
+checksum = "6d89fd380afde86567dfba715db065673989d6253f42b88179abd3eae47bda4b"
 dependencies = [
- "crossbeam-deque 0.8.5",
+ "crossbeam-deque",
  "globset",
- "log 0.4.22",
+ "log",
  "memchr",
- "regex-automata 0.4.7",
+ "regex-automata 0.4.11",
  "same-file",
  "walkdir",
  "winapi-util",
@@ -2477,63 +2661,63 @@ checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
 dependencies = [
  "autocfg",
  "hashbrown 0.12.3",
- "serde",
 ]
 
 [[package]]
 name = "indexmap"
-version = "2.2.6"
+version = "2.11.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
+checksum = "4b0f83760fb341a774ed326568e19f5a863af4a952def8c39f9ab92fd95b88e5"
 dependencies = [
  "equivalent",
- "hashbrown 0.14.5",
+ "hashbrown 0.16.0",
  "serde",
+ "serde_core",
 ]
 
 [[package]]
 name = "indicatif"
-version = "0.17.8"
+version = "0.17.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "763a5a8f45087d6bcea4222e7b72c291a054edf80e4ef6efd2a4979878c7bea3"
+checksum = "183b3088984b400f4cfac3620d5e076c84da5364016b4f49473de574b2586235"
 dependencies = [
  "console",
- "instant",
  "number_prefix",
  "portable-atomic",
- "unicode-width",
+ "unicode-width 0.2.2",
+ "web-time",
 ]
 
 [[package]]
 name = "inkwell"
-version = "0.1.1"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbac11e485159a525867fb7e6aa61981453e6a72f625fde6a4ab3047b0c6dec9"
+checksum = "40fb405537710d51f6bdbc8471365ddd4cd6d3a3c3ad6e0c8291691031ba94b2"
 dependencies = [
  "either",
  "inkwell_internals",
  "libc",
  "llvm-sys",
  "once_cell",
- "parking_lot 0.12.3",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "inkwell_internals"
-version = "0.7.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87d00c17e264ce02be5bc23d7bff959188ec7137beddd06b8b6b05a7c680ea85"
+checksum = "9dd28cfd4cfba665d47d31c08a6ba637eed16770abca2eccbbc3ca831fef1e44"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.106",
 ]
 
 [[package]]
 name = "inline-c"
-version = "0.1.7"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "340dd3d6102fa919bd20987024a6d84954c36ec691ac1efea37742ee983c8dd5"
+checksum = "ced39871c8d450695c9ddf7999e06da4c05ba3135aba2407837b3e20a3bb6aa0"
 dependencies = [
  "assert_cmd 1.0.8",
  "cc",
@@ -2548,9 +2732,9 @@ dependencies = [
 
 [[package]]
 name = "inline-c-macro"
-version = "0.1.5"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17f5621ec7adacda881d7c2826c064f5c29c72fd44333f97df61b458a583ae15"
+checksum = "d9b2cedf6123f450eadb06a82fdcafc6d492af3ac9256afcb954ca307d6339da"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2559,42 +2743,33 @@ dependencies = [
 
 [[package]]
 name = "inout"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
 dependencies = [
  "generic-array",
 ]
 
 [[package]]
 name = "insta"
-version = "1.39.0"
+version = "1.43.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "810ae6042d48e2c9e9215043563a58a80b877bc863228a74cf10c49d4620a6f5"
+checksum = "46fdb647ebde000f43b5b53f773c30cf9b0cb4300453208713fa38b2c70935a0"
 dependencies = [
  "console",
- "lazy_static",
- "linked-hash-map",
+ "once_cell",
+ "regex",
  "serde",
  "similar",
 ]
 
-[[package]]
-name = "instant"
-version = "0.1.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0242819d153cba4b4b05a5a8f2a7e9bbf97b6055b2a002b395c96b5ff3c0222"
-dependencies = [
- "cfg-if 1.0.0",
-]
-
 [[package]]
 name = "interfaces"
 version = "0.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bb6250a98af259a26fd5a4a6081fccea9ac116e4c3178acf4aeb86d32d2b7715"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.9.4",
  "cc",
  "handlebars",
  "lazy_static",
@@ -2615,36 +2790,57 @@ dependencies = [
 ]
 
 [[package]]
-name = "iovec"
-version = "0.1.4"
+name = "io-uring"
+version = "0.7.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e"
+checksum = "046fa2d4d00aea763528b4950358d0ead425372445dc8ff86312b3c69ff7727b"
 dependencies = [
+ "bitflags 2.9.4",
+ "cfg-if",
  "libc",
 ]
 
 [[package]]
 name = "ipnet"
-version = "2.9.0"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130"
+
+[[package]]
+name = "iprange"
+version = "0.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37209be0ad225457e63814401415e748e2453a5297f9b637338f5fb8afa4ec00"
+dependencies = [
+ "ipnet",
+]
+
+[[package]]
+name = "iri-string"
+version = "0.7.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3"
+checksum = "dbc5ebe9c3a1a7a5127f920a418f7585e9e758e911d0466ed004f393b0e380b2"
+dependencies = [
+ "memchr",
+ "serde",
+]
 
 [[package]]
 name = "is-terminal"
-version = "0.4.12"
+version = "0.4.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f23ff5ef2b80d608d61efee834934d862cd92461afc0560dedf493e4c033738b"
+checksum = "e04d7f318608d35d4b61ddd75cbdaee86b023ebe2bd5a66ee0915f0bf93095a9"
 dependencies = [
  "hermit-abi",
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "is_terminal_polyfill"
-version = "1.70.0"
+version = "1.70.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8478577c03552c21db0e2724ffb8986a5ce7af88107e6be5d2ee6e158c12800"
+checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
 
 [[package]]
 name = "itertools"
@@ -2664,47 +2860,48 @@ dependencies = [
  "either",
 ]
 
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
-version = "1.0.11"
+version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
+checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "jobserver"
-version = "0.1.31"
+version = "0.1.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2b099aaa34a9751c5bf0878add70444e1ed2dd73f347be99003d4577277de6e"
+checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
 dependencies = [
+ "getrandom 0.3.3",
  "libc",
 ]
 
 [[package]]
 name = "js-sys"
-version = "0.3.69"
+version = "0.3.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
+checksum = "ec48937a97411dcb524a265206ccd4c90bb711fca92b2792c407f268825b9305"
 dependencies = [
+ "once_cell",
  "wasm-bindgen",
 ]
 
-[[package]]
-name = "kernel32-sys"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
-dependencies = [
- "winapi 0.2.8",
- "winapi-build",
-]
-
 [[package]]
 name = "lalrpop-util"
-version = "0.20.2"
+version = "0.22.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "507460a910eb7b32ee961886ff48539633b788a36b65692b95f225b844c82553"
+checksum = "b5baa5e9ff84f1aefd264e6869907646538a52147a755d494517a8007fb48733"
 dependencies = [
- "regex-automata 0.4.7",
+ "rustversion",
 ]
 
 [[package]]
@@ -2720,17 +2917,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"
 
 [[package]]
-name = "lexical-core"
-version = "0.7.6"
+name = "leb128fmt"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6607c62aa161d23d17a9072cc5da0be67cdfc89d3afb1e8d9c842bebc2525ffe"
-dependencies = [
- "arrayvec 0.5.2",
- "bitflags 1.3.2",
- "cfg-if 1.0.0",
- "ryu",
- "static_assertions",
-]
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
 
 [[package]]
 name = "lexical-sort"
@@ -2743,42 +2933,53 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.155"
+version = "0.2.176"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+checksum = "58f929b4d672ea937a23a1ab494143d968337a5f47e56d0815df1e0890ddf174"
 
 [[package]]
 name = "libfuzzer-sys"
-version = "0.4.7"
+version = "0.4.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a96cfd5557eb82f2b83fed4955246c988d331975a002961b07c81584d107e7f7"
+checksum = "5037190e1f70cbeef565bd267599242926f724d3b8a9f510fd7e0b540cfa4404"
 dependencies = [
  "arbitrary",
  "cc",
- "once_cell",
 ]
 
 [[package]]
-name = "libredox"
-version = "0.1.3"
+name = "libloading"
+version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
+checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
 dependencies = [
- "bitflags 2.6.0",
- "libc",
+ "cfg-if",
+ "windows-link",
 ]
 
 [[package]]
-name = "libsqlite3-sys"
-version = "0.25.2"
+name = "libm"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
+
+[[package]]
+name = "libredox"
+version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29f835d03d717946d28b1d1ed632eb6f0e24a299388ee623d0c23118d3e8a7fa"
+checksum = "416f7e718bdb06000964960ffa43b4335ad4012ae8b99060261aa4a8088d5ccb"
 dependencies = [
- "cc",
- "pkg-config",
- "vcpkg",
+ "bitflags 2.9.4",
+ "libc",
+ "redox_syscall",
 ]
 
+[[package]]
+name = "libunwind"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c6639b70a7ce854b79c70d7e83f16b5dc0137cc914f3d7d03803b513ecc67ac"
+
 [[package]]
 name = "linked-hash-map"
 version = "0.5.6"
@@ -2787,157 +2988,193 @@ checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
 
 [[package]]
 name = "linked_hash_set"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47186c6da4d81ca383c7c47c1bfc80f4b95f4720514d860a5407aaf4233f9588"
+checksum = "bae85b5be22d9843c80e5fc80e9b64c8a3b1f98f867c709956eca3efff4e92e2"
 dependencies = [
  "linked-hash-map",
 ]
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.4.14"
+version = "0.4.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
+
+[[package]]
+name = "litemap"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
+checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956"
 
 [[package]]
 name = "litrs"
-version = "0.4.1"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4ce301924b7887e9d637144fdade93f9dfff9b60981d4ac161db09720d39aa5"
+checksum = "f5e54036fe321fd421e10d732f155734c4e4afd610dd556d9a82833ab3ee0bed"
 
 [[package]]
 name = "llvm-sys"
-version = "150.2.0"
+version = "180.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88d6891afbe90a8be244f769dfe1db0b3c4880b8c44b12a6d0f7ab848d89b26d"
+checksum = "778fa5fa02e32728e718f11eec147e6f134137399ab02fd2c13d32476337affa"
 dependencies = [
+ "anyhow",
  "cc",
  "lazy_static",
  "libc",
- "regex",
- "semver 1.0.23",
-]
-
-[[package]]
-name = "lock_api"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4da24a77a3d8a6d4862d95f72e6fdb9c09a643ecdb402d754004a557f2bec75"
-dependencies = [
- "scopeguard",
+ "regex-lite",
+ "semver 1.0.27",
 ]
 
 [[package]]
 name = "lock_api"
-version = "0.4.12"
+version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
 dependencies = [
- "autocfg",
  "scopeguard",
 ]
 
-[[package]]
-name = "lockfree-object-pool"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9374ef4228402d4b7e403e5838cb880d9ee663314b0a900d5a6aabf0c213552e"
-
-[[package]]
-name = "log"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e19e8d5c34a3e0e2223db8e060f9e8264aeeb5c5fc64a4ee9965c062211c024b"
-dependencies = [
- "log 0.4.22",
-]
-
 [[package]]
 name = "log"
-version = "0.4.22"
+version = "0.4.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
+checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
 
 [[package]]
 name = "logos"
-version = "0.14.0"
+version = "0.14.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "161971eb88a0da7ae0c333e1063467c5b5727e7fb6b710b8db4814eade3a42e8"
+checksum = "7251356ef8cb7aec833ddf598c6cb24d17b689d20b993f9d11a3d764e34e6458"
 dependencies = [
  "logos-derive",
 ]
 
 [[package]]
 name = "logos-codegen"
-version = "0.14.0"
+version = "0.14.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e31badd9de5131fdf4921f6473d457e3dd85b11b7f091ceb50e4df7c3eeb12a"
+checksum = "59f80069600c0d66734f5ff52cc42f2dabd6b29d205f333d61fd7832e9e9963f"
 dependencies = [
  "beef",
  "fnv",
  "lazy_static",
  "proc-macro2",
  "quote",
- "regex-syntax 0.8.4",
- "syn 2.0.72",
+ "regex-syntax",
+ "syn 2.0.106",
 ]
 
 [[package]]
 name = "logos-derive"
-version = "0.14.0"
+version = "0.14.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c2a69b3eb68d5bd595107c9ee58d7e07fe2bb5e360cc85b0f084dedac80de0a"
+checksum = "24fb722b06a9dc12adb0963ed585f19fc61dc5413e6a9be9422ef92c091e731d"
 dependencies = [
  "logos-codegen",
 ]
 
+[[package]]
+name = "loupe"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4de4e09ccbef442225e81339e930ed93dc339d4f1b2eaf479f89590ebeb9bf13"
+dependencies = [
+ "indexmap 2.11.4",
+ "loupe-derive",
+ "rustversion",
+]
+
+[[package]]
+name = "loupe-derive"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca8362a975c18ea799abfcb1902140370acd73d239f8c2f74d6e2c5f6a30929f"
+dependencies = [
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "lru-slab"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154"
+
 [[package]]
 name = "lz4_flex"
-version = "0.11.3"
+version = "0.11.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75761162ae2b0e580d7e7c390558127e5f01b4194debd6221fd8c207fc80e3f5"
+checksum = "08ab2867e3eeeca90e844d1940eab391c9dc5228783db2ed999acbc0a9ed375a"
 dependencies = [
- "twox-hash",
+ "twox-hash 2.1.2",
 ]
 
 [[package]]
 name = "lzma-rs"
-version = "0.2.0"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aba8ecb0450dfabce4ad72085eed0a75dffe8f21f7ada05638564ea9db2d7fb1"
+checksum = "297e814c836ae64db86b36cf2a557ba54368d03f6afcd7d947c266692f71115e"
 dependencies = [
  "byteorder",
  "crc",
 ]
 
+[[package]]
+name = "lzma-sys"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fda04ab3764e6cde78b9974eec4f779acaba7c4e84b36eca3cf77c581b85d27"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+]
+
 [[package]]
 name = "mac_address"
-version = "1.1.7"
+version = "1.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8836fae9d0d4be2c8b4efcdd79e828a2faa058a90d005abf42f91cac5493a08e"
+checksum = "c0aeb26bf5e836cc1c341c8106051b573f1766dfa05aa87f0b98be5e51b02303"
 dependencies = [
- "nix 0.28.0",
- "winapi 0.3.9",
+ "nix 0.29.0",
+ "winapi",
 ]
 
 [[package]]
 name = "mach2"
-version = "0.4.2"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19b955cdeb2a02b9117f121ce63aa52d08ade45de53e48fe6a38b39c10f6f709"
+checksum = "d640282b302c0bb0a2a8e0233ead9035e3bed871f0b7e81fe4a1ec829765db44"
 dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "macho-unwind-info"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb4bdc8b0ce69932332cf76d24af69c3a155242af95c226b2ab6c2e371ed1149"
+dependencies = [
+ "thiserror 2.0.17",
+ "zerocopy 0.8.27",
+ "zerocopy-derive 0.8.27",
+]
+
 [[package]]
 name = "macro-wasmer-universal-test"
-version = "4.3.7"
+version = "6.1.0"
 dependencies = [
  "proc-macro2",
- "proc-quote",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.106",
 ]
 
 [[package]]
@@ -2948,25 +3185,13 @@ checksum = "0ca88d725a0a943b096803bd34e73a4437208b6077654cc4ecb2947a5f91618d"
 
 [[package]]
 name = "matchers"
-version = "0.1.0"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"
+checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9"
 dependencies = [
- "regex-automata 0.1.10",
+ "regex-automata 0.4.11",
 ]
 
-[[package]]
-name = "matches"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2532096657941c2fea9c289d370a250971c689d4f143798ff67113ec042024a5"
-
-[[package]]
-name = "maybe-uninit"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60302e4db3a61da70c0cb7991976248362f30319e88850c487b9b95bbf059e00"
-
 [[package]]
 name = "md5"
 version = "0.7.0"
@@ -2975,18 +3200,9 @@ checksum = "490cc448043f947bae3cbee9c203358d62dbee0db12107a74be5c30ccfd09771"
 
 [[package]]
 name = "memchr"
-version = "2.7.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
-
-[[package]]
-name = "memmap2"
-version = "0.5.10"
+version = "2.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327"
-dependencies = [
- "libc",
-]
+checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
 
 [[package]]
 name = "memmap2"
@@ -2998,12 +3214,12 @@ dependencies = [
 ]
 
 [[package]]
-name = "memoffset"
-version = "0.5.6"
+name = "memmap2"
+version = "0.9.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "043175f069eda7b85febe4a74abbaeff828d9f8b448515d3151a14a3542811aa"
+checksum = "843a98750cd611cc2965a8213b53b43e715f13c37a9e096c6408e69990961db7"
 dependencies = [
- "autocfg",
+ "libc",
 ]
 
 [[package]]
@@ -3051,122 +3267,101 @@ dependencies = [
 ]
 
 [[package]]
-name = "minisign"
-version = "0.7.6"
+name = "minicov"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4225fad231f4cfb67990de1750bb53f10ff1d5b42b91beb2a49e6ebd36c9ab4a"
+checksum = "f27fe9f1cc3c22e1687f9446c2083c4c5fc7f0bcf1c7a86bdbded14985895b4b"
 dependencies = [
- "getrandom",
- "rpassword",
- "scrypt",
+ "cc",
+ "walkdir",
 ]
 
 [[package]]
-name = "miniz_oxide"
-version = "0.7.4"
+name = "minimal-lexical"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8a240ddb74feaf34a79a7add65a741f3167852fba007066dcac1ca548d89c08"
-dependencies = [
- "adler",
-]
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
 
 [[package]]
-name = "mio"
-version = "0.6.23"
+name = "miniz_oxide"
+version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4afd66f5b91bf2a3bc13fad0e21caedac168ca4c707504e75585648ae80e4cc4"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
 dependencies = [
- "cfg-if 0.1.10",
- "fuchsia-zircon",
- "fuchsia-zircon-sys",
- "iovec",
- "kernel32-sys",
- "libc",
- "log 0.4.22",
- "miow 0.2.2",
- "net2",
- "slab",
- "winapi 0.2.8",
+ "adler2",
+ "simd-adler32",
 ]
 
 [[package]]
 name = "mio"
-version = "0.8.11"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c"
+checksum = "78bed444cc8a2160f01cbcf811ef18cac863ad68ae8ca62092e8db51d51c761c"
 dependencies = [
  "libc",
- "log 0.4.22",
- "wasi 0.11.0+wasi-snapshot-preview1",
- "windows-sys 0.48.0",
+ "log",
+ "wasi 0.11.1+wasi-snapshot-preview1",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
-name = "mio-uds"
-version = "0.6.8"
+name = "miow"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afcb699eb26d4332647cc848492bbc15eafb26f08d0304550d5aa1f612e066f0"
+checksum = "b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21"
 dependencies = [
- "iovec",
- "libc",
- "mio 0.6.23",
+ "winapi",
 ]
 
 [[package]]
-name = "miow"
+name = "more-asserts"
 version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebd808424166322d4a38da87083bfddd3ac4c131334ed55856112eb06d46944d"
-dependencies = [
- "kernel32-sys",
- "net2",
- "winapi 0.2.8",
- "ws2_32-sys",
-]
+checksum = "7843ec2de400bcbc6a6328c958dc38e5359da6e93e72e37bc5246bf1ae776389"
 
 [[package]]
-name = "miow"
-version = "0.3.7"
+name = "multi-stash"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21"
+checksum = "685a9ac4b61f4e728e1d2c6a7844609c16527aeb5e6c865915c08e619c16410f"
+
+[[package]]
+name = "munge"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e17401f259eba956ca16491461b6e8f72913a0a114e39736ce404410f915a0c"
 dependencies = [
- "winapi 0.3.9",
+ "munge_macro",
 ]
 
 [[package]]
-name = "more-asserts"
-version = "0.2.2"
+name = "munge_macro"
+version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7843ec2de400bcbc6a6328c958dc38e5359da6e93e72e37bc5246bf1ae776389"
+checksum = "4568f25ccbd45ab5d5603dc34318c1ec56b117531781260002151b8530a9f931"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
 
 [[package]]
 name = "native-tls"
-version = "0.2.12"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8614eb2c83d59d1c8cc974dd3f920198647674a0a035e1af1fa58707e317466"
+checksum = "87de3442987e9dbec73158d5c715e7ad9072fda936bb03d19d7fa10e00520f0e"
 dependencies = [
  "libc",
- "log 0.4.22",
+ "log",
  "openssl",
  "openssl-probe",
  "openssl-sys",
  "schannel",
- "security-framework",
+ "security-framework 2.11.1",
  "security-framework-sys",
  "tempfile",
 ]
 
-[[package]]
-name = "net2"
-version = "0.2.39"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b13b648036a2339d06de780866fbdfda0dde886de7b3af2ddeba8b14f4ee34ac"
-dependencies = [
- "cfg-if 0.1.10",
- "libc",
- "winapi 0.3.9",
-]
-
 [[package]]
 name = "nix"
 version = "0.26.4"
@@ -3174,7 +3369,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "598beaf3cc6fdd9a5dfb1630c2800c7acd31df7aaf0f565796fba2b53ca1af1b"
 dependencies = [
  "bitflags 1.3.2",
- "cfg-if 1.0.0",
+ "cfg-if",
  "libc",
  "memoffset 0.7.1",
  "pin-utils",
@@ -3182,12 +3377,12 @@ dependencies = [
 
 [[package]]
 name = "nix"
-version = "0.28.0"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab2156c4fce2f8df6c499cc1c763e4394b7482525bf2a9701c9d79d215f519e4"
+checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
 dependencies = [
- "bitflags 2.6.0",
- "cfg-if 1.0.0",
+ "bitflags 2.9.4",
+ "cfg-if",
  "cfg_aliases",
  "libc",
  "memoffset 0.9.1",
@@ -3199,11 +3394,20 @@ version = "5.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08959a387a676302eebf4ddbcbc611da04285579f76f88ee0506c63b1a61dd4b"
 dependencies = [
- "lexical-core",
  "memchr",
  "version_check",
 ]
 
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
 [[package]]
 name = "normalize-line-endings"
 version = "0.3.0"
@@ -3221,22 +3425,11 @@ dependencies = [
 
 [[package]]
 name = "nu-ansi-term"
-version = "0.46.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
-dependencies = [
- "overload",
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "num-bigint"
-version = "0.4.6"
+version = "0.50.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+checksum = "d4a28e057d01f97e61255210fcff094d74ed0466038633e95017f5beb68e4399"
 dependencies = [
- "num-integer",
- "num-traits",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -3245,15 +3438,6 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
 
-[[package]]
-name = "num-integer"
-version = "0.1.46"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
-dependencies = [
- "num-traits",
-]
-
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -3265,9 +3449,9 @@ dependencies = [
 
 [[package]]
 name = "num_cpus"
-version = "1.16.0"
+version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
+checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
 dependencies = [
  "hermit-abi",
  "libc",
@@ -3275,23 +3459,24 @@ dependencies = [
 
 [[package]]
 name = "num_enum"
-version = "0.5.11"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f646caf906c20226733ed5b1374287eb97e3c2a5c227ce668c1f2ce20ae57c9"
+checksum = "a973b4e44ce6cad84ce69d797acf9a044532e4184c4f267913d1b546a0727b7a"
 dependencies = [
  "num_enum_derive",
+ "rustversion",
 ]
 
 [[package]]
 name = "num_enum_derive"
-version = "0.5.11"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcbff9bc912032c62bf65ef1d5aea88983b420f4f839db1e9b0c281a25c9c799"
+checksum = "77e878c846a8abae00dd069496dbe8751b16ac1c3d6bd2a7283a938e8228f90d"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.106",
 ]
 
 [[package]]
@@ -3302,66 +3487,54 @@ checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3"
 
 [[package]]
 name = "object"
-version = "0.28.4"
+version = "0.30.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e42c982f2d955fac81dd7e1d0e1426a7d702acd9c98d19ab01083a6a0328c424"
+checksum = "03b4680b86d9cfafba8fc491dc9b6df26b68cf40e9e6cd73909194759a63c385"
 dependencies = [
+ "flate2",
  "memchr",
 ]
 
 [[package]]
 name = "object"
-version = "0.29.0"
+version = "0.32.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21158b2c33aa6d4561f1c0a6ea283ca92bc54802a93b263e910746d679a7eb53"
+checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
 dependencies = [
  "crc32fast",
- "hashbrown 0.12.3",
- "indexmap 1.9.3",
- "memchr",
-]
-
-[[package]]
-name = "object"
-version = "0.30.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03b4680b86d9cfafba8fc491dc9b6df26b68cf40e9e6cd73909194759a63c385"
-dependencies = [
  "flate2",
+ "hashbrown 0.14.5",
+ "indexmap 2.11.4",
  "memchr",
+ "ruzstd",
 ]
 
 [[package]]
 name = "object"
-version = "0.32.2"
+version = "0.37.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
+checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
 dependencies = [
- "flate2",
  "memchr",
- "ruzstd",
 ]
 
 [[package]]
-name = "object"
-version = "0.36.1"
+name = "once_cell"
+version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "081b846d1d56ddfc18fdf1a922e4f6e07a11768ea1b92dec44e42b72712ccfce"
-dependencies = [
- "memchr",
-]
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
 [[package]]
-name = "once_cell"
-version = "1.19.0"
+name = "once_cell_polyfill"
+version = "1.70.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad"
 
 [[package]]
 name = "oorandom"
-version = "11.1.4"
+version = "11.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b410bbe7e14ab526a0e86877eb47c6996a2bd7746f027ba551028c925390e4e9"
+checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
 
 [[package]]
 name = "opener"
@@ -3369,19 +3542,19 @@ version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6c62dcb6174f9cb326eac248f07e955d5d559c272730b6c03e396b443b562788"
 dependencies = [
- "bstr 1.9.1",
+ "bstr 1.12.0",
  "normpath",
- "winapi 0.3.9",
+ "winapi",
 ]
 
 [[package]]
 name = "openssl"
-version = "0.10.66"
+version = "0.10.73"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9529f4786b70a3e8c61e11179af17ab6188ad8d0ded78c5529441ed39d4bd9c1"
+checksum = "8505734d46c8ab1e19a1dce3aef597ad87dcb4c37e7188231769bd6bd51cebf8"
 dependencies = [
- "bitflags 2.6.0",
- "cfg-if 1.0.0",
+ "bitflags 2.9.4",
+ "cfg-if",
  "foreign-types",
  "libc",
  "once_cell",
@@ -3397,20 +3570,20 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
 [[package]]
 name = "openssl-probe"
-version = "0.1.5"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
+checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
 
 [[package]]
 name = "openssl-sys"
-version = "0.9.103"
+version = "0.9.109"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f9e8deee91df40a943c71b917e5874b951d32a802526c85721ce3b776c929d6"
+checksum = "90096e2e47630d78b7d1c20952dc621f957103f8bc2c8359ec81290d75238571"
 dependencies = [
  "cc",
  "libc",
@@ -3420,9 +3593,9 @@ dependencies = [
 
 [[package]]
 name = "ouroboros"
-version = "0.18.4"
+version = "0.18.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "944fa20996a25aded6b4795c6d63f10014a7a83f8be9828a11860b08c5fc4a67"
+checksum = "1e0f050db9c44b97a94723127e6be766ac5c340c48f2c4bb3ffa11713744be59"
 dependencies = [
  "aliasable",
  "ouroboros_macro",
@@ -3431,71 +3604,54 @@ dependencies = [
 
 [[package]]
 name = "ouroboros_macro"
-version = "0.18.4"
+version = "0.18.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39b0deead1528fd0e5947a8546a9642a9777c25f6e1e26f34c97b204bbb465bd"
+checksum = "3c7028bdd3d43083f6d8d4d5187680d0d3560d54df4cc9d752005268b41e64d0"
 dependencies = [
  "heck 0.4.1",
- "itertools 0.12.1",
  "proc-macro2",
  "proc-macro2-diagnostics",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
 [[package]]
-name = "overload"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
-
-[[package]]
-name = "parking_lot"
-version = "0.9.0"
+name = "page_size"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f842b1982eb6c2fe34036a4fbfb06dd185a3f5c8edfaacdf7d1ea10b07de6252"
+checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da"
 dependencies = [
- "lock_api 0.3.4",
- "parking_lot_core 0.6.3",
- "rustc_version 0.2.3",
+ "libc",
+ "winapi",
 ]
 
 [[package]]
-name = "parking_lot"
-version = "0.12.3"
+name = "parking"
+version = "2.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27"
-dependencies = [
- "lock_api 0.4.12",
- "parking_lot_core 0.9.10",
-]
+checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
 
 [[package]]
-name = "parking_lot_core"
-version = "0.6.3"
+name = "parking_lot"
+version = "0.12.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bda66b810a62be75176a80873726630147a5ca780cd33921e0b5709033e66b0a"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
 dependencies = [
- "cfg-if 0.1.10",
- "cloudabi",
- "libc",
- "redox_syscall 0.1.57",
- "rustc_version 0.2.3",
- "smallvec 0.6.14",
- "winapi 0.3.9",
+ "lock_api",
+ "parking_lot_core",
 ]
 
 [[package]]
 name = "parking_lot_core"
-version = "0.9.10"
+version = "0.9.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
  "libc",
- "redox_syscall 0.5.3",
- "smallvec 1.13.2",
- "windows-targets 0.52.6",
+ "redox_syscall",
+ "smallvec",
+ "windows-link",
 ]
 
 [[package]]
@@ -3512,9 +3668,9 @@ checksum = "17359afc20d7ab31fdb42bb844c8b3bb1dabd7dcf7e68428492da7f16966fcef"
 
 [[package]]
 name = "pathdiff"
-version = "0.2.1"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8835116a5c179084a830efb3adc117ab007512b535bc1a21c991d3b32a6b44dd"
+checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3"
 
 [[package]]
 name = "pbkdf2"
@@ -3528,26 +3684,25 @@ dependencies = [
 
 [[package]]
 name = "percent-encoding"
-version = "2.3.1"
+version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 
 [[package]]
 name = "pest"
-version = "2.7.11"
+version = "2.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd53dff83f26735fdc1ca837098ccf133605d794cdae66acfc2bfac3ec809d95"
+checksum = "989e7521a040efde50c3ab6bbadafbe15ab6dc042686926be59ac35d74607df4"
 dependencies = [
  "memchr",
- "thiserror",
  "ucd-trie",
 ]
 
 [[package]]
 name = "pest_derive"
-version = "2.7.11"
+version = "2.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a548d2beca6773b1c244554d36fcf8548a8a58e74156968211567250e48e49a"
+checksum = "187da9a3030dbafabbbfb20cb323b976dc7b7ce91fcd84f2f74d6e31d378e2de"
 dependencies = [
  "pest",
  "pest_generator",
@@ -3555,63 +3710,104 @@ dependencies = [
 
 [[package]]
 name = "pest_generator"
-version = "2.7.11"
+version = "2.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c93a82e8d145725dcbaf44e5ea887c8a869efdcc28706df2d08c69e17077183"
+checksum = "49b401d98f5757ebe97a26085998d6c0eecec4995cad6ab7fc30ffdf4b052843"
 dependencies = [
  "pest",
  "pest_meta",
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
 [[package]]
 name = "pest_meta"
-version = "2.7.11"
+version = "2.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a941429fea7e08bedec25e4f6785b6ffaacc6b755da98df5ef3e7dcf4a124c4f"
+checksum = "72f27a2cfee9f9039c4d86faa5af122a0ac3851441a34865b8a043b46be0065a"
 dependencies = [
- "once_cell",
  "pest",
  "sha2",
 ]
 
 [[package]]
 name = "petgraph"
-version = "0.6.5"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
+checksum = "3672b37090dbd86368a4145bc067582552b29c27377cad4e0a306c97f9bd7772"
 dependencies = [
  "fixedbitset",
- "indexmap 2.2.6",
+ "indexmap 2.11.4",
+]
+
+[[package]]
+name = "phf"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
+dependencies = [
+ "phf_macros",
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
+dependencies = [
+ "phf_shared",
+ "rand 0.8.5",
+]
+
+[[package]]
+name = "phf_macros"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f84ac04429c13a7ff43785d75ad27569f2951ce0ffd30a3321230db2fc727216"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"
+dependencies = [
+ "siphasher 1.0.1",
 ]
 
 [[package]]
 name = "pin-project"
-version = "1.1.5"
+version = "1.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6bf43b791c5b9e34c3d182969b4abb522f9343702850a2e57f460d00d09b4b3"
+checksum = "677f1add503faace112b9f1373e43e9e054bfdd22ff1a63c1bc485eaec6a6a8a"
 dependencies = [
  "pin-project-internal",
 ]
 
 [[package]]
 name = "pin-project-internal"
-version = "1.1.5"
+version = "1.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965"
+checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
 [[package]]
 name = "pin-project-lite"
-version = "0.2.14"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02"
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
 
 [[package]]
 name = "pin-utils"
@@ -3621,15 +3817,58 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
 [[package]]
 name = "pkg-config"
-version = "0.3.30"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
+
+[[package]]
+name = "plain"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
+
+[[package]]
+name = "plotters"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747"
+dependencies = [
+ "num-traits",
+ "plotters-backend",
+ "plotters-svg",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "plotters-backend"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a"
+
+[[package]]
+name = "plotters-svg"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
+checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670"
+dependencies = [
+ "plotters-backend",
+]
 
 [[package]]
 name = "portable-atomic"
-version = "1.7.0"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
+
+[[package]]
+name = "potential_utf"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da544ee218f0d287a911e9c99a39a8c9bc8fcad3cb8db5959940044ecfc67265"
+checksum = "84df19adbe5b5a0782edcab45899906947ab039ccf4573713735ee7de1e6b08a"
+dependencies = [
+ "zerovec",
+]
 
 [[package]]
 name = "powerfmt"
@@ -3639,9 +3878,12 @@ checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
 
 [[package]]
 name = "ppv-lite86"
-version = "0.2.17"
+version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy 0.8.27",
+]
 
 [[package]]
 name = "predicates"
@@ -3650,7 +3892,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "59230a63c37f3e18569bdb90e4a89cbf5bf8b06fea0b84e65ea10cc4df47addd"
 dependencies = [
  "difflib",
- "float-cmp",
+ "float-cmp 0.9.0",
  "itertools 0.10.5",
  "normalize-line-endings",
  "predicates-core",
@@ -3659,13 +3901,13 @@ dependencies = [
 
 [[package]]
 name = "predicates"
-version = "3.1.0"
+version = "3.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68b87bfd4605926cdfefc1c3b5f8fe560e3feca9d5552cf68c466d3d8236c7e8"
+checksum = "a5d19ee57562043d37e82899fade9a22ebab7be9cef5026b07fda9cdd4293573"
 dependencies = [
  "anstyle",
  "difflib",
- "float-cmp",
+ "float-cmp 0.10.0",
  "normalize-line-endings",
  "predicates-core",
  "regex",
@@ -3673,15 +3915,15 @@ dependencies = [
 
 [[package]]
 name = "predicates-core"
-version = "1.0.6"
+version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b794032607612e7abeb4db69adb4e33590fa6cf1149e95fd7cb00e634b92f174"
+checksum = "727e462b119fe9c93fd0eb1429a5f7647394014cf3c04ab2c0350eeb09095ffa"
 
 [[package]]
 name = "predicates-tree"
-version = "1.0.9"
+version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "368ba315fb8c5052ab692e68a0eefec6ec57b23a36959c14496f0b0df2c0cecf"
+checksum = "72dd2d6d381dfb73a193c7fca536518d7caee39fc8503f74e7dc0be0531b425c"
 dependencies = [
  "predicates-core",
  "termtree",
@@ -3689,59 +3931,60 @@ dependencies = [
 
 [[package]]
 name = "pretty_assertions"
-version = "1.4.0"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af7cee1a6c8a5b9208b3cb1061f10c0cb689087b3d8ce85fb9d2dd7a29b6ba66"
+checksum = "3ae130e2f271fbc2ac3a40fb1d07180839cdbbe443c7a27e1e3c13c5cac0116d"
 dependencies = [
  "diff",
- "yansi 0.5.1",
+ "yansi",
 ]
 
 [[package]]
-name = "proc-macro-crate"
-version = "1.3.1"
+name = "prettyplease"
+version = "0.2.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
 dependencies = [
- "once_cell",
- "toml_edit 0.19.15",
+ "proc-macro2",
+ "syn 2.0.106",
 ]
 
 [[package]]
-name = "proc-macro-error"
-version = "1.0.4"
+name = "proc-macro-crate"
+version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+checksum = "219cb19e96be00ab2e37d6e299658a0cfa83e52429179969b0f0121b4ac46983"
 dependencies = [
- "proc-macro-error-attr",
- "proc-macro2",
- "quote",
- "syn 1.0.109",
- "version_check",
+ "toml_edit 0.23.6",
 ]
 
 [[package]]
-name = "proc-macro-error-attr"
-version = "1.0.4"
+name = "proc-macro-error-attr2"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5"
 dependencies = [
  "proc-macro2",
  "quote",
- "version_check",
 ]
 
 [[package]]
-name = "proc-macro-hack"
-version = "0.5.20+deprecated"
+name = "proc-macro-error2"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc375e1527247fe1a97d8b7156678dfe7c1af2fc075c9a4db3690ecd2a148068"
+checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802"
+dependencies = [
+ "proc-macro-error-attr2",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.86"
+version = "1.0.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+checksum = "89ae43fd86e4158d6db51ad8e2b80f313af9cc74f5c0e03ccb87de09998732de"
 dependencies = [
  "unicode-ident",
 ]
@@ -3754,53 +3997,49 @@ checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
  "version_check",
- "yansi 1.0.1",
+ "yansi",
 ]
 
 [[package]]
-name = "proc-quote"
-version = "0.4.0"
+name = "ptr_meta"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e84ab161de78c915302ca325a19bee6df272800e2ae1a43fe3ef430bab2a100"
+checksum = "0738ccf7ea06b608c10564b31debd4f5bc5e197fc8bfe088f68ae5ce81e7a4f1"
 dependencies = [
- "proc-macro-hack",
- "proc-macro2",
- "proc-quote-impl",
- "quote",
- "syn 1.0.109",
+ "ptr_meta_derive 0.1.4",
 ]
 
 [[package]]
-name = "proc-quote-impl"
-version = "0.3.2"
+name = "ptr_meta"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fb3ec628b063cdbcf316e06a8b8c1a541d28fa6c0a8eacd2bfb2b7f49e88aa0"
+checksum = "0b9a0cf95a1196af61d4f1cbdab967179516d9a4a4312af1f31948f8f6224a79"
 dependencies = [
- "proc-macro-hack",
- "proc-macro2",
- "quote",
+ "ptr_meta_derive 0.3.1",
 ]
 
 [[package]]
-name = "ptr_meta"
+name = "ptr_meta_derive"
 version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0738ccf7ea06b608c10564b31debd4f5bc5e197fc8bfe088f68ae5ce81e7a4f1"
+checksum = "16b845dbfca988fa33db069c0e230574d15a3088f147a87b64c7589eb662c9ac"
 dependencies = [
- "ptr_meta_derive",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
 ]
 
 [[package]]
 name = "ptr_meta_derive"
-version = "0.1.4"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16b845dbfca988fa33db069c0e230574d15a3088f147a87b64c7589eb662c9ac"
+checksum = "7347867d0a7e1208d93b46767be83e2b8f978c3dad35f775ac8d8847551d6fe1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.106",
 ]
 
 [[package]]
@@ -3822,64 +4061,82 @@ checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
 
 [[package]]
 name = "quinn"
-version = "0.11.2"
+version = "0.11.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4ceeeeabace7857413798eb1ffa1e9c905a9946a57d81fb69b4b71c4d8eb3ad"
+checksum = "b9e20a958963c291dc322d98411f541009df2ced7b5a4f2bd52337638cfccf20"
 dependencies = [
- "bytes 1.6.1",
+ "bytes",
+ "cfg_aliases",
  "pin-project-lite",
  "quinn-proto",
  "quinn-udp",
- "rustc-hash",
- "rustls 0.23.11",
- "thiserror",
- "tokio 1.38.1",
+ "rustc-hash 2.1.1",
+ "rustls",
+ "socket2 0.6.0",
+ "thiserror 2.0.17",
+ "tokio",
  "tracing",
+ "web-time",
 ]
 
 [[package]]
 name = "quinn-proto"
-version = "0.11.3"
+version = "0.11.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddf517c03a109db8100448a4be38d498df8a210a99fe0e1b9eaf39e78c640efe"
+checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31"
 dependencies = [
- "bytes 1.6.1",
- "rand",
+ "bytes",
+ "getrandom 0.3.3",
+ "lru-slab",
+ "rand 0.9.2",
  "ring",
- "rustc-hash",
- "rustls 0.23.11",
+ "rustc-hash 2.1.1",
+ "rustls",
+ "rustls-pki-types",
  "slab",
- "thiserror",
+ "thiserror 2.0.17",
  "tinyvec",
  "tracing",
+ "web-time",
 ]
 
 [[package]]
 name = "quinn-udp"
-version = "0.5.4"
+version = "0.5.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bffec3605b73c6f1754535084a85229fa8a30f86014e6c81aeec4abb68b0285"
+checksum = "addec6a0dcad8a8d96a771f815f0eaf55f9d1805756410b39f5fa81332574cbd"
 dependencies = [
+ "cfg_aliases",
  "libc",
  "once_cell",
- "socket2 0.5.7",
- "windows-sys 0.52.0",
+ "socket2 0.6.0",
+ "tracing",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.36"
+version = "1.0.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1"
 dependencies = [
  "proc-macro2",
 ]
 
 [[package]]
-name = "radium"
-version = "0.7.0"
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "rancor"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+checksum = "a063ea72381527c2a0561da9c80000ef822bdd7c3241b1cc1b12100e3df081ee"
+dependencies = [
+ "ptr_meta 0.3.1",
+]
 
 [[package]]
 name = "rand"
@@ -3888,8 +4145,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
 dependencies = [
  "libc",
- "rand_chacha",
- "rand_core",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.3",
 ]
 
 [[package]]
@@ -3899,115 +4166,120 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 dependencies = [
  "ppv-lite86",
- "rand_core",
+ "rand_core 0.6.4",
 ]
 
 [[package]]
-name = "rand_core"
-version = "0.6.4"
+name = "rand_chacha"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
 dependencies = [
- "getrandom",
+ "ppv-lite86",
+ "rand_core 0.9.3",
 ]
 
 [[package]]
-name = "rayon"
-version = "1.10.0"
+name = "rand_core"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "either",
- "rayon-core",
+ "getrandom 0.2.16",
 ]
 
 [[package]]
-name = "rayon-core"
-version = "1.12.1"
+name = "rand_core"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
+checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
 dependencies = [
- "crossbeam-deque 0.8.5",
- "crossbeam-utils 0.8.20",
+ "getrandom 0.3.3",
 ]
 
 [[package]]
-name = "redox_syscall"
-version = "0.1.57"
+name = "rayon"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce"
+checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
+dependencies = [
+ "either",
+ "rayon-core",
+]
 
 [[package]]
-name = "redox_syscall"
-version = "0.4.1"
+name = "rayon-core"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
 dependencies = [
- "bitflags 1.3.2",
+ "crossbeam-deque",
+ "crossbeam-utils",
 ]
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.3"
+version = "0.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a908a6e00f1fdd0dfd9c0eb08ce85126f6d8bbda50017e74bc4a4b7d4a926a4"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.9.4",
 ]
 
 [[package]]
 name = "redox_users"
-version = "0.4.5"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd283d9651eeda4b2a83a43c1c91b266c40fd76ecd39a50a8c630ae69dc72891"
+checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.16",
  "libredox",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "ref-cast"
-version = "1.0.23"
+version = "1.0.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccf0a6f84d5f1d581da8b41b47ec8600871962f2a528115b542b362d4b744931"
+checksum = "f354300ae66f76f1c85c5f84693f0ce81d747e2c3f21a45fef496d89c960bf7d"
 dependencies = [
  "ref-cast-impl",
 ]
 
 [[package]]
 name = "ref-cast-impl"
-version = "1.0.23"
+version = "1.0.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bcc303e793d3734489387d205e9b186fac9c6cfacedd98cbb2e8a5943595f3e6"
+checksum = "b7186006dcb21920990093f30e3dea63b7d6e977bf1256be20c3563a5db070da"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
 [[package]]
 name = "regalloc2"
-version = "0.5.1"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "300d4fbfb40c1c66a78ba3ddd41c1110247cf52f97b87d0f2fc9209bd49b030c"
+checksum = "ad156d539c879b7a24a363a2016d77961786e71f48f2e2fc8302a92abd2429a6"
 dependencies = [
- "fxhash",
- "log 0.4.22",
+ "hashbrown 0.13.2",
+ "log",
+ "rustc-hash 1.1.0",
  "slice-group-by",
- "smallvec 1.13.2",
+ "smallvec",
 ]
 
 [[package]]
 name = "regex"
-version = "1.10.5"
+version = "1.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b91213439dad192326a0d7c6ee3955910425f441d7038e0d6933b0aec5c4517f"
+checksum = "8b5288124840bee7b386bc413c487869b360b2b4ec421ea56425128692f2a82c"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-automata 0.4.7",
- "regex-syntax 0.8.4",
+ "regex-automata 0.4.11",
+ "regex-syntax",
 ]
 
 [[package]]
@@ -4015,32 +4287,29 @@ name = "regex-automata"
 version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
-dependencies = [
- "regex-syntax 0.6.29",
-]
 
 [[package]]
 name = "regex-automata"
-version = "0.4.7"
+version = "0.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df"
+checksum = "833eb9ce86d40ef33cb1306d8accf7bc8ec2bfea4355cbdebb3df68b40925cad"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-syntax 0.8.4",
+ "regex-syntax",
 ]
 
 [[package]]
-name = "regex-syntax"
-version = "0.6.29"
+name = "regex-lite"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
+checksum = "943f41321c63ef1c92fd763bfe054d2668f7f225a5c29f0105903dc2fc04ba30"
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.4"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b"
+checksum = "caf4aa5b0f434c91fe5c7f1ecb6a5ece2130b02ad2a590589dda5146df959001"
 
 [[package]]
 name = "region"
@@ -4056,113 +4325,108 @@ dependencies = [
 
 [[package]]
 name = "rend"
-version = "0.4.2"
+version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71fe3824f5629716b1589be05dacd749f6aa084c87e00e016714a8cdfccc997c"
+checksum = "cadadef317c2f20755a64d7fdc48f9e7178ee6b0e1f7fce33fa60f1d68a276e6"
 dependencies = [
- "bytecheck",
+ "bytecheck 0.8.2",
 ]
 
 [[package]]
 name = "replace_with"
-version = "0.1.7"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3a8614ee435691de62bcffcf4a66d91b3594bf1428a5722e79103249a095690"
+checksum = "51743d3e274e2b18df81c4dc6caf8a5b8e15dbe799e0dca05c7617380094e884"
 
 [[package]]
 name = "reqwest"
-version = "0.12.5"
+version = "0.12.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7d6d2a27d57148378eb5e111173f4276ad26340ecc5c49a4a2152167a2d6a37"
+checksum = "d429f34c8092b2d42c7c93cec323bb4adeb7c67698f70839adec842ec10c7ceb"
 dependencies = [
  "async-compression",
- "base64 0.22.1",
- "bytes 1.6.1",
+ "base64",
+ "bytes",
  "futures-channel",
  "futures-core",
  "futures-util",
- "http 1.1.0",
+ "http",
  "http-body",
  "http-body-util",
  "hyper",
  "hyper-rustls",
  "hyper-tls",
  "hyper-util",
- "ipnet",
  "js-sys",
- "log 0.4.22",
- "mime",
+ "log",
  "mime_guess",
  "native-tls",
- "once_cell",
  "percent-encoding",
  "pin-project-lite",
  "quinn",
- "rustls 0.23.11",
- "rustls-pemfile",
+ "rustls",
  "rustls-pki-types",
  "serde",
  "serde_json",
  "serde_urlencoded",
  "sync_wrapper",
- "tokio 1.38.1",
+ "tokio",
  "tokio-native-tls",
- "tokio-rustls 0.26.0",
- "tokio-socks",
+ "tokio-rustls",
  "tokio-util",
+ "tower 0.5.2",
+ "tower-http 0.6.6",
  "tower-service",
  "url",
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "wasm-streams",
  "web-sys",
- "webpki-roots",
- "winreg",
+ "webpki-roots 1.0.2",
 ]
 
 [[package]]
 name = "ring"
-version = "0.17.8"
+version = "0.17.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
 dependencies = [
  "cc",
- "cfg-if 1.0.0",
- "getrandom",
+ "cfg-if",
+ "getrandom 0.2.16",
  "libc",
- "spin",
  "untrusted",
  "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "rkyv"
-version = "0.7.44"
+version = "0.8.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cba464629b3394fc4dbc6f940ff8f5b4ff5c7aef40f29166fd4ad12acbc99c0"
+checksum = "35a640b26f007713818e9a9b65d34da1cf58538207b052916a83d80e43f3ffa4"
 dependencies = [
- "bitvec",
- "bytecheck",
- "bytes 1.6.1",
- "hashbrown 0.12.3",
- "indexmap 1.9.3",
- "ptr_meta",
+ "bytecheck 0.8.2",
+ "bytes",
+ "hashbrown 0.15.5",
+ "indexmap 2.11.4",
+ "munge",
+ "ptr_meta 0.3.1",
+ "rancor",
  "rend",
  "rkyv_derive",
- "seahash",
  "tinyvec",
  "uuid",
 ]
 
 [[package]]
 name = "rkyv_derive"
-version = "0.7.44"
+version = "0.8.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7dddfff8de25e6f62b9d64e6e432bf1c6736c57d20323e15ee10435fbda7c65"
+checksum = "bd83f5f173ff41e00337d97f6572e416d022ef8a19f371817259ae960324c482"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.106",
 ]
 
 [[package]]
@@ -4178,9 +4442,9 @@ dependencies = [
 
 [[package]]
 name = "rmp-serde"
-version = "0.15.5"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "723ecff9ad04f4ad92fe1c8ca6c20d2196d9286e9c60727c4cb5511629260e9d"
+checksum = "52e599a477cf9840e92f2cde9a7189e67b42c57532749bf90aea6ec10facd4db"
 dependencies = [
  "byteorder",
  "rmp",
@@ -4189,50 +4453,15 @@ dependencies = [
 
 [[package]]
 name = "roff"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b833d8d034ea094b1ea68aa6d5c740e0d04bad9d16568d08ba6f76823a114316"
-
-[[package]]
-name = "rpassword"
-version = "7.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80472be3c897911d0137b2d2b9055faf6eeac5b14e324073d83bc17b191d7e3f"
-dependencies = [
- "libc",
- "rtoolbox",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "rtoolbox"
-version = "0.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c247d24e63230cdb56463ae328478bd5eac8b8faa8c69461a77e8e323afac90e"
-dependencies = [
- "libc",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "rusqlite"
-version = "0.28.0"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01e213bc3ecb39ac32e81e51ebe31fd888a940515173e3a18a35f8c6e896422a"
-dependencies = [
- "bitflags 1.3.2",
- "fallible-iterator",
- "fallible-streaming-iterator",
- "hashlink",
- "libsqlite3-sys",
- "smallvec 1.13.2",
-]
+checksum = "88f8660c1ff60292143c98d08fc6e2f654d722db50410e3f3797d40baaf9d8f3"
 
 [[package]]
 name = "rustc-demangle"
-version = "0.1.24"
+version = "0.1.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"
+checksum = "56f7d92ca342cea22a06f2121d944b4fd82af56988c270852495420f961d4ace"
 
 [[package]]
 name = "rustc-hash"
@@ -4241,13 +4470,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
 [[package]]
-name = "rustc_version"
-version = "0.2.3"
+name = "rustc-hash"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
-dependencies = [
- "semver 0.9.0",
-]
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
 [[package]]
 name = "rustc_version"
@@ -4260,11 +4486,11 @@ dependencies = [
 
 [[package]]
 name = "rustc_version"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
 dependencies = [
- "semver 1.0.23",
+ "semver 1.0.27",
 ]
 
 [[package]]
@@ -4274,45 +4500,44 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f2c50b74badcddeb8f7652fa8323ce440b95286f8e4b64ebfd871c609672704e"
 dependencies = [
  "anyhow",
- "log 0.4.22",
+ "log",
  "serde",
  "serde_json",
 ]
 
 [[package]]
 name = "rustix"
-version = "0.38.34"
+version = "0.38.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
+checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.9.4",
  "errno",
  "libc",
- "linux-raw-sys",
- "windows-sys 0.52.0",
+ "linux-raw-sys 0.4.15",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
-name = "rustls"
-version = "0.22.4"
+name = "rustix"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf4ef73721ac7bcd79b2b315da7779d8fc09718c6b3d2d1b2d94850eb8c18432"
+checksum = "cd15f8a2c5551a84d56efdc1cd049089e409ac19a3072d5037a17fd70719ff3e"
 dependencies = [
- "log 0.4.22",
- "ring",
- "rustls-pki-types",
- "rustls-webpki",
- "subtle",
- "zeroize",
+ "bitflags 2.9.4",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.11.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "rustls"
-version = "0.23.11"
+version = "0.23.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4828ea528154ae444e5a642dbb7d5623354030dc9822b83fd9bb79683c7399d0"
+checksum = "cd3c25631629d034ce7cd9940adc9d45762d46de2b0f57193c4443b92c6d4d40"
 dependencies = [
- "log 0.4.22",
+ "log",
  "once_cell",
  "ring",
  "rustls-pki-types",
@@ -4323,38 +4548,31 @@ dependencies = [
 
 [[package]]
 name = "rustls-native-certs"
-version = "0.7.1"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a88d6d420651b496bdd98684116959239430022a115c1240e6c3993be0b15fba"
+checksum = "7fcff2dd52b58a8d98a70243663a0d234c4e2b79235637849d15913394a247d3"
 dependencies = [
  "openssl-probe",
- "rustls-pemfile",
  "rustls-pki-types",
  "schannel",
- "security-framework",
+ "security-framework 3.5.1",
 ]
 
 [[package]]
-name = "rustls-pemfile"
-version = "2.1.2"
+name = "rustls-pki-types"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29993a25686778eb88d4189742cd713c9bce943bc54251a33509dc63cbacf73d"
+checksum = "229a4a4c221013e7e1f1a043678c5cc39fe5171437c88fb47151a21e6f5b5c79"
 dependencies = [
- "base64 0.22.1",
- "rustls-pki-types",
+ "web-time",
+ "zeroize",
 ]
 
-[[package]]
-name = "rustls-pki-types"
-version = "1.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "976295e77ce332211c0d24d92c0e83e50f5c5f046d11082cea19f3df13a3562d"
-
 [[package]]
 name = "rustls-webpki"
-version = "0.102.6"
+version = "0.103.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e6b52d4fda176fd835fdc55a835d4a89b8499cad995885a21149d5ad62f852e"
+checksum = "e10b3f4191e8a80e6b43eebabfac91e5dcecebb27a71f04e820c47ec41d314bf"
 dependencies = [
  "ring",
  "rustls-pki-types",
@@ -4363,9 +4581,9 @@ dependencies = [
 
 [[package]]
 name = "rustversion"
-version = "1.0.17"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
 
 [[package]]
 name = "rusty_jsc"
@@ -4404,7 +4622,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4ed36cdb20de66d89a17ea04b8883fc7a386f2cf877aaedca5005583ce4876ff"
 dependencies = [
  "crossbeam-channel",
- "futures 0.3.30",
+ "futures",
  "futures-channel",
  "futures-executor",
  "num_cpus",
@@ -4417,23 +4635,24 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "58c4eb8a81997cf040a091d1f7e1938aeab6749d3a0dfa73af43cdc32393483d"
 dependencies = [
  "byteorder",
- "derive_more",
- "twox-hash",
+ "derive_more 0.99.20",
+ "twox-hash 1.6.3",
 ]
 
 [[package]]
 name = "ryu"
-version = "1.0.18"
+version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
+checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
 
 [[package]]
-name = "salsa20"
-version = "0.10.2"
+name = "saffron"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97a22f5af31f73a954c10289c93e8a50cc23d971e80ee446f1f6f7137a088213"
+checksum = "03fb9a628596fc7590eb7edbf7b0613287be78df107f5f97b118aad59fb2eea9"
 dependencies = [
- "cipher",
+ "chrono",
+ "nom 5.1.3",
 ]
 
 [[package]]
@@ -4447,51 +4666,39 @@ dependencies = [
 
 [[package]]
 name = "schannel"
-version = "0.1.23"
+version = "0.1.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbc91545643bcf3a0bbb6569265615222618bdf33ce4ffbbd13c4bbd4c093534"
+checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "schemars"
-version = "0.8.21"
+version = "0.8.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09c024468a378b7e36765cd36702b7a90cc3cba11654f6685c8f233408e89e92"
+checksum = "3fbf2ae1b8bc8e02df939598064d22402220cd5bbcca1c76f7d6a310974d5615"
 dependencies = [
  "dyn-clone",
+ "indexmap 2.11.4",
  "schemars_derive",
  "serde",
  "serde_json",
  "url",
- "uuid",
 ]
 
 [[package]]
 name = "schemars_derive"
-version = "0.8.21"
+version = "0.8.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1eee588578aff73f856ab961cd2f79e36bc45d7ded33a7562adba4667aecc0e"
+checksum = "32e265784ad618884abaea0600a9adf15393368d840e0222d101a072f3f7534d"
 dependencies = [
  "proc-macro2",
  "quote",
  "serde_derive_internals",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
-[[package]]
-name = "scoped-tls"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "332ffa32bf586782a3efaeb58f127980944bbc8c4d6913a86107ac2a5ab24b28"
-
-[[package]]
-name = "scoped-tls"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
-
 [[package]]
 name = "scopeguard"
 version = "1.2.0"
@@ -4499,21 +4706,24 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
-name = "scrypt"
-version = "0.11.0"
+name = "scroll"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0516a385866c09368f0b5bcd1caff3366aace790fcd46e2bb032697bb172fd1f"
+checksum = "6ab8598aa408498679922eff7fa985c25d58a90771bd6be794434c5277eab1a6"
 dependencies = [
- "pbkdf2",
- "salsa20",
- "sha2",
+ "scroll_derive",
 ]
 
 [[package]]
-name = "seahash"
-version = "4.1.0"
+name = "scroll_derive"
+version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
+checksum = "1783eabc414609e28a5ba76aee5ddd52199f7107a0b24c2e9746a1ecc34a683d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
 
 [[package]]
 name = "security-framework"
@@ -4521,37 +4731,41 @@ version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
 dependencies = [
- "bitflags 2.6.0",
- "core-foundation",
+ "bitflags 2.9.4",
+ "core-foundation 0.9.4",
  "core-foundation-sys",
  "libc",
  "security-framework-sys",
 ]
 
 [[package]]
-name = "security-framework-sys"
-version = "2.11.1"
+name = "security-framework"
+version = "3.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75da29fe9b9b08fe9d6b22b5b4bcbc75d8db3aa31e639aa56bb62e9d46bfceaf"
+checksum = "b3297343eaf830f66ede390ea39da1d462b6b0c1b000f420d0a83f898bbbe6ef"
 dependencies = [
+ "bitflags 2.9.4",
+ "core-foundation 0.10.1",
  "core-foundation-sys",
  "libc",
+ "security-framework-sys",
 ]
 
 [[package]]
-name = "self_cell"
-version = "1.0.4"
+name = "security-framework-sys"
+version = "2.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d369a96f978623eb3dc28807c4852d6cc617fed53da5d3c400feff1ef34a714a"
+checksum = "cc1f0cbffaac4852523ce30d8bd3c5cdc873501d96ff467ca09b6767bb8cd5c0"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
 
 [[package]]
-name = "semver"
-version = "0.9.0"
+name = "self_cell"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
-dependencies = [
- "semver-parser 0.7.0",
-]
+checksum = "0f7d95a54511e0c7be3f51e8867aa8cf35148d7b9445d44de2f943e2b206e749"
 
 [[package]]
 name = "semver"
@@ -4559,47 +4773,43 @@ version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f301af10236f6df4160f7c3f04eec6dbc70ace82d23326abad5edee88801c6b6"
 dependencies = [
- "semver-parser 0.10.2",
+ "semver-parser",
 ]
 
 [[package]]
 name = "semver"
-version = "1.0.23"
+version = "1.0.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"
+checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
 dependencies = [
  "serde",
+ "serde_core",
 ]
 
 [[package]]
 name = "semver-parser"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
-
-[[package]]
-name = "semver-parser"
-version = "0.10.2"
+version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00b0bef5b7f9e0df16536d3961cfb6e84331c065b4066afb39768d0e319411f7"
+checksum = "9900206b54a3527fdc7b8a938bffd94a568bac4f4aa8113b209df75a09c0dec2"
 dependencies = [
  "pest",
 ]
 
 [[package]]
 name = "serde"
-version = "1.0.204"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc76f558e0cbb2a839d37354c575f1dc3fdc6546b5be373ba43d95f231bf7c12"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
 dependencies = [
+ "serde_core",
  "serde_derive",
 ]
 
 [[package]]
 name = "serde-wasm-bindgen"
-version = "0.4.5"
+version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3b4c031cd0d9014307d82b8abf653c0290fbdaeb4c02d00c63cf52f728628bf"
+checksum = "8302e169f0eddcc139c70f139d19d6467353af16f9fce27e8c30158036a1e16b"
 dependencies = [
  "js-sys",
  "serde",
@@ -4608,11 +4818,12 @@ dependencies = [
 
 [[package]]
 name = "serde_bytes"
-version = "0.11.15"
+version = "0.11.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "387cc504cb06bb40a96c8e04e951fe01854cf6bc921053c954e4a606d9675c6a"
+checksum = "a5d440709e79d88e51ac01c4b72fc6cb7314017bb7da9eeff678aa94c10e3ea8"
 dependencies = [
  "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -4625,15 +4836,24 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
 [[package]]
 name = "serde_derive"
-version = "1.0.204"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0cd7e117be63d3c3678776753929474f3b04a43a080c744d6b0ae2a8c28e222"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
 [[package]]
@@ -4644,61 +4864,61 @@ checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.120"
+version = "1.0.145"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e0d21c9a8cae1235ad58a00c11cb40d4b1e5c784f1ef2c537876ed6ffd8b7c5"
+checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c"
 dependencies = [
  "itoa",
+ "memchr",
  "ryu",
  "serde",
+ "serde_core",
 ]
 
 [[package]]
 name = "serde_path_to_error"
-version = "0.1.16"
+version = "0.1.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af99884400da37c88f5e9146b7f1fd0fbcae8f6eec4e9da38b67d05486f814a6"
+checksum = "10a9ff822e371bb5403e391ecd83e182e0e77ba7f6fe0160b795797109d1b457"
 dependencies = [
  "itoa",
  "serde",
+ "serde_core",
 ]
 
 [[package]]
 name = "serde_spanned"
-version = "0.6.6"
+version = "0.6.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79e674e01f999af37c49f70a6ede167a8a60b2503e56c5599532a65baa5969a0"
+checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3"
 dependencies = [
  "serde",
 ]
 
 [[package]]
-name = "serde_urlencoded"
-version = "0.7.1"
+name = "serde_spanned"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
+checksum = "5417783452c2be558477e104686f7de5dae53dba813c28435e0e70f82d9b04ee"
 dependencies = [
- "form_urlencoded",
- "itoa",
- "ryu",
- "serde",
+ "serde_core",
 ]
 
 [[package]]
-name = "serde_yaml"
-version = "0.8.26"
+name = "serde_urlencoded"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578a7433b776b56a35785ed5ce9a7e777ac0598aac5a6dd1b4b18a307c7fc71b"
+checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
 dependencies = [
- "indexmap 1.9.3",
+ "form_urlencoded",
+ "itoa",
  "ryu",
  "serde",
- "yaml-rust",
 ]
 
 [[package]]
@@ -4707,7 +4927,7 @@ version = "0.9.34+deprecated"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
 dependencies = [
- "indexmap 2.2.6",
+ "indexmap 2.11.4",
  "itoa",
  "ryu",
  "serde",
@@ -4721,10 +4941,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0e56dd856803e253c8f298af3f4d7eb0ae5e23a737252cd90bb4f3b435033b2d"
 dependencies = [
  "dashmap 5.5.3",
- "futures 0.3.30",
+ "futures",
  "lazy_static",
- "log 0.4.22",
- "parking_lot 0.12.3",
+ "log",
+ "parking_lot",
  "serial_test_derive",
 ]
 
@@ -4736,7 +4956,7 @@ checksum = "91d129178576168c589c9ec973feedf7d3126c01ac2bf08795109aa35b69fb8f"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
 [[package]]
@@ -4745,18 +4965,18 @@ version = "0.10.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
  "cpufeatures",
  "digest",
 ]
 
 [[package]]
 name = "sha2"
-version = "0.10.8"
+version = "0.10.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
  "cpufeatures",
  "digest",
 ]
@@ -4776,7 +4996,7 @@ version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f6c99835bad52957e7aa241d3975ed17c1e5f8c92026377d117a606f36b84b16"
 dependencies = [
- "bytes 1.6.1",
+ "bytes",
  "memmap2 0.6.2",
 ]
 
@@ -4786,11 +5006,17 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde"
 
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
 [[package]]
 name = "signal-hook-registry"
-version = "1.4.2"
+version = "1.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9e9e0b4211b72e7b8b6e85c807d36c212bdb33ea8587f7569562a84df5465b1"
+checksum = "b2a4719bff48cee6b39d12c020eeb490953ad2443b7055bd0b21fca26bd8c28b"
 dependencies = [
  "libc",
 ]
@@ -4803,24 +5029,33 @@ checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
 
 [[package]]
 name = "simdutf8"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f27f6278552951f1f2b8cf9da965d10969b2efdea95a6ec47987ab46edfe263a"
+checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
 
 [[package]]
 name = "similar"
-version = "2.6.0"
+version = "2.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1de1d4f81173b03af4c0cbed3c898f6bff5b870e4a7f5d6f4057d62a7a4b686e"
+checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa"
+
+[[package]]
+name = "siphasher"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d"
+
+[[package]]
+name = "siphasher"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
 
 [[package]]
 name = "slab"
-version = "0.4.9"
+version = "0.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
-dependencies = [
- "autocfg",
-]
+checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
 
 [[package]]
 name = "slice-group-by"
@@ -4830,18 +5065,15 @@ checksum = "826167069c09b99d56f31e9ae5c99049e932a98c9dc2dac47645b08dbbf76ba7"
 
 [[package]]
 name = "smallvec"
-version = "0.6.14"
+version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b97fcaeba89edba30f044a10c6a3cc39df9c3f17d7cd829dd1446cab35f890e0"
-dependencies = [
- "maybe-uninit",
-]
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
-name = "smallvec"
-version = "1.13.2"
+name = "smawk"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
+checksum = "b7c388c1b5e93756d0c740965c41e8822f866621d41acbdf6336a6a168f8840c"
 
 [[package]]
 name = "smoltcp"
@@ -4856,31 +5088,22 @@ dependencies = [
 
 [[package]]
 name = "socket2"
-version = "0.4.10"
+version = "0.5.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f7916fc008ca5542385b89a3d3ce689953c143e9304a9bf8beec1de48994c0d"
+checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
 dependencies = [
  "libc",
- "winapi 0.3.9",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "socket2"
-version = "0.5.7"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce305eb0b4296696835b71df73eb912e0f1ffd2556a501fcede6e0c50349191c"
+checksum = "233504af464074f9d066d7b5416c5f9b894a5862a6506e306f7b816cdd6f1807"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
-]
-
-[[package]]
-name = "sparx"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc2257c28eacecfc38c658124ed239e7ecfc9b89082c0794b0672420b63b84c6"
-dependencies = [
- "byteorder",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -4888,9 +5111,6 @@ name = "spin"
 version = "0.9.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
-dependencies = [
- "lock_api 0.4.12",
-]
 
 [[package]]
 name = "stable_deref_trait"
@@ -4916,25 +5136,6 @@ version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
-[[package]]
-name = "strum"
-version = "0.26.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06"
-
-[[package]]
-name = "strum_macros"
-version = "0.26.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be"
-dependencies = [
- "heck 0.5.0",
- "proc-macro2",
- "quote",
- "rustversion",
- "syn 2.0.72",
-]
-
 [[package]]
 name = "subtle"
 version = "2.6.1"
@@ -4954,9 +5155,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.72"
+version = "2.0.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc4b9b9bf2add8093d3f2c0204471e951b2285580335de42f9d2534f3ae7a8af"
+checksum = "ede7c438028d4436d71104916910f5bb611972c5cfd7f89b8300a8186e6fada6"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4965,21 +5166,29 @@ dependencies = [
 
 [[package]]
 name = "sync_wrapper"
-version = "1.0.1"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7065abeca94b6a8a577f9bd45aa0867a2238b74e8eb67cf10d492bc39351394"
+checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263"
+dependencies = [
+ "futures-core",
+]
 
 [[package]]
-name = "tap"
-version = "1.0.1"
+name = "synstructure"
+version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
 
 [[package]]
 name = "tar"
-version = "0.4.41"
+version = "0.4.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb797dad5fb5b76fcf519e702f4a589483b5ef06567f160c392832c1f5e44909"
+checksum = "1d863878d212c87a19c1a610eb53bb01fe12951c0501cf5a0d65f724914a667a"
 dependencies = [
  "filetime",
  "libc",
@@ -4994,20 +5203,27 @@ checksum = "422045212ea98508ae3d28025bc5aaa2bd4a9cdaecd442a08da2ee620ee9ea95"
 
 [[package]]
 name = "target-lexicon"
-version = "0.12.15"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
+[[package]]
+name = "target-triple"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4873307b7c257eddcb50c9bedf158eb669578359fb28428bef438fec8e6ba7c2"
+checksum = "1ac9aa371f599d22256307c24a9d748c041e548cbf599f35d890f9d365361790"
 
 [[package]]
 name = "tempfile"
-version = "3.10.1"
+version = "3.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1"
+checksum = "2d31c77bdf42a745371d260a26ca7163f1e0924b64afa0b688e61b5a9fa02f16"
 dependencies = [
- "cfg-if 1.0.0",
  "fastrand",
- "rustix",
- "windows-sys 0.52.0",
+ "getrandom 0.3.3",
+ "once_cell",
+ "rustix 1.1.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -5018,7 +5234,7 @@ checksum = "c59df8ac95d96ff9bede18eb7300b0fda5e5d8d90960e76f8e14ae765eedbf1f"
 dependencies = [
  "dirs-next",
  "rustversion",
- "winapi 0.3.9",
+ "winapi",
 ]
 
 [[package]]
@@ -5036,7 +5252,7 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "21bebf2b7c9e0a515f6e0f8c51dc0f8e4696391e6f1ff30379559f8365fb0df7"
 dependencies = [
- "rustix",
+ "rustix 0.38.44",
  "windows-sys 0.48.0",
 ]
 
@@ -5051,23 +5267,23 @@ dependencies = [
 
 [[package]]
 name = "termtree"
-version = "0.4.1"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3369f5ac52d5eb6ab48c6b4ffdc8efbcad6b89c765749064ba298f2c68a16a76"
+checksum = "8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683"
 
 [[package]]
 name = "test-generator"
 version = "0.1.0"
 dependencies = [
  "anyhow",
- "target-lexicon 0.12.15",
+ "target-lexicon 0.12.16",
 ]
 
 [[package]]
 name = "test-log"
-version = "0.2.16"
+version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3dffced63c2b5c7be278154d76b479f9f9920ed34e7574201407f0b14e2bbb93"
+checksum = "1e33b98a582ea0be1168eba097538ee8dd4bbe0f2b01b22ac92ea30054e5be7b"
 dependencies = [
  "test-log-macros",
  "tracing-subscriber",
@@ -5075,13 +5291,13 @@ dependencies = [
 
 [[package]]
 name = "test-log-macros"
-version = "0.2.16"
+version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5999e24eaa32083191ba4e425deb75cdf25efefabe5aaccb7446dd0d4122a3f5"
+checksum = "451b374529930d7601b1eef8d32bc79ae870b6079b069401709c2a8bf9e75f36"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
 [[package]]
@@ -5090,47 +5306,69 @@ version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "89e8bf7e0eb2dd7b4228cc1b6821fc5114cd6841ae59f652a85488c016091e5f"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
  "getopts",
  "libc",
  "num_cpus",
  "term",
 ]
 
+[[package]]
+name = "textwrap"
+version = "0.16.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c13547615a44dc9c452a8a534638acdf07120d4b6847c8178705da06306a3057"
+dependencies = [
+ "smawk",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
 [[package]]
 name = "thiserror"
-version = "1.0.63"
+version = "2.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0342370b38b6a11b6cc11d6a805569958d54cfa061a29969c3b5ce2ea405724"
+checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8"
 dependencies = [
- "thiserror-impl",
+ "thiserror-impl 2.0.17",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.63"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
 [[package]]
-name = "thread-scoped"
-version = "1.0.2"
+name = "thiserror-impl"
+version = "2.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bcbb6aa301e5d3b0b5ef639c9a9c7e2f1c944f177b460c04dc24c69b1fa2bd99"
+checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
 
 [[package]]
 name = "thread_local"
-version = "1.1.8"
+version = "1.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c"
+checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
 dependencies = [
- "cfg-if 1.0.0",
- "once_cell",
+ "cfg-if",
 ]
 
 [[package]]
@@ -5141,14 +5379,14 @@ checksum = "1b797afad3f312d1c66a56d11d0316f916356d11bd158fbc6ca6389ff6bf805a"
 dependencies = [
  "libc",
  "wasi 0.10.0+wasi-snapshot-preview1",
- "winapi 0.3.9",
+ "winapi",
 ]
 
 [[package]]
 name = "time"
-version = "0.3.36"
+version = "0.3.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885"
+checksum = "91e7d9e3bb61134e77bde20dd4825b97c010155709965fedf0f49bb138e52a9d"
 dependencies = [
  "deranged",
  "itoa",
@@ -5161,20 +5399,30 @@ dependencies = [
 
 [[package]]
 name = "time-core"
-version = "0.1.2"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
+checksum = "40868e7c1d2f0b8d73e4a8c7f0ff63af4f6d19be117e90bd73eb1d62cf831c6b"
 
 [[package]]
 name = "time-macros"
-version = "0.2.18"
+version = "0.2.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf"
+checksum = "30cfb0125f12d9c277f35663a0a33f8c30190f4e4574868a330595412d34ebf3"
 dependencies = [
  "num-conv",
  "time-core",
 ]
 
+[[package]]
+name = "tinystr"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
 [[package]]
 name = "tinytemplate"
 version = "1.2.1"
@@ -5187,9 +5435,9 @@ dependencies = [
 
 [[package]]
 name = "tinyvec"
-version = "1.8.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "445e881f4f6d382d5f27c034e25eb92edd7c784ceab92a0937db7f2e9471b938"
+checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa"
 dependencies = [
  "tinyvec_macros",
 ]
@@ -5200,408 +5448,229 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
-[[package]]
-name = "tldextract"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec03259a0567ad58eed30812bc3e5eda8030f154abc70317ab57b14f00699ca4"
-dependencies = [
- "idna 0.2.3",
- "log 0.4.22",
- "regex",
- "serde_json",
- "thiserror",
- "url",
-]
-
 [[package]]
 name = "tokio"
-version = "0.1.22"
+version = "1.47.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a09c0b5bb588872ab2f09afa13ee6e9dac11e10a0ec9e8e3ba39a5a5d530af6"
-dependencies = [
- "bytes 0.4.12",
- "futures 0.1.31",
- "mio 0.6.23",
- "num_cpus",
- "tokio-codec",
- "tokio-current-thread",
- "tokio-executor",
- "tokio-fs",
- "tokio-io",
- "tokio-reactor",
- "tokio-sync",
- "tokio-tcp",
- "tokio-threadpool",
- "tokio-timer",
- "tokio-udp",
- "tokio-uds",
-]
-
-[[package]]
-name = "tokio"
-version = "1.38.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb2caba9f80616f438e09748d5acda951967e1ea58508ef53d9c6402485a46df"
+checksum = "89e49afdadebb872d3145a5638b59eb0691ea23e46ca484037cfab3b76b95038"
 dependencies = [
  "backtrace",
- "bytes 1.6.1",
+ "bytes",
+ "io-uring",
  "libc",
- "mio 0.8.11",
- "num_cpus",
+ "mio",
  "pin-project-lite",
  "signal-hook-registry",
- "socket2 0.5.7",
+ "slab",
+ "socket2 0.6.0",
  "tokio-macros",
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
-name = "tokio-codec"
-version = "0.1.2"
+name = "tokio-macros"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25b2998660ba0e70d18684de5d06b70b70a3a747469af9dea7618cc59e75976b"
+checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8"
 dependencies = [
- "bytes 0.4.12",
- "futures 0.1.31",
- "tokio-io",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
 ]
 
 [[package]]
-name = "tokio-core"
-version = "0.1.18"
+name = "tokio-native-tls"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87b1395334443abca552f63d4f61d0486f12377c2ba8b368e523f89e828cffd4"
+checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
 dependencies = [
- "bytes 0.4.12",
- "futures 0.1.31",
- "iovec",
- "log 0.4.22",
- "mio 0.6.23",
- "scoped-tls 0.1.2",
- "tokio 0.1.22",
- "tokio-executor",
- "tokio-io",
- "tokio-reactor",
- "tokio-timer",
+ "native-tls",
+ "tokio",
 ]
 
 [[package]]
-name = "tokio-current-thread"
-version = "0.1.7"
+name = "tokio-rustls"
+version = "0.26.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1de0e32a83f131e002238d7ccde18211c0a5397f60cbfffcb112868c2e0e20e"
+checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
 dependencies = [
- "futures 0.1.31",
- "tokio-executor",
+ "rustls",
+ "tokio",
 ]
 
 [[package]]
-name = "tokio-executor"
-version = "0.1.10"
+name = "tokio-serde"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb2d1b8f4548dbf5e1f7818512e9c406860678f29c300cdf0ebac72d1a3a1671"
+checksum = "caf600e7036b17782571dd44fa0a5cea3c82f60db5137f774a325a76a0d6852b"
 dependencies = [
- "crossbeam-utils 0.7.2",
- "futures 0.1.31",
+ "bincode",
+ "bytes",
+ "educe",
+ "futures-core",
+ "futures-sink",
+ "pin-project",
+ "rmp-serde",
+ "serde",
+ "serde_cbor",
+ "serde_json",
 ]
 
 [[package]]
-name = "tokio-fs"
-version = "0.1.7"
+name = "tokio-stream"
+version = "0.1.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "297a1206e0ca6302a0eed35b700d292b275256f596e2f3fea7729d5e629b6ff4"
+checksum = "eca58d7bba4a75707817a2c44174253f9236b2d5fbd055602e9d5c07c139a047"
 dependencies = [
- "futures 0.1.31",
- "tokio-io",
- "tokio-threadpool",
-]
-
-[[package]]
-name = "tokio-io"
-version = "0.1.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57fc868aae093479e3131e3d165c93b1c7474109d13c90ec0dda2a1bbfff0674"
-dependencies = [
- "bytes 0.4.12",
- "futures 0.1.31",
- "log 0.4.22",
-]
-
-[[package]]
-name = "tokio-macros"
-version = "2.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f5ae998a069d4b5aba8ee9dad856af7d520c3699e6159b185c2acd48155d39a"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.72",
-]
-
-[[package]]
-name = "tokio-native-tls"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
-dependencies = [
- "native-tls",
- "tokio 1.38.1",
-]
-
-[[package]]
-name = "tokio-reactor"
-version = "0.1.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09bc590ec4ba8ba87652da2068d150dcada2cfa2e07faae270a5e0409aa51351"
-dependencies = [
- "crossbeam-utils 0.7.2",
- "futures 0.1.31",
- "lazy_static",
- "log 0.4.22",
- "mio 0.6.23",
- "num_cpus",
- "parking_lot 0.9.0",
- "slab",
- "tokio-executor",
- "tokio-io",
- "tokio-sync",
+ "futures-core",
+ "pin-project-lite",
+ "tokio",
+ "tokio-util",
 ]
 
 [[package]]
-name = "tokio-rustls"
-version = "0.25.0"
+name = "tokio-tungstenite"
+version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "775e0c0f0adb3a2f22a00c4745d728b479985fc15ee7ca6a2608388c5569860f"
+checksum = "c83b561d025642014097b66e6c1bb422783339e0909e4429cde4749d1990bc38"
 dependencies = [
- "rustls 0.22.4",
- "rustls-pki-types",
- "tokio 1.38.1",
+ "futures-util",
+ "log",
+ "tokio",
+ "tungstenite 0.21.0",
 ]
 
 [[package]]
-name = "tokio-rustls"
-version = "0.26.0"
+name = "tokio-tungstenite"
+version = "0.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c7bc40d0e5a97695bb96e27995cd3a08538541b0a846f65bba7a359f36700d4"
+checksum = "edc5f74e248dc973e0dbb7b74c7e0d6fcc301c694ff50049504004ef4d0cdcd9"
 dependencies = [
- "rustls 0.23.11",
+ "futures-util",
+ "log",
+ "rustls",
+ "rustls-native-certs",
  "rustls-pki-types",
- "tokio 1.38.1",
+ "tokio",
+ "tokio-rustls",
+ "tungstenite 0.24.0",
+ "webpki-roots 0.26.11",
 ]
 
 [[package]]
-name = "tokio-serde"
-version = "0.8.0"
+name = "tokio-util"
+version = "0.7.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "911a61637386b789af998ee23f50aa30d5fd7edcec8d6d3dedae5e5815205466"
+checksum = "14307c986784f72ef81c89db7d9e28d6ac26d16213b109ea501696195e6e3ce5"
 dependencies = [
- "bincode",
- "bytes 1.6.1",
- "educe",
+ "bytes",
  "futures-core",
  "futures-sink",
- "pin-project",
- "rmp-serde",
- "serde",
- "serde_cbor",
- "serde_json",
-]
-
-[[package]]
-name = "tokio-socks"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51165dfa029d2a65969413a6cc96f354b86b464498702f174a4efa13608fd8c0"
-dependencies = [
- "either",
- "futures-util",
- "thiserror",
- "tokio 1.38.1",
-]
-
-[[package]]
-name = "tokio-stream"
-version = "0.1.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "267ac89e0bec6e691e5813911606935d77c476ff49024f98abcea3e7b15e37af"
-dependencies = [
- "futures-core",
  "pin-project-lite",
- "tokio 1.38.1",
- "tokio-util",
+ "tokio",
 ]
 
 [[package]]
-name = "tokio-sync"
-version = "0.1.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edfe50152bc8164fcc456dab7891fa9bf8beaf01c5ee7e1dd43a397c3cf87dee"
-dependencies = [
- "fnv",
- "futures 0.1.31",
-]
-
-[[package]]
-name = "tokio-tcp"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98df18ed66e3b72e742f185882a9e201892407957e45fbff8da17ae7a7c51f72"
-dependencies = [
- "bytes 0.4.12",
- "futures 0.1.31",
- "iovec",
- "mio 0.6.23",
- "tokio-io",
- "tokio-reactor",
-]
-
-[[package]]
-name = "tokio-threadpool"
-version = "0.1.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df720b6581784c118f0eb4310796b12b1d242a7eb95f716a8367855325c25f89"
-dependencies = [
- "crossbeam-deque 0.7.4",
- "crossbeam-queue 0.2.3",
- "crossbeam-utils 0.7.2",
- "futures 0.1.31",
- "lazy_static",
- "log 0.4.22",
- "num_cpus",
- "slab",
- "tokio-executor",
-]
-
-[[package]]
-name = "tokio-timer"
-version = "0.2.13"
+name = "toml"
+version = "0.5.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93044f2d313c95ff1cb7809ce9a7a05735b012288a888b62d4434fd58c94f296"
+checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
 dependencies = [
- "crossbeam-utils 0.7.2",
- "futures 0.1.31",
- "slab",
- "tokio-executor",
+ "serde",
 ]
 
 [[package]]
-name = "tokio-tungstenite"
-version = "0.21.0"
+name = "toml"
+version = "0.8.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c83b561d025642014097b66e6c1bb422783339e0909e4429cde4749d1990bc38"
+checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
 dependencies = [
- "futures-util",
- "log 0.4.22",
- "rustls 0.22.4",
- "rustls-native-certs",
- "rustls-pki-types",
- "tokio 1.38.1",
- "tokio-rustls 0.25.0",
- "tungstenite",
- "webpki-roots",
+ "indexmap 2.11.4",
+ "serde",
+ "serde_spanned 0.6.9",
+ "toml_datetime 0.6.11",
+ "toml_edit 0.22.27",
 ]
 
 [[package]]
-name = "tokio-udp"
-version = "0.1.6"
+name = "toml"
+version = "0.9.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2a0b10e610b39c38b031a2fcab08e4b82f16ece36504988dcbd81dbba650d82"
+checksum = "00e5e5d9bf2475ac9d4f0d9edab68cc573dc2fd644b0dba36b0c30a92dd9eaa0"
 dependencies = [
- "bytes 0.4.12",
- "futures 0.1.31",
- "log 0.4.22",
- "mio 0.6.23",
- "tokio-codec",
- "tokio-io",
- "tokio-reactor",
+ "indexmap 2.11.4",
+ "serde_core",
+ "serde_spanned 1.0.2",
+ "toml_datetime 0.7.2",
+ "toml_parser",
+ "toml_writer",
+ "winnow",
 ]
 
 [[package]]
-name = "tokio-uds"
-version = "0.2.7"
+name = "toml_datetime"
+version = "0.6.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab57a4ac4111c8c9dbcf70779f6fc8bc35ae4b2454809febac840ad19bd7e4e0"
+checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c"
 dependencies = [
- "bytes 0.4.12",
- "futures 0.1.31",
- "iovec",
- "libc",
- "log 0.4.22",
- "mio 0.6.23",
- "mio-uds",
- "tokio-codec",
- "tokio-io",
- "tokio-reactor",
+ "serde",
 ]
 
 [[package]]
-name = "tokio-util"
-version = "0.7.11"
+name = "toml_datetime"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cf6b47b3771c49ac75ad09a6162f53ad4b8088b76ac60e8ec1455b31a189fe1"
+checksum = "32f1085dec27c2b6632b04c80b3bb1b4300d6495d1e129693bdda7d91e72eec1"
 dependencies = [
- "bytes 1.6.1",
- "futures-core",
- "futures-sink",
- "pin-project-lite",
- "tokio 1.38.1",
+ "serde_core",
 ]
 
 [[package]]
-name = "toml"
-version = "0.5.11"
+name = "toml_edit"
+version = "0.22.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
+checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
 dependencies = [
- "indexmap 1.9.3",
+ "indexmap 2.11.4",
  "serde",
+ "serde_spanned 0.6.9",
+ "toml_datetime 0.6.11",
+ "toml_write",
+ "winnow",
 ]
 
 [[package]]
-name = "toml"
-version = "0.8.15"
+name = "toml_edit"
+version = "0.23.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac2caab0bf757388c6c0ae23b3293fdb463fee59434529014f85e3263b995c28"
+checksum = "f3effe7c0e86fdff4f69cdd2ccc1b96f933e24811c5441d44904e8683e27184b"
 dependencies = [
- "serde",
- "serde_spanned",
- "toml_datetime",
- "toml_edit 0.22.16",
+ "indexmap 2.11.4",
+ "toml_datetime 0.7.2",
+ "toml_parser",
+ "winnow",
 ]
 
 [[package]]
-name = "toml_datetime"
-version = "0.6.6"
+name = "toml_parser"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4badfd56924ae69bcc9039335b2e017639ce3f9b001c393c1b2d1ef846ce2cbf"
+checksum = "4cf893c33be71572e0e9aa6dd15e6677937abd686b066eac3f8cd3531688a627"
 dependencies = [
- "serde",
+ "winnow",
 ]
 
 [[package]]
-name = "toml_edit"
-version = "0.19.15"
+name = "toml_write"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
-dependencies = [
- "indexmap 2.2.6",
- "toml_datetime",
- "winnow 0.5.40",
-]
+checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
 
 [[package]]
-name = "toml_edit"
-version = "0.22.16"
+name = "toml_writer"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "278f3d518e152219c994ce877758516bca5e118eaed6996192a774fb9fbf0788"
-dependencies = [
- "indexmap 2.2.6",
- "serde",
- "serde_spanned",
- "toml_datetime",
- "winnow 0.6.15",
-]
+checksum = "d163a63c116ce562a22cda521fcc4d79152e7aba014456fb5eb442f6d6a10109"
 
 [[package]]
 name = "tower"
@@ -5613,50 +5682,83 @@ dependencies = [
  "futures-util",
  "pin-project",
  "pin-project-lite",
- "tokio 1.38.1",
+ "tokio",
  "tower-layer",
  "tower-service",
  "tracing",
 ]
 
+[[package]]
+name = "tower"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d039ad9159c98b70ecfd540b2573b97f7f52c3e8d9f8ad57a24b916a536975f9"
+dependencies = [
+ "futures-core",
+ "futures-util",
+ "pin-project-lite",
+ "sync_wrapper",
+ "tokio",
+ "tower-layer",
+ "tower-service",
+]
+
 [[package]]
 name = "tower-http"
 version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e9cd434a998747dd2c4276bc96ee2e0c7a2eadf3cae88e52be55a05fa9053f5"
 dependencies = [
- "bitflags 2.6.0",
- "bytes 1.6.1",
+ "bitflags 2.9.4",
+ "bytes",
  "futures-util",
- "http 1.1.0",
+ "http",
  "http-body",
  "http-body-util",
  "pin-project-lite",
- "tower",
+ "tower 0.4.13",
  "tower-layer",
  "tower-service",
  "tracing",
 ]
 
+[[package]]
+name = "tower-http"
+version = "0.6.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adc82fd73de2a9722ac5da747f12383d2bfdb93591ee6c58486e0097890f05f2"
+dependencies = [
+ "bitflags 2.9.4",
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "iri-string",
+ "pin-project-lite",
+ "tower 0.5.2",
+ "tower-layer",
+ "tower-service",
+]
+
 [[package]]
 name = "tower-layer"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c20c8dbed6283a09604c3e69b4b7eeb54e298b8a600d4d5ecb5ad39de609f1d0"
+checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
 
 [[package]]
 name = "tower-service"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
 
 [[package]]
 name = "tracing"
-version = "0.1.40"
+version = "0.1.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
+checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
 dependencies = [
- "log 0.4.22",
+ "log",
  "pin-project-lite",
  "tracing-attributes",
  "tracing-core",
@@ -5664,20 +5766,20 @@ dependencies = [
 
 [[package]]
 name = "tracing-attributes"
-version = "0.1.27"
+version = "0.1.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
+checksum = "81383ab64e72a7a8b8e13130c49e3dab29def6d0c7d76a03087b3cf71c5c6903"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
 [[package]]
 name = "tracing-core"
-version = "0.1.32"
+version = "0.1.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
+checksum = "b9d12581f227e93f094d3af2ae690a574abb8a2b9b7a96e7cfe9647b2b617678"
 dependencies = [
  "once_cell",
  "valuable",
@@ -5689,16 +5791,16 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
 dependencies = [
- "log 0.4.22",
+ "log",
  "once_cell",
  "tracing-core",
 ]
 
 [[package]]
 name = "tracing-serde"
-version = "0.1.3"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc6b213177105856957181934e4920de57730fc69bf42c37ee5bb664d406d9e1"
+checksum = "704b1aeb7be0d0a84fc9828cae51dab5970fee5088f83d1dd7ee6f6246fc6ff1"
 dependencies = [
  "serde",
  "tracing-core",
@@ -5706,18 +5808,18 @@ dependencies = [
 
 [[package]]
 name = "tracing-subscriber"
-version = "0.3.18"
+version = "0.3.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b"
+checksum = "2054a14f5307d601f88daf0553e1cbf472acc4f2c51afab632431cdcd72124d5"
 dependencies = [
  "matchers",
  "nu-ansi-term",
  "once_cell",
- "regex",
+ "regex-automata 0.4.11",
  "serde",
  "serde_json",
  "sharded-slab",
- "smallvec 1.13.2",
+ "smallvec",
  "thread_local",
  "tracing",
  "tracing-core",
@@ -5743,7 +5845,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04659ddb06c87d233c566112c1c9c5b9e98256d9af50ec3bc9c8327f873a7568"
 dependencies = [
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
 [[package]]
@@ -5765,49 +5867,55 @@ checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 
 [[package]]
 name = "trybuild"
-version = "1.0.97"
+version = "1.0.111"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b1e5645f2ee8025c2f1d75e1138f2dd034d74e6ba54620f3c569ba2a2a1ea06"
+checksum = "0ded9fdb81f30a5708920310bfcd9ea7482ff9cba5f54601f7a19a877d5c2392"
 dependencies = [
  "glob",
  "serde",
  "serde_derive",
  "serde_json",
+ "target-triple",
  "termcolor",
- "toml 0.8.15",
+ "toml 0.9.7",
 ]
 
 [[package]]
-name = "tun-tap"
-version = "0.1.4"
+name = "tungstenite"
+version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a477a4e9367c72ac875d23cd07ac99ffa932497d8428767fed0cfa27bbabe50"
+checksum = "9ef1a641ea34f399a848dea702823bbecfb4c486f911735368f1f137cb8257e1"
 dependencies = [
- "cc",
- "futures 0.1.31",
- "libc",
- "mio 0.6.23",
- "tokio-core",
+ "byteorder",
+ "bytes",
+ "data-encoding",
+ "http",
+ "httparse",
+ "log",
+ "rand 0.8.5",
+ "sha1",
+ "thiserror 1.0.69",
+ "url",
+ "utf-8",
 ]
 
 [[package]]
 name = "tungstenite"
-version = "0.21.0"
+version = "0.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ef1a641ea34f399a848dea702823bbecfb4c486f911735368f1f137cb8257e1"
+checksum = "18e5b8366ee7a95b16d32197d0b2604b43a0be89dc5fac9f8e96ccafbaedda8a"
 dependencies = [
  "byteorder",
- "bytes 1.6.1",
+ "bytes",
  "data-encoding",
- "http 1.1.0",
+ "http",
  "httparse",
- "log 0.4.22",
- "rand",
- "rustls 0.22.4",
+ "log",
+ "rand 0.8.5",
+ "rustls",
  "rustls-pki-types",
  "sha1",
- "thiserror",
- "url",
+ "thiserror 1.0.69",
  "utf-8",
 ]
 
@@ -5817,15 +5925,21 @@ version = "1.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
  "static_assertions",
 ]
 
+[[package]]
+name = "twox-hash"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ea3136b675547379c4bd395ca6b938e5ad3c3d20fad76e7fe85f9e0d011419c"
+
 [[package]]
 name = "typenum"
-version = "1.17.0"
+version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
 
 [[package]]
 name = "typetag"
@@ -5853,73 +5967,189 @@ dependencies = [
 
 [[package]]
 name = "ucd-trie"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed646292ffc8188ef8ea4d1e0e0150fb15a5c2e12ad9b8fc191ae7a8a7f3c4b9"
+checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
 
 [[package]]
 name = "unicase"
-version = "2.7.0"
+version = "2.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7d2d4dafb69621809a81864c9c1b864479e1235c0dd4e199924b9742439ed89"
-dependencies = [
- "version_check",
-]
-
-[[package]]
-name = "unicode-bidi"
-version = "0.3.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75"
+checksum = "75b844d17643ee918803943289730bec8aac480150456169e647ed0b576ba539"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.12"
+version = "1.0.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+checksum = "f63a545481291138910575129486daeaf8ac54aee4387fe7906919f7830c7d9d"
 
 [[package]]
 name = "unicode-normalization"
-version = "0.1.23"
+version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5"
+checksum = "5033c97c4262335cded6d6fc3e5c18ab755e1a3dc96376350f3d8e9f009ad956"
 dependencies = [
  "tinyvec",
 ]
 
 [[package]]
 name = "unicode-segmentation"
-version = "1.11.0"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4c87d22b6e3f4a18d4d40ef354e97c90fcb14dd91d7dc0aa9d8a1172ebf7202"
+checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
 
 [[package]]
 name = "unicode-width"
-version = "0.1.13"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0336d538f7abc86d282a4189614dfaa90810dfc2c6f6427eaf88e16311dd225d"
+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
+
+[[package]]
+name = "unicode-width"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
 
 [[package]]
 name = "unicode-xid"
-version = "0.2.4"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
 [[package]]
-name = "unix_mode"
-version = "0.1.4"
+name = "uniffi"
+version = "0.27.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b55eedc365f81a3c32aea49baf23fa965e3cd85bcc28fb8045708c7388d124ef"
+checksum = "cb3a4c447c50fcda7bc5604a8588b7e1f37ffbfd8838a1516a290398efa7c6f0"
+dependencies = [
+ "anyhow",
+ "uniffi_build",
+ "uniffi_core",
+ "uniffi_macros",
+]
 
 [[package]]
-name = "unreachable"
-version = "1.0.0"
+name = "uniffi_bindgen"
+version = "0.27.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0be2bc6bafd82c979b0faca77c7b26630d54017de9f5bd5a686ec6ef038ad5d9"
+dependencies = [
+ "anyhow",
+ "askama",
+ "camino",
+ "cargo_metadata",
+ "fs-err",
+ "glob",
+ "goblin",
+ "heck 0.4.1",
+ "once_cell",
+ "paste",
+ "serde",
+ "textwrap",
+ "toml 0.5.11",
+ "uniffi_meta",
+ "uniffi_testing",
+ "uniffi_udl",
+]
+
+[[package]]
+name = "uniffi_build"
+version = "0.27.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c59b65d59685ff3a10569287c6419f76487b4052ac52d5a0df38b2253d7f440"
+dependencies = [
+ "anyhow",
+ "camino",
+ "uniffi_bindgen",
+]
+
+[[package]]
+name = "uniffi_checksum_derive"
+version = "0.27.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d5c400339a9d1d17be34257d0b407e91d64af335e5b4fa49f4bf28467fc8d635"
+dependencies = [
+ "quote",
+ "syn 2.0.106",
+]
+
+[[package]]
+name = "uniffi_core"
+version = "0.27.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a02e67ac9634b10da9e4aa63a29a7920b8f1395eafef1ea659b2dd76dda96906"
+dependencies = [
+ "anyhow",
+ "bytes",
+ "camino",
+ "log",
+ "once_cell",
+ "paste",
+ "static_assertions",
+]
+
+[[package]]
+name = "uniffi_macros"
+version = "0.27.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6f08d5592c669b80a8af5066027098bebec4b4af17a9b8b299bac5f518ab89e"
+dependencies = [
+ "bincode",
+ "camino",
+ "fs-err",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "syn 2.0.106",
+ "toml 0.5.11",
+ "uniffi_meta",
+]
+
+[[package]]
+name = "uniffi_meta"
+version = "0.27.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"
+checksum = "583bab49f2bdf5681f9732f8b67a7e555ad920dbb5427be21450217bf1818189"
 dependencies = [
- "void",
+ "anyhow",
+ "bytes",
+ "siphasher 0.3.11",
+ "uniffi_checksum_derive",
 ]
 
+[[package]]
+name = "uniffi_testing"
+version = "0.27.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13963044ca9bde9b709d2eee68bc11dafc7acea144ae0fdc0cf29ed4add44481"
+dependencies = [
+ "anyhow",
+ "camino",
+ "cargo_metadata",
+ "fs-err",
+ "once_cell",
+]
+
+[[package]]
+name = "uniffi_udl"
+version = "0.27.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b92f984bb0d9a06778f256aec963e1e9a80714014f7a90fb0e01008821fe5a97"
+dependencies = [
+ "anyhow",
+ "textwrap",
+ "uniffi_meta",
+ "uniffi_testing",
+ "weedle2",
+]
+
+[[package]]
+name = "unix_mode"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b55eedc365f81a3c32aea49baf23fa965e3cd85bcc28fb8045708c7388d124ef"
+
 [[package]]
 name = "unsafe-libyaml"
 version = "0.2.11"
@@ -5934,28 +6164,28 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
 [[package]]
 name = "ureq"
-version = "2.10.0"
+version = "2.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72139d247e5f97a3eff96229a7ae85ead5328a39efe76f8bf5a06313d505b6ea"
+checksum = "02d1a66277ed75f640d608235660df48c8e3c19f3b4edb6a263315626cc3c01d"
 dependencies = [
- "base64 0.22.1",
+ "base64",
  "flate2",
- "log 0.4.22",
+ "log",
  "once_cell",
- "rustls 0.23.11",
+ "rustls",
  "rustls-pki-types",
  "url",
- "webpki-roots",
+ "webpki-roots 0.26.11",
 ]
 
 [[package]]
 name = "url"
-version = "2.5.2"
+version = "2.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22784dbdf76fdde8af1aeda5622b546b422b6fc585325248a2bf9f5e41e94d6c"
+checksum = "08bc136a29a3d1758e07a9cca267be308aeebf5cfd5a10f3f67ab2097683ef5b"
 dependencies = [
  "form_urlencoded",
- "idna 0.5.0",
+ "idna",
  "percent-encoding",
  "serde",
 ]
@@ -5972,6 +6202,12 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
 
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
 [[package]]
 name = "utf8parse"
 version = "0.2.2"
@@ -5980,19 +6216,20 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"
-version = "1.10.0"
+version = "1.18.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81dfa00651efa65069b0b6b651f4aaa31ba9e3c3ce0137aaad053604ee7e0314"
+checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2"
 dependencies = [
- "getrandom",
- "serde",
+ "getrandom 0.3.3",
+ "js-sys",
+ "wasm-bindgen",
 ]
 
 [[package]]
 name = "valuable"
-version = "0.1.0"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
+checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
 
 [[package]]
 name = "vcpkg"
@@ -6002,26 +6239,25 @@ checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
 
 [[package]]
 name = "version_check"
-version = "0.9.4"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
 name = "virtual-fs"
-version = "0.16.0"
+version = "0.601.0"
 dependencies = [
  "anyhow",
  "async-trait",
- "bytes 1.6.1",
- "dashmap 6.0.1",
- "derivative",
+ "bytes",
+ "dashmap 6.1.0",
+ "derive_more 2.0.1",
  "dunce",
  "filetime",
  "fs_extra",
- "futures 0.3.30",
- "getrandom",
- "indexmap 1.9.3",
- "lazy_static",
+ "futures",
+ "getrandom 0.2.16",
+ "indexmap 2.11.4",
  "libc",
  "pin-project-lite",
  "pretty_assertions",
@@ -6030,68 +6266,66 @@ dependencies = [
  "shared-buffer",
  "slab",
  "tempfile",
- "thiserror",
- "tokio 1.38.1",
+ "thiserror 1.0.69",
+ "tokio",
  "tracing",
  "tracing-test",
  "typetag",
+ "virtual-mio",
+ "wasmer-package",
+ "web-time",
  "webc",
 ]
 
 [[package]]
 name = "virtual-mio"
-version = "0.3.1"
+version = "0.601.0"
 dependencies = [
  "async-trait",
- "bytes 1.6.1",
- "derivative",
- "futures 0.3.30",
- "mio 0.8.11",
+ "bytes",
+ "futures",
+ "mio",
  "serde",
- "socket2 0.4.10",
- "thiserror",
+ "socket2 0.5.10",
+ "thiserror 1.0.69",
  "tracing",
 ]
 
 [[package]]
 name = "virtual-net"
-version = "0.8.0"
+version = "0.601.0"
 dependencies = [
  "anyhow",
  "async-trait",
- "base64 0.21.7",
+ "base64",
  "bincode",
- "bytecheck",
- "bytes 1.6.1",
- "derivative",
+ "bytecheck 0.6.12",
+ "bytes",
+ "derive_more 2.0.1",
  "futures-util",
  "hyper",
  "hyper-tungstenite",
  "hyper-util",
+ "ipnet",
+ "iprange",
  "libc",
- "mio 0.8.11",
+ "mio",
  "pin-project-lite",
  "rkyv",
  "serde",
  "serial_test",
  "smoltcp",
- "socket2 0.4.10",
- "thiserror",
- "tokio 1.38.1",
+ "socket2 0.5.10",
+ "thiserror 1.0.69",
+ "tokio",
  "tokio-serde",
- "tokio-tungstenite",
+ "tokio-tungstenite 0.24.0",
  "tokio-util",
  "tracing",
  "tracing-test",
  "virtual-mio",
 ]
 
-[[package]]
-name = "void"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
-
 [[package]]
 name = "wai-bindgen-gen-core"
 version = "0.2.3"
@@ -6158,13 +6392,13 @@ dependencies = [
 
 [[package]]
 name = "wai-bindgen-wasmer"
-version = "0.27.0"
+version = "0.601.0"
 dependencies = [
  "anyhow",
  "async-trait",
  "bitflags 1.3.2",
  "once_cell",
- "thiserror",
+ "thiserror 1.0.69",
  "tracing",
  "wai-bindgen-wasmer-impl",
  "wasmer",
@@ -6197,9 +6431,9 @@ dependencies = [
 
 [[package]]
 name = "wait-timeout"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f200f5b12eb75f8c1ed65abd4b2db8a6e1b138a20de009dacee265a2498f3f6"
+checksum = "09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11"
 dependencies = [
  "libc",
 ]
@@ -6237,70 +6471,85 @@ checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
 
 [[package]]
 name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasi"
+version = "0.14.7+wasi-0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+checksum = "883478de20367e224c0090af9cf5f9fa85bed63a95c1abf3afc5c083ebc06e8c"
+dependencies = [
+ "wasip2",
+]
 
 [[package]]
 name = "wasi-test-generator"
-version = "4.3.7"
+version = "6.1.0"
 dependencies = [
  "glob",
  "gumdrop",
  "serde",
  "serde_json",
  "tempfile",
- "wast 24.0.0",
+ "wast 216.0.1",
 ]
 
 [[package]]
-name = "wasite"
-version = "0.1.0"
+name = "wasip2"
+version = "1.0.1+wasi-0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
+checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
+dependencies = [
+ "wit-bindgen",
+]
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.92"
+version = "0.2.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
+checksum = "c1da10c01ae9f1ae40cbfac0bac3b1e724b320abfcf52229f80b547c0d250e2d"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
+ "once_cell",
+ "rustversion",
  "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.92"
+version = "0.2.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
+checksum = "671c9a5a66f49d8a47345ab942e2cb93c7d1d0339065d4f8139c486121b43b19"
 dependencies = [
  "bumpalo",
- "log 0.4.22",
- "once_cell",
+ "log",
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.42"
+version = "0.4.54"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76bc14366121efc8dbb487ab05bcc9d346b3b5ec0eaa76e46594cabbe51762c0"
+checksum = "7e038d41e478cc73bae0ff9b36c60cff1c98b8f38f8d7e8061e79ee63608ac5c"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
  "js-sys",
+ "once_cell",
  "wasm-bindgen",
  "web-sys",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.92"
+version = "0.2.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
+checksum = "7ca60477e4c59f5f2986c50191cd972e3a50d8a95603bc9434501cf156a9a119"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -6308,32 +6557,34 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.92"
+version = "0.2.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
+checksum = "9f07d2f20d4da7b26400c9f4a0511e6e0345b040694e8a75bd41d578fa4421d7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.92"
+version = "0.2.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
+checksum = "bad67dc8b2a1a6e5448428adec4c3e84c43e561d8c9ee8a9e5aabeb193ec41d1"
+dependencies = [
+ "unicode-ident",
+]
 
 [[package]]
 name = "wasm-bindgen-test"
-version = "0.3.42"
+version = "0.3.54"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9bf62a58e0780af3e852044583deee40983e5886da43a271dd772379987667b"
+checksum = "4e381134e148c1062f965a42ed1f5ee933eef2927c3f70d1812158f711d39865"
 dependencies = [
- "console_error_panic_hook",
  "js-sys",
- "scoped-tls 1.0.1",
+ "minicov",
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "wasm-bindgen-test-macro",
@@ -6341,20 +6592,20 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-test-macro"
-version = "0.3.42"
+version = "0.3.54"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7f89739351a2e03cb94beb799d47fb2cac01759b40ec441f7de39b00cbf7ef0"
+checksum = "b673bca3298fe582aeef8352330ecbad91849f85090805582400850f8270a2e8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
 ]
 
 [[package]]
 name = "wasm-coredump-builder"
-version = "0.1.22"
+version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31ca262b320e4530a60946ba16a1cbf987d3f7d4aa6a953bfcc96e179e3e7458"
+checksum = "e67c1c448581871272b2fb7b1a2ee373a4bd295b4d214c92b9938047e7bb867a"
 dependencies = [
  "wasm-coredump-encoder",
  "wasm-coredump-types",
@@ -6363,9 +6614,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-coredump-encoder"
-version = "0.1.22"
+version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6f36ccfe604720ce093fce7d7b0d609c086c646ec4bb9bba58cb9f4dc2c5623"
+checksum = "45c2fc6340ab2c342bbe706c321e46af41ebef4a0253d134e551abb4780b6d53"
 dependencies = [
  "leb128",
  "wasm-coredump-types",
@@ -6373,9 +6624,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-coredump-types"
-version = "0.1.22"
+version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2763d9807903c461b41275a13489396d04695d7bc365743b8ea430cfd72f336"
+checksum = "ce6930c202f9dabb7effcb8105a425ee68be0c2ab1d2a0d12fef107b17b92f7c"
 
 [[package]]
 name = "wasm-encoder"
@@ -6397,11 +6648,41 @@ dependencies = [
 
 [[package]]
 name = "wasm-encoder"
-version = "0.32.0"
+version = "0.216.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1de2d0fd411c201b8d76c04213901f9bb221abf17dd59c2201542d0b118bb90"
+dependencies = [
+ "leb128",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.221.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ba64e81215916eaeb48fee292f29401d69235d62d8b8fd92a7b2844ec5ae5f7"
+checksum = "dc8444fe4920de80a4fe5ab564fff2ae58b6b73166b89751f8c6c93509da32e5"
 dependencies = [
  "leb128",
+ "wasmparser 0.221.3",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.235.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3bc393c395cb621367ff02d854179882b9a351b4e0c93d1397e6090b53a5c2a"
+dependencies = [
+ "leb128fmt",
+ "wasmparser 0.235.0",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.239.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5be00faa2b4950c76fe618c409d2c3ea5a3c9422013e079482d78544bb2d184c"
+dependencies = [
+ "leb128fmt",
+ "wasmparser 0.239.0",
 ]
 
 [[package]]
@@ -6418,9 +6699,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-streams"
-version = "0.4.0"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b65dc4c90b63b118468cf747d8bf3566c1913ef60be765b5730ead9e0a3ba129"
+checksum = "15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65"
 dependencies = [
  "futures-util",
  "js-sys",
@@ -6431,26 +6712,32 @@ dependencies = [
 
 [[package]]
 name = "wasmer"
-version = "4.3.7"
+version = "6.1.0"
 dependencies = [
  "anyhow",
- "bytes 1.6.1",
- "cfg-if 1.0.0",
- "derivative",
+ "bindgen",
+ "bytes",
+ "cfg-if",
+ "cmake",
+ "derive_more 2.0.1",
  "hashbrown 0.11.2",
- "indexmap 1.9.3",
+ "indexmap 2.11.4",
  "js-sys",
+ "loupe",
  "macro-wasmer-universal-test",
  "more-asserts",
+ "paste",
  "rustc-demangle",
  "rusty_jsc",
  "serde",
  "serde-wasm-bindgen",
  "shared-buffer",
- "target-lexicon 0.12.15",
+ "tar",
+ "target-lexicon 0.12.16",
  "tempfile",
- "thiserror",
+ "thiserror 1.0.69",
  "tracing",
+ "ureq",
  "wasm-bindgen",
  "wasm-bindgen-test",
  "wasmer-compiler",
@@ -6460,59 +6747,66 @@ dependencies = [
  "wasmer-derive",
  "wasmer-types",
  "wasmer-vm",
- "wasmparser 0.121.2",
+ "wasmi_c_api_impl",
+ "wasmparser 0.224.1",
  "wat",
+ "which",
  "windows-sys 0.59.0",
+ "xz",
+ "zip",
 ]
 
 [[package]]
-name = "wasmer-api"
-version = "0.0.34"
+name = "wasmer-argus"
+version = "6.1.0"
 dependencies = [
  "anyhow",
- "base64 0.13.1",
+ "async-trait",
+ "clap",
  "cynic",
- "edge-schema 0.1.0",
- "futures 0.3.30",
- "getrandom",
- "harsh",
- "merge-streams",
- "pin-project-lite",
+ "derive_more 2.0.1",
+ "futures",
+ "indicatif",
+ "log",
  "reqwest",
  "serde",
  "serde_json",
- "serde_path_to_error",
- "time 0.3.36",
- "tokio 1.38.1",
+ "shared-buffer",
+ "tokio",
  "tracing",
+ "tracing-subscriber",
  "url",
- "uuid",
- "wasmer-config 0.8.0",
+ "wasmer",
+ "wasmer-backend-api",
  "webc",
 ]
 
 [[package]]
-name = "wasmer-argus"
-version = "4.3.7"
+name = "wasmer-backend-api"
+version = "0.601.0"
 dependencies = [
  "anyhow",
- "async-trait",
- "clap",
+ "async-tungstenite",
+ "base64",
  "cynic",
- "derive_more",
- "futures 0.3.30",
- "indicatif",
- "log 0.4.22",
+ "futures",
+ "getrandom 0.2.16",
+ "graphql-ws-client",
+ "harsh",
+ "merge-streams",
+ "pin-project-lite",
  "reqwest",
  "serde",
  "serde_json",
- "shared-buffer",
- "tokio 1.38.1",
+ "serde_path_to_error",
+ "time 0.3.44",
+ "tokio",
+ "tokio-tungstenite 0.24.0",
  "tracing",
- "tracing-subscriber",
  "url",
- "wasmer",
- "wasmer-api",
+ "uuid",
+ "wasmer-config",
+ "wasmer-package",
  "webc",
 ]
 
@@ -6534,18 +6828,17 @@ dependencies = [
 
 [[package]]
 name = "wasmer-c-api"
-version = "4.3.7"
+version = "6.1.0"
 dependencies = [
  "cbindgen",
- "cfg-if 1.0.0",
+ "cfg-if",
  "enumset",
  "field-offset",
  "inline-c",
- "lazy_static",
  "libc",
  "paste",
- "thiserror",
- "tokio 1.38.1",
+ "thiserror 1.0.69",
+ "tokio",
  "tracing",
  "tracing-subscriber",
  "typetag",
@@ -6555,7 +6848,6 @@ dependencies = [
  "wasmer-compiler-cranelift",
  "wasmer-compiler-llvm",
  "wasmer-compiler-singlepass",
- "wasmer-emscripten",
  "wasmer-inline-c",
  "wasmer-middlewares",
  "wasmer-types",
@@ -6565,7 +6857,7 @@ dependencies = [
 
 [[package]]
 name = "wasmer-c-api-test-runner"
-version = "4.3.7"
+version = "6.1.0"
 dependencies = [
  "cc",
  "regex",
@@ -6575,7 +6867,7 @@ dependencies = [
 
 [[package]]
 name = "wasmer-cache"
-version = "4.3.7"
+version = "6.1.0"
 dependencies = [
  "blake3",
  "clap",
@@ -6584,16 +6876,16 @@ dependencies = [
  "clap_lex",
  "criterion",
  "hex",
- "rand",
+ "rand 0.8.5",
  "tempfile",
- "thiserror",
+ "thiserror 1.0.69",
  "wasmer",
  "wasmer-compiler-singlepass",
 ]
 
 [[package]]
 name = "wasmer-capi-examples-runner"
-version = "4.3.7"
+version = "6.1.0"
 dependencies = [
  "cc",
  "regex",
@@ -6603,76 +6895,73 @@ dependencies = [
 
 [[package]]
 name = "wasmer-cli"
-version = "4.3.7"
+version = "6.1.0"
 dependencies = [
  "anyhow",
- "assert_cmd 2.0.14",
+ "assert_cmd 2.0.17",
  "async-trait",
- "bytes 1.6.1",
+ "base64",
+ "bytes",
  "bytesize",
  "cargo_metadata",
- "cfg-if 1.0.0",
+ "cfg-if",
  "chrono",
  "clap",
  "clap_complete",
  "clap_mangen",
- "colored 2.1.0",
+ "colored 2.2.0",
  "comfy-table",
  "console",
  "dialoguer",
  "dirs",
  "dotenvy",
- "edge-schema 0.1.0",
- "edge-util",
  "flate2",
- "fuse",
- "futures 0.3.30",
+ "fuser",
+ "futures",
  "futures-util",
  "hex",
- "http 1.1.0",
+ "http",
  "http-body-util",
  "humantime",
  "hyper",
  "hyper-util",
- "indexmap 1.9.3",
+ "indexmap 2.11.4",
  "indicatif",
  "interfaces",
  "is-terminal",
- "lazy_static",
  "libc",
- "log 0.4.22",
+ "log",
+ "lzma-rs",
  "mac_address",
- "mio 0.8.11",
+ "mio",
  "normpath",
  "object 0.32.2",
  "once_cell",
  "opener",
- "parking_lot 0.12.3",
+ "parking_lot",
  "pathdiff",
- "predicates 3.1.0",
+ "predicates 3.1.3",
  "pretty_assertions",
  "regex",
  "reqwest",
  "rkyv",
- "semver 1.0.23",
+ "semver 1.0.27",
  "serde",
  "serde_json",
- "serde_yaml 0.9.34+deprecated",
+ "serde_yaml",
  "sha2",
  "shared-buffer",
  "tar",
- "target-lexicon 0.12.15",
+ "target-lexicon 0.12.16",
  "tempfile",
- "thiserror",
+ "thiserror 1.0.69",
  "time 0.1.45",
- "time 0.3.36",
- "tldextract",
- "tokio 1.38.1",
- "tokio-tungstenite",
- "toml 0.5.11",
+ "time 0.3.44",
+ "tokio",
+ "tokio-tungstenite 0.24.0",
+ "toml 0.8.23",
  "tracing",
  "tracing-subscriber",
- "tun-tap",
  "unix_mode",
  "url",
  "uuid",
@@ -6682,15 +6971,14 @@ dependencies = [
  "walkdir",
  "wasm-coredump-builder",
  "wasmer",
- "wasmer-api",
+ "wasmer-backend-api",
  "wasmer-compiler",
  "wasmer-compiler-cranelift",
  "wasmer-compiler-llvm",
  "wasmer-compiler-singlepass",
- "wasmer-config 0.8.0",
- "wasmer-emscripten",
- "wasmer-object",
- "wasmer-registry",
+ "wasmer-config",
+ "wasmer-package",
+ "wasmer-sdk",
  "wasmer-types",
  "wasmer-vm",
  "wasmer-wasix",
@@ -6701,70 +6989,73 @@ dependencies = [
 
 [[package]]
 name = "wasmer-compiler"
-version = "4.3.7"
+version = "6.1.0"
 dependencies = [
  "backtrace",
- "bytes 1.6.1",
- "cfg-if 1.0.0",
+ "bytes",
+ "cfg-if",
  "enum-iterator",
  "enumset",
  "hashbrown 0.11.2",
- "lazy_static",
  "leb128",
  "libc",
- "memmap2 0.5.10",
+ "loupe",
+ "macho-unwind-info",
+ "memmap2 0.6.2",
  "more-asserts",
+ "object 0.32.2",
  "region",
  "rkyv",
  "self_cell",
  "serde",
  "serde_bytes",
  "shared-buffer",
- "smallvec 1.13.2",
- "thiserror",
- "wasmer-object",
+ "smallvec",
+ "target-lexicon 0.12.16",
+ "thiserror 1.0.69",
  "wasmer-types",
  "wasmer-vm",
- "wasmparser 0.121.2",
+ "wasmparser 0.224.1",
  "windows-sys 0.59.0",
  "xxhash-rust",
 ]
 
 [[package]]
 name = "wasmer-compiler-cli"
-version = "4.3.7"
+version = "6.1.0"
 dependencies = [
  "anyhow",
  "bytesize",
- "cfg-if 1.0.0",
+ "cfg-if",
  "clap",
- "colored 2.1.0",
+ "colored 2.2.0",
  "distance",
  "fern",
  "is-terminal",
- "log 0.4.22",
- "target-lexicon 0.12.15",
+ "log",
+ "target-lexicon 0.12.16",
  "unix_mode",
  "wasmer-compiler",
  "wasmer-compiler-cranelift",
+ "wasmer-compiler-llvm",
  "wasmer-compiler-singlepass",
  "wasmer-types",
 ]
 
 [[package]]
 name = "wasmer-compiler-cranelift"
-version = "4.3.7"
+version = "6.1.0"
 dependencies = [
  "cranelift-codegen",
  "cranelift-entity",
  "cranelift-frontend",
- "gimli 0.26.2",
+ "gimli 0.28.1",
  "hashbrown 0.11.2",
- "lazy_static",
+ "itertools 0.12.1",
  "more-asserts",
  "rayon",
- "smallvec 1.13.2",
- "target-lexicon 0.12.15",
+ "smallvec",
+ "target-lexicon 0.12.16",
  "tracing",
  "wasmer-compiler",
  "wasmer-types",
@@ -6772,21 +7063,22 @@ dependencies = [
 
 [[package]]
 name = "wasmer-compiler-llvm"
-version = "4.3.7"
+version = "6.1.0"
 dependencies = [
  "byteorder",
  "cc",
  "inkwell",
- "itertools 0.10.5",
- "lazy_static",
+ "itertools 0.12.1",
  "libc",
- "object 0.28.4",
+ "object 0.32.2",
+ "phf",
  "rayon",
  "regex",
- "rustc_version 0.4.0",
- "semver 1.0.23",
- "smallvec 1.13.2",
- "target-lexicon 0.12.15",
+ "rustc_version 0.4.1",
+ "semver 1.0.27",
+ "smallvec",
+ "target-lexicon 0.12.16",
+ "tracing",
  "wasmer-compiler",
  "wasmer-types",
  "wasmer-vm",
@@ -6794,93 +7086,57 @@ dependencies = [
 
 [[package]]
 name = "wasmer-compiler-singlepass"
-version = "4.3.7"
+version = "6.1.0"
 dependencies = [
  "byteorder",
  "dynasm",
  "dynasmrt",
  "enumset",
- "gimli 0.26.2",
+ "gimli 0.28.1",
  "hashbrown 0.11.2",
- "lazy_static",
  "more-asserts",
  "rayon",
- "smallvec 1.13.2",
- "target-lexicon 0.12.15",
+ "smallvec",
+ "target-lexicon 0.12.16",
  "wasmer-compiler",
  "wasmer-types",
 ]
 
 [[package]]
 name = "wasmer-config"
-version = "0.8.0"
+version = "0.601.0"
 dependencies = [
  "anyhow",
  "bytesize",
  "ciborium",
  "derive_builder",
  "hex",
- "indexmap 2.2.6",
+ "indexmap 2.11.4",
  "pretty_assertions",
+ "saffron",
  "schemars",
- "semver 1.0.23",
+ "semver 1.0.27",
  "serde",
  "serde_json",
- "serde_yaml 0.9.34+deprecated",
+ "serde_yaml",
  "tempfile",
- "thiserror",
- "toml 0.8.15",
- "url",
-]
-
-[[package]]
-name = "wasmer-config"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "644b7e3547bd7e796d92220f60bf57734914254c6cee56607e80177a3e8a28da"
-dependencies = [
- "anyhow",
- "bytesize",
- "ciborium",
- "derive_builder",
- "hex",
- "indexmap 2.2.6",
- "schemars",
- "semver 1.0.23",
- "serde",
- "serde_json",
- "serde_yaml 0.9.34+deprecated",
- "thiserror",
- "toml 0.8.15",
+ "thiserror 1.0.69",
+ "toml 0.8.23",
  "url",
 ]
 
 [[package]]
 name = "wasmer-derive"
-version = "4.3.7"
+version = "6.1.0"
 dependencies = [
  "compiletest_rs",
- "proc-macro-error",
+ "proc-macro-error2",
  "proc-macro2",
  "quote",
  "syn 1.0.109",
  "wasmer-types",
 ]
 
-[[package]]
-name = "wasmer-emscripten"
-version = "4.3.7"
-dependencies = [
- "byteorder",
- "getrandom",
- "lazy_static",
- "libc",
- "log 0.4.22",
- "time 0.3.36",
- "wasmer",
- "wasmer-types",
-]
-
 [[package]]
 name = "wasmer-inline-c"
 version = "0.1.2"
@@ -6911,14 +7167,13 @@ dependencies = [
 
 [[package]]
 name = "wasmer-integration-tests-cli"
-version = "4.3.7"
+version = "6.1.0"
 dependencies = [
  "anyhow",
- "assert_cmd 2.0.14",
- "derivative",
+ "assert_cmd 2.0.17",
  "dirs",
  "flate2",
- "futures 0.3.30",
+ "futures",
  "hex",
  "insta",
  "libc",
@@ -6927,32 +7182,31 @@ dependencies = [
  "once_cell",
  "predicates 2.1.5",
  "pretty_assertions",
- "rand",
+ "rand 0.8.5",
  "regex",
  "reqwest",
  "serde",
  "tar",
- "target-lexicon 0.12.15",
+ "target-lexicon 0.12.16",
  "tempfile",
- "tokio 1.38.1",
- "wasmer-registry",
+ "tokio",
 ]
 
 [[package]]
 name = "wasmer-integration-tests-ios"
-version = "4.3.7"
+version = "6.1.0"
 
 [[package]]
 name = "wasmer-journal"
-version = "0.9.0"
+version = "0.601.0"
 dependencies = [
  "anyhow",
  "async-trait",
- "base64 0.21.7",
+ "base64",
  "bincode",
- "bytecheck",
- "bytes 1.6.1",
- "derivative",
+ "bytecheck 0.6.12",
+ "bytes",
+ "derive_more 2.0.1",
  "lz4_flex",
  "num_enum",
  "rkyv",
@@ -6960,18 +7214,19 @@ dependencies = [
  "serde_json",
  "shared-buffer",
  "tempfile",
- "thiserror",
+ "thiserror 1.0.69",
  "tracing",
  "tracing-test",
  "virtual-fs",
  "virtual-net",
  "wasmer",
+ "wasmer-config",
  "wasmer-wasix-types",
 ]
 
 [[package]]
 name = "wasmer-middlewares"
-version = "4.3.7"
+version = "6.1.0"
 dependencies = [
  "wasmer",
  "wasmer-types",
@@ -6979,66 +7234,81 @@ dependencies = [
 ]
 
 [[package]]
-name = "wasmer-object"
-version = "4.3.7"
+name = "wasmer-package"
+version = "0.601.0"
 dependencies = [
- "object 0.29.0",
- "thiserror",
+ "anyhow",
+ "bytes",
+ "cfg-if",
+ "ciborium",
+ "flate2",
+ "hexdump",
+ "ignore",
+ "insta",
+ "libc",
+ "pretty_assertions",
+ "regex",
+ "semver 1.0.27",
+ "serde",
+ "serde_json",
+ "sha2",
+ "shared-buffer",
+ "tar",
+ "tempfile",
+ "thiserror 1.0.69",
+ "toml 0.8.23",
+ "ureq",
+ "url",
+ "wasmer-config",
  "wasmer-types",
+ "webc",
 ]
 
 [[package]]
-name = "wasmer-registry"
-version = "5.19.0"
+name = "wasmer-sdk"
+version = "6.1.0"
 dependencies = [
  "anyhow",
- "async-tungstenite",
- "clap",
- "console",
- "dialoguer",
- "dirs",
- "filetime",
- "flate2",
- "futures 0.3.30",
+ "bytes",
+ "bytesize",
  "futures-util",
- "graphql-ws-client",
- "graphql_client",
- "hex",
- "indexmap 1.9.3",
- "indicatif",
- "lazy_static",
- "log 0.4.22",
- "lzma-rs",
- "minisign",
- "pretty_assertions",
- "rand",
- "regex",
+ "ignore",
+ "rand 0.9.2",
  "reqwest",
- "rpassword",
- "rusqlite",
- "semver 1.0.23",
+ "semver 1.0.27",
  "serde",
- "serde_json",
- "tar",
+ "serde_yaml",
+ "sha2",
  "tempfile",
- "thiserror",
- "time 0.3.36",
- "tldextract",
- "tokio 1.38.1",
- "tokio-tungstenite",
- "toml 0.5.11",
+ "thiserror 1.0.69",
+ "tokio",
+ "toml 0.8.23",
  "tracing",
  "url",
- "wasmer-config 0.8.0",
- "wasmer-wasm-interface",
- "wasmparser 0.121.2",
+ "walkdir",
+ "wasmer-backend-api",
+ "wasmer-config",
+ "wasmer-package",
+ "zip",
+]
+
+[[package]]
+name = "wasmer-swift"
+version = "0.601.0"
+dependencies = [
+ "thiserror 1.0.69",
+ "tokio",
+ "uniffi",
+ "virtual-fs",
+ "wasmer",
+ "wasmer-package",
+ "wasmer-wasix",
  "webc",
- "whoami",
 ]
 
 [[package]]
 name = "wasmer-sys-utils"
-version = "0.27.0"
+version = "0.601.0"
 dependencies = [
  "libc",
  "region",
@@ -7052,48 +7322,51 @@ dependencies = [
 
 [[package]]
 name = "wasmer-types"
-version = "4.3.7"
+version = "6.1.0"
 dependencies = [
- "bytecheck",
+ "bytecheck 0.6.12",
  "enum-iterator",
  "enumset",
- "getrandom",
+ "getrandom 0.2.16",
  "hex",
- "indexmap 1.9.3",
+ "indexmap 2.11.4",
+ "loupe",
  "memoffset 0.9.1",
  "more-asserts",
  "rkyv",
  "serde",
  "serde_bytes",
  "sha2",
- "target-lexicon 0.12.15",
- "thiserror",
+ "target-lexicon 0.12.16",
+ "thiserror 1.0.69",
+ "wasmparser 0.224.1",
  "xxhash-rust",
 ]
 
 [[package]]
 name = "wasmer-vm"
-version = "4.3.7"
+version = "6.1.0"
 dependencies = [
  "backtrace",
  "cc",
- "cfg-if 1.0.0",
+ "cfg-if",
  "corosensei",
- "crossbeam-queue 0.3.11",
- "dashmap 6.0.1",
- "derivative",
+ "crossbeam-queue",
+ "dashmap 6.1.0",
  "enum-iterator",
  "fnv",
- "indexmap 1.9.3",
- "lazy_static",
+ "indexmap 2.11.4",
  "libc",
+ "libunwind",
+ "loupe",
  "mach2",
  "memoffset 0.9.1",
  "more-asserts",
  "region",
+ "rustversion",
  "scopeguard",
  "serde",
- "thiserror",
+ "thiserror 1.0.69",
  "tracing",
  "wasmer-types",
  "windows-sys 0.59.0",
@@ -7101,33 +7374,36 @@ dependencies = [
 
 [[package]]
 name = "wasmer-wasix"
-version = "0.27.0"
+version = "0.601.0"
 dependencies = [
- "ahash 0.8.11",
  "anyhow",
+ "assert-panic",
  "async-trait",
- "base64 0.21.7",
+ "base64",
  "bincode",
  "blake3",
- "bytecheck",
- "bytes 1.6.1",
- "cfg-if 1.0.0",
+ "bus",
+ "bytecheck 0.6.12",
+ "bytes",
+ "cfg-if",
  "chrono",
  "cooked-waker",
- "dashmap 6.0.1",
- "derivative",
- "futures 0.3.30",
- "getrandom",
+ "crossbeam-channel",
+ "dashmap 6.1.0",
+ "derive_more 2.0.1",
+ "env_logger",
+ "futures",
+ "getrandom 0.2.16",
  "heapless",
  "hex",
- "http 1.1.0",
+ "http",
  "http-body-util",
  "hyper",
  "hyper-util",
  "js-sys",
- "lazy_static",
  "libc",
  "linked_hash_set",
+ "log",
  "lz4_flex",
  "num_enum",
  "once_cell",
@@ -7135,27 +7411,27 @@ dependencies = [
  "pin-project",
  "pin-utils",
  "pretty_assertions",
- "rand",
+ "rand 0.8.5",
  "rayon",
  "reqwest",
  "rkyv",
  "rusty_pool",
- "semver 1.0.23",
+ "semver 1.0.27",
  "serde",
  "serde_derive",
  "serde_json",
- "serde_yaml 0.9.34+deprecated",
+ "serde_yaml",
  "sha2",
  "shared-buffer",
  "tempfile",
  "terminal_size",
  "termios",
- "thiserror",
- "tokio 1.38.1",
+ "thiserror 1.0.69",
+ "tokio",
  "tokio-stream",
- "toml 0.8.15",
- "tower",
- "tower-http",
+ "toml 0.8.23",
+ "tower 0.4.13",
+ "tower-http 0.5.2",
  "tracing",
  "tracing-subscriber",
  "tracing-test",
@@ -7170,14 +7446,16 @@ dependencies = [
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "wasm-bindgen-test",
+ "wasm-encoder 0.235.0",
  "wasmer",
- "wasmer-config 0.8.0",
- "wasmer-emscripten",
+ "wasmer-config",
  "wasmer-journal",
+ "wasmer-package",
  "wasmer-types",
  "wasmer-wasix-types",
- "wcgi 0.2.0",
- "wcgi-host 0.2.0",
+ "wasmparser 0.224.1",
+ "wcgi",
+ "wcgi-host",
  "web-sys",
  "webc",
  "weezl",
@@ -7187,16 +7465,16 @@ dependencies = [
 
 [[package]]
 name = "wasmer-wasix-types"
-version = "0.27.0"
+version = "0.601.0"
 dependencies = [
  "anyhow",
  "bitflags 1.3.2",
  "byteorder",
- "cfg-if 1.0.0",
+ "cfg-if",
  "num_enum",
  "pretty_assertions",
  "serde",
- "time 0.3.36",
+ "time 0.3.44",
  "tracing",
  "wai-bindgen-gen-core",
  "wai-bindgen-gen-rust",
@@ -7208,57 +7486,45 @@ dependencies = [
  "wasmer-types",
 ]
 
-[[package]]
-name = "wasmer-wasm-interface"
-version = "4.3.7"
-dependencies = [
- "bincode",
- "either",
- "nom",
- "serde",
- "wasmparser 0.121.2",
- "wat",
-]
-
 [[package]]
 name = "wasmer-wast"
-version = "4.3.7"
+version = "6.1.0"
 dependencies = [
  "anyhow",
- "futures 0.3.30",
+ "futures",
  "serde",
  "tempfile",
- "thiserror",
- "tokio 1.38.1",
+ "thiserror 1.0.69",
+ "tokio",
  "virtual-fs",
  "wasmer",
  "wasmer-types",
  "wasmer-wasix",
- "wast 38.0.1",
+ "wast 221.0.3",
 ]
 
 [[package]]
 name = "wasmer-workspace"
-version = "4.3.7"
+version = "6.1.0"
 dependencies = [
  "anyhow",
  "build-deps",
- "cfg-if 1.0.0",
+ "cfg-if",
  "clap",
  "clap_builder",
  "clap_derive",
  "clap_lex",
  "compiler-test-derive",
  "criterion",
- "crossbeam-queue 0.3.11",
+ "crossbeam-queue",
  "glob",
- "lazy_static",
- "rustc_version 0.4.0",
+ "reqwest",
+ "rustc_version 0.4.1",
  "serial_test",
  "tempfile",
  "test-generator",
  "test-log",
- "tokio 1.38.1",
+ "tokio",
  "tracing",
  "tracing-subscriber",
  "ureq",
@@ -7269,32 +7535,123 @@ dependencies = [
  "wasmer-compiler-cranelift",
  "wasmer-compiler-llvm",
  "wasmer-compiler-singlepass",
- "wasmer-emscripten",
  "wasmer-middlewares",
  "wasmer-types",
  "wasmer-wasix",
  "wasmer-wast",
 ]
 
+[[package]]
+name = "wasmi"
+version = "0.40.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a19af97fcb96045dd1d6b4d23e2b4abdbbe81723dbc5c9f016eb52145b320063"
+dependencies = [
+ "arrayvec 0.7.6",
+ "multi-stash",
+ "smallvec",
+ "spin",
+ "wasmi_collections",
+ "wasmi_core",
+ "wasmi_ir",
+ "wasmparser 0.221.3",
+]
+
+[[package]]
+name = "wasmi_c_api_impl"
+version = "0.40.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45e45f29eb7b0a2c0789c3c8075fc9c2c05182d6be2222702c6c848f72a2c2df"
+dependencies = [
+ "wasmi",
+ "wasmi_c_api_macros",
+]
+
+[[package]]
+name = "wasmi_c_api_macros"
+version = "0.40.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e03aa7908b941120f347018583d474de0950ca1eae5bc3f6cb680e0f9fbd7695"
+dependencies = [
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "wasmi_collections"
+version = "0.40.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e80d6b275b1c922021939d561574bf376613493ae2b61c6963b15db0e8813562"
+
+[[package]]
+name = "wasmi_core"
+version = "0.40.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a8c51482cc32d31c2c7ff211cd2bedd73c5bd057ba16a2ed0110e7a96097c33"
+dependencies = [
+ "downcast-rs",
+ "libm",
+]
+
+[[package]]
+name = "wasmi_ir"
+version = "0.40.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e431a14c186db59212a88516788bd68ed51f87aa1e08d1df742522867b5289a"
+dependencies = [
+ "wasmi_core",
+]
+
 [[package]]
 name = "wasmparser"
-version = "0.95.0"
+version = "0.121.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2ea896273ea99b15132414be1da01ab0d8836415083298ecaffbe308eaac87a"
+checksum = "9dbe55c8f9d0dbd25d9447a5a889ff90c0cc3feaa7395310d3d826b2c703eaab"
 dependencies = [
- "indexmap 1.9.3",
- "url",
+ "bitflags 2.9.4",
+ "indexmap 2.11.4",
+ "semver 1.0.27",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.221.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d06bfa36ab3ac2be0dee563380147a5b81ba10dd8885d7fbbc9eb574be67d185"
+dependencies = [
+ "bitflags 2.9.4",
+ "indexmap 2.11.4",
+ "semver 1.0.27",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.224.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04f17a5917c2ddd3819e84c661fae0d6ba29d7b9c1f0e96c708c65a9c4188e11"
+dependencies = [
+ "bitflags 2.9.4",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.235.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "161296c618fa2d63f6ed5fffd1112937e803cb9ec71b32b01a76321555660917"
+dependencies = [
+ "bitflags 2.9.4",
+ "indexmap 2.11.4",
 ]
 
 [[package]]
 name = "wasmparser"
-version = "0.121.2"
+version = "0.239.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dbe55c8f9d0dbd25d9447a5a889ff90c0cc3feaa7395310d3d826b2c703eaab"
+checksum = "8c9d90bb93e764f6beabf1d02028c70a2156a6583e63ac4218dd07ef733368b0"
 dependencies = [
- "bitflags 2.6.0",
- "indexmap 2.2.6",
- "semver 1.0.23",
+ "bitflags 2.9.4",
+ "indexmap 2.11.4",
+ "semver 1.0.27",
 ]
 
 [[package]]
@@ -7309,64 +7666,60 @@ dependencies = [
 
 [[package]]
 name = "wast"
-version = "24.0.0"
+version = "216.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ff1e3bd3ad0b2ee7784add89c30dc96b89a54b43e5d6d95d774eda1863b3500"
+checksum = "62cc4cc72b93d4a11c416ad1b4bb37888a9ea1dff575ee865f5bf26682ceba0e"
 dependencies = [
+ "bumpalo",
  "leb128",
+ "memchr",
+ "unicode-width 0.1.14",
+ "wasm-encoder 0.216.1",
 ]
 
 [[package]]
 name = "wast"
-version = "38.0.1"
+version = "221.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae0d7b256bef26c898fa7344a2d627e8499f5a749432ce0a05eae1a64ff0c271"
+checksum = "7e0d10d282261b825ffb3d49f46e8309e60a8b608328b6a0b0578e80f3f98e57"
 dependencies = [
+ "bumpalo",
  "leb128",
+ "memchr",
+ "unicode-width 0.2.2",
+ "wasm-encoder 0.221.3",
 ]
 
 [[package]]
 name = "wast"
-version = "64.0.0"
+version = "239.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a259b226fd6910225aa7baeba82f9d9933b6d00f2ce1b49b80fa4214328237cc"
+checksum = "9139176fe8a2590e0fb174cdcaf373b224cb93c3dde08e4297c1361d2ba1ea5d"
 dependencies = [
- "leb128",
+ "bumpalo",
+ "leb128fmt",
  "memchr",
- "unicode-width",
- "wasm-encoder 0.32.0",
+ "unicode-width 0.2.2",
+ "wasm-encoder 0.239.0",
 ]
 
 [[package]]
 name = "wat"
-version = "1.0.71"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53253d920ab413fca1c7dc2161d601c79b4fdf631d0ba51dd4343bf9b556c3f6"
-dependencies = [
- "wast 64.0.0",
-]
-
-[[package]]
-name = "wcgi"
-version = "0.1.2"
+version = "1.239.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39ca8f334eec3a8197bd25a612c74f415b8691d219ee11f1acd20f15a3e2bf77"
+checksum = "3e1c941927d34709f255558166f8901a2005f8ab4a9650432e9281b7cc6f3b75"
 dependencies = [
- "http 0.2.12",
- "http-serde 1.1.3",
- "serde",
- "serde_json",
- "url",
+ "wast 239.0.0",
 ]
 
 [[package]]
 name = "wcgi"
-version = "0.2.0"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b51540185fb0764ba68176a955c9530f8f7501b418b034e30607f892fec261b2"
+checksum = "3977728575e8a79833db34f835b810dd7e1affdec0fa18cf141f060421cade6a"
 dependencies = [
- "http 1.1.0",
- "http-serde 2.1.1",
+ "http",
+ "http-serde",
  "serde",
  "serde_json",
  "url",
@@ -7374,36 +7727,31 @@ dependencies = [
 
 [[package]]
 name = "wcgi-host"
-version = "0.1.2"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a762cf2b0ed389a2a2fb591d63a398c1a4c0f8bef938cfd040285a3c63b695cc"
+checksum = "4d78a0358eebb970afcacc158f4172d2b7355d37572b350f1ed46dc44fe2e464"
 dependencies = [
- "http 0.2.12",
- "schemars",
+ "http",
  "serde",
- "tokio 1.38.1",
- "wasmparser 0.95.0",
- "wcgi 0.1.2",
+ "tokio",
+ "wcgi",
 ]
 
 [[package]]
-name = "wcgi-host"
-version = "0.2.0"
+name = "web-sys"
+version = "0.3.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cfc134be64da186b33675e0154827ba8eb4eb30579c1142cebec88607cd2cf6"
+checksum = "9367c417a924a74cae129e6a2ae3b47fabb1f8995595ab474029da749a8be120"
 dependencies = [
- "http 1.1.0",
- "serde",
- "tokio 1.38.1",
- "wasmparser 0.95.0",
- "wcgi 0.2.0",
+ "js-sys",
+ "wasm-bindgen",
 ]
 
 [[package]]
-name = "web-sys"
-version = "0.3.69"
+name = "web-time"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77afa9a11836342370f4817622a2f0f418b134426d91a82dfb48f532d2ec13ef"
+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -7411,69 +7759,76 @@ dependencies = [
 
 [[package]]
 name = "webc"
-version = "6.0.0"
+version = "10.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6cf1915e27168c1ed82f7f0d03f60317648f257fecaf4256a1904428d8e4ccd"
+checksum = "637506ca3c48eae3301e97f0167aa1b46cdfdd479d008b868a19715182e48ae3"
 dependencies = [
  "anyhow",
- "base64 0.22.1",
- "bytes 1.6.1",
- "cfg-if 1.0.0",
+ "base64",
+ "bytes",
+ "cfg-if",
  "ciborium",
  "document-features",
- "flate2",
  "ignore",
- "indexmap 1.9.3",
+ "indexmap 2.11.4",
  "leb128",
  "lexical-sort",
  "libc",
  "once_cell",
  "path-clean",
- "rand",
- "semver 1.0.23",
+ "rand 0.8.5",
  "serde",
  "serde_json",
  "sha2",
  "shared-buffer",
- "tar",
- "tempfile",
- "thiserror",
- "toml 0.8.15",
+ "thiserror 1.0.69",
  "url",
- "wasmer-config 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "webpki-roots"
-version = "0.26.3"
+version = "0.26.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd7c23921eeb1713a4e851530e9b9756e4fb0e89978582942612524cf09f01cd"
+checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
 dependencies = [
- "rustls-pki-types",
+ "webpki-roots 1.0.2",
 ]
 
 [[package]]
-name = "weezl"
-version = "0.1.8"
+name = "webpki-roots"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53a85b86a771b1c87058196170769dd264f66c0782acf1ae6cc51bfd64b39082"
+checksum = "7e8983c3ab33d6fb807cfcdad2491c4ea8cbc8ed839181c7dfd9c67c83e261b2"
+dependencies = [
+ "rustls-pki-types",
+]
 
 [[package]]
-name = "whoami"
-version = "1.5.1"
+name = "weedle2"
+version = "5.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a44ab49fad634e88f55bf8f9bb3abd2f27d7204172a112c7c9987e01c1c94ea9"
+checksum = "998d2c24ec099a87daf9467808859f9d82b61f1d9c9701251aea037f514eae0e"
 dependencies = [
- "redox_syscall 0.4.1",
- "wasite",
- "web-sys",
+ "nom 7.1.3",
 ]
 
 [[package]]
-name = "winapi"
-version = "0.2.8"
+name = "weezl"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a751b3277700db47d3e574514de2eced5e54dc8a5436a3bf7a0b248b2cee16f3"
+
+[[package]]
+name = "which"
+version = "7.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
+checksum = "24d643ce3fd3e5b54854602a080f34fb10ab75e0b813ee32d00ca2b44fa74762"
+dependencies = [
+ "either",
+ "env_home",
+ "rustix 1.1.2",
+ "winsafe",
+]
 
 [[package]]
 name = "winapi"
@@ -7485,12 +7840,6 @@ dependencies = [
  "winapi-x86_64-pc-windows-gnu",
 ]
 
-[[package]]
-name = "winapi-build"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"
-
 [[package]]
 name = "winapi-i686-pc-windows-gnu"
 version = "0.4.0"
@@ -7499,11 +7848,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
 [[package]]
 name = "winapi-util"
-version = "0.1.8"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -7514,24 +7863,61 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "windows-core"
-version = "0.52.0"
+version = "0.62.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
 dependencies = [
- "windows-targets 0.52.6",
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
 ]
 
 [[package]]
-name = "windows-sys"
-version = "0.33.0"
+name = "windows-implement"
+version = "0.60.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43dbb096663629518eb1dfa72d80243ca5a6aca764cae62a2df70af760a9be75"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
 dependencies = [
- "windows_aarch64_msvc 0.33.0",
- "windows_i686_gnu 0.33.0",
- "windows_i686_msvc 0.33.0",
- "windows_x86_64_gnu 0.33.0",
- "windows_x86_64_msvc 0.33.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link",
 ]
 
 [[package]]
@@ -7561,6 +7947,24 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.48.5"
@@ -7585,13 +7989,30 @@ dependencies = [
  "windows_aarch64_gnullvm 0.52.6",
  "windows_aarch64_msvc 0.52.6",
  "windows_i686_gnu 0.52.6",
- "windows_i686_gnullvm",
+ "windows_i686_gnullvm 0.52.6",
  "windows_i686_msvc 0.52.6",
  "windows_x86_64_gnu 0.52.6",
  "windows_x86_64_gnullvm 0.52.6",
  "windows_x86_64_msvc 0.52.6",
 ]
 
+[[package]]
+name = "windows-targets"
+version = "0.53.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
+dependencies = [
+ "windows-link",
+ "windows_aarch64_gnullvm 0.53.1",
+ "windows_aarch64_msvc 0.53.1",
+ "windows_i686_gnu 0.53.1",
+ "windows_i686_gnullvm 0.53.1",
+ "windows_i686_msvc 0.53.1",
+ "windows_x86_64_gnu 0.53.1",
+ "windows_x86_64_gnullvm 0.53.1",
+ "windows_x86_64_msvc 0.53.1",
+]
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.48.5"
@@ -7605,10 +8026,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
 [[package]]
-name = "windows_aarch64_msvc"
-version = "0.33.0"
+name = "windows_aarch64_gnullvm"
+version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd761fd3eb9ab8cc1ed81e56e567f02dd82c4c837e48ac3b2181b9ffc5060807"
+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
 
 [[package]]
 name = "windows_aarch64_msvc"
@@ -7623,10 +8044,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
 [[package]]
-name = "windows_i686_gnu"
-version = "0.33.0"
+name = "windows_aarch64_msvc"
+version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cab0cf703a96bab2dc0c02c0fa748491294bf9b7feb27e1f4f96340f208ada0e"
+checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
 
 [[package]]
 name = "windows_i686_gnu"
@@ -7640,6 +8061,12 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
+
 [[package]]
 name = "windows_i686_gnullvm"
 version = "0.52.6"
@@ -7647,10 +8074,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
 [[package]]
-name = "windows_i686_msvc"
-version = "0.33.0"
+name = "windows_i686_gnullvm"
+version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cfdbe89cc9ad7ce618ba34abc34bbb6c36d99e96cae2245b7943cd75ee773d0"
+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
 
 [[package]]
 name = "windows_i686_msvc"
@@ -7665,10 +8092,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
 [[package]]
-name = "windows_x86_64_gnu"
-version = "0.33.0"
+name = "windows_i686_msvc"
+version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4dd9b0c0e9ece7bb22e84d70d01b71c6d6248b81a3c60d11869451b4cb24784"
+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
 
 [[package]]
 name = "windows_x86_64_gnu"
@@ -7682,6 +8109,12 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.48.5"
@@ -7695,10 +8128,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
 [[package]]
-name = "windows_x86_64_msvc"
-version = "0.33.0"
+name = "windows_x86_64_gnullvm"
+version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff1e4aa646495048ec7f3ffddc411e1d829c026a2ec62b39da15c1055e406eaa"
+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
 
 [[package]]
 name = "windows_x86_64_msvc"
@@ -7713,83 +8146,71 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
-name = "winnow"
-version = "0.5.40"
+name = "windows_x86_64_msvc"
+version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876"
-dependencies = [
- "memchr",
-]
+checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
 
 [[package]]
 name = "winnow"
-version = "0.6.15"
+version = "0.7.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "557404e450152cd6795bb558bca69e43c585055f4606e3bcae5894fc6dac9ba0"
+checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
-name = "winreg"
-version = "0.52.0"
+name = "winsafe"
+version = "0.0.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a277a57398d4bfa075df44f501a17cfdf8542d224f0d36095a2adc7aee4ef0a5"
-dependencies = [
- "cfg-if 1.0.0",
- "windows-sys 0.48.0",
-]
+checksum = "d135d17ab770252ad95e9a872d365cf3090e3be864a34ab46f48555993efc904"
 
 [[package]]
-name = "ws2_32-sys"
-version = "0.2.1"
+name = "wit-bindgen"
+version = "0.46.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d59cefebd0c892fa2dd6de581e937301d8552cb44489cdff035c6187cb63fa5e"
-dependencies = [
- "winapi 0.2.8",
- "winapi-build",
-]
+checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
 
 [[package]]
-name = "wyz"
-version = "0.5.1"
+name = "writeable"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
-dependencies = [
- "tap",
-]
+checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb"
 
 [[package]]
 name = "xattr"
-version = "1.3.1"
+version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8da84f1a25939b27f6820d92aed108f83ff920fdf11a7b19366c27c4cda81d4f"
+checksum = "32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156"
 dependencies = [
  "libc",
- "linux-raw-sys",
- "rustix",
+ "rustix 1.1.2",
 ]
 
 [[package]]
 name = "xxhash-rust"
-version = "0.8.11"
+version = "0.8.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "63658493314859b4dfdf3fb8c1defd61587839def09582db50b8a4e93afca6bb"
+checksum = "fdd20c5420375476fbd4394763288da7eb0cc0b8c11deed431a91562af7335d3"
 
 [[package]]
-name = "yaml-rust"
-version = "0.4.5"
+name = "xz"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
+checksum = "3c887690ff2a2e233e8e49633461521f98ec57fbff9d59a884c9a4f04ec1da34"
 dependencies = [
- "linked-hash-map",
+ "xz2",
 ]
 
 [[package]]
-name = "yansi"
-version = "0.5.1"
+name = "xz2"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"
+checksum = "388c44dc09d76f1536602ead6d325eb532f5c122f17782bd57fb47baeeb767e2"
+dependencies = [
+ "lzma-sys",
+]
 
 [[package]]
 name = "yansi"
@@ -7797,13 +8218,47 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
 
+[[package]]
+name = "yoke"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc"
+dependencies = [
+ "serde",
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+ "synstructure",
+]
+
 [[package]]
 name = "zerocopy"
 version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
 dependencies = [
- "zerocopy-derive",
+ "byteorder",
+ "zerocopy-derive 0.7.35",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0894878a5fa3edfd6da3f88c4805f4c8558e2b996227a3d864f47fe11e38282c"
+dependencies = [
+ "zerocopy-derive 0.8.27",
 ]
 
 [[package]]
@@ -7814,42 +8269,160 @@ checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.106",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88d2b8d9c68ad2b9e4340d7832716a4d21a22a1154777ad56ea55c51a9cf3831"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+ "synstructure",
 ]
 
 [[package]]
 name = "zeroize"
-version = "1.8.1"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
+dependencies = [
+ "zeroize_derive",
+]
+
+[[package]]
+name = "zeroize_derive"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
+[[package]]
+name = "zerotrie"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
+checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
 
 [[package]]
 name = "zip"
-version = "2.1.5"
+version = "2.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b895748a3ebcb69b9d38dcfdf21760859a4b0d0b0015277640c2ef4c69640e6f"
+checksum = "fabe6324e908f85a1c52063ce7aa26b68dcb7eb6dbc83a2d148403c9bc3eba50"
 dependencies = [
+ "aes",
  "arbitrary",
+ "bzip2",
+ "constant_time_eq",
  "crc32fast",
- "crossbeam-utils 0.8.20",
+ "crossbeam-utils",
+ "deflate64",
  "displaydoc",
  "flate2",
- "indexmap 2.2.6",
+ "getrandom 0.3.3",
+ "hmac",
+ "indexmap 2.11.4",
+ "lzma-rs",
  "memchr",
- "thiserror",
+ "pbkdf2",
+ "sha1",
+ "thiserror 2.0.17",
+ "time 0.3.44",
+ "xz2",
+ "zeroize",
  "zopfli",
+ "zstd",
 ]
 
 [[package]]
 name = "zopfli"
-version = "0.8.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5019f391bac5cf252e93bbcc53d039ffd62c7bfb7c150414d61369afe57e946"
+checksum = "edfc5ee405f504cd4984ecc6f14d02d55cfda60fa4b689434ef4102aae150cd7"
 dependencies = [
  "bumpalo",
  "crc32fast",
- "lockfree-object-pool",
- "log 0.4.22",
- "once_cell",
+ "log",
  "simd-adler32",
 ]
+
+[[package]]
+name = "zstd"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"
+dependencies = [
+ "zstd-safe",
+]
+
+[[package]]
+name = "zstd-safe"
+version = "7.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d"
+dependencies = [
+ "zstd-sys",
+]
+
+[[package]]
+name = "zstd-sys"
+version = "2.0.16+zstd.1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748"
+dependencies = [
+ "cc",
+ "pkg-config",
+]
diff --git a/Cargo.toml b/Cargo.toml
index bff17a4d1d..1a866eac9f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,69 +12,71 @@ rust-version.workspace = true
 version.workspace = true
 
 [dependencies]
-wasmer = { version = "=4.3.7", path = "lib/api", default-features = false }
-wasmer-compiler = { version = "=4.3.7", path = "lib/compiler", features = [
-    "compiler",
+wasmer = { version = "=6.1.0", path = "lib/api", default-features = false }
+wasmer-compiler = { version = "=6.1.0", path = "lib/compiler", features = [
+	"compiler",
 ], optional = true }
-wasmer-compiler-cranelift = { version = "=4.3.7", path = "lib/compiler-cranelift", optional = true }
-wasmer-compiler-singlepass = { version = "=4.3.7", path = "lib/compiler-singlepass", optional = true }
-wasmer-compiler-llvm = { version = "=4.3.7", path = "lib/compiler-llvm", optional = true }
-wasmer-emscripten = { version = "=4.3.7", path = "lib/emscripten", optional = true }
+wasmer-compiler-cranelift = { version = "=6.1.0", path = "lib/compiler-cranelift", optional = true }
+wasmer-compiler-singlepass = { version = "=6.1.0", path = "lib/compiler-singlepass", optional = true }
+wasmer-compiler-llvm = { version = "=6.1.0", path = "lib/compiler-llvm", optional = true }
 wasmer-wasix = { path = "lib/wasix", optional = true }
-wasmer-wast = { version = "=4.3.7", path = "tests/lib/wast", optional = true }
-wasi-test-generator = { version = "=4.3.7", path = "tests/wasi-wast", optional = true }
-wasmer-cache = { version = "=4.3.7", path = "lib/cache", optional = true }
-wasmer-types = { version = "=4.3.7", path = "lib/types" }
-wasmer-middlewares = { version = "=4.3.7", path = "lib/middlewares", optional = true }
+wasmer-wast = { version = "=6.1.0", path = "tests/lib/wast", optional = true }
+wasi-test-generator = { version = "=6.1.0", path = "tests/wasi-wast", optional = true }
+wasmer-cache = { version = "=6.1.0", path = "lib/cache", optional = true }
+wasmer-types = { version = "=6.1.0", path = "lib/types" }
+wasmer-middlewares = { version = "=6.1.0", path = "lib/middlewares", optional = true }
+
 
 # Third party dependencies
+
 cfg-if = "1.0"
-tokio = { version = "1", features = [
-    "rt",
-    "rt-multi-thread",
-    "macros",
+tokio = { version = "1.39", features = [
+	"rt",
+	"rt-multi-thread",
+	"macros",
 ], optional = true }
 crossbeam-queue = "0.3.8"
 
 [workspace]
 members = [
-    "fuzz",
-    "lib/api",
-    "lib/api/macro-wasmer-universal-test",
-    "lib/backend-api",
-    "lib/c-api",
-    "lib/c-api/examples/wasmer-capi-examples-runner",
-    "lib/c-api/tests/wasmer-c-api-test-runner",
-    "lib/cache",
-    "lib/cli-compiler",
-    "lib/cli",
-    "lib/compiler-cranelift",
-    "lib/compiler-llvm",
-    "lib/compiler-singlepass",
-    "lib/compiler",
-    "lib/config",
-    "lib/derive",
-    "lib/emscripten",
-    "lib/object",
-    "lib/registry",
-    "lib/sys-utils",
-    "lib/types",
-    "lib/virtual-io",
-    "lib/virtual-fs",
-    "lib/virtual-net",
-    "lib/vm",
-    "lib/wai-bindgen-wasmer",
-    "lib/wasi-types",
-    "lib/wasix",
-    "lib/wasm-interface",
-    "lib/journal",
-    "tests/integration/cli",
-    "tests/integration/ios",
-    "tests/lib/compiler-test-derive",
-    "tests/lib/wast",
-    "tests/wasi-wast",
-    "tests/wasmer-argus",
+	"fuzz",
+	"lib/api",
+	"lib/api/macro-wasmer-universal-test",
+	"lib/backend-api",
+	"lib/c-api",
+	"lib/c-api/examples/wasmer-capi-examples-runner",
+	"lib/c-api/tests/wasmer-c-api-test-runner",
+	"lib/cache",
+	"lib/cli-compiler",
+	"lib/cli",
+	"lib/compiler-cranelift",
+	"lib/compiler-llvm",
+	"lib/compiler-singlepass",
+	"lib/compiler",
+	"lib/config",
+	"lib/derive",
+	"lib/sys-utils",
+	"lib/types",
+	"lib/sdk",
+	"lib/virtual-io",
+	"lib/virtual-fs",
+	"lib/virtual-net",
+	"lib/vm",
+	"lib/wai-bindgen-wasmer",
+	"lib/wasi-types",
+	"lib/wasix",
+	"lib/journal",
+	"lib/swift",
+	"lib/package",
+	"tests/integration/cli",
+	"tests/integration/ios",
+	"tests/lib/compiler-test-derive",
+	"tests/lib/wast",
+	"tests/wasi-wast",
+	"tests/wasmer-argus",
+	"lib/sdk",
 ]
+exclude = ["./lib/cli/tests/packages/axum"]
 resolver = "2"
 
 [workspace.package]
@@ -83,33 +85,93 @@ edition = "2021"
 homepage = "https://wasmer.io/"
 license = "MIT"
 repository = "https://github.com/wasmerio/wasmer"
-rust-version = "1.74"
-version = "4.3.7"
+rust-version = "1.84"
+version = "6.1.0"
 
 [workspace.dependencies]
 # Repo-local crates
+wasmer-package = { version = "0.601.0", path = "lib/package" }
 wasmer-config = { path = "./lib/config" }
 wasmer-wasix = { path = "./lib/wasix" }
+wasmer-sdk = { path = "./lib/sdk" }
 
 # Wasmer-owned crates
-webc = { version = "6.0.0", default-features = false, features = ["package"] }
-edge-schema = { version = "=0.1.0" }
+webc = "=10.0.1"
 shared-buffer = "0.1.4"
+loupe = "0.2.0"
 
 # Third-party crates
+bytes = "1"
+serde_bytes = { version = "0.11" }
+hex = "0.4"
+anyhow = "1.0"
+sha2 = "0.10"
+async-trait = "0.1.68"
+getrandom = "0.2"
+ciborium = "0.2.2"
+bytesize = "1.3.0"
+semver = "1.0"
+tempfile = "3.6.0"
+cfg-if = "1.0"
+tar = "0.4.40"
+flate2 = "1.0.34"
+log = "0.4.22"
+blake3 = "1.0"
+rayon = "1.7.0"
+itertools = "0.12"
+byteorder = "1.3"
+more-asserts = "0.2"
+enum-iterator = "0.7.0"
+backtrace = "0.3"
+hashbrown = "0.11"
+smallvec = "1.6"
+region = "3.0"
+once_cell = "1.17.1"
+num_enum = "0.7.3"
 dashmap = "6.0.1"
 http = "1.0.0"
 hyper = "1"
+hyper-util = "0.1.5"
+http-body-util = "0.1.1"
 reqwest = { version = "0.12.0", default-features = false }
 enumset = "1.1.0"
 memoffset = "0.9.0"
-wasmparser = { version = "0.121.0", default-features = false }
-rkyv = { version = "0.7.40", features = ["indexmap", "validation", "strict"] }
+wasmparser = { version = "0.224.0", default-features = false, features = [
+	"validate",
+	"features",
+	"simd",
+] }
+rkyv = { version = "0.8.8", features = ["indexmap-2", "bytes-1"] }
 memmap2 = { version = "0.6.2" }
-toml = {version = "0.5.9", features = ["preserve_order"]}
+toml = { version = "0.8", features = ["preserve_order"] }
 indexmap = "2"
-serde_yaml = "0.9.34"
+serde = { version = "1", default-features = false }
+serde_yaml = { version = "0.9.34" }
+serde_json = { version = "1" }
+bytecheck = { version = "0.6.8" }
 libc = { version = "^0.2", default-features = false }
+gimli = { version = "0.28.1" }
+futures-util = { version = "0.3.31" }
+mio = "1"
+# MIO 1.0 starts at tokio version 1.39, hence the minimum requirement.
+tokio = { version = "1.39.0", default-features = false }
+tokio-tungstenite = { version = "0.24.0" }
+tracing = { version = "0.1" }
+tracing-subscriber = { version = "0.3" }
+tracing-test = { version = "0.2" }
+socket2 = { version = "0.5.7", features = ["all"] }
+pretty_assertions = "1.4.0"
+base64 = "0.22.0"
+time = "0.3.36"
+url = "2.5"
+thiserror = "1"
+target-lexicon = { version = "0.12.2", default-features = false }
+object = { version = "0.32.0", default-features = true }
+derive_more = { version = "2.0.1", features = ["debug", "display"] }
+wasm-encoder = { version = "0.235.0", default-features = false, features = [
+	"std",
+] }
+ignore = "0.4"
 
 [build-dependencies]
 test-generator = { path = "tests/lib/test-generator" }
@@ -119,18 +181,17 @@ glob = "0.3"
 rustc_version = "0.4"
 
 [dev-dependencies]
-wasmer = { version = "=4.3.7", path = "lib/api", features = [
-    "compiler",
-    "singlepass",
-    "sys",
+wasmer = { version = "=6.1.0", path = "lib/api", features = [
+	"compiler",
+	"singlepass",
+	"sys",
 ] }
 anyhow = "1.0"
-criterion = { version = "0.5", default-features = false }
+criterion = { version = "0.5", features = ["csv_output"] }
 clap = { version = "=4.4.11" }
 clap_builder = { version = "=4.4.11" }
 clap_derive = { version = "=4.4.7" }
 clap_lex = { version = "=0.6.0" }
-lazy_static = "1.4"
 serial_test = { version = "2.0", default-features = false }
 compiler-test-derive = { path = "tests/lib/compiler-test-derive" }
 tempfile = "3.6.0"
@@ -139,24 +200,34 @@ ureq = "2.6"
 test-log = { version = "0.2", default-features = false, features = ["trace"] }
 tracing = { version = "0.1", default-features = false, features = ["log"] }
 tracing-subscriber = { version = "0.3", default-features = false, features = [
-    "env-filter",
-    "fmt",
+	"env-filter",
+	"fmt",
 ] }
+reqwest = { workspace = true, features = ["blocking", "rustls-tls"] }
 
 [features]
 # Don't add the compiler features in default, please add them on the Makefile
 # since we might want to autoconfigure them depending on the availability on the host.
-default = ["wat", "wast", "cache", "wasi", "engine", "emscripten", "middlewares"]
+default = ["wat", "wast", "cache", "wasi", "middlewares"]
 # backend means that the `wasmer` crate will be compiled with the `wasmer-compiler` or the `jsc`.
 # That means: that is able to execute modules
 backend = []
 jsc = ["wasmer/jsc", "backend", "wat", "wasmer/std"]
+
+# Enable the WAMR backend (using it as default only if it is the only backend enabled)
+wamr = ["wasmer/wamr"]
+
+# Enable the V8 backend (using it as default only if it is the only backend enabled)
+v8 = ["wasmer/v8"]
+
+# Enable the wasmi backend (using it as default only if it is the only backend enabled)
+wasmi = ["wasmer/wasmi"]
+
 engine = ["universal"]
 universal = []
 cache = ["wasmer-cache"]
 wast = ["wasmer-wast"]
-wasi = ["wasmer-wasix"]
-emscripten = ["wasmer-emscripten"]
+wasi = ["wasmer-wasix", "tokio"]
 wat = ["wasmer/wat"]
 compiler = ["wasmer/compiler", "backend", "wasmer-compiler/translator"]
 singlepass = ["compiler", "wasmer-compiler-singlepass", "wasmer/singlepass"]
@@ -204,6 +275,18 @@ opt-level = 3
 [profile.dev.package.digest]
 opt-level = 3
 
+[[bench]]
+name = "run"
+harness = false
+
+[[bench]]
+name = "compile"
+harness = false
+
+[[bench]]
+name = "deserialize_modules"
+harness = false
+
 [[bench]]
 name = "static_and_dynamic_functions"
 harness = false
@@ -267,6 +350,11 @@ name = "exported-memory"
 path = "examples/exports_memory.rs"
 required-features = ["backend"]
 
+[[example]]
+name = "funcref"
+path = "examples/funcref.rs"
+required-features = ["backend"]
+
 [[example]]
 name = "imported-function"
 path = "examples/imports_function.rs"
@@ -285,7 +373,7 @@ required-features = ["cranelift"]
 [[example]]
 name = "wasi"
 path = "examples/wasi.rs"
-required-features = ["backend", "wasi"]
+required-features = ["wasi"]
 
 [[example]]
 name = "wasi-manual-setup"
@@ -307,6 +395,11 @@ name = "memory"
 path = "examples/memory.rs"
 required-features = ["backend"]
 
+[[example]]
+name = "memory-grow"
+path = "examples/memory_grow.rs"
+required-features = ["backend"]
+
 [[example]]
 name = "instance"
 path = "examples/instance.rs"
diff --git a/Makefile b/Makefile
index 97dc61d550..d2a25bf881 100644
--- a/Makefile
+++ b/Makefile
@@ -18,15 +18,15 @@ SHELL=/usr/bin/env bash
 #
 # Here is what works and what doesn't:
 #
-# * Cranelift works everywhere,
+# * Cranelift works everywhere except */`loongarch64`,
 #
 # * LLVM works on Linux+Darwin/`amd64`,
-#   and linux+`aarch64`, linux+`riscv`
+#   and linux+`aarch64`, linux+`riscv`, linux+`loongarch64`
 #   but it doesn't work on Darwin/`aarch64` or Windows/`aarch64`.
 #
 # * Singlepass works on Linux+Darwin+Windows/`amd64`,
 #   and Linux+Darwin/`aarch64`
-#   it doesn't work on */`riscv`.
+#   it doesn't work on */`riscv` or */`loongarch64`.
 #
 # * Windows isn't tested on `aarch64`, that's why we consider it's not
 #   working, but it might possibly be.
@@ -48,6 +48,7 @@ IS_WINDOWS := 0
 IS_AMD64 := 0
 IS_AARCH64 := 0
 IS_RISCV64 := 0
+IS_LOONGARCH64 := 0
 
 # Test Windows apart because it doesn't support `uname -s`.
 ifeq ($(OS), Windows_NT)
@@ -80,11 +81,13 @@ else
 		IS_AARCH64 := 1
 	else ifneq (, $(filter $(uname), riscv64))
 		IS_RISCV64 := 1
+	else ifneq (, $(filter $(uname), loongarch64))
+		IS_LOONGARCH64 := 1
 	else
 		# We use spaces instead of tabs to indent `$(error)`
 		# otherwise it's considered as a command outside a
 		# target and it will fail.
-                $(error Unrecognized architecture, expect `x86_64`, `aarch64`, `arm64`, 'riscv64')
+                $(error Unrecognized architecture, expect `x86_64`, `aarch64`, `arm64`, 'riscv64', 'loongarch64')
 	endif
 
 	# Libc
@@ -111,10 +114,16 @@ endif
 ENABLE_CRANELIFT ?=
 ENABLE_LLVM ?=
 ENABLE_SINGLEPASS ?=
+ENABLE_V8 ?=
+ENABLE_WAMR ?=
+ENABLE_WASMI ?=
 
 # Which compilers we build. These have dependencies that may not be on the system.
 compilers :=
 
+# Other backends to enable in the build phase (not while testing)
+build_compilers :=
+
 ##
 # Cranelift
 ##
@@ -142,23 +151,23 @@ endif
 ifeq ($(ENABLE_LLVM), 0)
 	LLVM_VERSION :=
 	# … then maybe the user forced to enable the LLVM compiler.
-else ifeq ($(ENABLE_LLVM), 1)
+else ifneq ($(filter 1 true,$(ENABLE_LLVM)),)
 	LLVM_VERSION := $(shell llvm-config --version)
 	compilers += llvm
 	# … or try to autodetect LLVM from `llvm-config-<version>`.
-else ifneq (, $(shell which llvm-config-15 2>/dev/null))
-	LLVM_VERSION := $(shell llvm-config-15 --version)
+else ifneq (, $(shell which llvm-config-18 2>/dev/null))
+	LLVM_VERSION := $(shell llvm-config-18 --version)
 	compilers += llvm
-	# need force LLVM_SYS_150_PREFIX, or llvm_sys will not build in the case
-	export LLVM_SYS_150_PREFIX = $(shell llvm-config-15 --prefix)
+	# need force LLVM_SYS_180_PREFIX, or llvm_sys will not build in the case
+	export LLVM_SYS_180_PREFIX = $(shell llvm-config-18 --prefix)
 else ifneq (, $(shell which llvm-config 2>/dev/null))
 	LLVM_VERSION := $(shell llvm-config --version)
-	ifneq (, $(findstring 15,$(LLVM_VERSION)))
+	ifneq (, $(findstring 18,$(LLVM_VERSION)))
 		compilers += llvm
-		export LLVM_SYS_150_PREFIX = $(shell llvm-config --prefix)
-	else ifneq (, $(findstring 14,$(LLVM_VERSION)))
+		export LLVM_SYS_180_PREFIX = $(shell llvm-config --prefix)
+	else ifneq (, $(findstring 18,$(LLVM_VERSION)))
 		compilers += llvm
-		export LLVM_SYS_150_PREFIX = $(shell llvm-config --prefix)
+		export LLVM_SYS_180_PREFIX = $(shell llvm-config --prefix)
 	endif
 endif
 
@@ -168,6 +177,7 @@ exclude_tests := --exclude wasmer-c-api --exclude wasmer-cli --exclude wasmer-co
 # We run integration tests separately (it requires building the c-api)
 exclude_tests += --exclude wasmer-integration-tests-cli
 exclude_tests += --exclude wasmer-integration-tests-ios
+exclude_tests += --exclude wasmer-swift
 
 ifneq (, $(findstring llvm,$(compilers)))
 	ENABLE_LLVM := 1
@@ -202,11 +212,64 @@ ifneq (, $(findstring singlepass,$(compilers)))
 	ENABLE_SINGLEPASS := 1
 endif
 
+##
+# V8 
+##
+
+# If the user didn't disable the V8 backend…
+ifneq ($(ENABLE_V8), 0)
+	# … then maybe the user forced to enable the V8 compiler.
+	ifneq ($(filter 1 true,$(ENABLE_V8)),)
+		build_compilers += v8
+	endif
+	# we don't check automatically for now  
+endif
+
+ifneq (, $(findstring v8,$(build_compilers)))
+	ENABLE_V8 := 1
+endif
+
+##
+# WAMR 
+##
+
+# If the user didn't disable the WAMR backend…
+ifneq ($(ENABLE_WAMR), 0)
+	# … then maybe the user forced to enable the WAMR compiler.
+	ifneq ($(filter 1 true,$(ENABLE_WAMR)),)
+		build_compilers += wamr
+	# we don't check automatically for now  
+	endif
+endif
+
+ifneq (, $(findstring wamr,$(build_compilers)))
+	ENABLE_WAMR := 1
+endif
+
+##
+# wasmi 
+##
+
+# If the user didn't disable the wasmi backend…
+ifneq ($(ENABLE_WASMI), 0)
+	# … then maybe the user forced to enable the wasmi compiler.
+	ifneq ($(filter 1 true,$(ENABLE_WASMI)),)
+		build_compilers += wasmi
+	# we don't check automatically for now  
+	endif
+endif
+
+ifneq (, $(findstring wasmi,$(build_compilers)))
+	ENABLE_WASMI := 1
+endif
+
+
 ##
 # Clean the `compilers` variable.
 ##
 
 compilers := $(strip $(compilers))
+build_compilers := $(strip $(build_compilers) $(compilers))
 
 
 #####
@@ -240,6 +303,8 @@ ifeq ($(ENABLE_LLVM), 1)
 			compilers_engines += llvm-universal
 		else ifeq ($(IS_RISCV64), 1)
 			compilers_engines += llvm-universal
+		else ifeq ($(IS_LOONGARCH64), 1)
+			compilers_engines += llvm-universal
 		endif
 	endif
 endif
@@ -275,6 +340,7 @@ comma := ,
 
 # Define the compiler Cargo features for all crates.
 compiler_features := --features $(subst $(space),$(comma),$(compilers)),wasmer-artifact-create,static-artifact-create,wasmer-artifact-load,static-artifact-load
+build_compiler_features := --features $(subst $(space),$(comma),$(build_compilers)),wasmer-artifact-create,static-artifact-create,wasmer-artifact-load,static-artifact-load
 capi_compilers_engines_exclude :=
 
 # Define the compiler Cargo features for the C API. It always excludes
@@ -377,18 +443,30 @@ check-wasmer:
 	$(CARGO_BINARY) check $(CARGO_TARGET_FLAG) --manifest-path lib/cli/Cargo.toml $(compiler_features) --bin wasmer --locked
 
 check-wasmer-wasm:
-	$(CARGO_BINARY) check --manifest-path lib/cli-compiler/Cargo.toml --target wasm32-wasi --features singlepass,cranelift --bin wasmer-compiler --locked
+	$(CARGO_BINARY) check --manifest-path lib/cli-compiler/Cargo.toml --target wasm32-wasip1 --features singlepass,cranelift --bin wasmer-compiler --locked
 
 check-capi:
 	RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) check $(CARGO_TARGET_FLAG) --manifest-path lib/c-api/Cargo.toml  \
 		--no-default-features --features wat,compiler,wasi,middlewares $(capi_compiler_features)
 
 build-wasmer:
-	$(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --release --manifest-path lib/cli/Cargo.toml $(compiler_features) --bin wasmer --locked
+	$(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --release --manifest-path lib/cli/Cargo.toml $(build_compiler_features) --bin wasmer --locked
+	
+build-wasmer-v8:
+	$(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --release --manifest-path lib/cli/Cargo.toml --no-default-features --features="v8" --bin wasmer --locked
+
+build-wasmer-wamr:
+	$(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --release --manifest-path lib/cli/Cargo.toml --no-default-features --features="wamr" --bin wasmer --locked
+
+build-wasmer-wasmi:
+	$(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --release --manifest-path lib/cli/Cargo.toml --no-default-features --features="wasmi" --bin wasmer --locked
 
 build-wasmer-jsc:
 	$(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --release --manifest-path lib/cli/Cargo.toml --no-default-features --features="jsc,wat" --bin wasmer --locked
 
+build-wasmer-api-js:
+	$(CARGO_BINARY) rustc --target wasm32-unknown-unknown --release --manifest-path lib/api/Cargo.toml --no-default-features --features "js, js-default, wasm-types-polyfill, enable-serde" --crate-type=cdylib --locked
+
 build-wasmer-debug:
 	$(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --manifest-path lib/cli/Cargo.toml $(compiler_features) --bin wasmer --locked
 
@@ -396,7 +474,7 @@ bench:
 	$(CARGO_BINARY) bench $(CARGO_TARGET_FLAG) $(compiler_features)
 
 build-wasmer-wasm:
-	$(CARGO_BINARY) build --release --manifest-path lib/cli-compiler/Cargo.toml --target wasm32-wasi --features singlepass,cranelift --bin wasmer-compiler --locked
+	$(CARGO_BINARY) build --release --manifest-path lib/cli-compiler/Cargo.toml --target wasm32-wasip1 --features singlepass,cranelift --bin wasmer-compiler --locked
 
 # For best results ensure the release profile looks like the following
 # in Cargo.toml:
@@ -412,7 +490,7 @@ build-wasmer-wasm:
 # rpath = false
 build-wasmer-headless-minimal: RUSTFLAGS += -C panic=abort
 build-wasmer-headless-minimal:
-	RUSTFLAGS="${RUSTFLAGS}" xargo build --target $(HOST_TARGET) --release --manifest-path=lib/cli/Cargo.toml --no-default-features --features sys,headless-minimal --bin wasmer-headless
+	RUSTFLAGS="${RUSTFLAGS}" cargo build --target $(HOST_TARGET) --release --manifest-path=lib/cli/Cargo.toml --no-default-features --features sys,headless-minimal --bin wasmer-headless
 ifeq ($(IS_DARWIN), 1)
 	strip target/$(HOST_TARGET)/release/wasmer-headless
 else ifeq ($(IS_WINDOWS), 1)
@@ -422,7 +500,7 @@ else
 endif
 
 build-docs:
-	$(CARGO_BINARY) doc $(CARGO_TARGET_FLAG) --release $(compiler_features) --document-private-items --no-deps --workspace --exclude wasmer-c-api --locked
+	$(CARGO_BINARY) doc $(CARGO_TARGET_FLAG) --release $(compiler_features) --document-private-items --no-deps --workspace --exclude wasmer-c-api --exclude wasmer-swift --locked
 
 # The tokio crate was excluded from the docs build because the code (which is not under our control)
 # does not currently compile its docs successfully
@@ -454,20 +532,25 @@ test-build-docs-rs:
 	done
 
 test-build-docs-rs-ci:
-	@manifest_docs_rs_features_path="package.metadata.docs.rs.features"; \
+	# detect toml in the path
+	if ! command -v toml &> /dev/null; then \
+		echo "toml-cli could not be found. Please install it with `cargo install toml-cli`"; \
+		exit 1; \
+	fi; \
 	for manifest_path in lib/*/Cargo.toml; do \
-		toml get "$$manifest_path" "$$manifest_docs_rs_features_path" >/dev/null 2>&1; \
+		toml get "$$manifest_path" "package.metadata.docs.rs.features" >/dev/null 2>&1; \
+		printf "toml get \"$$manifest_path\" \"package.metadata.docs.rs.features\"\n"; \
 		if [ $$? -ne 0 ]; then \
 			features=""; \
 		else \
-			features=$$(toml get "$$manifest_path" "$$manifest_docs_rs_features_path" | sed 's/\[//; s/\]//; s/"\([^"]*\)"/\1/g'); \
+			features=$$(toml get "$$manifest_path" "package.metadata.docs.rs.features" | sed 's/\[//; s/\]//; s/"\([^"]*\)"/\1/g'); \
 		fi; \
-		printf "*** Building doc for package with manifest $$manifest_path ***\n\n"; \
+		printf "*** Building doc for package with manifest $$manifest_path and features $$features ***\n\n"; \
 		if [ -z "$$features" ]; then \
-			RUSTDOCFLAGS="--cfg=docsrs" $(CARGO_BINARY) +nightly-2023-10-05  doc $(CARGO_TARGET_FLAG) --manifest-path "$$manifest_path" --no-deps --locked || exit 1; \
+			RUSTDOCFLAGS="--cfg=docsrs" $(CARGO_BINARY) +nightly-2025-02-09 doc $(CARGO_TARGET_FLAG) --manifest-path "$$manifest_path" --no-deps --locked || exit 1; \
 		else \
 			printf "Following features are inferred from Cargo.toml: $$features\n\n\n"; \
-			RUSTDOCFLAGS="--cfg=docsrs" $(CARGO_BINARY) +nightly-2023-10-05 doc $(CARGO_TARGET_FLAG) --manifest-path "$$manifest_path" --no-deps --features "$$features" --locked || exit 1; \
+			RUSTDOCFLAGS="--cfg=docsrs" $(CARGO_BINARY) +nightly-2025-02-09 doc $(CARGO_TARGET_FLAG) --manifest-path "$$manifest_path" --no-deps --features "$$features" --locked || exit 1; \
 		fi; \
 	done
 
@@ -481,7 +564,7 @@ build-docs-capi:
 
 build-capi:
 	RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --manifest-path lib/c-api/Cargo.toml --release \
-		--no-default-features --features wat,compiler,wasi,middlewares,webc_runner $(capi_compiler_features) --locked
+		--no-default-features --features wat,sys-default,compiler,wasi,middlewares,webc_runner $(capi_compiler_features) --locked
 
 build-capi-singlepass:
 	RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --manifest-path lib/c-api/Cargo.toml --release \
@@ -507,24 +590,36 @@ build-capi-llvm-universal:
 	RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --manifest-path lib/c-api/Cargo.toml --release \
 		--no-default-features --features wat,compiler,llvm,wasi,middlewares,webc_runner --locked
 
+build-capi-v8:
+	RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --manifest-path lib/c-api/Cargo.toml --release \
+		--no-default-features --features wat,v8-default,wasi --locked
+
+build-capi-wamr:
+	RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --manifest-path lib/c-api/Cargo.toml --release \
+		--no-default-features --features wat,wamr-default,wasi --locked
+
+build-capi-wasmi:
+	RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --manifest-path lib/c-api/Cargo.toml --release \
+		--no-default-features --features wat,wasmi-default,wasi --locked
+
 build-capi-jsc:
 	RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --manifest-path lib/c-api/Cargo.toml --release \
-		--no-default-features --features wat,jsc,wasi --locked
+		--no-default-features --features wat,jsc-default,wasi --locked
 
 # Headless (we include the minimal to be able to run)
 
 build-capi-headless:
 ifeq ($(CARGO_TARGET_FLAG),)
-	RUSTFLAGS="${RUSTFLAGS} -C panic=abort -C link-dead-code -C lto -O -C embed-bitcode=yes" $(CARGO_BINARY) build --target $(HOST_TARGET) --manifest-path lib/c-api/Cargo.toml --release \
-		--no-default-features --features compiler-headless,wasi,webc_runner  --target-dir target/headless --locked
+	CARGO_TARGET_DIR=target/headless RUSTFLAGS="${RUSTFLAGS} -C panic=abort -C link-dead-code -C lto -O -C embed-bitcode=yes" $(CARGO_BINARY) build --target $(HOST_TARGET) --manifest-path lib/c-api/Cargo.toml --release \
+		--no-default-features --features compiler-headless,wasi,webc_runner --locked
 else
-	RUSTFLAGS="${RUSTFLAGS} -C panic=abort -C link-dead-code -C lto -O -C embed-bitcode=yes" $(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --manifest-path lib/c-api/Cargo.toml --release \
-		--no-default-features --features compiler-headless,wasi,webc_runner --target-dir target/headless --locked
+	CARGO_TARGET_DIR=target/headless RUSTFLAGS="${RUSTFLAGS} -C panic=abort -C link-dead-code -C lto -O -C embed-bitcode=yes" $(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --manifest-path lib/c-api/Cargo.toml --release \
+		--no-default-features --features compiler-headless,wasi,webc_runner --locked
 endif
 
 build-capi-headless-ios:
-	RUSTFLAGS="${RUSTFLAGS} -C panic=abort" cargo lipo --manifest-path lib/c-api/Cargo.toml --release \
-		--no-default-features --features compiler-headless,wasi,webc_runner --target-dir target/$(CARGO_TARGET)/headless
+	CARGO_TARGET_DIR=target/$(CARGO_TARGET)/headless RUSTFLAGS="${RUSTFLAGS} -C panic=abort" cargo lipo --manifest-path lib/c-api/Cargo.toml --release \
+		--no-default-features --features compiler-headless,wasi,webc_runner
 
 #####
 #
@@ -534,12 +629,12 @@ build-capi-headless-ios:
 
 # test compilers
 test-stage-0-wast:
-	$(CARGO_BINARY) nextest run $(CARGO_TARGET_FLAG) --release $(compiler_features) --locked
+	$(CARGO_BINARY) nextest run $(CARGO_TARGET_FLAG) --release $(compiler_features) --locked --jobs=1
 
 # test packages
 test-stage-1-test-all:
-	$(CARGO_BINARY) nextest run $(CARGO_TARGET_FLAG) --workspace --release $(exclude_tests) --exclude wasmer-c-api-test-runner --exclude wasmer-capi-examples-runner $(compiler_features) --locked
-	$(CARGO_BINARY) test --doc $(CARGO_TARGET_FLAG) --workspace --release $(exclude_tests) --exclude wasmer-c-api-test-runner --exclude wasmer-capi-examples-runner $(compiler_features) --locked
+	$(CARGO_BINARY) nextest run $(CARGO_TARGET_FLAG) --workspace --release $(exclude_tests) --exclude wasmer-c-api-test-runner --exclude wasmer-capi-examples-runner $(compiler_features) --locked --jobs=1
+	$(CARGO_BINARY) test --doc $(CARGO_TARGET_FLAG) --workspace --release $(exclude_tests) --exclude wasmer-c-api-test-runner --exclude wasmer-capi-examples-runner $(compiler_features) --locked --jobs=1
 test-stage-2-test-compiler-cranelift-nostd:
 	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --manifest-path lib/compiler-cranelift/Cargo.toml --release --no-default-features --features=std --locked
 test-stage-3-test-compiler-singlepass-nostd:
@@ -566,6 +661,22 @@ test-packages: test-stage-1-test-all test-stage-2-test-compiler-cranelift-nostd
 
 test-examples: test-stage-5-test-examples test-stage-6-test-examples-release
 
+
+test-v8: test-v8-api
+
+test-v8-api:
+	cargo nextest run --package=wasmer --release --features="v8-default" --no-default-features
+
+test-wamr: test-wamr-api
+
+test-wamr-api:
+	cargo nextest run --package=wasmer --release --features="wamr-default" --no-default-features
+
+test-wasmi: test-wasmi-api
+
+test-wasmi-api:
+	cargo nextest run --package=wasmer --release --features="wasmi-default" --no-default-features
+
 test-js: test-js-api test-js-wasi
 
 # TODO: disabled because the no-std / core feature doesn't actually work at the moment.
@@ -609,6 +720,10 @@ test-capi-ci: $(foreach compiler_engine,$(capi_compilers_engines),test-capi-crat
 # compilers first
 test-capi: build-capi package-capi test-capi-ci
 
+test-capi-v8: build-capi-v8 package-capi test-capi-integration-v8 
+test-capi-wasmi: build-capi-wasmi package-capi test-capi-integration-wasmi
+test-capi-wamr: build-capi-wamr package-capi test-capi-integration-wamr 
+
 test-capi-jsc: build-capi-jsc package-capi test-capi-integration-jsc
 
 test-capi-crate-%:
@@ -638,14 +753,23 @@ test-wasix: build-wasmer
 
 test-integration-cli: build-wasmer build-capi package-capi-headless package distribution
 	cp ./dist/wasmer.tar.gz ./link.tar.gz
-	rustup target add wasm32-wasi
+	rustup target add wasm32-wasip1
 	WASMER_DIR=`pwd`/package $(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --features webc_runner --no-fail-fast -p wasmer-integration-tests-cli --locked
 
 # Before running this in the CI, we need to set up link.tar.gz and /cache/wasmer-[target].tar.gz
 test-integration-cli-ci: require-nextest
-	rustup target add wasm32-wasi
+	rustup target add wasm32-wasip1
 	$(CARGO_BINARY) nextest run $(CARGO_TARGET_FLAG) --features webc_runner -p wasmer-integration-tests-cli --locked
 
+test-integration-cli-wamr-ci: require-nextest build-wasmer-wamr
+	rustup target add wasm32-wasip1
+	$(CARGO_BINARY) nextest run $(CARGO_TARGET_FLAG) --features webc_runner,wamr -p wasmer-integration-tests-cli --locked --no-fail-fast -E "not (test(deploy) | test(snapshot) | test(login) | test(init) | test(gen_c_header) | test(up_to_date) | test(publish) | test(create) | test(whoami) | test(config) | test(c_flags))"
+
+test-integration-cli-wasmi-ci: require-nextest build-wasmer-wasmi
+	rustup target add wasm32-wasip1
+	$(CARGO_BINARY) nextest run $(CARGO_TARGET_FLAG) --features webc_runner,wamr -p wasmer-integration-tests-cli --locked --no-fail-fast -E "not (test(deploy) | test(snapshot) | test(login) | test(init) | test(gen_c_header) | test(up_to_date) | test(publish) | test(create) | test(whoami) | test(config) | test(c_flags))"
+
+
 test-integration-ios:
 	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --features webc_runner -p wasmer-integration-tests-ios --locked
 
@@ -924,9 +1048,9 @@ install-wasmer-headless-minimal:
 update-testsuite:
 	git subtree pull --prefix tests/wast/spec https://github.com/WebAssembly/testsuite.git master --squash
 
-lint-packages: RUSTFLAGS += -D dead-code -D nonstandard-style -D unused-imports -D unused-mut -D unused-variables -D unused-unsafe -D unreachable-patterns -D bad-style -D improper-ctypes -D unused-allocation -D unused-comparisons -D while-true -D unconditional-recursion -D bare-trait-objects -D function_item_references # TODO: add `-D missing-docs`
+lint-packages: RUSTFLAGS += -D dead-code -D nonstandard-style -D unused-imports -D unused-mut -D unused-variables -D unused-unsafe -D unreachable-patterns -D bad-style -D improper-ctypes -D unused-allocation -D unused-comparisons -D while-true -D unconditional-recursion -D bare-trait-objects -D function_item_references -D clippy::uninlined_format_args # TODO: add `-D missing-docs`
 lint-packages:
-	RUSTFLAGS="${RUSTFLAGS}" cargo clippy --all --exclude wasmer-cli --locked -- -D clippy::all
+	RUSTFLAGS="${RUSTFLAGS}" cargo clippy --all --exclude wasmer-cli --exclude wasmer-swift --locked -- -D clippy::all
 	RUSTFLAGS="${RUSTFLAGS}" cargo clippy --manifest-path lib/cli/Cargo.toml --locked $(compiler_features) -- -D clippy::all
 	RUSTFLAGS="${RUSTFLAGS}" cargo clippy --manifest-path fuzz/Cargo.toml --locked $(compiler_features) -- -D clippy::all
 
@@ -948,3 +1072,7 @@ update-graphql-schema:
 
 require-nextest:
 	cargo nextest --version > /dev/null || cargo binstall cargo-nextest --secure || cargo install cargo-nextest
+
+# Check all the features compatible with the `sys` backend.
+check-api-features:
+	cargo check --package wasmer --features=$(subst $(space),$(comma),$(compilers)),default,artifact-size,core,enable-serde,wasmer-artifact-load,wasmer-artifact-create,static-artifact-load,static-artifact-create
diff --git a/README.md b/README.md
index fe42233abe..fef44a0f19 100644
--- a/README.md
+++ b/README.md
@@ -7,8 +7,8 @@
   </a>
 
   <p>
-    <a href="https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild">
-      <img src="https://github.com/wasmerio/wasmer/actions/workflows/build.yml/badge.svg?event=push" alt="Build Status">
+     <a href="https://github.com/wasmerio/wasmer/releases">
+      <img src="https://shields.io/github/v/tag/wasmerio/wasmer" alt="Github release">
     </a>
     <a href="https://github.com/wasmerio/wasmer/blob/main/LICENSE">
       <img src="https://img.shields.io/github/license/wasmerio/wasmer.svg" alt="License">
@@ -17,8 +17,11 @@
       <img src="https://img.shields.io/static/v1?label=Docs&message=docs.wasmer.io&color=blue" alt="Wasmer Docs">
     </a>
     <a href="https://discord.gg/rWkMNStrEW">
-      <img src="https://img.shields.io/discord/1110300506942881873" alt="Wasmer on Discord">
+      <img src="https://img.shields.io/discord/1110300506942881873?label=Wasmer&logo=discord&logoColor=white" alt="Wasmer on Discord">
     </a>
+    <a href="https://x.com/wasmerio">
+      <img src="https://img.shields.io/twitter/follow/wasmerio" alt="Wasmer on X">
+    </a>  
   </p>
 </div>
 
@@ -28,7 +31,7 @@ Wasmer is a _blazing fast_ and _secure_ [**WebAssembly**](https://webassembly.or
 _lightweight containers_ to run anywhere: from _Desktop_ to the _Cloud_, _Edge_ and your browser.
 
 - **Secure** by default. No file, network, or environment access, unless explicitly enabled.
-- **Pluggable**. supports [**WASIX**](https://wasix.org/), [WASI](https://github.com/WebAssembly/WASI) and [Emscripten](https://emscripten.org/) out of the box.
+- **Pluggable**. supports [**WASIX**](https://wasix.org/), [WASI](https://github.com/WebAssembly/WASI) out of the box.
 - **Incredibly Fast**. Run WebAssembly at near-native speeds.
 - **Embeddable** [anywhere via Wasmer SDKs](https://github.com/wasmerio/wasmer/#wasmer-sdk)
 
@@ -89,9 +92,12 @@ curl https://get.wasmer.io -sSfL | sh
 </details>
 
 > Note: You can also try Wasmer online in [wasmer.sh](https://wasmer.sh/)
-> 
+
 ### Quickstart
 
+> [!Tip]  
+> As part of our commitment to open source, we want to reward all GitHub users. In addition to the free tier, you can get up to $200 in [Wasmer Edge](https://wasmer.io/products/edge) credits for your open-source contributions - [Claim here](https://github.com/wasmerio/wasmer/discussions/5560).
+
 You can start by running
 [Cowsay](https://wasmer.io/syrusakbary/cowsay):
 
@@ -180,7 +186,7 @@ languages** with the Wasmer SDK:
 [js logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/js.svg
 [js integration]: https://github.com/wasmerio/wasmer-js
 [`@wasmerio` npm packages]: https://www.npmjs.com/org/wasmer
-[js docs]: https://docs.wasmer.io/integrations/js/reference-api
+[js docs]: https://docs.wasmer.io/sdk/wasmer-js
 [ruby logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/ruby.svg
 [ruby integration]: https://github.com/wasmerio/wasmer-ruby
 [`wasmer` ruby gem]: https://rubygems.org/gems/wasmer
@@ -238,7 +244,7 @@ We recommend reading the following guide on how to contribute into a complex pro
 https://mitchellh.com/writing/contributing-to-complex-projects
 
 Check our docs on how to [build Wasmer from
-source](https://docs.wasmer.io/developers/build-from-source) or [test your changes](https://docs.wasmer.io/developers/testing).
+source](./docs/BUILD.md) or [test your changes](https://docs.wasmer.io/developers/testing).
 
 <!-- ## Bounties
 
diff --git a/Xargo.toml b/Xargo.toml
deleted file mode 100644
index 2b87983bca..0000000000
--- a/Xargo.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-[dependencies]
-std = {}
diff --git a/benches/compile.rs b/benches/compile.rs
new file mode 100644
index 0000000000..6ce896a57a
--- /dev/null
+++ b/benches/compile.rs
@@ -0,0 +1,150 @@
+use criterion::{
+    criterion_group, criterion_main, measurement::WallTime, BenchmarkGroup, Criterion,
+};
+use wasmer::*;
+
+static BENCHMARKS_ARTIFACTS_BASE_URL: &str = "https://pub-083d1a0568d446d1aa5b2e07bd16983b.r2.dev";
+
+#[allow(unreachable_code)]
+fn get_engine() -> Engine {
+    #[cfg(feature = "llvm")]
+    return sys::LLVM::new().into();
+
+    #[cfg(feature = "singlepass")]
+    return sys::Singlepass::new().into();
+
+    #[cfg(feature = "cranelift")]
+    return sys::Cranelift::new().into();
+
+    #[cfg(not(any(feature = "cranelift", feature = "llvm", feature = "singlepass")))]
+    return Default::default();
+}
+
+pub fn compile_wasm(c: &mut BenchmarkGroup<'_, WallTime>, module: &[u8], name: &str) {
+    c.bench_function(name, |b| {
+        let engine = get_engine();
+
+        b.iter(|| {
+            let store = Store::new(engine.clone());
+            assert!(Module::new(&store, module).is_ok());
+        })
+    });
+}
+
+pub fn download_and_compile_small(c: &mut BenchmarkGroup<'_, WallTime>) {
+    let name = if cfg!(feature = "cranelift") {
+        "cranelift"
+    } else if cfg!(feature = "llvm") {
+        "llvm"
+    } else if cfg!(feature = "singlepass") {
+        "singlepass"
+    } else if cfg!(feature = "v8") {
+        "v8"
+    } else if cfg!(feature = "wamr") {
+        "wamr"
+    } else if cfg!(feature = "wasmi") {
+        "wasmi"
+    } else {
+        panic!("Unrecognized backend!")
+    };
+
+    let modules = [
+        "counter", "primes", "fib_rec", "fib_iter", "bulk_ops", "matmul",
+    ];
+
+    for module in modules {
+        let bytes =
+            reqwest::blocking::get(format!("{BENCHMARKS_ARTIFACTS_BASE_URL}/{module}.wasm"))
+                .unwrap()
+                .bytes()
+                .unwrap();
+        compile_wasm(c, bytes.as_ref(), &format!("exec/{name}/{module}"));
+    }
+}
+
+pub fn download_and_compile_medium(c: &mut BenchmarkGroup<'_, WallTime>) {
+    let name = if cfg!(feature = "cranelift") {
+        "cranelift"
+    } else if cfg!(feature = "llvm") {
+        "llvm"
+    } else if cfg!(feature = "singlepass") {
+        "singlepass"
+    } else if cfg!(feature = "v8") {
+        "v8"
+    } else if cfg!(feature = "wamr") {
+        "wamr"
+    } else if cfg!(feature = "wasmi") {
+        "wasmi"
+    } else {
+        panic!("Unrecognized backend!")
+    };
+
+    let modules = ["bash", "irb", "argon2"];
+
+    for module in modules {
+        let bytes =
+            reqwest::blocking::get(format!("{BENCHMARKS_ARTIFACTS_BASE_URL}/{module}.wasm"))
+                .unwrap()
+                .bytes()
+                .unwrap();
+        compile_wasm(c, bytes.as_ref(), &format!("exec/{name}/{module}"));
+    }
+}
+
+pub fn download_and_compile_large(c: &mut BenchmarkGroup<'_, WallTime>) {
+    let name = if cfg!(feature = "cranelift") {
+        "cranelift"
+    } else if cfg!(feature = "llvm") {
+        "llvm"
+    } else if cfg!(feature = "singlepass") {
+        "singlepass"
+    } else if cfg!(feature = "v8") {
+        "v8"
+    } else if cfg!(feature = "wamr") {
+        "wamr"
+    } else if cfg!(feature = "wasmi") {
+        "wasmi"
+    } else {
+        panic!("Unrecognized backend!")
+    };
+
+    let modules = [
+        "winterjs",
+        "wasix_axum",
+        "static_web_server",
+        "s3_server",
+        "python",
+        "php",
+    ];
+
+    for module in modules {
+        let bytes =
+            reqwest::blocking::get(format!("{BENCHMARKS_ARTIFACTS_BASE_URL}/{module}.wasm"))
+                .unwrap()
+                .bytes()
+                .unwrap();
+        compile_wasm(c, bytes.as_ref(), &format!("exec/{name}/{module}"));
+    }
+}
+
+pub fn download_and_compile(c: &mut Criterion) {
+    {
+        let mut group = c.benchmark_group("large_benches");
+        group.sample_size(10);
+        download_and_compile_large(&mut group);
+    }
+
+    {
+        let mut group = c.benchmark_group("medium_benches");
+        group.sample_size(40);
+        download_and_compile_medium(&mut group);
+    }
+    {
+        let mut group = c.benchmark_group("small_benches");
+        group.sample_size(60);
+        download_and_compile_small(&mut group);
+    }
+}
+
+criterion_group!(benches, download_and_compile);
+criterion_main!(benches);
diff --git a/benches/deserialize_modules.rs b/benches/deserialize_modules.rs
new file mode 100644
index 0000000000..10207a7723
--- /dev/null
+++ b/benches/deserialize_modules.rs
@@ -0,0 +1,51 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+
+use wasmer::*;
+
+static BENCHMARKS_ARTIFACTS_BASE_URL: &str = "https://pub-53a226d993e144159d6f8b993fe0cbf3.r2.dev";
+
+pub fn serialize_deserialize(c: &mut Criterion, bytes: &[u8], name: &str) {
+    let engine = Engine::default();
+
+    c.bench_function(&format!("rkyv_from-binary_{name}"), |b| {
+        b.iter(|| {
+            let module = Module::from_binary(&engine, bytes);
+            assert!(module.is_ok());
+            drop(module);
+        })
+    });
+}
+
+pub fn serialize_deserialize_unchecked(c: &mut Criterion, bytes: &[u8], name: &str) {
+    let engine = Engine::default();
+
+    c.bench_function(&format!("rkyv_from-binary-unchecked_{name}"), |b| {
+        b.iter(|| unsafe {
+            let module = Module::from_binary_unchecked(&engine, bytes);
+            assert!(module.is_ok());
+            drop(module);
+        })
+    });
+}
+
+pub fn download_and_run(c: &mut Criterion) {
+    let modules = ["small", "medium", "large"];
+
+    for module in modules {
+        let bytes =
+            reqwest::blocking::get(format!("{BENCHMARKS_ARTIFACTS_BASE_URL}/{module}.wasm"))
+                .unwrap()
+                .bytes()
+                .unwrap();
+        serialize_deserialize(c, &bytes, module);
+        serialize_deserialize_unchecked(c, &bytes, module);
+    }
+}
+
+criterion_group!(
+    name = benches;
+    config = Criterion::default().sample_size(60);
+    targets = download_and_run
+);
+
+criterion_main!(benches);
diff --git a/benches/import_functions.rs b/benches/import_functions.rs
index 2f1d4f758b..23fafc44c1 100644
--- a/benches/import_functions.rs
+++ b/benches/import_functions.rs
@@ -33,26 +33,23 @@ pub fn run_import_inner(store: &mut Store, n_fn: u32, compiler_name: &str, c: &m
     )
     .unwrap();
 
-    c.bench_function(
-        &format!("import in {} (size: {})", compiler_name, n_fn),
-        |b| {
-            let module = module.clone();
-            b.iter(|| {
-                let mut imports = imports! {};
-                for i in 0..n_fn {
-                    let name = format!("f{i}");
-                    imports.define(
-                        "env",
-                        &name,
-                        donor_instance.exports.get_function(&name).unwrap().clone(),
-                    );
-                }
-
-                let instance = black_box(Instance::new(store, &module, &imports));
-                assert!(instance.is_ok());
-            })
-        },
-    );
+    c.bench_function(&format!("import in {compiler_name} (size: {n_fn})"), |b| {
+        let module = module.clone();
+        b.iter(|| {
+            let mut imports = imports! {};
+            for i in 0..n_fn {
+                let name = format!("f{i}");
+                imports.define(
+                    "env",
+                    &name,
+                    donor_instance.exports.get_function(&name).unwrap().clone(),
+                );
+            }
+
+            let instance = black_box(Instance::new(store, &module, &imports));
+            assert!(instance.is_ok());
+        })
+    });
 }
 
 fn run_import_functions_benchmarks_small(_c: &mut Criterion) {
diff --git a/benches/mods/argon2.wasm b/benches/mods/argon2.wasm
new file mode 100644
index 0000000000..704cd488c2
Binary files /dev/null and b/benches/mods/argon2.wasm differ
diff --git a/benches/mods/bulk_ops.wasm b/benches/mods/bulk_ops.wasm
new file mode 100644
index 0000000000..fe27e5600e
Binary files /dev/null and b/benches/mods/bulk_ops.wasm differ
diff --git a/benches/mods/counter.wasm b/benches/mods/counter.wasm
new file mode 100644
index 0000000000..6551b6de65
Binary files /dev/null and b/benches/mods/counter.wasm differ
diff --git a/benches/mods/fib_iter.wasm b/benches/mods/fib_iter.wasm
new file mode 100644
index 0000000000..9526bb1c20
Binary files /dev/null and b/benches/mods/fib_iter.wasm differ
diff --git a/benches/mods/fib_rec.wasm b/benches/mods/fib_rec.wasm
new file mode 100644
index 0000000000..75d0af323b
Binary files /dev/null and b/benches/mods/fib_rec.wasm differ
diff --git a/benches/mods/matmul.wasm b/benches/mods/matmul.wasm
new file mode 100644
index 0000000000..3a51f2c9ae
Binary files /dev/null and b/benches/mods/matmul.wasm differ
diff --git a/benches/mods/primes.wasm b/benches/mods/primes.wasm
new file mode 100644
index 0000000000..6551b6de65
Binary files /dev/null and b/benches/mods/primes.wasm differ
diff --git a/benches/run.rs b/benches/run.rs
new file mode 100644
index 0000000000..d83eeff64c
--- /dev/null
+++ b/benches/run.rs
@@ -0,0 +1,82 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use wasmer::{sys::*, *};
+
+static BENCHMARKS_ARTIFACTS_BASE_URL: &str = "https://pub-083d1a0568d446d1aa5b2e07bd16983b.r2.dev";
+
+#[allow(unreachable_code)]
+fn get_engine() -> Engine {
+    #[cfg(feature = "llvm")]
+    return LLVM::new().into();
+
+    #[cfg(feature = "singlepass")]
+    return Singlepass::new().into();
+
+    #[cfg(feature = "cranelift")]
+    return Cranelift::new().into();
+
+    #[cfg(not(any(feature = "cranelift", feature = "llvm", feature = "singlepass")))]
+    return Default::default();
+}
+
+pub fn run_fn(c: &mut Criterion, module: &[u8], name: &str, input: i64) {
+    c.bench_function(name, |b| {
+        let engine = get_engine();
+        let mut store = Store::new(engine);
+        let module = Module::new(&store, module).unwrap();
+        let import_object = imports! {};
+        let instance = Instance::new(&mut store, &module, &import_object).unwrap();
+        let func = instance
+            .exports
+            .get_typed_function::<i64, i64>(&store, "run")
+            .unwrap();
+
+        b.iter(|| {
+            let _ = func.call(&mut store, input);
+        })
+    });
+}
+
+pub fn download_and_run(c: &mut Criterion) {
+    let name = if cfg!(feature = "cranelift") {
+        "cranelift"
+    } else if cfg!(feature = "llvm") {
+        "llvm"
+    } else if cfg!(feature = "singlepass") {
+        "singlepass"
+    } else if cfg!(feature = "v8") {
+        "v8"
+    } else if cfg!(feature = "wamr") {
+        "wamr"
+    } else if cfg!(feature = "wasmi") {
+        "wasmi"
+    } else {
+        panic!("Unrecognized backend!")
+    };
+
+    let modules = [
+        ("counter", 5_000_000),
+        ("primes", 1_000),
+        ("fib_rec", 40),
+        ("fib_iter", 2_000_000),
+        ("bulk_ops", 5_000),
+        ("matmul", 200),
+        ("argon2", 1),
+    ];
+
+    for (module, arg) in modules {
+        let bytes =
+            reqwest::blocking::get(format!("{BENCHMARKS_ARTIFACTS_BASE_URL}/{module}.wasm"))
+                .unwrap()
+                .bytes()
+                .unwrap();
+        run_fn(c, bytes.as_ref(), &format!("exec/{name}/{module}"), arg);
+    }
+}
+
+criterion_group!(
+    name = run_benches;
+    config = Criterion::default().sample_size(60);
+    targets = download_and_run
+);
+
+criterion_main!(run_benches);
diff --git a/benches/static_and_dynamic_functions.rs b/benches/static_and_dynamic_functions.rs
index 4a8bf30745..ab2d17b171 100644
--- a/benches/static_and_dynamic_functions.rs
+++ b/benches/static_and_dynamic_functions.rs
@@ -42,7 +42,7 @@ pub fn run_basic_static_function(store: &mut Store, compiler_name: &str, c: &mut
     let dyn_f: &Function = instance.exports.get("add").unwrap();
     let f: TypedFunction<(i32, i32), i32> = dyn_f.typed(store).unwrap();
 
-    c.bench_function(&format!("basic static func {}", compiler_name), |b| {
+    c.bench_function(&format!("basic static func {compiler_name}"), |b| {
         b.iter(|| {
             let result = black_box(f.call(store, 4, 6).unwrap());
             assert_eq!(result, 10);
@@ -76,7 +76,7 @@ pub fn run_basic_static_function(store: &mut Store, compiler_name: &str, c: &mut
         i32,
     > = dyn_f_many.typed(store).unwrap();
     c.bench_function(
-        &format!("basic static func with many args {}", compiler_name),
+        &format!("basic static func with many args {compiler_name}"),
         |b| {
             b.iter(|| {
                 let result = black_box(
@@ -103,7 +103,7 @@ pub fn run_basic_dynamic_function(store: &mut Store, compiler_name: &str, c: &mu
     let instance = Instance::new(store, &module, &import_object).unwrap();
 
     let dyn_f: &Function = instance.exports.get("add").unwrap();
-    c.bench_function(&format!("basic dynfunc {}", compiler_name), |b| {
+    c.bench_function(&format!("basic dynfunc {compiler_name}"), |b| {
         b.iter(|| {
             let dyn_result = black_box(dyn_f.call(store, &[Value::I32(4), Value::I32(6)]).unwrap());
             assert_eq!(dyn_result[0], Value::I32(10));
@@ -112,7 +112,7 @@ pub fn run_basic_dynamic_function(store: &mut Store, compiler_name: &str, c: &mu
 
     let dyn_f_many: &Function = instance.exports.get("add20").unwrap();
     c.bench_function(
-        &format!("basic dynfunc with many args {}", compiler_name),
+        &format!("basic dynfunc with many args {compiler_name}"),
         |b| {
             b.iter(|| {
                 let dyn_result = black_box(
diff --git a/build.rs b/build.rs
index d069178ba0..5028469735 100644
--- a/build.rs
+++ b/build.rs
@@ -22,6 +22,7 @@ fn main() -> anyhow::Result<()> {
         .expect("Can't get directory");
     build_deps::rerun_if_changed_paths("tests/wasi-wast/wasi/nightly-2022-10-18/*")
         .expect("Can't get directory");
+    build_deps::rerun_if_changed_paths("tests/wast/spec/proposals/*").expect("Can't get directory");
 
     let out_dir = PathBuf::from(
         env::var_os("OUT_DIR").expect("The OUT_DIR environment variable must be set"),
@@ -42,6 +43,11 @@ fn main() -> anyhow::Result<()> {
                 wast_processor,
             )?;
             test_directory_module(spectests, "tests/wast/spec/proposals/simd", wast_processor)?;
+            test_directory_module(
+                spectests,
+                "tests/wast/spec/proposals/exception-handling",
+                wast_processor,
+            )?;
             test_directory_module(
                 spectests,
                 "tests/wast/spec/proposals/threads",
@@ -86,7 +92,7 @@ fn main() -> anyhow::Result<()> {
                         with_test_module(wasitests, wasi_filesystem_test_name, |wasitests| {
                             test_directory(
                                 wasitests,
-                                format!("tests/wasi-wast/wasi/{}", wasi_version),
+                                format!("tests/wasi-wast/wasi/{wasi_version}"),
                                 |out, path| wasi_processor(out, path, wasi_filesystem_kind),
                             )
                         })?;
diff --git a/deny.toml b/deny.toml
index 949f572118..293f8df2aa 100644
--- a/deny.toml
+++ b/deny.toml
@@ -9,6 +9,11 @@
 # The values provided in this template are the default values that will be used
 # when any section or field is not specified in your own configuration
 
+# Root options
+
+# The graph table configures how the dependency graph is constructed and thus
+# which crates the checks are performed against
+[graph]
 # If 1 or more target triples (and optionally, target_features) are specified,
 # only the specified targets will be checked when running `cargo deny check`.
 # This means, if a particular package is only ever used as a target specific
@@ -18,132 +23,144 @@
 # dependencies not shared by any other crates, would be ignored, as the target
 # list here is effectively saying which targets you are building for.
 targets = [
-    # The triple can be any string, but only the target triples built in to
-    # rustc (as of 1.40) can be checked against actual config expressions
-    #{ triple = "x86_64-unknown-linux-musl" },
-    # You can also specify which target_features you promise are enabled for a
-    # particular target. target_features are currently not validated against
-    # the actual valid features supported by the target architecture.
-    #{ triple = "wasm32-unknown-unknown", features = ["atomics"] },
+	# The triple can be any string, but only the target triples built in to
+	# rustc (as of 1.40) can be checked against actual config expressions
+	#"x86_64-unknown-linux-musl",
+	# You can also specify which target_features you promise are enabled for a
+	# particular target. target_features are currently not validated against
+	# the actual valid features supported by the target architecture.
+	#{ triple = "wasm32-unknown-unknown", features = ["atomics"] },
 ]
+# When creating the dependency graph used as the source of truth when checks are
+# executed, this field can be used to prune crates from the graph, removing them
+# from the view of cargo-deny. This is an extremely heavy hammer, as if a crate
+# is pruned from the graph, all of its dependencies will also be pruned unless
+# they are connected to another crate in the graph that hasn't been pruned,
+# so it should be used with care. The identifiers are [Package ID Specifications]
+# (https://doc.rust-lang.org/cargo/reference/pkgid-spec.html)
+#exclude = []
+# If true, metadata will be collected with `--all-features`. Note that this can't
+# be toggled off if true, if you want to conditionally enable `--all-features` it
+# is recommended to pass `--all-features` on the cmd line instead
+all-features = false
+# If true, metadata will be collected with `--no-default-features`. The same
+# caveat with `all-features` applies
+no-default-features = false
+# If set, these feature will be enabled when collecting metadata. If `--features`
+# is specified on the cmd line they will take precedence over this option.
+#features = []
+
+# The output table provides options for how/if diagnostics are outputted
+[output]
+# When outputting inclusion graphs in diagnostics that include features, this
+# option can be used to specify the depth at which feature edges will be added.
+# This option is included since the graphs can be quite large and the addition
+# of features from the crate(s) to all of the graph roots can be far too verbose.
+# This option can be overridden via `--feature-depth` on the cmd line
+feature-depth = 1
 
 # This section is considered when running `cargo deny check advisories`
 # More documentation for the advisories section can be found here:
 # https://embarkstudios.github.io/cargo-deny/checks/advisories/cfg.html
 [advisories]
-# The path where the advisory database is cloned/fetched into
-db-path = "~/.cargo/advisory-db"
+# The path where the advisory databases are cloned/fetched into
+#db-path = "$CARGO_HOME/advisory-dbs"
 # The url(s) of the advisory databases to use
-db-urls = ["https://github.com/rustsec/advisory-db"]
-# The lint level for security vulnerabilities
-vulnerability = "deny"
-# The lint level for unmaintained crates
-unmaintained = "warn"
-# The lint level for crates that have been yanked from their source registry
-yanked = "deny"
-# The lint level for crates with security notices. Note that as of
-# 2019-12-17 there are no security notice advisories in
-# https://github.com/rustsec/advisory-db
-notice = "warn"
+#db-urls = ["https://github.com/rustsec/advisory-db"]
 # A list of advisory IDs to ignore. Note that ignored advisories will still
 # output a note when they are encountered.
 ignore = [
-    #"RUSTSEC-0000-0000",
+	#"RUSTSEC-0000-0000",
+	#{ id = "RUSTSEC-0000-0000", reason = "you can specify a reason the advisory is ignored" },
+	#"a-crate-that-is-yanked@0.1.1", # you can also ignore yanked crate versions if you wish
+	#{ crate = "a-crate-that-is-yanked@0.1.1", reason = "you can specify why you are ignoring the yanked crate" },
 
+	"proc-macro-error@1.0.4",
+	"RUSTSEC-2024-0370",
+	"RUSTSEC-2024-0436",
 ]
 # If this is true, then cargo deny will use the git executable to fetch advisory database.
 # If this is false, then it uses a built-in git library.
 # Setting this to true can be helpful if you have special authentication requirements that cargo-deny does not support.
 # See Git Authentication for more information about setting up git authentication.
-git-fetch-with-cli = true
-# Threshold for security vulnerabilities, any vulnerability with a CVSS score
-# lower than the range specified will be ignored. Note that ignored advisories
-# will still output a note when they are encountered.
-# * None - CVSS Score 0.0
-# * Low - CVSS Score 0.1 - 3.9
-# * Medium - CVSS Score 4.0 - 6.9
-# * High - CVSS Score 7.0 - 8.9
-# * Critical - CVSS Score 9.0 - 10.0
-#severity-threshold =
+#git-fetch-with-cli = true
 
 # This section is considered when running `cargo deny check licenses`
 # More documentation for the licenses section can be found here:
 # https://embarkstudios.github.io/cargo-deny/checks/licenses/cfg.html
 [licenses]
-# The lint level for crates which do not have a detectable license
-unlicensed = "deny"
 # List of explicitly allowed licenses
 # See https://spdx.org/licenses/ for list of possible licenses
-# [possible values: any SPDX 3.7 short identifier (+ optional exception)].
+# [possible values: any SPDX 3.11 short identifier (+ optional exception)].
 allow = [
-    "MIT",
-    "Apache-2.0",
-    "Apache-2.0 WITH LLVM-exception",
+	"MIT",
+	"Apache-2.0",
+	"Apache-2.0 WITH LLVM-exception",
+	"ISC",
+	"BSD-2-Clause",
+	"MPL-2.0",
+	"0BSD",
+	"CC0-1.0",
+	"OpenSSL",
+	"BSD-3-Clause",
+	"Unicode-DFS-2016",
+	"Unicode-3.0",
+	# BOOST source license
+	# NOTE: not to be confused with business source license!
+	"BSL-1.0",
+	"Unicode-3.0",
+	"CDLA-Permissive-2.0",
 ]
-# List of explicitly disallowed licenses
-# See https://spdx.org/licenses/ for list of possible licenses
-# [possible values: any SPDX 3.7 short identifier (+ optional exception)].
-deny = [
-    "AGPL-1.0",
-    "AGPL-3.0",
-]
-# Lint level for licenses considered copyleft
-copyleft = "warn"
-# Blanket approval or denial for OSI-approved or FSF Free/Libre licenses
-# * both - The license will be approved if it is both OSI-approved *AND* FSF
-# * either - The license will be approved if it is either OSI-approved *OR* FSF
-# * osi-only - The license will be approved if is OSI-approved *AND NOT* FSF
-# * fsf-only - The license will be approved if is FSF *AND NOT* OSI-approved
-# * neither - This predicate is ignored and the default lint level is used
-allow-osi-fsf-free = "either"
-# Lint level used when no other predicates are matched
-# 1. License isn't in the allow or deny lists
-# 2. License isn't copyleft
-# 3. License isn't OSI/FSF, or allow-osi-fsf-free = "neither"
-default = "deny"
 # The confidence threshold for detecting a license from license text.
 # The higher the value, the more closely the license text must be to the
 # canonical license text of a valid SPDX license file.
 # [possible values: any between 0.0 and 1.0].
-confidence-threshold = 0.8
+confidence-threshold = 0.6
 # Allow 1 or more licenses on a per-crate basis, so that particular licenses
 # aren't accepted for every possible crate as with the normal allow list
 exceptions = [
-    # Each entry is the crate and version constraint, and its specific allow
-    # list
-]
-
+	# Each entry is the crate and version constraint, and its specific allow
+	# list
+	#{ allow = ["Zlib"], crate = "adler32" },
 
+	{ allow = ["BUSL-1.1"], crate = "wasmer-compiler-singlepass" },
+	{ allow = ["BUSL-1.1"], crate = "wasmer-compiler-llvm" },
+]
 
 # Some crates don't have (easily) machine readable licensing information,
 # adding a clarification entry for it allows you to manually specify the
 # licensing information
-[[licenses.clarify]]
-name = "webc"
-version = "*"
-expression = "BSL-1.0"
-license-files = [
-  { path = "LICENSE.txt", hash = 0xa2180a97 }
-]
+#[[licenses.clarify]]
+# The package spec the clarification applies to
+#crate = "ring"
+# The SPDX expression for the license requirements of the crate
+#expression = "MIT AND ISC AND OpenSSL"
+# One or more files in the crate's source used as the "source of truth" for
+# the license expression. If the contents match, the clarification will be used
+# when running the license check, otherwise the clarification will be ignored
+# and the crate will be checked normally, which may produce warnings or errors
+# depending on the rest of your configuration
+#license-files = [
+# Each entry is a crate relative path, and the (opaque) hash of its contents
+#{ path = "LICENSE", hash = 0xbd0eed23 }
+#]
 
 [[licenses.clarify]]
-name = "ring"
-version = "*"
+crate = "ring"
 expression = "MIT AND ISC AND OpenSSL"
-license-files = [
-    # Each entry is a crate relative path, and the (opaque) hash of its contents
-    { path = "LICENSE", hash = 0xbd0eed23 }
-]
+license-files = [{ path = "LICENSE", hash = 0xbd0eed23 }]
 
 [licenses.private]
 # If true, ignores workspace crates that aren't published, or are only
-# published to private registries
+# published to private registries.
+# To see how to mark a crate as unpublished (to the official registry),
+# visit https://doc.rust-lang.org/cargo/reference/manifest.html#the-publish-field.
 ignore = false
 # One or more private registries that you might publish crates to, if a crate
 # is only published to private registries, and ignore is true, the crate will
 # not have its license(s) checked
 registries = [
-    #"https://sekretz.com/registry
+	#"https://sekretz.com/registry
 ]
 
 # This section is considered when running `cargo deny check bans`.
@@ -160,41 +177,63 @@ wildcards = "allow"
 # * simplest-path - The path to the version with the fewest edges is highlighted
 # * all - Both lowest-version and simplest-path are used
 highlight = "all"
+# The default lint level for `default` features for crates that are members of
+# the workspace that is being checked. This can be overridden by allowing/denying
+# `default` on a crate-by-crate basis if desired.
+workspace-default-features = "allow"
+# The default lint level for `default` features for external crates that are not
+# members of the workspace. This can be overridden by allowing/denying `default`
+# on a crate-by-crate basis if desired.
+external-default-features = "allow"
 # List of crates that are allowed. Use with care!
 allow = [
-    #{ name = "ansi_term", version = "=0.11.0" },
+	#"ansi_term@0.11.0",
+	#{ crate = "ansi_term@0.11.0", reason = "you can specify a reason it is allowed" },
 ]
 # List of crates to deny
 deny = [
-    # Each entry the name of a crate and a version range. If version is
-    # not specified, all versions will be matched.
-    #{ name = "ansi_term", version = "=0.11.0" },
-    #
-    # Wrapper crates can optionally be specified to allow the crate when it
-    # is a direct dependency of the otherwise banned crate
-    #{ name = "ansi_term", version = "=0.11.0", wrappers = [] },
+	#"ansi_term@0.11.0",
+	#{ crate = "ansi_term@0.11.0", reason = "you can specify a reason it is banned" },
+	# Wrapper crates can optionally be specified to allow the crate when it
+	# is a direct dependency of the otherwise banned crate
+	#{ crate = "ansi_term@0.11.0", wrappers = ["this-crate-directly-depends-on-ansi_term"] },
 ]
+
+# List of features to allow/deny
+# Each entry the name of a crate and a version range. If version is
+# not specified, all versions will be matched.
+#[[bans.features]]
+#crate = "reqwest"
+# Features to not allow
+#deny = ["json"]
+# Features to allow
+#allow = [
+#    "rustls",
+#    "__rustls",
+#    "__tls",
+#    "hyper-rustls",
+#    "rustls",
+#    "rustls-pemfile",
+#    "rustls-tls-webpki-roots",
+#    "tokio-rustls",
+#    "webpki-roots",
+#]
+# If true, the allowed features must exactly match the enabled feature set. If
+# this is set there is no point setting `deny`
+#exact = true
+
 # Certain crates/versions that will be skipped when doing duplicate detection.
 skip = [
-    { name = "webc" },  # licence is not fetched correctly and end up as unknown
-    { name = "ahash", version = "=0.4.7" },
-    { name = "hashbrown", version = "=0.9.1" },
-    { name = "cfg-if", version = "=0.1.10" },
-    { name = "gimli", version = "=0.25.0" },
-    { name = "strsim", version = "=0.8.0" },
-    { name = "semver", version = "=0.9.0" },
-    { name = "semver", version = "=0.11.0" },
-    { name = "semver-parser", version = "=0.7.0" },
-    { name = "rustc_version", version = "=0.2.3" },
-    { name = "itoa", version = "=0.4.8" },
-    { name = "object", version = "=0.27.1" },
+	#"ansi_term@0.11.0",
+	#{ crate = "ansi_term@0.11.0", reason = "you can specify a reason why it can't be updated/removed" },
 ]
 # Similarly to `skip` allows you to skip certain crates during duplicate
 # detection. Unlike skip, it also includes the entire tree of transitive
 # dependencies starting at the specified crate, up to a certain depth, which is
-# by default infinite
+# by default infinite.
 skip-tree = [
-    #{ name = "ansi_term", version = "=0.11.0", depth = 20 },
+	#"ansi_term@0.11.0", # will be skipped along with _all_ of its direct and transitive dependencies
+	#{ crate = "ansi_term@0.11.0", depth = 20 },
 ]
 
 # This section is considered when running `cargo deny check sources`.
@@ -203,20 +242,20 @@ skip-tree = [
 [sources]
 # Lint level for what to happen when a crate from a crate registry that is not
 # in the allow list is encountered
-unknown-registry = "deny"
+unknown-registry = "warn"
 # Lint level for what to happen when a crate from a git repository that is not
 # in the allow list is encountered
-unknown-git = "deny"
+unknown-git = "warn"
 # List of URLs for allowed crate registries. Defaults to the crates.io index
 # if not specified. If it is specified but empty, no registries are allowed.
 allow-registry = ["https://github.com/rust-lang/crates.io-index"]
 # List of URLs for allowed Git repositories
 allow-git = []
 
-#[sources.allow-org]
+[sources.allow-org]
 # 1 or more github.com organizations to allow git sources for
-#github = [""]
+github = []
 # 1 or more gitlab.com organizations to allow git sources for
-#gitlab = [""]
+gitlab = []
 # 1 or more bitbucket.org organizations to allow git sources for
-#bitbucket = [""]
+bitbucket = []
diff --git a/docs/ATTRIBUTIONS.md b/docs/ATTRIBUTIONS.md
index 1f1cca7ce1..c322f14091 100644
--- a/docs/ATTRIBUTIONS.md
+++ b/docs/ATTRIBUTIONS.md
@@ -6,7 +6,7 @@ Listed below are notable sections of code that are licensed
 from other projects and the relevant license of those projects.
 
 These are the projects that were used as inspiration and/or that we are using code from.
-Each of the subcrates we have have an `Aknowledgements` section with more details.
+Each of the subcrates we have an `Aknowledgements` section with more details.
 
 Projects:
 
diff --git a/docs/BUILD.md b/docs/BUILD.md
index 09439213b8..ada65e811a 100644
--- a/docs/BUILD.md
+++ b/docs/BUILD.md
@@ -2,7 +2,7 @@
 
 ## Installing Rustup
 
-Building Wasmer from source requires [Rust](https://rustup.rs/) **1.67+**.
+Building Wasmer from source requires [Rust](https://rustup.rs/) **1.84+**.
 
 The easiest way to install Rust on your system is via Rustup. To get Rustup on Linux and macOS, you can run the following:
 
@@ -15,14 +15,30 @@ curl https://sh.rustup.rs -sSf | sh
 
 ## Installing Additional Dependencies
 
+### Linux
+
+Linux is fully supported by Wasmer. WASI(x) is also fully supported. Users
+building from source can enable the LLVM backend following the instruction in
+the dedicated section below and installing LLVM version 18. To install it,
+refer to [LLVM's download
+page](https://github.com/llvm/llvm-project/releases/tag/llvmorg-18.1.7) or
+check your distro's package manager.
+
+### macOS
+
+macOS is fully supported by Wasmer. WASI(x) is also fully supported. Users
+building from source can enable the LLVM backend following the instruction in
+the dedicated section below and installing LLVM version 18. To install it on
+macOS, you can use [homebrew](https://brew.sh/): `brew install llvm@18`.
+
 ### Windows
 
-Windows is fully supported by Wasmer. WASI is also fully supported, but Emscripten support is still experimental.
+Windows is fully supported by Wasmer. WASI(x) is also fully supported.
 
 1. Install [Visual Studio](https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community&rel=15)
 2. Install [Rust for Windows](https://win.rustup.rs/)
 3. Install [Git for Windows](https://git-scm.com/download/win). Allow it to add `git.exe` to your PATH (default settings for the installer are fine).
-4. \(optional\) Install [LLVM 11.0](https://prereleases.llvm.org/win-snapshots/LLVM-11.0.0-2663a25f-win64.exe)
+4. \(optional\) Install [LLVM 18.0](https://github.com/llvm/llvm-project/releases/download/llvmorg-18.1.7/LLVM-18.1.7-win64.exe)
 
 ## Building the Wasmer Runtime
 
@@ -35,41 +51,53 @@ git clone https://github.com/wasmerio/wasmer.git
 cd wasmer
 ```
 
-Wasmer supports three different compilers at the moment:
+Wasmer supports six different backends at the moment: `singlepass`,
+`cranelift`, `LLVM`, `V8`, `wasmi` and `wamr`.
 
 ### Singlepass Compiler
 
-Build Wasmer:
+The Singlepass compiler works on Linux, Darwin and Windows systems on amd64
+platforms and on Linux and Darwin systems on aarch64 platforms. Currently, it
+doesn't work on `RISC-V` or `loongarch64`. On system in which it can be used it
+is enabled by default.
+
+You can build Wasmer by running this command in the root of the repo:
 
 ```text
 make build-wasmer
 ```
 
-**Note**: you should see this `Enabled Compilers: singlepass` in console. 
+**Note**: you should see `singlepass` appear in the `Enabled Compilers: ...` message in the console.
 
-You may disable Singlepass compiler with `export ENABLE_SINGLEPASS=0`.
+You may disable the Singlepass backend with the `ENABLE_SINGLEPASS=0` environment
+variable, and force its enabling with `ENABLE_SINGLEPASS=1`.
 
 ### Cranelift Compiler
 
-The Cranelift compiler will work if you are on a X86 or ARM machine. It will be detected automatically, so you don't need to do anything to your system to enable it.
+The Cranelift compiler will work if you are on a X86 or ARM machine. On system
+in which it can be used it is enabled by default.
+
+You can build Wasmer by running this command in the root of the repo:
 
 ```text
 make build-wasmer
 ```
 
-**Note**: should see this as the first line in the console:  
-`Enabled Compilers: cranelift`
+**Note**: you should see `cranelift` appear in the `Enabled Compilers: ...` message in the console.
 
-You may disable the Cranelift compiler with `export ENABLE_CRANELIFT=0`.
+You may disable the Cranelift backend with the `ENABLE_SINGLEPASS=0` environment
+variable, and force its enabling with `ENABLE_SINGLEPASS=1`.
 
 ### LLVM Compiler
 
-If you want support for the Wasmer LLVM compiler, then you will also need to ensure:
+If you want support for the Wasmer LLVM compiler, then you will also need to:
 
-* Ensure that LLVM 10.0.x &gt; is installed on your system
-  * You can refer to [LLVM install instructions](https://github.com/wasmerio/wasmer/tree/master/lib/compiler-llvm#requirements)
-  * You can also [download and use a prebuilt LLVM binary](https://releases.llvm.org/download.html)
-* In case `llvm-config` is not accessible, set the correct environment variable for LLVM to access: For example, the environment variable for LLVM 11.0.x would be: `LLVM_SYS_110_PREFIX=/path/to/unpacked/llvm-11.0`
+- Ensure that LLVM >=18.0.x is installed on your system
+  - You can refer to [LLVM install instructions](https://github.com/wasmerio/wasmer/tree/master/lib/compiler-llvm#requirements)
+  - You can also [download and use a prebuilt LLVM binary](https://releases.llvm.org/download.html)
+- In case `llvm-config` is not accessible, set the correct environment variable
+  for LLVM to access: For example, the environment variable for LLVM 18.0.x
+  would be: `LLVM_SYS_180_PREFIX=/path/to/unpacked/llvm-18.0`
 
 And create a Wasmer release
 
@@ -82,6 +110,21 @@ make build-wasmer
 
 You may disable the LLVM compiler with `export ENABLE_LLVM=0`.
 
+### V8, wasmi and wamr
+
+To enable any of these backends, you can set the according `ENABLE_<backend>=1`
+flag at build time. The build script itself will download the necessary
+libraries at build time.
+
+Note, however, that these backends are not supported on all the platforms that
+Wasmer can run on.
+
+For example, to have a Wasmer build with all three backends enabled you can run:
+
+```text
+ENABLE_V8=1 ENABLE_WASMI=1 ENABLE_WAMR=1 make build-wasmer
+```
+
 ### All compilers
 
 Once you have LLVM and Rust, you can just run:
@@ -113,9 +156,9 @@ make build-capi
 
 This will generate the shared library (depending on your system):
 
-* Windows: `target/release/libwasmer_c_api.dll`
-* macOS: `target/release/libwasmer_c_api.dylib`
-* Linux: `target/release/libwasmer_c_api.so`
+- Windows: `target/release/libwasmer_c_api.dll`
+- macOS: `target/release/libwasmer_c_api.dylib`
+- Linux: `target/release/libwasmer_c_api.so`
 
 If you want to generate the library and headers for using them easily, you can execute:
 
@@ -129,7 +172,7 @@ This command will generate a `package` directory, that you can then use easily i
 package/
   lib/
     libwasmer.so
-  headers/
+  include/
     wasm.h
     wasmer.h
 ```
@@ -138,6 +181,6 @@ package/
 >
 > By default, the Wasmer C API shared library will include all the backends available in the system where is built.
 > Defaulting to `cranelift` if available.
-> 
+>
 > You can generate the C-API for a specific compiler and engine with:
 > `make build-capi-{ENGINE}`
diff --git a/docs/README.md b/docs/README.md
index faea0b65d6..65e70cb097 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -20,5 +20,5 @@ Wasmer provides multiple documentations. Here are some pointers:
   environments, each embedding provides its own documentation, book
   etc.,
 * [OS distro packaging
-  notes](https://github.com/wasmerio/wasmer/blob/main/PACKAGING.md)
+  notes](https://github.com/wasmerio/wasmer/blob/main/docs/PACKAGING.md)
   contains notes about how to package Wasmer for OS distributions.
diff --git a/docs/SECURITY.md b/docs/SECURITY.md
index 0f8b87442e..7d4fc08e62 100644
--- a/docs/SECURITY.md
+++ b/docs/SECURITY.md
@@ -8,8 +8,11 @@ The table below summarizes which versions are still supported, and which aren't.
 |-|-|
 | 0.x | ❌ |
 | 1.x | ❌ |
-| 2.x | ✅ |
-| 3.x | ✅ |
+| 2.x | ❌ |
+| 3.x | ❌ |
+| 4.x | ❌ |
+| 5.x | ✅ |
+| 6.x | ⏰ |
 
 ## Reporting a Vulnerability
 
diff --git a/docs/cn/README.md b/docs/cn/README.md
index a958dc95fd..6bbb500bf2 100644
--- a/docs/cn/README.md
+++ b/docs/cn/README.md
@@ -5,7 +5,7 @@
 
   <p>
     <a href="https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild">
-      <img src="https://github.com/wasmerio/wasmer/actions/workflows/build.yml/badge.svg?event=push" alt="Build Status">
+      <img src="https://github.com/wasmerio/wasmer/actions/workflows/build.yml/badge.svg?style=flat-square" alt="Build Status">
     </a>
     <a href="https://github.com/wasmerio/wasmer/blob/main/LICENSE">
       <img src="https://img.shields.io/github/license/wasmerio/wasmer.svg" alt="License">
diff --git a/docs/de/README.md b/docs/de/README.md
index 20da4b5920..8edd37cb0b 100644
--- a/docs/de/README.md
+++ b/docs/de/README.md
@@ -5,7 +5,7 @@
 
   <p>
     <a href="https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild">
-      <img src="https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square" alt="Build Status">
+      <img src="https://github.com/wasmerio/wasmer/actions/workflows/build.yml/badge.svg?style=flat-square" alt="Build Status">
     </a>
     <a href="https://github.com/wasmerio/wasmer/blob/main/LICENSE">
       <img src="https://img.shields.io/github/license/wasmerio/wasmer.svg" alt="Lizenz">
diff --git a/docs/deps_dedup.dot b/docs/deps_dedup.dot
index d86c4ef4bd..944192e180 100644
--- a/docs/deps_dedup.dot
+++ b/docs/deps_dedup.dot
@@ -8,7 +8,6 @@ digraph dependencies {
 	n8 [label="wasmer-types", color=orange];
 	n9 [label="wasmer-vm", color=orange];
 	n10 [label="wasmer-c-api", color=orange];
-	n11 [label="wasmer-emscripten", color=orange];
 	n12 [label="wasmer-wasi", color=orange];
 	n13 [label="wasmer-cache", color=orange];
 	n14 [label="wasmer-cli", color=orange];
@@ -45,7 +44,6 @@ digraph dependencies {
 		color=brown;
 
 		n12 [label="wasmer-wasi", color=orange];
-		n11 [label="wasmer-emscripten", color=orange];
 	}
 
 	n14 -> n13 [color=orange, style=dashed];
diff --git a/docs/en/wamr.md b/docs/en/wamr.md
new file mode 100644
index 0000000000..791486417a
--- /dev/null
+++ b/docs/en/wamr.md
@@ -0,0 +1,26 @@
+> [!WARNING]
+> The WAMR backend is, as of now, an experimental feature. This document is
+> likely to change quickly.
+
+# Introduction
+
+Recent efforts introduced the possibility to use the WAMR interpreter as a
+backend in Wasmer. Among other things, this allows Wasmer to be used in iOS!
+This document has the objective to document important aspects of this backend.
+
+## About the WAMR backend
+1. Direct calls (outside host) to grow memory are [not
+   supported](https://github.com/bytecodealliance/wasm-micro-runtime/blob/main/doc/memory_tune.md#the-memory-model),
+   and users are encouraged to use the dedicated opcode (`memory.grow`)
+   instead.
+2. Importing memories and tables is not supported. If used, WAMR will simply
+   print `doesn't support import memories and tables for now, ignore them` to
+   standard output.
+3. Due to point (2) above, multithreaded programs relying on importing memories
+   can fail with out-of-bound memory read/write errors.
+4. Custom sections are not entirely supported as of now. 
+5. Functions cannot be called without an attached instance. 
+6. Globals cannot be inspected without an attached instance. 
+
+Notice, again, that the support is experimental: if you happen to incur in
+other issues not listed here, please file an issue!
diff --git a/docs/es/README.md b/docs/es/README.md
index 360a4be06d..69a57c97cb 100644
--- a/docs/es/README.md
+++ b/docs/es/README.md
@@ -5,7 +5,7 @@
   
   <p>
     <a href="https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild">
-      <img src="https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square" alt="Build Status">
+      <img src="https://github.com/wasmerio/wasmer/actions/workflows/build.yml/badge.svg?style=flat-square" alt="Build Status">
     </a>
     <a href="https://github.com/wasmerio/wasmer/blob/main/LICENSE">
       <img src="https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square" alt="License">
diff --git a/docs/ko/README.md b/docs/ko/README.md
index 3fda75001b..984dc4d5bc 100644
--- a/docs/ko/README.md
+++ b/docs/ko/README.md
@@ -5,7 +5,7 @@
 
   <p>
     <a href="https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild">
-      <img src="https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square" alt="Build Status">
+      <img src="https://github.com/wasmerio/wasmer/actions/workflows/build.yml/badge.svg?style=flat-square" alt="Build Status">
     </a>
     <a href="https://github.com/wasmerio/wasmer/blob/main/LICENSE">
       <img src="https://img.shields.io/github/license/wasmerio/wasmer.svg" alt="License">
diff --git a/docs/schema/generated/jsonschema/types/AppConfigV1.schema.json b/docs/schema/generated/jsonschema/types/AppConfigV1.schema.json
index 16e42a9081..6c9fe72498 100644
--- a/docs/schema/generated/jsonschema/types/AppConfigV1.schema.json
+++ b/docs/schema/generated/jsonschema/types/AppConfigV1.schema.json
@@ -4,7 +4,6 @@
   "description": "User-facing app.yaml config file for apps.\n\nNOTE: only used by the backend, Edge itself does not use this format, and uses [`super::AppVersionV1Spec`] instead.",
   "type": "object",
   "required": [
-    "name",
     "package"
   ],
   "properties": {
@@ -68,6 +67,15 @@
         "$ref": "#/definitions/HealthCheckV1"
       }
     },
+    "jobs": {
+      "type": [
+        "array",
+        "null"
+      ],
+      "items": {
+        "$ref": "#/definitions/Job"
+      }
+    },
     "locality": {
       "description": "Location-related configuration for the app.",
       "anyOf": [
@@ -81,7 +89,10 @@
     },
     "name": {
       "description": "Name of the app.",
-      "type": "string"
+      "type": [
+        "string",
+        "null"
+      ]
     },
     "owner": {
       "description": "Owner of the app.\n\nThis is either a username or a namespace.",
@@ -141,9 +152,25 @@
       "properties": {
         "max_age": {
           "description": "Maximum age of snapshots.\n\nFormat: 5m, 1h, 2d, ...\n\nAfter the specified time new snapshots will be created, and the old ones discarded.",
-          "type": [
-            "string",
-            "null"
+          "anyOf": [
+            {
+              "$ref": "#/definitions/PrettyDuration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "mode": {
+          "description": "The method to use to generate the instaboot snapshot for the instance.",
+          "default": null,
+          "anyOf": [
+            {
+              "$ref": "#/definitions/InstabootSnapshotModeV1"
+            },
+            {
+              "type": "null"
+            }
           ]
         },
         "requests": {
@@ -180,6 +207,27 @@
               "type": "null"
             }
           ]
+        },
+        "runtime": {
+          "description": "Runtime settings.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/AppConfigCapabilityRuntimeV1"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "ssh": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/CapabilitySshServerV1"
+            },
+            {
+              "type": "null"
+            }
+          ]
         }
       },
       "additionalProperties": true
@@ -197,6 +245,26 @@
         }
       }
     },
+    "AppConfigCapabilityRuntimeV1": {
+      "description": "Runtime capability settings.",
+      "type": "object",
+      "properties": {
+        "async_threads": {
+          "description": "Whether to enable asynchronous threads/deep sleeping.",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "engine": {
+          "description": "Engine to use for an instance, e.g. wasmer_cranelift, wasmer_llvm, etc.",
+          "type": [
+            "string",
+            "null"
+          ]
+        }
+      }
+    },
     "AppScalingConfigV1": {
       "type": "object",
       "properties": {
@@ -244,6 +312,108 @@
         }
       }
     },
+    "CapabilitySshServerV1": {
+      "description": "Configure SSH server credentials and settings.",
+      "type": "object",
+      "properties": {
+        "enabled": {
+          "description": "Enable an SSH server.",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "users": {
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "$ref": "#/definitions/SshUserV1"
+          }
+        }
+      },
+      "additionalProperties": true
+    },
+    "ExecutableJob": {
+      "type": "object",
+      "properties": {
+        "capabilities": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/ExecutableJobCompatibilityMapV1"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "cli_args": {
+          "description": "CLI arguments passed to the runner. Only applicable for runners that accept CLI arguments.",
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "type": "string"
+          }
+        },
+        "command": {
+          "description": "The command to run. Defaults to the package's entrypoint.",
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "env": {
+          "description": "Environment variables.",
+          "type": [
+            "object",
+            "null"
+          ],
+          "additionalProperties": {
+            "type": "string"
+          }
+        },
+        "package": {
+          "description": "The package that contains the command to run. Defaults to the app config's package.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/PackageSource"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "volumes": {
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "$ref": "#/definitions/AppVolume"
+          }
+        }
+      }
+    },
+    "ExecutableJobCompatibilityMapV1": {
+      "type": "object",
+      "properties": {
+        "memory": {
+          "description": "Instance memory settings.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/AppConfigCapabilityMemoryV1"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      },
+      "additionalProperties": true
+    },
     "HealthCheckHttpV1": {
       "description": "Health check configuration for http endpoints.",
       "type": "object",
@@ -307,9 +477,13 @@
         },
         "timeout": {
           "description": "Request timeout.\n\nFormat: 1s, 5m, 11h, ...",
-          "type": [
-            "string",
-            "null"
+          "anyOf": [
+            {
+              "$ref": "#/definitions/PrettyDuration"
+            },
+            {
+              "type": "null"
+            }
           ]
         },
         "unhealthy_threshold": {
@@ -402,9 +576,13 @@
         },
         "timeout": {
           "description": "Request timeout.\n\nFormat: 1s, 5m, 11h, ...",
-          "type": [
-            "string",
-            "null"
+          "anyOf": [
+            {
+              "$ref": "#/definitions/PrettyDuration"
+            },
+            {
+              "type": "null"
+            }
           ]
         }
       }
@@ -441,6 +619,134 @@
         }
       }
     },
+    "InstabootSnapshotModeV1": {
+      "description": "How will an instance be bootstrapped?",
+      "oneOf": [
+        {
+          "description": "Start the instance without any snapshot triggers. Once the requests are done, use [`snapshot_and_stop`](wasmer_wasix::WasiProcess::snapshot_and_stop) to capture a snapshot and shut the instance down.",
+          "type": "string",
+          "enum": [
+            "bootstrap"
+          ]
+        },
+        {
+          "description": "Explicitly enable the given snapshot triggers before starting the instance. The instance's process will have its stop_running_after_checkpoint flag set, so the first snapshot will cause the instance to shut down.",
+          "type": "object",
+          "required": [
+            "triggers"
+          ],
+          "properties": {
+            "triggers": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/SnapshotTrigger"
+              }
+            }
+          },
+          "additionalProperties": false
+        }
+      ]
+    },
+    "Job": {
+      "description": "Job configuration.",
+      "type": "object",
+      "required": [
+        "action",
+        "name",
+        "trigger"
+      ],
+      "properties": {
+        "action": {
+          "$ref": "#/definitions/JobAction"
+        },
+        "jitter_percent_max": {
+          "description": "Maximum percent of \"jitter\" to introduce between invocations.\n\nValue range: 0-100\n\nJitter is used to spread out jobs over time. The calculation works by multiplying the time between invocations by a random amount, and taking the percentage of that random amount.\n\nSee also [`Self::jitter_percent_min`] to set a minimum jitter.",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint8",
+          "minimum": 0.0
+        },
+        "jitter_percent_min": {
+          "description": "Minimum \"jitter\" to introduce between invocations.\n\nValue range: 0-100\n\nJitter is used to spread out jobs over time. The calculation works by multiplying the time between invocations by a random amount, and taking the percentage of that random amount.\n\nIf not specified while `jitter_percent_max` is, it will default to 10%.\n\nSee also [`Self::jitter_percent_max`] to set a maximum jitter.",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint8",
+          "minimum": 0.0
+        },
+        "max_schedule_drift": {
+          "description": "Don't start job if past the due time by this amount, instead opting to wait for the next instance of it to be triggered.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/PrettyDuration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "name": {
+          "type": "string"
+        },
+        "retries": {
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint32",
+          "minimum": 0.0
+        },
+        "timeout": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/PrettyDuration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "trigger": {
+          "$ref": "#/definitions/JobTrigger"
+        }
+      },
+      "additionalProperties": true
+    },
+    "JobAction": {
+      "type": "object",
+      "oneOf": [
+        {
+          "type": "object",
+          "required": [
+            "fetch"
+          ],
+          "properties": {
+            "fetch": {
+              "$ref": "#/definitions/HttpRequest"
+            }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": [
+            "execute"
+          ],
+          "properties": {
+            "execute": {
+              "$ref": "#/definitions/ExecutableJob"
+            }
+          },
+          "additionalProperties": false
+        }
+      ]
+    },
+    "JobTrigger": {
+      "type": "string"
+    },
     "Locality": {
       "type": "object",
       "required": [
@@ -458,6 +764,51 @@
     "PackageSource": {
       "type": "string"
     },
+    "PasswordV1": {
+      "oneOf": [
+        {
+          "description": "Plain text password.",
+          "type": "object",
+          "required": [
+            "password",
+            "type"
+          ],
+          "properties": {
+            "password": {
+              "type": "string"
+            },
+            "type": {
+              "type": "string",
+              "enum": [
+                "plain"
+              ]
+            }
+          }
+        },
+        {
+          "description": "Bcrypt password hash.",
+          "type": "object",
+          "required": [
+            "hash",
+            "type"
+          ],
+          "properties": {
+            "hash": {
+              "type": "string"
+            },
+            "type": {
+              "type": "string",
+              "enum": [
+                "bcrypt"
+              ]
+            }
+          }
+        }
+      ]
+    },
+    "PrettyDuration": {
+      "type": "string"
+    },
     "Redirect": {
       "description": "App redirect configuration.",
       "type": "object",
@@ -470,6 +821,42 @@
           ]
         }
       }
+    },
+    "SnapshotTrigger": {
+      "type": "string"
+    },
+    "SshUserV1": {
+      "type": "object",
+      "required": [
+        "username"
+      ],
+      "properties": {
+        "authorized_keys": {
+          "description": "SSH public keys for this user.",
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "type": "string"
+          }
+        },
+        "passwords": {
+          "description": "Passwords for this user.",
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "$ref": "#/definitions/PasswordV1"
+          }
+        },
+        "username": {
+          "description": "The username used for SSH login.",
+          "type": "string"
+        }
+      },
+      "additionalProperties": true
     }
   }
 }
\ No newline at end of file
diff --git a/examples/early_exit.rs b/examples/early_exit.rs
index 95d9a801cc..1d9e7bc594 100644
--- a/examples/early_exit.rs
+++ b/examples/early_exit.rs
@@ -98,7 +98,7 @@ fn main() -> anyhow::Result<()> {
                 Ok(())
             }
             Err(e) => {
-                bail!("Unknown error `{}` found. expected `ErrorCode`", e);
+                bail!("Unknown error `{}` found. expected `ExitCode`", e);
             }
         },
     }
diff --git a/examples/engine.rs b/examples/engine.rs
index 1bb2001610..d8836de7c0 100644
--- a/examples/engine.rs
+++ b/examples/engine.rs
@@ -13,12 +13,12 @@
 //! You can run the example directly by executing in Wasmer root:
 //!
 //! ```shell
-//! cargo run --example engine-universal --release --features "cranelift"
+//! cargo run --example engine --release --features "cranelift"
 //! ```
 //!
 //! Ready?
 
-use wasmer::{imports, wat2wasm, EngineBuilder, Instance, Module, Store, Value};
+use wasmer::{imports, sys::EngineBuilder, wat2wasm, Instance, Module, Store, Value};
 use wasmer_compiler_cranelift::Cranelift;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
diff --git a/examples/engine_cross_compilation.rs b/examples/engine_cross_compilation.rs
index 9021694182..9bc8ca7803 100644
--- a/examples/engine_cross_compilation.rs
+++ b/examples/engine_cross_compilation.rs
@@ -19,9 +19,12 @@
 //! Ready?
 
 use std::str::FromStr;
-use wasmer::{wat2wasm, EngineBuilder, Module, RuntimeError, Store};
+use wasmer::{
+    sys::{CpuFeature, EngineBuilder},
+    wat2wasm, Module, RuntimeError, Store,
+};
 use wasmer_compiler_cranelift::Cranelift;
-use wasmer_types::{CpuFeature, Target, Triple};
+use wasmer_types::target::{Target, Triple};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Let's declare the Wasm module with the text representation.
diff --git a/examples/engine_headless.rs b/examples/engine_headless.rs
index c0cbf2b334..984bedecf9 100644
--- a/examples/engine_headless.rs
+++ b/examples/engine_headless.rs
@@ -45,7 +45,7 @@
 //! Ready?
 
 use tempfile::NamedTempFile;
-use wasmer::{imports, wat2wasm, EngineBuilder, Instance, Module, Store, Value};
+use wasmer::{imports, sys::EngineBuilder, wat2wasm, Instance, Module, Store, Value};
 use wasmer_compiler_cranelift::Cranelift;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
diff --git a/examples/features.rs b/examples/features.rs
index 28ea86e7e3..c732afbfb8 100644
--- a/examples/features.rs
+++ b/examples/features.rs
@@ -10,7 +10,11 @@
 //!
 //! Ready?
 
-use wasmer::{imports, wat2wasm, EngineBuilder, Features, Instance, Module, Store, Value};
+use wasmer::{
+    imports,
+    sys::{EngineBuilder, Features},
+    wat2wasm, Instance, Module, Store, Value,
+};
 use wasmer_compiler_cranelift::Cranelift;
 
 fn main() -> anyhow::Result<()> {
diff --git a/examples/funcref.rs b/examples/funcref.rs
new file mode 100644
index 0000000000..548a7fde59
--- /dev/null
+++ b/examples/funcref.rs
@@ -0,0 +1,75 @@
+use std::error::Error;
+use wasmer::{imports, Instance, Module, Store, Table, TableType, Type, Value};
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // 1) Create a default Wasmer Store.
+    let mut store = Store::default();
+
+    // 2) Our first WAT module ("module A") that exports `add_one`.
+    let module_a_wat = r#"(module
+  (type $t0 (func (param i32) (result i32)))
+  (func $add_one (type $t0) (param $x i32) (result i32)
+    local.get $x
+    i32.const 1
+    i32.add)
+  (export "add_one" (func $add_one))
+)"#;
+
+    // 3) Our second WAT module ("module B") that imports the table and uses `call_ref`.
+    let module_b_wat = r#"(module
+  (type $t0 (func (param i32) (result i32)))
+  (import "env" "table" (table 1 funcref))
+  (func $call_func (param i32) (result i32)
+    (local.get 0)
+    (call_indirect (type $t0)
+      (i32.const 0)
+    )
+  )
+  (export "call_func" (func $call_func))
+)"#;
+
+    // 4) Compile module A.
+    let module_a = Module::new(&store, module_a_wat)?;
+    // 5) Instantiate module A (no imports needed).
+    let instance_a = Instance::new(&mut store, &module_a, &imports! {})?;
+
+    // 6) Get the exported function `add_one`.
+    let add_one_func = instance_a.exports.get_function("add_one")?;
+
+    // 7) Create a Table for `function`.
+    //    Initial size = 1, Max size = 1 (optional).
+    let table_type = TableType::new(Type::FuncRef, 1, Some(1)); // anyref => ExternRef in Wasmer
+    let table = Table::new(&mut store, table_type, Value::FuncRef(None))?;
+
+    // 8) Place the `add_one_func` into table[0] as an ExternRef.
+    //    Note: In older Wasmer versions, you might need `Value::FuncRef`.
+    //    But for the new `anyref`, we store it as `Value::ExternRef(Some(...))`.
+    table.set(&mut store, 0, Value::FuncRef(Some(add_one_func.clone())))?;
+
+    // 9) Compile module B (which imports the table).
+    let module_b = Module::new(&store, module_b_wat)?;
+
+    // 10) Create an ImportObject providing the table to module B.
+    let import_object = imports! {
+        "env" => {
+            "table" => table.clone(),
+        }
+    };
+
+    // 11) Instantiate module B with that import.
+    let instance_b = Instance::new(&mut store, &module_b, &import_object)?;
+
+    // 12) Get the exported `call_func` from module B.
+    let call_func = instance_b.exports.get_function("call_func")?;
+
+    // 13) Call `call_func(41)`, which should end up calling `add_one(41)`.
+    let results = call_func.call(&mut store, &[Value::I32(41)])?;
+
+    // 14) Print the result (should be 42).
+    println!(
+        "Result from module B calling module A's `add_one(41)`: {}",
+        results[0].i32().unwrap()
+    );
+
+    Ok(())
+}
diff --git a/examples/imports_function_env.rs b/examples/imports_function_env.rs
index fa0f338dd3..6e38860033 100644
--- a/examples/imports_function_env.rs
+++ b/examples/imports_function_env.rs
@@ -38,8 +38,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     (block
       (loop
         (call $add_to_counter (i32.const 1))
-        (set_local $x (i32.sub (get_local $x) (i32.const 1)))
-        (br_if 1 (i32.eq (get_local $x) (i32.const 0)))
+        (local.set $x (i32.sub (local.get $x) (i32.const 1)))
+        (br_if 1 (i32.eq (local.get $x) (i32.const 0)))
         (br 0)))
     call $get_counter)
   (export "increment_counter_loop" (func $increment_f)))
diff --git a/examples/imports_function_env_global.rs b/examples/imports_function_env_global.rs
index 46126f98bb..61ac3418b4 100644
--- a/examples/imports_function_env_global.rs
+++ b/examples/imports_function_env_global.rs
@@ -40,8 +40,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     (block
       (loop
         (call $add_to_counter (i32.const 1))
-        (set_local $x (i32.sub (get_local $x) (i32.const 1)))
-        (br_if 1 (i32.eq (get_local $x) (i32.const 0)))
+        (local.set $x (i32.sub (local.get $x) (i32.const 1)))
+        (br_if 1 (i32.eq (local.get $x) (i32.const 0)))
         (br 0)))
     call $get_counter)
   (export "increment_counter_loop" (func $increment_f)))
diff --git a/examples/memory.rs b/examples/memory.rs
index 15ed18cc90..2644638708 100644
--- a/examples/memory.rs
+++ b/examples/memory.rs
@@ -108,37 +108,41 @@ fn main() -> anyhow::Result<()> {
     // see how we can do that:
     println!("Growing memory...");
 
-    // Here we are requesting two more pages for our memory.
-    memory.grow(&mut store, 2)?;
-
-    let memory_view = memory.view(&store);
-    assert_eq!(memory_view.size(), Pages::from(3));
-    assert_eq!(memory_view.data_size(), 65536 * 3);
-
-    // Now that we know how to query and adjust the size of the memory,
-    // let's see how wa can write to it or read from it.
-    //
-    // We'll only focus on how to do this using exported functions, the goal
-    // is to show how to work with memory addresses. Here we'll use absolute
-    // addresses to write and read a value.
-    let mem_addr = 0x2220;
-    let val = 0xFEFEFFE;
-    set_at.call(&mut store, mem_addr, val)?;
-
-    let result = get_at.call(&mut store, mem_addr)?;
-    println!("Value at {:#x?}: {:?}", mem_addr, result);
-    assert_eq!(result, val);
-
-    // Now instead of using hard coded memory addresses, let's try to write
-    // something at the end of the second memory page and read it.
-    let page_size = 0x1_0000;
-    let mem_addr = (page_size * 2) - mem::size_of_val(&val) as i32;
-    let val = 0xFEA09;
-    set_at.call(&mut store, mem_addr, val)?;
-
-    let result = get_at.call(&mut store, mem_addr)?;
-    println!("Value at {:#x?}: {:?}", mem_addr, result);
-    assert_eq!(result, val);
+    // 'wamr' does not support direct calls to memory.grow()
+    #[cfg(not(feature = "wamr"))]
+    {
+        // Here we are requesting two more pages for our memory.
+        memory.grow(&mut store, 2)?;
+
+        let memory_view = memory.view(&store);
+        assert_eq!(memory_view.size(), Pages::from(3));
+        assert_eq!(memory_view.data_size(), 65536 * 3);
+
+        // Now that we know how to query and adjust the size of the memory,
+        // let's see how wa can write to it or read from it.
+        //
+        // We'll only focus on how to do this using exported functions, the goal
+        // is to show how to work with memory addresses. Here we'll use absolute
+        // addresses to write and read a value.
+        let mem_addr = 0x2220;
+        let val = 0xFEFEFFE;
+        set_at.call(&mut store, mem_addr, val)?;
+
+        let result = get_at.call(&mut store, mem_addr)?;
+        println!("Value at {:#x?}: {:?}", mem_addr, result);
+        assert_eq!(result, val);
+
+        // Now instead of using hard coded memory addresses, let's try to write
+        // something at the end of the second memory page and read it.
+        let page_size = 0x1_0000;
+        let mem_addr = (page_size * 2) - mem::size_of_val(&val) as i32;
+        let val = 0xFEA09;
+        set_at.call(&mut store, mem_addr, val)?;
+
+        let result = get_at.call(&mut store, mem_addr)?;
+        println!("Value at {:#x?}: {:?}", mem_addr, result);
+        assert_eq!(result, val);
+    }
 
     Ok(())
 }
diff --git a/examples/memory_grow.rs b/examples/memory_grow.rs
new file mode 100644
index 0000000000..11a587e660
--- /dev/null
+++ b/examples/memory_grow.rs
@@ -0,0 +1,51 @@
+//! Example demonstrating WebAssembly memory growth limits
+//!
+//! Tests growing memory to maximum allowed size according to the spec
+//! You can run the example directly by executing:
+//! ```shell
+//! cargo run --example memory-grow --release --features "cranelift"
+//! ```
+
+use wasmer::{imports, wat2wasm, Instance, Module, Store};
+
+fn main() -> anyhow::Result<()> {
+    let wasm_bytes = wat2wasm(
+        r#"
+(module
+   (memory (export "memory") 1 65536)
+   (func (export "mem_size") (result i32)
+       memory.size)
+   (func (export "grow") (param i32) (result i32)
+       local.get 0
+       memory.grow))
+"#
+        .as_bytes(),
+    )?;
+
+    let mut store = Store::default();
+    let module = Module::new(&store, wasm_bytes)?;
+    let instance = Instance::new(&mut store, &module, &imports! {})?;
+    let memory = instance.exports.get_memory("memory")?;
+
+    println!("Testing memory growth limits...");
+    println!("Initial size: {:?}", memory.view(&store).size());
+
+    let _ = memory.grow(&mut store, 65534)?;
+    println!("After growing by 65534: {:?}", memory.view(&store).size());
+
+    let _ = memory.grow(&mut store, 1)?;
+    println!(
+        "After growing to max (65536): {:?}",
+        memory.view(&store).size()
+    );
+
+    let result = memory.grow(&mut store, 1);
+    println!("Attempt to exceed max: {:?}", result);
+
+    Ok(())
+}
+
+#[test]
+fn test_memory_grow() -> anyhow::Result<()> {
+    main()
+}
diff --git a/examples/metering.rs b/examples/metering.rs
index e5d8c70d74..a9551cb96f 100644
--- a/examples/metering.rs
+++ b/examples/metering.rs
@@ -17,8 +17,11 @@
 use anyhow::bail;
 use std::sync::Arc;
 use wasmer::wasmparser::Operator;
-use wasmer::CompilerConfig;
-use wasmer::{imports, wat2wasm, EngineBuilder, Instance, Module, Store, TypedFunction};
+use wasmer::{
+    imports,
+    sys::{CompilerConfig, EngineBuilder},
+    wat2wasm, Instance, Module, Store, TypedFunction,
+};
 use wasmer_compiler_cranelift::Cranelift;
 use wasmer_middlewares::{
     metering::{get_remaining_points, set_remaining_points, MeteringPoints},
diff --git a/examples/platform_ios_headless.rs b/examples/platform_ios_headless.rs
index 7b133b2db0..585ccc5bf9 100644
--- a/examples/platform_ios_headless.rs
+++ b/examples/platform_ios_headless.rs
@@ -14,9 +14,9 @@
 #![allow(unused)]
 use std::path::Path;
 use std::str::FromStr;
-use wasmer::{wat2wasm, Module, RuntimeError, Store};
+use wasmer::{sys::CpuFeature, wat2wasm, Module, RuntimeError, Store};
 use wasmer_compiler_cranelift::Cranelift;
-use wasmer_types::{CpuFeature, Target, Triple};
+use wasmer_types::target::{Target, Triple};
 /*
 use wasmer_engine_dylib::Dylib;
 */
diff --git a/examples/table.rs b/examples/table.rs
index cd74083694..52e5b9f458 100644
--- a/examples/table.rs
+++ b/examples/table.rs
@@ -154,7 +154,6 @@ fn main() -> anyhow::Result<()> {
 
 // This test is currently failing with:
 // not implemented: Native function definitions can't be directly called from the host yet
-#[cfg(FALSE)]
 #[test]
 fn test_table() -> anyhow::Result<()> {
     main()
diff --git a/examples/tunables_limit_memory.rs b/examples/tunables_limit_memory.rs
index da2c7a4ece..33e3b69e35 100644
--- a/examples/tunables_limit_memory.rs
+++ b/examples/tunables_limit_memory.rs
@@ -1,14 +1,16 @@
 use std::ptr::NonNull;
+use wasmer_compiler_cranelift::Cranelift;
 
+// This is to be able to set the tunables
 use wasmer::{
     imports,
-    vm::{self, MemoryError, MemoryStyle, TableStyle, VMMemoryDefinition, VMTableDefinition},
-    wat2wasm, BaseTunables, Engine, Instance, Memory, MemoryType, Module, Pages, Store, TableType,
-    Target, Tunables,
+    sys::{
+        vm::{VMMemory, VMMemoryDefinition, VMTable, VMTableDefinition},
+        BaseTunables, NativeEngineExt, Target, Tunables,
+    },
+    wat2wasm, Engine, Instance, Memory, MemoryError, MemoryStyle, MemoryType, Module, Pages, Store,
+    TableStyle, TableType,
 };
-use wasmer_compiler_cranelift::Cranelift;
-// This is to be able to set the tunables
-use wasmer::NativeEngineExt;
 
 /// A custom tunables that allows you to set a memory limit.
 ///
@@ -86,7 +88,7 @@ impl<T: Tunables> Tunables for LimitingTunables<T> {
         &self,
         ty: &MemoryType,
         style: &MemoryStyle,
-    ) -> Result<vm::VMMemory, MemoryError> {
+    ) -> Result<VMMemory, MemoryError> {
         let adjusted = self.adjust_memory(ty);
         self.validate_memory(&adjusted)?;
         self.base.create_host_memory(&adjusted, style)
@@ -100,7 +102,7 @@ impl<T: Tunables> Tunables for LimitingTunables<T> {
         ty: &MemoryType,
         style: &MemoryStyle,
         vm_definition_location: NonNull<VMMemoryDefinition>,
-    ) -> Result<vm::VMMemory, MemoryError> {
+    ) -> Result<VMMemory, MemoryError> {
         let adjusted = self.adjust_memory(ty);
         self.validate_memory(&adjusted)?;
         self.base
@@ -110,7 +112,7 @@ impl<T: Tunables> Tunables for LimitingTunables<T> {
     /// Create a table owned by the host given a [`TableType`] and a [`TableStyle`].
     ///
     /// Delegated to base.
-    fn create_host_table(&self, ty: &TableType, style: &TableStyle) -> Result<vm::VMTable, String> {
+    fn create_host_table(&self, ty: &TableType, style: &TableStyle) -> Result<VMTable, String> {
         self.base.create_host_table(ty, style)
     }
 
@@ -122,7 +124,7 @@ impl<T: Tunables> Tunables for LimitingTunables<T> {
         ty: &TableType,
         style: &TableStyle,
         vm_definition_location: NonNull<VMTableDefinition>,
-    ) -> Result<vm::VMTable, String> {
+    ) -> Result<VMTable, String> {
         self.base.create_vm_table(ty, style, vm_definition_location)
     }
 }
diff --git a/examples/wasi.rs b/examples/wasi.rs
index c055d356a8..e3bea0c5a0 100644
--- a/examples/wasi.rs
+++ b/examples/wasi.rs
@@ -14,10 +14,13 @@
 //!
 //! Ready?
 
-use std::io::Read;
+use std::{io::Read, sync::Arc};
 
-use wasmer::{Module, Store};
-use wasmer_wasix::{Pipe, WasiEnv};
+use wasmer_wasix::{
+    runners::wasi::{RuntimeOrEngine, WasiRunner},
+    runtime::{module_cache::HashedModuleData, task_manager::tokio::TokioTaskManager},
+    Pipe, PluggableRuntime, Runtime,
+};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let wasm_path = concat!(
@@ -27,28 +30,51 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Let's declare the Wasm module with the text representation.
     let wasm_bytes = std::fs::read(wasm_path)?;
 
-    // Create a Store.
-    let mut store = Store::default();
+    // We optionally need a tokio runtime and a WASI runtime. This doesn't need to
+    // happen though; see the wasi-pipes example for an alternate approach. Things
+    // such as the file system or networking can be configured on the runtime.
+    let tokio_runtime = tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .build()
+        .unwrap();
+    let _guard = tokio_runtime.enter();
+    let tokio_task_manager = TokioTaskManager::new(tokio_runtime.handle().clone());
+    let runtime = PluggableRuntime::new(Arc::new(tokio_task_manager));
 
     println!("Compiling module...");
     // Let's compile the Wasm module.
-    let module = Module::new(&store, wasm_bytes)?;
+    let data = HashedModuleData::new(wasm_bytes.clone());
+    let module = runtime.load_hashed_module_sync(data, None)?;
 
+    // Create a pipe for the module's stdout.
     let (stdout_tx, mut stdout_rx) = Pipe::channel();
 
-    // Run the module.
-    WasiEnv::builder("hello")
-        // .args(&["world"])
-        // .env("KEY", "Value")
-        .stdout(Box::new(stdout_tx))
-        .run_with_store(module, &mut store)?;
+    {
+        // Create a WASI runner. We use a scope to make sure the runner is dropped
+        // as soon as we are done with it; otherwise, it will keep the stdout pipe
+        // open.
+        let mut runner = WasiRunner::new();
+        runner.with_stdout(Box::new(stdout_tx));
 
-    eprintln!("Run complete - reading output");
+        println!("Running module...");
+        // Now, run the module.
+        runner.run_wasm(
+            RuntimeOrEngine::Runtime(Arc::new(runtime)),
+            "hello",
+            module,
+            wasmer_types::ModuleHash::xxhash(wasm_bytes),
+        )?;
+    }
+
+    println!("Run complete - reading output");
 
     let mut buf = String::new();
     stdout_rx.read_to_string(&mut buf).unwrap();
 
-    eprintln!("Output: {buf}");
+    println!("Output: {buf}");
+
+    // Verify the module wrote the correct thing, for the test below
+    assert_eq!(buf, "Hello, world!\n");
 
     Ok(())
 }
diff --git a/examples/wasi_manual_setup.rs b/examples/wasi_manual_setup.rs
index d08de6d01b..504eb8be4f 100644
--- a/examples/wasi_manual_setup.rs
+++ b/examples/wasi_manual_setup.rs
@@ -10,7 +10,7 @@
 //! You can run the example directly by executing in Wasmer root:
 //!
 //! ```shell
-//! cargo run --example wasi-manual-setup --release --features "cranelift,wasi"
+//! cargo run --example wasi-manual-setup --release --features "cranelift,tokio,wasi"
 //! ```
 //!
 //! Ready?
@@ -45,6 +45,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut wasi_env = WasiEnv::builder("hello")
         // .args(&["world"])
         // .env("KEY", "Value")
+        .engine(store.engine().clone())
         .finalize(&mut store)?;
 
     println!("Instantiating module with WASI imports...");
diff --git a/examples/wasi_pipes.rs b/examples/wasi_pipes.rs
index 925c880195..93392fa8e2 100644
--- a/examples/wasi_pipes.rs
+++ b/examples/wasi_pipes.rs
@@ -6,14 +6,18 @@
 //! You can run the example directly by executing in Wasmer root:
 //!
 //! ```shell
-//! cargo run --example wasi-pipes --release --features "cranelift,wasi"
+//! cargo run --example wasi-pipes --release --features "cranelift,tokio,backend,wasi"
 //! ```
 //!
 //! Ready?
 
 use std::io::{Read, Write};
-use wasmer::{Module, Store};
-use wasmer_wasix::{Pipe, WasiEnv};
+
+use wasmer::Module;
+use wasmer_wasix::{
+    runners::wasi::{RuntimeOrEngine, WasiRunner},
+    Pipe,
+};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let wasm_path = concat!(
@@ -23,12 +27,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Let's declare the Wasm module with the text representation.
     let wasm_bytes = std::fs::read(wasm_path)?;
 
-    // Create a Store.
-    let mut store = Store::default();
+    // We need at least an engine to be able to compile the module.
+    let engine = wasmer::Engine::default();
 
     println!("Compiling module...");
     // Let's compile the Wasm module.
-    let module = Module::new(&store, wasm_bytes)?;
+    let module = Module::new(&engine, &wasm_bytes[..])?;
 
     let msg = "racecar go zoom";
     println!("Writing \"{}\" to the WASI stdin...", msg);
@@ -38,18 +42,35 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // To write to the stdin
     writeln!(stdin_sender, "{}", msg)?;
 
-    println!("Running module...");
-    // First, we create the `WasiEnv` with the stdio pipes
-    WasiEnv::builder("hello")
-        .stdin(Box::new(stdin_reader))
-        .stdout(Box::new(stdout_sender))
-        .run_with_store(module, &mut store)?;
+    {
+        // Create a WASI runner. We use a scope to make sure the runner is dropped
+        // as soon as we are done with it; otherwise, it will keep the stdout pipe
+        // open.
+        let mut runner = WasiRunner::new();
+
+        // Configure the WasiRunner with the stdio pipes.
+        runner
+            .with_stdin(Box::new(stdin_reader))
+            .with_stdout(Box::new(stdout_sender));
+
+        // Now, run the module.
+        println!("Running module...");
+        runner.run_wasm(
+            RuntimeOrEngine::Engine(engine),
+            "hello",
+            module,
+            wasmer_types::ModuleHash::xxhash(wasm_bytes),
+        )?;
+    }
 
     // To read from the stdout
     let mut buf = String::new();
     stdout_reader.read_to_string(&mut buf)?;
     println!("Read \"{}\" from the WASI stdout!", buf.trim());
 
+    // Verify the module wrote the correct thing, for the test below
+    assert_eq!(buf.trim(), "mooz og racecar");
+
     Ok(())
 }
 
diff --git a/flake.lock b/flake.lock
index 6c8dc25047..8d268d8d52 100644
--- a/flake.lock
+++ b/flake.lock
@@ -5,11 +5,11 @@
         "systems": "systems"
       },
       "locked": {
-        "lastModified": 1710146030,
-        "narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=",
+        "lastModified": 1726560853,
+        "narHash": "sha256-X6rJYSESBVr3hBoH0WbKE5KvhPU5bloyZ2L4K60/fPQ=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a",
+        "rev": "c1dfcf08411b08f6b8615f7d8971a2bfa81d5e8a",
         "type": "github"
       },
       "original": {
@@ -20,16 +20,16 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1712168706,
-        "narHash": "sha256-XP24tOobf6GGElMd0ux90FEBalUtw6NkBSVh/RlA6ik=",
+        "lastModified": 1730137625,
+        "narHash": "sha256-9z8oOgFZiaguj+bbi3k4QhAD6JabWrnv7fscC/mt0KE=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "1487bdea619e4a7a53a4590c475deabb5a9d1bfb",
+        "rev": "64b80bfb316b57cdb8919a9110ef63393d74382a",
         "type": "github"
       },
       "original": {
         "owner": "NixOS",
-        "ref": "nixos-23.11",
+        "ref": "nixos-24.05",
         "repo": "nixpkgs",
         "type": "github"
       }
diff --git a/flake.nix b/flake.nix
index 9cd483ac66..9e761650fb 100644
--- a/flake.nix
+++ b/flake.nix
@@ -2,7 +2,7 @@
   description = "Wasmer Webassembly runtime";
 
   inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixos-23.11";
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.05";
     flakeutils.url = "github:numtide/flake-utils";
   };
 
@@ -35,8 +35,8 @@
             openssl
 
             # LLVM and related dependencies
-            llvmPackages_15.libllvm
-            llvmPackages_15.llvm
+            llvmPackages_18.libllvm
+            llvmPackages_18.llvm
             libxml2
             libffi
 
@@ -67,11 +67,12 @@
             wasm-tools
           ];
 
-          env.LLVM_SYS_150_PREFIX = pkgs.llvmPackages_15.llvm.dev;
-          env.LD_LIBRARY_PATH = pkgs.lib.makeLibraryPath [
-            pkgs.stdenv.cc.cc
-            pkgs.openssl.out
-          ];
+          env.LLVM_SYS_180_PREFIX = pkgs.llvmPackages_18.llvm.dev;
+
+          # shellHook = ''
+          #   LD_LIBRARY_PATH = "${ env.LD_LIBRARY_PATH = pkgs.lib.makeLibraryPath [ pkgs.stdenv.cc.cc pkgs.openssl.out ] }:$LD_LIBRARY_PATH"
+          # '';
+
         };
       }
     );
diff --git a/fuzz/README.md b/fuzz/README.md
index 13e40a304c..736e709f62 100644
--- a/fuzz/README.md
+++ b/fuzz/README.md
@@ -38,7 +38,7 @@ $ cargo fuzz run universal_cranelift
 ```
 
 See the
-[`fuzz/fuzz_targets`](https://github.com/wasmerio/wasmer/tree/fuzz/fuzz_targets/)
+[`fuzz/fuzz_targets`](https://github.com/wasmerio/wasmer/tree/main/fuzz/fuzz_targets/)
 directory for the full list of fuzzers.
 
 You should see output that looks something like this:
diff --git a/lib/README.md b/lib/README.md
index 1cff03e2e7..06a7b0e381 100644
--- a/lib/README.md
+++ b/lib/README.md
@@ -22,7 +22,6 @@ composed of a set of crates. We can group them as follows:
     performance.
 * `derive` — A set of procedural macros used inside Wasmer,
 * ABI:
-  * `emscripten` — Emscripten ABI implementation inside Wasmer,
   * `wasi` — WASI ABI implementation inside Wasmer:
     * `wasi-types` — All the WASI types,
 * `engine` — The general abstraction for creating an engine, which is
diff --git a/lib/api/Cargo.toml b/lib/api/Cargo.toml
index 5eeb1685e6..37f91a092f 100644
--- a/lib/api/Cargo.toml
+++ b/lib/api/Cargo.toml
@@ -13,10 +13,16 @@ rust-version.workspace = true
 version.workspace = true
 
 #####
-# This crate comes in 2 major flavors:
+# This crate comes in 3 major flavors:
 #
 # - `sys`, where `wasmer` will be compiled to a native executable
 #    which provides compilers, engines, a full VM etc.
+# - `wamr`, where `wasmer` will be compiled to a native executable
+#    which provides an interpreter using WAMR as a backend.
+# - `wasmi`, where `wasmer` will be compiled to a native executable
+#    which provides an interpreter using `wasmi` as a backend.
+# - `v8`, where `wasmer` will be compiled to a native executable
+#    using `v8` as a backend.
 # - `js`, where `wasmer` will be compiled to WebAssembly to run in a
 #   JavaScript host.
 #####
@@ -24,30 +30,40 @@ version.workspace = true
 # Shared dependencies.
 [dependencies]
 # - Mandatory shared dependencies.
-indexmap = { version = "1.6" }
-cfg-if = "1.0"
-thiserror = "1.0"
-more-asserts = "0.2"
-derivative = { version = "^2" }
-bytes = "1"
-tracing = { version = "0.1" }
+indexmap.workspace = true
+cfg-if.workspace = true
+thiserror.workspace = true
+more-asserts.workspace = true
+bytes.workspace = true
+tracing.workspace = true
 # - Optional shared dependencies.
-wat = { version = "=1.0.71", optional = true }
+wat = { version = "1.216.0", optional = true }
 rustc-demangle = "0.1"
-shared-buffer = { workspace = true }
+shared-buffer.workspace = true
+
+wasmi_c_api = { version = "0.40.0", package = "wasmi_c_api_impl", optional = true, features = [
+	"prefix-symbols",
+] }
+
+loupe = { workspace = true, optional = true, features = [
+	"indexmap",
+	"enable-indexmap",
+] }
+paste = "1.0.15"
+derive_more = { workspace = true, features = ["from", "debug"] }
 
 # Dependencies and Development Dependencies for `sys`.
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 # - Mandatory dependencies for `sys`.
-wasmer-vm = { path = "../vm", version = "=4.3.7" }
-wasmer-compiler = { path = "../compiler", version = "=4.3.7" }
-wasmer-derive = { path = "../derive", version = "=4.3.7" }
-wasmer-types = { path = "../types", version = "=4.3.7" }
-target-lexicon = { version = "0.12.2", default-features = false }
+wasmer-vm = { path = "../vm", version = "=6.1.0", optional = true }
+wasmer-compiler = { path = "../compiler", version = "=6.1.0", optional = true }
+wasmer-derive = { path = "../derive", version = "=6.1.0" }
+wasmer-types = { path = "../types", version = "=6.1.0" }
+target-lexicon = { workspace = true, default-features = false }
 # - Optional dependencies for `sys`.
-wasmer-compiler-singlepass = { path = "../compiler-singlepass", version = "=4.3.7", optional = true }
-wasmer-compiler-cranelift = { path = "../compiler-cranelift", version = "=4.3.7", optional = true }
-wasmer-compiler-llvm = { path = "../compiler-llvm", version = "=4.3.7", optional = true }
+wasmer-compiler-singlepass = { path = "../compiler-singlepass", version = "=6.1.0", optional = true }
+wasmer-compiler-cranelift = { path = "../compiler-cranelift", version = "=6.1.0", optional = true }
+wasmer-compiler-llvm = { path = "../compiler-llvm", version = "=6.1.0", optional = true }
 
 wasm-bindgen = { version = "0.2.74", optional = true }
 js-sys = { version = "0.3.51", optional = true }
@@ -60,29 +76,33 @@ windows-sys = "0.59"
 # - Development Dependencies for `sys`.
 [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
 wat = "1.0"
-tempfile = "3.6.0"
-anyhow = "1.0"
-macro-wasmer-universal-test = { version = "4.3.7", path = "./macro-wasmer-universal-test" }
+tempfile.workspace = true
+anyhow.workspace = true
+macro-wasmer-universal-test = { version = "6.1.0", path = "./macro-wasmer-universal-test" }
 
 # Dependencies and Develoment Dependencies for `js`.
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 # - Mandatory dependencies for `js`.
-wasmer-types = { path = "../types", version = "=4.3.7", default-features = false, features = ["std"] }
-wasm-bindgen = "0.2.74"
-js-sys = "0.3.51"
-wasmer-derive = { path = "../derive", version = "=4.3.7" }
+wasmer-types = { path = "../types", version = "=6.1.0", default-features = false, features = [
+	"std",
+] }
+wasm-bindgen = "0.2.100"
+js-sys = "0.3.77"
+wasmer-derive = { path = "../derive", version = "=6.1.0" }
+wasmer-compiler = { path = "../compiler", version = "=6.1.0" }
 # - Optional dependencies for `js`.
 wasmparser = { workspace = true, default-features = false, optional = true }
-hashbrown = { version = "0.11", optional = true }
-serde-wasm-bindgen = { version = "0.4.5" }
-serde = { version = "1.0", features = ["derive"] }
+hashbrown = { workspace = true, optional = true }
+serde-wasm-bindgen = { version = "0.6.5" }
+serde.workspace = true
+target-lexicon.workspace = true
 
 # - Development Dependencies for `js`.
 [target.'cfg(target_arch = "wasm32")'.dev-dependencies]
 wat = "1.0"
-anyhow = "1.0"
+anyhow.workspace = true
 wasm-bindgen-test = "0.3.0"
-macro-wasmer-universal-test = { version = "4.3.7", path = "./macro-wasmer-universal-test" }
+macro-wasmer-universal-test = { version = "6.1.0", path = "./macro-wasmer-universal-test" }
 
 # Specific to `js`.
 #
@@ -96,58 +116,101 @@ maintenance = { status = "actively-developed" }
 
 [features]
 default = ["sys-default"]
-# default = ["js-default"]
 std = []
 core = ["hashbrown"]
+artifact-size = [
+	"dep:loupe",
+	"wasmer-vm/artifact-size",
+	"wasmer-compiler/artifact-size",
+]
 
 # Features for `sys`.
-sys = ["wasmer-compiler/translator", "wasmer-compiler/compiler", "std"]
+sys = ["std", "dep:wasmer-vm", "dep:wasmer-compiler"]
 sys-default = ["sys", "wat", "cranelift"]
+
 # - Compilers.
-compiler = ["sys"]
+compiler = [
+	"sys",
+	"dep:wasmer-compiler",
+	"wasmer-compiler/translator",
+	"wasmer-compiler/compiler",
+]
 singlepass = ["compiler", "wasmer-compiler-singlepass"]
 cranelift = ["compiler", "wasmer-compiler-cranelift"]
 llvm = ["compiler", "wasmer-compiler-llvm"]
-# - Engines.
-engine = ["sys"]
-# - Deprecated features.
-jit = ["engine"]
+
+# --- Enable the WAMR backend and use it as default backend.
+wamr-default = ["wamr", "wat"]
+# --- Enable the WAMR backend and use it as defaul backend only if it is the only one enabled.
+wamr = ["wasm-c-api", "std", "dep:which", "dep:zip", "dep:ureq"]
+
+# --- Enable the wasmi backend and use it as default backend.
+wasmi = ["wasm-c-api", "std", "dep:wasmi_c_api"]
+# --- Enable the wasmi backend and use it as defaul backend only if it is the only one enabled.
+wasmi-default = ["wasmi", "wat"]
+
+# --- Enable the v8 backend and use it as default backend.
+v8 = ["wasm-c-api", "std", "dep:which", "dep:xz", "dep:ureq"]
+# --- Enable the v8 backend and use it as defaul backend only if it is the only one enabled.
+v8-default = ["v8", "wat"]
+
+wasm-c-api = ["wasm-types-polyfill"]
 
 # Features for `js`.
 js = ["wasm-bindgen", "js-sys"]
 js-default = ["js", "std", "wasm-types-polyfill"]
 
 wasm-types-polyfill = ["wasmparser"]
+wat = ["dep:wat", "wasmparser"]
 
 jsc = ["rusty_jsc", "wasm-types-polyfill", "wasmparser"]
-
+jsc-default = ["jsc"]
 js-serializable-module = []
 
 # Optional
 enable-serde = [
-  "wasmer-vm/enable-serde",
-  "wasmer-compiler/enable-serde",
-  "wasmer-types/enable-serde",
+	"wasmer-vm/enable-serde",
+	"wasmer-compiler/enable-serde",
+	"wasmer-types/enable-serde",
 ]
 
+# AddressSanitizer support
+sanitizer = ["wasmer-vm/sanitizer"]
+
 wasmer-artifact-load = ["wasmer-compiler/wasmer-artifact-load"]
 wasmer-artifact-create = ["wasmer-compiler/wasmer-artifact-create"]
 static-artifact-load = ["wasmer-compiler/static-artifact-load"]
 static-artifact-create = ["wasmer-compiler/static-artifact-create"]
 
+[build-dependencies]
+cmake = "0.1.50"
+tar.workspace = true
+ureq = { version = "2.10.1", optional = true }
+which = { version = "7.0.0", optional = true }
+xz = { version = "0.1.0", optional = true }
+zip = { version = "2.2.0", optional = true }
+
+[target.'cfg(target_env = "musl")'.build-dependencies]
+bindgen = { version = "0.70.1", default-features = false, features = [
+	"static",
+	"logging",
+	"prettyplease",
+] }
+
+[target.'cfg(not(target_env = "musl"))'.build-dependencies]
+bindgen = { version = "0.70.1" }
+
 [package.metadata.docs.rs]
 features = [
-  "compiler",
-  "core",
-  "cranelift",
-  "engine",
-  "jit",
-  "singlepass",
-  "static-artifact-create",
-  "static-artifact-load",
-  "sys",
-  "sys-default",
-  "wasmer-artifact-create",
-  "wasmer-artifact-load",
+	"compiler",
+	"core",
+	"cranelift",
+	"singlepass",
+	"static-artifact-create",
+	"static-artifact-load",
+	"sys",
+	"sys-default",
+	"wasmer-artifact-create",
+	"wasmer-artifact-load",
 ]
 rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/api/README.md b/lib/api/README.md
index abb66fb3f1..2de372f5c0 100644
--- a/lib/api/README.md
+++ b/lib/api/README.md
@@ -1,9 +1,9 @@
-# `wasmer` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE) [![crates.io](https://img.shields.io/crates/v/wasmer.svg)](https://crates.io/crates/wasmer)
+# `wasmer` [![Build Status](https://github.com/wasmerio/wasmer/actions/workflows/build.yml/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE) [![crates.io](https://img.shields.io/crates/v/wasmer.svg)](https://crates.io/crates/wasmer)
 
 [`Wasmer`](https://wasmer.io/) is the most popular
-[WebAssembly](https://webassembly.org/) runtime for Rust. It supports
-JIT (Just In Time) and AOT (Ahead Of Time) compilation as well as
-pluggable compilers suited to your needs.
+[WebAssembly](https://webassembly.org/) runtime for Rust. It supports JIT (Just
+In Time), AOT (Ahead Of Time) compilation, an experimental interpreter as well
+as pluggable compilers suited to your needs.
 
 It's designed to be safe and secure, and runnable in any kind of environment.
 
@@ -20,7 +20,7 @@ fn main() -> anyhow::Result<()> {
     (module
     (type $t0 (func (param i32) (result i32)))
     (func $add_one (export "add_one") (type $t0) (param $p0 i32) (result i32)
-        get_local $p0
+        local.get $p0
         i32.const 1
         i32.add))
     "#;
@@ -53,6 +53,13 @@ Wasmer is not only fast, but also designed to be *highly customizable*:
     compilation-time and runtime performance, useful for development,
   * [`wasmer-compiler-llvm`] provides a deeply optimized executable
     code with the fastest runtime speed, ideal for production.
+
+* **Pluggable interpreters** (experimental) - `wamr`, a feature provided by
+  the `wasmer` crate, provides binding to the interpreter provided by
+  [`WAMR`](https://github.com/bytecodealliance/wasm-micro-runtime). More
+  informations about this experimental backend can be found in the [dedicated
+  documentation](/docs/en/wamr.md).
+ 
     
 * **Headless mode** — Once a WebAssembly module has been compiled, it
   is possible to serialize it in a file for example, and later execute
diff --git a/lib/api/build.rs b/lib/api/build.rs
new file mode 100644
index 0000000000..0a440fbe27
--- /dev/null
+++ b/lib/api/build.rs
@@ -0,0 +1,438 @@
+#[cfg(feature = "wamr")]
+fn build_wamr() {
+    use bindgen::callbacks::ParseCallbacks;
+    const WAMR_ZIP: &str =
+        "https://github.com/bytecodealliance/wasm-micro-runtime/archive/refs/tags/WAMR-2.2.0.zip";
+    const ZIP_NAME: &str = "wasm-micro-runtime-WAMR-2.2.0";
+
+    use cmake::Config;
+    use std::{env, path::PathBuf};
+
+    let crate_root = env::var("OUT_DIR").unwrap();
+
+    // Read target os from cargo env
+    // Transform from cargo value to valid wasm-micro-runtime os
+    let target_os = match env::var("CARGO_CFG_TARGET_OS").unwrap().as_str() {
+        "linux" => "linux",
+        "windows" => "windows",
+        "macos" => "darwin",
+        "freebsd" => "freebsd",
+        "android" => "android",
+        "ios" => "ios",
+        other => panic!("Unsupported CARGO_CFG_TARGET_OS: {}", other),
+    };
+
+    // Read target arch from cargo env
+    // Transform from cargo value to valid wasm-micro-runtime WAMR_BUILD_TARGET
+    let target_arch = match env::var("CARGO_CFG_TARGET_ARCH").unwrap().as_str() {
+        "x86" => "X86_32",
+        "x86_64" => "X86_64",
+        "arm" => "ARM",
+        "aarch64" => "AARCH64",
+        "mips" => "MIPS",
+        "powerpc" => "POWERPC",
+        "powerpc64" => "POWERPC64",
+        other => panic!("Unsupported CARGO_CFG_TARGET_ARCH: {}", other),
+    };
+
+    // Cleanup tmp data from prior builds
+    let wamr_dir = PathBuf::from(&crate_root).join("third_party/wamr");
+    if !wamr_dir.exists() {
+        let zip_dir = PathBuf::from(&crate_root).join("third_party");
+        let _ = std::fs::remove_dir_all(&wamr_dir);
+        let _ = std::fs::remove_dir_all(&zip_dir);
+
+        // Fetch & extract wasm-micro-runtime source
+        let zip = ureq::get(WAMR_ZIP).call().expect("failed to download wamr");
+        let mut zip_data = Vec::new();
+        zip.into_reader()
+            .read_to_end(&mut zip_data)
+            .expect("failed to download wamr");
+        std::fs::create_dir_all(&zip_dir)
+            .expect("Failed to create temporary zip extraction directory");
+        zip::read::ZipArchive::new(std::io::Cursor::new(zip_data))
+            .expect("failed to open wamr zip file")
+            .extract(&zip_dir)
+            .expect("failed to extract wamr zip file");
+        let _ = std::fs::remove_dir_all(&wamr_dir);
+        std::fs::rename(zip_dir.join(ZIP_NAME), &wamr_dir)
+            .unwrap_or_else(|e| panic!("failed to rename wamr dir: {zip_dir:?} due to: {e:?}"));
+    } else {
+        println!("cargo::rerun-if-changed={}", wamr_dir.display());
+    }
+
+    let wamr_platform_dir = wamr_dir.join("product-mini/platforms").join(target_os);
+    let mut dst = Config::new(wamr_platform_dir.as_path());
+
+    dst.always_configure(true)
+        .generator("Ninja")
+        .no_build_target(true)
+        .define(
+            "CMAKE_BUILD_TYPE",
+            if cfg!(debug_assertions) {
+                "RelWithDebInfo"
+            } else {
+                "Release"
+            },
+        )
+        .define("CMAKE_POLICY_VERSION_MINIMUM", "3.5")
+        .define("WAMR_BUILD_AOT", "0")
+        //.define("WAMR_BUILD_TAIL_CALL", "1")
+        //.define("WAMR_BUILD_DUMP_CALL_STACK", "1")
+        // .define("WAMR_BUILD_CUSTOM_NAME_SECTION", "1")
+        // .define("WAMR_BUILD_LOAD_CUSTOM_SECTION", "1")
+        .define("WAMR_BUILD_BULK_MEMORY", "1")
+        .define("WAMR_BUILD_REF_TYPES", "1")
+        .define("WAMR_BUILD_SIMD", "1")
+        .define("WAMR_BUILD_FAST_INTERP", "1")
+        .define("WAMR_BUILD_LIB_PTHREAD", "1")
+        .define("WAMR_BUILD_LIB_WASI_THREADS", "0")
+        .define("WAMR_BUILD_LIBC_WASI", "0")
+        .define("WAMR_BUILD_LIBC_BUILTIN", "0")
+        .define("WAMR_BUILD_SHARED_MEMORY", "1")
+        .define("WAMR_BUILD_MULTI_MODULE", "1")
+        .define("WAMR_DISABLE_HW_BOUND_CHECK", "1")
+        .define("WAMR_BUILD_TARGET", target_arch);
+
+    if target_os == "windows" {
+        dst.define("CMAKE_CXX_COMPILER", "cl.exe");
+        dst.define("CMAKE_C_COMPILER", "cl.exe");
+        dst.define("CMAKE_LINKER_TYPE", "MSVC");
+        dst.define("WAMR_BUILD_PLATFORM", "windows");
+        dst.define("WAMR_BUILD_LIBC_UVWASI", "0");
+    }
+
+    //if target_os == "ios" {
+    //    // XXX: Hacky
+    //    //
+    //    // Compiling wamr targeting `aarch64-apple-ios` results in
+    //    //
+    //    // ```
+    //    //  clang: error: unsupported option '-mfloat-abi=' for target 'aarch64-apple-ios'
+    //    // ```
+    //    // So, here, we simply remove that setting.
+    //    //
+    //    // See: https://github.com/bytecodealliance/wasm-micro-runtime/pull/3889
+    //    let mut lines = vec![];
+    //    let cmake_file_path = wamr_platform_dir.join("CMakeLists.txt");
+    //    for line in std::fs::read_to_string(&cmake_file_path).unwrap().lines() {
+    //        if !line.contains("-mfloat-abi=hard") {
+    //            lines.push(line.to_string())
+    //        }
+    //    }
+    //    std::fs::write(cmake_file_path, lines.join("\n")).unwrap();
+    //}
+
+    let dst = dst.build();
+
+    // Check output of `cargo build --verbose`, should see something like:
+    // -L native=/path/runng/target/debug/build/runng-sys-abc1234/out
+    // That contains output from cmake
+
+    // Rename the symbols created from wamr.
+    static mut WAMR_RENAMED: Vec<(String, String)> = vec![];
+
+    #[derive(Debug)]
+    struct WamrRenamer {}
+    impl ParseCallbacks for WamrRenamer {
+        /// This function will run for every extern variable and function. The returned value determines
+        /// the link name in the bindings.
+        fn generated_link_name_override(
+            &self,
+            item_info: bindgen::callbacks::ItemInfo<'_>,
+        ) -> Option<String> {
+            if item_info.name.starts_with("wasm") {
+                let new_name = format!("wamr_{}", item_info.name);
+                unsafe {
+                    WAMR_RENAMED.push((item_info.name.to_string(), new_name.clone()));
+                }
+                Some(new_name)
+            } else {
+                None
+            }
+        }
+    }
+
+    let bindings = bindgen::Builder::default()
+        .header(
+            wamr_dir
+                .join("core/iwasm/include/wasm_c_api.h")
+                .to_str()
+                .unwrap(),
+        )
+        .derive_default(true)
+        .derive_debug(true)
+        .parse_callbacks(Box::new(WamrRenamer {}))
+        .generate()
+        .expect("Unable to generate bindings");
+    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
+    bindings
+        .write_to_file(out_path.join("wamr_bindings.rs"))
+        .expect("Couldn't write bindings");
+
+    let objcopy_names = ["llvm-objcopy", "objcopy", "gobjcopy"];
+
+    let mut objcopy = None;
+    for n in objcopy_names {
+        if which::which(n).is_ok() {
+            objcopy = Some(n);
+            break;
+        }
+    }
+
+    if objcopy.is_none() {
+        panic!(
+            "No program akin to `objcopy` found\nI searched for these programs in your path: {}",
+            objcopy_names.join(", ")
+        );
+    }
+
+    let objcopy = objcopy.unwrap();
+
+    unsafe {
+        let syms: Vec<String> = WAMR_RENAMED
+            .iter()
+            .map(|(old, new)|
+                // A bit hacky: we need a way to figure out if we're going to target a Mach-O
+                // library or an ELF one to take care of the "_" in front of symbols.
+            {
+                if cfg!(any(target_os = "macos", target_os = "ios")) {
+                    format!("--redefine-sym=_{old}={new}")
+                } else {
+                    format!("--redefine-sym={old}={new}")
+                }
+            })
+            .collect();
+        let output = std::process::Command::new(objcopy)
+            .args(syms)
+            .arg(dst.join("build").join("libvmlib.a").display().to_string())
+            .arg(dst.join("build").join("libwamr.a").display().to_string())
+            .output()
+            .unwrap();
+
+        if !output.status.success() {
+            panic!(
+                "{objcopy} failed with error code {}: {}",
+                output.status,
+                String::from_utf8(output.stderr).unwrap()
+            );
+        }
+    }
+
+    println!(
+        "cargo:rustc-link-search=native={}",
+        dst.join("build").display()
+    );
+    println!("cargo:rustc-link-lib=static=wamr");
+}
+
+#[cfg(feature = "v8")]
+fn build_v8() {
+    use bindgen::callbacks::ParseCallbacks;
+    use std::{env, path::PathBuf};
+
+    let url = match (
+            env::var("CARGO_CFG_TARGET_OS").unwrap().as_str(),
+            env::var("CARGO_CFG_TARGET_ARCH").unwrap().as_str(),
+            env::var("CARGO_CFG_TARGET_ENV").unwrap_or_default().as_str(),
+        ) {
+            ("macos", "aarch64", _) => "https://github.com/wasmerio/wee8-custom-builds/releases/download/11.8/wee8-darwin-aarch64.tar.xz",
+            ("macos", "x86_64", _) => "https://github.com/wasmerio/wee8-custom-builds/releases/download/11.8/wee8-darwin-amd64.tar.xz",
+            ("linux", "x86_64", "gnu") => "https://github.com/wasmerio/wee8-custom-builds/releases/download/11.8/wee8-linux-amd64.tar.xz",
+            ("linux", "x86_64", "musl") => "https://github.com/wasmerio/wee8-custom-builds/releases/download/11.8/wee8-linux-musl-amd64.tar.xz",
+            ("android", "aarch64", _)  => "https://github.com/wasmerio/wee8-custom-builds/releases/download/11.8/wee8-android-arm64.tar.xz",
+            // Not supported in 6.0.0-alpha1
+            //("windows", "x86_64", _) => "https://github.com/wasmerio/wee8-custom-builds/releases/download/11.7-custom1/wee8-windows-amd64.tar.xz",
+            (os, arch, _) => panic!("target os + arch combination not supported: {os}, {arch}"),
+        };
+
+    let out_dir = env::var("OUT_DIR").unwrap();
+    let crate_root = env::var("CARGO_MANIFEST_DIR").unwrap();
+    let v8_header_path = PathBuf::from(&crate_root).join("third-party").join("wee8");
+
+    let tar = ureq::get(url).call().expect("failed to download v8");
+
+    let mut tar_data = Vec::new();
+    tar.into_reader()
+        .read_to_end(&mut tar_data)
+        .expect("failed to download v8 lib");
+
+    let tar = xz::read::XzDecoder::new(tar_data.as_slice());
+    let mut archive = tar::Archive::new(tar);
+
+    for entry in archive.entries().unwrap() {
+        eprintln!("entry: {:?}", entry.unwrap().path());
+    }
+
+    let tar = xz::read::XzDecoder::new(tar_data.as_slice());
+    let mut archive = tar::Archive::new(tar);
+
+    archive.unpack(out_dir.clone()).unwrap();
+    println!("cargo:rustc-link-search=native={}", out_dir);
+
+    if cfg!(any(target_os = "linux",)) {
+        println!("cargo:rustc-link-lib=stdc++");
+    } else if cfg!(target_os = "windows") {
+        println!("cargo:rustc-link-lib=winmm");
+        println!("cargo:rustc-link-lib=dbghelp");
+        println!("cargo:rustc-link-lib=shlwapi");
+    } else {
+        println!("cargo:rustc-link-lib=c++");
+    }
+
+    // Rename the symbols created from wee8.
+    static mut WEE8_RENAMED: Vec<(String, String)> = vec![];
+
+    #[derive(Debug)]
+    struct Wee8Renamer {}
+    impl ParseCallbacks for Wee8Renamer {
+        /// This function will run for every extern variable and function. The returned value determines
+        /// the link name in the bindings.
+        fn generated_link_name_override(
+            &self,
+            item_info: bindgen::callbacks::ItemInfo<'_>,
+        ) -> Option<String> {
+            if item_info.name.starts_with("wasm") {
+                let new_name = format!("wee8_{}", item_info.name);
+                unsafe {
+                    WEE8_RENAMED.push((item_info.name.to_string(), new_name.clone()));
+                }
+                Some(new_name)
+            } else {
+                None
+            }
+        }
+    }
+
+    let header_path = v8_header_path.join("wasm.h");
+    let mut args = vec![];
+    if cfg!(target_os = "macos") {
+        args.push("-I/usr/local/include");
+        args.push("-I/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/c++/v1");
+        args.push("-I/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include");
+        args.push("-I/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include");
+        args.push("-I/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks");
+    }
+    let bindings = bindgen::Builder::default()
+        .header(header_path.display().to_string())
+        .clang_args(args)
+        .derive_default(true)
+        .derive_debug(true)
+        .parse_callbacks(Box::new(Wee8Renamer {}))
+        .generate()
+        .expect("Unable to generate bindings for `v8`!");
+
+    let out_path = PathBuf::from(out_dir);
+
+    bindings
+        .write_to_file(out_path.join("v8_bindings.rs"))
+        .expect("Couldn't write bindings");
+
+    let objcopy_names = ["llvm-objcopy", "objcopy", "gobjcopy"];
+
+    let mut objcopy = None;
+    for n in objcopy_names {
+        if which::which(n).is_ok() {
+            objcopy = Some(n);
+            break;
+        }
+    }
+
+    if objcopy.is_none() {
+        panic!(
+            "No program akin to `objcopy` found\nI searched for these programs in your path: {}",
+            objcopy_names.join(", ")
+        );
+    }
+
+    let objcopy = objcopy.unwrap();
+
+    unsafe {
+        let syms: Vec<String> = WEE8_RENAMED
+            .iter()
+            .map(|(old, new)|
+                // A bit hacky: we need a way to figure out if we're going to target a Mach-O
+                // library or an ELF one to take care of the "_" in front of symbols.
+            {
+                if cfg!(any(target_os = "macos", target_os = "ios")) {
+                    format!("--redefine-sym=_{old}={new}")
+                } else {
+                    format!("--redefine-sym={old}={new}")
+                }
+            })
+            .collect();
+        let output = dbg!(std::process::Command::new(objcopy)
+            .args(syms)
+            .arg(out_path.join("obj").join("libwee8.a").display().to_string())
+            .arg(out_path.join("libwee8prefixed.a").display().to_string()))
+        .output()
+        .unwrap();
+
+        if !output.status.success() {
+            panic!(
+                "{objcopy} failed with error code {}: {}",
+                output.status,
+                String::from_utf8(output.stderr).unwrap()
+            );
+        }
+    }
+
+    println!("cargo:rustc-link-lib=static=wee8prefixed");
+}
+
+#[cfg(feature = "wasmi")]
+fn build_wasmi() {
+    use bindgen::callbacks::ParseCallbacks;
+    use std::{env, path::PathBuf};
+
+    #[derive(Debug)]
+    struct WasmiRenamer {}
+
+    impl ParseCallbacks for WasmiRenamer {
+        /// This function will run for every extern variable and function. The returned value determines
+        /// the link name in the bindings.
+        fn generated_link_name_override(
+            &self,
+            item_info: bindgen::callbacks::ItemInfo<'_>,
+        ) -> Option<String> {
+            if item_info.name.starts_with("wasm") {
+                let new_name = if cfg!(any(target_os = "macos", target_os = "ios")) {
+                    format!("_wasmi_{}", item_info.name)
+                } else {
+                    format!("wasmi_{}", item_info.name)
+                };
+
+                Some(new_name)
+            } else {
+                None
+            }
+        }
+    }
+
+    let bindings = bindgen::Builder::default()
+        .header(
+            PathBuf::from(std::env::var("DEP_WASMI_C_API_INCLUDE").unwrap())
+                .join("wasm.h")
+                .to_string_lossy(),
+        )
+        .derive_default(true)
+        .derive_debug(true)
+        .parse_callbacks(Box::new(WasmiRenamer {}))
+        .generate()
+        .expect("Unable to generate bindings for `wasmi`!");
+    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
+    bindings
+        .write_to_file(out_path.join("wasmi_bindings.rs"))
+        .expect("Couldn't write bindings");
+}
+#[allow(unused)]
+fn main() {
+    #[cfg(feature = "wamr")]
+    build_wamr();
+
+    #[cfg(feature = "v8")]
+    build_v8();
+
+    #[cfg(feature = "wasmi")]
+    build_wasmi();
+}
diff --git a/lib/api/macro-wasmer-universal-test/Cargo.toml b/lib/api/macro-wasmer-universal-test/Cargo.toml
index 6bfecb9115..11d9f9acbd 100644
--- a/lib/api/macro-wasmer-universal-test/Cargo.toml
+++ b/lib/api/macro-wasmer-universal-test/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "macro-wasmer-universal-test"
-version = "4.3.7"
+version = "6.1.0"
 edition = "2021"
 license = "MIT"
 description = "Universal test macro for wasmer-test"
@@ -9,7 +9,14 @@ description = "Universal test macro for wasmer-test"
 proc-macro = true
 
 [dependencies]
-proc-quote = "0.4.0"
-proc-macro2 = "1.0.43"     
-syn = { version = "1.0.99", features = ["full"] }
-quote = "1.0.21"
\ No newline at end of file
+proc-macro2 = "1.0.60"
+syn = { version = "2.0", default-features = false, features = [
+    "full",
+    "parsing",
+    "printing",
+    "visit-mut",
+    "clone-impls",
+    "extra-traits",
+    "proc-macro",
+] }
+quote = "1.0.20"
diff --git a/lib/api/macro-wasmer-universal-test/src/lib.rs b/lib/api/macro-wasmer-universal-test/src/lib.rs
index 9af4a8c042..2e7abc3bae 100644
--- a/lib/api/macro-wasmer-universal-test/src/lib.rs
+++ b/lib/api/macro-wasmer-universal-test/src/lib.rs
@@ -1,36 +1,70 @@
-extern crate proc_macro;
-
-use proc_macro::TokenStream;
-use proc_macro2::{Ident, Span};
+use proc_macro2::{Ident, Span, TokenStream};
+use syn::{
+    parse::{Parse, ParseStream},
+    Attribute, Signature, Visibility,
+};
 
 #[proc_macro_attribute]
-pub fn universal_test(_attr: TokenStream, item: TokenStream) -> TokenStream {
-    let item_clone = item.clone();
-    let mut iter = item_clone.into_iter();
-    let _ = iter.next().unwrap(); // fn
-    let item_tree: proc_macro::TokenTree = iter.next().unwrap(); // fn ...
-    let n = match &item_tree {
-        proc_macro::TokenTree::Ident(i) => i.to_string(),
-        _ => panic!("expected fn ...() -> Result<(), String>"),
-    };
+pub fn universal_test(
+    _attr: proc_macro::TokenStream,
+    item: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    let MaybeItemFn {
+        outer_attrs,
+        inner_attrs,
+        vis,
+        sig,
+        block,
+    } = syn::parse_macro_input!(item as MaybeItemFn);
 
-    let function_name_normal = Ident::new(&n, Span::call_site());
-    let function_name_js = Ident::new(&format!("{}_js", n), Span::call_site());
-    let parsed = match syn::parse::<syn::ItemFn>(item) {
-        Ok(o) => o,
-        Err(e) => {
-            return proc_macro::TokenStream::from(e.to_compile_error());
-        }
-    };
+    let fn_call = Ident::new(&sig.ident.to_string(), Span::call_site());
+    let fn_js_call = Ident::new(&format!("{}_js", sig.ident), Span::call_site());
 
     let tokens = quote::quote! {
         #[cfg(feature = "js")]
         #[cfg_attr(feature = "js", wasm_bindgen_test)]
-        fn #function_name_js() { #function_name_normal().unwrap(); }
+        #(#outer_attrs) *
+        fn #fn_js_call() { #fn_call().unwrap(); }
 
-        #[cfg_attr(any(feature = "sys", feature = "jsc"), test)]
-        #parsed
+        #[cfg_attr(any(feature = "sys", feature = "jsc", feature = "wasm-c-api"), test)]
+        #(#outer_attrs) *
+        #vis #sig
+        {
+            #(#inner_attrs) *
+            #block
+        }
     };
 
     proc_macro::TokenStream::from(tokens)
 }
+
+// ---- Taken from tracing::instrument ----
+// This is a more flexible/imprecise `ItemFn` type,
+// which's block is just a `TokenStream` (it may contain invalid code).
+#[derive(Debug, Clone)]
+struct MaybeItemFn {
+    outer_attrs: Vec<Attribute>,
+    inner_attrs: Vec<Attribute>,
+    vis: Visibility,
+    sig: Signature,
+    block: TokenStream,
+}
+
+/// This parses a `TokenStream` into a `MaybeItemFn`
+/// (just like `ItemFn`, but skips parsing the body).
+impl Parse for MaybeItemFn {
+    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
+        let outer_attrs = input.call(Attribute::parse_outer)?;
+        let vis: Visibility = input.parse()?;
+        let sig: Signature = input.parse()?;
+        let inner_attrs = input.call(Attribute::parse_inner)?;
+        let block: TokenStream = input.parse()?;
+        Ok(Self {
+            outer_attrs,
+            inner_attrs,
+            vis,
+            sig,
+            block,
+        })
+    }
+}
diff --git a/lib/api/src/access.rs b/lib/api/src/access.rs
deleted file mode 100644
index 32ec42b5ce..0000000000
--- a/lib/api/src/access.rs
+++ /dev/null
@@ -1,219 +0,0 @@
-use std::mem::MaybeUninit;
-
-use crate::mem_access::{WasmRef, WasmSlice};
-
-pub(super) enum SliceCow<'a, T> {
-    #[allow(dead_code)]
-    Borrowed(&'a mut [T]),
-    #[allow(dead_code)]
-    Owned(Vec<T>, bool),
-}
-
-impl<'a, T> AsRef<[T]> for SliceCow<'a, T> {
-    fn as_ref(&self) -> &[T] {
-        match self {
-            Self::Borrowed(buf) => buf,
-            Self::Owned(buf, _) => buf,
-        }
-    }
-}
-
-impl<'a, T> AsMut<[T]> for SliceCow<'a, T> {
-    fn as_mut(&mut self) -> &mut [T] {
-        // Note: Zero padding is not required here as its a typed copy which does
-        //       not leak the bytes into the memory
-        // https://stackoverflow.com/questions/61114026/does-stdptrwrite-transfer-the-uninitialized-ness-of-the-bytes-it-writes
-        match self {
-            Self::Borrowed(buf) => buf,
-            Self::Owned(buf, modified) => {
-                *modified = true;
-                buf.as_mut()
-            }
-        }
-    }
-}
-
-/// Provides direct memory access to a piece of memory that
-/// is owned by WASM
-pub struct WasmSliceAccess<'a, T>
-where
-    T: wasmer_types::ValueType,
-{
-    pub(super) slice: WasmSlice<'a, T>,
-    pub(super) buf: SliceCow<'a, T>,
-}
-
-impl<'a, T> AsRef<[T]> for WasmSliceAccess<'a, T>
-where
-    T: wasmer_types::ValueType,
-{
-    fn as_ref(&self) -> &[T] {
-        self.buf.as_ref()
-    }
-}
-
-impl<'a, T> AsMut<[T]> for WasmSliceAccess<'a, T>
-where
-    T: wasmer_types::ValueType,
-{
-    fn as_mut(&mut self) -> &mut [T] {
-        self.buf.as_mut()
-    }
-}
-
-impl<'a, T> WasmSliceAccess<'a, T>
-where
-    T: wasmer_types::ValueType,
-{
-    /// Returns an iterator of all the elements in the slice
-    pub fn iter(&'a self) -> std::slice::Iter<'a, T> {
-        self.as_ref().iter()
-    }
-
-    /// Returns an iterator of all the elements in the slice
-    pub fn iter_mut(&'a mut self) -> std::slice::IterMut<'a, T> {
-        self.buf.as_mut().iter_mut()
-    }
-
-    /// Number of elements in this slice
-    pub fn len(&self) -> usize {
-        self.buf.as_ref().len()
-    }
-
-    /// If the slice is empty
-    pub fn is_empty(&self) -> bool {
-        self.buf.as_ref().is_empty()
-    }
-}
-
-impl<'a> WasmSliceAccess<'a, u8> {
-    /// Writes to the address pointed to by this `WasmPtr` in a memory.
-    #[inline]
-    pub fn copy_from_slice(&mut self, src: &[u8]) {
-        let dst = self.buf.as_mut();
-        dst.copy_from_slice(src);
-    }
-
-    /// Writes to the address pointed to by this `WasmPtr` in a memory.
-    ///
-    /// If the source buffer is smaller than the destination buffer
-    /// only the correct amount of bytes will be copied
-    ///
-    /// Returns the number of bytes copied
-    #[inline]
-    pub fn copy_from_slice_min(&mut self, src: &[u8]) -> usize {
-        let dst = self.buf.as_mut();
-        let amt = dst.len().min(src.len());
-        dst[..amt].copy_from_slice(&src[..amt]);
-        amt
-    }
-}
-
-impl<'a, T> Drop for WasmSliceAccess<'a, T>
-where
-    T: wasmer_types::ValueType,
-{
-    fn drop(&mut self) {
-        if let SliceCow::Owned(buf, modified) = &self.buf {
-            if *modified {
-                self.slice.write_slice(buf.as_ref()).ok();
-            }
-        }
-    }
-}
-
-pub(super) enum RefCow<'a, T> {
-    #[allow(dead_code)]
-    Borrowed(&'a mut T),
-    #[allow(dead_code)]
-    Owned(T, bool),
-}
-
-impl<'a, T> AsRef<T> for RefCow<'a, T> {
-    fn as_ref(&self) -> &T {
-        match self {
-            Self::Borrowed(val) => val,
-            Self::Owned(val, _) => val,
-        }
-    }
-}
-
-impl<'a, T> AsMut<T> for RefCow<'a, T> {
-    fn as_mut(&mut self) -> &mut T {
-        // Note: Zero padding is not required here as its a typed copy which does
-        //       not leak the bytes into the memory
-        // https://stackoverflow.com/questions/61114026/does-stdptrwrite-transfer-the-uninitialized-ness-of-the-bytes-it-writes
-        match self {
-            Self::Borrowed(val) => val,
-            Self::Owned(val, modified) => {
-                *modified = true;
-                val
-            }
-        }
-    }
-}
-
-/// Provides direct memory access to a piece of memory that
-/// is owned by WASM
-pub struct WasmRefAccess<'a, T>
-where
-    T: wasmer_types::ValueType,
-{
-    pub(super) ptr: WasmRef<'a, T>,
-    pub(super) buf: RefCow<'a, T>,
-}
-
-impl<'a, T> AsRef<T> for WasmRefAccess<'a, T>
-where
-    T: wasmer_types::ValueType,
-{
-    fn as_ref(&self) -> &T {
-        self.buf.as_ref()
-    }
-}
-
-impl<'a, T> AsMut<T> for WasmRefAccess<'a, T>
-where
-    T: wasmer_types::ValueType,
-{
-    fn as_mut(&mut self) -> &mut T {
-        self.buf.as_mut()
-    }
-}
-
-impl<'a, T> Drop for WasmRefAccess<'a, T>
-where
-    T: wasmer_types::ValueType,
-{
-    fn drop(&mut self) {
-        if let RefCow::Owned(val, modified) = &self.buf {
-            if *modified {
-                self.ptr.write(*val).ok();
-            }
-        }
-    }
-}
-
-impl<'a, T> WasmSliceAccess<'a, T>
-where
-    T: wasmer_types::ValueType,
-{
-    /// Returns a mutable slice that is not yet initialized
-    pub fn as_mut_uninit(&mut self) -> &mut [MaybeUninit<T>] {
-        let ret: &mut [T] = self.buf.as_mut();
-        let ret: &mut [MaybeUninit<T>] = unsafe { std::mem::transmute(ret) };
-        ret
-    }
-}
-
-impl<'a, T> WasmRefAccess<'a, T>
-where
-    T: wasmer_types::ValueType,
-{
-    /// Returns a reference to an unitialized reference to this value
-    pub fn as_mut_uninit(&mut self) -> &mut MaybeUninit<T> {
-        let ret: &mut T = self.buf.as_mut();
-        let ret: &mut MaybeUninit<T> = unsafe { std::mem::transmute(ret) };
-        ret
-    }
-}
diff --git a/lib/api/src/backend/js/entities/engine.rs b/lib/api/src/backend/js/entities/engine.rs
new file mode 100644
index 0000000000..cdb2316c30
--- /dev/null
+++ b/lib/api/src/backend/js/entities/engine.rs
@@ -0,0 +1,81 @@
+use wasmer_types::{target::Target, Features};
+
+/// The engine for the JavaScript runtime.
+#[derive(Clone, Debug)]
+pub struct Engine;
+
+impl Engine {
+    pub(crate) fn deterministic_id(&self) -> String {
+        // All js engines have the same id
+        String::from("js-generic")
+    }
+
+    /// Returns the WebAssembly features supported by the JS engine.
+    pub fn supported_features() -> Features {
+        // JS-specific features
+        let mut features = Features::default();
+        features.bulk_memory(true);
+        features.reference_types(true);
+        features.simd(true);
+        features.threads(true);
+        features.multi_value(true);
+        features.exceptions(false);
+        features
+    }
+
+    /// Returns the default features for the JS engine.
+    pub fn default_features() -> Features {
+        Self::supported_features()
+    }
+}
+
+impl Default for Engine {
+    fn default() -> Self {
+        Engine
+    }
+}
+
+/// Returns the default engine for the JS engine
+pub(crate) fn default_engine() -> Engine {
+    Engine::default()
+}
+
+impl crate::Engine {
+    /// Consume [`self`] into a [`crate::backend::js::engine::Engine`].
+    pub fn into_js(self) -> crate::backend::js::engine::Engine {
+        match self.be {
+            crate::BackendEngine::Js(s) => s,
+            _ => panic!("Not a `js` engine!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::js::engine::Engine`].
+    pub fn as_js(&self) -> &crate::backend::js::engine::Engine {
+        match self.be {
+            crate::BackendEngine::Js(ref s) => s,
+            _ => panic!("Not a `js` engine!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::js::engine::Engine`].
+    pub fn as_js_mut(&mut self) -> &mut crate::backend::js::engine::Engine {
+        match self.be {
+            crate::BackendEngine::Js(ref mut s) => s,
+            _ => panic!("Not a `js` engine!"),
+        }
+    }
+
+    /// Return true if [`self`] is an engine from the `js` runtime.
+    pub fn is_js(&self) -> bool {
+        matches!(self.be, crate::BackendEngine::Js(_))
+    }
+}
+
+impl Into<crate::Engine> for Engine {
+    fn into(self) -> crate::Engine {
+        crate::Engine {
+            be: crate::BackendEngine::Js(self),
+            id: crate::Engine::atomic_next_engine_id(),
+        }
+    }
+}
diff --git a/lib/api/src/backend/js/entities/exception.rs b/lib/api/src/backend/js/entities/exception.rs
new file mode 100644
index 0000000000..be352635d4
--- /dev/null
+++ b/lib/api/src/backend/js/entities/exception.rs
@@ -0,0 +1,61 @@
+//! Data types, functions and traits for `sys` runtime's `Tag` implementation.
+
+use super::store::StoreHandle;
+use crate::{
+    js::vm::{VMException, VMExceptionRef},
+    AsStoreMut, AsStoreRef, Tag, Value,
+};
+use std::any::Any;
+use wasmer_types::{TagType, Type};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// A WebAssembly `tag` in the `v8` runtime.
+pub(crate) struct Exception {
+    pub(crate) handle: VMException,
+}
+
+unsafe impl Send for Exception {}
+unsafe impl Sync for Exception {}
+
+impl Exception {
+    /// Create a new [`Exception`].
+    pub fn new(store: &mut impl AsStoreMut, tag: Tag, payload: &[Value]) -> Self {
+        todo!()
+    }
+}
+
+#[derive(Debug, Clone)]
+#[repr(transparent)]
+/// A WebAssembly `exnref` in `js`.
+pub(crate) struct ExceptionRef;
+
+impl ExceptionRef {
+    pub fn new<T>(_store: &mut impl AsStoreMut, _value: T) -> Self
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        unimplemented!("ExceptionRef is not yet supported in js");
+    }
+
+    pub fn downcast<'a, T>(&self, _store: &'a impl AsStoreRef) -> Option<&'a T>
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        unimplemented!("ExceptionRef is not yet supported in js");
+    }
+
+    pub(crate) fn vm_exceptionref(&self) -> VMExceptionRef {
+        unimplemented!("ExceptionRef is not yet supported in js");
+    }
+
+    pub(crate) unsafe fn from_vm_exceptionref(
+        _store: &mut impl AsStoreMut,
+        _vm_exceptionref: VMExceptionRef,
+    ) -> Self {
+        unimplemented!("ExceptionRef is not yet supported in js");
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
diff --git a/lib/api/src/js/extern_ref.rs b/lib/api/src/backend/js/entities/external.rs
similarity index 96%
rename from lib/api/src/js/extern_ref.rs
rename to lib/api/src/backend/js/entities/external.rs
index fc0771e612..37da6fd0af 100644
--- a/lib/api/src/js/extern_ref.rs
+++ b/lib/api/src/backend/js/entities/external.rs
@@ -5,6 +5,7 @@ use crate::store::{AsStoreMut, AsStoreRef};
 
 #[derive(Debug, Clone)]
 #[repr(transparent)]
+/// A WebAssembly `extern ref` in `js`.
 pub struct ExternRef;
 
 impl ExternRef {
diff --git a/lib/api/src/function_env.rs b/lib/api/src/backend/js/entities/function/env.rs
similarity index 70%
rename from lib/api/src/function_env.rs
rename to lib/api/src/backend/js/entities/function/env.rs
index 89c1de7e0d..b05024cd78 100644
--- a/lib/api/src/function_env.rs
+++ b/lib/api/src/backend/js/entities/function/env.rs
@@ -1,8 +1,10 @@
 use std::{any::Any, fmt::Debug, marker::PhantomData};
 
-use crate::vm::VMFunctionEnvironment;
-
-use crate::store::{AsStoreMut, AsStoreRef, StoreHandle, StoreMut, StoreObjects, StoreRef};
+use crate::{
+    js::{store::StoreHandle, vm::VMFunctionEnvironment},
+    store::{AsStoreMut, AsStoreRef, StoreRef},
+    StoreMut,
+};
 
 #[derive(Debug)]
 #[repr(transparent)]
@@ -21,7 +23,7 @@ impl<T> FunctionEnv<T> {
     {
         Self {
             handle: StoreHandle::new(
-                store.as_store_mut().objects_mut(),
+                store.as_store_mut().objects_mut().as_js_mut(),
                 VMFunctionEnvironment::new(value),
             ),
             marker: PhantomData,
@@ -34,13 +36,12 @@ impl<T> FunctionEnv<T> {
         T: Any + Send + 'static + Sized,
     {
         self.handle
-            .get(store.as_store_ref().objects())
+            .get(store.as_store_ref().objects().as_js())
             .as_ref()
             .downcast_ref::<T>()
             .unwrap()
     }
 
-    #[allow(dead_code)] // This function is only used in js
     pub(crate) fn from_handle(handle: StoreHandle<VMFunctionEnvironment>) -> Self {
         Self {
             handle,
@@ -54,7 +55,7 @@ impl<T> FunctionEnv<T> {
         T: Any + Send + 'static + Sized,
     {
         self.handle
-            .get_mut(store.objects_mut())
+            .get_mut(store.objects_mut().as_js_mut())
             .as_mut()
             .downcast_mut::<T>()
             .unwrap()
@@ -161,8 +162,46 @@ impl<T> AsStoreMut for FunctionEnvMut<'_, T> {
             inner: self.store_mut.inner,
         }
     }
-    #[inline]
-    fn objects_mut(&mut self) -> &mut StoreObjects {
-        &mut self.store_mut.inner.objects
+
+    fn objects_mut(&mut self) -> &mut crate::StoreObjects {
+        self.store_mut.objects_mut()
+    }
+}
+
+impl<T> crate::FunctionEnv<T> {
+    /// Consume [`self`] into [`crate::backend::js::function::env::FunctionEnv`].
+    pub fn into_js(self) -> FunctionEnv<T> {
+        match self.0 {
+            crate::BackendFunctionEnv::Js(s) => s,
+            _ => panic!("Not a `js` function env!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference to [`crate::backend::js::function::env::FunctionEnv`].
+    pub fn as_js(&self) -> &FunctionEnv<T> {
+        match self.0 {
+            crate::BackendFunctionEnv::Js(ref s) => s,
+            _ => panic!("Not a `js` function env!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::js::function::env::FunctionEnv`].
+    pub fn as_js_mut(&mut self) -> &mut FunctionEnv<T> {
+        match self.0 {
+            crate::BackendFunctionEnv::Js(ref mut s) => s,
+            _ => panic!("Not a `js` function env!"),
+        }
+    }
+}
+
+impl<'a, T> From<FunctionEnvMut<'a, T>> for crate::FunctionEnvMut<'a, T> {
+    fn from(value: FunctionEnvMut<'a, T>) -> Self {
+        crate::FunctionEnvMut(crate::BackendFunctionEnvMut::Js(value))
+    }
+}
+
+impl<T> From<FunctionEnv<T>> for crate::FunctionEnv<T> {
+    fn from(value: FunctionEnv<T>) -> Self {
+        crate::FunctionEnv(crate::BackendFunctionEnv::Js(value))
     }
 }
diff --git a/lib/api/src/js/externals/function.rs b/lib/api/src/backend/js/entities/function/mod.rs
similarity index 63%
rename from lib/api/src/js/externals/function.rs
rename to lib/api/src/backend/js/entities/function/mod.rs
index 1d588ff9d0..667fa091ec 100644
--- a/lib/api/src/js/externals/function.rs
+++ b/lib/api/src/backend/js/entities/function/mod.rs
@@ -1,44 +1,33 @@
-use crate::errors::RuntimeError;
-use crate::externals::function::{HostFunction, HostFunctionKind, WithEnv, WithoutEnv};
-use crate::function_env::{FunctionEnv, FunctionEnvMut};
-use crate::js::as_js::{param_from_js, AsJs}; /* ValFuncRef */
-use crate::js::store::{InternalStoreHandle, StoreHandle};
-use crate::js::vm::{VMExtern, VMFuncRef, VMFunction, VMFunctionCallback, VMFunctionEnvironment};
-use crate::native_type::{FromToNativeWasmType, IntoResult, NativeWasmTypeInto, WasmTypeList};
-use crate::store::{AsStoreMut, AsStoreRef, StoreMut};
-use crate::value::Value;
-use std::fmt;
-use std::iter::FromIterator;
+pub(crate) mod env;
+pub(crate) mod typed;
 use std::marker::PhantomData;
-use std::panic::{self, AssertUnwindSafe};
 
-use wasmer_types::{FunctionType, NativeWasmType, RawValue};
+pub(crate) use typed::*;
 
-use js_sys::{Array, Function as JSFunction};
-use wasm_bindgen::prelude::*;
-use wasm_bindgen::JsCast;
+use js_sys::{Array, Function as JsFunction};
+use wasm_bindgen::{prelude::*, JsCast};
+use wasmer_types::{FunctionType, RawValue};
 
-#[inline]
-fn result_to_js(val: &Value) -> JsValue {
-    match val {
-        Value::I32(i) => JsValue::from_f64(*i as _),
-        Value::I64(i) => JsValue::from_f64(*i as _),
-        Value::F32(f) => JsValue::from_f64(*f as _),
-        Value::F64(f) => JsValue::from_f64(*f),
-        Value::V128(f) => JsValue::from_f64(*f as _),
-        val => unimplemented!(
-            "The value `{:?}` is not yet supported in the JS Function API",
-            val
-        ),
-    }
-}
+use crate::{
+    js::{
+        utils::convert::{js_value_to_wasmer, wasmer_value_to_js, AsJs as _},
+        vm::{function::VMFunction, VMFuncRef, VMFunctionCallback},
+    },
+    vm::{VMExtern, VMExternFunction},
+    AsStoreMut, AsStoreRef, BackendFunction, BackendFunctionEnv, BackendFunctionEnvMut,
+    FromToNativeWasmType, FunctionEnv, FunctionEnvMut, HostFunction, HostFunctionKind, IntoResult,
+    NativeWasmType, NativeWasmTypeInto, RuntimeError, StoreMut, Value, WasmTypeList, WithEnv,
+    WithoutEnv,
+};
+
+use std::panic::{self, AssertUnwindSafe};
 
 #[inline]
-fn results_to_js_array(values: &[Value]) -> Array {
-    Array::from_iter(values.iter().map(result_to_js))
+fn wasmer_array_to_js_array(values: &[Value]) -> Array {
+    Array::from_iter(values.iter().map(wasmer_value_to_js))
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Clone, PartialEq, Eq)]
 pub struct Function {
     pub(crate) handle: VMFunction,
 }
@@ -55,8 +44,10 @@ impl From<VMFunction> for Function {
 
 impl Function {
     /// To `VMExtern`.
-    pub fn to_vm_extern(&self) -> VMExtern {
-        VMExtern::Function(self.handle.clone())
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Js(crate::js::vm::external::VMExtern::Function(
+            self.handle.clone(),
+        ))
     }
 
     #[allow(clippy::cast_ptr_alignment)]
@@ -86,7 +77,7 @@ impl Function {
                     .params()
                     .iter()
                     .enumerate()
-                    .map(|(i, param)| param_from_js(param, &args.get(i as u32)))
+                    .map(|(i, param)| js_value_to_wasmer(param, &args.get(i as u32)))
                     .collect::<Vec<_>>();
                 let _results = func(env, &wasm_arguments)?;
                 Ok(())
@@ -100,10 +91,10 @@ impl Function {
                     .params()
                     .iter()
                     .enumerate()
-                    .map(|(i, param)| param_from_js(param, &args.get(i as u32)))
+                    .map(|(i, param)| js_value_to_wasmer(param, &args.get(i as u32)))
                     .collect::<Vec<_>>();
                 let results = func(env, &wasm_arguments)?;
-                return Ok(result_to_js(&results[0]));
+                return Ok(wasmer_value_to_js(&results[0]));
             })
                 as Box<dyn FnMut(&Array) -> Result<JsValue, JsValue>>)
             .into_js_value(),
@@ -114,20 +105,20 @@ impl Function {
                     .params()
                     .iter()
                     .enumerate()
-                    .map(|(i, param)| param_from_js(param, &args.get(i as u32)))
+                    .map(|(i, param)| js_value_to_wasmer(param, &args.get(i as u32)))
                     .collect::<Vec<_>>();
                 let results = func(env, &wasm_arguments)?;
-                return Ok(results_to_js_array(&results));
+                return Ok(wasmer_array_to_js_array(&results));
             })
                 as Box<dyn FnMut(&Array) -> Result<Array, JsValue>>)
             .into_js_value(),
         };
 
         let dyn_func =
-            JSFunction::new_with_args("f", "return f(Array.prototype.slice.call(arguments, 1))");
+            JsFunction::new_with_args("f", "return f(Array.prototype.slice.call(arguments, 1))");
         let binded_func = dyn_func.bind1(&JsValue::UNDEFINED, &wrapped_func);
         let vm_function = VMFunction::new(binded_func, func_ty);
-        Self::from_vm_extern(&mut store, vm_function)
+        Self::from_vm_extern(&mut store, VMExternFunction::Js(vm_function))
     }
 
     /// Creates a new host `Function` from a native function.
@@ -183,7 +174,7 @@ impl Function {
         let binded_func = func.bind2(
             &JsValue::UNDEFINED,
             &JsValue::from_f64(store.as_raw() as *mut u8 as usize as f64),
-            &JsValue::from_f64(env.handle.internal_handle().index() as f64),
+            &JsValue::from_f64(env.as_js().handle.internal_handle().index() as f64),
         );
         let ty = function.ty();
         let vm_function = VMFunction::new(binded_func, ty);
@@ -256,7 +247,7 @@ impl Function {
         match result_types.len() {
             0 => Ok(Box::new([])),
             1 => {
-                let value = param_from_js(&result_types[0], &result);
+                let value = js_value_to_wasmer(&result_types[0], &result);
                 Ok(vec![value].into_boxed_slice())
             }
             _n => {
@@ -264,15 +255,17 @@ impl Function {
                 Ok(result_array
                     .iter()
                     .enumerate()
-                    .map(|(i, js_val)| param_from_js(&result_types[i], &js_val))
+                    .map(|(i, js_val)| js_value_to_wasmer(&result_types[i], &js_val))
                     .collect::<Vec<_>>()
                     .into_boxed_slice())
             }
         }
     }
 
-    pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, internal: VMFunction) -> Self {
-        Self { handle: internal }
+    pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, internal: VMExternFunction) -> Self {
+        Self {
+            handle: internal.into_js(),
+        }
     }
 
     pub(crate) fn vm_funcref(&self, _store: &impl AsStoreRef) -> VMFuncRef {
@@ -297,8 +290,8 @@ impl Function {
     }
 }
 
-impl fmt::Debug for Function {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+impl std::fmt::Debug for Function {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
         formatter.debug_struct("Function").finish()
     }
 }
@@ -327,7 +320,7 @@ where
         T: Sized,
     {
         Self {
-            address: function.function_callback(),
+            address: function.function_callback(crate::BackendKind::Js).into_js(),
             _phantom: PhantomData,
         }
     }
@@ -345,116 +338,123 @@ where
     }
 }
 
+impl crate::Function {
+    /// Consume [`self`] into [`crate::backend::js::function::Function`].
+    pub fn into_js(self) -> crate::backend::js::function::Function {
+        match self.0 {
+            BackendFunction::Js(s) => s,
+            _ => panic!("Not a `js` function!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference to [`crate::backend::js::function::Function`].
+    pub fn as_js(&self) -> &crate::backend::js::function::Function {
+        match self.0 {
+            BackendFunction::Js(ref s) => s,
+            _ => panic!("Not a `js` function!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::js::function::Function`].
+    pub fn as_js_mut(&mut self) -> &mut crate::backend::js::function::Function {
+        match self.0 {
+            BackendFunction::Js(ref mut s) => s,
+            _ => panic!("Not a `js` function!"),
+        }
+    }
+}
+
 macro_rules! impl_host_function {
-        ( [$c_struct_representation:ident]
-           $c_struct_name:ident,
-           $( $x:ident ),* ) => {
-
-            // Implement `HostFunction` for a function with a [`FunctionEnvMut`] that has the same
-            // arity than the tuple.
-            #[allow(unused_parens)]
-            impl< $( $x, )* Rets, RetsAsResult, T, Func >
-                HostFunction<T, ( $( $x ),* ), Rets, WithEnv>
-            for
-                Func
+    ([$c_struct_representation:ident] $c_struct_name:ident, $( $x:ident ),* ) => {
+        paste::paste! {
+        #[allow(non_snake_case)]
+        pub(crate) fn [<gen_fn_callback_ $c_struct_name:lower _no_env>]
+            <$( $x: FromToNativeWasmType, )* Rets: WasmTypeList, RetsAsResult: IntoResult<Rets>, Func: Fn($( $x , )*) -> RetsAsResult + 'static>
+            (this: &Func) -> crate::backend::js::vm::VMFunctionCallback {
+
+            /// This is a function that wraps the real host
+            /// function. Its address will be used inside the
+            /// runtime.
+            unsafe extern "C" fn func_wrapper<$( $x, )* Rets, RetsAsResult, Func>( store_ptr: usize, $( $x: <$x::Native as NativeWasmType>::Abi, )* ) -> Rets::CStruct
             where
                 $( $x: FromToNativeWasmType, )*
                 Rets: WasmTypeList,
                 RetsAsResult: IntoResult<Rets>,
-                T: Send + 'static,
-                Func: Fn(FunctionEnvMut<'_, T>, $( $x , )*) -> RetsAsResult + 'static,
+                Func: Fn($( $x , )*) -> RetsAsResult + 'static,
             {
-                #[allow(non_snake_case)]
-                fn function_callback(&self) -> VMFunctionCallback {
-                    /// This is a function that wraps the real host
-                    /// function. Its address will be used inside the
-                    /// runtime.
-                    unsafe extern "C" fn func_wrapper<T, $( $x, )* Rets, RetsAsResult, Func>( store_ptr: usize, handle_index: usize, $( $x: <$x::Native as NativeWasmType>::Abi, )* ) -> Rets::CStruct
-                    where
-                        $( $x: FromToNativeWasmType, )*
-                        Rets: WasmTypeList,
-                        RetsAsResult: IntoResult<Rets>,
-                        T: Send + 'static,
-                        Func: Fn(FunctionEnvMut<'_, T>, $( $x , )*) -> RetsAsResult + 'static,
-                    {
-                        let mut store = StoreMut::from_raw(store_ptr as *mut _);
-                        let mut store2 = StoreMut::from_raw(store_ptr as *mut _);
-
-                        let result = {
-                            // let env: &Env = unsafe { &*(ptr as *const u8 as *const Env) };
-                            let func: &Func = &*(&() as *const () as *const Func);
-                            panic::catch_unwind(AssertUnwindSafe(|| {
-                                let handle: StoreHandle<VMFunctionEnvironment> = StoreHandle::from_internal(store2.objects_mut().id(), InternalStoreHandle::from_index(handle_index).unwrap());
-                                let env: FunctionEnvMut<T> = FunctionEnv::from_handle(handle).into_mut(&mut store2);
-                                func(env, $( FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(&mut store, $x)) ),* ).into_result()
-                            }))
-                        };
-
-                        match result {
-                            Ok(Ok(result)) => return result.into_c_struct(&mut store),
-                            #[allow(deprecated)]
-                            #[cfg(feature = "std")]
-                            Ok(Err(trap)) => crate::js::errors::raise(Box::new(trap)),
-                            #[cfg(feature = "core")]
-                            #[allow(deprecated)]
-                            Ok(Err(trap)) => crate::js::errors::raise(Box::new(trap)),
-                            Err(_panic) => unimplemented!(),
-                        }
-                    }
-
-                    func_wrapper::< T, $( $x, )* Rets, RetsAsResult, Self > as VMFunctionCallback
+                // let env: &Env = unsafe { &*(ptr as *const u8 as *const Env) };
+                let func: &Func = &*(&() as *const () as *const Func);
+                let mut store = StoreMut::from_raw(store_ptr as *mut _);
+
+                let result = panic::catch_unwind(AssertUnwindSafe(|| {
+                    func($( FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(&mut store, $x)) ),* ).into_result()
+                }));
+
+                match result {
+                    Ok(Ok(result)) => return result.into_c_struct(&mut store),
+                    #[cfg(feature = "std")]
+                    #[allow(deprecated)]
+                    Ok(Err(trap)) => crate::backend::js::error::raise(Box::new(trap)),
+                    #[cfg(feature = "core")]
+                    #[allow(deprecated)]
+                    Ok(Err(trap)) => crate::backend::js::error::raise(Box::new(trap)),
+                    Err(_panic) => unimplemented!(),
                 }
             }
 
-            // Implement `HostFunction` for a function that has the same arity than the tuple.
-            #[allow(unused_parens)]
-            impl< $( $x, )* Rets, RetsAsResult, Func >
-                HostFunction<(), ( $( $x ),* ), Rets, WithoutEnv>
-            for
-                Func
+            func_wrapper::< $( $x, )* Rets, RetsAsResult, Func> as _
+
+        }
+
+
+        #[allow(non_snake_case)]
+        pub(crate) fn [<gen_fn_callback_ $c_struct_name:lower>]
+            <$( $x: FromToNativeWasmType, )* Rets: WasmTypeList, RetsAsResult: IntoResult<Rets>, T: Send + 'static,  Func: Fn(FunctionEnvMut<T>, $( $x , )*) -> RetsAsResult + 'static>
+            (this: &Func) -> crate::backend::js::vm::VMFunctionCallback {
+
+            /// This is a function that wraps the real host
+            /// function. Its address will be used inside the
+            /// runtime.
+            unsafe extern "C" fn func_wrapper<T, $( $x, )* Rets, RetsAsResult, Func>( store_ptr: usize, handle_index: usize, $( $x: <$x::Native as NativeWasmType>::Abi, )* ) -> Rets::CStruct
             where
                 $( $x: FromToNativeWasmType, )*
                 Rets: WasmTypeList,
                 RetsAsResult: IntoResult<Rets>,
-                Func: Fn($( $x , )*) -> RetsAsResult + 'static,
+                T: Send + 'static,
+                Func: Fn(FunctionEnvMut<'_, T>, $( $x , )*) -> RetsAsResult + 'static,
             {
-                #[allow(non_snake_case)]
-                fn function_callback(&self) -> VMFunctionCallback {
-                    /// This is a function that wraps the real host
-                    /// function. Its address will be used inside the
-                    /// runtime.
-                    unsafe extern "C" fn func_wrapper<$( $x, )* Rets, RetsAsResult, Func>( store_ptr: usize, $( $x: <$x::Native as NativeWasmType>::Abi, )* ) -> Rets::CStruct
-                    where
-                        $( $x: FromToNativeWasmType, )*
-                        Rets: WasmTypeList,
-                        RetsAsResult: IntoResult<Rets>,
-                        Func: Fn($( $x , )*) -> RetsAsResult + 'static,
-                    {
-                        // let env: &Env = unsafe { &*(ptr as *const u8 as *const Env) };
-                        let func: &Func = &*(&() as *const () as *const Func);
-                        let mut store = StoreMut::from_raw(store_ptr as *mut _);
-
-                        let result = panic::catch_unwind(AssertUnwindSafe(|| {
-                            func($( FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(&mut store, $x)) ),* ).into_result()
-                        }));
-
-                        match result {
-                            Ok(Ok(result)) => return result.into_c_struct(&mut store),
-                            #[cfg(feature = "std")]
-                            #[allow(deprecated)]
-                            Ok(Err(trap)) => crate::js::errors::raise(Box::new(trap)),
-                            #[cfg(feature = "core")]
-                            #[allow(deprecated)]
-                            Ok(Err(trap)) => crate::js::errors::raise(Box::new(trap)),
-                            Err(_panic) => unimplemented!(),
-                        }
-                    }
-
-                    func_wrapper::< $( $x, )* Rets, RetsAsResult, Self > as VMFunctionCallback
+                let mut store = StoreMut::from_raw(store_ptr as *mut _);
+                let mut store2 = StoreMut::from_raw(store_ptr as *mut _);
+
+                let result = {
+                    // let env: &Env = unsafe { &*(ptr as *const u8 as *const Env) };
+                    let func: &Func = &*(&() as *const () as *const Func);
+                    panic::catch_unwind(AssertUnwindSafe(|| {
+                        let handle: crate::backend::js::store::StoreHandle<crate::backend::js::vm::VMFunctionEnvironment> =
+                          crate::backend::js::store::StoreHandle::from_internal(store2.objects_mut().id(), crate::backend::js::store::InternalStoreHandle::from_index(handle_index).unwrap());
+                        let env: crate::backend::js::function::env::FunctionEnvMut<T> = crate::backend::js::function::env::FunctionEnv::from_handle(handle).into_mut(&mut store2);
+                        func(BackendFunctionEnvMut::Js(env).into(), $( FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(&mut store, $x)) ),* ).into_result()
+                    }))
+                };
+
+                match result {
+                    Ok(Ok(result)) => return result.into_c_struct(&mut store),
+                    #[allow(deprecated)]
+                    #[cfg(feature = "std")]
+                    Ok(Err(trap)) => crate::js::error::raise(Box::new(trap)),
+                    #[cfg(feature = "core")]
+                    #[allow(deprecated)]
+                    Ok(Err(trap)) => crate::js::error::raise(Box::new(trap)),
+                    Err(_panic) => unimplemented!(),
                 }
             }
-        };
-    }
+
+            func_wrapper::< T, $( $x, )* Rets, RetsAsResult, Func > as _
+        }
+
+        }
+    };
+}
 
 // Here we go! Let's generate all the C struct, `WasmTypeList`
 // implementations and `HostFunction` implementations.
diff --git a/lib/api/src/js/typed_function.rs b/lib/api/src/backend/js/entities/function/typed.rs
similarity index 81%
rename from lib/api/src/js/typed_function.rs
rename to lib/api/src/backend/js/entities/function/typed.rs
index 22cd2bf9c5..029dd229c1 100644
--- a/lib/api/src/js/typed_function.rs
+++ b/lib/api/src/backend/js/entities/function/typed.rs
@@ -7,12 +7,11 @@
 //! let add_one = instance.exports.get_function("function_name")?;
 //! let add_one_native: TypedFunction<i32, i32> = add_one.typed().unwrap();
 //! ```
-use crate::native_type::NativeWasmTypeInto;
-use crate::Value;
-use crate::{AsStoreMut, TypedFunction};
-use crate::{FromToNativeWasmType, RuntimeError, WasmTypeList};
-// use std::panic::{catch_unwind, AssertUnwindSafe};
-use crate::js::as_js::{param_from_js, AsJs};
+use crate::{
+    js::utils::convert::{js_value_to_wasmer, AsJs},
+    AsStoreMut, FromToNativeWasmType, NativeWasmType, NativeWasmTypeInto, RuntimeError,
+    TypedFunction, Value, WasmTypeList,
+};
 use js_sys::Array;
 use std::iter::FromIterator;
 use wasm_bindgen::JsValue;
@@ -28,18 +27,18 @@ macro_rules! impl_native_traits {
         {
             /// Call the typed func and return results.
             #[allow(clippy::too_many_arguments)]
-            pub fn call(&self, mut store: &mut impl AsStoreMut, $( $x: $x, )* ) -> Result<Rets, RuntimeError> where
-            $( $x: FromToNativeWasmType + NativeWasmTypeInto, )*
+            pub fn call_js(&self, mut store: &mut impl AsStoreMut, $( $x: $x, )* ) -> Result<Rets, RuntimeError> where
+            $( $x: FromToNativeWasmType,  )*
             {
                 #[allow(unused_unsafe)]
                 let params_list: Vec<_> = unsafe {
-                    vec![ $( ($x::WASM_TYPE, $x.into_raw(store) ) ),* ]
+                    vec![ $( (<$x::Native as NativeWasmType>::WASM_TYPE, $x.to_native().into_raw(store) ) ),* ]
                 };
                 let results = {
                     let mut r;
                     // TODO: This loop is needed for asyncify. It will be refactored with https://github.com/wasmerio/wasmer/issues/3451
                     loop {
-                        r = self.func.0.handle.function.apply(
+                        r = self.func.as_js().handle.function.apply(
                             &JsValue::UNDEFINED,
                             unsafe {
                                 &Array::from_iter(params_list.clone()
@@ -66,7 +65,7 @@ macro_rules! impl_native_traits {
                     0 => {},
                     1 => unsafe {
                         let ty = Rets::wasm_types()[0];
-                        let val = param_from_js(&ty, &results);
+                        let val = js_value_to_wasmer(&ty, &results);
                         *mut_rets = val.as_raw(&mut store);
                     }
                     _n => {
@@ -74,7 +73,7 @@ macro_rules! impl_native_traits {
                         for (i, ret_type) in Rets::wasm_types().iter().enumerate() {
                             let ret = results.get(i as u32);
                             unsafe {
-                                let val = param_from_js(&ret_type, &ret);
+                                let val = js_value_to_wasmer(&ret_type, &ret);
                                 let slot = mut_rets.add(i);
                                 *slot = val.as_raw(&mut store);
                             }
@@ -83,6 +82,14 @@ macro_rules! impl_native_traits {
                 }
                 Ok(unsafe { Rets::from_array(store, rets_list_array) })
             }
+
+            #[doc(hidden)]
+            #[allow(missing_docs)]
+            #[allow(unused_mut)]
+            #[allow(clippy::too_many_arguments)]
+            pub fn call_raw_js(&self, store: &mut impl AsStoreMut, mut params_list: Vec<RawValue> ) -> Result<Rets, RuntimeError> {
+                todo!("Raw calls from js are not supported yet!")
+            }
         }
     };
 }
diff --git a/lib/api/src/js/externals/global.rs b/lib/api/src/backend/js/entities/global.rs
similarity index 69%
rename from lib/api/src/js/externals/global.rs
rename to lib/api/src/backend/js/entities/global.rs
index d9be955f60..9b5ca611e4 100644
--- a/lib/api/src/js/externals/global.rs
+++ b/lib/api/src/backend/js/entities/global.rs
@@ -1,14 +1,15 @@
-use crate::errors::RuntimeError;
-use crate::js::wasm_bindgen_polyfill::Global as JSGlobal;
-use crate::store::{AsStoreMut, AsStoreRef};
-use crate::value::Value;
-use crate::vm::{VMExtern, VMGlobal};
-use crate::GlobalType;
-use crate::Mutability;
-use wasm_bindgen::JsValue;
-use wasmer_types::{RawValue, Type};
+use wasm_bindgen::{prelude::*, JsValue};
+use wasmer_types::{GlobalType, Mutability, RawValue, Type};
 
-#[derive(Debug, Clone, PartialEq)]
+use crate::{
+    js::vm::VMGlobal,
+    vm::{VMExtern, VMExternGlobal},
+    AsStoreMut, AsStoreRef, BackendGlobal, RuntimeError, Value,
+};
+use js_sys::WebAssembly;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// A WebAssembly `global` in `js`.
 pub struct Global {
     pub(crate) handle: VMGlobal,
 }
@@ -19,7 +20,7 @@ pub struct Global {
 
 impl Global {
     pub(crate) fn to_vm_extern(&self) -> VMExtern {
-        VMExtern::Global(self.handle.clone())
+        VMExtern::Js(crate::js::vm::VMExtern::Global(self.handle.clone()))
     }
 
     /// Create a `Global` with the initial value [`Value`] and the provided [`Mutability`].
@@ -54,10 +55,10 @@ impl Global {
             &mutability.is_mutable().into(),
         )?;
 
-        let js_global = JSGlobal::new(&descriptor, &value).unwrap();
+        let js_global = WebAssembly::Global::new(&descriptor, &value).unwrap();
         let vm_global = VMGlobal::new(js_global, global_ty);
 
-        Ok(Self::from_vm_extern(store, vm_global))
+        Ok(Self::from_vm_extern(store, VMExternGlobal::Js(vm_global)))
     }
 
     pub fn ty(&self, _store: &impl AsStoreRef) -> GlobalType {
@@ -94,6 +95,12 @@ impl Global {
                     //     VMExternRef::from_raw(raw).map(|e| ExternRef::from_vm_externref(store, e)),
                     // )
                 }
+                Type::ExceptionRef => {
+                    unimplemented!();
+                    // Self::ExternRef(
+                    //     VMExternRef::from_raw(raw).map(|e| ExternRef::from_vm_externref(store, e)),
+                    // )
+                }
             };
             Value::from_raw(store, ty.ty, raw)
         }
@@ -127,13 +134,41 @@ impl Global {
         Ok(())
     }
 
-    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_global: VMGlobal) -> Self {
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_global: VMExternGlobal) -> Self {
         use crate::js::store::StoreObject;
-        VMGlobal::list_mut(store.objects_mut()).push(vm_global.clone());
-        Self { handle: vm_global }
+        VMGlobal::list_mut(store.objects_mut().as_js_mut()).push(vm_global.as_js().clone());
+        Self {
+            handle: vm_global.into_js(),
+        }
     }
 
     pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
         true
     }
 }
+
+impl crate::Global {
+    /// Consume [`self`] into [`crate::backend::js::global::Global`].
+    pub fn into_js(self) -> crate::backend::js::global::Global {
+        match self.0 {
+            BackendGlobal::Js(s) => s,
+            _ => panic!("Not a `js` global!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::js::global::Global`].
+    pub fn as_js(&self) -> &crate::backend::js::global::Global {
+        match self.0 {
+            BackendGlobal::Js(ref s) => s,
+            _ => panic!("Not a `js` global!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::js::global::Global`].
+    pub fn as_js_mut(&mut self) -> &mut crate::backend::js::global::Global {
+        match self.0 {
+            BackendGlobal::Js(ref mut s) => s,
+            _ => panic!("Not a `js` global!"),
+        }
+    }
+}
diff --git a/lib/api/src/js/instance.rs b/lib/api/src/backend/js/entities/instance.rs
similarity index 66%
rename from lib/api/src/js/instance.rs
rename to lib/api/src/backend/js/entities/instance.rs
index 49726418d4..bae0211142 100644
--- a/lib/api/src/js/instance.rs
+++ b/lib/api/src/backend/js/entities/instance.rs
@@ -1,14 +1,15 @@
-use crate::exports::Exports;
-use crate::imports::Imports;
-use crate::js::as_js::AsJs;
-use crate::js::vm::VMInstance;
-use crate::module::Module;
-use crate::store::AsStoreMut;
-use crate::Extern;
-use crate::{errors::InstantiationError, js::js_handle::JsHandle};
 use js_sys::WebAssembly;
 
+use crate::{
+    js::{
+        utils::{convert::AsJs, js_handle::JsHandle},
+        vm::VMInstance,
+    },
+    AsStoreMut, BackendInstance, Exports, Extern, Imports, InstantiationError, Module,
+};
+
 #[derive(Clone, PartialEq, Eq)]
+/// A WebAssembly `instance` in `js`.
 pub struct Instance {
     pub(crate) _handle: JsHandle<VMInstance>,
 }
@@ -24,7 +25,7 @@ impl Instance {
         imports: &Imports,
     ) -> Result<(Self, Exports), InstantiationError> {
         let instance = module
-            .0
+            .as_js()
             .instantiate(&mut store, imports)
             .map_err(|e| InstantiationError::Start(e))?;
 
@@ -74,3 +75,29 @@ impl Instance {
         Ok((instance, exports))
     }
 }
+
+impl crate::Instance {
+    /// Consume [`self`] into [`crate::backend::js::instance::Instance`].
+    pub fn into_js(self) -> crate::backend::js::instance::Instance {
+        match self._inner {
+            BackendInstance::Js(s) => s,
+            _ => panic!("Not a `js` global!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference to [`crate::backend::js::instance::Instance`].
+    pub fn as_js(&self) -> &crate::backend::js::instance::Instance {
+        match self._inner {
+            BackendInstance::Js(ref s) => s,
+            _ => panic!("Not a `js` global!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference to [`crate::backend::js::instance::Instance`].
+    pub fn as_js_mut(&mut self) -> &mut crate::backend::js::instance::Instance {
+        match self._inner {
+            BackendInstance::Js(ref mut s) => s,
+            _ => panic!("Not a `js` global!"),
+        }
+    }
+}
diff --git a/lib/api/src/backend/js/entities/memory/buffer.rs b/lib/api/src/backend/js/entities/memory/buffer.rs
new file mode 100644
index 0000000000..c93da285fb
--- /dev/null
+++ b/lib/api/src/backend/js/entities/memory/buffer.rs
@@ -0,0 +1,82 @@
+use super::Memory;
+use crate::{js::store::StoreObjects, MemoryAccessError};
+use std::{marker::PhantomData, mem::MaybeUninit, slice};
+use tracing::warn;
+
+/// Underlying buffer for a memory.
+#[derive(Copy, Clone, Debug)]
+pub(crate) struct MemoryBuffer<'a> {
+    pub(crate) base: *mut js_sys::Uint8Array,
+    pub(crate) marker: PhantomData<(&'a Memory, &'a StoreObjects)>,
+}
+
+impl<'a> MemoryBuffer<'a> {
+    pub(crate) fn read(&self, offset: u64, buf: &mut [u8]) -> Result<(), MemoryAccessError> {
+        let end = offset
+            .checked_add(buf.len() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        let view = unsafe { &*(self.base) };
+        if end > view.length().into() {
+            warn!(
+                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
+                buf.len(),
+                end,
+                view.length()
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        view.subarray(offset as _, end as _)
+            .copy_to(unsafe { &mut slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len()) });
+        Ok(())
+    }
+
+    #[inline]
+    pub(crate) fn len(&self) -> usize {
+        let view = unsafe { &*(self.base) };
+        view.length() as usize
+    }
+
+    pub(crate) fn read_uninit<'b>(
+        &self,
+        offset: u64,
+        buf: &'b mut [MaybeUninit<u8>],
+    ) -> Result<&'b mut [u8], MemoryAccessError> {
+        let end = offset
+            .checked_add(buf.len() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        let view = unsafe { &*(self.base) };
+        if end > view.length().into() {
+            warn!(
+                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
+                buf.len(),
+                end,
+                view.length()
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        let buf_ptr = buf.as_mut_ptr() as *mut u8;
+        view.subarray(offset as _, end as _)
+            .copy_to(unsafe { &mut slice::from_raw_parts_mut(buf_ptr, buf.len()) });
+
+        Ok(unsafe { slice::from_raw_parts_mut(buf_ptr, buf.len()) })
+    }
+
+    pub(crate) fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
+        let end = offset
+            .checked_add(data.len() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        let view = unsafe { &mut *(self.base) };
+        if end > view.length().into() {
+            warn!(
+                "attempted to write ({} bytes) beyond the bounds of the memory view ({} > {})",
+                data.len(),
+                end,
+                view.length()
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        view.subarray(offset as _, end as _).copy_from(data);
+
+        Ok(())
+    }
+}
diff --git a/lib/api/src/backend/js/entities/memory/js.rs b/lib/api/src/backend/js/entities/memory/js.rs
new file mode 100644
index 0000000000..9b9656795d
--- /dev/null
+++ b/lib/api/src/backend/js/entities/memory/js.rs
@@ -0,0 +1,40 @@
+use js_sys::wasm_bindgen;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory)
+    #[wasm_bindgen(js_namespace = WebAssembly, extends = js_sys::Object, typescript_type = "WebAssembly.Memory")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type JSMemory;
+
+    /// The `buffer` property of the `Memory` object, which is an `ArrayBuffer` or `SharedArrayBuffer`.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/WebAssembly/Reference/JavaScript_interface/Memory/buffer)
+    #[wasm_bindgen(method, getter, js_name = buffer, js_namespace = WebAssembly)]
+    pub fn buffer(this: &JSMemory) -> JsValue;
+
+    /// The `grow()` protoype method of the `Memory` object increases the
+    /// size of the memory instance by a specified number of WebAssembly
+    /// pages.
+    ///
+    /// Takes the number of pages to grow (64KiB in size) and returns the
+    /// previous size of memory, in pages.
+    ///
+    /// # Reimplementation
+    ///
+    /// We re-implement `WebAssembly.Memory.grow` because it is
+    /// different from what `wasm-bindgen` declares. It marks the function
+    /// as `catch`, which means it can throw an exception.
+    ///
+    /// See [the opened patch](https://github.com/rustwasm/wasm-bindgen/pull/2599).
+    ///
+    /// # Exceptions
+    ///
+    /// A `RangeError` is thrown if adding pages would exceed the maximum
+    /// memory.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/grow)
+    #[wasm_bindgen(catch, method, js_namespace = WebAssembly)]
+    pub fn grow(this: &JSMemory, pages: u32) -> Result<u32, JsValue>;
+}
diff --git a/lib/api/src/js/externals/memory.rs b/lib/api/src/backend/js/entities/memory/mod.rs
similarity index 52%
rename from lib/api/src/js/externals/memory.rs
rename to lib/api/src/backend/js/entities/memory/mod.rs
index ebd8b3e375..76ff50e5d8 100644
--- a/lib/api/src/js/externals/memory.rs
+++ b/lib/api/src/backend/js/entities/memory/mod.rs
@@ -1,54 +1,22 @@
-use crate::js::vm::{VMExtern, VMMemory};
-use crate::mem_access::MemoryAccessError;
-use crate::store::{AsStoreMut, AsStoreRef, StoreObjects};
-use crate::MemoryType;
-use std::marker::PhantomData;
-use std::mem::MaybeUninit;
-use std::slice;
+pub(crate) mod js;
+pub(crate) use js::*;
 
-use tracing::warn;
+pub(crate) mod view;
+pub(crate) use view::*;
+
+pub(crate) mod buffer;
+pub(crate) use buffer::*;
 
-use wasm_bindgen::prelude::*;
 use wasm_bindgen::JsCast;
-use wasmer_types::Pages;
-
-use super::memory_view::MemoryView;
-
-pub use wasmer_types::MemoryError;
-
-#[wasm_bindgen]
-extern "C" {
-    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory)
-    #[wasm_bindgen(js_namespace = WebAssembly, extends = js_sys::Object, typescript_type = "WebAssembly.Memory")]
-    #[derive(Clone, Debug, PartialEq, Eq)]
-    pub type JSMemory;
-
-    /// The `grow()` protoype method of the `Memory` object increases the
-    /// size of the memory instance by a specified number of WebAssembly
-    /// pages.
-    ///
-    /// Takes the number of pages to grow (64KiB in size) and returns the
-    /// previous size of memory, in pages.
-    ///
-    /// # Reimplementation
-    ///
-    /// We re-implement `WebAssembly.Memory.grow` because it is
-    /// different from what `wasm-bindgen` declares. It marks the function
-    /// as `catch`, which means it can throw an exception.
-    ///
-    /// See [the opened patch](https://github.com/rustwasm/wasm-bindgen/pull/2599).
-    ///
-    /// # Exceptions
-    ///
-    /// A `RangeError` is thrown if adding pages would exceed the maximum
-    /// memory.
-    ///
-    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/grow)
-    #[wasm_bindgen(catch, method, js_namespace = WebAssembly)]
-    pub fn grow(this: &JSMemory, pages: u32) -> Result<u32, JsValue>;
-}
+use wasmer_types::{MemoryError, MemoryType, Pages, WASM_PAGE_SIZE};
+
+use crate::{
+    js::vm::memory::VMMemory,
+    vm::{VMExtern, VMExternMemory},
+    AsStoreMut, AsStoreRef, BackendMemory,
+};
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Eq)]
 pub struct Memory {
     pub(crate) handle: VMMemory,
 }
@@ -71,7 +39,7 @@ unsafe impl Sync for Memory {}
 impl Memory {
     pub fn new(store: &mut impl AsStoreMut, ty: MemoryType) -> Result<Self, MemoryError> {
         let vm_memory = VMMemory::new(Self::js_memory_from_type(&ty)?, ty);
-        Ok(Self::from_vm_extern(store, vm_memory))
+        Ok(Self::from_vm_extern(store, VMExternMemory::Js(vm_memory)))
     }
 
     pub(crate) fn js_memory_from_type(
@@ -103,11 +71,11 @@ impl Memory {
     }
 
     pub fn new_from_existing(new_store: &mut impl AsStoreMut, memory: VMMemory) -> Self {
-        Self::from_vm_extern(new_store, memory)
+        Self::from_vm_extern(new_store, VMExternMemory::Js(memory))
     }
 
     pub(crate) fn to_vm_extern(&self) -> VMExtern {
-        VMExtern::Memory(self.handle.clone())
+        VMExtern::Js(crate::js::vm::VMExtern::Memory(self.handle.clone()))
     }
 
     pub fn ty(&self, _store: &impl AsStoreRef) -> MemoryType {
@@ -120,6 +88,24 @@ impl Memory {
         MemoryView::new(self, store)
     }
 
+    pub fn size(&self, store: &impl AsStoreRef) -> Pages {
+        let js_memory = &self.handle.memory;
+        let our_js_memory: &JSMemory = JsCast::unchecked_from_js_ref(js_memory);
+        let buffer = our_js_memory.buffer();
+
+        let byte_length = match buffer.dyn_into::<js_sys::ArrayBuffer>() {
+            Ok(array_buffer) => array_buffer.byte_length(),
+            Err(buffer) => match buffer.dyn_into::<js_sys::SharedArrayBuffer>() {
+                Ok(array_buffer) => array_buffer.byte_length(),
+                Err(_) => {
+                    unreachable!("Memory.buffer should be an array buffer or a shared array buffer")
+                }
+            },
+        };
+
+        Pages(byte_length.div_ceil(WASM_PAGE_SIZE as u32))
+    }
+
     pub fn grow<IntoPages>(
         &self,
         store: &mut impl AsStoreMut,
@@ -163,8 +149,10 @@ impl Memory {
         Ok(())
     }
 
-    pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, internal: VMMemory) -> Self {
-        Self { handle: internal }
+    pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, internal: VMExternMemory) -> Self {
+        Self {
+            handle: internal.into_js(),
+        }
     }
 
     /// Cloning memory will create another reference to the same memory that
@@ -184,7 +172,7 @@ impl Memory {
         true
     }
 
-    pub fn as_shared(&self, _store: &impl AsStoreRef) -> Option<crate::SharedMemory> {
+    pub fn as_shared(&self, _store: &impl AsStoreRef) -> Option<crate::shared::SharedMemory> {
         // Not supported.
         None
     }
@@ -198,84 +186,38 @@ impl std::cmp::PartialEq for Memory {
 
 impl From<Memory> for crate::Memory {
     fn from(value: Memory) -> Self {
-        crate::Memory(value)
+        crate::Memory(crate::BackendMemory::Js(value))
     }
 }
 
 impl From<crate::Memory> for Memory {
     fn from(value: crate::Memory) -> Self {
-        value.0
+        value.into_js()
     }
 }
 
-/// Underlying buffer for a memory.
-#[derive(Copy, Clone, Debug)]
-pub(crate) struct MemoryBuffer<'a> {
-    pub(crate) base: *mut js_sys::Uint8Array,
-    pub(crate) marker: PhantomData<(&'a Memory, &'a StoreObjects)>,
-}
-
-impl<'a> MemoryBuffer<'a> {
-    pub(crate) fn read(&self, offset: u64, buf: &mut [u8]) -> Result<(), MemoryAccessError> {
-        let end = offset
-            .checked_add(buf.len() as u64)
-            .ok_or(MemoryAccessError::Overflow)?;
-        let view = unsafe { &*(self.base) };
-        if end > view.length().into() {
-            warn!(
-                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
-                buf.len(),
-                end,
-                view.length()
-            );
-            return Err(MemoryAccessError::HeapOutOfBounds);
+impl crate::Memory {
+    /// Consume [`self`] into a [`crate::backend::js::mem::Memory`].
+    pub fn into_js(self) -> crate::backend::js::memory::Memory {
+        match self.0 {
+            BackendMemory::Js(s) => s,
+            _ => panic!("Not a `js` memory!"),
         }
-        view.subarray(offset as _, end as _)
-            .copy_to(unsafe { &mut slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len()) });
-        Ok(())
     }
 
-    pub(crate) fn read_uninit<'b>(
-        &self,
-        offset: u64,
-        buf: &'b mut [MaybeUninit<u8>],
-    ) -> Result<&'b mut [u8], MemoryAccessError> {
-        let end = offset
-            .checked_add(buf.len() as u64)
-            .ok_or(MemoryAccessError::Overflow)?;
-        let view = unsafe { &*(self.base) };
-        if end > view.length().into() {
-            warn!(
-                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
-                buf.len(),
-                end,
-                view.length()
-            );
-            return Err(MemoryAccessError::HeapOutOfBounds);
+    /// Convert a reference to [`self`] into a reference to [`crate::backend::js::mem::Memory`].
+    pub fn as_js(&self) -> &crate::backend::js::memory::Memory {
+        match self.0 {
+            BackendMemory::Js(ref s) => s,
+            _ => panic!("Not a `js` memory!"),
         }
-        let buf_ptr = buf.as_mut_ptr() as *mut u8;
-        view.subarray(offset as _, end as _)
-            .copy_to(unsafe { &mut slice::from_raw_parts_mut(buf_ptr, buf.len()) });
-
-        Ok(unsafe { slice::from_raw_parts_mut(buf_ptr, buf.len()) })
     }
 
-    pub(crate) fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
-        let end = offset
-            .checked_add(data.len() as u64)
-            .ok_or(MemoryAccessError::Overflow)?;
-        let view = unsafe { &mut *(self.base) };
-        if end > view.length().into() {
-            warn!(
-                "attempted to write ({} bytes) beyond the bounds of the memory view ({} > {})",
-                data.len(),
-                end,
-                view.length()
-            );
-            return Err(MemoryAccessError::HeapOutOfBounds);
+    /// Convert a mutable reference to [`self`] into a mutable reference to [`crate::backend::js::mem::Memory`].
+    pub fn as_js_mut(&mut self) -> &mut crate::backend::js::memory::Memory {
+        match self.0 {
+            BackendMemory::Js(ref mut s) => s,
+            _ => panic!("Not a `js` memory!"),
         }
-        view.subarray(offset as _, end as _).copy_from(data);
-
-        Ok(())
     }
 }
diff --git a/lib/api/src/js/externals/memory_view.rs b/lib/api/src/backend/js/entities/memory/view.rs
similarity index 97%
rename from lib/api/src/js/externals/memory_view.rs
rename to lib/api/src/backend/js/entities/memory/view.rs
index f4830add65..e4c451624d 100644
--- a/lib/api/src/js/externals/memory_view.rs
+++ b/lib/api/src/backend/js/entities/memory/view.rs
@@ -1,12 +1,11 @@
-use std::{convert::TryInto, marker::PhantomData, mem::MaybeUninit, ops::Range, slice};
+use std::{marker::PhantomData, mem::MaybeUninit, ops::Range, slice};
+
 use wasm_bindgen::JsCast;
 use wasmer_types::{Bytes, Pages};
 
-use crate::{
-    js::externals::memory::{Memory, MemoryBuffer},
-    mem_access::MemoryAccessError,
-    store::AsStoreRef,
-};
+use crate::{AsStoreRef, MemoryAccessError};
+
+use super::{Memory, MemoryBuffer};
 
 /// A WebAssembly `memory` view.
 ///
diff --git a/lib/api/src/backend/js/entities/mod.rs b/lib/api/src/backend/js/entities/mod.rs
new file mode 100644
index 0000000000..ce7a5e6d7c
--- /dev/null
+++ b/lib/api/src/backend/js/entities/mod.rs
@@ -0,0 +1,11 @@
+pub(crate) mod engine;
+pub(crate) mod exception;
+pub(crate) mod external;
+pub(crate) mod function;
+pub(crate) mod global;
+pub(crate) mod instance;
+pub(crate) mod memory;
+pub(crate) mod module;
+pub(crate) mod store;
+pub(crate) mod table;
+pub(crate) mod tag;
diff --git a/lib/api/src/js/module.rs b/lib/api/src/backend/js/entities/module.rs
similarity index 84%
rename from lib/api/src/js/module.rs
rename to lib/api/src/backend/js/entities/module.rs
index 61866abcf5..b734661f96 100644
--- a/lib/api/src/js/module.rs
+++ b/lib/api/src/backend/js/entities/module.rs
@@ -1,20 +1,22 @@
-use crate::errors::RuntimeError;
-use crate::imports::Imports;
-use crate::js::AsJs;
-use crate::store::AsStoreMut;
-use crate::vm::VMInstance;
-use crate::Extern;
-use crate::IntoBytes;
-use crate::{errors::InstantiationError, js::js_handle::JsHandle};
-use crate::{AsEngineRef, ExportType, ImportType};
+use std::path::Path;
+
 use bytes::Bytes;
 use js_sys::{Reflect, Uint8Array, WebAssembly};
-use std::path::Path;
 use tracing::{debug, warn};
-use wasm_bindgen::JsValue;
+use wasm_bindgen::{prelude::*, JsValue};
 use wasmer_types::{
-    CompileError, DeserializeError, ExportsIterator, ExternType, FunctionType, GlobalType,
-    ImportsIterator, MemoryType, ModuleInfo, Mutability, Pages, SerializeError, TableType, Type,
+    CompileError, DeserializeError, ExportType, ExportsIterator, ExternType, FunctionType,
+    GlobalType, ImportType, ImportsIterator, MemoryType, ModuleInfo, Mutability, Pages,
+    SerializeError, TableType, Type,
+};
+
+use crate::{
+    js::{
+        utils::{convert::AsJs as _, js_handle::JsHandle},
+        vm::VMInstance,
+    },
+    AsEngineRef, AsStoreMut, BackendModule, Extern, Imports, InstantiationError, IntoBytes,
+    RuntimeError,
 };
 
 /// WebAssembly in the browser doesn't yet output the descriptor/types
@@ -44,14 +46,10 @@ pub struct Module {
     raw_bytes: Option<Bytes>,
 }
 
-// Module implements `structuredClone` in js, so it's safe it to make it Send.
-// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
-// ```js
-// const module = new WebAssembly.Module(new Uint8Array([
-//   0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00
-// ]));
-// structuredClone(module)
-// ```
+// XXX
+// Do not rely on `Module` being `Send`: it will panic at runtime
+// if accessed from multiple threads thanks to [`JsHandle`].
+// See https://github.com/wasmerio/wasmer/issues/4158 for details.
 unsafe impl Send for Module {}
 unsafe impl Sync for Module {}
 
@@ -74,8 +72,13 @@ impl Module {
         binary: &[u8],
     ) -> Result<Self, CompileError> {
         let js_bytes = Uint8Array::view(binary);
-        let module = WebAssembly::Module::new(&js_bytes.into())
-            .map_err(|e| CompileError::Validate(format!("{}", e.as_string().unwrap())))?;
+        let module = WebAssembly::Module::new(&js_bytes.into()).map_err(|e| {
+            CompileError::Validate(format!(
+                "{}",
+                e.as_string()
+                    .unwrap_or("Unknown validation error".to_string())
+            ))
+        })?;
         Ok(Self::from_js_module(module, binary))
     }
 
@@ -89,7 +92,7 @@ impl Module {
         // The module is now validated, so we can safely parse it's types
         #[cfg(feature = "wasm-types-polyfill")]
         let (type_hints, name) = {
-            let info = crate::module_info_polyfill::translate_module(&binary[..]).unwrap();
+            let info = crate::polyfill::translate_module(&binary[..]).unwrap();
 
             (
                 Some(ModuleTypeHints {
@@ -281,7 +284,7 @@ impl Module {
         //     .unwrap_or(false)
     }
 
-    pub fn imports<'a>(&'a self) -> ImportsIterator<impl Iterator<Item = ImportType> + 'a> {
+    pub fn imports<'a>(&'a self) -> ImportsIterator<Box<dyn Iterator<Item = ImportType> + 'a>> {
         let imports = WebAssembly::Module::imports(&self.module);
         let iter = imports
             .iter()
@@ -336,7 +339,7 @@ impl Module {
             })
             .collect::<Vec<_>>()
             .into_iter();
-        ImportsIterator::new(iter, imports.length() as usize)
+        ImportsIterator::new(Box::new(iter), imports.length() as usize)
     }
 
     /// Set the type hints for this module.
@@ -366,6 +369,7 @@ impl Module {
                 ExternType::Global(_) => "global",
                 ExternType::Memory(_) => "memory",
                 ExternType::Table(_) => "table",
+                ExternType::Tag(_) => "tag",
             };
             if expected_kind != kind.as_str() {
                 return Err(format!("The provided type hint for the export {} is {} which doesn't match the expected kind: {}", i, kind.as_str(), expected_kind));
@@ -375,7 +379,7 @@ impl Module {
         Ok(())
     }
 
-    pub fn exports<'a>(&'a self) -> ExportsIterator<impl Iterator<Item = ExportType> + 'a> {
+    pub fn exports<'a>(&'a self) -> ExportsIterator<Box<dyn Iterator<Item = ExportType> + 'a>> {
         let exports = WebAssembly::Module::exports(&self.module);
         let iter = exports
             .iter()
@@ -429,18 +433,23 @@ impl Module {
             })
             .collect::<Vec<_>>()
             .into_iter();
-        ExportsIterator::new(iter, exports.length() as usize)
+        ExportsIterator::new(Box::new(iter), exports.length() as usize)
     }
 
-    pub fn custom_sections<'a>(&'a self, name: &'a str) -> impl Iterator<Item = Box<[u8]>> + 'a {
-        WebAssembly::Module::custom_sections(&self.module, name)
-            .iter()
-            .map(move |buf_val| {
-                let typebuf: js_sys::Uint8Array = js_sys::Uint8Array::new(&buf_val);
-                typebuf.to_vec().into_boxed_slice()
-            })
-            .collect::<Vec<Box<[u8]>>>()
-            .into_iter()
+    pub fn custom_sections<'a>(
+        &'a self,
+        name: &'a str,
+    ) -> Box<dyn Iterator<Item = Box<[u8]>> + 'a> {
+        Box::new(
+            WebAssembly::Module::custom_sections(&self.module, name)
+                .iter()
+                .map(move |buf_val| {
+                    let typebuf: js_sys::Uint8Array = js_sys::Uint8Array::new(&buf_val);
+                    typebuf.to_vec().into_boxed_slice()
+                })
+                .collect::<Vec<Box<[u8]>>>()
+                .into_iter(),
+        )
     }
 
     pub(crate) fn info(&self) -> &ModuleInfo {
@@ -463,17 +472,48 @@ impl From<WebAssembly::Module> for Module {
 
 impl<T: IntoBytes> From<(WebAssembly::Module, T)> for crate::module::Module {
     fn from((module, binary): (WebAssembly::Module, T)) -> crate::module::Module {
-        unsafe { crate::module::Module(Module::from_js_module(module, binary.into_bytes())) }
+        unsafe {
+            crate::module::Module(BackendModule::Js(Module::from_js_module(
+                module,
+                binary.into_bytes(),
+            )))
+        }
     }
 }
 
 impl From<WebAssembly::Module> for crate::module::Module {
     fn from(module: WebAssembly::Module) -> crate::module::Module {
-        crate::module::Module(module.into())
+        crate::module::Module(BackendModule::Js(module.into()))
     }
 }
 impl From<crate::module::Module> for WebAssembly::Module {
     fn from(value: crate::module::Module) -> Self {
-        value.0.module.into_inner()
+        value.into_js().module.into_inner()
+    }
+}
+
+impl crate::Module {
+    /// Consume [`self`] into a reference [`crate::backend::js::module::Module`].
+    pub fn into_js(self) -> crate::backend::js::module::Module {
+        match self.0 {
+            BackendModule::Js(s) => s,
+            _ => panic!("Not a `js` module!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::js::module::Module`].
+    pub fn as_js(&self) -> &crate::backend::js::module::Module {
+        match self.0 {
+            BackendModule::Js(ref s) => s,
+            _ => panic!("Not a `js` module!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::js::module::Module`].
+    pub fn as_js_mut(&mut self) -> &mut crate::backend::js::module::Module {
+        match self.0 {
+            BackendModule::Js(ref mut s) => s,
+            _ => panic!("Not a `js` module!"),
+        }
     }
 }
diff --git a/lib/api/src/backend/js/entities/store/handle.rs b/lib/api/src/backend/js/entities/store/handle.rs
new file mode 100644
index 0000000000..686da2ce41
--- /dev/null
+++ b/lib/api/src/backend/js/entities/store/handle.rs
@@ -0,0 +1,158 @@
+use std::{marker::PhantomData, num::NonZeroUsize};
+
+use wasmer_types::StoreId;
+
+use super::{obj::StoreObject, StoreObjects};
+
+/// Handle to an object managed by a context.
+///
+/// Internally this is just an integer index into a context. A reference to the
+/// context must be passed in separately to access the actual object.
+pub struct StoreHandle<T> {
+    id: StoreId,
+    internal: InternalStoreHandle<T>,
+}
+
+impl<T> core::cmp::PartialEq for StoreHandle<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+
+impl<T> std::hash::Hash for StoreHandle<T> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.id.hash(state);
+        self.internal.idx.hash(state);
+    }
+}
+
+impl<T> Clone for StoreHandle<T> {
+    fn clone(&self) -> Self {
+        Self {
+            id: self.id,
+            internal: self.internal,
+        }
+    }
+}
+
+impl<T: StoreObject> std::fmt::Debug for StoreHandle<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("StoreHandle")
+            .field("id", &self.id)
+            .field("internal", &self.internal.index())
+            .finish()
+    }
+}
+
+impl<T: StoreObject> StoreHandle<T> {
+    /// Moves the given object into a context and returns a handle to it.
+    pub fn new(store: &mut StoreObjects, val: T) -> Self {
+        Self {
+            id: store.id(),
+            internal: InternalStoreHandle::new(store, val),
+        }
+    }
+
+    /// Returns a reference to the object that this handle points to.
+    pub fn get<'a>(&self, store: &'a StoreObjects) -> &'a T {
+        assert_eq!(self.id, store.id(), "object used with the wrong context");
+        self.internal.get(store)
+    }
+
+    /// Returns a mutable reference to the object that this handle points to.
+    pub fn get_mut<'a>(&self, store: &'a mut StoreObjects) -> &'a mut T {
+        assert_eq!(self.id, store.id(), "object used with the wrong context");
+        self.internal.get_mut(store)
+    }
+
+    /// Returns the internal handle contains within this handle.
+    pub fn internal_handle(&self) -> InternalStoreHandle<T> {
+        self.internal
+    }
+
+    /// Returns the ID of the context associated with the handle.
+    #[allow(unused)]
+    pub fn store_id(&self) -> StoreId {
+        self.id
+    }
+
+    /// Overrides the store id with a new ID
+    #[allow(unused)]
+    pub fn set_store_id(&mut self, id: StoreId) {
+        self.id = id;
+    }
+
+    /// Constructs a `StoreHandle` from a `StoreId` and an `InternalStoreHandle`.
+    ///
+    /// # Safety
+    /// Handling `InternalStoreHandle` values is unsafe because they do not track context ID.
+    pub unsafe fn from_internal(id: StoreId, internal: InternalStoreHandle<T>) -> Self {
+        Self { id, internal }
+    }
+}
+
+/// Internal handle to an object owned by the current context.
+///
+/// Unlike `StoreHandle` this does not track the context ID: it is only
+/// intended to be used within objects already owned by a context.
+#[repr(transparent)]
+pub struct InternalStoreHandle<T> {
+    // Use a NonZero here to reduce the size of Option<InternalStoreHandle>.
+    idx: NonZeroUsize,
+    marker: PhantomData<fn() -> T>,
+}
+
+impl<T> Clone for InternalStoreHandle<T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl<T> Copy for InternalStoreHandle<T> {}
+
+impl<T> std::fmt::Debug for InternalStoreHandle<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("InternalStoreHandle")
+            .field("idx", &self.idx)
+            .finish()
+    }
+}
+impl<T> PartialEq for InternalStoreHandle<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.idx == other.idx
+    }
+}
+impl<T> Eq for InternalStoreHandle<T> {}
+
+impl<T: StoreObject> InternalStoreHandle<T> {
+    /// Moves the given object into a context and returns a handle to it.
+    pub fn new(store: &mut StoreObjects, val: T) -> Self {
+        let list = T::list_mut(store);
+        let idx = NonZeroUsize::new(list.len() + 1).unwrap();
+        list.push(val);
+        Self {
+            idx,
+            marker: PhantomData,
+        }
+    }
+
+    /// Returns a reference to the object that this handle points to.
+    pub fn get<'a>(&self, store: &'a StoreObjects) -> &'a T {
+        &T::list(store)[self.idx.get() - 1]
+    }
+
+    /// Returns a mutable reference to the object that this handle points to.
+    pub fn get_mut<'a>(&self, store: &'a mut StoreObjects) -> &'a mut T {
+        &mut T::list_mut(store)[self.idx.get() - 1]
+    }
+
+    pub(crate) fn index(&self) -> usize {
+        self.idx.get()
+    }
+
+    pub(crate) fn from_index(idx: usize) -> Option<Self> {
+        NonZeroUsize::new(idx).map(|idx| Self {
+            idx,
+            marker: PhantomData,
+        })
+    }
+}
diff --git a/lib/api/src/backend/js/entities/store/mod.rs b/lib/api/src/backend/js/entities/store/mod.rs
new file mode 100644
index 0000000000..c29333ac41
--- /dev/null
+++ b/lib/api/src/backend/js/entities/store/mod.rs
@@ -0,0 +1,84 @@
+use crate::{AsEngineRef, Engine, EngineRef};
+
+pub(crate) mod handle;
+pub(crate) mod obj;
+
+pub(crate) use handle::*;
+pub(crate) use obj::*;
+
+#[derive(Debug)]
+pub(crate) struct Store {
+    pub(crate) engine: Engine,
+}
+
+impl Store {
+    pub(crate) fn new(engine: Engine) -> Self {
+        Self { engine }
+    }
+
+    pub(crate) fn engine(&self) -> &Engine {
+        &self.engine
+    }
+
+    pub(crate) fn engine_mut(&mut self) -> &mut Engine {
+        &mut self.engine
+    }
+}
+
+impl AsEngineRef for Store {
+    fn as_engine_ref(&self) -> EngineRef<'_> {
+        EngineRef::new(&self.engine)
+    }
+}
+
+impl crate::BackendStore {
+    /// Consume [`self`] into [`crate::backend::js::store::Store`].
+    pub fn into_js(self) -> crate::backend::js::store::Store {
+        match self {
+            Self::Js(s) => s,
+            _ => panic!("Not a `js` store!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::js::store::Store`].
+    pub fn as_js(&self) -> &crate::backend::js::store::Store {
+        match self {
+            Self::Js(s) => s,
+            _ => panic!("Not a `js` store!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::js::store::Store`].
+    pub fn as_js_mut(&mut self) -> &mut crate::backend::js::store::Store {
+        match self {
+            Self::Js(s) => s,
+            _ => panic!("Not a `js` store!"),
+        }
+    }
+    /// Return true if [`self`] is a store from the `js` runtime.
+    pub fn is_js(&self) -> bool {
+        matches!(self, Self::Js(_))
+    }
+}
+
+impl crate::Store {
+    /// Consume [`self`] into [`crate::backend::js::store::Store`].
+    pub(crate) fn into_js(self) -> crate::backend::js::store::Store {
+        self.inner.store.into_js()
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::js::store::Store`].
+    pub(crate) fn as_js(&self) -> &crate::backend::js::store::Store {
+        self.inner.store.as_js()
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::js::store::Store`].
+    pub(crate) fn as_js_mut(&mut self) -> &mut crate::backend::js::store::Store {
+        self.inner.store.as_js_mut()
+    }
+
+    /// Return true if [`self`] is a store from the `js` runtime.
+    pub fn is_js(&self) -> bool {
+        self.inner.store.is_js()
+    }
+}
diff --git a/lib/api/src/backend/js/entities/store/obj.rs b/lib/api/src/backend/js/entities/store/obj.rs
new file mode 100644
index 0000000000..4f4a75f5d0
--- /dev/null
+++ b/lib/api/src/backend/js/entities/store/obj.rs
@@ -0,0 +1,135 @@
+use std::{marker::PhantomData, num::NonZeroUsize};
+
+use wasm_bindgen::JsValue;
+use wasmer_types::StoreId;
+
+use crate::js::vm::{function::VMFunctionEnvironment, global::VMGlobal};
+
+use super::handle::InternalStoreHandle;
+
+/// Trait to represent an object managed by a context. This is implemented on
+/// the VM types managed by the context.
+pub trait StoreObject: Sized {
+    fn list(store: &StoreObjects) -> &Vec<Self>;
+    fn list_mut(store: &mut StoreObjects) -> &mut Vec<Self>;
+}
+
+macro_rules! impl_store_object {
+    ($($field:ident => $ty:ty,)*) => {
+        $(
+            impl StoreObject for $ty {
+                fn list(store: &StoreObjects) -> &Vec<Self> {
+                    &store.$field
+                }
+                fn list_mut(store: &mut StoreObjects) -> &mut Vec<Self> {
+                    &mut store.$field
+                }
+            }
+        )*
+    };
+}
+
+impl_store_object! {
+    // Note: we store the globals in order to be able to access them later via
+    // `StoreObjects::iter_globals`.
+    globals => VMGlobal,
+    // functions => VMFunction,
+    // tables => VMTable,
+    // memories => VMMemory,
+    // The function environments are the only things attached to a store,
+    // since the other JS objects (table, globals, memory and functions)
+    // live in the JS VM Store by default
+    function_environments => VMFunctionEnvironment,
+}
+
+/// Set of objects managed by a context.
+#[derive(Default, Debug)]
+pub struct StoreObjects {
+    id: StoreId,
+    globals: Vec<VMGlobal>,
+    function_environments: Vec<VMFunctionEnvironment>,
+}
+
+impl StoreObjects {
+    /// Returns the ID of this context.
+    pub fn id(&self) -> StoreId {
+        self.id
+    }
+
+    /// Sets the ID of this store
+    pub fn set_id(&mut self, id: StoreId) {
+        self.id = id;
+    }
+
+    /// Returns a pair of mutable references from two handles.
+    ///
+    /// Panics if both handles point to the same object.
+    pub fn get_2_mut<T: StoreObject>(
+        &mut self,
+        a: InternalStoreHandle<T>,
+        b: InternalStoreHandle<T>,
+    ) -> (&mut T, &mut T) {
+        assert_ne!(a.index(), b.index());
+        let list = T::list_mut(self);
+        if a.index() < b.index() {
+            let (low, high) = list.split_at_mut(b.index());
+            (&mut low[a.index()], &mut high[0])
+        } else {
+            let (low, high) = list.split_at_mut(a.index());
+            (&mut high[0], &mut low[a.index()])
+        }
+    }
+
+    /// Return an immutable iterator over all globals
+    pub fn iter_globals(&self) -> core::slice::Iter<VMGlobal> {
+        self.globals.iter()
+    }
+
+    /// Return an vector of all globals and converted to u128
+    pub fn as_u128_globals(&self) -> Vec<u128> {
+        self.iter_globals()
+            .map(|v| v.global.value().as_f64().unwrap() as u128)
+            .collect()
+    }
+
+    /// Set a global, at index idx. Will panic if idx is out of range
+    /// Safety: the caller should check that the raw value is compatible
+    /// with destination VMGlobal type
+    pub fn set_global_unchecked(&self, idx: usize, new_val: u128) {
+        assert!(idx < self.globals.len());
+
+        let g = &self.globals[idx].global;
+        let cur_val = g.value().as_f64().unwrap();
+        let new_val = new_val as f64;
+        if cur_val != new_val {
+            let new_value = JsValue::from(new_val);
+            g.set_value(&new_value);
+        }
+    }
+}
+
+impl crate::StoreObjects {
+    /// Consume [`self`] into [`crate::backend::js::store::StoreObjects`].
+    pub fn into_js(self) -> crate::backend::js::store::StoreObjects {
+        match self {
+            Self::Js(s) => s,
+            _ => panic!("Not a `js` store!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::js::store::StoreObjects`].
+    pub fn as_js(&self) -> &crate::backend::js::store::StoreObjects {
+        match self {
+            Self::Js(s) => s,
+            _ => panic!("Not a `js` store!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::js::store::StoreObjects`].
+    pub fn as_js_mut(&mut self) -> &mut crate::backend::js::store::StoreObjects {
+        match self {
+            Self::Js(s) => s,
+            _ => panic!("Not a `js` store!"),
+        }
+    }
+}
diff --git a/lib/api/src/backend/js/entities/table.rs b/lib/api/src/backend/js/entities/table.rs
new file mode 100644
index 0000000000..436f407991
--- /dev/null
+++ b/lib/api/src/backend/js/entities/table.rs
@@ -0,0 +1,193 @@
+use crate::{
+    js::vm::{VMFunction, VMTable},
+    vm::{VMExtern, VMExternTable},
+    AsStoreMut, AsStoreRef, BackendTable, RuntimeError, Value,
+};
+use js_sys::Function;
+use wasmer_types::{FunctionType, TableType};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Table {
+    pub(crate) handle: VMTable,
+}
+
+// Table can't be Send in js because it dosen't support `structuredClone`
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// unsafe impl Send for Table {}
+
+fn set_table_item(table: &VMTable, item_index: u32, item: &Function) -> Result<(), RuntimeError> {
+    table.table.set(item_index, item).map_err(|e| e.into())
+}
+
+fn get_function(store: &mut impl AsStoreMut, val: Value) -> Result<Option<Function>, RuntimeError> {
+    if !val.is_from_store(store) {
+        return Err(RuntimeError::new("cannot pass Value across contexts"));
+    }
+    match val {
+        Value::FuncRef(Some(ref func)) => {
+            Ok(Some(func.as_js().handle.function.clone().into_inner()))
+        }
+        Value::FuncRef(None) => Ok(None),
+        // Only funcrefs is supported by the spec atm
+        _ => unimplemented!("The {val:?} is not yet supported"),
+    }
+}
+
+impl Table {
+    pub fn new(
+        store: &mut impl AsStoreMut,
+        ty: TableType,
+        init: Value,
+    ) -> Result<Self, RuntimeError> {
+        let mut store = store;
+        let descriptor = js_sys::Object::new();
+        js_sys::Reflect::set(&descriptor, &"initial".into(), &ty.minimum.into())?;
+        if let Some(max) = ty.maximum {
+            js_sys::Reflect::set(&descriptor, &"maximum".into(), &max.into())?;
+        }
+        js_sys::Reflect::set(&descriptor, &"element".into(), &"anyfunc".into())?;
+
+        let js_table = js_sys::WebAssembly::Table::new(&descriptor)?;
+        // TODO: use `Table.new_with_value` method from wasm-bindgen
+        // https://github.com/wasm-bindgen/wasm-bindgen/pull/4698
+        let table = VMTable::new(js_table, ty);
+        let num_elements = table.table.length();
+        let func = get_function(&mut store, init)?;
+        if let Some(func) = func {
+            for i in 0..num_elements {
+                set_table_item(&table, i, &func)?;
+            }
+        }
+
+        Ok(Self { handle: table })
+    }
+
+    pub fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Js(crate::js::vm::VMExtern::Table(self.handle.clone()))
+    }
+
+    pub fn ty(&self, _store: &impl AsStoreRef) -> TableType {
+        self.handle.ty
+    }
+
+    pub fn get(&self, store: &mut impl AsStoreMut, index: u32) -> Option<Value> {
+        if let Some(func) = self.handle.table.get(index).ok() {
+            let ty = FunctionType::new(vec![], vec![]);
+            let vm_function = VMFunction::new(func, ty);
+            let function = crate::Function::from_vm_extern(
+                store,
+                crate::vm::VMExternFunction::Js(vm_function),
+            );
+            Some(Value::FuncRef(Some(function)))
+        } else {
+            None
+        }
+    }
+
+    pub fn set(
+        &self,
+        store: &mut impl AsStoreMut,
+        index: u32,
+        val: Value,
+    ) -> Result<(), RuntimeError> {
+        let item = get_function(store, val)?;
+        if let Some(item) = item {
+            set_table_item(&self.handle, index, &item)?;
+        }
+        Ok(())
+    }
+
+    pub fn size(&self, _store: &impl AsStoreRef) -> u32 {
+        self.handle.table.length()
+    }
+
+    pub fn grow(
+        &self,
+        store: &mut impl AsStoreMut,
+        delta: u32,
+        init: Value,
+    ) -> Result<u32, RuntimeError> {
+        // TODO: use `Table.grow_with_value` method from wasm-bindgen
+        // https://github.com/wasm-bindgen/wasm-bindgen/pull/4698
+        let grow_by = self.handle.table.grow(delta)?;
+        if let Some(func) = get_function(store, init)? {
+            for i in grow_by..(grow_by + delta) {
+                set_table_item(&self.handle, i, &func)?;
+            }
+        }
+        Ok(grow_by)
+    }
+
+    pub fn copy(
+        _store: &mut impl AsStoreMut,
+        _dst_table: &Self,
+        _dst_index: u32,
+        _src_table: &Self,
+        _src_index: u32,
+        _len: u32,
+    ) -> Result<(), RuntimeError> {
+        unimplemented!("Table.copy is not natively supported in Javascript");
+    }
+
+    pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, vm_extern: VMExternTable) -> Self {
+        Self {
+            handle: vm_extern.into_js(),
+        }
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
+
+impl crate::Table {
+    /// Consume [`self`] into [`crate::backend::js::table::Table`].
+    pub fn into_js(self) -> crate::backend::js::table::Table {
+        match self.0 {
+            BackendTable::Js(s) => s,
+            _ => panic!("Not a `js` table!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::js::table::Table`].
+    pub fn as_js(&self) -> &crate::backend::js::table::Table {
+        match self.0 {
+            BackendTable::Js(ref s) => s,
+            _ => panic!("Not a `js` table!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::js::table::Table`].
+    pub fn as_js_mut(&mut self) -> &mut crate::backend::js::table::Table {
+        match self.0 {
+            BackendTable::Js(ref mut s) => s,
+            _ => panic!("Not a `js` table!"),
+        }
+    }
+}
+
+impl crate::BackendTable {
+    /// Consume [`self`] into [`crate::backend::js::table::Table`].
+    pub fn into_js(self) -> crate::backend::js::table::Table {
+        match self {
+            Self::Js(s) => s,
+            _ => panic!("Not a `js` table!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::js::table::Table`].
+    pub fn as_js(&self) -> &crate::backend::js::table::Table {
+        match self {
+            Self::Js(ref s) => s,
+            _ => panic!("Not a `js` table!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::js::table::Table`].
+    pub fn as_js_mut(&mut self) -> &mut crate::backend::js::table::Table {
+        match self {
+            Self::Js(ref mut s) => s,
+            _ => panic!("Not a `js` table!"),
+        }
+    }
+}
diff --git a/lib/api/src/backend/js/entities/tag.rs b/lib/api/src/backend/js/entities/tag.rs
new file mode 100644
index 0000000000..b00c9c3b9f
--- /dev/null
+++ b/lib/api/src/backend/js/entities/tag.rs
@@ -0,0 +1,87 @@
+use wasmer_types::{TagType, Type};
+
+use crate::{
+    js::vm::VMTag,
+    vm::{VMExtern, VMExternTag},
+    AsStoreMut, AsStoreRef, BackendTag, TagKind,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// A WebAssembly `tag` in the `v8` runtime.
+pub(crate) struct Tag {
+    pub(crate) handle: VMTag,
+}
+
+unsafe impl Send for Tag {}
+unsafe impl Sync for Tag {}
+
+// Tag can't be Send in js because it dosen't support `structuredClone`
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// unsafe impl Send for Tag {}
+
+impl Tag {
+    pub fn new<P: Into<Box<[Type]>>>(store: &mut impl AsStoreMut, params: P) -> Self {
+        let descriptor = js_sys::Object::new();
+        let params: Box<[Type]> = params.into();
+        let parameters: Vec<String> = params
+            .into_iter()
+            .map(|param| match param {
+                Type::I32 => "i32".to_string(),
+                Type::I64 => "i64".to_string(),
+                Type::F32 => "f32".to_string(),
+                Type::F64 => "f64".to_string(),
+                _ => unimplemented!("The type is not yet supported in the JS Global API"),
+            })
+            .collect();
+        js_sys::Reflect::set(&descriptor, &"parameters".into(), &parameters.into()).unwrap();
+
+        let tag = js_sys::WebAssembly::Tag::new(&descriptor);
+        let ty = TagType::new(TagKind::Exception, params);
+        let handle = VMTag::new(tag.unwrap(), ty);
+        Self { handle }
+    }
+
+    pub fn ty(&self, store: &impl AsStoreRef) -> TagType {
+        self.handle.ty.clone()
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternTag) -> Self {
+        Self {
+            handle: vm_extern.into_js(),
+        }
+    }
+
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        true
+    }
+
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Js(crate::js::vm::VMExtern::Tag(self.handle.clone()))
+    }
+}
+
+impl crate::Tag {
+    /// Consume [`self`] into [`crate::backend::js::tag::Tag`].
+    pub fn into_js(self) -> crate::backend::js::tag::Tag {
+        match self.0 {
+            BackendTag::Js(s) => s,
+            _ => panic!("Not a `js` tag!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::js::tag::Tag`].
+    pub fn as_js(&self) -> &crate::backend::js::tag::Tag {
+        match self.0 {
+            BackendTag::Js(ref s) => s,
+            _ => panic!("Not a `js` tag!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::js::tag::Tag`].
+    pub fn as_js_mut(&mut self) -> &mut crate::backend::js::tag::Tag {
+        match self.0 {
+            BackendTag::Js(ref mut s) => s,
+            _ => panic!("Not a `js` tag!"),
+        }
+    }
+}
diff --git a/lib/api/src/js/trap.rs b/lib/api/src/backend/js/error.rs
similarity index 81%
rename from lib/api/src/js/trap.rs
rename to lib/api/src/backend/js/error.rs
index 23a002e066..f52554a18b 100644
--- a/lib/api/src/js/trap.rs
+++ b/lib/api/src/backend/js/error.rs
@@ -1,7 +1,4 @@
-use std::{
-    error::Error,
-    fmt::{self, Display},
-};
+use std::error::Error;
 
 use js_sys::Reflect;
 use wasm_bindgen::{prelude::*, JsValue};
@@ -71,8 +68,8 @@ impl std::error::Error for Trap {
     }
 }
 
-impl fmt::Display for Trap {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl std::fmt::Display for Trap {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self.inner {
             InnerTrap::User(e) => write!(f, "user: {e}"),
             InnerTrap::Js(value) => write!(f, "js: {value}"),
@@ -169,11 +166,47 @@ impl From<JsValue> for JsTrap {
     }
 }
 
-impl Display for JsTrap {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl std::fmt::Display for JsTrap {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             JsTrap::Message(m) => write!(f, "{m}"),
             JsTrap::Unknown => write!(f, "unknown"),
         }
     }
 }
+
+impl From<JsTrap> for Trap {
+    fn from(value: JsTrap) -> Self {
+        Self {
+            inner: InnerTrap::Js(value),
+        }
+    }
+}
+
+impl From<JsTrap> for RuntimeError {
+    fn from(value: JsTrap) -> Self {
+        Into::<Trap>::into(value).into()
+    }
+}
+
+impl From<Trap> for RuntimeError {
+    fn from(trap: Trap) -> Self {
+        if trap.is::<Self>() {
+            return trap.downcast::<Self>().unwrap();
+        }
+
+        RuntimeError::new_from_source(crate::BackendTrap::Js(trap), vec![], None)
+    }
+}
+
+impl From<RuntimeError> for wasm_bindgen::JsValue {
+    fn from(value: RuntimeError) -> Self {
+        wasm_bindgen::JsValue::from(value.to_string())
+    }
+}
+
+pub(crate) fn raise(error: Box<dyn std::error::Error + Send + Sync>) -> ! {
+    let error = Trap::user(error);
+    let js_error: JsValue = error.into();
+    wasm_bindgen::throw_val(js_error)
+}
diff --git a/lib/api/src/backend/js/mod.rs b/lib/api/src/backend/js/mod.rs
new file mode 100644
index 0000000000..1bb4f68222
--- /dev/null
+++ b/lib/api/src/backend/js/mod.rs
@@ -0,0 +1,9 @@
+//! Data types, functions and traits for the `js` backend.
+
+pub(crate) mod entities;
+pub(crate) mod error;
+pub(crate) mod utils;
+pub(crate) mod vm;
+
+pub use entities::*;
+pub use utils::*;
diff --git a/lib/api/src/js/as_js.rs b/lib/api/src/backend/js/utils/convert.rs
similarity index 72%
rename from lib/api/src/js/as_js.rs
rename to lib/api/src/backend/js/utils/convert.rs
index 5068c8b127..c65008478f 100644
--- a/lib/api/src/js/as_js.rs
+++ b/lib/api/src/backend/js/utils/convert.rs
@@ -1,23 +1,24 @@
-//use crate::js::externals::Function;
-// use crate::store::{Store, StoreObject};
-// use crate::js::RuntimeError;
-use crate::imports::Imports;
-use crate::instance::Instance;
-use crate::js::instance::Instance as JsInstance;
-use crate::js::vm::{VMFunction, VMGlobal, VMMemory, VMTable};
-use crate::js::wasm_bindgen_polyfill::Global as JsGlobal;
-use crate::store::{AsStoreMut, AsStoreRef};
-use crate::value::Value;
-use crate::Type;
-use crate::{Extern, Function, Global, Memory, Table};
-use js_sys::Function as JsFunction;
-use js_sys::WebAssembly::{Memory as JsMemory, Table as JsTable};
-use std::collections::HashMap;
-use std::convert::TryInto;
-use wasm_bindgen::JsCast;
-use wasm_bindgen::{JsError, JsValue};
+use std::{collections::HashMap, convert::TryInto};
+
+use js_sys::{
+    Function as JsFunction,
+    WebAssembly::{Global as JsGlobal, Memory as JsMemory, Table as JsTable, Tag as JsTag},
+};
+use wasm_bindgen::{JsCast, JsError, JsValue};
 use wasmer_types::ExternType;
 
+use crate::{
+    imports::Imports,
+    instance::Instance,
+    js::{
+        instance::Instance as JsInstance,
+        vm::{VMFunction, VMGlobal, VMMemory, VMTable, VMTag},
+    },
+    store::{AsStoreMut, AsStoreRef},
+    value::Value,
+    Extern, Function, Global, Memory, Table, Tag, Type,
+};
+
 /// Convert the given type to a [`JsValue`].
 pub trait AsJs: Sized {
     /// The inner definition type from this Javascript object
@@ -33,7 +34,8 @@ pub trait AsJs: Sized {
 }
 
 #[inline]
-pub fn param_from_js(ty: &Type, js_val: &JsValue) -> Value {
+/// Convert a JsValue into a wasmer Value
+pub fn js_value_to_wasmer(ty: &Type, js_val: &JsValue) -> Value {
     match ty {
         Type::I32 => Value::I32(js_val.as_f64().unwrap() as _),
         Type::I64 => Value::I64(if js_val.is_bigint() {
@@ -47,13 +49,29 @@ pub fn param_from_js(ty: &Type, js_val: &JsValue) -> Value {
             let big_num: u128 = js_sys::BigInt::from(js_val.clone()).try_into().unwrap();
             Value::V128(big_num)
         }
-        Type::ExternRef | Type::FuncRef => unimplemented!(
+        Type::ExternRef | Type::FuncRef | Type::ExceptionRef => unimplemented!(
             "The type `{:?}` is not yet supported in the JS Function API",
             ty
         ),
     }
 }
 
+#[inline]
+/// Convert a wasmer Value into a JsValue
+pub fn wasmer_value_to_js(val: &Value) -> JsValue {
+    match val {
+        Value::I32(i) => JsValue::from_f64(*i as _),
+        Value::I64(i) => JsValue::from_f64(*i as _),
+        Value::F32(f) => JsValue::from_f64(*f as _),
+        Value::F64(f) => JsValue::from_f64(*f),
+        Value::V128(f) => JsValue::from_f64(*f as _),
+        val => unimplemented!(
+            "The value `{:?}` is not yet supported in the JS Function API",
+            val
+        ),
+    }
+}
+
 impl AsJs for Value {
     type DefinitionType = Type;
 
@@ -64,9 +82,14 @@ impl AsJs for Value {
             Self::F32(f) => JsValue::from(*f),
             Self::F64(f) => JsValue::from(*f),
             Self::V128(v) => JsValue::from(*v),
-            Self::FuncRef(Some(func)) => func.0.handle.function.clone().into(),
+            Self::FuncRef(Some(func)) => func.as_js().handle.function.clone().into(),
             Self::FuncRef(None) => JsValue::null(),
-            Self::ExternRef(_) => unimplemented!(),
+            Self::ExternRef(_) => {
+                unimplemented!("ExternRefs are not yet supported in the JS Function API",)
+            }
+            Self::ExceptionRef(_) => {
+                unimplemented!("ExceptionRefs are not yet supported in the JS Function API",)
+            }
         }
     }
 
@@ -75,7 +98,7 @@ impl AsJs for Value {
         type_: &Self::DefinitionType,
         value: &JsValue,
     ) -> Result<Self, JsError> {
-        Ok(param_from_js(type_, value))
+        Ok(js_value_to_wasmer(type_, value))
     }
 }
 
@@ -165,10 +188,11 @@ impl AsJs for Extern {
 
     fn as_jsvalue(&self, _store: &impl AsStoreRef) -> wasm_bindgen::JsValue {
         match self {
-            Self::Memory(memory) => memory.0.handle.memory.clone().into(),
-            Self::Function(function) => function.0.handle.function.clone().into(),
-            Self::Table(table) => table.0.handle.table.clone().into(),
-            Self::Global(global) => global.0.handle.global.clone().into(),
+            Self::Memory(memory) => memory.as_js().handle.memory.clone().into(),
+            Self::Function(function) => function.as_js().handle.function.clone().into(),
+            Self::Table(table) => table.as_js().handle.table.clone().into(),
+            Self::Global(global) => global.as_js().handle.global.clone().into(),
+            Self::Tag(tag) => tag.as_js().handle.tag.clone().into(),
         }
     }
 
@@ -194,6 +218,7 @@ impl AsJs for Extern {
             ExternType::Table(table_type) => {
                 Ok(Self::Table(Table::from_jsvalue(store, table_type, val)?))
             }
+            ExternType::Tag(tag_type) => Ok(Self::Tag(Tag::from_jsvalue(store, tag_type, val)?)),
         }
     }
 }
@@ -201,7 +226,7 @@ impl AsJs for Extern {
 impl AsJs for Instance {
     type DefinitionType = crate::module::Module;
     fn as_jsvalue(&self, _store: &impl AsStoreRef) -> wasm_bindgen::JsValue {
-        self._inner._handle.clone().into()
+        self.as_js()._handle.clone().into()
     }
 
     fn from_jsvalue(
@@ -213,7 +238,7 @@ impl AsJs for Instance {
         let (instance, exports) = JsInstance::from_module_and_instance(store, module, js_instance)
             .map_err(|e| JsError::new(&format!("Can't get the instance: {:?}", e)))?;
         Ok(Instance {
-            _inner: instance,
+            _inner: crate::BackendInstance::Js(instance),
             module: module.clone(),
             exports,
         })
@@ -224,7 +249,7 @@ impl AsJs for Memory {
     type DefinitionType = crate::MemoryType;
 
     fn as_jsvalue(&self, _store: &impl AsStoreRef) -> wasm_bindgen::JsValue {
-        self.0.handle.memory.clone().into()
+        self.as_js().handle.memory.clone().into()
     }
 
     fn from_jsvalue(
@@ -235,7 +260,7 @@ impl AsJs for Memory {
         if let Some(memory) = value.dyn_ref::<JsMemory>() {
             Ok(Memory::from_vm_extern(
                 store,
-                VMMemory::new(memory.clone(), memory_type.clone()),
+                crate::vm::VMExternMemory::Js(VMMemory::new(memory.clone(), memory_type.clone())),
             ))
         } else {
             Err(JsError::new(&format!(
@@ -250,7 +275,7 @@ impl AsJs for Function {
     type DefinitionType = crate::FunctionType;
 
     fn as_jsvalue(&self, _store: &impl AsStoreRef) -> wasm_bindgen::JsValue {
-        self.0.handle.function.clone().into()
+        self.as_js().handle.function.clone().into()
     }
 
     fn from_jsvalue(
@@ -261,10 +286,10 @@ impl AsJs for Function {
         if value.is_instance_of::<JsFunction>() {
             Ok(Function::from_vm_extern(
                 store,
-                VMFunction::new(
+                crate::vm::VMExternFunction::Js(VMFunction::new(
                     value.clone().unchecked_into::<JsFunction>(),
                     function_type.clone(),
-                ),
+                )),
             ))
         } else {
             Err(JsError::new(&format!(
@@ -275,11 +300,39 @@ impl AsJs for Function {
     }
 }
 
+impl AsJs for Tag {
+    type DefinitionType = crate::TagType;
+    fn as_jsvalue(&self, _store: &impl AsStoreRef) -> wasm_bindgen::JsValue {
+        self.as_js().handle.tag.clone().into()
+    }
+
+    fn from_jsvalue(
+        store: &mut impl AsStoreMut,
+        tag: &Self::DefinitionType,
+        value: &JsValue,
+    ) -> Result<Self, JsError> {
+        if value.is_instance_of::<JsTag>() {
+            Ok(Tag::from_vm_extern(
+                store,
+                crate::vm::VMExternTag::Js(VMTag::new(
+                    value.clone().unchecked_into::<JsTag>(),
+                    tag.clone(),
+                )),
+            ))
+        } else {
+            Err(JsError::new(&format!(
+                "Extern expect to be of type Tag, but received {:?}",
+                value
+            )))
+        }
+    }
+}
+
 impl AsJs for Global {
     type DefinitionType = crate::GlobalType;
 
     fn as_jsvalue(&self, _store: &impl AsStoreRef) -> wasm_bindgen::JsValue {
-        self.0.handle.global.clone().into()
+        self.as_js().handle.global.clone().into()
     }
 
     fn from_jsvalue(
@@ -290,10 +343,10 @@ impl AsJs for Global {
         if value.is_instance_of::<JsGlobal>() {
             Ok(Global::from_vm_extern(
                 store,
-                VMGlobal::new(
+                crate::vm::VMExternGlobal::Js(VMGlobal::new(
                     value.clone().unchecked_into::<JsGlobal>(),
                     global_type.clone(),
-                ),
+                )),
             ))
         } else {
             Err(JsError::new(&format!(
@@ -308,7 +361,7 @@ impl AsJs for Table {
     type DefinitionType = crate::TableType;
 
     fn as_jsvalue(&self, _store: &impl AsStoreRef) -> wasm_bindgen::JsValue {
-        self.0.handle.table.clone().into()
+        self.as_js().handle.table.clone().into()
     }
 
     fn from_jsvalue(
@@ -319,10 +372,10 @@ impl AsJs for Table {
         if value.is_instance_of::<JsTable>() {
             Ok(Table::from_vm_extern(
                 store,
-                VMTable::new(
+                crate::vm::VMExternTable::Js(VMTable::new(
                     value.clone().unchecked_into::<JsTable>(),
                     table_type.clone(),
-                ),
+                )),
             ))
         } else {
             Err(JsError::new(&format!(
diff --git a/lib/api/src/js/js_handle.rs b/lib/api/src/backend/js/utils/js_handle.rs
similarity index 100%
rename from lib/api/src/js/js_handle.rs
rename to lib/api/src/backend/js/utils/js_handle.rs
diff --git a/lib/api/src/backend/js/utils/mod.rs b/lib/api/src/backend/js/utils/mod.rs
new file mode 100644
index 0000000000..14f75ed024
--- /dev/null
+++ b/lib/api/src/backend/js/utils/mod.rs
@@ -0,0 +1,5 @@
+pub(crate) mod convert;
+pub(crate) mod js_handle;
+
+pub use convert::*;
+pub use js_handle::*;
diff --git a/lib/api/src/backend/js/vm/external.rs b/lib/api/src/backend/js/vm/external.rs
new file mode 100644
index 0000000000..ec324cdda5
--- /dev/null
+++ b/lib/api/src/backend/js/vm/external.rs
@@ -0,0 +1,68 @@
+use wasmer_types::RawValue;
+
+use crate::{AsStoreMut, Extern, VMExternToExtern};
+
+use super::{function::VMFunction, global::VMGlobal, memory::VMMemory, table::VMTable, tag::VMTag};
+
+/// The value of an export passed from one instance to another in the `js` VM.
+pub enum VMExtern {
+    /// A function export value.
+    Function(VMFunction),
+
+    /// A table export value.
+    Table(VMTable),
+
+    /// A memory export value.
+    Memory(VMMemory),
+
+    /// A global export value.
+    Global(VMGlobal),
+
+    /// A tag export value.
+    Tag(VMTag),
+}
+
+impl VMExternToExtern for VMExtern {
+    fn to_extern(self, store: &mut impl AsStoreMut) -> Extern {
+        match self {
+            Self::Function(f) => Extern::Function(crate::Function::from_vm_extern(
+                store,
+                crate::vm::VMExternFunction::Js(f),
+            )),
+            Self::Memory(m) => Extern::Memory(crate::Memory::from_vm_extern(
+                store,
+                crate::vm::VMExternMemory::Js(m),
+            )),
+            Self::Global(g) => Extern::Global(crate::Global::from_vm_extern(
+                store,
+                crate::vm::VMExternGlobal::Js(g),
+            )),
+            Self::Table(t) => Extern::Table(crate::Table::from_vm_extern(
+                store,
+                crate::vm::VMExternTable::Js(t),
+            )),
+            Self::Tag(t) => Extern::Tag(crate::Tag::from_vm_extern(
+                store,
+                crate::vm::VMExternTag::Js(t),
+            )),
+        }
+    }
+}
+
+/// A reference to an external value in the `js` VM.
+pub struct VMExternRef;
+
+impl VMExternRef {
+    /// Converts the `VMExternRef` into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        unimplemented!();
+    }
+
+    /// Extracts a `VMExternRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw` must be a valid `VMExternRef` instance.
+    pub unsafe fn from_raw(_raw: RawValue) -> Option<Self> {
+        unimplemented!();
+    }
+}
diff --git a/lib/api/src/backend/js/vm/function.rs b/lib/api/src/backend/js/vm/function.rs
new file mode 100644
index 0000000000..6f50bfe28c
--- /dev/null
+++ b/lib/api/src/backend/js/vm/function.rs
@@ -0,0 +1,92 @@
+use std::any::Any;
+
+use crate::js::utils::js_handle::JsHandle;
+use js_sys::Function as JsFunction;
+use wasmer_types::{FunctionType, RawValue};
+
+/// The VM Function type
+#[derive(Clone, Eq)]
+pub struct VMFunction {
+    pub(crate) function: JsHandle<JsFunction>,
+    pub(crate) ty: FunctionType,
+}
+
+unsafe impl Send for VMFunction {}
+unsafe impl Sync for VMFunction {}
+
+impl VMFunction {
+    pub(crate) fn new(function: JsFunction, ty: FunctionType) -> Self {
+        Self {
+            function: JsHandle::new(function),
+            ty,
+        }
+    }
+}
+
+impl PartialEq for VMFunction {
+    fn eq(&self, other: &Self) -> bool {
+        self.function == other.function
+    }
+}
+
+impl std::fmt::Debug for VMFunction {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("VMFunction")
+            .field("function", &self.function)
+            .finish()
+    }
+}
+
+/// Underlying FunctionEnvironment used by a `VMFunction`.
+#[derive(Debug)]
+pub struct VMFunctionEnvironment {
+    pub(crate) contents: Box<dyn Any + Send + 'static>,
+}
+
+impl VMFunctionEnvironment {
+    /// Wraps the given value to expose it to Wasm code as a function context.
+    pub fn new(val: impl Any + Send + 'static) -> Self {
+        Self {
+            contents: Box::new(val),
+        }
+    }
+
+    #[allow(clippy::should_implement_trait)]
+    /// Returns a reference to the underlying value.
+    pub fn as_ref(&self) -> &(dyn Any + Send + 'static) {
+        &*self.contents
+    }
+
+    #[allow(clippy::should_implement_trait)]
+    /// Returns a mutable reference to the underlying value.
+    pub fn as_mut(&mut self) -> &mut (dyn Any + Send + 'static) {
+        &mut *self.contents
+    }
+}
+
+#[repr(C)]
+/// The type of function bodies in the `js` VM.
+pub struct VMFunctionBody(u8);
+
+#[repr(transparent)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+/// The type of function references in the `js` VM.
+pub(crate) struct VMFuncRef;
+
+impl VMFuncRef {
+    /// Converts the `VMFuncRef` into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        unimplemented!();
+    }
+
+    /// Extracts a `VMFuncRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw.funcref` must be a valid pointer.
+    pub unsafe fn from_raw(_raw: RawValue) -> Option<Self> {
+        unimplemented!();
+    }
+}
+
+/// The type of function callbacks in the `js` VM.
+pub type VMFunctionCallback = *const VMFunctionBody;
diff --git a/lib/api/src/backend/js/vm/global.rs b/lib/api/src/backend/js/vm/global.rs
new file mode 100644
index 0000000000..dec457067f
--- /dev/null
+++ b/lib/api/src/backend/js/vm/global.rs
@@ -0,0 +1,18 @@
+use js_sys::WebAssembly::Global as JsGlobal;
+use wasmer_types::GlobalType;
+
+/// The VM Global type
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct VMGlobal {
+    pub(crate) global: JsGlobal,
+    pub(crate) ty: GlobalType,
+}
+
+impl VMGlobal {
+    pub(crate) fn new(global: JsGlobal, ty: GlobalType) -> Self {
+        Self { global, ty }
+    }
+}
+
+unsafe impl Send for VMGlobal {}
+unsafe impl Sync for VMGlobal {}
diff --git a/lib/api/src/backend/js/vm/memory.rs b/lib/api/src/backend/js/vm/memory.rs
new file mode 100644
index 0000000000..706694b746
--- /dev/null
+++ b/lib/api/src/backend/js/vm/memory.rs
@@ -0,0 +1,108 @@
+use crate::js::utils::js_handle::JsHandle;
+use js_sys::WebAssembly::Memory as JsMemory;
+use tracing::trace;
+use wasm_bindgen::{JsCast, JsValue};
+use wasmer_types::{MemoryError, MemoryType, Pages, WASM_PAGE_SIZE};
+
+/// Represents linear memory that is managed by the javascript runtime
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct VMMemory {
+    pub(crate) memory: JsHandle<JsMemory>,
+    pub(crate) ty: MemoryType,
+}
+
+unsafe impl Send for VMMemory {}
+unsafe impl Sync for VMMemory {}
+
+#[derive(serde::Serialize, serde::Deserialize)]
+struct DummyBuffer {
+    #[serde(rename = "byteLength")]
+    byte_length: u32,
+}
+
+impl VMMemory {
+    /// Creates a new memory directly from a WebAssembly javascript object
+    pub fn new(memory: JsMemory, ty: MemoryType) -> Self {
+        Self {
+            memory: JsHandle::new(memory),
+            ty,
+        }
+    }
+
+    /// Returns the size of the memory buffer in pages
+    pub fn get_runtime_size(&self) -> u32 {
+        let dummy: DummyBuffer = match serde_wasm_bindgen::from_value(self.memory.buffer()) {
+            Ok(o) => o,
+            Err(_) => return 0,
+        };
+        if dummy.byte_length == 0 {
+            return 0;
+        }
+        dummy.byte_length / WASM_PAGE_SIZE as u32
+    }
+
+    /// Attempts to clone this memory (if its clonable)
+    pub(crate) fn try_clone(&self) -> Result<VMMemory, MemoryError> {
+        Ok(self.clone())
+    }
+
+    /// Copies this memory to a new memory
+    pub fn copy(&mut self) -> Result<VMMemory, wasmer_types::MemoryError> {
+        let new_memory = crate::js::memory::Memory::js_memory_from_type(&self.ty)?;
+
+        let src = crate::js::memory::MemoryView::new_raw(&self.memory);
+        let amount = src.data_size() as usize;
+
+        trace!(%amount, "memory copy started");
+
+        let mut dst = crate::js::memory::MemoryView::new_raw(&new_memory);
+        let dst_size = dst.data_size() as usize;
+
+        if amount > dst_size {
+            let delta = amount - dst_size;
+            let pages = ((delta - 1) / WASM_PAGE_SIZE) + 1;
+
+            let our_js_memory: &crate::js::memory::JSMemory =
+                JsCast::unchecked_from_js_ref(&new_memory);
+            our_js_memory.grow(pages as u32).map_err(|err| {
+                if err.is_instance_of::<js_sys::RangeError>() {
+                    let cur_pages = dst_size;
+                    MemoryError::CouldNotGrow {
+                        current: Pages(cur_pages as u32),
+                        attempted_delta: Pages(pages as u32),
+                    }
+                } else {
+                    MemoryError::Generic(err.as_string().unwrap())
+                }
+            })?;
+
+            dst = crate::js::memory::MemoryView::new_raw(&new_memory);
+        }
+
+        src.copy_to_memory(amount as u64, &dst).map_err(|err| {
+            wasmer_types::MemoryError::Generic(format!("failed to copy the memory - {}", err))
+        })?;
+
+        trace!("memory copy finished (size={})", dst.size().bytes().0);
+
+        Ok(Self {
+            memory: JsHandle::new(new_memory),
+            ty: self.ty.clone(),
+        })
+    }
+}
+
+impl From<VMMemory> for JsValue {
+    fn from(value: VMMemory) -> Self {
+        JsValue::from(value.memory)
+    }
+}
+
+impl From<VMMemory> for (JsValue, MemoryType) {
+    fn from(value: VMMemory) -> Self {
+        (JsValue::from(value.memory), value.ty)
+    }
+}
+
+/// Shared VM memory, in `js`, is the "normal" memory.
+pub type VMSharedMemory = VMMemory;
diff --git a/lib/api/src/backend/js/vm/mod.rs b/lib/api/src/backend/js/vm/mod.rs
new file mode 100644
index 0000000000..eb8e63afda
--- /dev/null
+++ b/lib/api/src/backend/js/vm/mod.rs
@@ -0,0 +1,48 @@
+pub(crate) mod external;
+pub(crate) mod function;
+pub(crate) mod global;
+pub(crate) mod memory;
+pub(crate) mod table;
+pub(crate) mod tag;
+pub use super::error::Trap;
+
+pub use external::*;
+pub use function::*;
+pub use global::*;
+pub use memory::*;
+pub use table::*;
+pub use tag::*;
+
+/// The type of instances in the `js` VM.
+pub type VMInstance = js_sys::WebAssembly::Instance;
+
+pub struct VMTrampoline;
+
+/// The type of extern tables in the `js` VM.
+pub(crate) type VMExternTable = VMTable;
+/// The type of extern memories in the `js` VM.
+pub(crate) type VMExternMemory = VMMemory;
+/// The type of extern globals in the `js` VM.
+pub(crate) type VMExternGlobal = VMGlobal;
+/// The type of extern functions in the `js` VM.
+pub(crate) type VMExternFunction = VMFunction;
+
+// No EH for now.
+pub(crate) type VMException = ();
+pub(crate) type VMExternTag = VMTag;
+
+pub struct VMExceptionRef;
+impl VMExceptionRef {
+    /// Converts the `VMExceptionRef` into a `RawValue`.
+    pub fn into_raw(self) -> wasmer_types::RawValue {
+        unimplemented!()
+    }
+
+    /// Extracts a `VMExceptionRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw` must be a valid `VMExceptionRef` instance.
+    pub unsafe fn from_raw(_raw: wasmer_types::RawValue) -> Option<Self> {
+        unimplemented!();
+    }
+}
diff --git a/lib/api/src/backend/js/vm/table.rs b/lib/api/src/backend/js/vm/table.rs
new file mode 100644
index 0000000000..a0d059c663
--- /dev/null
+++ b/lib/api/src/backend/js/vm/table.rs
@@ -0,0 +1,23 @@
+use js_sys::WebAssembly::Table as JsTable;
+use wasmer_types::TableType;
+
+/// The VM Table type
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct VMTable {
+    pub(crate) table: JsTable,
+    pub(crate) ty: TableType,
+}
+
+unsafe impl Send for VMTable {}
+unsafe impl Sync for VMTable {}
+
+impl VMTable {
+    pub(crate) fn new(table: JsTable, ty: TableType) -> Self {
+        Self { table, ty }
+    }
+
+    /// Get the table size at runtime
+    pub fn get_runtime_size(&self) -> u32 {
+        self.table.length()
+    }
+}
diff --git a/lib/api/src/backend/js/vm/tag.rs b/lib/api/src/backend/js/vm/tag.rs
new file mode 100644
index 0000000000..d0118137b8
--- /dev/null
+++ b/lib/api/src/backend/js/vm/tag.rs
@@ -0,0 +1,18 @@
+use js_sys::WebAssembly::Tag as JsTag;
+use wasmer_types::TagType;
+
+/// The VM Tag type
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct VMTag {
+    pub(crate) tag: JsTag,
+    pub(crate) ty: TagType,
+}
+
+impl VMTag {
+    pub(crate) fn new(tag: JsTag, ty: TagType) -> Self {
+        Self { tag, ty }
+    }
+}
+
+unsafe impl Send for VMTag {}
+unsafe impl Sync for VMTag {}
diff --git a/lib/api/src/jsc/engine.rs b/lib/api/src/backend/jsc/entities/engine.rs
similarity index 64%
rename from lib/api/src/jsc/engine.rs
rename to lib/api/src/backend/jsc/entities/engine.rs
index adbf7a33cd..c026f4b18f 100644
--- a/lib/api/src/jsc/engine.rs
+++ b/lib/api/src/backend/jsc/entities/engine.rs
@@ -1,6 +1,10 @@
-use rusty_jsc::{JSContext, JSObject};
 use std::sync::Arc;
 
+use rusty_jsc::{JSContext, JSObject};
+use wasmer_types::{target::Target, Features};
+
+use crate::{AsEngineRef, AsStoreRef};
+
 #[derive(Debug)]
 pub(crate) struct JSCEngine {
     context: JSContext,
@@ -65,7 +69,7 @@ impl Default for JSCEngine {
     }
 }
 
-/// A WebAssembly `Universal` Engine.
+/// The engine for the JavascriptCore runtime.
 #[derive(Clone, Debug, Default)]
 pub struct Engine {
     inner: Arc<JSCEngine>,
@@ -76,43 +80,43 @@ unsafe impl Sync for Engine {}
 
 impl From<&crate::engine::Engine> for Engine {
     fn from(engine: &crate::engine::Engine) -> Self {
-        engine.0.clone()
+        engine.as_jsc().clone()
     }
 }
 
-pub(crate) trait JSC {
+pub(crate) trait IntoJSC {
     fn jsc(&self) -> &JSCEngine;
 }
 
-impl JSC for crate::Engine {
+impl IntoJSC for crate::Engine {
     #[inline]
     fn jsc(&self) -> &JSCEngine {
-        &self.0.inner
+        &self.as_jsc().inner
     }
 }
 
-impl JSC for crate::engine::EngineRef<'_> {
+impl IntoJSC for crate::engine::EngineRef<'_> {
     #[inline]
     fn jsc(&self) -> &JSCEngine {
-        &self.engine().0.inner
+        &self.engine().as_jsc().inner
     }
 }
 
-impl JSC for crate::store::StoreRef<'_> {
+impl IntoJSC for crate::store::StoreRef<'_> {
     #[inline]
     fn jsc(&self) -> &JSCEngine {
         &self.engine().jsc()
     }
 }
 
-impl JSC for crate::store::StoreMut<'_> {
+impl IntoJSC for crate::store::StoreMut<'_> {
     #[inline]
     fn jsc(&self) -> &JSCEngine {
         &self.engine().jsc()
     }
 }
 
-impl JSC for crate::Store {
+impl IntoJSC for crate::Store {
     #[inline]
     fn jsc(&self) -> &JSCEngine {
         &self.engine().jsc()
@@ -162,9 +166,27 @@ impl JSCEngine {
 }
 
 impl Engine {
-    pub(crate) fn deterministic_id(&self) -> &str {
+    pub(crate) fn deterministic_id(&self) -> String {
         // All js engines have the same id
-        "javascriptcore"
+        String::from("javascriptcore")
+    }
+
+    /// Returns the WebAssembly features supported by the JSC engine for the given target.
+    pub fn supported_features() -> Features {
+        // JSC-specific features
+        let mut features = Features::default();
+        features.bulk_memory(true);
+        features.reference_types(true);
+        features.simd(true);
+        features.threads(true);
+        features.multi_value(true);
+        features.exceptions(false);
+        features
+    }
+
+    /// Returns the default features for the JSC engine.
+    pub fn default_features() -> Features {
+        Self::supported_features()
     }
 
     #[inline]
@@ -208,13 +230,47 @@ impl Engine {
     }
 }
 
-// impl Default for Engine {
-//     fn default() -> Self {
-//         Engine
-//     }
-// }
-
 /// Returns the default engine for the JS engine
 pub(crate) fn default_engine() -> Engine {
     Engine::default()
 }
+
+impl crate::Engine {
+    /// Consume [`self`] into a [`crate::backend::jsc::engine::Engine`].
+    pub fn into_jsc(self) -> crate::backend::jsc::engine::Engine {
+        match self.be {
+            crate::BackendEngine::Jsc(s) => s,
+            _ => panic!("Not a `jsc` engine!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::jsc::engine::Engine`].
+    pub fn as_jsc(&self) -> &crate::backend::jsc::engine::Engine {
+        match self.be {
+            crate::BackendEngine::Jsc(ref s) => s,
+            _ => panic!("Not a `jsc` engine!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::jsc::engine::Engine`].
+    pub fn as_jsc_mut(&mut self) -> &mut crate::backend::jsc::engine::Engine {
+        match self.be {
+            crate::BackendEngine::Jsc(ref mut s) => s,
+            _ => panic!("Not a `jsc` engine!"),
+        }
+    }
+
+    /// Return true if [`self`] is an engine from the `jsc` runtime.
+    pub fn is_jsc(&self) -> bool {
+        matches!(self.be, crate::BackendEngine::Jsc(_))
+    }
+}
+
+impl Into<crate::Engine> for Engine {
+    fn into(self) -> crate::Engine {
+        crate::Engine {
+            be: crate::BackendEngine::Jsc(self),
+            id: crate::Engine::atomic_next_engine_id(),
+        }
+    }
+}
diff --git a/lib/api/src/backend/jsc/entities/exception.rs b/lib/api/src/backend/jsc/entities/exception.rs
new file mode 100644
index 0000000000..f7a2a63f99
--- /dev/null
+++ b/lib/api/src/backend/jsc/entities/exception.rs
@@ -0,0 +1,63 @@
+//! Data types, functions and traits for `sys` runtime's `Tag` implementation.
+use std::any::Any;
+
+use wasmer_types::{TagType, Type};
+
+use crate::{
+    jsc::vm::{VMException, VMExceptionRef},
+    AsStoreMut, AsStoreRef, Tag, Value,
+};
+
+use super::store::StoreHandle;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// A WebAssembly `tag` in the `v8` runtime.
+pub(crate) struct Exception {
+    pub(crate) handle: VMException,
+}
+
+unsafe impl Send for Exception {}
+unsafe impl Sync for Exception {}
+
+impl Exception {
+    /// Create a new [`Exception`].
+    pub fn new(store: &mut impl AsStoreMut, tag: Tag, payload: &[Value]) -> Self {
+        todo!()
+    }
+}
+
+#[derive(Debug, Clone)]
+#[repr(transparent)]
+/// A WebAssembly `exnref` in `jsc`.
+pub(crate) struct ExceptionRef;
+
+impl ExceptionRef {
+    pub fn new<T>(_store: &mut impl AsStoreMut, _value: T) -> Self
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        unimplemented!("ExceptionRef is not yet supported in jsc");
+    }
+
+    pub fn downcast<'a, T>(&self, _store: &'a impl AsStoreRef) -> Option<&'a T>
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        unimplemented!("ExceptionRef is not yet supported in jsc");
+    }
+
+    pub(crate) fn vm_exceptionref(&self) -> VMExceptionRef {
+        unimplemented!("ExceptionRef is not yet supported in jsc");
+    }
+
+    pub(crate) unsafe fn from_vm_exceptionref(
+        _store: &mut impl AsStoreMut,
+        _vm_exceptionref: VMExceptionRef,
+    ) -> Self {
+        unimplemented!("ExceptionRef is not yet supported in jsc");
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
diff --git a/lib/api/src/jsc/extern_ref.rs b/lib/api/src/backend/jsc/entities/external.rs
similarity index 100%
rename from lib/api/src/jsc/extern_ref.rs
rename to lib/api/src/backend/jsc/entities/external.rs
diff --git a/lib/api/src/backend/jsc/entities/function/env.rs b/lib/api/src/backend/jsc/entities/function/env.rs
new file mode 100644
index 0000000000..81f4aef391
--- /dev/null
+++ b/lib/api/src/backend/jsc/entities/function/env.rs
@@ -0,0 +1,207 @@
+use std::{any::Any, fmt::Debug, marker::PhantomData};
+
+use crate::{
+    jsc::{store::StoreHandle, vm::VMFunctionEnvironment},
+    store::{AsStoreMut, AsStoreRef, StoreRef},
+    StoreMut,
+};
+
+#[derive(Debug)]
+#[repr(transparent)]
+/// An opaque reference to a function environment.
+/// The function environment data is owned by the `Store`.
+pub struct FunctionEnv<T> {
+    pub(crate) handle: StoreHandle<VMFunctionEnvironment>,
+    marker: PhantomData<T>,
+}
+
+impl<T> FunctionEnv<T> {
+    /// Make a new FunctionEnv
+    pub fn new(store: &mut impl AsStoreMut, value: T) -> Self
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        Self {
+            handle: StoreHandle::new(
+                store.as_store_mut().objects_mut().as_jsc_mut(),
+                VMFunctionEnvironment::new(value),
+            ),
+            marker: PhantomData,
+        }
+    }
+
+    /// Get the data as reference
+    pub fn as_ref<'a>(&self, store: &'a impl AsStoreRef) -> &'a T
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        self.handle
+            .get(store.as_store_ref().objects().as_jsc())
+            .as_ref()
+            .downcast_ref::<T>()
+            .unwrap()
+    }
+
+    pub(crate) fn from_handle(handle: StoreHandle<VMFunctionEnvironment>) -> Self {
+        Self {
+            handle,
+            marker: PhantomData,
+        }
+    }
+
+    /// Get the data as mutable
+    pub fn as_mut<'a>(&self, store: &'a mut impl AsStoreMut) -> &'a mut T
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        self.handle
+            .get_mut(store.objects_mut().as_jsc_mut())
+            .as_mut()
+            .downcast_mut::<T>()
+            .unwrap()
+    }
+
+    /// Convert it into a `FunctionEnvMut`
+    pub fn into_mut(self, store: &mut impl AsStoreMut) -> FunctionEnvMut<T>
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        FunctionEnvMut {
+            store_mut: store.as_store_mut(),
+            func_env: self,
+        }
+    }
+}
+
+impl<T> PartialEq for FunctionEnv<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.handle == other.handle
+    }
+}
+
+impl<T> Eq for FunctionEnv<T> {}
+
+impl<T> std::hash::Hash for FunctionEnv<T> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.handle.hash(state);
+        self.marker.hash(state);
+    }
+}
+
+impl<T> Clone for FunctionEnv<T> {
+    fn clone(&self) -> Self {
+        Self {
+            handle: self.handle.clone(),
+            marker: self.marker,
+        }
+    }
+}
+
+/// A temporary handle to a [`FunctionEnv`].
+pub struct FunctionEnvMut<'a, T: 'a> {
+    pub(crate) store_mut: StoreMut<'a>,
+    pub(crate) func_env: FunctionEnv<T>,
+}
+
+impl<'a, T> Debug for FunctionEnvMut<'a, T>
+where
+    T: Send + Debug + 'static,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.func_env.as_ref(&self.store_mut).fmt(f)
+    }
+}
+
+impl<T: Send + 'static> FunctionEnvMut<'_, T> {
+    /// Returns a reference to the host state in this function environement.
+    pub fn data(&self) -> &T {
+        self.func_env.as_ref(&self.store_mut)
+    }
+
+    /// Returns a mutable- reference to the host state in this function environement.
+    pub fn data_mut(&mut self) -> &mut T {
+        self.func_env.as_mut(&mut self.store_mut)
+    }
+
+    /// Borrows a new immmutable reference
+    pub fn as_ref(&self) -> FunctionEnv<T> {
+        self.func_env.clone()
+    }
+
+    /// Borrows a new mutable reference
+    pub fn as_mut(&mut self) -> FunctionEnvMut<'_, T> {
+        FunctionEnvMut {
+            store_mut: self.store_mut.as_store_mut(),
+            func_env: self.func_env.clone(),
+        }
+    }
+
+    /// Borrows a new mutable reference of both the attached Store and host state
+    pub fn data_and_store_mut(&mut self) -> (&mut T, StoreMut) {
+        let data = self.func_env.as_mut(&mut self.store_mut) as *mut T;
+        // telling the borrow check to close his eyes here
+        // this is still relatively safe to do as func_env are
+        // stored in a specific vec of Store, separate from the other objects
+        // and not really directly accessible with the StoreMut
+        let data = unsafe { &mut *data };
+        (data, self.store_mut.as_store_mut())
+    }
+}
+
+impl<T> AsStoreRef for FunctionEnvMut<'_, T> {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        StoreRef {
+            inner: self.store_mut.inner,
+        }
+    }
+}
+
+impl<T> AsStoreMut for FunctionEnvMut<'_, T> {
+    fn as_store_mut(&mut self) -> StoreMut<'_> {
+        StoreMut {
+            inner: self.store_mut.inner,
+        }
+    }
+
+    fn objects_mut(&mut self) -> &mut crate::StoreObjects {
+        self.store_mut.objects_mut()
+    }
+}
+
+impl<T> crate::FunctionEnv<T> {
+    /// Consume [`self`] into [`crate::backend::jsc::function::env::FunctionEnv`].
+    pub fn into_jsc(self) -> FunctionEnv<T> {
+        match self.0 {
+            crate::BackendFunctionEnv::Jsc(s) => s,
+            _ => panic!("Not a `jsc` function env!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference to [`crate::backend::jsc::function::env::FunctionEnv`].
+    pub fn as_jsc(&self) -> &FunctionEnv<T> {
+        match self.0 {
+            crate::BackendFunctionEnv::Jsc(ref s) => s,
+            _ => panic!("Not a `jsc` function env!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::jsc::function::env::FunctionEnv`].
+    pub fn as_jsc_mut(&mut self) -> &mut FunctionEnv<T> {
+        match self.0 {
+            crate::BackendFunctionEnv::Jsc(ref mut s) => s,
+            _ => panic!("Not a `jsc` function env!"),
+        }
+    }
+}
+
+impl<'a, T> From<FunctionEnvMut<'a, T>> for crate::FunctionEnvMut<'a, T> {
+    fn from(value: FunctionEnvMut<'a, T>) -> Self {
+        crate::FunctionEnvMut(crate::BackendFunctionEnvMut::Jsc(value))
+    }
+}
+
+impl<T> From<FunctionEnv<T>> for crate::FunctionEnv<T> {
+    fn from(value: FunctionEnv<T>) -> Self {
+        crate::FunctionEnv(crate::BackendFunctionEnv::Jsc(value))
+    }
+}
diff --git a/lib/api/src/backend/jsc/entities/function/mod.rs b/lib/api/src/backend/jsc/entities/function/mod.rs
new file mode 100644
index 0000000000..6856dfeeb2
--- /dev/null
+++ b/lib/api/src/backend/jsc/entities/function/mod.rs
@@ -0,0 +1,600 @@
+pub(crate) mod env;
+pub(crate) mod typed;
+
+use rusty_jsc::{
+    callback, callback_closure, JSContext, JSObject, JSObjectCallAsFunctionCallback, JSValue,
+};
+use std::marker::PhantomData;
+use std::panic::{self, AssertUnwindSafe};
+use wasmer_types::{FunctionType, RawValue};
+
+use crate::{
+    jsc::{
+        store::{InternalStoreHandle, StoreHandle},
+        utils::convert::{jsc_value_to_wasmer, AsJsc},
+        vm::{VMFuncRef, VMFunction, VMFunctionEnvironment},
+    },
+    vm::VMExtern,
+    AsStoreMut, AsStoreRef, BackendFunction, BackendFunctionEnvMut, FromToNativeWasmType,
+    FunctionEnv, FunctionEnvMut, HostFunction, HostFunctionKind, IntoResult, NativeWasmType,
+    NativeWasmTypeInto, RuntimeError, StoreMut, Value, WasmTypeList, WithEnv, WithoutEnv,
+};
+
+use super::engine::IntoJSC;
+
+pub(crate) use env::*;
+pub(crate) use typed::*;
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct Function {
+    pub(crate) handle: VMFunction,
+}
+
+// Function can't be Send in js because it dosen't support `structuredClone`
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// unsafe impl Send for Function {}
+
+impl From<VMFunction> for Function {
+    fn from(handle: VMFunction) -> Self {
+        Self { handle }
+    }
+}
+
+impl Function {
+    /// To `VMExtern`.
+    pub fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Jsc(crate::backend::jsc::vm::VMExtern::Function(
+            self.handle.clone(),
+        ))
+    }
+
+    #[allow(clippy::cast_ptr_alignment)]
+    pub fn new_with_env<FT, F, T: Send + 'static>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        ty: FT,
+        func: F,
+    ) -> Self
+    where
+        FT: Into<FunctionType>,
+        F: Fn(FunctionEnvMut<'_, T>, &[Value]) -> Result<Vec<Value>, RuntimeError>
+            + 'static
+            + Send
+            + Sync,
+    {
+        let store = store.as_store_mut();
+        let context = store.jsc().context();
+        let function_type = ty.into();
+
+        let new_function_type = function_type.clone();
+        let raw_env = env.clone();
+
+        let callback = callback_closure!(&context, move |ctx: JSContext,
+                                                         function: JSObject,
+                                                         this: JSObject,
+                                                         args: &[JSValue]|
+              -> Result<JSValue, JSValue> {
+            let global = ctx.get_global_object();
+            let store_ptr = global
+                .get_property(&ctx, "__store_ptr".to_string())
+                .to_number(&ctx)
+                .unwrap();
+
+            let mut store = unsafe { StoreMut::from_raw(store_ptr as usize as *mut _) };
+
+            let env: FunctionEnvMut<T> = raw_env.clone().into_mut(&mut store);
+
+            let wasm_arguments = new_function_type
+                .params()
+                .iter()
+                .enumerate()
+                .map(|(i, param)| jsc_value_to_wasmer(&ctx, param, &args[i]))
+                .collect::<Vec<_>>();
+            let results = func(env, &wasm_arguments).map_err(|e| {
+                let value = format!("{}", e);
+                JSValue::string(&ctx, value)
+            })?;
+            match new_function_type.results().len() {
+                0 => Ok(JSValue::undefined(&ctx)),
+                1 => Ok(results[0].as_jsc_value(&mut store)),
+                _ => Ok(JSObject::new_array(
+                    &ctx,
+                    &results
+                        .into_iter()
+                        .map(|result| result.as_jsc_value(&mut store))
+                        .collect::<Vec<_>>(),
+                )?
+                .to_jsvalue()),
+            }
+        });
+
+        let vm_function = VMFunction::new(callback, function_type);
+        Self {
+            handle: vm_function,
+        }
+    }
+
+    /// Creates a new host `Function` from a native function.
+    pub fn new_typed<F, Args, Rets>(store: &mut impl AsStoreMut, func: F) -> Self
+    where
+        F: HostFunction<(), Args, Rets, WithoutEnv> + 'static + Send + Sync,
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+    {
+        let store = store.as_store_mut();
+        let function = WasmFunction::<Args, Rets>::new(func);
+        let callback = function.callback(store.jsc().context());
+
+        let ty = function.ty();
+        let vm_function = VMFunction::new(callback, ty);
+        Self {
+            handle: vm_function,
+        }
+    }
+
+    pub fn new_typed_with_env<T, F, Args, Rets>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        func: F,
+    ) -> Self
+    where
+        F: HostFunction<T, Args, Rets, WithEnv>,
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+    {
+        let store = store.as_store_mut();
+        let context = store.jsc().context();
+        let function = WasmFunction::<Args, Rets>::new(func);
+        let callback = function.callback(store.jsc().context());
+
+        let bind = callback
+            .get_property(&context, "bind".to_string())
+            .to_object(&context)
+            .unwrap();
+        let callback_with_env = bind
+            .call(
+                &context,
+                Some(&callback),
+                &[
+                    JSValue::undefined(&context),
+                    JSValue::number(
+                        &context,
+                        env.as_jsc().handle.internal_handle().index() as f64,
+                    ),
+                ],
+            )
+            .unwrap()
+            .to_object(&context)
+            .unwrap();
+
+        let ty = function.ty();
+        let vm_function = VMFunction::new(callback_with_env, ty);
+        Self {
+            handle: vm_function,
+        }
+    }
+
+    pub fn ty(&self, _store: &impl AsStoreRef) -> FunctionType {
+        self.handle.ty.clone()
+    }
+
+    pub fn call_raw(
+        &self,
+        _store: &mut impl AsStoreMut,
+        _params: Vec<RawValue>,
+    ) -> Result<Box<[Value]>, RuntimeError> {
+        // There is no optimal call_raw in JSC, so we just
+        // simply rely the call
+        // self.call(store, params)
+        unimplemented!();
+    }
+
+    pub fn call(
+        &self,
+        store: &mut impl AsStoreMut,
+        params: &[Value],
+    ) -> Result<Box<[Value]>, RuntimeError> {
+        let store_mut = store.as_store_mut();
+        let engine = store_mut.engine();
+        let context = engine.as_jsc().context();
+
+        let mut global = context.get_global_object();
+        let store_ptr = store_mut.as_raw() as usize;
+        global.set_property(
+            &context,
+            "__store_ptr".to_string(),
+            JSValue::number(&context, store_ptr as _),
+        );
+
+        let params_list = params
+            .iter()
+            .map(|v| v.as_jsc_value(&store_mut))
+            .collect::<Vec<_>>();
+        let result = {
+            let mut r;
+            // TODO: This loop is needed for asyncify. It will be refactored with https://github.com/wasmerio/wasmer/issues/3451
+            loop {
+                let store_mut = store.as_store_mut();
+                let engine = store_mut.engine();
+                let context = engine.as_jsc().context();
+                r = self.handle.function.call(&context, None, &params_list);
+                if let Some(callback) = store_mut.inner.on_called.take() {
+                    match callback(store_mut) {
+                        Ok(wasmer_types::OnCalledAction::InvokeAgain) => {
+                            continue;
+                        }
+                        Ok(wasmer_types::OnCalledAction::Finish) => {
+                            break;
+                        }
+                        Ok(wasmer_types::OnCalledAction::Trap(trap)) => {
+                            return Err(RuntimeError::user(trap))
+                        }
+                        Err(trap) => return Err(RuntimeError::user(trap)),
+                    }
+                }
+                break;
+            }
+            r?
+        };
+        let result_types = self.handle.ty.results();
+        let store_mut = store.as_store_mut();
+        let engine = store_mut.engine();
+        let context = engine.as_jsc().context();
+        match result_types.len() {
+            0 => Ok(Box::new([])),
+            1 => {
+                let value = jsc_value_to_wasmer(&context, &result_types[0], &result);
+                Ok(vec![value].into_boxed_slice())
+            }
+            n => {
+                let result = result.to_object(&context).unwrap();
+                Ok((0..n)
+                    .map(|i| {
+                        let js_val = result.get_property_at_index(&context, i as _).unwrap();
+                        jsc_value_to_wasmer(&context, &result_types[i], &js_val)
+                    })
+                    .collect::<Vec<_>>()
+                    .into_boxed_slice())
+            }
+        }
+    }
+
+    pub(crate) fn from_vm_extern(
+        _store: &mut impl AsStoreMut,
+        internal: crate::vm::VMExternFunction,
+    ) -> Self {
+        Self {
+            handle: internal.into_jsc(),
+        }
+    }
+
+    pub(crate) fn vm_funcref(&self, _store: &impl AsStoreRef) -> VMFuncRef {
+        unimplemented!();
+    }
+
+    pub(crate) unsafe fn from_vm_funcref(
+        _store: &mut impl AsStoreMut,
+        _funcref: VMFuncRef,
+    ) -> Self {
+        unimplemented!();
+    }
+
+    /// Checks whether this `Function` can be used with the given context.
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
+
+impl std::fmt::Debug for Function {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.debug_struct("Function").finish()
+    }
+}
+
+/// Represents a low-level Wasm static host function. See
+/// `super::Function::new` and `super::Function::new_env` to learn
+/// more.
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct WasmFunction<Args = (), Rets = ()> {
+    callback: JSObjectCallAsFunctionCallback,
+    _phantom: PhantomData<(Args, Rets)>,
+}
+
+unsafe impl<Args, Rets> Send for WasmFunction<Args, Rets> {}
+
+impl<Args, Rets> WasmFunction<Args, Rets>
+where
+    Args: WasmTypeList,
+    Rets: WasmTypeList,
+{
+    /// Creates a new `WasmFunction`.
+    #[allow(dead_code)]
+    pub fn new<F, T, Kind: HostFunctionKind>(function: F) -> Self
+    where
+        F: HostFunction<T, Args, Rets, Kind>,
+        T: Sized,
+    {
+        Self {
+            callback: function
+                .function_callback(crate::BackendKind::Jsc)
+                .into_jsc(),
+            _phantom: PhantomData,
+        }
+    }
+
+    /// Get the function type of this `WasmFunction`.
+    #[allow(dead_code)]
+    pub fn ty(&self) -> FunctionType {
+        FunctionType::new(Args::wasm_types(), Rets::wasm_types())
+    }
+
+    /// Get the address of this `WasmFunction`.
+    #[allow(dead_code)]
+    pub fn callback(&self, context: &JSContext) -> JSObject {
+        JSObject::new_function_with_callback(context, "FunctionCallback".to_string(), self.callback)
+    }
+}
+
+impl crate::Function {
+    /// Consume [`self`] into [`crate::backend::jsc::function::Function`].
+    pub fn into_jsc(self) -> crate::backend::jsc::function::Function {
+        match self.0 {
+            BackendFunction::Jsc(s) => s,
+            _ => panic!("Not a `jsc` function!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference to [`crate::backend::jsc::function::Function`].
+    pub fn as_jsc(&self) -> &crate::backend::jsc::function::Function {
+        match self.0 {
+            BackendFunction::Jsc(ref s) => s,
+            _ => panic!("Not a `jsc` function!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::jsc::function::Function`].
+    pub fn as_jsc_mut(&mut self) -> &mut crate::backend::jsc::function::Function {
+        match self.0 {
+            BackendFunction::Jsc(ref mut s) => s,
+            _ => panic!("Not a `jsc` function!"),
+        }
+    }
+}
+
+// Black-magic to count the number of identifiers at compile-time.
+macro_rules! count_idents {
+    ( $($idents:ident),* ) => {
+        {
+            #[allow(dead_code, non_camel_case_types)]
+            enum Idents { $( $idents, )* __CountIdentsLast }
+            const COUNT: usize = Idents::__CountIdentsLast as usize;
+            COUNT
+        }
+    };
+}
+
+macro_rules! impl_host_function {
+    ([$c_struct_representation:ident] $c_struct_name:ident, $( $x:ident ),* ) => {
+        paste::paste! {
+        #[allow(non_snake_case)]
+        pub(crate) fn [<gen_fn_callback_ $c_struct_name:lower _no_env>]
+            <$( $x: FromToNativeWasmType, )* Rets: WasmTypeList, RetsAsResult: IntoResult<Rets>, Func: Fn($( $x , )*) -> RetsAsResult + 'static>
+            (this: &Func) -> crate::backend::jsc::vm::VMFunctionCallback {
+
+            #[callback]
+            fn fn_callback<$( $x, )* Rets, RetsAsResult, Func>(
+                ctx: JSContext,
+                function: JSObject,
+                this_object: JSObject,
+                arguments: &[JSValue],
+            ) -> Result<JSValue, JSValue>
+            where
+                $( $x: FromToNativeWasmType, )*
+                Rets: WasmTypeList,
+                RetsAsResult: IntoResult<Rets>,
+                Func: Fn($( $x , )*) -> RetsAsResult + 'static,
+                // $( $x: NativeWasmTypeInto, )*
+            {
+                use std::convert::TryInto;
+
+                let func: &Func = &*(&() as *const () as *const Func);
+                let global = ctx.get_global_object();
+                let store_ptr = global.get_property(&ctx, "__store_ptr".to_string()).to_number(&ctx).unwrap();
+                if store_ptr.is_nan() {
+                    panic!("Store pointer is invalid. Received {}", store_ptr as usize)
+                }
+
+                let mut store = StoreMut::from_raw(store_ptr as usize as *mut _);
+                let result = panic::catch_unwind(AssertUnwindSafe(|| {
+                    type JSArray<'a> = &'a [JSValue; count_idents!( $( $x ),* )];
+                    let args_without_store: JSArray = arguments.try_into().unwrap();
+                    let [ $( $x ),* ] = args_without_store;
+                    func($( FromToNativeWasmType::from_native( $x::Native::from_raw(&mut store, RawValue { u128: {
+                        // TODO: This may not be the fastest way, but JSC doesn't expose a BigInt interface
+                        // so the only thing we can do is parse from the string repr
+                        if $x.is_number(&ctx) {
+                            $x.to_number(&ctx).unwrap() as _
+                        }
+                        else {
+                            $x.to_string(&ctx).unwrap().to_string().parse::<u128>().unwrap()
+                        }
+                    } }) ) ),* ).into_result()
+                }));
+
+                match result {
+                    Ok(Ok(result)) => {
+                        match Rets::size() {
+                            0 => {Ok(JSValue::undefined(&ctx))},
+                            1 => {
+                                let ty = Rets::wasm_types()[0];
+                                let mut arr = result.into_array(&mut store);
+                                let val = Value::from_raw(&mut store, ty, arr.as_mut()[0]);
+                                let value: JSValue = val.as_jsc_value(&store);
+                                Ok(value)
+                            }
+                            _n => {
+                                let mut arr = result.into_array(&mut store);
+                                let result_values = Rets::wasm_types().iter().enumerate().map(|(i, ret_type)| {
+                                    let raw = arr.as_mut()[i];
+                                    Value::from_raw(&mut store, *ret_type, raw).as_jsc_value(&mut store)
+                                }).collect::<Vec<_>>();
+                                Ok(JSObject::new_array(&ctx, &result_values).unwrap().to_jsvalue())
+                            }
+                        }
+                    },
+                    #[cfg(feature = "std")]
+                    Ok(Err(err)) => {
+                        let trap = crate::backend::jsc::error::Trap::user(Box::new(err));
+                        Err(trap.into_jsc_value(&ctx))
+                    },
+                    #[cfg(feature = "core")]
+                    Ok(Err(err)) => {
+                        let trap = crate::backend::jsc::error::Trap::user(Box::new(err));
+                        Err(trap.into_jsc_value(&ctx))
+                    },
+                    Err(panic) => {
+                        Err(JSValue::string(&ctx, format!("panic: {:?}", panic)))
+                        // We can't just resume the unwind, because it will put
+                        // JavacriptCore in a bad state, so we need to transform
+                        // the error
+
+                        // std::panic::resume_unwind(panic)
+                    },
+                }
+
+            }
+            Some(fn_callback::< $( $x, )* Rets, RetsAsResult, Func> as _)
+        }
+
+
+        #[allow(non_snake_case)]
+        pub(crate) fn [<gen_fn_callback_ $c_struct_name:lower>]
+            <$( $x: FromToNativeWasmType, )* Rets: WasmTypeList, RetsAsResult: IntoResult<Rets>, T: Send + 'static,  Func: Fn(FunctionEnvMut<T>, $( $x , )*) -> RetsAsResult + 'static>
+            (this: &Func) -> crate::backend::jsc::vm::VMFunctionCallback {
+
+            #[callback]
+            fn fn_callback<T, $( $x, )* Rets, RetsAsResult, Func>(
+                ctx: JSContext,
+                function: JSObject,
+                this_object: JSObject,
+                arguments: &[JSValue],
+            ) -> Result<JSValue, JSValue>
+            where
+                $( $x: FromToNativeWasmType, )*
+                Rets: WasmTypeList,
+                RetsAsResult: IntoResult<Rets>,
+                Func: Fn(FunctionEnvMut<'_, T>, $( $x , )*) -> RetsAsResult + 'static,
+                T: Send + 'static,
+            {
+                use std::convert::TryInto;
+
+                let func: &Func = &*(&() as *const () as *const Func);
+                let global = ctx.get_global_object();
+                let store_ptr = global.get_property(&ctx, "__store_ptr".to_string()).to_number(&ctx).unwrap();
+                if store_ptr.is_nan() {
+                    panic!("Store pointer is invalid. Received {}", store_ptr as usize)
+                }
+                let mut store = StoreMut::from_raw(store_ptr as usize as *mut _);
+
+                let handle_index = arguments[0].to_number(&ctx).unwrap() as usize;
+                let handle: StoreHandle<VMFunctionEnvironment> = StoreHandle::from_internal(store.objects_mut().id(), InternalStoreHandle::from_index(handle_index).unwrap());
+                let env = crate::backend::jsc::function::env::FunctionEnv::from_handle(handle).into_mut(&mut store);
+
+                let result = panic::catch_unwind(AssertUnwindSafe(|| {
+                    type JSArray<'a> = &'a [JSValue; count_idents!( $( $x ),* )];
+                    let args_without_store: JSArray = arguments[1..].try_into().unwrap();
+                    let [ $( $x ),* ] = args_without_store;
+                    let mut store = StoreMut::from_raw(store_ptr as usize as *mut _);
+                    func(BackendFunctionEnvMut::Jsc(env).into(), $( FromToNativeWasmType::from_native( $x::Native::from_raw(&mut store, RawValue { u128: {
+                        // TODO: This may not be the fastest way, but JSC doesn't expose a BigInt interface
+                        // so the only thing we can do is parse from the string repr
+                        if $x.is_number(&ctx) {
+                            $x.to_number(&ctx).unwrap() as _
+                        }
+                        else {
+                            $x.to_string(&ctx).unwrap().to_string().parse::<u128>().unwrap()
+                        }
+                    } }) ) ),* ).into_result()
+                }));
+
+                match result {
+                    Ok(Ok(result)) => {
+                        match Rets::size() {
+                            0 => {Ok(JSValue::undefined(&ctx))},
+                            1 => {
+                                // unimplemented!();
+
+                                let ty = Rets::wasm_types()[0];
+                                let mut arr = result.into_array(&mut store);
+                                // Value::from_raw(&store, ty, arr[0])
+                                let val = Value::from_raw(&mut store, ty, arr.as_mut()[0]);
+                                let value: JSValue = val.as_jsc_value(&store);
+                                Ok(value)
+                                // *mut_rets = val.as_raw(&mut store);
+                            }
+                            _n => {
+                                // if !results.is_array(&context) {
+                                //     panic!("Expected results to be an array.")
+                                // }
+                                let mut arr = result.into_array(&mut store);
+                                let result_values = Rets::wasm_types().iter().enumerate().map(|(i, ret_type)| {
+                                    let raw = arr.as_mut()[i];
+                                    Value::from_raw(&mut store, *ret_type, raw).as_jsc_value(&mut store)
+                                }).collect::<Vec<_>>();
+                                Ok(JSObject::new_array(&ctx, &result_values).unwrap().to_jsvalue())
+                            }
+                        }
+                    },
+                    #[cfg(feature = "std")]
+                    Ok(Err(err)) => {
+                        let trap = crate::jsc::vm::Trap::user(Box::new(err));
+                        Err(trap.into_jsc_value(&ctx))
+                    },
+                    #[cfg(feature = "core")]
+                    Ok(Err(err)) => {
+                        let trap = crate::jsc::vm::Trap::user(Box::new(err));
+                        Err(trap.into_jsc_value(&ctx))
+                    },
+                    Err(panic) => {
+                        Err(JSValue::string(&ctx, format!("panic: {:?}", panic)))
+                    },
+                }
+
+            }
+
+            Some(fn_callback::<T, $( $x, )* Rets, RetsAsResult, Func> as _)
+        }
+
+        }
+    };
+}
+
+// Here we go! Let's generate all the C struct, `WasmTypeList`
+// implementations and `HostFunction` implementations.
+impl_host_function!([C] S0,);
+impl_host_function!([transparent] S1, A1);
+impl_host_function!([C] S2, A1, A2);
+impl_host_function!([C] S3, A1, A2, A3);
+impl_host_function!([C] S4, A1, A2, A3, A4);
+impl_host_function!([C] S5, A1, A2, A3, A4, A5);
+impl_host_function!([C] S6, A1, A2, A3, A4, A5, A6);
+impl_host_function!([C] S7, A1, A2, A3, A4, A5, A6, A7);
+impl_host_function!([C] S8, A1, A2, A3, A4, A5, A6, A7, A8);
+impl_host_function!([C] S9, A1, A2, A3, A4, A5, A6, A7, A8, A9);
+impl_host_function!([C] S10, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+impl_host_function!([C] S11, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
+impl_host_function!([C] S12, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
+impl_host_function!([C] S13, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
+impl_host_function!([C] S14, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
+impl_host_function!([C] S15, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
+impl_host_function!([C] S16, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16);
+impl_host_function!([C] S17, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17);
+impl_host_function!([C] S18, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18);
+impl_host_function!([C] S19, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19);
+impl_host_function!([C] S20, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20);
+impl_host_function!([C] S21, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21);
+impl_host_function!([C] S22, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22);
+impl_host_function!([C] S23, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23);
+impl_host_function!([C] S24, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24);
+impl_host_function!([C] S25, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25);
+impl_host_function!([C] S26, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26);
diff --git a/lib/api/src/jsc/typed_function.rs b/lib/api/src/backend/jsc/entities/function/typed.rs
similarity index 82%
rename from lib/api/src/jsc/typed_function.rs
rename to lib/api/src/backend/jsc/entities/function/typed.rs
index ff3cf39461..846da4e462 100644
--- a/lib/api/src/jsc/typed_function.rs
+++ b/lib/api/src/backend/jsc/entities/function/typed.rs
@@ -7,15 +7,18 @@
 //! let add_one = instance.exports.get_function("function_name")?;
 //! let add_one_native: TypedFunction<i32, i32> = add_one.typed().unwrap();
 //! ```
-use crate::jsc::as_js::{param_from_js, AsJs};
-use crate::jsc::engine::JSC;
-use crate::jsc::trap::Trap;
-use crate::native_type::NativeWasmTypeInto;
-use crate::Value;
-use crate::{AsStoreMut, TypedFunction};
-use crate::{FromToNativeWasmType, RuntimeError, WasmTypeList};
-use rusty_jsc::JSValue;
 // use std::panic::{catch_unwind, AssertUnwindSafe};
+use crate::{
+    backend::jsc::{
+        engine::IntoJSC,
+        error::Trap,
+        utils::convert::{jsc_value_to_wasmer, AsJsc},
+    },
+    AsStoreMut, FromToNativeWasmType, NativeWasmType, NativeWasmTypeInto, RuntimeError,
+    TypedFunction, Value, WasmTypeList,
+};
+
+use rusty_jsc::JSValue;
 use std::iter::FromIterator;
 use wasmer_types::RawValue;
 
@@ -29,16 +32,15 @@ macro_rules! impl_native_traits {
         {
             /// Call the typed func and return results.
             #[allow(clippy::too_many_arguments)]
-            pub fn call(&self, mut store: &mut impl AsStoreMut, $( $x: $x, )* ) -> Result<Rets, RuntimeError> where
-            $( $x: FromToNativeWasmType + NativeWasmTypeInto, )*
+            pub fn call_jsc(&self, mut store: &mut impl AsStoreMut, $( $x: $x, )* ) -> Result<Rets, RuntimeError> where
+            $( $x: FromToNativeWasmType, )*
             {
-                // let store_ptr = Value::I64(store.as_store_mut().as_raw() as _).as_jsvalue(store);
                 #[allow(unused_unsafe)]
                 let params_list: Vec<_> = unsafe {
                     vec![ $( {
-                        let raw = $x.into_raw(store);
-                        let value = Value::from_raw(&mut store, $x::WASM_TYPE, raw);
-                        value.as_jsvalue(store)
+                        let raw = $x.to_native().into_raw(store);
+                        let value = Value::from_raw(&mut store, <$x::Native as NativeWasmType>::WASM_TYPE, raw);
+                        value.as_jsc_value(store)
                     } ),* ]
                 };
 
@@ -56,7 +58,7 @@ macro_rules! impl_native_traits {
 
                         let store_mut = store.as_store_mut();
                         let context = store_mut.jsc().context();
-                        r = self.func.0.handle.function
+                        r = self.func.as_jsc().handle.function
                             .call(
                                 &context,
                                 None,
@@ -80,7 +82,7 @@ macro_rules! impl_native_traits {
                     }
                     let store_mut = store.as_store_mut();
                     let context = store_mut.jsc().context();
-                    r.map_err(|e| Trap::from_jsvalue(context, e))?
+                    r.map_err(|e| Trap::from_jsc_value(context, e))?
                 };
                 let mut rets_list_array = Rets::empty_array();
                 let mut_rets = rets_list_array.as_mut() as *mut [RawValue] as *mut RawValue;
@@ -90,7 +92,7 @@ macro_rules! impl_native_traits {
                     0 => {},
                     1 => unsafe {
                         let ty = Rets::wasm_types()[0];
-                        let val = param_from_js(&context, &ty, &results);
+                        let val = jsc_value_to_wasmer(&context, &ty, &results);
                         *mut_rets = val.as_raw(&mut store);
                     }
                     _n => {
@@ -103,7 +105,7 @@ macro_rules! impl_native_traits {
                             let context = store_mut.jsc().context();
                             let ret = results.get_property_at_index(&context, i as _).unwrap();
                             unsafe {
-                                let val = param_from_js(&context, &ret_type, &ret);
+                                let val = jsc_value_to_wasmer(&context, &ret_type, &ret);
                                 let slot = mut_rets.add(i);
                                 *slot = val.as_raw(&mut store);
                             }
@@ -112,6 +114,14 @@ macro_rules! impl_native_traits {
                 }
                 Ok(unsafe { Rets::from_array(store, rets_list_array) })
             }
+
+            #[doc(hidden)]
+            #[allow(missing_docs)]
+            #[allow(unused_mut)]
+            #[allow(clippy::too_many_arguments)]
+            pub fn call_raw_jsc(&self, store: &mut impl AsStoreMut, mut params_list: Vec<RawValue> ) -> Result<Rets, RuntimeError> {
+                todo!("Raw calls from jsc are not supported yet!")
+            }
         }
     };
 }
diff --git a/lib/api/src/jsc/externals/global.rs b/lib/api/src/backend/jsc/entities/global.rs
similarity index 56%
rename from lib/api/src/jsc/externals/global.rs
rename to lib/api/src/backend/jsc/entities/global.rs
index ca83f52992..e0a35269bc 100644
--- a/lib/api/src/jsc/externals/global.rs
+++ b/lib/api/src/backend/jsc/entities/global.rs
@@ -1,15 +1,18 @@
-use crate::errors::RuntimeError;
-use crate::jsc::as_js::param_from_js;
-use crate::jsc::as_js::AsJs;
-use crate::store::{AsStoreMut, AsStoreRef};
-use crate::value::Value;
-use crate::vm::{VMExtern, VMGlobal};
-use crate::GlobalType;
-use crate::Mutability;
 use rusty_jsc::{JSObject, JSValue};
-use wasmer_types::{RawValue, Type};
+use wasmer_types::{GlobalType, Mutability, Type};
 
-#[derive(Debug, Clone, PartialEq)]
+use crate::{
+    jsc::{
+        utils::convert::{jsc_value_to_wasmer, AsJsc},
+        vm::VMGlobal,
+    },
+    vm::VMExtern,
+    AsStoreMut, AsStoreRef, BackendGlobal, RuntimeError, Value,
+};
+
+use super::store::StoreObject;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Global {
     pub(crate) handle: VMGlobal,
 }
@@ -20,7 +23,9 @@ pub struct Global {
 
 impl Global {
     pub(crate) fn to_vm_extern(&self) -> VMExtern {
-        VMExtern::Global(self.handle.clone())
+        VMExtern::Jsc(crate::backend::jsc::vm::VMExtern::Global(
+            self.handle.clone(),
+        ))
     }
 
     /// Create a `Global` with the initial value [`Value`] and the provided [`Mutability`].
@@ -38,7 +43,7 @@ impl Global {
         };
         let store_mut = store.as_store_mut();
         let engine = store_mut.engine();
-        let context = engine.0.context();
+        let context = engine.as_jsc().context();
 
         let mut descriptor = JSObject::new(&context);
         let type_str = match val.ty() {
@@ -64,14 +69,16 @@ impl Global {
             JSValue::boolean(&context, mutability.is_mutable()),
         );
 
-        let value: JSValue = val.as_jsvalue(&store_mut);
+        let value: JSValue = val.as_jsc_value(&store_mut);
         let js_global = engine
-            .0
+            .as_jsc()
             .wasm_global_type()
             .construct(&context, &[descriptor.to_jsvalue(), value])
             .map_err(|e| <JSValue as Into<RuntimeError>>::into(e))?;
         let vm_global = VMGlobal::new(js_global, global_ty);
-        Ok(Self::from_vm_extern(store, vm_global))
+        crate::backend::jsc::vm::VMGlobal::list_mut(store.objects_mut().as_jsc_mut())
+            .push(vm_global.clone());
+        Ok(Self { handle: vm_global })
     }
 
     pub fn ty(&self, _store: &impl AsStoreRef) -> GlobalType {
@@ -81,32 +88,63 @@ impl Global {
     pub fn get(&self, store: &mut impl AsStoreMut) -> Value {
         let store_mut = store.as_store_mut();
         let engine = store_mut.engine();
-        let context = engine.0.context();
+        let context = engine.as_jsc().context();
         let value = self
             .handle
             .global
             .get_property(&context, "value".to_string());
-        param_from_js(&context, &self.handle.ty.ty, &value)
+        jsc_value_to_wasmer(&context, &self.handle.ty.ty, &value)
     }
 
     pub fn set(&self, store: &mut impl AsStoreMut, val: Value) -> Result<(), RuntimeError> {
         let store_mut = store.as_store_mut();
-        let new_value = val.as_jsvalue(&store_mut);
+        let new_value = val.as_jsc_value(&store_mut);
         let engine = store_mut.engine();
-        let context = engine.0.context();
+        let context = engine.as_jsc().context();
         self.handle
             .global
             .set_property(&context, "value".to_string(), new_value)
             .map_err(|e| <JSValue as Into<RuntimeError>>::into(e))
     }
 
-    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_global: VMGlobal) -> Self {
-        use crate::jsc::store::StoreObject;
-        VMGlobal::list_mut(store.objects_mut()).push(vm_global.clone());
-        Self { handle: vm_global }
+    pub(crate) fn from_vm_extern(
+        store: &mut impl AsStoreMut,
+        vm_global: crate::vm::VMExternGlobal,
+    ) -> Self {
+        crate::backend::jsc::vm::VMGlobal::list_mut(store.objects_mut().as_jsc_mut())
+            .push(vm_global.as_jsc().clone());
+        Self {
+            handle: vm_global.into_jsc(),
+        }
     }
 
     pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
         true
     }
 }
+
+impl crate::Global {
+    /// Consume [`self`] into [`crate::backend::jsc::global::Global`].
+    pub fn into_jsc(self) -> crate::backend::jsc::global::Global {
+        match self.0 {
+            BackendGlobal::Jsc(s) => s,
+            _ => panic!("Not a `jsc` global!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::jsc::global::Global`].
+    pub fn as_jsc(&self) -> &crate::backend::jsc::global::Global {
+        match self.0 {
+            BackendGlobal::Jsc(ref s) => s,
+            _ => panic!("Not a `jsc` global!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::jsc::global::Global`].
+    pub fn as_jsc_mut(&mut self) -> &mut crate::backend::jsc::global::Global {
+        match self.0 {
+            BackendGlobal::Jsc(ref mut s) => s,
+            _ => panic!("Not a `jsc` global!"),
+        }
+    }
+}
diff --git a/lib/api/src/jsc/instance.rs b/lib/api/src/backend/jsc/entities/instance.rs
similarity index 63%
rename from lib/api/src/jsc/instance.rs
rename to lib/api/src/backend/jsc/entities/instance.rs
index 614eb76e75..f7074dcf74 100644
--- a/lib/api/src/jsc/instance.rs
+++ b/lib/api/src/backend/jsc/entities/instance.rs
@@ -1,12 +1,9 @@
-use crate::errors::InstantiationError;
-use crate::exports::Exports;
-use crate::imports::Imports;
-use crate::jsc::as_js::AsJs;
-use crate::jsc::engine::JSC;
-use crate::jsc::vm::VMInstance;
-use crate::module::Module;
-use crate::store::AsStoreMut;
-use crate::Extern;
+use crate::{
+    jsc::{utils::convert::AsJsc, vm::VMInstance},
+    AsStoreMut, BackendInstance, Exports, Extern, Imports, InstantiationError, Module,
+};
+
+use super::engine::IntoJSC;
 
 #[derive(Clone, PartialEq, Eq)]
 pub struct Instance {
@@ -24,7 +21,7 @@ impl Instance {
         imports: &Imports,
     ) -> Result<(Self, Exports), InstantiationError> {
         let instance = module
-            .0
+            .as_jsc()
             .instantiate(&mut store, imports)
             .map_err(|e| InstantiationError::Start(e))?;
 
@@ -67,7 +64,7 @@ impl Instance {
                 let extern_type = export_type.ty();
                 // Annotation is here to prevent spurious IDE warnings.
                 let js_export = instance_exports.get_property(&context, name.to_string());
-                let extern_ = Extern::from_jsvalue(&mut store, extern_type, &js_export).unwrap();
+                let extern_ = Extern::from_jsc_value(&mut store, extern_type, &js_export).unwrap();
                 Ok((name.to_string(), extern_))
             })
             .collect::<Result<Exports, InstantiationError>>()?;
@@ -75,3 +72,29 @@ impl Instance {
         Ok((Self { _handle: instance }, exports))
     }
 }
+
+impl crate::Instance {
+    /// Consume [`self`] into [`crate::backend::jsc::instance::Instance`].
+    pub fn into_jsc(self) -> crate::backend::jsc::instance::Instance {
+        match self._inner {
+            BackendInstance::Jsc(s) => s,
+            _ => panic!("Not a `jsc` global!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference to [`crate::backend::jsc::instance::Instance`].
+    pub fn as_jsc(&self) -> &crate::backend::jsc::instance::Instance {
+        match self._inner {
+            BackendInstance::Jsc(ref s) => s,
+            _ => panic!("Not a `jsc` global!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference to [`crate::backend::jsc::instance::Instance`].
+    pub fn as_jsc_mut(&mut self) -> &mut crate::backend::jsc::instance::Instance {
+        match self._inner {
+            BackendInstance::Jsc(ref mut s) => s,
+            _ => panic!("Not a `jsc` global!"),
+        }
+    }
+}
diff --git a/lib/api/src/backend/jsc/entities/memory/buffer.rs b/lib/api/src/backend/jsc/entities/memory/buffer.rs
new file mode 100644
index 0000000000..ef0846974c
--- /dev/null
+++ b/lib/api/src/backend/jsc/entities/memory/buffer.rs
@@ -0,0 +1,139 @@
+use std::{marker::PhantomData, mem::MaybeUninit};
+
+use tracing::warn;
+
+use crate::MemoryAccessError;
+
+use super::MemoryView;
+
+/// Underlying buffer for a memory.
+#[derive(Debug, Copy, Clone)]
+pub(crate) struct MemoryBuffer<'a> {
+    pub(crate) base: *mut u8,
+    pub(crate) len: usize,
+    pub(crate) marker: PhantomData<&'a MemoryView<'a>>,
+}
+
+impl<'a> MemoryBuffer<'a> {
+    pub(crate) fn read(&self, offset: u64, buf: &mut [u8]) -> Result<(), MemoryAccessError> {
+        let end = offset
+            .checked_add(buf.len() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        if end > self.len.try_into().unwrap() {
+            warn!(
+                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
+                buf.len(),
+                end,
+                self.len
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        unsafe {
+            volatile_memcpy_read(self.base.add(offset as usize), buf.as_mut_ptr(), buf.len());
+        }
+        Ok(())
+    }
+
+    pub(crate) fn read_uninit<'b>(
+        &self,
+        offset: u64,
+        buf: &'b mut [MaybeUninit<u8>],
+    ) -> Result<&'b mut [u8], MemoryAccessError> {
+        let end = offset
+            .checked_add(buf.len() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        if end > self.len.try_into().unwrap() {
+            warn!(
+                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
+                buf.len(),
+                end,
+                self.len
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        let buf_ptr = buf.as_mut_ptr() as *mut u8;
+        unsafe {
+            volatile_memcpy_read(self.base.add(offset as usize), buf_ptr, buf.len());
+        }
+
+        Ok(unsafe { std::slice::from_raw_parts_mut(buf_ptr, buf.len()) })
+    }
+
+    pub(crate) fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
+        let end = offset
+            .checked_add(data.len() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        if end > self.len.try_into().unwrap() {
+            warn!(
+                "attempted to write ({} bytes) beyond the bounds of the memory view ({} > {})",
+                data.len(),
+                end,
+                self.len
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        unsafe {
+            volatile_memcpy_write(data.as_ptr(), self.base.add(offset as usize), data.len());
+        }
+        Ok(())
+    }
+}
+// We can't use a normal memcpy here because it has undefined behavior if the
+// memory is being concurrently modified. So we need to write our own memcpy
+// implementation which uses volatile operations.
+//
+// The implementation of these functions can optimize very well when inlined
+// with a fixed length: they should compile down to a single load/store
+// instruction for small (8/16/32/64-bit) copies.
+#[inline]
+unsafe fn volatile_memcpy_read(mut src: *const u8, mut dst: *mut u8, mut len: usize) {
+    #[inline]
+    unsafe fn copy_one<T>(src: &mut *const u8, dst: &mut *mut u8, len: &mut usize) {
+        #[repr(packed)]
+        struct Unaligned<T>(T);
+        let val = (*src as *const Unaligned<T>).read_volatile();
+        (*dst as *mut Unaligned<T>).write(val);
+        *src = src.add(std::mem::size_of::<T>());
+        *dst = dst.add(std::mem::size_of::<T>());
+        *len -= std::mem::size_of::<T>();
+    }
+
+    while len >= 8 {
+        copy_one::<u64>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 4 {
+        copy_one::<u32>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 2 {
+        copy_one::<u16>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 1 {
+        copy_one::<u8>(&mut src, &mut dst, &mut len);
+    }
+}
+#[inline]
+unsafe fn volatile_memcpy_write(mut src: *const u8, mut dst: *mut u8, mut len: usize) {
+    #[inline]
+    unsafe fn copy_one<T>(src: &mut *const u8, dst: &mut *mut u8, len: &mut usize) {
+        #[repr(packed)]
+        struct Unaligned<T>(T);
+        let val = (*src as *const Unaligned<T>).read();
+        (*dst as *mut Unaligned<T>).write_volatile(val);
+        *src = src.add(std::mem::size_of::<T>());
+        *dst = dst.add(std::mem::size_of::<T>());
+        *len -= std::mem::size_of::<T>();
+    }
+
+    while len >= 8 {
+        copy_one::<u64>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 4 {
+        copy_one::<u32>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 2 {
+        copy_one::<u16>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 1 {
+        copy_one::<u8>(&mut src, &mut dst, &mut len);
+    }
+}
diff --git a/lib/api/src/backend/jsc/entities/memory/mod.rs b/lib/api/src/backend/jsc/entities/memory/mod.rs
new file mode 100644
index 0000000000..1ef1b4249b
--- /dev/null
+++ b/lib/api/src/backend/jsc/entities/memory/mod.rs
@@ -0,0 +1,257 @@
+pub(crate) mod view;
+pub(crate) use view::*;
+
+pub(crate) mod buffer;
+pub(crate) use buffer::*;
+
+use crate::{jsc::vm::VMMemory, vm::VMExtern, AsStoreMut, AsStoreRef, BackendMemory};
+use rusty_jsc::{JSObject, JSValue};
+use wasmer_types::{MemoryError, MemoryType, Pages};
+
+#[derive(Debug, Clone)]
+pub struct Memory {
+    pub(crate) handle: VMMemory,
+}
+
+// Only SharedMemories can be Send in js, becuase they support `structuredClone`.
+// Normal memories will fail while doing structuredClone.
+// In this case, we implement Send just in case as it can be a shared memory.
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// ```js
+// const memory = new WebAssembly.Memory({
+//   initial: 10,
+//   maximum: 100,
+//   shared: true // <--- It must be shared, otherwise structuredClone will fail
+// });
+// structuredClone(memory)
+// ```
+unsafe impl Send for Memory {}
+unsafe impl Sync for Memory {}
+
+impl Memory {
+    pub fn new(store: &mut impl AsStoreMut, ty: MemoryType) -> Result<Self, MemoryError> {
+        let handle = VMMemory::new(Self::js_memory_from_type(store, &ty)?, ty);
+        Ok(Self { handle })
+    }
+
+    pub(crate) fn js_memory_from_type(
+        store: &impl AsStoreRef,
+        ty: &MemoryType,
+    ) -> Result<JSObject, MemoryError> {
+        let store_ref = store.as_store_ref();
+        let engine = store_ref.engine();
+        let context = engine.as_jsc().context();
+
+        let mut descriptor = JSObject::new(&context);
+        descriptor.set_property(
+            &context,
+            "initial".to_string(),
+            JSValue::number(&context, ty.minimum.0.into()),
+        );
+        if let Some(max) = ty.maximum {
+            descriptor.set_property(
+                &context,
+                "maximum".to_string(),
+                JSValue::number(&context, max.0.into()),
+            );
+        }
+        descriptor.set_property(
+            &context,
+            "shared".to_string(),
+            JSValue::boolean(&context, ty.shared),
+        );
+
+        engine
+            .as_jsc()
+            .wasm_memory_type()
+            .construct(&context, &[descriptor.to_jsvalue()])
+            .map_err(|e| MemoryError::Generic(format!("{:?}", e)))
+    }
+
+    pub fn new_from_existing(new_store: &mut impl AsStoreMut, memory: VMMemory) -> Self {
+        Self {
+            handle: memory.clone(),
+        }
+    }
+
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Jsc(crate::backend::jsc::vm::VMExtern::Memory(
+            self.handle.clone(),
+        ))
+    }
+
+    pub fn ty(&self, _store: &impl AsStoreRef) -> MemoryType {
+        self.handle.ty
+    }
+
+    pub fn view<'a>(&self, store: &'a impl AsStoreRef) -> MemoryView<'a> {
+        MemoryView::new(self, store)
+    }
+
+    pub fn size(&self, store: &impl AsStoreRef) -> Pages {
+        let store_ref = store.as_store_ref();
+        let engine = store_ref.engine();
+        let context = engine.as_jsc().context();
+
+        let js_memory = &self.handle.memory;
+        let buffer = js_memory
+            .get_property(context, "buffer")
+            .to_object(context)
+            .unwrap();
+        let byte_length = buffer
+            .get_property(context, "byteLength")
+            .to_number(context)
+            .unwrap() as u32;
+        Pages(byte_length.div_ceil(wasmer_types::WASM_PAGE_SIZE as u32))
+    }
+
+    pub fn grow<IntoPages>(
+        &self,
+        store: &mut impl AsStoreMut,
+        delta: IntoPages,
+    ) -> Result<Pages, MemoryError>
+    where
+        IntoPages: Into<Pages>,
+    {
+        let pages = delta.into();
+
+        let store_mut = store.as_store_mut();
+        let engine = store_mut.engine();
+        let context = engine.as_jsc().context();
+        let func = self
+            .handle
+            .memory
+            .get_property(&context, "grow".to_string())
+            .to_object(&context)
+            .unwrap();
+        match func.call(
+            &context,
+            Some(&self.handle.memory),
+            &[JSValue::number(&context, pages.0 as _)],
+        ) {
+            Ok(val) => Ok(Pages(val.to_number(&context).unwrap() as _)),
+            Err(e) => {
+                let old_pages = pages;
+                Err(MemoryError::CouldNotGrow {
+                    current: old_pages,
+                    attempted_delta: pages,
+                })
+            }
+        }
+    }
+
+    pub fn grow_at_least(
+        &self,
+        store: &mut impl AsStoreMut,
+        min_size: u64,
+    ) -> Result<(), MemoryError> {
+        let cur_size = self.view(store).data_size();
+        if min_size > cur_size {
+            let delta = min_size - cur_size;
+            let pages = ((delta - 1) / wasmer_types::WASM_PAGE_SIZE as u64) + 1;
+
+            self.grow(store, Pages(pages as u32))?;
+        }
+        Ok(())
+    }
+
+    pub fn reset(&self, _store: &mut impl AsStoreMut) -> Result<(), MemoryError> {
+        Ok(())
+    }
+
+    pub fn copy_to_store(
+        &self,
+        store: &impl AsStoreRef,
+        new_store: &mut impl AsStoreMut,
+    ) -> Result<Self, MemoryError> {
+        let view = self.view(store);
+        let ty = self.ty(store);
+        let amount = view.data_size() as usize;
+
+        let new_memory = Self::new(new_store, ty)?;
+        let mut new_view = new_memory.view(&new_store);
+        let new_view_size = new_view.data_size() as usize;
+        if amount > new_view_size {
+            let delta = amount - new_view_size;
+            let pages = ((delta - 1) / wasmer_types::WASM_PAGE_SIZE) + 1;
+            new_memory.grow(new_store, Pages(pages as u32))?;
+            new_view = new_memory.view(&new_store);
+        }
+
+        // Copy the bytes
+        view.copy_to_memory(amount as u64, &new_view)
+            .map_err(|err| MemoryError::Generic(err.to_string()))?;
+        // // Return the new memory
+        Ok(new_memory)
+    }
+
+    pub(crate) fn from_vm_extern(
+        _store: &mut impl AsStoreMut,
+        internal: crate::vm::VMExternMemory,
+    ) -> Self {
+        Self {
+            handle: internal.into_jsc(),
+        }
+    }
+
+    /// Cloning memory will create another reference to the same memory that
+    /// can be put into a new store
+    pub fn try_clone(&self, _store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
+        self.handle.try_clone()
+    }
+
+    /// Copying the memory will actually copy all the bytes in the memory to
+    /// a identical byte copy of the original that can be put into a new store
+    pub fn try_copy(&self, store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
+        let mut cloned = self.try_clone(store)?;
+        cloned.copy(store)
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+
+    #[allow(unused)]
+    pub fn duplicate(&mut self, store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
+        self.handle.copy(store)
+    }
+
+    pub fn as_shared(&self, _store: &impl AsStoreRef) -> Option<crate::shared::SharedMemory> {
+        // Not supported.
+        None
+    }
+}
+
+impl std::cmp::PartialEq for Memory {
+    fn eq(&self, other: &Self) -> bool {
+        self.handle == other.handle
+    }
+}
+
+impl std::cmp::Eq for Memory {}
+
+impl crate::Memory {
+    /// Consume [`self`] into a [`crate::backend::jsc::mem::Memory`].
+    pub fn into_jsc(self) -> crate::backend::jsc::memory::Memory {
+        match self.0 {
+            BackendMemory::Jsc(s) => s,
+            _ => panic!("Not a `jsc` memory!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference to [`crate::backend::jsc::mem::Memory`].
+    pub fn as_jsc(&self) -> &crate::backend::jsc::memory::Memory {
+        match self.0 {
+            BackendMemory::Jsc(ref s) => s,
+            _ => panic!("Not a `jsc` memory!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference to [`crate::backend::jsc::mem::Memory`].
+    pub fn as_jsc_mut(&mut self) -> &mut crate::backend::jsc::memory::Memory {
+        match self.0 {
+            BackendMemory::Jsc(ref mut s) => s,
+            _ => panic!("Not a `jsc` memory!"),
+        }
+    }
+}
diff --git a/lib/api/src/jsc/externals/memory_view.rs b/lib/api/src/backend/jsc/entities/memory/view.rs
similarity index 93%
rename from lib/api/src/jsc/externals/memory_view.rs
rename to lib/api/src/backend/jsc/entities/memory/view.rs
index bb891293f2..cfdae79c29 100644
--- a/lib/api/src/jsc/externals/memory_view.rs
+++ b/lib/api/src/backend/jsc/entities/memory/view.rs
@@ -1,15 +1,11 @@
-use crate::store::AsStoreRef;
-use crate::MemoryAccessError;
+use std::{marker::PhantomData, mem::MaybeUninit, ops::Range};
+
+use super::{Memory, MemoryBuffer};
+use crate::{AsStoreRef, MemoryAccessError};
+
 use rusty_jsc::JSObject;
-use std::convert::TryFrom;
-use std::marker::PhantomData;
-use std::mem::MaybeUninit;
-use std::slice;
-use std::{convert::TryInto, ops::Range};
 use wasmer_types::{Bytes, Pages};
 
-use super::memory::{Memory, MemoryBuffer};
-
 /// A WebAssembly `memory` view.
 ///
 /// A memory view is used to read and write to the linear memory.
@@ -19,7 +15,6 @@ use super::memory::{Memory, MemoryBuffer};
 #[derive(Debug)]
 pub struct MemoryView<'a> {
     pub(crate) buffer: MemoryBuffer<'a>,
-    // pub(crate) size: Pages,
 }
 
 impl<'a> MemoryView<'a> {
@@ -30,7 +25,7 @@ impl<'a> MemoryView<'a> {
     pub(crate) fn new_raw(memory: &JSObject, store: &'a (impl AsStoreRef + ?Sized)) -> Self {
         let store_ref = store.as_store_ref();
         let engine = store_ref.engine();
-        let context = engine.0.context();
+        let context = engine.as_jsc().context();
 
         let buffer = memory
             .get_property(&context, "buffer".to_string())
@@ -55,7 +50,7 @@ impl<'a> MemoryView<'a> {
 
     /// Returns the pointer to the raw bytes of the `Memory`.
     //
-    // This used by wasmer-emscripten and wasmer-c-api, but should be treated
+    // This used by wasmer-c-api, but should be treated
     // as deprecated and not used in future code.
     #[doc(hidden)]
     pub fn data_ptr(&self) -> *mut u8 {
@@ -91,7 +86,7 @@ impl<'a> MemoryView<'a> {
     #[allow(clippy::mut_from_ref)]
     #[doc(hidden)]
     pub unsafe fn data_unchecked_mut(&self) -> &mut [u8] {
-        slice::from_raw_parts_mut(self.buffer.base, self.buffer.len)
+        std::slice::from_raw_parts_mut(self.buffer.base, self.buffer.len)
     }
 
     /// Returns the size (in [`Pages`]) of the `Memory`.
diff --git a/lib/api/src/backend/jsc/entities/mod.rs b/lib/api/src/backend/jsc/entities/mod.rs
new file mode 100644
index 0000000000..ce7a5e6d7c
--- /dev/null
+++ b/lib/api/src/backend/jsc/entities/mod.rs
@@ -0,0 +1,11 @@
+pub(crate) mod engine;
+pub(crate) mod exception;
+pub(crate) mod external;
+pub(crate) mod function;
+pub(crate) mod global;
+pub(crate) mod instance;
+pub(crate) mod memory;
+pub(crate) mod module;
+pub(crate) mod store;
+pub(crate) mod table;
+pub(crate) mod tag;
diff --git a/lib/api/src/jsc/module.rs b/lib/api/src/backend/jsc/entities/module.rs
similarity index 78%
rename from lib/api/src/jsc/module.rs
rename to lib/api/src/backend/jsc/entities/module.rs
index 08146f4ad7..8cdc47be67 100644
--- a/lib/api/src/jsc/module.rs
+++ b/lib/api/src/backend/jsc/entities/module.rs
@@ -1,23 +1,21 @@
-use crate::errors::InstantiationError;
-use crate::errors::RuntimeError;
-use crate::imports::Imports;
-use crate::jsc::as_js::AsJs;
-use crate::jsc::engine::JSC;
-use crate::store::AsStoreMut;
-use crate::store::AsStoreRef;
-use crate::vm::VMInstance;
-use crate::Extern;
-use crate::IntoBytes;
-use crate::{AsEngineRef, ExportType, ImportType};
-use bytes::Bytes;
-use rusty_jsc::{JSObject, JSString, JSValue};
 use std::path::Path;
-use tracing::{debug, warn};
+
+use bytes::Bytes;
+use rusty_jsc::{JSObject, JSValue};
+use tracing::warn;
 use wasmer_types::{
-    CompileError, DeserializeError, ExportsIterator, ExternType, FunctionType, GlobalType,
-    ImportsIterator, MemoryType, ModuleInfo, Mutability, Pages, SerializeError, TableType, Type,
+    CompileError, DeserializeError, ExportType, ExportsIterator, ImportType, ImportsIterator,
+    ModuleInfo, SerializeError,
+};
+
+use crate::{
+    jsc::{utils::convert::AsJsc, vm::VMInstance},
+    AsEngineRef, AsStoreMut, AsStoreRef, BackendModule, Imports, InstantiationError, IntoBytes,
+    RuntimeError,
 };
 
+use super::engine::IntoJSC;
+
 #[derive(Clone, PartialEq, Eq)]
 pub struct Module {
     module: JSObject,
@@ -69,7 +67,7 @@ impl Module {
         let binary = binary.into_bytes();
 
         // The module is now validated, so we can safely parse it's types
-        let info = crate::module_info_polyfill::translate_module(&binary[..])
+        let info = crate::utils::polyfill::translate_module(&binary[..])
             .unwrap()
             .info;
 
@@ -135,7 +133,7 @@ impl Module {
                     obj_val.set_property(
                         &context,
                         import_type.name().to_string(),
-                        import.as_jsvalue(&store.as_store_ref()),
+                        import.as_jsc_value(&store.as_store_ref()),
                     );
                 } else {
                     // If the namespace doesn't exist
@@ -143,7 +141,7 @@ impl Module {
                     import_namespace.set_property(
                         &context,
                         import_type.name().to_string(),
-                        import.as_jsvalue(&store.as_store_ref()),
+                        import.as_jsc_value(&store.as_store_ref()),
                     );
                     imports_object
                         .set_property(
@@ -218,15 +216,18 @@ impl Module {
         true
     }
 
-    pub fn imports<'a>(&'a self) -> ImportsIterator<impl Iterator<Item = ImportType> + 'a> {
+    pub fn imports<'a>(&'a self) -> ImportsIterator<Box<dyn Iterator<Item = ImportType> + 'a>> {
         self.info().imports()
     }
 
-    pub fn exports<'a>(&'a self) -> ExportsIterator<impl Iterator<Item = ExportType> + 'a> {
+    pub fn exports<'a>(&'a self) -> ExportsIterator<Box<dyn Iterator<Item = ExportType> + 'a>> {
         self.info().exports()
     }
 
-    pub fn custom_sections<'a>(&'a self, name: &'a str) -> impl Iterator<Item = Box<[u8]>> + 'a {
+    pub fn custom_sections<'a>(
+        &'a self,
+        name: &'a str,
+    ) -> Box<dyn Iterator<Item = Box<[u8]>> + 'a> {
         self.info().custom_sections(name)
     }
 
@@ -235,26 +236,28 @@ impl Module {
     }
 }
 
-// impl From<WebAssembly::Module> for Module {
-//     fn from(module: WebAssembly::Module) -> Module {
-//         Module {
-//             module,
-//             name: None,
-//             type_hints: None,
-//             #[cfg(feature = "js-serializable-module")]
-//             raw_bytes: None,
-//         }
-//     }
-// }
-
-// impl<T: IntoBytes> From<(WebAssembly::Module, T)> for crate::module::Module {
-//     fn from((module, binary): (WebAssembly::Module, T)) -> crate::module::Module {
-//         unsafe { crate::module::Module(Module::from_js_module(module, binary.into_bytes())) }
-//     }
-// }
-
-// impl From<WebAssembly::Module> for crate::module::Module {
-//     fn from(module: WebAssembly::Module) -> crate::module::Module {
-//         crate::module::Module(module.into())
-//     }
-// }
+impl crate::Module {
+    /// Consume [`self`] into a reference [`crate::backend::jsc::module::Module`].
+    pub fn into_jsc(self) -> crate::backend::jsc::module::Module {
+        match self.0 {
+            BackendModule::Jsc(s) => s,
+            _ => panic!("Not a `jsc` module!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::jsc::module::Module`].
+    pub fn as_jsc(&self) -> &crate::backend::jsc::module::Module {
+        match self.0 {
+            BackendModule::Jsc(ref s) => s,
+            _ => panic!("Not a `jsc` module!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::jsc::module::Module`].
+    pub fn as_jsc_mut(&mut self) -> &mut crate::backend::jsc::module::Module {
+        match self.0 {
+            BackendModule::Jsc(ref mut s) => s,
+            _ => panic!("Not a `jsc` module!"),
+        }
+    }
+}
diff --git a/lib/api/src/backend/jsc/entities/store/handle.rs b/lib/api/src/backend/jsc/entities/store/handle.rs
new file mode 100644
index 0000000000..9e3903b448
--- /dev/null
+++ b/lib/api/src/backend/jsc/entities/store/handle.rs
@@ -0,0 +1,158 @@
+use std::{marker::PhantomData, num::NonZeroUsize};
+
+use wasmer_types::StoreId;
+
+use super::{StoreObject, StoreObjects};
+
+/// Handle to an object managed by a context.
+///
+/// Internally this is just an integer index into a context. A reference to the
+/// context must be passed in separately to access the actual object.
+pub struct StoreHandle<T> {
+    id: StoreId,
+    internal: InternalStoreHandle<T>,
+}
+
+impl<T> core::cmp::PartialEq for StoreHandle<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+
+impl<T> std::hash::Hash for StoreHandle<T> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.id.hash(state);
+        self.internal.idx.hash(state);
+    }
+}
+
+impl<T> Clone for StoreHandle<T> {
+    fn clone(&self) -> Self {
+        Self {
+            id: self.id,
+            internal: self.internal,
+        }
+    }
+}
+
+impl<T: StoreObject> std::fmt::Debug for StoreHandle<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("StoreHandle")
+            .field("id", &self.id)
+            .field("internal", &self.internal.index())
+            .finish()
+    }
+}
+
+impl<T: StoreObject> StoreHandle<T> {
+    /// Moves the given object into a context and returns a handle to it.
+    pub fn new(store: &mut StoreObjects, val: T) -> Self {
+        Self {
+            id: store.id(),
+            internal: InternalStoreHandle::new(store, val),
+        }
+    }
+
+    /// Returns a reference to the object that this handle points to.
+    pub fn get<'a>(&self, store: &'a StoreObjects) -> &'a T {
+        assert_eq!(self.id, store.id(), "object used with the wrong context");
+        self.internal.get(store)
+    }
+
+    /// Returns a mutable reference to the object that this handle points to.
+    pub fn get_mut<'a>(&self, store: &'a mut StoreObjects) -> &'a mut T {
+        assert_eq!(self.id, store.id(), "object used with the wrong context");
+        self.internal.get_mut(store)
+    }
+
+    /// Returns the internal handle contains within this handle.
+    pub fn internal_handle(&self) -> InternalStoreHandle<T> {
+        self.internal
+    }
+
+    /// Returns the ID of the context associated with the handle.
+    #[allow(unused)]
+    pub fn store_id(&self) -> StoreId {
+        self.id
+    }
+
+    /// Overrides the store id with a new ID
+    #[allow(unused)]
+    pub fn set_store_id(&mut self, id: StoreId) {
+        self.id = id;
+    }
+
+    /// Constructs a `StoreHandle` from a `StoreId` and an `InternalStoreHandle`.
+    ///
+    /// # Safety
+    /// Handling `InternalStoreHandle` values is unsafe because they do not track context ID.
+    pub unsafe fn from_internal(id: StoreId, internal: InternalStoreHandle<T>) -> Self {
+        Self { id, internal }
+    }
+}
+
+/// Internal handle to an object owned by the current context.
+///
+/// Unlike `StoreHandle` this does not track the context ID: it is only
+/// intended to be used within objects already owned by a context.
+#[repr(transparent)]
+pub struct InternalStoreHandle<T> {
+    // Use a NonZero here to reduce the size of Option<InternalStoreHandle>.
+    idx: NonZeroUsize,
+    marker: PhantomData<fn() -> T>,
+}
+
+impl<T> Clone for InternalStoreHandle<T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl<T> Copy for InternalStoreHandle<T> {}
+
+impl<T> std::fmt::Debug for InternalStoreHandle<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("InternalStoreHandle")
+            .field("idx", &self.idx)
+            .finish()
+    }
+}
+impl<T> PartialEq for InternalStoreHandle<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.idx == other.idx
+    }
+}
+impl<T> Eq for InternalStoreHandle<T> {}
+
+impl<T: StoreObject> InternalStoreHandle<T> {
+    /// Moves the given object into a context and returns a handle to it.
+    pub fn new(store: &mut StoreObjects, val: T) -> Self {
+        let list = T::list_mut(store);
+        let idx = NonZeroUsize::new(list.len() + 1).unwrap();
+        list.push(val);
+        Self {
+            idx,
+            marker: PhantomData,
+        }
+    }
+
+    /// Returns a reference to the object that this handle points to.
+    pub fn get<'a>(&self, store: &'a StoreObjects) -> &'a T {
+        &T::list(store)[self.idx.get() - 1]
+    }
+
+    /// Returns a mutable reference to the object that this handle points to.
+    pub fn get_mut<'a>(&self, store: &'a mut StoreObjects) -> &'a mut T {
+        &mut T::list_mut(store)[self.idx.get() - 1]
+    }
+
+    pub(crate) fn index(&self) -> usize {
+        self.idx.get()
+    }
+
+    pub(crate) fn from_index(idx: usize) -> Option<Self> {
+        NonZeroUsize::new(idx).map(|idx| Self {
+            idx,
+            marker: PhantomData,
+        })
+    }
+}
diff --git a/lib/api/src/backend/jsc/entities/store/mod.rs b/lib/api/src/backend/jsc/entities/store/mod.rs
new file mode 100644
index 0000000000..8482e7522a
--- /dev/null
+++ b/lib/api/src/backend/jsc/entities/store/mod.rs
@@ -0,0 +1,84 @@
+pub(crate) mod handle;
+pub(crate) mod obj;
+
+pub(crate) use handle::*;
+pub(crate) use obj::*;
+
+use crate::{AsEngineRef, Engine, EngineRef};
+
+#[derive(Debug)]
+pub(crate) struct Store {
+    pub(crate) engine: Engine,
+}
+
+impl Store {
+    pub(crate) fn new(engine: Engine) -> Self {
+        Self { engine }
+    }
+
+    pub(crate) fn engine(&self) -> &Engine {
+        &self.engine
+    }
+
+    pub(crate) fn engine_mut(&mut self) -> &mut Engine {
+        &mut self.engine
+    }
+}
+
+impl AsEngineRef for Store {
+    fn as_engine_ref(&self) -> EngineRef<'_> {
+        EngineRef::new(&self.engine)
+    }
+}
+
+impl crate::BackendStore {
+    /// Consume [`self`] into [`crate::backend::jsc::store::Store`].
+    pub fn into_jsc(self) -> crate::backend::jsc::store::Store {
+        match self {
+            Self::Jsc(s) => s,
+            _ => panic!("Not a `jsc` store!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::jsc::store::Store`].
+    pub fn as_jsc(&self) -> &crate::backend::jsc::store::Store {
+        match self {
+            Self::Jsc(s) => s,
+            _ => panic!("Not a `jsc` store!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::jsc::store::Store`].
+    pub fn as_jsc_mut(&mut self) -> &mut crate::backend::jsc::store::Store {
+        match self {
+            Self::Jsc(s) => s,
+            _ => panic!("Not a `jsc` store!"),
+        }
+    }
+    /// Return true if [`self`] is a store from the `jsc` runtime.
+    pub fn is_jsc(&self) -> bool {
+        matches!(self, Self::Jsc(_))
+    }
+}
+
+impl crate::Store {
+    /// Consume [`self`] into [`crate::backend::jsc::store::Store`].
+    pub(crate) fn into_jsc(self) -> crate::backend::jsc::store::Store {
+        self.inner.store.into_jsc()
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::jsc::store::Store`].
+    pub(crate) fn as_jsc(&self) -> &crate::backend::jsc::store::Store {
+        self.inner.store.as_jsc()
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::jsc::store::Store`].
+    pub(crate) fn as_jsc_mut(&mut self) -> &mut crate::backend::jsc::store::Store {
+        self.inner.store.as_jsc_mut()
+    }
+
+    /// Return true if [`self`] is a store from the `jsc` runtime.
+    pub fn is_jsc(&self) -> bool {
+        self.inner.store.is_jsc()
+    }
+}
diff --git a/lib/api/src/backend/jsc/entities/store/obj.rs b/lib/api/src/backend/jsc/entities/store/obj.rs
new file mode 100644
index 0000000000..e15b1cde40
--- /dev/null
+++ b/lib/api/src/backend/jsc/entities/store/obj.rs
@@ -0,0 +1,134 @@
+use std::{marker::PhantomData, num::NonZeroUsize};
+
+use wasmer_types::StoreId;
+
+use crate::jsc::vm::{VMFunctionEnvironment, VMGlobal};
+
+use super::InternalStoreHandle;
+
+/// Trait to represent an object managed by a context. This is implemented on
+/// the VM types managed by the context.
+pub trait StoreObject: Sized {
+    fn list(store: &StoreObjects) -> &Vec<Self>;
+    fn list_mut(store: &mut StoreObjects) -> &mut Vec<Self>;
+}
+
+macro_rules! impl_store_object {
+    ($($field:ident => $ty:ty,)*) => {
+        $(
+            impl StoreObject for $ty {
+                fn list(store: &StoreObjects) -> &Vec<Self> {
+                    &store.$field
+                }
+                fn list_mut(store: &mut StoreObjects) -> &mut Vec<Self> {
+                    &mut store.$field
+                }
+            }
+        )*
+    };
+}
+
+impl_store_object! {
+    // Note: we store the globals in order to be able to access them later via
+    // `StoreObjects::iter_globals`.
+    globals => VMGlobal,
+    // functions => VMFunction,
+    // tables => VMTable,
+    // memories => VMMemory,
+    // The function environments are the only things attached to a store,
+    // since the other JS objects (table, globals, memory and functions)
+    // live in the JS VM Store by default
+    function_environments => VMFunctionEnvironment,
+}
+
+/// Set of objects managed by a context.
+#[derive(Default, Debug)]
+pub struct StoreObjects {
+    id: StoreId,
+    globals: Vec<VMGlobal>,
+    function_environments: Vec<VMFunctionEnvironment>,
+}
+
+impl StoreObjects {
+    /// Returns the ID of this context.
+    pub fn id(&self) -> StoreId {
+        self.id
+    }
+
+    /// Sets the ID of this store
+    pub fn set_id(&mut self, id: StoreId) {
+        self.id = id;
+    }
+
+    /// Returns a pair of mutable references from two handles.
+    ///
+    /// Panics if both handles point to the same object.
+    pub fn get_2_mut<T: StoreObject>(
+        &mut self,
+        a: InternalStoreHandle<T>,
+        b: InternalStoreHandle<T>,
+    ) -> (&mut T, &mut T) {
+        assert_ne!(a.index(), b.index());
+        let list = T::list_mut(self);
+        if a.index() < b.index() {
+            let (low, high) = list.split_at_mut(b.index());
+            (&mut low[a.index()], &mut high[0])
+        } else {
+            let (low, high) = list.split_at_mut(a.index());
+            (&mut high[0], &mut low[a.index()])
+        }
+    }
+
+    /// Return an immutable iterator over all globals
+    pub fn iter_globals(&self) -> core::slice::Iter<VMGlobal> {
+        self.globals.iter()
+    }
+
+    /// Return an vector of all globals and converted to u128
+    pub fn as_u128_globals(&self) -> Vec<u128> {
+        vec![]
+        // self.iter_globals()
+        //     .map(|v| v.global.value().as_f64().unwrap() as u128)
+        //     .collect()
+    }
+
+    /// Set a global, at index idx. Will panic if idx is out of range
+    /// Safety: the caller should check taht the raw value is compatible
+    /// with destination VMGlobal type
+    pub fn set_global_unchecked(&self, idx: usize, new_val: u128) {
+        assert!(idx < self.globals.len());
+        // let g = &self.globals[idx].global;
+        // let cur_val = g.value().as_f64().unwrap();
+        // let new_val = new_val as f64;
+        // if cur_val != new_val {
+        //     let new_value = JSValue::from(new_val);
+        //     g.set_value(&new_value);
+        // }
+    }
+}
+
+impl crate::StoreObjects {
+    /// Consume [`self`] into [`crate::backend::jsc::store::StoreObjects`].
+    pub fn into_jsc(self) -> crate::backend::jsc::store::StoreObjects {
+        match self {
+            Self::Jsc(s) => s,
+            _ => panic!("Not a `jsc` store!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::jsc::store::StoreObjects`].
+    pub fn as_jsc(&self) -> &crate::backend::jsc::store::StoreObjects {
+        match self {
+            Self::Jsc(s) => s,
+            _ => panic!("Not a `jsc` store!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::jsc::store::StoreObjects`].
+    pub fn as_jsc_mut(&mut self) -> &mut crate::backend::jsc::store::StoreObjects {
+        match self {
+            Self::Jsc(s) => s,
+            _ => panic!("Not a `jsc` store!"),
+        }
+    }
+}
diff --git a/lib/api/src/jsc/externals/table.rs b/lib/api/src/backend/jsc/entities/table.rs
similarity index 59%
rename from lib/api/src/jsc/externals/table.rs
rename to lib/api/src/backend/jsc/entities/table.rs
index 24159773b1..a5a2873e69 100644
--- a/lib/api/src/jsc/externals/table.rs
+++ b/lib/api/src/backend/jsc/entities/table.rs
@@ -1,12 +1,13 @@
-use crate::errors::RuntimeError;
-use crate::store::{AsStoreMut, AsStoreRef};
-use crate::value::Value;
-use crate::vm::VMExternTable;
-use crate::vm::{VMExtern, VMFunction, VMTable};
-use crate::{FunctionType, TableType};
 use rusty_jsc::{JSObject, JSValue};
+use wasmer_types::TableType;
 
-#[derive(Debug, Clone, PartialEq)]
+use crate::{
+    jsc::vm::{VMExternTable, VMTable},
+    vm::VMExtern,
+    AsStoreMut, AsStoreRef, BackendTable, RuntimeError, Value,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Table {
     pub(crate) handle: VMTable,
 }
@@ -22,14 +23,6 @@ fn set_table_item(table: &VMTable, item_index: u32, item: &JSObject) -> Result<(
 
 fn get_function(store: &mut impl AsStoreMut, val: Value) -> Result<JSObject, RuntimeError> {
     unimplemented!();
-    // if !val.is_from_store(store) {
-    //     return Err(RuntimeError::new("cannot pass Value across contexts"));
-    // }
-    // match val {
-    //     Value::FuncRef(Some(ref func)) => Ok(func.0.handle.function.clone().into()),
-    //     // Only funcrefs is supported by the spec atm
-    //     _ => unimplemented!("The {val:?} is not yet supported"),
-    // }
 }
 
 impl Table {
@@ -40,7 +33,7 @@ impl Table {
     ) -> Result<Self, RuntimeError> {
         let store_mut = store.as_store_mut();
         let engine = store_mut.engine();
-        let context = engine.0.context();
+        let context = engine.as_jsc().context();
 
         let mut descriptor = JSObject::new(&context);
         descriptor.set_property(
@@ -62,16 +55,18 @@ impl Table {
         );
 
         let js_table = engine
-            .0
+            .as_jsc()
             .wasm_table_type()
             .construct(&context, &[descriptor.to_jsvalue()])
             .map_err(|e| <JSValue as Into<RuntimeError>>::into(e))?;
         let vm_table = VMTable::new(js_table, ty);
-        Ok(Self::from_vm_extern(store, vm_table))
+        Ok(Self { handle: vm_table })
     }
 
     pub fn to_vm_extern(&self) -> VMExtern {
-        VMExtern::Table(self.handle.clone())
+        VMExtern::Jsc(crate::backend::jsc::vm::VMExtern::Table(
+            self.handle.clone(),
+        ))
     }
 
     pub fn ty(&self, _store: &impl AsStoreRef) -> TableType {
@@ -80,14 +75,6 @@ impl Table {
 
     pub fn get(&self, store: &mut impl AsStoreMut, index: u32) -> Option<Value> {
         unimplemented!();
-        // if let Some(func) = self.handle.table.get(index).ok() {
-        //     let ty = FunctionType::new(vec![], vec![]);
-        //     let vm_function = VMFunction::new(func, ty);
-        //     let function = crate::Function::from_vm_extern(store, vm_function);
-        //     Some(Value::FuncRef(Some(function)))
-        // } else {
-        //     None
-        // }
     }
 
     pub fn set(
@@ -104,7 +91,7 @@ impl Table {
     pub fn size(&self, store: &impl AsStoreRef) -> u32 {
         let store_mut = store.as_store_ref();
         let engine = store_mut.engine();
-        let context = engine.0.context();
+        let context = engine.as_jsc().context();
         self.handle
             .table
             .get_property(&context, "length".to_string())
@@ -120,7 +107,7 @@ impl Table {
     ) -> Result<u32, RuntimeError> {
         let store_mut = store.as_store_mut();
         let engine = store_mut.engine();
-        let context = engine.0.context();
+        let context = engine.as_jsc().context();
         let func = self
             .handle
             .table
@@ -148,11 +135,68 @@ impl Table {
         unimplemented!("Table.copy is not natively supported in Javascript");
     }
 
-    pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, vm_extern: VMExternTable) -> Self {
-        Self { handle: vm_extern }
+    pub(crate) fn from_vm_extern(
+        _store: &mut impl AsStoreMut,
+        vm_extern: crate::vm::VMExternTable,
+    ) -> Self {
+        Self {
+            handle: vm_extern.into_jsc(),
+        }
     }
 
     pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
         true
     }
 }
+
+impl crate::Table {
+    /// Consume [`self`] into [`crate::backend::jsc::table::Table`].
+    pub fn into_jsc(self) -> crate::backend::jsc::table::Table {
+        match self.0 {
+            BackendTable::Jsc(s) => s,
+            _ => panic!("Not a `jsc` table!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::jsc::table::Table`].
+    pub fn as_jsc(&self) -> &crate::backend::jsc::table::Table {
+        match self.0 {
+            BackendTable::Jsc(ref s) => s,
+            _ => panic!("Not a `jsc` table!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::jsc::table::Table`].
+    pub fn as_jsc_mut(&mut self) -> &mut crate::backend::jsc::table::Table {
+        match self.0 {
+            BackendTable::Jsc(ref mut s) => s,
+            _ => panic!("Not a `jsc` table!"),
+        }
+    }
+}
+
+impl crate::BackendTable {
+    /// Consume [`self`] into [`crate::backend::jsc::table::Table`].
+    pub fn into_jsc(self) -> crate::backend::jsc::table::Table {
+        match self {
+            Self::Jsc(s) => s,
+            _ => panic!("Not a `jsc` table!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::jsc::table::Table`].
+    pub fn as_jsc(&self) -> &crate::backend::jsc::table::Table {
+        match self {
+            Self::Jsc(ref s) => s,
+            _ => panic!("Not a `jsc` table!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::jsc::table::Table`].
+    pub fn as_jsc_mut(&mut self) -> &mut crate::backend::jsc::table::Table {
+        match self {
+            Self::Jsc(ref mut s) => s,
+            _ => panic!("Not a `jsc` table!"),
+        }
+    }
+}
diff --git a/lib/api/src/backend/jsc/entities/tag.rs b/lib/api/src/backend/jsc/entities/tag.rs
new file mode 100644
index 0000000000..c77261b6c3
--- /dev/null
+++ b/lib/api/src/backend/jsc/entities/tag.rs
@@ -0,0 +1,42 @@
+use wasmer_types::{TagType, Type};
+
+use crate::{
+    jsc::vm::VMTag,
+    vm::{VMExtern, VMExternTag},
+    AsStoreMut, AsStoreRef,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// A WebAssembly `tag` in the `v8` runtime.
+pub(crate) struct Tag {
+    pub(crate) handle: VMTag,
+}
+
+unsafe impl Send for Tag {}
+unsafe impl Sync for Tag {}
+
+// Tag can't be Send in js because it dosen't support `structuredClone`
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// unsafe impl Send for Tag {}
+
+impl Tag {
+    pub fn new<P: Into<Box<[Type]>>>(store: &mut impl AsStoreMut, params: P) -> Self {
+        panic!("EH not supported yet!")
+    }
+
+    pub fn ty(&self, store: &impl AsStoreRef) -> TagType {
+        panic!("EH not supported yet!")
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternTag) -> Self {
+        panic!("EH not supported yet!")
+    }
+
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        panic!("EH not supported yet!")
+    }
+
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        panic!("EH not supported yet!")
+    }
+}
diff --git a/lib/api/src/jsc/trap.rs b/lib/api/src/backend/jsc/error.rs
similarity index 89%
rename from lib/api/src/jsc/trap.rs
rename to lib/api/src/backend/jsc/error.rs
index fa606fc137..65b79012ab 100644
--- a/lib/api/src/jsc/trap.rs
+++ b/lib/api/src/backend/jsc/error.rs
@@ -52,7 +52,7 @@ impl Trap {
         }
     }
 
-    pub(crate) fn into_jsvalue(self, ctx: &JSContext) -> JSValue {
+    pub(crate) fn into_jsc_value(self, ctx: &JSContext) -> JSValue {
         match self.inner {
             InnerTrap::User(err) => {
                 let obj = JSObject::new(ctx);
@@ -66,7 +66,7 @@ impl Trap {
         }
     }
 
-    pub(crate) fn from_jsvalue(ctx: &JSContext, val: JSValue) -> Self {
+    pub(crate) fn from_jsc_value(ctx: &JSContext, val: JSValue) -> Self {
         let obj_val = val.to_object(ctx).unwrap();
         let wasmer_error_ptr = obj_val.get_property(&ctx, "wasmer_error_ptr".to_string());
         if wasmer_error_ptr.is_number(ctx) {
@@ -115,3 +115,13 @@ impl From<JSValue> for RuntimeError {
         // trap.into()
     }
 }
+
+impl From<Trap> for RuntimeError {
+    fn from(trap: Trap) -> Self {
+        if trap.is::<Self>() {
+            return trap.downcast::<Self>().unwrap();
+        }
+
+        RuntimeError::new_from_source(crate::BackendTrap::Jsc(trap), vec![], None)
+    }
+}
diff --git a/lib/api/src/backend/jsc/mod.rs b/lib/api/src/backend/jsc/mod.rs
new file mode 100644
index 0000000000..1cbf43f5c5
--- /dev/null
+++ b/lib/api/src/backend/jsc/mod.rs
@@ -0,0 +1,8 @@
+//! Data types, functions and traits for the `jsc` backend.
+
+pub(crate) mod entities;
+pub(crate) mod error;
+pub(crate) mod utils;
+pub(crate) mod vm;
+
+pub use entities::{engine::Engine as JSC, *};
diff --git a/lib/api/src/jsc/as_js.rs b/lib/api/src/backend/jsc/utils/convert.rs
similarity index 57%
rename from lib/api/src/jsc/as_js.rs
rename to lib/api/src/backend/jsc/utils/convert.rs
index 77175fc121..3128134eab 100644
--- a/lib/api/src/jsc/as_js.rs
+++ b/lib/api/src/backend/jsc/utils/convert.rs
@@ -1,25 +1,16 @@
-use crate::imports::Imports;
-use crate::instance::Instance;
-use crate::jsc::engine::JSC;
-use crate::jsc::instance::Instance as JsInstance;
-use crate::jsc::vm::{VMFunction, VMGlobal, VMMemory, VMTable};
-use crate::store::{AsStoreMut, AsStoreRef};
-use crate::value::Value;
-use crate::Type;
-use crate::{Extern, Function, Global, Memory, Table};
-use rusty_jsc::{JSContext, JSObject, JSValue};
-use std::collections::HashMap;
-use std::convert::TryInto;
-use wasmer_types::ExternType;
+use rusty_jsc::{JSContext, JSValue};
+use wasmer_types::{ExternType, Type};
+
+use crate::{jsc::engine::IntoJSC, AsStoreMut, AsStoreRef, Extern, Function, Value};
 
 /// Convert the given type to a [`JsValue`].
-pub trait AsJs: Sized {
+pub trait AsJsc: Sized {
     /// The inner definition type from this Javascript object
     type DefinitionType;
     /// Convert the given type to a [`JsValue`].
-    fn as_jsvalue(&self, store: &impl AsStoreRef) -> JSValue;
+    fn as_jsc_value(&self, store: &impl AsStoreRef) -> JSValue;
     /// Convert the given type to a [`JsValue`].
-    fn from_jsvalue(
+    fn from_jsc_value(
         store: &mut impl AsStoreMut,
         type_: &Self::DefinitionType,
         value: &JSValue,
@@ -27,7 +18,7 @@ pub trait AsJs: Sized {
 }
 
 #[inline]
-pub fn param_from_js(context: &JSContext, ty: &Type, js_val: &JSValue) -> Value {
+pub fn jsc_value_to_wasmer(context: &JSContext, ty: &Type, js_val: &JSValue) -> Value {
     match ty {
         Type::I32 => Value::I32(js_val.to_number(&context).unwrap() as _),
         Type::I64 => {
@@ -58,17 +49,17 @@ pub fn param_from_js(context: &JSContext, ty: &Type, js_val: &JSValue) -> Value
             };
             Value::V128(number)
         }
-        Type::ExternRef | Type::FuncRef => unimplemented!(
-            "The type `{:?}` is not yet supported in the JS Function API",
+        Type::ExternRef | Type::FuncRef | Type::ExceptionRef => unimplemented!(
+            "The type `{:?}` is not yet supported in the JSC Function API",
             ty
         ),
     }
 }
 
-impl AsJs for Value {
+impl AsJsc for Value {
     type DefinitionType = Type;
 
-    fn as_jsvalue(&self, store: &impl AsStoreRef) -> JSValue {
+    fn as_jsc_value(&self, store: &impl AsStoreRef) -> JSValue {
         let engine = store.as_store_ref();
         let context = engine.jsc().context();
         match self {
@@ -81,36 +72,42 @@ impl AsJs for Value {
             Self::F32(f) => JSValue::number(&context, *f as _),
             Self::F64(f) => JSValue::number(&context, *f),
             Self::V128(v) => JSValue::number(&context, *v as _),
-            Self::FuncRef(Some(func)) => func.0.handle.function.clone().to_jsvalue(),
+            Self::FuncRef(Some(func)) => func.as_jsc().handle.function.clone().to_jsvalue(),
             Self::FuncRef(None) => JSValue::null(&context),
-            Self::ExternRef(_) => unimplemented!(),
+            Self::ExternRef(_) => {
+                unimplemented!("ExternRefs are not yet supported in the JSC Function API",)
+            }
+            Self::ExceptionRef(_) => {
+                unimplemented!("ExceptionRefs are not yet supported in the JSC Function API",)
+            }
         }
     }
 
-    fn from_jsvalue(
+    fn from_jsc_value(
         store: &mut impl AsStoreMut,
         type_: &Self::DefinitionType,
         value: &JSValue,
     ) -> Result<Self, JSValue> {
         let engine = store.as_store_ref();
         let context = engine.jsc().context();
-        Ok(param_from_js(context, type_, value))
+        Ok(jsc_value_to_wasmer(context, type_, value))
     }
 }
 
-impl AsJs for Extern {
+impl AsJsc for Extern {
     type DefinitionType = ExternType;
 
-    fn as_jsvalue(&self, _store: &impl AsStoreRef) -> JSValue {
+    fn as_jsc_value(&self, _store: &impl AsStoreRef) -> JSValue {
         match self {
-            Self::Memory(memory) => memory.0.handle.memory.clone().to_jsvalue(),
-            Self::Function(function) => function.0.handle.function.clone().to_jsvalue(),
-            Self::Table(table) => table.0.handle.table.clone().to_jsvalue(),
-            Self::Global(global) => global.0.handle.global.clone().to_jsvalue(),
+            Self::Memory(memory) => memory.as_jsc().handle.memory.clone().to_jsvalue(),
+            Self::Function(function) => function.as_jsc().handle.function.clone().to_jsvalue(),
+            Self::Table(table) => table.as_jsc().handle.table.clone().to_jsvalue(),
+            Self::Global(global) => global.as_jsc().handle.global.clone().to_jsvalue(),
+            Self::Tag(_) => unimplemented!("Tags are not yet supported in the JS Function API"),
         }
     }
 
-    fn from_jsvalue(
+    fn from_jsc_value(
         store: &mut impl AsStoreMut,
         extern_type: &Self::DefinitionType,
         val: &JSValue,
@@ -125,30 +122,47 @@ impl AsJs for Extern {
                 let obj_val = val.to_object(&context).unwrap();
                 Ok(Self::Function(Function::from_vm_extern(
                     store,
-                    VMFunction::new(obj_val, function_type.clone()),
+                    crate::vm::VMExternFunction::Jsc(
+                        crate::backend::jsc::vm::VMExternFunction::new(
+                            obj_val,
+                            function_type.clone(),
+                        ),
+                    ),
                 )))
             }
             ExternType::Global(global_type) => {
                 let obj_val = val.to_object(&context).unwrap();
-                Ok(Self::Global(Global::from_vm_extern(
+                Ok(Self::Global(crate::Global::from_vm_extern(
                     store,
-                    VMGlobal::new(obj_val, global_type.clone()),
+                    crate::vm::VMExternGlobal::Jsc(crate::backend::jsc::vm::VMExternGlobal::new(
+                        obj_val,
+                        global_type.clone(),
+                    )),
                 )))
             }
             ExternType::Memory(memory_type) => {
                 let obj_val = val.to_object(&context).unwrap();
-                Ok(Self::Memory(Memory::from_vm_extern(
+                Ok(Self::Memory(crate::Memory::from_vm_extern(
                     store,
-                    VMMemory::new(obj_val, memory_type.clone()),
+                    crate::vm::VMExternMemory::Jsc(crate::backend::jsc::vm::VMExternMemory::new(
+                        obj_val,
+                        memory_type.clone(),
+                    )),
                 )))
             }
             ExternType::Table(table_type) => {
                 let obj_val = val.to_object(&context).unwrap();
-                Ok(Self::Table(Table::from_vm_extern(
+                Ok(Self::Table(crate::Table::from_vm_extern(
                     store,
-                    VMTable::new(obj_val, table_type.clone()),
+                    crate::vm::VMExternTable::Jsc(crate::backend::jsc::vm::VMExternTable::new(
+                        obj_val,
+                        table_type.clone(),
+                    )),
                 )))
             }
+            ExternType::Tag(tag) => {
+                panic!("EH not supported in `jsc` rt")
+            }
         }
     }
 }
diff --git a/lib/api/src/backend/jsc/utils/mod.rs b/lib/api/src/backend/jsc/utils/mod.rs
new file mode 100644
index 0000000000..02d63d4e14
--- /dev/null
+++ b/lib/api/src/backend/jsc/utils/mod.rs
@@ -0,0 +1 @@
+pub(crate) mod convert;
diff --git a/lib/api/src/backend/jsc/vm/external.rs b/lib/api/src/backend/jsc/vm/external.rs
new file mode 100644
index 0000000000..3610cdfac7
--- /dev/null
+++ b/lib/api/src/backend/jsc/vm/external.rs
@@ -0,0 +1,61 @@
+use wasmer_types::RawValue;
+
+use crate::{AsStoreMut, Extern, VMExternToExtern};
+
+use super::{function::VMFunction, global::VMGlobal, memory::VMMemory, table::VMTable};
+
+/// The value of an export passed from one instance to another in the `jsc` VM.
+pub enum VMExtern {
+    /// A function export value.
+    Function(VMFunction),
+
+    /// A table export value.
+    Table(VMTable),
+
+    /// A memory export value.
+    Memory(VMMemory),
+
+    /// A global export value.
+    Global(VMGlobal),
+}
+
+impl VMExternToExtern for VMExtern {
+    fn to_extern(self, store: &mut impl AsStoreMut) -> Extern {
+        match self {
+            Self::Function(f) => Extern::Function(crate::Function::from_vm_extern(
+                store,
+                crate::vm::VMExternFunction::Jsc(f),
+            )),
+            Self::Memory(m) => Extern::Memory(crate::Memory::from_vm_extern(
+                store,
+                crate::vm::VMExternMemory::Jsc(m),
+            )),
+            Self::Global(g) => Extern::Global(crate::Global::from_vm_extern(
+                store,
+                crate::vm::VMExternGlobal::Jsc(g),
+            )),
+            Self::Table(t) => Extern::Table(crate::Table::from_vm_extern(
+                store,
+                crate::vm::VMExternTable::Jsc(t),
+            )),
+        }
+    }
+}
+
+/// A reference to an external value in the `js` VM.
+pub struct VMExternRef;
+
+impl VMExternRef {
+    /// Converts the `VMExternRef` into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        unimplemented!();
+    }
+
+    /// Extracts a `VMExternRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw` must be a valid `VMExternRef` instance.
+    pub unsafe fn from_raw(_raw: RawValue) -> Option<Self> {
+        unimplemented!();
+    }
+}
diff --git a/lib/api/src/backend/jsc/vm/function.rs b/lib/api/src/backend/jsc/vm/function.rs
new file mode 100644
index 0000000000..3fe4e97865
--- /dev/null
+++ b/lib/api/src/backend/jsc/vm/function.rs
@@ -0,0 +1,86 @@
+use std::any::Any;
+
+use rusty_jsc::{JSObject, JSObjectCallAsFunctionCallback};
+use wasmer_types::{FunctionType, RawValue};
+
+/// The VM Function type
+#[derive(Clone, Eq)]
+pub struct VMFunction {
+    pub(crate) function: JSObject,
+    pub(crate) ty: FunctionType,
+}
+
+unsafe impl Send for VMFunction {}
+unsafe impl Sync for VMFunction {}
+
+impl VMFunction {
+    pub(crate) fn new(function: JSObject, ty: FunctionType) -> Self {
+        Self { function, ty }
+    }
+}
+
+impl PartialEq for VMFunction {
+    fn eq(&self, other: &Self) -> bool {
+        self.function == other.function
+    }
+}
+
+impl std::fmt::Debug for VMFunction {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("VMFunction")
+            .field("function", &self.function)
+            .finish()
+    }
+}
+
+/// Underlying FunctionEnvironment used by a `VMFunction`.
+#[derive(Debug)]
+pub struct VMFunctionEnvironment {
+    pub(crate) contents: Box<dyn Any + Send + 'static>,
+}
+
+impl VMFunctionEnvironment {
+    /// Wraps the given value to expose it to Wasm code as a function context.
+    pub fn new(val: impl Any + Send + 'static) -> Self {
+        Self {
+            contents: Box::new(val),
+        }
+    }
+
+    #[allow(clippy::should_implement_trait)]
+    /// Returns a reference to the underlying value.
+    pub fn as_ref(&self) -> &(dyn Any + Send + 'static) {
+        &*self.contents
+    }
+
+    #[allow(clippy::should_implement_trait)]
+    /// Returns a mutable reference to the underlying value.
+    pub fn as_mut(&mut self) -> &mut (dyn Any + Send + 'static) {
+        &mut *self.contents
+    }
+}
+
+#[repr(transparent)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub(crate) struct VMFuncRef;
+
+impl VMFuncRef {
+    /// Converts the `VMFuncRef` into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        unimplemented!();
+    }
+
+    /// Extracts a `VMFuncRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw.funcref` must be a valid pointer.
+    pub unsafe fn from_raw(_raw: RawValue) -> Option<Self> {
+        unimplemented!();
+    }
+}
+
+/// The type of function callbackes in the `jsc` runtime.
+pub type VMFunctionCallback = JSObjectCallAsFunctionCallback;
+
+/// Necessary for the top-level macros to work as intended.
+pub(crate) type VMFunctionBody = ();
diff --git a/lib/api/src/backend/jsc/vm/global.rs b/lib/api/src/backend/jsc/vm/global.rs
new file mode 100644
index 0000000000..31542e7841
--- /dev/null
+++ b/lib/api/src/backend/jsc/vm/global.rs
@@ -0,0 +1,18 @@
+use rusty_jsc::JSObject;
+use wasmer_types::GlobalType;
+
+/// The VM Global type
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct VMGlobal {
+    pub(crate) global: JSObject,
+    pub(crate) ty: GlobalType,
+}
+
+impl VMGlobal {
+    pub(crate) fn new(global: JSObject, ty: GlobalType) -> Self {
+        Self { global, ty }
+    }
+}
+
+unsafe impl Send for VMGlobal {}
+unsafe impl Sync for VMGlobal {}
diff --git a/lib/api/src/backend/jsc/vm/memory.rs b/lib/api/src/backend/jsc/vm/memory.rs
new file mode 100644
index 0000000000..a75bfae4f2
--- /dev/null
+++ b/lib/api/src/backend/jsc/vm/memory.rs
@@ -0,0 +1,66 @@
+use rusty_jsc::JSObject;
+use tracing::trace;
+use wasmer_types::{MemoryError, MemoryType};
+
+use crate::AsStoreRef;
+
+/// Represents linear memory that is managed by the Javascript Core runtime
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct VMMemory {
+    pub(crate) memory: JSObject,
+    pub(crate) ty: MemoryType,
+}
+
+unsafe impl Send for VMMemory {}
+unsafe impl Sync for VMMemory {}
+
+impl VMMemory {
+    /// Creates a new memory directly from a WebAssembly javascript object
+    pub fn new(memory: JSObject, ty: MemoryType) -> Self {
+        Self { memory, ty }
+    }
+
+    /// Returns the size of the memory buffer in pages
+    pub fn get_runtime_size(&self) -> u32 {
+        unimplemented!();
+        // let dummy: DummyBuffer = match serde_wasm_bindgen::from_value(self.memory.buffer()) {
+        //     Ok(o) => o,
+        //     Err(_) => return 0,
+        // };
+        // if dummy.byte_length == 0 {
+        //     return 0;
+        // }
+        // dummy.byte_length / WASM_PAGE_SIZE as u32
+    }
+
+    /// Attempts to clone this memory (if its clonable)
+    pub(crate) fn try_clone(&self) -> Result<VMMemory, MemoryError> {
+        Ok(self.clone())
+    }
+
+    /// Copies this memory to a new memory
+    pub fn copy(&self, store: &impl AsStoreRef) -> Result<VMMemory, wasmer_types::MemoryError> {
+        let new_memory = crate::jsc::memory::Memory::js_memory_from_type(&store, &self.ty)?;
+
+        trace!("memory copy started");
+
+        let src = crate::jsc::memory::view::MemoryView::new_raw(&self.memory, store);
+        let amount = src.data_size() as usize;
+        let mut dst = crate::jsc::memory::view::MemoryView::new_raw(&new_memory, store);
+        let dst_size = dst.data_size() as usize;
+
+        src.copy_to_memory(amount as u64, &dst).map_err(|err| {
+            wasmer_types::MemoryError::Generic(format!("failed to copy the memory - {}", err))
+        })?;
+
+        trace!("memory copy finished (size={})", dst.size().bytes().0);
+
+        Ok(Self {
+            memory: new_memory,
+            ty: self.ty.clone(),
+        })
+    }
+}
+
+/// Shared VM memory, in `jsc`, is the "normal" memory.
+pub type VMSharedMemory = VMMemory;
diff --git a/lib/api/src/backend/jsc/vm/mod.rs b/lib/api/src/backend/jsc/vm/mod.rs
new file mode 100644
index 0000000000..9d26bc773d
--- /dev/null
+++ b/lib/api/src/backend/jsc/vm/mod.rs
@@ -0,0 +1,48 @@
+pub(crate) mod external;
+pub(crate) mod function;
+pub(crate) mod global;
+pub(crate) mod memory;
+pub(crate) mod table;
+pub use super::error::Trap;
+
+pub use external::*;
+pub use function::*;
+pub use global::*;
+pub use memory::*;
+pub use table::*;
+
+/// The type of instances in the `js` VM.
+pub type VMInstance = rusty_jsc::JSObject;
+
+pub struct VMTrampoline;
+
+/// The type of extern tables in the `js` VM.
+pub(crate) type VMExternTable = VMTable;
+/// The type of extern memories in the `js` VM.
+pub(crate) type VMExternMemory = VMMemory;
+/// The type of extern globals in the `js` VM.
+pub(crate) type VMExternGlobal = VMGlobal;
+/// The type of extern functions in the `js` VM.
+pub(crate) type VMExternFunction = VMFunction;
+
+// No EH for now.
+pub(crate) type VMException = ();
+pub(crate) type VMTag = ();
+pub(crate) type VMExternTag = ();
+
+pub struct VMExceptionRef;
+
+impl VMExceptionRef {
+    /// Converts the `VMExceptionRef` into a `RawValue`.
+    pub fn into_raw(self) -> wasmer_types::RawValue {
+        unimplemented!()
+    }
+
+    /// Extracts a `VMExceptionRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw` must be a valid `VMExceptionRef` instance.
+    pub unsafe fn from_raw(_raw: wasmer_types::RawValue) -> Option<Self> {
+        unimplemented!();
+    }
+}
diff --git a/lib/api/src/backend/jsc/vm/table.rs b/lib/api/src/backend/jsc/vm/table.rs
new file mode 100644
index 0000000000..2fdbedce94
--- /dev/null
+++ b/lib/api/src/backend/jsc/vm/table.rs
@@ -0,0 +1,24 @@
+use rusty_jsc::JSObject;
+use wasmer_types::TableType;
+
+/// The VM Table type
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct VMTable {
+    pub(crate) table: JSObject,
+    pub(crate) ty: TableType,
+}
+
+unsafe impl Send for VMTable {}
+unsafe impl Sync for VMTable {}
+
+impl VMTable {
+    pub(crate) fn new(table: JSObject, ty: TableType) -> Self {
+        Self { table, ty }
+    }
+
+    /// Get the table size at runtime
+    pub fn get_runtime_size(&self) -> u32 {
+        unimplemented!();
+        // self.table.length()
+    }
+}
diff --git a/lib/api/src/backend/mod.rs b/lib/api/src/backend/mod.rs
new file mode 100644
index 0000000000..18730741e5
--- /dev/null
+++ b/lib/api/src/backend/mod.rs
@@ -0,0 +1,151 @@
+//! This submodule has the concrete definitions for all the available implenters of the WebAssembly
+//! types needed to create a runtime.
+
+#[cfg(feature = "sys")]
+pub mod sys;
+
+#[cfg(feature = "wamr")]
+pub mod wamr;
+
+#[cfg(feature = "wasmi")]
+pub mod wasmi;
+
+#[cfg(feature = "v8")]
+pub mod v8;
+
+#[cfg(feature = "js")]
+pub mod js;
+
+#[cfg(feature = "jsc")]
+pub mod jsc;
+
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy)]
+/// An enumeration over all the supported runtimes.
+pub enum BackendKind {
+    #[cfg(feature = "cranelift")]
+    /// The `cranelift` runtime.
+    Cranelift,
+
+    #[cfg(feature = "llvm")]
+    /// The `llvm` runtime.
+    LLVM,
+
+    #[cfg(feature = "singlepass")]
+    /// The `singlepass` runtime.
+    Singlepass,
+
+    #[cfg(feature = "sys")]
+    /// The sys `headless` runtime.
+    Headless,
+
+    #[cfg(feature = "wamr")]
+    /// The `wamr` runtime.
+    Wamr,
+
+    #[cfg(feature = "wasmi")]
+    /// The `wasmi` runtime.
+    Wasmi,
+
+    #[cfg(feature = "v8")]
+    /// The `v8` runtime.
+    V8,
+
+    #[cfg(feature = "js")]
+    /// The `js` runtime.
+    Js,
+
+    #[cfg(feature = "jsc")]
+    /// The `jsc` runtime.
+    Jsc,
+}
+
+impl Default for BackendKind {
+    fn default() -> Self {
+        #[cfg(feature = "sys-default")]
+        {
+            #[cfg(feature = "cranelift")]
+            {
+                return Self::Cranelift;
+            }
+            #[cfg(feature = "singlepass")]
+            {
+                return Self::Singlepass;
+            }
+            #[cfg(feature = "llvm")]
+            {
+                return Self::LLVM;
+            }
+            return Self::Headless;
+        }
+
+        #[cfg(feature = "wamr-default")]
+        {
+            return Self::Wamr;
+        }
+
+        #[cfg(feature = "wasmi-default")]
+        {
+            return Self::Wasmi;
+        }
+
+        #[cfg(feature = "v8-default")]
+        {
+            return Self::V8;
+        }
+
+        #[cfg(feature = "js-default")]
+        {
+            return Self::Js;
+        }
+
+        #[cfg(feature = "jsc-default")]
+        {
+            return Self::Jsc;
+        }
+
+        #[cfg(feature = "sys")]
+        {
+            #[cfg(feature = "cranelift")]
+            {
+                return Self::Cranelift;
+            }
+            #[cfg(feature = "singlepass")]
+            {
+                return Self::Singlepass;
+            }
+            #[cfg(feature = "llvm")]
+            {
+                return Self::LLVM;
+            }
+            return Self::Headless;
+        }
+
+        #[cfg(feature = "wamr")]
+        {
+            return Self::Wamr;
+        }
+
+        #[cfg(feature = "wasmi")]
+        {
+            return Self::Wasmi;
+        }
+
+        #[cfg(feature = "v8")]
+        {
+            return Self::V8;
+        }
+
+        #[cfg(feature = "js")]
+        {
+            return Self::Js;
+        }
+
+        #[cfg(feature = "jsc")]
+        {
+            return Self::Jsc;
+        }
+
+        panic!("No runtime enabled!")
+    }
+}
diff --git a/lib/api/src/backend/sys/entities/engine.rs b/lib/api/src/backend/sys/entities/engine.rs
new file mode 100644
index 0000000000..dee040f955
--- /dev/null
+++ b/lib/api/src/backend/sys/entities/engine.rs
@@ -0,0 +1,275 @@
+//! Data types, functions and traits for `sys` runtime's `Engine` implementation.
+
+use std::{path::Path, sync::Arc};
+
+use shared_buffer::OwnedBuffer;
+pub use wasmer_compiler::{Artifact, BaseTunables, Engine, EngineBuilder, Tunables};
+use wasmer_types::{target::Target, DeserializeError, Features, HashAlgorithm};
+
+use crate::{BackendEngine, BackendModule};
+
+/// Get the default config for the sys Engine
+#[allow(unreachable_code)]
+#[cfg(feature = "compiler")]
+pub fn get_default_compiler_config() -> Option<Box<dyn wasmer_compiler::CompilerConfig>> {
+    cfg_if::cfg_if! {
+        if #[cfg(feature = "cranelift")] {
+            Some(Box::<wasmer_compiler_cranelift::Cranelift>::default())
+        } else if #[cfg(feature = "llvm")] {
+            Some(Box::<wasmer_compiler_llvm::LLVM>::default())
+        } else if #[cfg(feature = "singlepass")] {
+            Some(Box::<wasmer_compiler_singlepass::Singlepass>::default())
+        }
+        else {
+            None
+        }
+    }
+}
+
+/// Returns the default engine for the Sys engine
+pub fn default_engine() -> Engine {
+    #[cfg(feature = "compiler")]
+    fn get_engine() -> Engine {
+        if let Some(config) = get_default_compiler_config() {
+            EngineBuilder::new(config).engine()
+        } else {
+            EngineBuilder::headless().engine()
+        }
+    }
+
+    #[cfg(not(feature = "compiler"))]
+    fn get_engine() -> Engine {
+        EngineBuilder::headless().engine()
+    }
+
+    let mut engine = get_engine();
+    let tunables = BaseTunables::for_target(engine.target());
+    engine.set_tunables(tunables);
+    engine
+}
+
+/// The custom trait to access to all the `sys` function in the common
+/// engine.
+pub trait NativeEngineExt {
+    /// Create a new `Engine` with the given config
+    #[cfg(feature = "compiler")]
+    fn new(
+        compiler_config: Box<dyn wasmer_compiler::CompilerConfig>,
+        target: Target,
+        features: Features,
+    ) -> Self;
+
+    /// Sets the hash algorithm
+    fn set_hash_algorithm(&mut self, hash_algorithm: Option<HashAlgorithm>);
+
+    /// Create a headless `Engine`
+    ///
+    /// A headless engine is an engine without any compiler attached.
+    /// This is useful for assuring a minimal runtime for running
+    /// WebAssembly modules.
+    ///
+    /// For example, for running in IoT devices where compilers are very
+    /// expensive, or also to optimize startup speed.
+    ///
+    /// # Important
+    ///
+    /// Headless engines can't compile or validate any modules,
+    /// they just take already processed Modules (via `Module::serialize`).
+    fn headless() -> Self;
+
+    /// Gets the target
+    fn target(&self) -> &Target;
+
+    /// Attach a Tunable to this engine
+    fn set_tunables(&mut self, tunables: impl Tunables + Send + Sync + 'static);
+
+    /// Get a reference to attached Tunable of this engine
+    fn tunables(&self) -> &dyn Tunables;
+
+    /// Load a serialized WebAssembly module from a memory mapped file and deserialize it.
+    ///
+    /// NOTE: you should almost always prefer [`Self::deserialize_from_mmapped_file`].
+    ///
+    /// # Safety
+    /// See [`Artifact::deserialize_unchecked`].
+    unsafe fn deserialize_from_mmapped_file_unchecked(
+        &self,
+        file_ref: &Path,
+    ) -> Result<crate::Module, DeserializeError>;
+
+    /// Load a serialized WebAssembly module from a memory mapped file and deserialize it.
+    ///
+    /// # Safety
+    /// See [`Artifact::deserialize`].
+    unsafe fn deserialize_from_mmapped_file(
+        &self,
+        file_ref: &Path,
+    ) -> Result<crate::Module, DeserializeError>;
+}
+
+impl NativeEngineExt for crate::engine::Engine {
+    #[cfg(feature = "compiler")]
+    fn new(
+        compiler_config: Box<dyn wasmer_compiler::CompilerConfig>,
+        target: Target,
+        features: Features,
+    ) -> Self {
+        Self {
+            be: BackendEngine::Sys(Engine::new(compiler_config, target, features)),
+            id: Self::atomic_next_engine_id(),
+        }
+    }
+
+    fn headless() -> Self {
+        Self {
+            be: BackendEngine::Sys(Engine::headless()),
+            id: Self::atomic_next_engine_id(),
+        }
+    }
+
+    fn target(&self) -> &Target {
+        match self.be {
+            BackendEngine::Sys(ref s) => s.target(),
+            _ => panic!("Not a `sys` engine!"),
+        }
+    }
+
+    fn set_tunables(&mut self, tunables: impl Tunables + Send + Sync + 'static) {
+        match self.be {
+            BackendEngine::Sys(ref mut s) => s.set_tunables(tunables),
+            _ => panic!("Not a `sys` engine!"),
+        }
+    }
+
+    fn tunables(&self) -> &dyn Tunables {
+        match self.be {
+            BackendEngine::Sys(ref s) => s.tunables(),
+            _ => panic!("Not a `sys` engine!"),
+        }
+    }
+
+    unsafe fn deserialize_from_mmapped_file_unchecked(
+        &self,
+        file_ref: &Path,
+    ) -> Result<crate::Module, DeserializeError> {
+        let file = std::fs::File::open(file_ref)?;
+        let artifact = Arc::new(Artifact::deserialize_unchecked(
+            self.as_sys(),
+            OwnedBuffer::from_file(&file)
+                .map_err(|e| DeserializeError::Generic(format!("{e:?}")))?,
+        )?);
+        Ok(crate::Module(BackendModule::Sys(
+            super::module::Module::from_artifact(artifact),
+        )))
+    }
+
+    unsafe fn deserialize_from_mmapped_file(
+        &self,
+        file_ref: &Path,
+    ) -> Result<crate::Module, DeserializeError> {
+        let file = std::fs::File::open(file_ref)?;
+        let artifact = Arc::new(Artifact::deserialize(
+            self.as_sys(),
+            OwnedBuffer::from_file(&file)
+                .map_err(|e| DeserializeError::Generic(format!("{e:?}")))?,
+        )?);
+        Ok(crate::Module(BackendModule::Sys(
+            super::module::Module::from_artifact(artifact),
+        )))
+    }
+
+    fn set_hash_algorithm(&mut self, hash_algorithm: Option<HashAlgorithm>) {
+        match self.be {
+            BackendEngine::Sys(ref mut s) => s.set_hash_algorithm(hash_algorithm),
+            _ => panic!("Not a `sys` engine!"),
+        }
+    }
+}
+
+impl crate::Engine {
+    /// Consume [`self`] into a [`crate::backend::sys::engine::Engine`].
+    pub fn into_sys(self) -> crate::backend::sys::engine::Engine {
+        match self.be {
+            BackendEngine::Sys(s) => s,
+            _ => panic!("Not a `sys` engine!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::sys::engine::Engine`].
+    pub fn as_sys(&self) -> &crate::backend::sys::engine::Engine {
+        match self.be {
+            BackendEngine::Sys(ref s) => s,
+            _ => panic!("Not a `sys` engine!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::sys::engine::Engine`].
+    pub fn as_sys_mut(&mut self) -> &mut crate::backend::sys::engine::Engine {
+        match self.be {
+            BackendEngine::Sys(ref mut s) => s,
+            _ => panic!("Not a `sys` engine!"),
+        }
+    }
+
+    /// Return true if [`self`] is an engine from the `sys` runtime.
+    pub fn is_sys(&self) -> bool {
+        matches!(self.be, BackendEngine::Sys(_))
+    }
+}
+
+impl From<Engine> for crate::Engine {
+    fn from(value: Engine) -> Self {
+        Self {
+            be: BackendEngine::Sys(value),
+            id: Self::atomic_next_engine_id(),
+        }
+    }
+}
+
+impl From<&Engine> for crate::Engine {
+    fn from(value: &Engine) -> Self {
+        Self {
+            be: BackendEngine::Sys(value.cloned()),
+            id: Self::atomic_next_engine_id(),
+        }
+    }
+}
+
+impl From<EngineBuilder> for crate::Engine {
+    fn from(value: EngineBuilder) -> Self {
+        Self {
+            be: BackendEngine::Sys(value.engine()),
+            id: Self::atomic_next_engine_id(),
+        }
+    }
+}
+
+#[cfg(feature = "cranelift")]
+impl From<wasmer_compiler_cranelift::Cranelift> for crate::Engine {
+    fn from(value: wasmer_compiler_cranelift::Cranelift) -> Self {
+        Self {
+            be: BackendEngine::Sys(value.into()),
+            id: Self::atomic_next_engine_id(),
+        }
+    }
+}
+
+#[cfg(feature = "singlepass")]
+impl From<wasmer_compiler_singlepass::Singlepass> for crate::Engine {
+    fn from(value: wasmer_compiler_singlepass::Singlepass) -> Self {
+        Self {
+            be: BackendEngine::Sys(value.into()),
+            id: Self::atomic_next_engine_id(),
+        }
+    }
+}
+
+#[cfg(feature = "llvm")]
+impl From<wasmer_compiler_llvm::LLVM> for crate::Engine {
+    fn from(value: wasmer_compiler_llvm::LLVM) -> Self {
+        Self {
+            be: BackendEngine::Sys(value.into()),
+            id: Self::atomic_next_engine_id(),
+        }
+    }
+}
diff --git a/lib/api/src/backend/sys/entities/exception.rs b/lib/api/src/backend/sys/entities/exception.rs
new file mode 100644
index 0000000000..751184cd8d
--- /dev/null
+++ b/lib/api/src/backend/sys/entities/exception.rs
@@ -0,0 +1,92 @@
+//! Data types, functions and traits for `sys` runtime's `Tag` implementation.
+use std::any::Any;
+
+use wasmer_types::{TagType, Type};
+use wasmer_vm::StoreHandle;
+
+use crate::{
+    sys::vm::{VMException, VMExceptionRef},
+    AsStoreMut, AsStoreRef, Tag, Value,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// A WebAssembly `exception` in the `sys` runtime.
+pub(crate) struct Exception {
+    pub(crate) handle: VMException,
+}
+
+unsafe impl Send for Exception {}
+unsafe impl Sync for Exception {}
+
+impl Exception {
+    /// Create a new [`Exception`].
+    pub fn new(store: &mut impl AsStoreMut, tag: Tag, payload: &[Value]) -> Self {
+        todo!()
+    }
+}
+
+#[derive(Debug, Clone)]
+#[repr(transparent)]
+/// A WebAssembly `extern ref` in the `sys` runtime.
+pub(crate) struct ExceptionRef {
+    handle: StoreHandle<wasmer_vm::VMExceptionObj>,
+}
+
+impl ExceptionRef {
+    /// Make a new extern reference
+    pub fn new<T>(store: &mut impl AsStoreMut, value: T) -> Self
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        Self {
+            handle: crate::backend::sys::store::StoreHandle::new(
+                store.objects_mut().as_sys_mut(),
+                wasmer_vm::VMExceptionObj::new(value),
+            ),
+        }
+    }
+
+    /// Try to downcast to the given value.
+    pub fn downcast<'a, T>(&self, store: &'a impl AsStoreRef) -> Option<&'a T>
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        self.handle
+            .get(store.as_store_ref().objects().as_sys())
+            .as_ref()
+            .downcast_ref::<T>()
+    }
+
+    /// Create a [`VMExceptionRef`] from [`Self`].
+    pub(crate) fn vm_exceptionref(&self) -> VMExceptionRef {
+        wasmer_vm::VMExceptionRef(self.handle.internal_handle())
+    }
+
+    /// Create an instance of [`Self`] from a [`VMExceptionRef`].
+    pub(crate) unsafe fn from_vm_exceptionref(
+        store: &mut impl AsStoreMut,
+        vm_exceptionref: VMExceptionRef,
+    ) -> Self {
+        Self {
+            handle: StoreHandle::from_internal(store.objects_mut().id(), vm_exceptionref.0),
+        }
+    }
+
+    /// Checks whether this `ExceptionRef` can be used with the given context.
+    ///
+    /// Primitive (`i32`, `i64`, etc) and null funcref/exceptionref values are not
+    /// tied to a context and can be freely shared between contexts.
+    ///
+    /// exceptionref and funcref values are tied to a context and can only be used
+    /// with that context.
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.handle.store_id() == store.as_store_ref().objects().id()
+    }
+}
+
+#[cfg(feature = "artifact-size")]
+impl loupe::MemoryUsage for Exception {
+    fn size_of_val(&self, tracker: &mut dyn loupe::MemoryUsageTracker) -> usize {
+        std::mem::size_of::<Self>()
+    }
+}
diff --git a/lib/api/src/backend/sys/entities/external.rs b/lib/api/src/backend/sys/entities/external.rs
new file mode 100644
index 0000000000..b014029b2e
--- /dev/null
+++ b/lib/api/src/backend/sys/entities/external.rs
@@ -0,0 +1,65 @@
+//! Data types, functions and traits for `sys` runtime's `ExternRef` implementation.
+
+use std::any::Any;
+use wasmer_vm::{StoreHandle, VMExternRef};
+
+use crate::store::{AsStoreMut, AsStoreRef};
+
+#[derive(Debug, Clone)]
+#[repr(transparent)]
+/// A WebAssembly `extern ref` in the `sys` runtime.
+pub(crate) struct ExternRef {
+    handle: StoreHandle<wasmer_vm::VMExternObj>,
+}
+
+impl ExternRef {
+    /// Make a new extern reference
+    pub fn new<T>(store: &mut impl AsStoreMut, value: T) -> Self
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        Self {
+            handle: StoreHandle::new(
+                store.objects_mut().as_sys_mut(),
+                wasmer_vm::VMExternObj::new(value),
+            ),
+        }
+    }
+
+    /// Try to downcast to the given value.
+    pub fn downcast<'a, T>(&self, store: &'a impl AsStoreRef) -> Option<&'a T>
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        self.handle
+            .get(store.as_store_ref().objects().as_sys())
+            .as_ref()
+            .downcast_ref::<T>()
+    }
+
+    /// Create a [`VMExternRef`] from [`Self`].
+    pub(crate) fn vm_externref(&self) -> VMExternRef {
+        wasmer_vm::VMExternRef(self.handle.internal_handle())
+    }
+
+    /// Create an instance of [`Self`] from a [`VMExternRef`].
+    pub(crate) unsafe fn from_vm_externref(
+        store: &mut impl AsStoreMut,
+        vm_externref: VMExternRef,
+    ) -> Self {
+        Self {
+            handle: StoreHandle::from_internal(store.objects_mut().id(), vm_externref.0),
+        }
+    }
+
+    /// Checks whether this `ExternRef` can be used with the given context.
+    ///
+    /// Primitive (`i32`, `i64`, etc) and null funcref/externref values are not
+    /// tied to a context and can be freely shared between contexts.
+    ///
+    /// Externref and funcref values are tied to a context and can only be used
+    /// with that context.
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.handle.store_id() == store.as_store_ref().objects().id()
+    }
+}
diff --git a/lib/api/src/backend/sys/entities/function/env.rs b/lib/api/src/backend/sys/entities/function/env.rs
new file mode 100644
index 0000000000..362804a593
--- /dev/null
+++ b/lib/api/src/backend/sys/entities/function/env.rs
@@ -0,0 +1,209 @@
+use std::{any::Any, fmt::Debug, marker::PhantomData};
+
+use crate::{
+    store::{AsStoreMut, AsStoreRef, StoreRef},
+    StoreMut,
+};
+
+use wasmer_vm::{StoreHandle, StoreObject, StoreObjects, VMFunctionEnvironment};
+
+#[derive(Debug)]
+#[repr(transparent)]
+/// An opaque reference to a function environment.
+/// The function environment data is owned by the `Store`.
+pub struct FunctionEnv<T> {
+    pub(crate) handle: StoreHandle<VMFunctionEnvironment>,
+    marker: PhantomData<T>,
+}
+
+impl<T> FunctionEnv<T> {
+    /// Make a new FunctionEnv
+    pub fn new(store: &mut impl AsStoreMut, value: T) -> Self
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        Self {
+            handle: StoreHandle::new(
+                store.as_store_mut().objects_mut().as_sys_mut(),
+                VMFunctionEnvironment::new(value),
+            ),
+            marker: PhantomData,
+        }
+    }
+
+    /// Get the data as reference
+    pub fn as_ref<'a>(&self, store: &'a impl AsStoreRef) -> &'a T
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        self.handle
+            .get(store.as_store_ref().objects().as_sys())
+            .as_ref()
+            .downcast_ref::<T>()
+            .unwrap()
+    }
+
+    #[allow(dead_code)] // This function is only used in js
+    pub(crate) fn from_handle(handle: StoreHandle<VMFunctionEnvironment>) -> Self {
+        Self {
+            handle,
+            marker: PhantomData,
+        }
+    }
+
+    /// Get the data as mutable
+    pub fn as_mut<'a>(&self, store: &'a mut impl AsStoreMut) -> &'a mut T
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        self.handle
+            .get_mut(store.objects_mut().as_sys_mut())
+            .as_mut()
+            .downcast_mut::<T>()
+            .unwrap()
+    }
+
+    /// Convert it into a `FunctionEnvMut`
+    pub fn into_mut(self, store: &mut impl AsStoreMut) -> FunctionEnvMut<T>
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        FunctionEnvMut {
+            store_mut: store.as_store_mut(),
+            func_env: self,
+        }
+    }
+}
+
+impl<T> crate::FunctionEnv<T> {
+    /// Consume self into [`crate::backend::sys::function::FunctionEnv`].
+    pub fn into_sys(self) -> FunctionEnv<T> {
+        match self.0 {
+            crate::BackendFunctionEnv::Sys(s) => s,
+            _ => panic!("Not a `sys` function env!"),
+        }
+    }
+
+    /// Convert a reference to self into a reference to [`crate::backend::sys::function::FunctionEnv`].
+    pub fn as_sys(&self) -> &FunctionEnv<T> {
+        match self.0 {
+            crate::BackendFunctionEnv::Sys(ref s) => s,
+            _ => panic!("Not a `sys` function env!"),
+        }
+    }
+
+    /// Convert a mutable reference to self into a mutable reference [`crate::backend::sys::function::FunctionEnv`].
+    pub fn as_sys_mut(&mut self) -> &mut FunctionEnv<T> {
+        match self.0 {
+            crate::BackendFunctionEnv::Sys(ref mut s) => s,
+            _ => panic!("Not a `sys` function env!"),
+        }
+    }
+}
+
+impl<T> PartialEq for FunctionEnv<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.handle == other.handle
+    }
+}
+
+impl<T> Eq for FunctionEnv<T> {}
+
+impl<T> std::hash::Hash for FunctionEnv<T> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.handle.hash(state);
+        self.marker.hash(state);
+    }
+}
+
+impl<T> Clone for FunctionEnv<T> {
+    fn clone(&self) -> Self {
+        Self {
+            handle: self.handle.clone(),
+            marker: self.marker,
+        }
+    }
+}
+
+/// A temporary handle to a [`FunctionEnv`].
+pub struct FunctionEnvMut<'a, T: 'a> {
+    pub(crate) store_mut: StoreMut<'a>,
+    pub(crate) func_env: FunctionEnv<T>,
+}
+
+impl<T> Debug for FunctionEnvMut<'_, T>
+where
+    T: Send + Debug + 'static,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.func_env.as_ref(&self.store_mut).fmt(f)
+    }
+}
+
+impl<T: Send + 'static> FunctionEnvMut<'_, T> {
+    /// Returns a reference to the host state in this function environement.
+    pub fn data(&self) -> &T {
+        self.func_env.as_ref(&self.store_mut)
+    }
+
+    /// Returns a mutable- reference to the host state in this function environement.
+    pub fn data_mut(&mut self) -> &mut T {
+        self.func_env.as_mut(&mut self.store_mut)
+    }
+
+    /// Borrows a new immmutable reference
+    pub fn as_ref(&self) -> FunctionEnv<T> {
+        self.func_env.clone()
+    }
+
+    /// Borrows a new mutable reference
+    pub fn as_mut(&mut self) -> FunctionEnvMut<'_, T> {
+        FunctionEnvMut {
+            store_mut: self.store_mut.as_store_mut(),
+            func_env: self.func_env.clone(),
+        }
+    }
+
+    /// Borrows a new mutable reference of both the attached Store and host state
+    pub fn data_and_store_mut(&mut self) -> (&mut T, StoreMut) {
+        let data = self.func_env.as_mut(&mut self.store_mut) as *mut T;
+        // telling the borrow check to close his eyes here
+        // this is still relatively safe to do as func_env are
+        // stored in a specific vec of Store, separate from the other objects
+        // and not really directly accessible with the StoreMut
+        let data = unsafe { &mut *data };
+        (data, self.store_mut.as_store_mut())
+    }
+}
+
+impl<T> AsStoreRef for FunctionEnvMut<'_, T> {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        StoreRef {
+            inner: self.store_mut.inner,
+        }
+    }
+}
+
+impl<T> AsStoreMut for FunctionEnvMut<'_, T> {
+    fn as_store_mut(&mut self) -> StoreMut<'_> {
+        StoreMut {
+            inner: self.store_mut.inner,
+        }
+    }
+
+    fn objects_mut(&mut self) -> &mut crate::StoreObjects {
+        self.store_mut.objects_mut()
+    }
+}
+
+impl<'a, T> From<FunctionEnvMut<'a, T>> for crate::FunctionEnvMut<'a, T> {
+    fn from(value: FunctionEnvMut<'a, T>) -> Self {
+        crate::FunctionEnvMut(crate::BackendFunctionEnvMut::Sys(value))
+    }
+}
+
+impl<T> From<FunctionEnv<T>> for crate::FunctionEnv<T> {
+    fn from(value: FunctionEnv<T>) -> Self {
+        Self(crate::BackendFunctionEnv::Sys(value))
+    }
+}
diff --git a/lib/api/src/sys/externals/function.rs b/lib/api/src/backend/sys/entities/function/mod.rs
similarity index 64%
rename from lib/api/src/sys/externals/function.rs
rename to lib/api/src/backend/sys/entities/function/mod.rs
index 41c292f90c..e032cb5c6f 100644
--- a/lib/api/src/sys/externals/function.rs
+++ b/lib/api/src/backend/sys/entities/function/mod.rs
@@ -1,19 +1,28 @@
-use crate::externals::function::{HostFunction, WithEnv, WithoutEnv};
-use crate::native_type::{FromToNativeWasmType, IntoResult, NativeWasmTypeInto, WasmTypeList};
-use crate::store::{AsStoreMut, AsStoreRef, StoreInner, StoreMut};
-use crate::sys::engine::NativeEngineExt;
-use crate::vm::{VMExternFunction, VMFunctionCallback};
-use crate::{FunctionEnv, FunctionEnvMut, FunctionType, RuntimeError, Value};
+//! Data types, functions and traits for `sys` runtime's `Function` implementation.
+
+pub(crate) mod env;
+pub(crate) mod typed;
+
+use crate::{
+    backend::sys::{engine::NativeEngineExt, vm::VMFunctionCallback},
+    entities::store::{AsStoreMut, AsStoreRef, StoreMut},
+    utils::{FromToNativeWasmType, IntoResult, NativeWasmTypeInto, WasmTypeList},
+    vm::{VMExtern, VMExternFunction},
+    BackendFunction, FunctionEnv, FunctionEnvMut, FunctionType, HostFunction, RuntimeError,
+    StoreInner, Value, WithEnv, WithoutEnv,
+};
 use std::panic::{self, AssertUnwindSafe};
 use std::{cell::UnsafeCell, cmp::max, ffi::c_void};
 use wasmer_types::{NativeWasmType, RawValue};
 use wasmer_vm::{
     on_host_stack, raise_user_trap, resume_panic, wasmer_call_trampoline, MaybeInstanceOwned,
-    StoreHandle, VMCallerCheckedAnyfunc, VMContext, VMDynamicFunctionContext, VMExtern, VMFuncRef,
-    VMFunction, VMFunctionContext, VMFunctionKind, VMTrampoline,
+    StoreHandle, VMCallerCheckedAnyfunc, VMContext, VMDynamicFunctionContext, VMFuncRef,
+    VMFunction, VMFunctionBody, VMFunctionContext, VMFunctionKind, VMTrampoline,
 };
 
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[derive(Debug, Clone, PartialEq, Eq)]
+/// A WebAssembly `function` instance, in the `sys` runtime.
 pub struct Function {
     pub(crate) handle: StoreHandle<VMFunction>,
 }
@@ -25,7 +34,7 @@ impl From<StoreHandle<VMFunction>> for Function {
 }
 
 impl Function {
-    pub fn new_with_env<FT, F, T: Send + 'static>(
+    pub(crate) fn new_with_env<FT, F, T: Send + 'static>(
         store: &mut impl AsStoreMut,
         env: &FunctionEnv<T>,
         ty: FT,
@@ -40,20 +49,26 @@ impl Function {
     {
         let function_type = ty.into();
         let func_ty = function_type.clone();
-        let func_env = env.clone();
+        let func_env = env.clone().into_sys();
         let raw_store = store.as_store_mut().as_raw() as *mut u8;
         let wrapper = move |values_vec: *mut RawValue| -> Result<(), RuntimeError> {
             unsafe {
                 let mut store = StoreMut::from_raw(raw_store as *mut StoreInner);
                 let mut args = Vec::with_capacity(func_ty.params().len());
+
                 for (i, ty) in func_ty.params().iter().enumerate() {
-                    args.push(Value::from_raw(&mut store, *ty, *values_vec.add(i)));
+                    args.push(Value::from_raw(
+                        &mut store,
+                        *ty,
+                        values_vec.add(i).read_unaligned(),
+                    ));
                 }
                 let store_mut = StoreMut::from_raw(raw_store as *mut StoreInner);
-                let env = FunctionEnvMut {
+                let env = env::FunctionEnvMut {
                     store_mut,
                     func_env: func_env.clone(),
-                };
+                }
+                .into();
                 let returns = func(env, &args)?;
 
                 // We need to dynamically check that the returns
@@ -67,7 +82,7 @@ impl Function {
                     )));
                 }
                 for (i, ret) in returns.iter().enumerate() {
-                    *values_vec.add(i) = ret.as_raw(&store);
+                    values_vec.add(i).write_unaligned(ret.as_raw(&store));
                 }
             }
             Ok(())
@@ -85,7 +100,7 @@ impl Function {
         let type_index = store
             .as_store_mut()
             .engine()
-            .0
+            .as_sys()
             .register_signature(&function_type);
         let vmctx = VMFunctionContext {
             host_env: host_data.as_ref() as *const _ as *mut c_void,
@@ -105,19 +120,19 @@ impl Function {
             host_data,
         };
         Self {
-            handle: StoreHandle::new(store.as_store_mut().objects_mut(), vm_function),
+            handle: StoreHandle::new(store.as_store_mut().objects_mut().as_sys_mut(), vm_function),
         }
     }
 
     /// Creates a new host `Function` from a native function.
-    pub fn new_typed<F, Args, Rets>(store: &mut impl AsStoreMut, func: F) -> Self
+    pub(crate) fn new_typed<F, Args, Rets>(store: &mut impl AsStoreMut, func: F) -> Self
     where
         F: HostFunction<(), Args, Rets, WithoutEnv> + 'static + Send + Sync,
         Args: WasmTypeList,
         Rets: WasmTypeList,
     {
         let env = FunctionEnv::new(store, ());
-        let func_ptr = func.function_callback();
+        let func_ptr = func.function_callback_sys().into_sys();
         let host_data = Box::new(StaticFunction {
             raw_store: store.as_store_mut().as_raw() as *mut u8,
             env,
@@ -128,13 +143,13 @@ impl Function {
         let type_index = store
             .as_store_mut()
             .engine()
-            .0
+            .as_sys()
             .register_signature(&function_type);
         let vmctx = VMFunctionContext {
             host_env: host_data.as_ref() as *const _ as *mut c_void,
         };
         let call_trampoline =
-            <F as HostFunction<(), Args, Rets, WithoutEnv>>::call_trampoline_address();
+            <F as HostFunction<(), Args, Rets, WithoutEnv>>::call_trampoline_address().into_sys();
         let anyfunc = VMCallerCheckedAnyfunc {
             func_ptr,
             type_index,
@@ -149,11 +164,11 @@ impl Function {
             host_data,
         };
         Self {
-            handle: StoreHandle::new(store.as_store_mut().objects_mut(), vm_function),
+            handle: StoreHandle::new(store.as_store_mut().objects_mut().as_sys_mut(), vm_function),
         }
     }
 
-    pub fn new_typed_with_env<T: Send + 'static, F, Args, Rets>(
+    pub(crate) fn new_typed_with_env<T: Send + 'static, F, Args, Rets>(
         store: &mut impl AsStoreMut,
         env: &FunctionEnv<T>,
         func: F,
@@ -163,10 +178,10 @@ impl Function {
         Args: WasmTypeList,
         Rets: WasmTypeList,
     {
-        let func_ptr = func.function_callback();
+        let func_ptr = func.function_callback_sys().into_sys();
         let host_data = Box::new(StaticFunction {
             raw_store: store.as_store_mut().as_raw() as *mut u8,
-            env: env.clone(),
+            env: env.as_sys().clone().into(),
             func,
         });
         let function_type = FunctionType::new(Args::wasm_types(), Rets::wasm_types());
@@ -174,13 +189,13 @@ impl Function {
         let type_index = store
             .as_store_mut()
             .engine()
-            .0
+            .as_sys()
             .register_signature(&function_type);
         let vmctx = VMFunctionContext {
             host_env: host_data.as_ref() as *const _ as *mut c_void,
         };
         let call_trampoline =
-            <F as HostFunction<T, Args, Rets, WithEnv>>::call_trampoline_address();
+            <F as HostFunction<T, Args, Rets, WithEnv>>::call_trampoline_address().into_sys();
         let anyfunc = VMCallerCheckedAnyfunc {
             func_ptr,
             type_index,
@@ -195,13 +210,13 @@ impl Function {
             host_data,
         };
         Self {
-            handle: StoreHandle::new(store.as_store_mut().objects_mut(), vm_function),
+            handle: StoreHandle::new(store.as_store_mut().objects_mut().as_sys_mut(), vm_function),
         }
     }
 
-    pub fn ty(&self, store: &impl AsStoreRef) -> FunctionType {
+    pub(crate) fn ty(&self, store: &impl AsStoreRef) -> FunctionType {
         self.handle
-            .get(store.as_store_ref().objects())
+            .get(store.as_store_ref().objects().as_sys())
             .signature
             .clone()
     }
@@ -273,7 +288,7 @@ impl Function {
             // TODO: This loop is needed for asyncify. It will be refactored with https://github.com/wasmerio/wasmer/issues/3451
             loop {
                 let storeref = store.as_store_ref();
-                let vm_function = self.handle.get(storeref.objects());
+                let vm_function = self.handle.get(storeref.objects().as_sys());
                 let config = storeref.engine().tunables().vmconfig();
                 r = unsafe {
                     wasmer_call_trampoline(
@@ -319,18 +334,18 @@ impl Function {
         Ok(())
     }
 
-    pub fn result_arity(&self, store: &impl AsStoreRef) -> usize {
+    pub(crate) fn result_arity(&self, store: &impl AsStoreRef) -> usize {
         self.ty(store).results().len()
     }
 
-    pub fn call(
+    pub(crate) fn call(
         &self,
         store: &mut impl AsStoreMut,
         params: &[Value],
     ) -> Result<Box<[Value]>, RuntimeError> {
         let trampoline = unsafe {
             self.handle
-                .get(store.as_store_ref().objects())
+                .get(store.as_store_ref().objects().as_sys())
                 .anyfunc
                 .as_ptr()
                 .as_ref()
@@ -343,14 +358,14 @@ impl Function {
 
     #[doc(hidden)]
     #[allow(missing_docs)]
-    pub fn call_raw(
+    pub(crate) fn call_raw(
         &self,
         store: &mut impl AsStoreMut,
         params: Vec<RawValue>,
     ) -> Result<Box<[Value]>, RuntimeError> {
         let trampoline = unsafe {
             self.handle
-                .get(store.as_store_ref().objects())
+                .get(store.as_store_ref().objects().as_sys())
                 .anyfunc
                 .as_ptr()
                 .as_ref()
@@ -362,7 +377,7 @@ impl Function {
     }
 
     pub(crate) fn vm_funcref(&self, store: &impl AsStoreRef) -> VMFuncRef {
-        let vm_function = self.handle.get(store.as_store_ref().objects());
+        let vm_function = self.handle.get(store.as_store_ref().objects().as_sys());
         if vm_function.kind == VMFunctionKind::Dynamic {
             panic!("dynamic functions cannot be used in tables or as funcrefs");
         }
@@ -373,7 +388,7 @@ impl Function {
         let signature = store
             .as_store_ref()
             .engine()
-            .0
+            .as_sys()
             .lookup_signature(funcref.0.as_ref().type_index)
             .expect("Signature not found in store");
         let vm_function = VMFunction {
@@ -385,25 +400,28 @@ impl Function {
             host_data: Box::new(()),
         };
         Self {
-            handle: StoreHandle::new(store.as_store_mut().objects_mut(), vm_function),
+            handle: StoreHandle::new(store.objects_mut().as_sys_mut(), vm_function),
         }
     }
 
     pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternFunction) -> Self {
         Self {
             handle: unsafe {
-                StoreHandle::from_internal(store.as_store_ref().objects().id(), vm_extern)
+                StoreHandle::from_internal(
+                    store.as_store_ref().objects().id(),
+                    vm_extern.into_sys(),
+                )
             },
         }
     }
 
     /// Checks whether this `Function` can be used with the given store.
-    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+    pub(crate) fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
         self.handle.store_id() == store.as_store_ref().objects().id()
     }
 
     pub(crate) fn to_vm_extern(&self) -> VMExtern {
-        VMExtern::Function(self.handle.internal_handle())
+        VMExtern::Sys(wasmer_vm::VMExtern::Function(self.handle.internal_handle()))
     }
 }
 
@@ -422,12 +440,18 @@ where
         this: &mut VMDynamicFunctionContext<Self>,
         values_vec: *mut RawValue,
     ) {
-        let result =
-            on_host_stack(|| panic::catch_unwind(AssertUnwindSafe(|| (this.ctx.func)(values_vec))));
+        let result = on_host_stack(|| {
+            panic::catch_unwind(AssertUnwindSafe(|| {
+                (this.ctx.func)(values_vec).map_err(Box::new)
+            }))
+        });
 
+        // IMPORTANT: DO NOT ALLOCATE ON THE STACK,
+        // AS WE ARE IN THE WASM STACK, NOT ON THE HOST ONE.
+        // See: https://github.com/wasmerio/wasmer/pull/5700
         match result {
             Ok(Ok(())) => {}
-            Ok(Err(trap)) => raise_user_trap(Box::new(trap)),
+            Ok(Err(trap)) => raise_user_trap(trap),
             Err(panic) => resume_panic(panic),
         }
     }
@@ -461,174 +485,166 @@ pub(crate) struct StaticFunction<F, T> {
     pub(crate) func: F,
 }
 
+impl crate::Function {
+    /// Consume [`self`] into [`crate::backend::sys::function::Function`].
+    pub fn into_sys(self) -> crate::backend::sys::function::Function {
+        match self.0 {
+            BackendFunction::Sys(s) => s,
+            _ => panic!("Not a `sys` function!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference to [`crate::backend::sys::function::Function`].
+    pub fn as_sys(&self) -> &crate::backend::sys::function::Function {
+        match self.0 {
+            BackendFunction::Sys(ref s) => s,
+            _ => panic!("Not a `sys` function!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::sys::function::Function`].
+    pub fn as_sys_mut(&mut self) -> &mut crate::backend::sys::function::Function {
+        match self.0 {
+            BackendFunction::Sys(ref mut s) => s,
+            _ => panic!("Not a `sys` function!"),
+        }
+    }
+}
+
 macro_rules! impl_host_function {
-        ( [$c_struct_representation:ident]
-           $c_struct_name:ident,
-           $( $x:ident ),* ) => {
-
-            // Implement `HostFunction` for a function with a [`FunctionEnvMut`] that has the same
-            // arity than the tuple.
-            #[allow(unused_parens)]
-            impl< $( $x, )* Rets, RetsAsResult, T: Send + 'static, Func >
-                HostFunction<T, ( $( $x ),* ), Rets, WithEnv>
-            for
-                Func
+    ([$c_struct_representation:ident] $c_struct_name:ident, $( $x:ident ),* ) => {
+        paste::paste! {
+        #[allow(non_snake_case)]
+        pub(crate) fn [<gen_fn_callback_ $c_struct_name:lower _no_env>]
+            <$( $x: FromToNativeWasmType, )* Rets: WasmTypeList, RetsAsResult: IntoResult<Rets>, Func: Fn($( $x , )*) -> RetsAsResult + 'static>
+            (this: &Func) -> crate::backend::sys::vm::VMFunctionCallback {
+            /// This is a function that wraps the real host
+            /// function. Its address will be used inside the
+            /// runtime.
+            unsafe extern "C" fn func_wrapper<$( $x, )* Rets, RetsAsResult, Func>( env: &StaticFunction<Func, ()>, $( $x: <$x::Native as NativeWasmType>::Abi, )* ) -> Rets::CStruct
             where
                 $( $x: FromToNativeWasmType, )*
                 Rets: WasmTypeList,
                 RetsAsResult: IntoResult<Rets>,
-                Func: Fn(FunctionEnvMut<T>, $( $x , )*) -> RetsAsResult + 'static,
+                Func: Fn($( $x , )*) -> RetsAsResult + 'static,
             {
-                #[allow(non_snake_case)]
-                fn function_callback(&self) -> VMFunctionCallback {
-                    /// This is a function that wraps the real host
-                    /// function. Its address will be used inside the
-                    /// runtime.
-                    unsafe extern "C" fn func_wrapper<T: Send + 'static, $( $x, )* Rets, RetsAsResult, Func>( env: &StaticFunction<Func, T>, $( $x: <$x::Native as NativeWasmType>::Abi, )* ) -> Rets::CStruct
-                    where
-                        $( $x: FromToNativeWasmType, )*
-                        Rets: WasmTypeList,
-                        RetsAsResult: IntoResult<Rets>,
-                        Func: Fn(FunctionEnvMut<T>, $( $x , )*) -> RetsAsResult + 'static,
-                    {
-                        // println!("func wrapper");
-                        let mut store = StoreMut::from_raw(env.raw_store as *mut _);
-                        let result = on_host_stack(|| {
-                            // println!("func wrapper1");
-                            panic::catch_unwind(AssertUnwindSafe(|| {
-                                $(
-                                    let $x = FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(&mut store, $x));
-                                )*
-                                // println!("func wrapper2 {:p}", *env.raw_env);
-                                let store_mut = StoreMut::from_raw(env.raw_store as *mut _);
-                                let f_env = FunctionEnvMut {
-                                    store_mut,
-                                    func_env: env.env.clone(),
-                                };
-                                // println!("func wrapper3");
-                                (env.func)(f_env, $($x),* ).into_result()
-                            }))
-                        });
-
-                        match result {
-                            Ok(Ok(result)) => return result.into_c_struct(&mut store),
-                            Ok(Err(trap)) => raise_user_trap(Box::new(trap)),
-                            Err(panic) => resume_panic(panic) ,
-                        }
-                    }
-
-                    func_wrapper::< T, $( $x, )* Rets, RetsAsResult, Self > as VMFunctionCallback
+                let mut store = StoreMut::from_raw(env.raw_store as *mut _);
+                let result = on_host_stack(|| {
+                    panic::catch_unwind(AssertUnwindSafe(|| {
+                        $(
+                            let $x = FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(&mut store, $x));
+                        )*
+                        (env.func)($($x),* ).into_result().map_err(Box::new)
+                    }))
+                });
+
+                // IMPORTANT: DO NOT ALLOCATE ON THE STACK,
+                // AS WE ARE IN THE WASM STACK, NOT ON THE HOST ONE.
+                // See: https://github.com/wasmerio/wasmer/pull/5700
+                match result {
+                    Ok(Ok(result)) => return result.into_c_struct(&mut store),
+                    Ok(Err(trap)) => raise_user_trap(trap),
+                    Err(panic) => resume_panic(panic) ,
                 }
+            }
 
-                #[allow(non_snake_case)]
-                fn call_trampoline_address() -> VMTrampoline {
-                    unsafe extern "C" fn call_trampoline<
-                        $( $x: FromToNativeWasmType, )*
-                        Rets: WasmTypeList,
-                    >(
-                        vmctx: *mut VMContext,
-                        body: VMFunctionCallback,
-                        args: *mut RawValue,
-                    ) {
-                            let body: unsafe extern "C" fn(
-                                vmctx: *mut VMContext,
-                                $( $x: <$x::Native as NativeWasmType>::Abi, )*
-                            ) -> Rets::CStruct
-                                = std::mem::transmute(body);
-
-                            let mut _n = 0;
-                            $(
-                                let $x = *args.add(_n).cast();
-                                _n += 1;
-                            )*
-
-                            let results = body(vmctx, $( $x ),*);
-                            Rets::write_c_struct_to_ptr(results, args);
-                    }
+            func_wrapper::< $( $x, )* Rets, RetsAsResult, Func > as _
 
-                    call_trampoline::<$( $x, )* Rets>
-                }
+        }
 
+        #[allow(non_snake_case)]
+        pub(crate) fn [<gen_call_trampoline_address_ $c_struct_name:lower _no_env>]
+            <$( $x: FromToNativeWasmType, )* Rets: WasmTypeList>
+            () -> crate::backend::sys::vm::VMTrampoline {
+
+            unsafe extern "C" fn call_trampoline<$( $x: FromToNativeWasmType, )* Rets: WasmTypeList>
+            (
+                vmctx: *mut crate::backend::sys::vm::VMContext,
+                body: crate::backend::sys::vm::VMFunctionCallback,
+                args: *mut RawValue,
+            ) {
+                let body: unsafe extern "C" fn(vmctx: *mut crate::backend::sys::vm::VMContext, $( $x: <$x::Native as NativeWasmType>::Abi, )*) -> Rets::CStruct = std::mem::transmute(body);
+                let mut _n = 0;
+                $(
+                    let $x = *args.add(_n).cast();
+                    _n += 1;
+                )*
+
+                let results = body(vmctx, $( $x ),*);
+                Rets::write_c_struct_to_ptr(results, args);
             }
 
-            // Implement `HostFunction` for a function that has the same arity than the tuple.
-            #[allow(unused_parens)]
-            impl< $( $x, )* Rets, RetsAsResult, Func >
-                HostFunction<(), ( $( $x ),* ), Rets, WithoutEnv>
-            for
-                Func
-            where
+            call_trampoline::<$( $x, )* Rets> as _
+
+        }
+
+        #[allow(non_snake_case)]
+        pub(crate) fn [<gen_fn_callback_ $c_struct_name:lower>]
+            <$( $x: FromToNativeWasmType, )* Rets: WasmTypeList, RetsAsResult: IntoResult<Rets>, T: Send + 'static,  Func: Fn(FunctionEnvMut<T>, $( $x , )*) -> RetsAsResult + 'static>
+            (this: &Func) -> crate::backend::sys::vm::VMFunctionCallback {
+            /// This is a function that wraps the real host
+            /// function. Its address will be used inside the
+            /// runtime.
+            unsafe extern "C" fn func_wrapper<T: Send + 'static, $( $x, )* Rets, RetsAsResult, Func>( env: &StaticFunction<Func, T>, $( $x: <$x::Native as NativeWasmType>::Abi, )* ) -> Rets::CStruct
+                where
                 $( $x: FromToNativeWasmType, )*
                 Rets: WasmTypeList,
                 RetsAsResult: IntoResult<Rets>,
-                Func: Fn($( $x , )*) -> RetsAsResult + 'static,
+                Func: Fn(FunctionEnvMut<T>, $( $x , )*) -> RetsAsResult + 'static,
             {
-                #[allow(non_snake_case)]
-                fn function_callback(&self) -> VMFunctionCallback {
-                    /// This is a function that wraps the real host
-                    /// function. Its address will be used inside the
-                    /// runtime.
-                    unsafe extern "C" fn func_wrapper<$( $x, )* Rets, RetsAsResult, Func>( env: &StaticFunction<Func, ()>, $( $x: <$x::Native as NativeWasmType>::Abi, )* ) -> Rets::CStruct
-                    where
-                        $( $x: FromToNativeWasmType, )*
-                        Rets: WasmTypeList,
-                        RetsAsResult: IntoResult<Rets>,
-                        Func: Fn($( $x , )*) -> RetsAsResult + 'static,
-                    {
-                        // println!("func wrapper");
-                        let mut store = StoreMut::from_raw(env.raw_store as *mut _);
-                        let result = on_host_stack(|| {
-                            // println!("func wrapper1");
-                            panic::catch_unwind(AssertUnwindSafe(|| {
-                                $(
-                                    let $x = FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(&mut store, $x));
-                                )*
-                                (env.func)($($x),* ).into_result()
-                            }))
-                        });
-
-                        match result {
-                            Ok(Ok(result)) => return result.into_c_struct(&mut store),
-                            Ok(Err(trap)) => raise_user_trap(Box::new(trap)),
-                            Err(panic) => resume_panic(panic) ,
-                        }
-                    }
 
-                    func_wrapper::< $( $x, )* Rets, RetsAsResult, Self > as VMFunctionCallback
-                }
-
-                #[allow(non_snake_case)]
-                fn call_trampoline_address() -> VMTrampoline {
-                    unsafe extern "C" fn call_trampoline<
-                        $( $x: FromToNativeWasmType, )*
-                        Rets: WasmTypeList,
-                    >(
-                        vmctx: *mut VMContext,
-                        body: VMFunctionCallback,
-                        args: *mut RawValue,
-                    ) {
-                            let body: unsafe extern "C" fn(
-                                vmctx: *mut VMContext,
-                                $( $x: <$x::Native as NativeWasmType>::Abi, )*
-                            ) -> Rets::CStruct
-                                = std::mem::transmute(body);
-
-                            let mut _n = 0;
-                            $(
-                                let $x = *args.add(_n).cast();
-                                _n += 1;
-                            )*
-
-                            let results = body(vmctx, $( $x ),*);
-                            Rets::write_c_struct_to_ptr(results, args);
-                    }
-
-                    call_trampoline::<$( $x, )* Rets>
+                let mut store = StoreMut::from_raw(env.raw_store as *mut _);
+                let result = wasmer_vm::on_host_stack(|| {
+                    panic::catch_unwind(AssertUnwindSafe(|| {
+                        $(
+                            let $x = FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(&mut store, $x));
+                        )*
+                        let store_mut = StoreMut::from_raw(env.raw_store as *mut _);
+                        let f_env = crate::backend::sys::function::env::FunctionEnvMut {
+                            store_mut,
+                            func_env: env.env.as_sys().clone(),
+                        }.into();
+                        (env.func)(f_env, $($x),* ).into_result().map_err(Box::new)
+                    }))
+                });
+
+                // IMPORTANT: DO NOT ALLOCATE ON THE STACK,
+                // AS WE ARE IN THE WASM STACK, NOT ON THE HOST ONE.
+                // See: https://github.com/wasmerio/wasmer/pull/5700
+                match result {
+                    Ok(Ok(result)) => return result.into_c_struct(&mut store),
+                    Ok(Err(trap)) => raise_user_trap(trap),
+                    Err(panic) => resume_panic(panic),
                 }
+            }
+            func_wrapper::< T, $( $x, )* Rets, RetsAsResult, Func > as _
+        }
 
+        #[allow(non_snake_case)]
+        pub(crate) fn [<gen_call_trampoline_address_ $c_struct_name:lower>]
+            <$( $x: FromToNativeWasmType, )* Rets: WasmTypeList>
+            () -> crate::backend::sys::vm::VMTrampoline {
+
+            unsafe extern "C" fn call_trampoline<$( $x: FromToNativeWasmType, )* Rets: WasmTypeList>(
+                  vmctx: *mut crate::backend::sys::vm::VMContext,
+                  body: crate::backend::sys::vm::VMFunctionCallback,
+                  args: *mut RawValue,
+            ) {
+                let body: unsafe extern "C" fn(vmctx: *mut crate::backend::sys::vm::VMContext, $( $x: <$x::Native as NativeWasmType>::Abi, )*) -> Rets::CStruct = std::mem::transmute(body);
+                let mut _n = 0;
+                $(
+                let $x = *args.add(_n).cast();
+                _n += 1;
+                )*
+
+                let results = body(vmctx, $( $x ),*);
+                Rets::write_c_struct_to_ptr(results, args);
             }
-        };
-    }
+
+            call_trampoline::<$( $x, )* Rets> as _
+        }
+    }};
+}
 
 // Here we go! Let's generate all the C struct, `WasmTypeList`
 // implementations and `HostFunction` implementations.
diff --git a/lib/api/src/sys/typed_function.rs b/lib/api/src/backend/sys/entities/function/typed.rs
similarity index 94%
rename from lib/api/src/sys/typed_function.rs
rename to lib/api/src/backend/sys/entities/function/typed.rs
index 1ff5d252bd..53f5f9c1a1 100644
--- a/lib/api/src/sys/typed_function.rs
+++ b/lib/api/src/backend/sys/entities/function/typed.rs
@@ -1,9 +1,7 @@
-use crate::{FromToNativeWasmType, RuntimeError, TypedFunction, WasmTypeList};
-use wasmer_types::RawValue;
-
-use crate::native_type::NativeWasmTypeInto;
+use crate::backend::sys::engine::NativeEngineExt;
 use crate::store::{AsStoreMut, AsStoreRef};
-use crate::sys::engine::NativeEngineExt;
+use crate::{FromToNativeWasmType, NativeWasmTypeInto, RuntimeError, TypedFunction, WasmTypeList};
+use wasmer_types::RawValue;
 
 macro_rules! impl_native_traits {
     (  $( $x:ident ),* ) => {
@@ -16,11 +14,11 @@ macro_rules! impl_native_traits {
             /// Call the typed func and return results.
             #[allow(unused_mut)]
             #[allow(clippy::too_many_arguments)]
-            pub fn call(&self, store: &mut impl AsStoreMut, $( $x: $x, )* ) -> Result<Rets, RuntimeError> {
+            pub fn call_sys(&self, store: &mut impl AsStoreMut, $( $x: $x, )* ) -> Result<Rets, RuntimeError> {
                 let anyfunc = unsafe {
-                    *self.func.0
+                    *self.func.as_sys()
                         .handle
-                        .get(store.as_store_ref().objects())
+                        .get(store.as_store_ref().objects().as_sys())
                         .anyfunc
                         .as_ptr()
                         .as_ref()
@@ -105,11 +103,11 @@ macro_rules! impl_native_traits {
             #[allow(missing_docs)]
             #[allow(unused_mut)]
             #[allow(clippy::too_many_arguments)]
-            pub fn call_raw(&self, store: &mut impl AsStoreMut, mut params_list: Vec<RawValue> ) -> Result<Rets, RuntimeError> {
+            pub fn call_raw_sys(&self, store: &mut impl AsStoreMut, mut params_list: Vec<RawValue> ) -> Result<Rets, RuntimeError> {
                 let anyfunc = unsafe {
-                    *self.func.0
+                    *self.func.as_sys()
                         .handle
-                        .get(store.as_store_ref().objects())
+                        .get(store.as_store_ref().objects().as_sys())
                         .anyfunc
                         .as_ptr()
                         .as_ref()
diff --git a/lib/api/src/sys/externals/global.rs b/lib/api/src/backend/sys/entities/global.rs
similarity index 65%
rename from lib/api/src/sys/externals/global.rs
rename to lib/api/src/backend/sys/entities/global.rs
index 8d43e80f08..893db3f47a 100644
--- a/lib/api/src/sys/externals/global.rs
+++ b/lib/api/src/backend/sys/entities/global.rs
@@ -1,12 +1,17 @@
-use crate::errors::RuntimeError;
-use crate::store::{AsStoreMut, AsStoreRef};
-use crate::value::Value;
-use crate::vm::VMExternGlobal;
-use crate::GlobalType;
-use crate::Mutability;
-use wasmer_vm::{StoreHandle, VMExtern, VMGlobal};
+//! Data types, functions and traits for `sys` runtime's `Global` implementation.
+
+use crate::{
+    error::RuntimeError,
+    store::{AsStoreMut, AsStoreRef},
+    value::Value,
+    vm::{VMExtern, VMExternGlobal},
+};
+use wasmer_types::{GlobalType, Mutability};
+use wasmer_vm::{StoreHandle, VMGlobal};
 
 #[derive(Debug, Clone)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+/// A WebAssembly `global` in the `sys` runtime.
 pub struct Global {
     handle: StoreHandle<VMGlobal>,
 }
@@ -30,24 +35,27 @@ impl Global {
         }
 
         Ok(Self {
-            handle: StoreHandle::new(store.objects_mut(), global),
+            handle: StoreHandle::new(store.objects_mut().as_sys_mut(), global),
         })
     }
 
-    pub fn ty(&self, store: &impl AsStoreRef) -> GlobalType {
-        *self.handle.get(store.as_store_ref().objects()).ty()
+    pub(crate) fn ty(&self, store: &impl AsStoreRef) -> GlobalType {
+        *self
+            .handle
+            .get(store.as_store_ref().objects().as_sys())
+            .ty()
     }
 
-    pub fn get(&self, store: &mut impl AsStoreMut) -> Value {
+    pub(crate) fn get(&self, store: &mut impl AsStoreMut) -> Value {
         unsafe {
-            let global = self.handle.get(store.as_store_ref().objects());
+            let global = self.handle.get(store.as_store_ref().objects().as_sys());
             let raw = global.vmglobal().as_ref().val;
             let ty = global.ty().ty;
             Value::from_raw(store, ty, raw)
         }
     }
 
-    pub fn set(&self, store: &mut impl AsStoreMut, val: Value) -> Result<(), RuntimeError> {
+    pub(crate) fn set(&self, store: &mut impl AsStoreMut, val: Value) -> Result<(), RuntimeError> {
         if !val.is_from_store(store) {
             return Err(RuntimeError::new("cross-`Store` values are not supported"));
         }
@@ -72,17 +80,20 @@ impl Global {
     pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternGlobal) -> Self {
         Self {
             handle: unsafe {
-                StoreHandle::from_internal(store.as_store_ref().objects().id(), vm_extern)
+                StoreHandle::from_internal(
+                    store.as_store_ref().objects().id(),
+                    vm_extern.into_sys(),
+                )
             },
         }
     }
 
-    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+    pub(crate) fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
         self.handle.store_id() == store.as_store_ref().objects().id()
     }
 
     pub(crate) fn to_vm_extern(&self) -> VMExtern {
-        VMExtern::Global(self.handle.internal_handle())
+        VMExtern::Sys(wasmer_vm::VMExtern::Global(self.handle.internal_handle()))
     }
 }
 
diff --git a/lib/api/src/sys/instance.rs b/lib/api/src/backend/sys/entities/instance.rs
similarity index 62%
rename from lib/api/src/sys/instance.rs
rename to lib/api/src/backend/sys/entities/instance.rs
index bbeab94b79..0219939529 100644
--- a/lib/api/src/sys/instance.rs
+++ b/lib/api/src/backend/sys/entities/instance.rs
@@ -1,13 +1,15 @@
-use crate::errors::InstantiationError;
-use crate::exports::Exports;
-use crate::module::Module;
+//! Data types, functions and traits for `sys` runtime's `Instance` implementation.
+
+use crate::{
+    error::InstantiationError, exports::Exports, imports::Imports, module::Module,
+    store::AsStoreMut, Extern,
+};
 use wasmer_vm::{StoreHandle, VMInstance};
 
-use crate::imports::Imports;
-use crate::store::AsStoreMut;
-use crate::Extern;
+use super::store::Store;
 
 #[derive(Clone, PartialEq, Eq)]
+/// A WebAssembly `instance` in the `sys` runtime.
 pub struct Instance {
     _handle: StoreHandle<VMInstance>,
 }
@@ -48,11 +50,11 @@ impl Instance {
         let externs = imports
             .imports_for_module(module)
             .map_err(InstantiationError::Link)?;
-        let mut handle = module.0.instantiate(store, &externs)?;
-        let exports = Self::get_exports(store, module, &mut handle);
+        let mut handle = module.as_sys().instantiate(store, &externs)?;
+        let exports = Self::get_exports(store, module, handle.as_sys_mut());
 
         let instance = Self {
-            _handle: StoreHandle::new(store.objects_mut(), handle),
+            _handle: StoreHandle::new(store.objects_mut().as_sys_mut(), handle.into_sys()),
         };
 
         Ok((instance, exports))
@@ -65,10 +67,13 @@ impl Instance {
         externs: &[Extern],
     ) -> Result<(Self, Exports), InstantiationError> {
         let externs = externs.to_vec();
-        let mut handle = module.0.instantiate(store, &externs)?;
-        let exports = Self::get_exports(store, module, &mut handle);
+        let mut handle = module.as_sys().instantiate(store, &externs)?;
+        let exports = Self::get_exports(store, module, handle.as_sys_mut());
         let instance = Self {
-            _handle: StoreHandle::new(store.objects_mut(), handle),
+            _handle: StoreHandle::new(
+                store.as_store_mut().objects_mut().as_sys_mut(),
+                handle.into_sys(),
+            ),
         };
 
         Ok((instance, exports))
@@ -84,9 +89,19 @@ impl Instance {
             .map(|export| {
                 let name = export.name().to_string();
                 let export = handle.lookup(&name).expect("export");
-                let extern_ = Extern::from_vm_extern(store, export);
+                let extern_ = Extern::from_vm_extern(store, crate::vm::VMExtern::Sys(export));
                 (name, extern_)
             })
             .collect::<Exports>()
     }
 }
+
+impl crate::BackendInstance {
+    /// Consume [`self`] into a [`crate::backend::sys::instance::Instance`].
+    pub(crate) fn into_sys(self) -> crate::backend::sys::instance::Instance {
+        match self {
+            Self::Sys(s) => s,
+            _ => panic!("Not a `sys` instance"),
+        }
+    }
+}
diff --git a/lib/api/src/sys/externals/memory.rs b/lib/api/src/backend/sys/entities/memory/mod.rs
similarity index 68%
rename from lib/api/src/sys/externals/memory.rs
rename to lib/api/src/backend/sys/entities/memory/mod.rs
index b61adc4ff6..faa2a51d38 100644
--- a/lib/api/src/sys/externals/memory.rs
+++ b/lib/api/src/backend/sys/entities/memory/mod.rs
@@ -1,3 +1,4 @@
+//! Data types, functions and traits for `sys` runtime's `Memory` implementation.
 use std::{
     convert::TryInto,
     marker::PhantomData,
@@ -6,45 +7,59 @@ use std::{
 };
 
 use tracing::warn;
-use wasmer_types::Pages;
-use wasmer_vm::{
-    LinearMemory, MemoryError, StoreHandle, ThreadConditionsHandle, VMExtern, VMMemory,
-};
+use wasmer_types::{MemoryType, Pages};
+use wasmer_vm::{LinearMemory, MemoryError, StoreHandle, ThreadConditionsHandle, VMMemory};
 
 use crate::{
-    store::{AsStoreMut, AsStoreRef},
-    sys::{engine::NativeEngineExt, externals::memory_view::MemoryView},
-    vm::VMExternMemory,
-    MemoryAccessError, MemoryType,
+    backend::sys::entities::{engine::NativeEngineExt, memory::MemoryView},
+    entities::store::{AsStoreMut, AsStoreRef},
+    location::{MemoryLocation, SharedMemoryOps},
+    vm::{VMExtern, VMExternMemory},
+    BackendMemory, MemoryAccessError,
 };
 
+pub(crate) mod view;
+pub use view::*;
+
+use super::store::Store;
+
 #[derive(Debug, Clone)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+/// A WebAssembly `memory` in the `sys` runtime.
 pub struct Memory {
     pub(crate) handle: StoreHandle<VMMemory>,
 }
 
 impl Memory {
-    pub fn new(store: &mut impl AsStoreMut, ty: MemoryType) -> Result<Self, MemoryError> {
+    pub(crate) fn new(store: &mut impl AsStoreMut, ty: MemoryType) -> Result<Self, MemoryError> {
         let mut store = store.as_store_mut();
         let tunables = store.engine().tunables();
         let style = tunables.memory_style(&ty);
         let memory = tunables.create_host_memory(&ty, &style)?;
 
         Ok(Self {
-            handle: StoreHandle::new(store.objects_mut(), memory),
+            handle: StoreHandle::new(store.as_store_mut().objects_mut().as_sys_mut(), memory),
         })
     }
 
-    pub fn new_from_existing(new_store: &mut impl AsStoreMut, memory: VMMemory) -> Self {
-        let handle = StoreHandle::new(new_store.objects_mut(), memory);
-        Self::from_vm_extern(new_store, handle.internal_handle())
+    pub(crate) fn new_from_existing(new_store: &mut impl AsStoreMut, memory: VMMemory) -> Self {
+        let handle = StoreHandle::new(new_store.objects_mut().as_sys_mut(), memory);
+        Self::from_vm_extern(new_store, VMExternMemory::Sys(handle.internal_handle()))
+    }
+
+    pub(crate) fn ty(&self, store: &impl AsStoreRef) -> MemoryType {
+        self.handle
+            .get(store.as_store_ref().objects().as_sys())
+            .ty()
     }
 
-    pub fn ty(&self, store: &impl AsStoreRef) -> MemoryType {
-        self.handle.get(store.as_store_ref().objects()).ty()
+    pub(crate) fn size(&self, store: &impl AsStoreRef) -> Pages {
+        self.handle
+            .get(store.as_store_ref().objects().as_sys())
+            .size()
     }
 
-    pub fn grow<IntoPages>(
+    pub(crate) fn grow<IntoPages>(
         &self,
         store: &mut impl AsStoreMut,
         delta: IntoPages,
@@ -52,48 +67,55 @@ impl Memory {
     where
         IntoPages: Into<Pages>,
     {
-        self.handle.get_mut(store.objects_mut()).grow(delta.into())
+        self.handle
+            .get_mut(store.objects_mut().as_sys_mut())
+            .grow(delta.into())
     }
 
-    pub fn grow_at_least(
+    pub(crate) fn grow_at_least(
         &self,
         store: &mut impl AsStoreMut,
         min_size: u64,
     ) -> Result<(), MemoryError> {
         self.handle
-            .get_mut(store.objects_mut())
+            .get_mut(store.objects_mut().as_sys_mut())
             .grow_at_least(min_size)
     }
 
-    pub fn reset(&self, store: &mut impl AsStoreMut) -> Result<(), MemoryError> {
-        self.handle.get_mut(store.objects_mut()).reset()?;
+    pub(crate) fn reset(&self, store: &mut impl AsStoreMut) -> Result<(), MemoryError> {
+        self.handle
+            .get_mut(store.as_store_mut().objects_mut().as_sys_mut())
+            .reset()?;
         Ok(())
     }
 
     pub(crate) fn from_vm_extern(store: &impl AsStoreRef, vm_extern: VMExternMemory) -> Self {
         Self {
             handle: unsafe {
-                StoreHandle::from_internal(store.as_store_ref().objects().id(), vm_extern)
+                StoreHandle::from_internal(
+                    store.as_store_ref().objects().id(),
+                    vm_extern.into_sys(),
+                )
             },
         }
     }
 
     /// Checks whether this `Memory` can be used with the given context.
-    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+    pub(crate) fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
         self.handle.store_id() == store.as_store_ref().objects().id()
     }
 
     /// Cloning memory will create another reference to the same memory that
     /// can be put into a new store
-    pub fn try_clone(&self, store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
-        let mem = self.handle.get(store.as_store_ref().objects());
+    pub(crate) fn try_clone(&self, store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
+        let mem = self.handle.get(store.as_store_ref().objects().as_sys());
         let cloned = mem.try_clone()?;
         Ok(cloned.into())
     }
 
     /// Copying the memory will actually copy all the bytes in the memory to
     /// a identical byte copy of the original that can be put into a new store
-    pub fn try_copy(
+    pub(crate) fn try_copy(
         &self,
         store: &impl AsStoreRef,
     ) -> Result<Box<dyn LinearMemory + 'static>, MemoryError> {
@@ -101,25 +123,27 @@ impl Memory {
         mem.copy()
     }
 
-    pub fn as_shared(&self, store: &impl AsStoreRef) -> Option<crate::SharedMemory> {
-        let mem = self.handle.get(store.as_store_ref().objects());
+    pub(crate) fn as_shared(
+        &self,
+        store: &impl AsStoreRef,
+    ) -> Option<crate::memory::shared::SharedMemory> {
+        let mem = self.handle.get(store.as_store_ref().objects().as_sys());
         let conds = mem.thread_conditions()?.downgrade();
 
-        Some(crate::SharedMemory::new(crate::Memory(self.clone()), conds))
+        Some(crate::memory::shared::SharedMemory::new(
+            crate::Memory(BackendMemory::Sys(self.clone())),
+            conds,
+        ))
     }
 
     /// To `VMExtern`.
     pub(crate) fn to_vm_extern(&self) -> VMExtern {
-        VMExtern::Memory(self.handle.internal_handle())
+        VMExtern::Sys(wasmer_vm::VMExtern::Memory(self.handle.internal_handle()))
     }
 }
 
-impl crate::externals::memory::SharedMemoryOps for ThreadConditionsHandle {
-    fn notify(
-        &self,
-        dst: crate::externals::memory::MemoryLocation,
-        count: u32,
-    ) -> Result<u32, crate::AtomicsError> {
+impl SharedMemoryOps for ThreadConditionsHandle {
+    fn notify(&self, dst: MemoryLocation, count: u32) -> Result<u32, crate::AtomicsError> {
         let count = self
             .upgrade()
             .ok_or(crate::AtomicsError::Unimplemented)?
@@ -134,7 +158,7 @@ impl crate::externals::memory::SharedMemoryOps for ThreadConditionsHandle {
 
     fn wait(
         &self,
-        dst: crate::externals::memory::MemoryLocation,
+        dst: MemoryLocation,
         timeout: Option<std::time::Duration>,
     ) -> Result<u32, crate::AtomicsError> {
         self.upgrade()
@@ -184,7 +208,7 @@ pub(crate) struct MemoryBuffer<'a> {
     pub(crate) marker: PhantomData<&'a MemoryView<'a>>,
 }
 
-impl<'a> MemoryBuffer<'a> {
+impl MemoryBuffer<'_> {
     pub(crate) fn read(&self, offset: u64, buf: &mut [u8]) -> Result<(), MemoryAccessError> {
         let end = offset
             .checked_add(buf.len() as u64)
@@ -308,3 +332,29 @@ unsafe fn volatile_memcpy_write(mut src: *const u8, mut dst: *mut u8, mut len: u
         copy_one::<u8>(&mut src, &mut dst, &mut len);
     }
 }
+
+impl crate::Memory {
+    /// Consume [`self`] into a [`crate::backend::sys::memory::Memory`].
+    pub fn into_sys(self) -> crate::backend::sys::memory::Memory {
+        match self.0 {
+            BackendMemory::Sys(s) => s,
+            _ => panic!("Not a `sys` memory!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference to [`crate::backend::sys::memory::Memory`].
+    pub fn as_sys(&self) -> &crate::backend::sys::memory::Memory {
+        match self.0 {
+            BackendMemory::Sys(ref s) => s,
+            _ => panic!("Not a `sys` memory!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference to [`crate::backend::sys::memory::Memory`].
+    pub fn as_sys_mut(&mut self) -> &mut crate::backend::sys::memory::Memory {
+        match self.0 {
+            BackendMemory::Sys(ref mut s) => s,
+            _ => panic!("Not a `sys` memory!"),
+        }
+    }
+}
diff --git a/lib/api/src/sys/externals/memory_view.rs b/lib/api/src/backend/sys/entities/memory/view.rs
similarity index 94%
rename from lib/api/src/sys/externals/memory_view.rs
rename to lib/api/src/backend/sys/entities/memory/view.rs
index b1dc5e1f8d..9fb4e04c77 100644
--- a/lib/api/src/sys/externals/memory_view.rs
+++ b/lib/api/src/backend/sys/entities/memory/view.rs
@@ -7,7 +7,7 @@ use std::{convert::TryInto, ops::Range};
 use wasmer_types::Pages;
 use wasmer_vm::LinearMemory;
 
-use super::memory::{Memory, MemoryBuffer};
+use super::{Memory, MemoryBuffer};
 
 /// A WebAssembly `memory` view.
 ///
@@ -23,9 +23,15 @@ pub struct MemoryView<'a> {
 
 impl<'a> MemoryView<'a> {
     pub(crate) fn new(memory: &Memory, store: &'a (impl AsStoreRef + ?Sized)) -> Self {
-        let size = memory.handle.get(store.as_store_ref().objects()).size();
-
-        let definition = memory.handle.get(store.as_store_ref().objects()).vmmemory();
+        let size = memory
+            .handle
+            .get(store.as_store_ref().objects().as_sys())
+            .size();
+
+        let definition = memory
+            .handle
+            .get(store.as_store_ref().objects().as_sys())
+            .vmmemory();
         let def = unsafe { definition.as_ref() };
 
         Self {
@@ -40,7 +46,7 @@ impl<'a> MemoryView<'a> {
 
     /// Returns the pointer to the raw bytes of the `Memory`.
     //
-    // This used by wasmer-emscripten and wasmer-c-api, but should be treated
+    // This used by wasmer-c-api, but should be treated
     // as deprecated and not used in future code.
     #[doc(hidden)]
     pub fn data_ptr(&self) -> *mut u8 {
diff --git a/lib/api/src/backend/sys/entities/mod.rs b/lib/api/src/backend/sys/entities/mod.rs
new file mode 100644
index 0000000000..21108debf5
--- /dev/null
+++ b/lib/api/src/backend/sys/entities/mod.rs
@@ -0,0 +1,11 @@
+pub mod engine;
+pub mod exception;
+pub mod external;
+pub mod function;
+pub mod global;
+pub mod instance;
+pub mod memory;
+pub mod module;
+pub mod store;
+pub mod table;
+pub mod tag;
diff --git a/lib/api/src/sys/module.rs b/lib/api/src/backend/sys/entities/module.rs
similarity index 67%
rename from lib/api/src/sys/module.rs
rename to lib/api/src/backend/sys/entities/module.rs
index 3aae35d02e..b2a4d63d97 100644
--- a/lib/api/src/sys/module.rs
+++ b/lib/api/src/backend/sys/entities/module.rs
@@ -1,19 +1,22 @@
+//! Data types, functions and traits for `sys` runtime's `Module` implementation.
 use std::path::Path;
 use std::sync::Arc;
 
 use bytes::Bytes;
-use wasmer_compiler::{Artifact, ArtifactCreate};
+use wasmer_compiler::{Artifact, ArtifactCreate, Engine};
 use wasmer_types::{
-    CompileError, DeserializeError, ExportsIterator, ImportsIterator, ModuleInfo, SerializeError,
+    CompileError, DeserializeError, ExportType, ExportsIterator, ImportType, ImportsIterator,
+    ModuleInfo, SerializeError,
 };
-use wasmer_types::{ExportType, ImportType};
 
 use crate::{
-    engine::AsEngineRef, sys::engine::NativeEngineExt, vm::VMInstance, AsStoreMut, AsStoreRef,
-    InstantiationError, IntoBytes,
+    backend::sys::entities::engine::NativeEngineExt, engine::AsEngineRef,
+    error::InstantiationError, vm::VMInstance, AsStoreMut, AsStoreRef, BackendModule, IntoBytes,
 };
 
 #[derive(Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+/// A WebAssembly `module` in the `sys` runtime.
 pub struct Module {
     // The field ordering here is actually significant because of the drop
     // order: we want to drop the artifact before dropping the engine.
@@ -49,14 +52,22 @@ impl Module {
         Ok(module)
     }
 
+    #[cfg(feature = "compiler")]
     #[tracing::instrument(level = "debug", skip_all)]
     pub(crate) fn validate(engine: &impl AsEngineRef, binary: &[u8]) -> Result<(), CompileError> {
-        engine.as_engine_ref().engine().0.validate(binary)
+        engine.as_engine_ref().engine().as_sys().validate(binary)
+    }
+
+    #[cfg(not(feature = "compiler"))]
+    pub(crate) fn validate(_engine: &impl AsEngineRef, _binary: &[u8]) -> Result<(), CompileError> {
+        Err(CompileError::UnsupportedTarget(
+            "The compiler feature is not enabled, but is required to validate a Module".to_string(),
+        ))
     }
 
     #[cfg(feature = "compiler")]
     fn compile(engine: &impl AsEngineRef, binary: &[u8]) -> Result<Self, CompileError> {
-        let artifact = engine.as_engine_ref().engine().0.compile(binary)?;
+        let artifact = engine.as_engine_ref().engine().as_sys().compile(binary)?;
         Ok(Self::from_artifact(artifact))
     }
 
@@ -72,7 +83,7 @@ impl Module {
     }
 
     #[tracing::instrument(level = "debug", skip_all)]
-    pub unsafe fn deserialize_unchecked(
+    pub(crate) unsafe fn deserialize_unchecked(
         engine: &impl AsEngineRef,
         bytes: impl IntoBytes,
     ) -> Result<Self, DeserializeError> {
@@ -80,13 +91,13 @@ impl Module {
         let artifact = engine
             .as_engine_ref()
             .engine()
-            .0
+            .as_sys()
             .deserialize_unchecked(bytes.into())?;
         Ok(Self::from_artifact(artifact))
     }
 
     #[tracing::instrument(level = "debug", skip_all)]
-    pub unsafe fn deserialize(
+    pub(crate) unsafe fn deserialize(
         engine: &impl AsEngineRef,
         bytes: impl IntoBytes,
     ) -> Result<Self, DeserializeError> {
@@ -94,31 +105,31 @@ impl Module {
         let artifact = engine
             .as_engine_ref()
             .engine()
-            .0
+            .as_sys()
             .deserialize(bytes.into())?;
         Ok(Self::from_artifact(artifact))
     }
 
-    pub unsafe fn deserialize_from_file_unchecked(
+    pub(crate) unsafe fn deserialize_from_file_unchecked(
         engine: &impl AsEngineRef,
         path: impl AsRef<Path>,
     ) -> Result<Self, DeserializeError> {
         let artifact = engine
             .as_engine_ref()
             .engine()
-            .0
+            .as_sys()
             .deserialize_from_file_unchecked(path.as_ref())?;
         Ok(Self::from_artifact(artifact))
     }
 
-    pub unsafe fn deserialize_from_file(
+    pub(crate) unsafe fn deserialize_from_file(
         engine: &impl AsEngineRef,
         path: impl AsRef<Path>,
     ) -> Result<Self, DeserializeError> {
         let artifact = engine
             .as_engine_ref()
             .engine()
-            .0
+            .as_sys()
             .deserialize_from_file(path.as_ref())?;
         Ok(Self::from_artifact(artifact))
     }
@@ -153,9 +164,9 @@ impl Module {
                 engine.tunables(),
                 &imports
                     .iter()
-                    .map(crate::Extern::to_vm_extern)
+                    .map(|e| crate::Extern::to_vm_extern(e).into_sys())
                     .collect::<Vec<_>>(),
-                objects,
+                objects.as_sys_mut(),
             )?;
 
             // After the instance handle is created, we need to initialize
@@ -166,7 +177,7 @@ impl Module {
             self.artifact
                 .finish_instantiation(config, signal_handler, &mut instance_handle)?;
 
-            Ok(instance_handle)
+            Ok(VMInstance::Sys(instance_handle))
         }
     }
 
@@ -175,23 +186,22 @@ impl Module {
     }
 
     pub(crate) fn set_name(&mut self, name: &str) -> bool {
-        Arc::get_mut(&mut self.artifact).map_or(false, |artifact| {
-            artifact.set_module_info_name(name.to_string())
-        })
+        Arc::get_mut(&mut self.artifact)
+            .is_some_and(|artifact| artifact.set_module_info_name(name.to_string()))
     }
 
-    pub(crate) fn imports(&self) -> ImportsIterator<impl Iterator<Item = ImportType> + '_> {
+    pub(crate) fn imports(&self) -> ImportsIterator<Box<dyn Iterator<Item = ImportType> + '_>> {
         self.info().imports()
     }
 
-    pub(crate) fn exports(&self) -> ExportsIterator<impl Iterator<Item = ExportType> + '_> {
+    pub(crate) fn exports(&self) -> ExportsIterator<Box<dyn Iterator<Item = ExportType> + '_>> {
         self.info().exports()
     }
 
     pub(crate) fn custom_sections<'a>(
         &'a self,
         name: &'a str,
-    ) -> impl Iterator<Item = Box<[u8]>> + 'a {
+    ) -> Box<dyn Iterator<Item = Box<[u8]>> + 'a> {
         self.info().custom_sections(name)
     }
 
@@ -199,3 +209,29 @@ impl Module {
         self.artifact.module_info()
     }
 }
+
+impl crate::Module {
+    /// Consume [`self`] into a reference [`crate::backend::sys::module::Module`].
+    pub fn into_sys(self) -> crate::backend::sys::module::Module {
+        match self.0 {
+            BackendModule::Sys(s) => s,
+            _ => panic!("Not a `sys` module!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::sys::module::Module`].
+    pub fn as_sys(&self) -> &crate::backend::sys::module::Module {
+        match self.0 {
+            BackendModule::Sys(ref s) => s,
+            _ => panic!("Not a `sys` module!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::sys::module::Module`].
+    pub fn as_sys_mut(&mut self) -> &mut crate::backend::sys::module::Module {
+        match self.0 {
+            BackendModule::Sys(ref mut s) => s,
+            _ => panic!("Not a `sys` module!"),
+        }
+    }
+}
diff --git a/lib/api/src/backend/sys/entities/store/mod.rs b/lib/api/src/backend/sys/entities/store/mod.rs
new file mode 100644
index 0000000000..43a171eb3d
--- /dev/null
+++ b/lib/api/src/backend/sys/entities/store/mod.rs
@@ -0,0 +1,135 @@
+//! Data types, functions and traits for `sys` runtime's `Store` implementation.
+use crate::entities::engine::{AsEngineRef, Engine, EngineRef};
+use crate::BackendStore;
+use wasmer_vm::init_traps;
+use wasmer_vm::TrapHandlerFn;
+pub use wasmer_vm::{StoreHandle, StoreObjects};
+
+mod obj;
+pub use obj::*;
+
+/// A WebAssembly `store` in the `sys` runtime.
+pub struct Store {
+    pub(crate) engine: Engine,
+    pub(crate) trap_handler: Option<Box<TrapHandlerFn<'static>>>,
+}
+
+impl std::fmt::Debug for Store {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Store")
+            .field("engine", &self.engine)
+            .finish()
+    }
+}
+
+impl Store {
+    pub(crate) fn new(engine: Engine) -> Self {
+        init_traps();
+
+        Self {
+            engine,
+            trap_handler: None,
+        }
+    }
+
+    pub(crate) fn engine(&self) -> &Engine {
+        &self.engine
+    }
+
+    pub(crate) fn engine_mut(&mut self) -> &mut Engine {
+        &mut self.engine
+    }
+}
+
+impl AsEngineRef for Store {
+    fn as_engine_ref(&self) -> EngineRef<'_> {
+        EngineRef::new(&self.engine)
+    }
+}
+
+/// The custom trait to access to all the `sys` functions in the
+/// Store.
+pub trait NativeStoreExt {
+    /// Sets the trap handler
+    fn set_trap_handler(&mut self, handler: Option<Box<TrapHandlerFn<'static>>>);
+    /// The signal handler
+    fn signal_handler(&self) -> Option<*const TrapHandlerFn<'static>>;
+}
+
+impl NativeStoreExt for Store {
+    fn set_trap_handler(&mut self, handler: Option<Box<TrapHandlerFn<'static>>>) {
+        self.trap_handler = handler;
+    }
+
+    /// The signal handler
+    #[inline]
+    fn signal_handler(&self) -> Option<*const TrapHandlerFn<'static>> {
+        self.trap_handler
+            .as_ref()
+            .map(|handler| handler.as_ref() as *const _)
+    }
+}
+
+impl NativeStoreExt for crate::Store {
+    fn set_trap_handler(&mut self, handler: Option<Box<TrapHandlerFn<'static>>>) {
+        self.inner.store.as_sys_mut().set_trap_handler(handler)
+    }
+
+    /// The signal handler
+    #[inline]
+    fn signal_handler(&self) -> Option<*const TrapHandlerFn<'static>> {
+        self.inner.store.as_sys().signal_handler()
+    }
+}
+
+impl crate::BackendStore {
+    /// Consume [`self`] into [`crate::backend::sys::store::Store`].
+    pub fn into_sys(self) -> crate::backend::sys::store::Store {
+        match self {
+            Self::Sys(s) => s,
+            _ => panic!("Not a `sys` store!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::sys::store::Store`].
+    pub fn as_sys(&self) -> &crate::backend::sys::store::Store {
+        match self {
+            Self::Sys(s) => s,
+            _ => panic!("Not a `sys` store!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::sys::store::Store`].
+    pub fn as_sys_mut(&mut self) -> &mut crate::backend::sys::store::Store {
+        match self {
+            Self::Sys(s) => s,
+            _ => panic!("Not a `sys` store!"),
+        }
+    }
+    /// Return true if [`self`] is a store from the `sys` runtime.
+    pub fn is_sys(&self) -> bool {
+        matches!(self, Self::Sys(_))
+    }
+}
+
+impl crate::Store {
+    /// Consume [`self`] into [`crate::backend::sys::store::Store`].
+    pub(crate) fn into_sys(self) -> crate::backend::sys::store::Store {
+        self.inner.store.into_sys()
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::sys::store::Store`].
+    pub(crate) fn as_sys(&self) -> &crate::backend::sys::store::Store {
+        self.inner.store.as_sys()
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::sys::store::Store`].
+    pub(crate) fn as_sys_mut(&mut self) -> &mut crate::backend::sys::store::Store {
+        self.inner.store.as_sys_mut()
+    }
+
+    /// Return true if [`self`] is a store from the `sys` runtime.
+    pub fn is_sys(&self) -> bool {
+        self.inner.store.is_sys()
+    }
+}
diff --git a/lib/api/src/backend/sys/entities/store/obj.rs b/lib/api/src/backend/sys/entities/store/obj.rs
new file mode 100644
index 0000000000..ba90370dc1
--- /dev/null
+++ b/lib/api/src/backend/sys/entities/store/obj.rs
@@ -0,0 +1,76 @@
+use wasmer_vm::StoreId;
+
+use crate::AsStoreMut;
+
+impl crate::StoreObjects {
+    /// Consume store objects into [`crate::backend::sys::store::StoreObjects`].
+    pub fn into_sys(self) -> crate::backend::sys::store::StoreObjects {
+        match self {
+            Self::Sys(s) => s,
+            _ => panic!("Not a `sys` store!"),
+        }
+    }
+
+    /// Convert a reference to store objects into a reference [`crate::backend::sys::store::StoreObjects`].
+    pub fn as_sys(&self) -> &crate::backend::sys::store::StoreObjects {
+        match self {
+            Self::Sys(s) => s,
+            _ => panic!("Not a `sys` store!"),
+        }
+    }
+
+    /// Convert a mutable reference to store objects into a mutable reference [`crate::backend::sys::store::StoreObjects`].
+    pub fn as_sys_mut(&mut self) -> &mut crate::backend::sys::store::StoreObjects {
+        match self {
+            Self::Sys(s) => s,
+            _ => panic!("Not a `sys` store!"),
+        }
+    }
+}
+
+//pub trait GetStoreObjects {
+//    /// Return a mutable reference to [`wasmer_vm::StoreObjects`] and a reference to the current
+//    /// engine.
+//    fn engine_and_objects_mut(
+//        &mut self,
+//    ) -> (&crate::Engine, &mut crate::backend::sys::store::StoreObjects);
+//
+//    /// Return a mutable reference to [`wasmer_vm::StoreObjects`].
+//    fn objects_mut(&mut self) -> &mut crate::backend::sys::store::StoreObjects;
+//}
+//
+//impl GetStoreObjects for crate::StoreInner {
+//    fn objects_mut(&mut self) -> &mut crate::backend::sys::store::StoreObjects {
+//        self.objects.as_sys_mut()
+//    }
+//
+//    fn engine_and_objects_mut(
+//        &mut self,
+//    ) -> (&crate::Engine, &mut crate::backend::sys::store::StoreObjects) {
+//        match (&mut self.objects, &self.store) {
+//            (crate::StoreObjects::Sys(o), crate::BackendStore::Sys(s)) => (&s.engine, o),
+//            _ => panic!("Not a `sys` store!"),
+//        }
+//    }
+//}
+//
+//impl<T: AsStoreMut> GetStoreObjects for T {
+//    fn objects_mut<'a>(&'a mut self) -> &'a mut crate::backend::sys::store::StoreObjects {
+//        match self.as_store_mut().inner.objects {
+//            crate::StoreObjects::Sys(ref mut s) => s,
+//            _ => panic!("Not a `sys` store!"),
+//        }
+//    }
+//
+//    fn engine_and_objects_mut(
+//        &mut self,
+//    ) -> (&crate::Engine, &mut crate::backend::sys::store::StoreObjects) {
+//        let mut store = self.as_store_mut();
+//        match (&mut store.inner.objects, &store.inner.store) {
+//            (crate::StoreObjects::Sys(ref mut o), crate::BackendStore::Sys(ref s)) => {
+//                (&s.engine, o)
+//            }
+//            _ => panic!("Not a `sys` store!"),
+//        }
+//    }
+//}
diff --git a/lib/api/src/backend/sys/entities/table.rs b/lib/api/src/backend/sys/entities/table.rs
new file mode 100644
index 0000000000..6888da892d
--- /dev/null
+++ b/lib/api/src/backend/sys/entities/table.rs
@@ -0,0 +1,241 @@
+//! Data types, functions and traits for `sys` runtime's `Table` implementation.
+use crate::{
+    backend::sys::entities::engine::NativeEngineExt,
+    entities::store::{AsStoreMut, AsStoreRef},
+    error::RuntimeError,
+    vm::{VMExtern, VMExternTable},
+    BackendTable, ExternRef, Function, Value,
+};
+use wasmer_types::TableType;
+use wasmer_vm::{StoreHandle, TableElement, Trap, VMTable};
+
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+/// A WebAssembly `table` in the `sys` runtime.
+pub struct Table {
+    handle: StoreHandle<VMTable>,
+}
+
+fn set_table_item(
+    table: &mut VMTable,
+    item_index: u32,
+    item: TableElement,
+) -> Result<(), RuntimeError> {
+    table
+        .set(item_index, item)
+        .map_err(Into::<RuntimeError>::into)
+}
+
+fn value_to_table_element(
+    store: &mut impl AsStoreMut,
+    val: Value,
+) -> Result<wasmer_vm::TableElement, RuntimeError> {
+    if !val.is_from_store(store) {
+        return Err(RuntimeError::new("cannot pass Value across contexts"));
+    }
+    Ok(match val {
+        Value::ExternRef(extern_ref) => {
+            wasmer_vm::TableElement::ExternRef(extern_ref.map(|e| e.vm_externref().into_sys()))
+        }
+        Value::FuncRef(func_ref) => {
+            wasmer_vm::TableElement::FuncRef(func_ref.map(|f| f.vm_funcref(store).into_sys()))
+        }
+        _ => return Err(RuntimeError::new("val is not reference")),
+    })
+}
+
+fn value_from_table_element(store: &mut impl AsStoreMut, item: wasmer_vm::TableElement) -> Value {
+    match item {
+        wasmer_vm::TableElement::FuncRef(funcref) => Value::FuncRef(
+            funcref
+                .map(|f| unsafe { Function::from_vm_funcref(store, crate::vm::VMFuncRef::Sys(f)) }),
+        ),
+        wasmer_vm::TableElement::ExternRef(extern_ref) => {
+            Value::ExternRef(extern_ref.map(|e| unsafe {
+                ExternRef::from_vm_externref(store, crate::vm::VMExternRef::Sys(e))
+            }))
+        }
+    }
+}
+
+impl Table {
+    pub(crate) fn new(
+        mut store: &mut impl AsStoreMut,
+        ty: TableType,
+        init: Value,
+    ) -> Result<Self, RuntimeError> {
+        let item = value_to_table_element(&mut store, init)?;
+        let mut store = store.as_store_mut();
+        let tunables = store.engine().tunables();
+        let style = tunables.table_style(&ty);
+        let mut table = tunables
+            .create_host_table(&ty, &style)
+            .map_err(RuntimeError::new)?;
+
+        let num_elements = table.size();
+        for i in 0..num_elements {
+            set_table_item(&mut table, i, item.clone())?;
+        }
+
+        Ok(Self {
+            handle: StoreHandle::new(store.objects_mut().as_sys_mut(), table),
+        })
+    }
+
+    pub(crate) fn ty(&self, store: &impl AsStoreRef) -> TableType {
+        *self
+            .handle
+            .get(store.as_store_ref().objects().as_sys())
+            .ty()
+    }
+
+    pub(crate) fn get(&self, store: &mut impl AsStoreMut, index: u32) -> Option<Value> {
+        let item = self
+            .handle
+            .get(store.as_store_ref().objects().as_sys())
+            .get(index)?;
+        Some(value_from_table_element(store, item))
+    }
+
+    pub(crate) fn set(
+        &self,
+        store: &mut impl AsStoreMut,
+        index: u32,
+        val: Value,
+    ) -> Result<(), RuntimeError> {
+        let item = value_to_table_element(store, val)?;
+        set_table_item(
+            self.handle.get_mut(store.objects_mut().as_sys_mut()),
+            index,
+            item,
+        )
+    }
+
+    pub(crate) fn size(&self, store: &impl AsStoreRef) -> u32 {
+        self.handle
+            .get(store.as_store_ref().objects().as_sys())
+            .size()
+    }
+
+    pub(crate) fn grow(
+        &self,
+        store: &mut impl AsStoreMut,
+        delta: u32,
+        init: Value,
+    ) -> Result<u32, RuntimeError> {
+        let item = value_to_table_element(store, init)?;
+        let obj_mut = store.objects_mut().as_sys_mut();
+
+        self.handle
+            .get_mut(obj_mut)
+            .grow(delta, item)
+            .ok_or_else(|| RuntimeError::new(format!("failed to grow table by `{delta}`")))
+    }
+
+    pub(crate) fn copy(
+        store: &mut impl AsStoreMut,
+        dst_table: &Self,
+        dst_index: u32,
+        src_table: &Self,
+        src_index: u32,
+        len: u32,
+    ) -> Result<(), RuntimeError> {
+        if dst_table.handle.store_id() != src_table.handle.store_id() {
+            return Err(RuntimeError::new(
+                "cross-`Store` table copies are not supported",
+            ));
+        }
+        if dst_table.handle.internal_handle() == src_table.handle.internal_handle() {
+            let table = dst_table.handle.get_mut(store.objects_mut().as_sys_mut());
+            table.copy_within(dst_index, src_index, len)
+        } else {
+            let (src_table, dst_table) = store.objects_mut().as_sys_mut().get_2_mut(
+                src_table.handle.internal_handle(),
+                dst_table.handle.internal_handle(),
+            );
+            VMTable::copy(dst_table, src_table, dst_index, src_index, len)
+        }
+        .map_err(Into::<RuntimeError>::into)?;
+        Ok(())
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternTable) -> Self {
+        Self {
+            handle: unsafe {
+                StoreHandle::from_internal(
+                    store.as_store_ref().objects().id(),
+                    vm_extern.into_sys(),
+                )
+            },
+        }
+    }
+
+    /// Checks whether this `Table` can be used with the given context.
+    pub(crate) fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.handle.store_id() == store.as_store_ref().objects().id()
+    }
+
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Sys(wasmer_vm::VMExtern::Table(self.handle.internal_handle()))
+    }
+}
+
+impl std::cmp::PartialEq for Table {
+    fn eq(&self, other: &Self) -> bool {
+        self.handle == other.handle
+    }
+}
+
+impl std::cmp::Eq for Table {}
+
+impl crate::Table {
+    /// Consume [`self`] into [`crate::backend::sys::table::Table`].
+    pub fn into_sys(self) -> crate::backend::sys::table::Table {
+        match self.0 {
+            BackendTable::Sys(s) => s,
+            _ => panic!("Not a `sys` table!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::sys::table::Table`].
+    pub fn as_sys(&self) -> &crate::backend::sys::table::Table {
+        match self.0 {
+            BackendTable::Sys(ref s) => s,
+            _ => panic!("Not a `sys` table!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::sys::table::Table`].
+    pub fn as_sys_mut(&mut self) -> &mut crate::backend::sys::table::Table {
+        match self.0 {
+            BackendTable::Sys(ref mut s) => s,
+            _ => panic!("Not a `sys` table!"),
+        }
+    }
+}
+
+impl crate::BackendTable {
+    /// Consume [`self`] into [`crate::backend::sys::table::Table`].
+    pub fn into_sys(self) -> crate::backend::sys::table::Table {
+        match self {
+            Self::Sys(s) => s,
+            _ => panic!("Not a `sys` table!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::sys::table::Table`].
+    pub fn as_sys(&self) -> &crate::backend::sys::table::Table {
+        match self {
+            Self::Sys(ref s) => s,
+            _ => panic!("Not a `sys` table!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::sys::table::Table`].
+    pub fn as_sys_mut(&mut self) -> &mut crate::backend::sys::table::Table {
+        match self {
+            Self::Sys(ref mut s) => s,
+            _ => panic!("Not a `sys` table!"),
+        }
+    }
+}
diff --git a/lib/api/src/backend/sys/entities/tag.rs b/lib/api/src/backend/sys/entities/tag.rs
new file mode 100644
index 0000000000..8f1de9b06a
--- /dev/null
+++ b/lib/api/src/backend/sys/entities/tag.rs
@@ -0,0 +1,74 @@
+//! Data types, functions and traits for `sys` runtime's `Tag` implementation.
+use wasmer_types::{FunctionType, TagType, Type};
+use wasmer_vm::StoreHandle;
+
+use crate::{
+    sys::vm::VMTag,
+    vm::{VMExtern, VMExternTag},
+    AsStoreMut, AsStoreRef,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// A WebAssembly `tag` in the `v8` runtime.
+pub(crate) struct Tag {
+    pub(crate) handle: StoreHandle<wasmer_vm::VMTag>,
+}
+
+unsafe impl Send for Tag {}
+unsafe impl Sync for Tag {}
+
+// Tag can't be Send in js because it dosen't support `structuredClone`
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// unsafe impl Send for Tag {}
+
+impl Tag {
+    /// Create a new [`Tag`].
+    pub fn new<P: Into<Box<[Type]>>>(store: &mut impl AsStoreMut, params: P) -> Self {
+        Self {
+            handle: StoreHandle::new(
+                store.objects_mut().as_sys_mut(),
+                VMTag::new(
+                    wasmer_types::TagKind::Exception,
+                    FunctionType::new(params, []),
+                ),
+            ),
+        }
+    }
+
+    /// Get the [`Tag`]'s type.
+    pub fn ty(&self, store: &impl AsStoreRef) -> TagType {
+        TagType {
+            kind: wasmer_types::TagKind::Exception,
+            params: self
+                .handle
+                .get(store.as_store_ref().objects().as_sys())
+                .signature
+                .params()
+                .into(),
+        }
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternTag) -> Self {
+        Self {
+            handle: unsafe {
+                StoreHandle::from_internal(store.objects_mut().id(), vm_extern.into_sys())
+            },
+        }
+    }
+
+    /// Check whether or not the [`Tag`] is from the given store.
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.handle.store_id() == store.as_store_ref().objects().id()
+    }
+
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Sys(wasmer_vm::VMExtern::Tag(self.handle.internal_handle()))
+    }
+}
+
+#[cfg(feature = "artifact-size")]
+impl loupe::MemoryUsage for Tag {
+    fn size_of_val(&self, tracker: &mut dyn loupe::MemoryUsageTracker) -> usize {
+        std::mem::size_of::<Self>()
+    }
+}
diff --git a/lib/api/src/sys/errors.rs b/lib/api/src/backend/sys/error.rs
similarity index 82%
rename from lib/api/src/sys/errors.rs
rename to lib/api/src/backend/sys/error.rs
index b5943bef4d..e8ced176cd 100644
--- a/lib/api/src/sys/errors.rs
+++ b/lib/api/src/backend/sys/error.rs
@@ -1,4 +1,4 @@
-use crate::{LinkError, RuntimeError};
+use crate::LinkError;
 use wasmer_vm::Trap;
 
 impl From<wasmer_compiler::LinkError> for LinkError {
@@ -13,12 +13,12 @@ impl From<wasmer_compiler::LinkError> for LinkError {
     }
 }
 
-impl From<Trap> for RuntimeError {
+impl From<Trap> for crate::RuntimeError {
     fn from(trap: Trap) -> Self {
         if trap.is::<Self>() {
             return trap.downcast::<Self>().unwrap();
         }
         let (wasm_trace, trap_code) = wasmer_compiler::get_trace_and_trapcode(&trap);
-        Self::new_from_source(trap, wasm_trace, trap_code)
+        Self::new_from_source(crate::BackendTrap::Sys(trap), wasm_trace, trap_code)
     }
 }
diff --git a/lib/api/src/backend/sys/mod.rs b/lib/api/src/backend/sys/mod.rs
new file mode 100644
index 0000000000..ab009c0dc2
--- /dev/null
+++ b/lib/api/src/backend/sys/mod.rs
@@ -0,0 +1,27 @@
+//! Data types, functions and traits for the `sys` runtime.
+
+pub(crate) mod entities;
+pub(crate) mod error;
+pub(crate) mod tunables;
+pub mod vm;
+
+pub use engine::NativeEngineExt;
+pub use entities::*;
+pub use tunables::*;
+
+#[cfg(feature = "compiler")]
+pub use wasmer_compiler::{
+    wasmparser, CompilerConfig, FunctionMiddleware, MiddlewareReaderState, ModuleMiddleware,
+};
+
+pub use wasmer_compiler::{Artifact, EngineBuilder, Features, Tunables};
+
+pub use wasmer_types::target::{Architecture, CpuFeature, OperatingSystem, Target, Triple};
+pub use wasmer_types::MiddlewareError;
+
+#[cfg(feature = "cranelift")]
+pub use wasmer_compiler_cranelift::{Cranelift, CraneliftOptLevel};
+#[cfg(feature = "llvm")]
+pub use wasmer_compiler_llvm::{LLVMOptLevel, LLVM};
+#[cfg(feature = "singlepass")]
+pub use wasmer_compiler_singlepass::Singlepass;
diff --git a/lib/api/src/sys/tunables.rs b/lib/api/src/backend/sys/tunables.rs
similarity index 95%
rename from lib/api/src/sys/tunables.rs
rename to lib/api/src/backend/sys/tunables.rs
index 45f9225adf..018ee72b0a 100644
--- a/lib/api/src/sys/tunables.rs
+++ b/lib/api/src/backend/sys/tunables.rs
@@ -31,7 +31,7 @@ mod tests {
         let style = tunables.memory_style(&requested);
         match style {
             MemoryStyle::Dynamic { offset_guard_size } => assert_eq!(offset_guard_size, 256),
-            s => panic!("Unexpected memory style: {:?}", s),
+            s => panic!("Unexpected memory style: {s:?}"),
         }
 
         // Large maximum
@@ -39,7 +39,7 @@ mod tests {
         let style = tunables.memory_style(&requested);
         match style {
             MemoryStyle::Dynamic { offset_guard_size } => assert_eq!(offset_guard_size, 256),
-            s => panic!("Unexpected memory style: {:?}", s),
+            s => panic!("Unexpected memory style: {s:?}"),
         }
 
         // Small maximum
@@ -53,7 +53,7 @@ mod tests {
                 assert_eq!(bound, Pages(2048));
                 assert_eq!(offset_guard_size, 128);
             }
-            s => panic!("Unexpected memory style: {:?}", s),
+            s => panic!("Unexpected memory style: {s:?}"),
         }
     }
 
@@ -225,7 +225,7 @@ mod tests {
         }
 
         // Will use a minimum stack size of 8kb, not the 1Mb default
-        fn vmconfig(&self) -> &crate::vm::VMConfig {
+        fn vmconfig(&self) -> &wasmer_vm::VMConfig {
             &VMConfig {
                 wasm_stack_size: Some(8 * 1024),
             }
@@ -255,9 +255,10 @@ mod tests {
     }
 
     #[test]
-    fn check_customtunables() -> Result<(), Box<dyn std::error::Error>> {
-        use crate::{imports, wat2wasm, Engine, Instance, Memory, Module, Store};
-        use wasmer_compiler_cranelift::Cranelift;
+    fn check_custom_tunables() -> Result<(), Box<dyn std::error::Error>> {
+        #[cfg(feature = "wat")]
+        use crate::wat2wasm;
+        use crate::{imports, Engine, Instance, Memory, Module, Store};
 
         let wasm_bytes = wat2wasm(
             br#"(module
@@ -267,7 +268,16 @@ mod tests {
             (data (;0;) (i32.const 1048576) "*\00\00\00")
           )"#,
         )?;
-        let compiler = Cranelift::default();
+
+        cfg_if::cfg_if! {
+            if #[cfg(feature = "singlepass")] {
+                let compiler =  wasmer_compiler_singlepass::Singlepass::default();
+            } else if #[cfg(feature = "llvm")] {
+                let compiler =  wasmer_compiler_llvm::LLVM::default();
+            } else {
+                let compiler =  wasmer_compiler_cranelift::Cranelift::default();
+            }
+        }
 
         let tunables = TinyTunables {};
         #[allow(deprecated)]
@@ -463,7 +473,7 @@ mod tests {
             .get_function("large_local")?
             .call(&mut store, &[]);
 
-        println!("result = {:?}", result);
+        println!("result = {result:?}");
         assert!(result.is_err());
 
         Ok(())
diff --git a/lib/api/src/backend/sys/vm.rs b/lib/api/src/backend/sys/vm.rs
new file mode 100644
index 0000000000..ee1816d0f8
--- /dev/null
+++ b/lib/api/src/backend/sys/vm.rs
@@ -0,0 +1,51 @@
+//! The `vm` module re-exports wasmer-vm types.
+use crate::entities::{Function, Global, Memory, Table, Tag};
+use crate::store::AsStoreMut;
+pub use wasmer_vm::*;
+
+// No EH for now.
+pub(crate) type VMException = ();
+
+/// The type of extern tables in the `sys` VM.
+pub type VMExternTable = InternalStoreHandle<VMTable>;
+///
+/// The type of extern memories in the `sys` VM.
+pub type VMExternMemory = InternalStoreHandle<VMMemory>;
+
+/// The type of extern globals in the `sys` VM.
+pub type VMExternGlobal = InternalStoreHandle<VMGlobal>;
+
+/// The type of extern functions in the `sys` VM.
+pub type VMExternFunction = InternalStoreHandle<VMFunction>;
+
+/// The type of extern tags in the `sys` VM.
+pub(crate) type VMExternTag = InternalStoreHandle<VMTag>;
+
+/// The type of function callbacks in the `sys` VM.
+pub type VMFunctionCallback = *const VMFunctionBody;
+
+impl crate::VMExternToExtern for VMExtern {
+    fn to_extern(self, store: &mut impl AsStoreMut) -> crate::Extern {
+        match self {
+            Self::Function(f) => crate::Extern::Function(Function::from_vm_extern(
+                store,
+                crate::vm::VMExternFunction::Sys(f),
+            )),
+            Self::Memory(m) => crate::Extern::Memory(Memory::from_vm_extern(
+                store,
+                crate::vm::VMExternMemory::Sys(m),
+            )),
+            Self::Global(g) => crate::Extern::Global(Global::from_vm_extern(
+                store,
+                crate::vm::VMExternGlobal::Sys(g),
+            )),
+            Self::Table(t) => crate::Extern::Table(Table::from_vm_extern(
+                store,
+                crate::vm::VMExternTable::Sys(t),
+            )),
+            Self::Tag(t) => {
+                crate::Extern::Tag(Tag::from_vm_extern(store, crate::vm::VMExternTag::Sys(t)))
+            }
+        }
+    }
+}
diff --git a/lib/api/src/backend/v8/bindings.rs b/lib/api/src/backend/v8/bindings.rs
new file mode 100644
index 0000000000..71f9e088a6
--- /dev/null
+++ b/lib/api/src/backend/v8/bindings.rs
@@ -0,0 +1,7 @@
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(unused)]
+
+// This matches bindgen::Builder output
+include!(concat!(env!("OUT_DIR"), "/v8_bindings.rs"));
diff --git a/lib/api/src/backend/v8/entities/engine.rs b/lib/api/src/backend/v8/entities/engine.rs
new file mode 100644
index 0000000000..5e5e44de7c
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/engine.rs
@@ -0,0 +1,122 @@
+//! Data types, functions and traits for `sys` runtime's `Engine` implementation.
+use crate::{
+    backend::v8::bindings::{wasm_engine_delete, wasm_engine_new, wasm_engine_t},
+    BackendEngine,
+};
+use std::sync::Arc;
+use wasmer_types::{target::Target, Features};
+
+// A handle to an engine, which we want to unsafely mark as Sync.
+struct EngineCapsule(*mut wasm_engine_t);
+
+impl Drop for EngineCapsule {
+    fn drop(&mut self) {
+        unsafe { wasm_engine_delete(self.0) }
+    }
+}
+
+unsafe impl Sync for EngineCapsule {}
+unsafe impl Send for EngineCapsule {}
+
+static ENGINE: std::sync::OnceLock<std::sync::Mutex<EngineCapsule>> = std::sync::OnceLock::new();
+
+#[derive(Debug)]
+pub(crate) struct CApiEngine {
+    pub(crate) engine: *mut wasm_engine_t,
+}
+
+impl Default for CApiEngine {
+    fn default() -> Self {
+        let engine = ENGINE
+            .get_or_init(|| unsafe { std::sync::Mutex::new(EngineCapsule(wasm_engine_new())) });
+        let engine = unsafe { engine.lock().unwrap().0 };
+        Self { engine }
+    }
+}
+
+impl Drop for CApiEngine {
+    fn drop(&mut self) {}
+}
+
+/// The V8 engine.
+#[derive(Clone, Debug, Default)]
+pub struct Engine {
+    pub(crate) inner: Arc<CApiEngine>,
+}
+
+impl Engine {
+    /// Create a new instance of the `V8` engine.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub(crate) fn deterministic_id(&self) -> String {
+        String::from("v8")
+    }
+
+    /// Returns the WebAssembly features supported by the V8 engine.
+    pub fn supported_features() -> Features {
+        // V8-specific features
+        let mut features = Features::default();
+        features.bulk_memory(true);
+        features.reference_types(true);
+        features.simd(true);
+        features.threads(true);
+        features.multi_value(true);
+        features.exceptions(false);
+        features
+    }
+
+    /// Returns the default features for the V8 engine.
+    pub fn default_features() -> Features {
+        Self::supported_features()
+    }
+}
+
+unsafe impl Send for Engine {}
+unsafe impl Sync for Engine {}
+
+/// Returns the default engine for the JS engine
+pub(crate) fn default_engine() -> Engine {
+    Engine::default()
+}
+
+impl crate::Engine {
+    /// Consume [`self`] into a [`crate::backend::v8::engine::Engine`].
+    pub fn into_v8(self) -> crate::backend::v8::engine::Engine {
+        match self.be {
+            BackendEngine::V8(s) => s,
+            _ => panic!("Not a `v8` engine!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::v8::engine::Engine`].
+    pub fn as_v8(&self) -> &crate::backend::v8::engine::Engine {
+        match &self.be {
+            BackendEngine::V8(s) => s,
+            _ => panic!("Not a `v8` engine!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::v8::engine::Engine`].
+    pub fn as_v8_mut(&mut self) -> &mut crate::backend::v8::engine::Engine {
+        match self.be {
+            BackendEngine::V8(ref mut s) => s,
+            _ => panic!("Not a `v8` engine!"),
+        }
+    }
+
+    /// Return true if [`self`] is an engine from the `v8` runtime.
+    pub fn is_v8(&self) -> bool {
+        matches!(self.be, BackendEngine::V8(_))
+    }
+}
+
+impl From<Engine> for crate::Engine {
+    fn from(value: Engine) -> Self {
+        crate::Engine {
+            be: BackendEngine::V8(value),
+            id: crate::Engine::atomic_next_engine_id(),
+        }
+    }
+}
diff --git a/lib/api/src/backend/v8/entities/exception.rs b/lib/api/src/backend/v8/entities/exception.rs
new file mode 100644
index 0000000000..7923ab57c9
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/exception.rs
@@ -0,0 +1,63 @@
+//! Data types, functions and traits for `sys` runtime's `Tag` implementation.
+use std::any::Any;
+
+use wasmer_types::{TagType, Type};
+
+use crate::{
+    v8::vm::{VMException, VMExceptionRef},
+    AsStoreMut, AsStoreRef, Tag, Value,
+};
+
+use super::store::StoreHandle;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// A WebAssembly `tag` in the `v8` runtime.
+pub(crate) struct Exception {
+    pub(crate) handle: VMException,
+}
+
+unsafe impl Send for Exception {}
+unsafe impl Sync for Exception {}
+
+impl Exception {
+    /// Create a new [`Exception`].
+    pub fn new(store: &mut impl AsStoreMut, tag: Tag, payload: &[Value]) -> Self {
+        todo!()
+    }
+}
+
+#[derive(Debug, Clone)]
+#[repr(transparent)]
+/// A WebAssembly `extern ref` in `v8`.
+pub(crate) struct ExceptionRef;
+
+impl ExceptionRef {
+    pub fn new<T>(_store: &mut impl AsStoreMut, _value: T) -> Self
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        unimplemented!("ExceptionRef is not yet supported in v8");
+    }
+
+    pub fn downcast<'a, T>(&self, _store: &'a impl AsStoreRef) -> Option<&'a T>
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        unimplemented!("ExceptionRef is not yet supported in v8");
+    }
+
+    pub(crate) fn vm_exceptionref(&self) -> VMExceptionRef {
+        unimplemented!("ExceptionRef is not yet supported in v8");
+    }
+
+    pub(crate) unsafe fn from_vm_exceptionref(
+        _store: &mut impl AsStoreMut,
+        _vm_exceptionref: VMExceptionRef,
+    ) -> Self {
+        unimplemented!("ExceptionRef is not yet supported in v8");
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
diff --git a/lib/api/src/backend/v8/entities/external.rs b/lib/api/src/backend/v8/entities/external.rs
new file mode 100644
index 0000000000..f2c01afb6a
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/external.rs
@@ -0,0 +1,42 @@
+//! Data types, functions and traits for `v8` runtime's `ExternRef` implementation.
+use crate::{
+    store::{AsStoreMut, AsStoreRef},
+    v8::vm::VMExternRef,
+};
+use std::any::Any;
+
+#[derive(Debug, Clone)]
+#[repr(transparent)]
+/// A WebAssembly `extern ref` in the `v8` runtime.
+pub struct ExternRef;
+
+impl ExternRef {
+    pub fn new<T>(_store: &mut impl AsStoreMut, _value: T) -> Self
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        unimplemented!("ExternRef is not yet supported with wasm_c_api");
+    }
+
+    pub fn downcast<'a, T>(&self, _store: &'a impl AsStoreRef) -> Option<&'a T>
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        unimplemented!("ExternRef is not yet supported in wasm_c_api");
+    }
+
+    pub(crate) fn vm_externref(&self) -> VMExternRef {
+        unimplemented!("ExternRef is not yet supported in wasm_c_api");
+    }
+
+    pub(crate) unsafe fn from_vm_externref(
+        _store: &mut impl AsStoreMut,
+        _vm_externref: VMExternRef,
+    ) -> Self {
+        unimplemented!("ExternRef is not yet supported in wasm_c_api");
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
diff --git a/lib/api/src/backend/v8/entities/function/env.rs b/lib/api/src/backend/v8/entities/function/env.rs
new file mode 100644
index 0000000000..efaf1ab7a2
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/function/env.rs
@@ -0,0 +1,213 @@
+use std::{any::Any, fmt::Debug, marker::PhantomData};
+
+use crate::{
+    store::{AsStoreMut, AsStoreRef, StoreRef},
+    v8::{store::StoreHandle, vm::VMFunctionEnvironment},
+    StoreMut,
+};
+
+#[derive(Debug)]
+#[repr(transparent)]
+/// An opaque reference to a function environment.
+/// The function environment data is owned by the `Store`.
+pub struct FunctionEnv<T> {
+    pub(crate) handle: StoreHandle<VMFunctionEnvironment>,
+    marker: PhantomData<T>,
+}
+
+impl<T> FunctionEnv<T> {
+    /// Make a new FunctionEnv
+    pub fn new(store: &mut impl AsStoreMut, value: T) -> Self
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        Self {
+            handle: StoreHandle::new(
+                store.as_store_mut().objects_mut().as_v8_mut(),
+                VMFunctionEnvironment::new(value),
+            ),
+            marker: PhantomData,
+        }
+    }
+
+    /// Get the data as reference
+    pub fn as_ref<'a>(&self, store: &'a impl AsStoreRef) -> &'a T
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        self.handle
+            .get(store.as_store_ref().objects().as_v8())
+            .as_ref()
+            .downcast_ref::<T>()
+            .unwrap()
+    }
+
+    pub(crate) fn from_handle(handle: StoreHandle<VMFunctionEnvironment>) -> Self {
+        Self {
+            handle,
+            marker: PhantomData,
+        }
+    }
+
+    /// Get the data as mutable
+    pub fn as_mut<'a>(&self, store: &'a mut impl AsStoreMut) -> &'a mut T
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        self.handle
+            .get_mut(store.objects_mut().as_v8_mut())
+            .as_mut()
+            .downcast_mut::<T>()
+            .unwrap()
+    }
+
+    /// Convert it into a `FunctionEnvMut`
+    pub fn into_mut(self, store: &mut impl AsStoreMut) -> FunctionEnvMut<T>
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        FunctionEnvMut {
+            store_mut: store.as_store_mut(),
+            func_env: self,
+        }
+    }
+}
+
+impl<T> PartialEq for FunctionEnv<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.handle == other.handle
+    }
+}
+
+impl<T> Eq for FunctionEnv<T> {}
+
+impl<T> std::hash::Hash for FunctionEnv<T> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.handle.hash(state);
+        self.marker.hash(state);
+    }
+}
+
+impl<T> Clone for FunctionEnv<T> {
+    fn clone(&self) -> Self {
+        Self {
+            handle: self.handle.clone(),
+            marker: self.marker,
+        }
+    }
+}
+
+/// A temporary handle to a [`FunctionEnv`].
+pub struct FunctionEnvMut<'a, T: 'a> {
+    pub(crate) store_mut: StoreMut<'a>,
+    pub(crate) func_env: FunctionEnv<T>,
+}
+
+impl<'a, T> Debug for FunctionEnvMut<'a, T>
+where
+    T: Send + Debug + 'static,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.func_env.as_ref(&self.store_mut).fmt(f)
+    }
+}
+
+impl<T: Send + 'static> FunctionEnvMut<'_, T> {
+    /// Returns a reference to the host state in this function environement.
+    pub fn data(&self) -> &T {
+        self.func_env.as_ref(&self.store_mut)
+    }
+
+    /// Returns a mutable- reference to the host state in this function environement.
+    pub fn data_mut(&mut self) -> &mut T {
+        self.func_env.as_mut(&mut self.store_mut)
+    }
+
+    /// Borrows a new immmutable reference
+    pub fn as_ref(&self) -> FunctionEnv<T> {
+        self.func_env.clone()
+    }
+
+    /// Borrows a new mutable reference
+    pub fn as_mut(&mut self) -> FunctionEnvMut<'_, T> {
+        FunctionEnvMut {
+            store_mut: self.store_mut.as_store_mut(),
+            func_env: self.func_env.clone(),
+        }
+    }
+
+    /// Borrows a new mutable reference of both the attached Store and host state
+    pub fn data_and_store_mut(&mut self) -> (&mut T, StoreMut) {
+        let data = self.func_env.as_mut(&mut self.store_mut) as *mut T;
+        // telling the borrow check to close his eyes here
+        // this is still relatively safe to do as func_env are
+        // stored in a specific vec of Store, separate from the other objects
+        // and not really directly accessible with the StoreMut
+        let data = unsafe { &mut *data };
+        (data, self.store_mut.as_store_mut())
+    }
+}
+
+//impl<T> Into<crate::FunctionEnv<T>> for FunctionEnv<T> {
+//    fn into(self) -> crate::FunctionEnv<T> {
+//        crate::FunctionEnv::Wamr(self)
+//    }
+//}
+
+impl<T> AsStoreRef for FunctionEnvMut<'_, T> {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        StoreRef {
+            inner: self.store_mut.inner,
+        }
+    }
+}
+
+impl<T> AsStoreMut for FunctionEnvMut<'_, T> {
+    fn as_store_mut(&mut self) -> StoreMut<'_> {
+        StoreMut {
+            inner: self.store_mut.inner,
+        }
+    }
+
+    fn objects_mut(&mut self) -> &mut crate::StoreObjects {
+        self.store_mut.objects_mut()
+    }
+}
+
+impl<T> crate::FunctionEnv<T> {
+    /// Consume [`self`] into [`crate::backend::v8::function::env::FunctionEnv`].
+    pub fn into_v8(self) -> FunctionEnv<T> {
+        match self.0 {
+            crate::BackendFunctionEnv::V8(s) => s,
+            _ => panic!("Not a `v8` function env!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference to [`crate::backend::v8::function::env::FunctionEnv`].
+    pub fn as_v8(&self) -> &FunctionEnv<T> {
+        match self.0 {
+            crate::BackendFunctionEnv::V8(ref s) => s,
+            _ => panic!("Not a `v8` function env!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::v8::function::env::FunctionEnv`].
+    pub fn as_v8_mut(&mut self) -> &mut FunctionEnv<T> {
+        match self.0 {
+            crate::BackendFunctionEnv::V8(ref mut s) => s,
+            _ => panic!("Not a `v8` function env!"),
+        }
+    }
+}
+
+impl<'a, T> From<FunctionEnvMut<'a, T>> for crate::FunctionEnvMut<'a, T> {
+    fn from(value: FunctionEnvMut<'a, T>) -> Self {
+        crate::FunctionEnvMut(crate::BackendFunctionEnvMut::V8(value))
+    }
+}
+
+impl<T> From<FunctionEnv<T>> for crate::FunctionEnv<T> {
+    fn from(value: FunctionEnv<T>) -> Self {
+        crate::FunctionEnv(crate::BackendFunctionEnv::V8(value))
+    }
+}
diff --git a/lib/api/src/backend/v8/entities/function/mod.rs b/lib/api/src/backend/v8/entities/function/mod.rs
new file mode 100644
index 0000000000..67278428d3
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/function/mod.rs
@@ -0,0 +1,717 @@
+//! Data types, functions and traits for `v8` runtime's `Function` implementation.
+#![allow(non_snake_case)]
+use std::{
+    ffi::c_void,
+    panic::{self, AssertUnwindSafe},
+};
+
+use crate::{
+    v8::{
+        bindings::*,
+        utils::convert::{IntoCApiType, IntoCApiValue, IntoWasmerType, IntoWasmerValue},
+        vm::{VMFuncRef, VMFunction, VMFunctionCallback, VMFunctionEnvironment},
+    },
+    vm::{VMExtern, VMExternFunction},
+    AsStoreMut, AsStoreRef, BackendFunction, BackendFunctionEnvMut, BackendTrap,
+    FromToNativeWasmType, FunctionEnv, FunctionEnvMut, IntoResult, NativeWasmType,
+    NativeWasmTypeInto, RuntimeError, StoreMut, Value, WasmTypeList, WithEnv, WithoutEnv,
+};
+
+use super::{super::error::Trap, check_isolate, store::StoreHandle};
+use wasmer_types::{FunctionType, RawValue};
+
+pub(crate) mod env;
+pub(crate) mod typed;
+
+pub use typed::*;
+
+type CCallback = unsafe extern "C" fn(
+    *mut c_void,
+    *const wasm_val_vec_t,
+    *mut wasm_val_vec_t,
+) -> *mut wasm_trap_t;
+
+#[derive(Clone, PartialEq, Eq)]
+/// A WebAssembly `function` in `v8`.
+pub struct Function {
+    pub(crate) handle: VMFunction,
+}
+
+unsafe impl Send for Function {}
+unsafe impl Sync for Function {}
+
+impl From<VMFunction> for Function {
+    fn from(handle: VMFunction) -> Self {
+        Self { handle }
+    }
+}
+
+pub(crate) struct FunctionCallbackEnv<'a, F> {
+    pub(crate) store: StoreMut<'a>,
+    pub(crate) func: F,
+    pub(crate) env_handle: Option<StoreHandle<VMFunctionEnvironment>>,
+}
+
+impl<'a, F> std::fmt::Debug for FunctionCallbackEnv<'a, F> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("FunctionCallbackEnv")
+            .field("env_is_some", &self.env_handle.is_some())
+            .finish()
+    }
+}
+
+impl Function {
+    /// To `VMExtern`.
+    pub fn to_vm_extern(&self) -> VMExtern {
+        let extern_ = unsafe { wasm_func_as_extern(self.handle) };
+        assert!(
+            !extern_.is_null(),
+            "Returned null Function extern from wasm-c-api"
+        );
+        VMExtern::V8(extern_)
+    }
+
+    #[allow(clippy::cast_ptr_alignment)]
+    pub fn new_with_env<FT, F, T: Send + 'static>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        ty: FT,
+        func: F,
+    ) -> Self
+    where
+        FT: Into<FunctionType>,
+        F: Fn(FunctionEnvMut<'_, T>, &[Value]) -> Result<Vec<Value>, RuntimeError>
+            + 'static
+            + Send
+            + Sync,
+    {
+        check_isolate(store);
+
+        let fn_ty: FunctionType = ty.into();
+        let params = fn_ty.params();
+
+        let mut param_types = params
+            .into_iter()
+            .map(|param| {
+                let kind = param.into_ct();
+                unsafe { wasm_valtype_new(kind) }
+            })
+            .collect::<Vec<_>>();
+
+        let mut wasm_param_types = unsafe {
+            let mut vec = Default::default();
+            wasm_valtype_vec_new(&mut vec, param_types.len(), param_types.as_ptr());
+            vec
+        };
+
+        let results = fn_ty.results();
+        let mut result_types = results
+            .into_iter()
+            .map(|param| {
+                let kind = param.into_ct();
+                unsafe { wasm_valtype_new(kind) }
+            })
+            .collect::<Vec<_>>();
+
+        let mut wasm_result_types = unsafe {
+            let mut vec = Default::default();
+            wasm_valtype_vec_new(&mut vec, result_types.len(), result_types.as_ptr());
+            vec
+        };
+
+        let wasm_functype = unsafe {
+            wasm_functype_new(
+                &mut wasm_param_types as *mut _,
+                &mut wasm_result_types as *mut _,
+            )
+        };
+
+        let mut store = store.as_store_mut();
+        let inner = store.inner.store.as_v8().inner;
+
+        let callback: CCallback = make_fn_callback(&func, param_types.len());
+
+        let mut callback_env: *mut FunctionCallbackEnv<'_, F> =
+            Box::leak(Box::new(FunctionCallbackEnv {
+                store,
+                func,
+                env_handle: Some(env.as_v8().handle.clone()),
+            }));
+
+        let wasm_function = unsafe {
+            wasm_func_new_with_env(
+                inner,
+                wasm_functype,
+                Some(callback),
+                callback_env as *mut _ as _,
+                None,
+            )
+        };
+
+        if wasm_function.is_null() {
+            panic!("failed when creating new typed function");
+        }
+
+        Function {
+            handle: wasm_function,
+        }
+    }
+
+    /// Creates a new host `Function` from a native function.
+    pub fn new_typed<F, Args, Rets>(store: &mut impl AsStoreMut, func: F) -> Self
+    where
+        F: crate::HostFunction<(), Args, Rets, WithoutEnv> + 'static + Send + Sync,
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+    {
+        check_isolate(store);
+        let mut param_types = Args::wasm_types()
+            .into_iter()
+            .map(|param| {
+                let kind = param.into_ct();
+                unsafe { wasm_valtype_new(kind) }
+            })
+            .collect::<Vec<_>>();
+
+        let mut wasm_param_types = unsafe {
+            let mut vec = Default::default();
+            wasm_valtype_vec_new(&mut vec, param_types.len(), param_types.as_ptr());
+            vec
+        };
+
+        let mut result_types = Rets::wasm_types()
+            .into_iter()
+            .map(|param| {
+                let kind = param.into_ct();
+                unsafe { wasm_valtype_new(kind) }
+            })
+            .collect::<Vec<_>>();
+
+        let mut wasm_result_types = unsafe {
+            let mut vec = Default::default();
+            wasm_valtype_vec_new(&mut vec, result_types.len(), result_types.as_ptr());
+            vec
+        };
+
+        let wasm_functype =
+            unsafe { wasm_functype_new(&mut wasm_param_types, &mut wasm_result_types) };
+
+        let mut store = store.as_store_mut();
+        let inner = store.inner.store.as_v8().inner;
+
+        let callback: CCallback = unsafe {
+            std::mem::transmute(func.function_callback(crate::BackendKind::V8).into_v8())
+        };
+
+        let mut callback_env: *mut FunctionCallbackEnv<'_, F> =
+            Box::into_raw(Box::new(FunctionCallbackEnv {
+                store,
+                func,
+                env_handle: None,
+            }));
+
+        let wasm_function = unsafe {
+            wasm_func_new_with_env(
+                inner,
+                wasm_functype,
+                Some(callback),
+                callback_env as _,
+                None,
+            )
+        };
+
+        if wasm_function.is_null() {
+            panic!("failed when creating new typed function");
+        }
+
+        Function {
+            handle: wasm_function,
+        }
+    }
+
+    pub fn new_typed_with_env<T, F, Args, Rets>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        func: F,
+    ) -> Self
+    where
+        F: crate::HostFunction<T, Args, Rets, WithEnv>,
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+        T: Send + 'static,
+    {
+        check_isolate(store);
+        let mut param_types = Args::wasm_types()
+            .into_iter()
+            .map(|param| {
+                let kind = param.into_ct();
+                unsafe { wasm_valtype_new(kind) }
+            })
+            .collect::<Vec<_>>();
+
+        let mut wasm_param_types = unsafe {
+            let mut vec = wasm_valtype_vec_t::default();
+            wasm_valtype_vec_new(&mut vec, param_types.len(), param_types.as_ptr());
+            vec
+        };
+
+        let mut result_types = Rets::wasm_types()
+            .into_iter()
+            .map(|param| {
+                let kind = param.into_ct();
+                unsafe { wasm_valtype_new(kind) }
+            })
+            .collect::<Vec<_>>();
+
+        let mut wasm_result_types = unsafe {
+            let mut vec: wasm_valtype_vec_t = Default::default();
+            wasm_valtype_vec_new(&mut vec, result_types.len(), result_types.as_ptr());
+            vec
+        };
+
+        let wasm_functype = unsafe {
+            wasm_functype_new(
+                &mut wasm_param_types as *mut _,
+                &mut wasm_result_types as *mut _,
+            )
+        };
+
+        let mut store = store.as_store_mut();
+        let inner = store.inner.store.as_v8().inner;
+
+        let callback: CCallback = unsafe {
+            std::mem::transmute(func.function_callback(crate::BackendKind::V8).into_v8())
+        };
+
+        let mut callback_env: *mut FunctionCallbackEnv<'_, F> =
+            Box::into_raw(Box::new(FunctionCallbackEnv {
+                store,
+                func,
+                env_handle: Some(env.as_v8().handle.clone()),
+            }));
+
+        let wasm_function = unsafe {
+            wasm_func_new_with_env(
+                inner,
+                wasm_functype,
+                Some(callback),
+                callback_env as _,
+                None,
+            )
+        };
+
+        if wasm_function.is_null() {
+            panic!("failed when creating new typed function");
+        }
+
+        Function {
+            handle: wasm_function,
+        }
+    }
+
+    pub fn ty(&self, _store: &impl AsStoreRef) -> FunctionType {
+        check_isolate(_store);
+        let type_ = unsafe { wasm_func_type(self.handle) };
+        let params: *const wasm_valtype_vec_t = unsafe { wasm_functype_params(type_) };
+        let returns: *const wasm_valtype_vec_t = unsafe { wasm_functype_results(type_) };
+
+        let params: Vec<wasmer_types::Type> = unsafe {
+            let mut res = vec![];
+            for i in 0..(*params).size {
+                res.push((*(*params).data.wrapping_add(i)).into_wt());
+            }
+            res
+        };
+
+        let returns: Vec<wasmer_types::Type> = unsafe {
+            let mut res = vec![];
+            for i in 0..(*returns).size {
+                res.push((*(*returns).data.wrapping_add(i)).into_wt());
+            }
+            res
+        };
+
+        FunctionType::new(params, returns)
+    }
+
+    pub fn call_raw(
+        &self,
+        _store: &mut impl AsStoreMut,
+        _params: Vec<RawValue>,
+    ) -> Result<Box<[Value]>, RuntimeError> {
+        // There is no optimal call_raw in JSC, so we just
+        // simply rely the call
+        // self.call(store, params)
+        unimplemented!();
+    }
+
+    pub fn call(
+        &self,
+        store: &mut impl AsStoreMut,
+        params: &[Value],
+    ) -> Result<Box<[Value]>, RuntimeError> {
+        check_isolate(store);
+        // unimplemented!();
+        let store_mut = store.as_store_mut();
+        // let wasm_func_param_arity(self.handle)
+
+        let mut args = {
+            unsafe {
+                let mut wasm_params = params
+                    .into_iter()
+                    .map(|v| IntoCApiValue::into_cv(v.clone()))
+                    .collect::<Vec<_>>()
+                    .into_boxed_slice();
+                let mut vec = Default::default();
+                wasm_val_vec_new(&mut vec, wasm_params.len(), wasm_params.as_ptr());
+                vec
+            }
+        };
+
+        let size = unsafe { wasm_func_result_arity(self.handle) };
+
+        let mut results = {
+            unsafe {
+                let mut vec = Default::default();
+                wasm_val_vec_new_uninitialized(&mut vec, size);
+                vec
+            }
+        };
+
+        let mut trap;
+
+        loop {
+            trap = unsafe { wasm_func_call(self.handle, &mut args as _, &mut results as *mut _) };
+            let store_mut = store.as_store_mut();
+            if let Some(callback) = store_mut.inner.on_called.take() {
+                match callback(store_mut) {
+                    Ok(wasmer_types::OnCalledAction::InvokeAgain) => {
+                        continue;
+                    }
+                    Ok(wasmer_types::OnCalledAction::Finish) => {
+                        break;
+                    }
+                    Ok(wasmer_types::OnCalledAction::Trap(trap)) => {
+                        return Err(RuntimeError::user(trap))
+                    }
+                    Err(trap) => return Err(RuntimeError::user(trap)),
+                }
+            }
+            break;
+        }
+
+        if !trap.is_null() {
+            return Err(Into::<Trap>::into(trap).into());
+        }
+
+        unsafe {
+            let results = std::ptr::slice_from_raw_parts(results.data, results.size);
+            return Ok((*results)
+                .into_iter()
+                .map(|v| IntoWasmerValue::into_wv(*v))
+                .collect::<Vec<_>>()
+                .into_boxed_slice());
+        }
+    }
+
+    pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, internal: VMExternFunction) -> Self {
+        Self {
+            handle: internal.into_v8(),
+        }
+    }
+
+    pub(crate) fn vm_funcref(&self, _store: &impl AsStoreRef) -> VMFuncRef {
+        unimplemented!();
+    }
+
+    pub(crate) unsafe fn from_vm_funcref(
+        _store: &mut impl AsStoreMut,
+        _funcref: VMFuncRef,
+    ) -> Self {
+        unimplemented!();
+    }
+
+    /// Checks whether this `Function` can be used with the given context.
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
+
+fn make_fn_callback<F, T: Send + 'static>(func: &F, args: usize) -> CCallback
+where
+    F: Fn(FunctionEnvMut<'_, T>, &[Value]) -> Result<Vec<Value>, RuntimeError>
+        + 'static
+        + Send
+        + Sync,
+{
+    unsafe extern "C" fn fn_callback<F, T: Send + 'static>(
+        env: *mut c_void,
+        args: *const wasm_val_vec_t,
+        rets: *mut wasm_val_vec_t,
+    ) -> *mut wasm_trap_t
+    where
+        F: Fn(FunctionEnvMut<'_, T>, &[Value]) -> Result<Vec<Value>, RuntimeError>
+            + 'static
+            + Send
+            + Sync,
+    {
+        let r: *mut (FunctionCallbackEnv<'_, F>) = env as _;
+
+        let mut store = (*r).store.as_store_mut();
+        let env_handle = (*r).env_handle.as_ref().unwrap().clone();
+        let mut fn_env = env::FunctionEnv::from_handle(env_handle).into_mut(&mut store);
+        let func: &F = &(*r).func;
+
+        let mut wasmer_args = vec![];
+
+        for i in 0..(*args).size {
+            wasmer_args.push((*(*args).data.wrapping_add(i)).into_wv().clone());
+        }
+
+        let result = panic::catch_unwind(AssertUnwindSafe(|| unsafe {
+            func(fn_env.into(), wasmer_args.as_slice())
+        }));
+
+        match result {
+            Ok(Ok(native_results)) => {
+                let mut c_results: Vec<wasm_val_t> = native_results
+                    .into_iter()
+                    .map(IntoCApiValue::into_cv)
+                    .collect();
+
+                if c_results.len() != (*rets).size {
+                    panic!("when calling host function: number of observed results differ from wanted results")
+                }
+
+                unsafe {
+                    for i in 0..(*rets).size {
+                        *((*rets).data.wrapping_add(i)) = c_results[i]
+                    }
+                }
+
+                unsafe { std::ptr::null_mut() }
+            }
+
+            Ok(Err(e)) => {
+                let trap: Trap = Trap::user(Box::new(e));
+                unsafe { trap.into_wasm_trap(&mut store) }
+            }
+
+            Err(e) => {
+                unimplemented!("host function panicked");
+            }
+        }
+    }
+
+    return fn_callback::<F, T>;
+}
+
+impl std::fmt::Debug for Function {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.debug_struct("Function").finish()
+    }
+}
+
+impl crate::Function {
+    /// Consume [`self`] into [`crate::backend::v8::function::Function`].
+    pub fn into_v8(self) -> crate::backend::v8::function::Function {
+        match self.0 {
+            BackendFunction::V8(s) => s,
+            _ => panic!("Not a `v8` function!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference to [`crate::backend::v8::function::Function`].
+    pub fn as_v8(&self) -> &crate::backend::v8::function::Function {
+        match self.0 {
+            BackendFunction::V8(ref s) => s,
+            _ => panic!("Not a `v8` function!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::v8::function::Function`].
+    pub fn as_v8_mut(&mut self) -> &mut crate::backend::v8::function::Function {
+        match self.0 {
+            BackendFunction::V8(ref mut s) => s,
+            _ => panic!("Not a `v8` function!"),
+        }
+    }
+}
+
+macro_rules! impl_host_function {
+    ([$c_struct_representation:ident] $c_struct_name:ident, $( $x:ident ),* ) => {
+        paste::paste! {
+        #[allow(non_snake_case)]
+        pub(crate) fn [<gen_fn_callback_ $c_struct_name:lower _no_env>]
+            <$( $x: FromToNativeWasmType, )* Rets: WasmTypeList, RetsAsResult: IntoResult<Rets>, Func: Fn($( $x , )*) -> RetsAsResult + 'static>
+            (this: &Func) -> crate::backend::v8::vm::VMFunctionCallback {
+
+            /// This is a function that wraps the real host
+            /// function. Its address will be used inside the
+            /// runtime.
+            unsafe extern "C" fn func_wrapper<$( $x, )* Rets, RetsAsResult, Func>(env: *mut c_void, args: *const wasm_val_vec_t, results: *mut wasm_val_vec_t) -> *mut wasm_trap_t
+            where
+                $( $x: FromToNativeWasmType, )*
+                Rets: WasmTypeList,
+                RetsAsResult: IntoResult<Rets>,
+                Func: Fn($( $x , )*) -> RetsAsResult + 'static,
+            {
+                let mut r: *mut crate::backend::v8::function::FunctionCallbackEnv<Func> = unsafe {std::mem::transmute(env)};
+                let store = &mut (*r).store.as_store_mut();
+                let mut i = 0;
+
+                $(
+                    let c_arg = (*(*args).data.wrapping_add(i)).clone();
+                    let wasmer_arg = c_arg.into_wv();
+                    let raw_arg : RawValue = wasmer_arg.as_raw(store);
+                    let $x : $x = FromToNativeWasmType::from_native($x::Native::from_raw(store, raw_arg));
+
+                    i += 1;
+                )*
+
+                let result = panic::catch_unwind(AssertUnwindSafe(|| unsafe {
+                    ((*r).func)( $( $x, )* ).into_result()
+                }));
+
+                match result {
+                    Ok(Ok(result)) => {
+
+                        let types = Rets::wasm_types();
+                        let mut native_results = result.into_array(store);
+                        let native_results = native_results.as_mut();
+
+                        let native_results: Vec<Value> = native_results.into_iter().enumerate()
+                            .map(|(i, r)| Value::from_raw(store, types[i], r.clone()))
+                            .collect();
+
+                        let mut c_results: Vec<wasm_val_t> = native_results.into_iter().map(IntoCApiValue::into_cv).collect();
+
+                        if c_results.len() != (*results).size {
+                            panic!("when calling host function: number of observed results differ from wanted results")
+                        }
+
+                        unsafe {
+                            for i in 0..(*results).size {
+                                *((*results).data.wrapping_add(i)) = c_results[i]
+                            }
+                        }
+
+                         unsafe { std::ptr::null_mut() }
+                    },
+
+                    Ok(Err(e)) => {
+                        let trap =  crate::backend::v8::error::Trap::user(Box::new(e));
+                        unsafe { trap.into_wasm_trap(store) }
+                        // unimplemented!("host function panicked");
+                    },
+
+                    Err(e) => {
+                        unimplemented!("host function panicked");
+                    }
+                }
+            }
+            func_wrapper::< $( $x, )* Rets, RetsAsResult, Func> as _
+        }
+
+
+        #[allow(non_snake_case)]
+        pub(crate) fn [<gen_fn_callback_ $c_struct_name:lower>]
+            <$( $x: FromToNativeWasmType, )* Rets: WasmTypeList, RetsAsResult: IntoResult<Rets>, T: Send + 'static,  Func: Fn(FunctionEnvMut<T>, $( $x , )*) -> RetsAsResult + 'static>
+            (this: &Func) -> crate::backend::v8::vm::VMFunctionCallback {
+            unsafe extern "C" fn func_wrapper<$( $x, )* Rets, RetsAsResult, Func, T>(env: *mut c_void, args: *const wasm_val_vec_t, results: *mut wasm_val_vec_t) -> *mut wasm_trap_t
+            where
+              $( $x: FromToNativeWasmType, )*
+              Rets: WasmTypeList,
+              RetsAsResult: IntoResult<Rets>,
+              T: Send + 'static,
+              Func: Fn(FunctionEnvMut<'_, T>, $( $x , )*) -> RetsAsResult + 'static,
+            {
+
+              let r: *mut (crate::backend::v8::function::FunctionCallbackEnv<'_, Func>) = env as _;
+              let store = &mut (*r).store.as_store_mut();
+
+              let mut i = 0;
+
+              $(
+              let c_arg = (*(*args).data.wrapping_add(i)).clone();
+              let wasmer_arg = c_arg.into_wv();
+              let raw_arg : RawValue = wasmer_arg.as_raw(store);
+              let $x : $x = FromToNativeWasmType::from_native($x::Native::from_raw(store, raw_arg));
+
+              i += 1;
+              )*
+
+              let env_handle = (*r).env_handle.as_ref().unwrap().clone();
+              let mut fn_env = crate::backend::v8::function::env::FunctionEnv::from_handle(env_handle).into_mut(store);
+              let func: &Func = &(*r).func;
+
+              let result = panic::catch_unwind(AssertUnwindSafe(|| unsafe {
+                  ((*r).func)(BackendFunctionEnvMut::V8(fn_env).into(), $( $x, )* ).into_result()
+              }));
+
+
+              match result {
+                  Ok(Ok(result)) => {
+                    let types = Rets::wasm_types();
+                    let mut native_results = result.into_array(store);
+                    let native_results = native_results.as_mut();
+
+                    let native_results: Vec<Value> = native_results.into_iter().enumerate().map(|(i, r)| Value::from_raw(store, types[i], r.clone())).collect();
+
+                    let mut c_results: Vec<wasm_val_t> = native_results.into_iter().map(IntoCApiValue::into_cv).collect();
+
+                    if c_results.len() != (*results).size {
+                        panic!("when calling host function: number of observed results differ from wanted results")
+                    }
+
+                    unsafe {
+                        for i in 0..(*results).size {
+                            *((*results).data.wrapping_add(i)) = c_results[i]
+                        }
+
+                    }
+
+                    unsafe { std::ptr::null_mut() }
+                },
+
+                Ok(Err(e)) => { let trap = crate::backend::v8::error::Trap::user(Box::new(e)); unsafe { trap.into_wasm_trap(store) } },
+
+                Err(e) => { unimplemented!("host function panicked"); }
+              }
+            }
+
+            func_wrapper::< $( $x, )* Rets, RetsAsResult, Func, T> as _
+        }
+        }
+    };
+}
+
+// Here we go! Let's generate all the C struct, `WasmTypeList`
+// implementations and `HostFunction` implementations.
+impl_host_function!([C] S0,);
+impl_host_function!([transparent] S1, A1);
+impl_host_function!([C] S2, A1, A2);
+impl_host_function!([C] S3, A1, A2, A3);
+impl_host_function!([C] S4, A1, A2, A3, A4);
+impl_host_function!([C] S5, A1, A2, A3, A4, A5);
+impl_host_function!([C] S6, A1, A2, A3, A4, A5, A6);
+impl_host_function!([C] S7, A1, A2, A3, A4, A5, A6, A7);
+impl_host_function!([C] S8, A1, A2, A3, A4, A5, A6, A7, A8);
+impl_host_function!([C] S9, A1, A2, A3, A4, A5, A6, A7, A8, A9);
+impl_host_function!([C] S10, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+impl_host_function!([C] S11, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
+impl_host_function!([C] S12, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
+impl_host_function!([C] S13, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
+impl_host_function!([C] S14, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
+impl_host_function!([C] S15, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
+impl_host_function!([C] S16, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16);
+impl_host_function!([C] S17, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17);
+impl_host_function!([C] S18, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18);
+impl_host_function!([C] S19, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19);
+impl_host_function!([C] S20, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20);
+impl_host_function!([C] S21, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21);
+impl_host_function!([C] S22, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22);
+impl_host_function!([C] S23, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23);
+impl_host_function!([C] S24, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24);
+impl_host_function!([C] S25, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25);
+impl_host_function!([C] S26, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26);
diff --git a/lib/api/src/backend/v8/entities/function/typed.rs b/lib/api/src/backend/v8/entities/function/typed.rs
new file mode 100644
index 0000000000..ffbe1e9a97
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/function/typed.rs
@@ -0,0 +1,147 @@
+//! Native Functions.
+//!
+//! This module creates the helper `TypedFunction` that let us call WebAssembly
+//! functions with the native ABI, that is:
+//!
+//! ```ignore
+//! let add_one = instance.exports.get_function("function_name")?;
+//! let add_one_native: TypedFunction<i32, i32> = add_one.typed().unwrap();
+//! ```
+
+use std::iter::FromIterator;
+
+use crate::{
+    backend::v8::{bindings::*, error::Trap, function::Function, utils::convert::*},
+    AsStoreMut, FromToNativeWasmType, NativeWasmType, NativeWasmTypeInto, RuntimeError,
+    TypedFunction, Value, WasmTypeList,
+};
+use wasmer_types::RawValue;
+
+macro_rules! impl_native_traits {
+    (  $( $x:ident ),* ) => {
+        #[allow(unused_parens, non_snake_case)]
+         impl<$( $x , )* Rets> TypedFunction<( $( $x ),* ), Rets>
+         where
+             $( $x: FromToNativeWasmType, )*
+             Rets: WasmTypeList,
+         {
+             /// Call the typed func and return results.
+            #[allow(clippy::too_many_arguments)]
+            pub fn call_v8(&self, mut store: &mut impl AsStoreMut, $( $x: $x, )* ) -> Result<Rets, RuntimeError> where
+            $( $x: FromToNativeWasmType, )*
+            {
+
+                 // // let store_ptr = Value::I64(store.as_store_mut().as_raw() as _).as_jsvalue(store);
+                 #[allow(unused_unsafe)]
+                 let params_list: Vec<_> = unsafe {
+                     vec![ $( {
+                         let raw = $x.to_native().into_raw(store);
+                         let value = Value::from_raw(&mut store, <$x::Native as NativeWasmType>::WASM_TYPE, raw);
+                         value.into_cv()
+                     } ),* ]
+                 };
+
+                 let mut results = {
+                    unsafe {
+                        let mut ret = std::mem::zeroed();
+                        wasm_val_vec_new_uninitialized(&mut ret, Rets::wasm_types().len());
+                        ret
+                    }
+                };
+
+
+                 let func = unsafe { wasm_extern_as_func(self.func.to_vm_extern().into_v8()) };
+
+                let mut params = unsafe {std::mem::zeroed()};
+                unsafe {wasm_val_vec_new(&mut params, params_list.len(), params_list.as_ptr())};
+
+                 let mut trap;
+
+                 loop {
+                    trap = unsafe { wasm_func_call(func, &params, &mut results) };
+
+                    let store_mut = store.as_store_mut();
+                    if let Some(callback) = store_mut.inner.on_called.take() {
+                        match callback(store_mut) {
+                            Ok(wasmer_types::OnCalledAction::InvokeAgain) => { continue; }
+                            Ok(wasmer_types::OnCalledAction::Finish) => { break; }
+                            Ok(wasmer_types::OnCalledAction::Trap(trap)) => { return Err(RuntimeError::user(trap)) },
+                            Err(trap) => { return Err(RuntimeError::user(trap)) },
+                        }
+                    }
+                    break;
+                };
+
+
+
+                 if !trap.is_null() {
+                     unsafe {
+                        let trap: Trap = trap.into();
+                        return Err(RuntimeError::from(trap));
+                     }
+                }
+
+                unsafe {
+                    let mut rets_list_array = Rets::empty_array();
+                    let mut_rets = rets_list_array.as_mut() as *mut [RawValue] as *mut RawValue;
+
+                    match Rets::size() {
+                        0 => {},
+                        1 => {
+                            let val = (*results.data.wrapping_add(0)).clone();
+                            let val = val.into_wv();
+                            *mut_rets = val.as_raw(&mut store);
+                        }
+                        _n => {
+                            for (i, ret_type) in Rets::wasm_types().iter().enumerate() {
+                                    let val = (*results.data.wrapping_add(i)).clone();
+                                    let val = val.into_wv();
+                                    let slot = mut_rets.add(i);
+                                    *slot = val.as_raw(&mut store);
+                            }
+                        }
+                    }
+
+                    Ok(unsafe { Rets::from_array(store, rets_list_array) })
+                }
+            }
+
+            #[doc(hidden)]
+            #[allow(missing_docs)]
+            #[allow(unused_mut)]
+            #[allow(clippy::too_many_arguments)]
+            pub fn call_raw_v8(&self, store: &mut impl AsStoreMut, mut params_list: Vec<RawValue> ) -> Result<Rets, RuntimeError> {
+                todo!("Raw calls from v8 are not supported yet!")
+            }
+        }
+    };
+
+}
+
+impl_native_traits!();
+impl_native_traits!(A1);
+impl_native_traits!(A1, A2);
+impl_native_traits!(A1, A2, A3);
+impl_native_traits!(A1, A2, A3, A4);
+impl_native_traits!(A1, A2, A3, A4, A5);
+impl_native_traits!(A1, A2, A3, A4, A5, A6);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17);
+impl_native_traits!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18
+);
+impl_native_traits!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19
+);
+impl_native_traits!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20
+);
diff --git a/lib/api/src/backend/v8/entities/global.rs b/lib/api/src/backend/v8/entities/global.rs
new file mode 100644
index 0000000000..796047081e
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/global.rs
@@ -0,0 +1,127 @@
+//! Data types, functions and traits for `v8` runtime's `Global` implementation.
+use wasmer_types::{GlobalType, Mutability};
+
+use crate::{
+    v8::{
+        bindings::{
+            self, wasm_global_as_extern, wasm_global_get, wasm_global_new, wasm_global_set,
+            wasm_global_type, wasm_globaltype_content, wasm_globaltype_mutability,
+            wasm_globaltype_new, wasm_mutability_t, wasm_valtype_new,
+        },
+        utils::convert::{IntoCApiType, IntoCApiValue, IntoWasmerType, IntoWasmerValue},
+        vm::VMGlobal,
+    },
+    vm::{VMExtern, VMExternGlobal},
+    AsStoreMut, AsStoreRef, RuntimeError, Value,
+};
+
+use super::check_isolate;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// A WebAssembly `global` in the `v8` runtime.
+pub struct Global {
+    pub(crate) handle: VMGlobal,
+}
+
+unsafe impl Send for Global {}
+unsafe impl Sync for Global {}
+
+// Global can't be Send in js because it dosen't support `structuredClone`
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// unsafe impl Send for Global {}
+
+impl Global {
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        let extern_ = unsafe { wasm_global_as_extern(self.handle) };
+        assert!(
+            !extern_.is_null(),
+            "Returned null Global extern from wasm-c-api"
+        );
+        VMExtern::V8(extern_)
+    }
+
+    /// Create a `Global` with the initial value [`Value`] and the provided [`Mutability`].
+    pub(crate) fn from_value(
+        store: &mut impl AsStoreMut,
+        val: Value,
+        mutability: Mutability,
+    ) -> Result<Self, RuntimeError> {
+        check_isolate(store);
+        let store = store.as_store_mut();
+        let v8_store = store.inner.store.as_v8();
+        let v8_type = val.ty().into_ct();
+        let v8_value = val.into_cv();
+        let v8_mutability = if mutability.is_mutable() {
+            bindings::wasm_mutability_enum_WASM_VAR
+        } else {
+            bindings::wasm_mutability_enum_WASM_CONST
+        } as wasm_mutability_t;
+
+        let v8_global_type =
+            unsafe { wasm_globaltype_new(wasm_valtype_new(v8_type), v8_mutability) };
+
+        Ok(Self {
+            handle: unsafe { wasm_global_new(v8_store.inner, v8_global_type, &v8_value) },
+        })
+    }
+
+    pub fn ty(&self, store: &impl AsStoreRef) -> GlobalType {
+        check_isolate(store);
+        let store = store.as_store_ref();
+        let r#type = unsafe { wasm_global_type(self.handle) };
+        let mutability = unsafe { wasm_globaltype_mutability(&*r#type) };
+        let valtype = unsafe { wasm_globaltype_content(r#type) };
+        let wasmer_type = valtype.into_wt();
+
+        GlobalType::new(
+            wasmer_type,
+            if mutability == bindings::wasm_mutability_enum_WASM_VAR as u8 {
+                Mutability::Var
+            } else {
+                Mutability::Const
+            },
+        )
+    }
+
+    pub fn get(&self, store: &mut impl AsStoreMut) -> Value {
+        check_isolate(store);
+        let store = store.as_store_ref();
+        let mut out = unsafe { std::mem::zeroed() };
+        unsafe { wasm_global_get(self.handle, &mut out) };
+        out.into_wv()
+    }
+
+    pub fn set(&self, store: &mut impl AsStoreMut, val: Value) -> Result<(), RuntimeError> {
+        check_isolate(store);
+
+        if val.ty() != self.ty(store).ty {
+            return Err(RuntimeError::new(format!(
+                "Incompatible types: {} != {}",
+                val.ty(),
+                self.ty(store)
+            )));
+        }
+
+        if self.ty(store).mutability == Mutability::Const {
+            return Err(RuntimeError::new("The global is immutable".to_owned()));
+        }
+
+        let value = val.into_cv();
+
+        unsafe { wasm_global_set(self.handle, &value) };
+
+        Ok(())
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_global: VMExternGlobal) -> Self {
+        check_isolate(store);
+        Self {
+            handle: vm_global.into_v8(),
+        }
+    }
+
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        check_isolate(store);
+        true
+    }
+}
diff --git a/lib/api/src/backend/v8/entities/instance.rs b/lib/api/src/backend/v8/entities/instance.rs
new file mode 100644
index 0000000000..3d337a6447
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/instance.rs
@@ -0,0 +1,148 @@
+//! Data types, functions and traits for `v8` runtime's `Function` implementation.
+use std::sync::Arc;
+
+use crate::{
+    backend::v8::bindings::*, v8::error::Trap, vm::VMExtern, AsStoreMut, AsStoreRef, Exports,
+    Extern, Imports, InstantiationError, Module,
+};
+
+use super::check_isolate;
+
+#[derive(PartialEq, Eq)]
+pub(crate) struct InstanceHandle(pub(crate) *mut wasm_instance_t);
+
+unsafe impl Send for InstanceHandle {}
+unsafe impl Sync for InstanceHandle {}
+
+impl InstanceHandle {
+    fn new(
+        store: *mut wasm_store_t,
+        module: *mut wasm_shared_module_t,
+        mut externs: Vec<VMExtern>,
+    ) -> Result<Self, InstantiationError> {
+        let mut trap: *mut wasm_trap_t = std::ptr::null_mut() as _;
+
+        let externs: Vec<_> = externs.into_iter().map(|v| v.into_v8()).collect();
+
+        let instance = unsafe {
+            let mut imports = unsafe {
+                let mut vec = Default::default();
+                wasm_extern_vec_new(&mut vec, externs.len(), externs.as_ptr());
+                vec
+            };
+
+            std::mem::forget(externs);
+
+            wasm_instance_new(
+                store,
+                wasm_module_obtain(store, module),
+                &mut imports,
+                &mut trap,
+            )
+        };
+
+        if instance.is_null() {
+            let trap = Trap::from(trap);
+            return Err(InstantiationError::Start(trap.into()));
+        }
+
+        Ok(InstanceHandle(instance))
+    }
+
+    fn get_exports(&self, mut store: &mut impl AsStoreMut, module: &Module) -> Exports {
+        check_isolate(store);
+        let mut exports = unsafe {
+            let mut vec = Default::default();
+            wasm_instance_exports(self.0, &mut vec);
+            vec
+        };
+
+        let wasm_exports: &[*mut wasm_extern_t] =
+            unsafe { std::slice::from_raw_parts(exports.data, exports.size) };
+
+        let exports_ty = module.exports().collect::<Vec<_>>();
+        let exports = exports_ty
+            .iter()
+            .zip(wasm_exports.into_iter())
+            .map(|(export_type, wasm_export)| {
+                let name = export_type.name();
+                let mut store = store.as_store_mut();
+                let extern_type = export_type.ty();
+                // Annotation is here to prevent spurious IDE warnings.
+
+                let extern_ = Extern::from_vm_extern(&mut store, VMExtern::V8(*wasm_export));
+                (name.to_string(), extern_)
+            })
+            .collect::<Exports>();
+        exports
+    }
+}
+impl Drop for InstanceHandle {
+    fn drop(&mut self) {
+        unsafe { wasm_instance_delete(self.0) }
+    }
+}
+
+#[derive(Clone, PartialEq, Eq)]
+/// A WebAssembly `instance` in the `v8` runtime.
+pub struct Instance {
+    pub(crate) handle: Arc<InstanceHandle>,
+}
+
+impl Instance {
+    pub(crate) fn new(
+        store: &mut impl AsStoreMut,
+        module: &Module,
+        imports: &Imports,
+    ) -> Result<(Self, Exports), InstantiationError> {
+        check_isolate(store);
+        let mut store = store.as_store_mut();
+
+        let externs = module
+            .imports()
+            .map(|import_ty| {
+                imports
+                    .get_export(import_ty.module(), import_ty.name())
+                    .expect(format!("Export {import_ty:?} not found").as_str())
+            })
+            .collect::<Vec<_>>();
+
+        return Self::new_by_index(&mut store, module, &externs);
+    }
+
+    pub(crate) fn new_by_index(
+        store: &mut impl AsStoreMut,
+        module: &Module,
+        externs: &[Extern],
+    ) -> Result<(Self, Exports), InstantiationError> {
+        check_isolate(store);
+        let store_ref = store.as_store_ref();
+        let externs: Vec<VMExtern> = externs
+            .iter()
+            .map(|extern_| extern_.to_vm_extern())
+            .collect::<Vec<_>>();
+        let instance = InstanceHandle::new(
+            store_ref.inner.store.as_v8().inner,
+            module.as_v8().handle.v8_shared_module_handle,
+            externs,
+        )?;
+        let exports = instance.get_exports(store, module);
+
+        Ok((
+            Self {
+                handle: Arc::new(instance),
+            },
+            exports,
+        ))
+    }
+}
+
+impl crate::BackendInstance {
+    /// Consume [`self`] into a [`crate::backend::v8::instance::Instance`].
+    pub(crate) fn into_v8(self) -> crate::backend::v8::instance::Instance {
+        match self {
+            Self::V8(s) => s,
+            _ => panic!("Not a `v8` instance"),
+        }
+    }
+}
diff --git a/lib/api/src/backend/v8/entities/memory/mod.rs b/lib/api/src/backend/v8/entities/memory/mod.rs
new file mode 100644
index 0000000000..c78874df5d
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/memory/mod.rs
@@ -0,0 +1,396 @@
+//! Data types, functions and traits for `v8` runtime's `Memory` implementation.
+use std::{marker::PhantomData, mem::MaybeUninit};
+
+use tracing::warn;
+pub use wasmer_types::MemoryError;
+use wasmer_types::{MemoryType, Pages, WASM_PAGE_SIZE};
+
+use crate::{
+    shared::SharedMemory,
+    v8::{bindings::*, vm::VMMemory},
+    vm::{VMExtern, VMExternMemory},
+    AsStoreMut, AsStoreRef, BackendMemory, MemoryAccessError,
+};
+
+pub(crate) mod view;
+pub use view::*;
+
+use super::check_isolate;
+
+#[derive(Debug, Clone)]
+/// A WebAssembly `memory` in the `v8` runtime.
+pub struct Memory {
+    pub(crate) handle: VMMemory,
+}
+
+unsafe impl Send for Memory {}
+unsafe impl Sync for Memory {}
+
+impl Memory {
+    pub fn new(store: &mut impl AsStoreMut, ty: MemoryType) -> Result<Self, MemoryError> {
+        check_isolate(store);
+
+        let mut store_mut = store.as_store_mut();
+        let v8_store = store_mut.inner.store.as_v8();
+
+        let max_requested = ty.maximum.unwrap_or(Pages::max_value());
+
+        let min = ty.minimum.0;
+        let max = max_requested.0;
+
+        if max < min {
+            return Err(MemoryError::InvalidMemory {
+                reason: format!("the maximum ({max} pages) is less than the minimum ({min} pages)",),
+            });
+        }
+
+        let max_allowed = Pages::max_value();
+        if max_requested > max_allowed {
+            return Err(MemoryError::MaximumMemoryTooLarge {
+                max_requested,
+                max_allowed,
+            });
+        }
+
+        let limits = Box::into_raw(Box::new(wasm_limits_t {
+            min,
+            max,
+            shared: ty.shared,
+        }));
+
+        let memorytype = unsafe { wasm_memorytype_new(limits) };
+        let c_memory = unsafe { wasm_memory_new(v8_store.inner, memorytype) };
+
+        Ok(Self { handle: c_memory })
+    }
+
+    pub fn new_from_existing(new_store: &mut impl AsStoreMut, memory: VMMemory) -> Self {
+        check_isolate(new_store);
+        let store_mut = new_store.as_store_mut();
+        Self { handle: memory }
+    }
+
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::V8(unsafe { wasm_memory_as_extern(self.handle) })
+    }
+
+    pub fn ty(&self, store: &impl AsStoreRef) -> MemoryType {
+        check_isolate(store);
+        let store = store.as_store_ref();
+
+        let memory_type: *mut wasm_memorytype_t = unsafe { wasm_memory_type(self.handle) };
+        let limits: *const wasm_limits_t = unsafe { wasm_memorytype_limits(memory_type) };
+
+        MemoryType {
+            shared: unsafe { (*limits).shared },
+            minimum: unsafe { wasmer_types::Pages((*limits).min) },
+            maximum: unsafe { Some(wasmer_types::Pages((*limits).max)) },
+        }
+    }
+
+    pub fn size(&self, store: &impl AsStoreRef) -> Pages {
+        check_isolate(store);
+        let size = unsafe { wasm_memory_size(self.handle) };
+        Pages(size)
+    }
+
+    pub fn view<'a>(&self, store: &'a impl AsStoreRef) -> MemoryView<'a> {
+        check_isolate(store);
+        let store_ref = store.as_store_ref();
+        MemoryView::new(self, store)
+    }
+
+    // Note: the return value is the memory size (in [`Pages`]) *before* growing it.
+    pub fn grow<IntoPages>(
+        &self,
+        store: &mut impl AsStoreMut,
+        delta: IntoPages,
+    ) -> Result<Pages, MemoryError>
+    where
+        IntoPages: Into<Pages>,
+    {
+        check_isolate(store);
+        let store_mut = store.as_store_mut();
+        unsafe {
+            let delta: Pages = delta.into();
+            let current = Pages(wasm_memory_size(self.handle));
+
+            if !wasm_memory_grow(self.handle, delta.0) {
+                Err(MemoryError::CouldNotGrow {
+                    current,
+                    attempted_delta: delta,
+                })
+            } else {
+                Ok(current)
+            }
+        }
+    }
+
+    pub fn grow_at_least(
+        &self,
+        store: &mut impl AsStoreMut,
+        min_size: u64,
+    ) -> Result<(), MemoryError> {
+        check_isolate(store);
+        let store_mut = store.as_store_mut();
+
+        unsafe {
+            let current = wasm_memory_size(self.handle);
+            let delta = (min_size as u32) - current;
+            if delta > 0 {
+                self.grow(store, delta)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    pub fn reset(&self, store: &mut impl AsStoreMut) -> Result<(), MemoryError> {
+        check_isolate(store);
+        Ok(())
+    }
+
+    pub fn copy_to_store(
+        &self,
+        store: &impl AsStoreRef,
+        new_store: &mut impl AsStoreMut,
+    ) -> Result<Self, MemoryError> {
+        unimplemented!();
+        // let view = self.view(store);
+        // let ty = self.ty(store);
+        // let amount = view.data_size() as usize;
+
+        // let new_memory = Self::new(new_store, ty)?;
+        // let mut new_view = new_memory.view(&new_store);
+        // let new_view_size = new_view.data_size() as usize;
+        // if amount > new_view_size {
+        //     let delta = amount - new_view_size;
+        //     let pages = ((delta - 1) / wasmer_types::WASM_PAGE_SIZE) + 1;
+        //     new_memory.grow(new_store, Pages(pages as u32))?;
+        //     new_view = new_memory.view(&new_store);
+        // }
+
+        // // Copy the bytes
+        // view.copy_to_memory(amount as u64, &new_view)
+        //     .map_err(|err| MemoryError::Generic(err.to_string()))?;
+        // // // Return the new memory
+        // Ok(new_memory)
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, internal: VMExternMemory) -> Self {
+        check_isolate(store);
+        Self {
+            handle: internal.into_v8(),
+        }
+    }
+
+    /// Cloning memory will create another reference to the same memory that
+    /// can be put into a new store
+    pub fn try_clone(&self, store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
+        check_isolate(store);
+        Ok(self.handle.clone())
+    }
+
+    /// Copying the memory will actually copy all the bytes in the memory to
+    /// a identical byte copy of the original that can be put into a new store
+    pub fn try_copy(&self, store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
+        check_isolate(store);
+
+        let res = unsafe { wasm_memory_copy(self.handle) };
+        if res.is_null() {
+            Err(MemoryError::Generic("memory copy failed".to_owned()))
+        } else {
+            Ok(res)
+        }
+    }
+
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        check_isolate(store);
+        true
+    }
+
+    #[allow(unused)]
+    pub fn duplicate(&mut self, store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
+        unimplemented!();
+        // self.handle.duplicate(store)
+    }
+
+    pub fn as_shared(&self, _store: &impl AsStoreRef) -> Option<SharedMemory> {
+        // Not supported.
+        None
+    }
+}
+
+impl std::cmp::PartialEq for Memory {
+    fn eq(&self, other: &Self) -> bool {
+        self.handle == other.handle
+    }
+}
+
+impl std::cmp::Eq for Memory {}
+
+/// Underlying buffer for a memory.
+#[derive(Debug, Copy, Clone)]
+pub(crate) struct MemoryBuffer<'a> {
+    pub(crate) base: *mut u8,
+    pub(crate) len: usize,
+    pub(crate) marker: PhantomData<&'a MemoryView<'a>>,
+}
+
+impl<'a> MemoryBuffer<'a> {
+    pub(crate) fn read(&self, offset: u64, buf: &mut [u8]) -> Result<(), MemoryAccessError> {
+        let end = offset
+            .checked_add(buf.len() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+
+        let len: u64 = self.len.try_into().unwrap();
+        if end > len {
+            warn!(
+                "attempted to read {} bytes, but the end offset is beyond the bounds of the memory view ({} > {}, diff. {} bytes)",
+                buf.len(),
+                end,
+                len,
+                end - len,
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        unsafe {
+            volatile_memcpy_read(self.base.add(offset as usize), buf.as_mut_ptr(), buf.len());
+        }
+        Ok(())
+    }
+
+    pub(crate) fn read_uninit<'b>(
+        &self,
+        offset: u64,
+        buf: &'b mut [MaybeUninit<u8>],
+    ) -> Result<&'b mut [u8], MemoryAccessError> {
+        let end = offset
+            .checked_add(buf.len() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+
+        let len: u64 = self.len.try_into().unwrap();
+        if end > len {
+            warn!(
+                "attempted to read {} bytes, but the end offset is beyond the bounds of the memory view ({} > {}, diff. {} bytes)",
+                buf.len(),
+                end,
+                len,
+                end - len,
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        let buf_ptr = buf.as_mut_ptr() as *mut u8;
+        unsafe {
+            volatile_memcpy_read(self.base.add(offset as usize), buf_ptr, buf.len());
+        }
+
+        Ok(unsafe { std::slice::from_raw_parts_mut(buf_ptr, buf.len()) })
+    }
+
+    pub(crate) fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
+        let end = offset
+            .checked_add(data.len() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        if end > self.len.try_into().unwrap() {
+            warn!(
+                "attempted to write ({} bytes) beyond the bounds of the memory view ({} > {})",
+                data.len(),
+                end,
+                self.len
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        unsafe {
+            volatile_memcpy_write(data.as_ptr(), self.base.add(offset as usize), data.len());
+        }
+        Ok(())
+    }
+}
+
+// We can't use a normal memcpy here because it has undefined behavior if the
+// memory is being concurrently modified. So we need to write our own memcpy
+// implementation which uses volatile operations.
+//
+// The implementation of these functions can optimize very well when inlined
+// with a fixed length: they should compile down to a single load/store
+// instruction for small (8/16/32/64-bit) copies.
+#[inline]
+unsafe fn volatile_memcpy_read(mut src: *const u8, mut dst: *mut u8, mut len: usize) {
+    #[inline]
+    unsafe fn copy_one<T>(src: &mut *const u8, dst: &mut *mut u8, len: &mut usize) {
+        #[repr(packed)]
+        struct Unaligned<T>(T);
+        let val = (*src as *const Unaligned<T>).read_volatile();
+        (*dst as *mut Unaligned<T>).write(val);
+        *src = src.add(std::mem::size_of::<T>());
+        *dst = dst.add(std::mem::size_of::<T>());
+        *len -= std::mem::size_of::<T>();
+    }
+
+    while len >= 8 {
+        copy_one::<u64>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 4 {
+        copy_one::<u32>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 2 {
+        copy_one::<u16>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 1 {
+        copy_one::<u8>(&mut src, &mut dst, &mut len);
+    }
+}
+
+#[inline]
+unsafe fn volatile_memcpy_write(mut src: *const u8, mut dst: *mut u8, mut len: usize) {
+    #[inline]
+    unsafe fn copy_one<T>(src: &mut *const u8, dst: &mut *mut u8, len: &mut usize) {
+        #[repr(packed)]
+        struct Unaligned<T>(T);
+        let val = (*src as *const Unaligned<T>).read();
+        (*dst as *mut Unaligned<T>).write_volatile(val);
+        *src = src.add(std::mem::size_of::<T>());
+        *dst = dst.add(std::mem::size_of::<T>());
+        *len -= std::mem::size_of::<T>();
+    }
+
+    while len >= 8 {
+        copy_one::<u64>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 4 {
+        copy_one::<u32>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 2 {
+        copy_one::<u16>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 1 {
+        copy_one::<u8>(&mut src, &mut dst, &mut len);
+    }
+}
+
+impl crate::Memory {
+    /// Consume [`self`] into a [`crate::backend::v8::memory::Memory`].
+    pub fn into_v8(self) -> crate::backend::v8::memory::Memory {
+        match self.0 {
+            BackendMemory::V8(s) => s,
+            _ => panic!("Not a `v8` memory!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference to [`crate::backend::v8::memory::Memory`].
+    pub fn as_v8(&self) -> &crate::backend::v8::memory::Memory {
+        match self.0 {
+            BackendMemory::V8(ref s) => s,
+            _ => panic!("Not a `v8` memory!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference to [`crate::backend::v8::memory::Memory`].
+    pub fn as_v8_mut(&mut self) -> &mut crate::backend::v8::memory::Memory {
+        match self.0 {
+            BackendMemory::V8(ref mut s) => s,
+            _ => panic!("Not a `v8` memory!"),
+        }
+    }
+}
diff --git a/lib/api/src/externals/memory_view.rs b/lib/api/src/backend/v8/entities/memory/view.rs
similarity index 77%
rename from lib/api/src/externals/memory_view.rs
rename to lib/api/src/backend/v8/entities/memory/view.rs
index 1fbda5c9af..a4be3e93ed 100644
--- a/lib/api/src/externals/memory_view.rs
+++ b/lib/api/src/backend/v8/entities/memory/view.rs
@@ -1,43 +1,56 @@
-use super::memory::{Memory, MemoryBuffer};
-use crate::store::AsStoreRef;
-use crate::MemoryAccessError;
-use std::mem::MaybeUninit;
-use std::ops::Range;
+use std::{marker::PhantomData, mem::MaybeUninit, ops::Range};
+
 use wasmer_types::Pages;
 
-#[cfg(feature = "js")]
-use crate::js::externals::memory_view as memory_view_impl;
-#[cfg(feature = "jsc")]
-use crate::jsc::externals::memory_view as memory_view_impl;
-#[cfg(feature = "sys")]
-use crate::sys::externals::memory_view as memory_view_impl;
+use super::{Memory, MemoryBuffer};
+use crate::{
+    backend::v8::bindings::{wasm_memory_data, wasm_memory_data_size, wasm_memory_size},
+    v8::bindings::wasm_memory_t,
+    AsStoreRef, MemoryAccessError,
+};
 
 /// A WebAssembly `memory` view.
 ///
 /// A memory view is used to read and write to the linear memory.
 ///
 /// After a memory is grown a view must not be used anymore. Views are
-/// created using the Memory.view() method.
+/// created using the Memory.grow() method.
 #[derive(Debug)]
-pub struct MemoryView<'a>(pub(crate) memory_view_impl::MemoryView<'a>);
+pub struct MemoryView<'a> {
+    pub(crate) buffer: MemoryBuffer<'a>,
+    pub(crate) size: u32,
+}
 
 impl<'a> MemoryView<'a> {
     pub(crate) fn new(memory: &Memory, store: &'a (impl AsStoreRef + ?Sized)) -> Self {
-        MemoryView(memory_view_impl::MemoryView::new(&memory.0, store))
+        let c_memory: *mut wasm_memory_t = memory.handle;
+
+        let len = unsafe { wasm_memory_data_size(c_memory as _).try_into().unwrap() };
+        let base: *mut u8 = unsafe { wasm_memory_data(c_memory as _) as _ };
+        let size = unsafe { wasm_memory_size(c_memory as _) };
+
+        Self {
+            buffer: MemoryBuffer {
+                base,
+                len,
+                marker: PhantomData,
+            },
+            size,
+        }
     }
 
     /// Returns the pointer to the raw bytes of the `Memory`.
     //
-    // This used by wasmer-emscripten and wasmer-c-api, but should be treated
+    // This used by wasmer-c-api, but should be treated
     // as deprecated and not used in future code.
     #[doc(hidden)]
     pub fn data_ptr(&self) -> *mut u8 {
-        self.0.data_ptr()
+        self.buffer.base
     }
 
     /// Returns the size (in bytes) of the `Memory`.
     pub fn data_size(&self) -> u64 {
-        self.0.data_size()
+        self.buffer.len.try_into().unwrap()
     }
 
     /// Retrieve a slice of the memory contents.
@@ -49,7 +62,7 @@ impl<'a> MemoryView<'a> {
     /// function that writes to the memory or by resizing the memory.
     #[doc(hidden)]
     pub unsafe fn data_unchecked(&self) -> &[u8] {
-        self.0.data_unchecked()
+        self.data_unchecked_mut()
     }
 
     /// Retrieve a mutable slice of the memory contents.
@@ -64,7 +77,7 @@ impl<'a> MemoryView<'a> {
     #[allow(clippy::mut_from_ref)]
     #[doc(hidden)]
     pub unsafe fn data_unchecked_mut(&self) -> &mut [u8] {
-        self.0.data_unchecked_mut()
+        std::slice::from_raw_parts_mut(self.buffer.base, self.buffer.len)
     }
 
     /// Returns the size (in [`Pages`]) of the `Memory`.
@@ -80,12 +93,12 @@ impl<'a> MemoryView<'a> {
     /// assert_eq!(m.view(&mut store).size(), Pages(1));
     /// ```
     pub fn size(&self) -> Pages {
-        self.0.size()
+        Pages(self.size)
     }
 
     #[inline]
     pub(crate) fn buffer(&'a self) -> MemoryBuffer<'a> {
-        MemoryBuffer(self.0.buffer())
+        self.buffer
     }
 
     /// Safely reads bytes from the memory at the given offset.
@@ -96,7 +109,7 @@ impl<'a> MemoryView<'a> {
     /// This method is guaranteed to be safe (from the host side) in the face of
     /// concurrent writes.
     pub fn read(&self, offset: u64, buf: &mut [u8]) -> Result<(), MemoryAccessError> {
-        self.0.read(offset, buf)
+        self.buffer.read(offset, buf)
     }
 
     /// Safely reads a single byte from memory at the given offset
@@ -104,7 +117,9 @@ impl<'a> MemoryView<'a> {
     /// This method is guaranteed to be safe (from the host side) in the face of
     /// concurrent writes.
     pub fn read_u8(&self, offset: u64) -> Result<u8, MemoryAccessError> {
-        self.0.read_u8(offset)
+        let mut buf = [0u8; 1];
+        self.read(offset, &mut buf)?;
+        Ok(buf[0])
     }
 
     /// Safely reads bytes from the memory at the given offset.
@@ -122,7 +137,7 @@ impl<'a> MemoryView<'a> {
         offset: u64,
         buf: &'b mut [MaybeUninit<u8>],
     ) -> Result<&'b mut [u8], MemoryAccessError> {
-        self.0.read_uninit(offset, buf)
+        self.buffer.read_uninit(offset, buf)
     }
 
     /// Safely writes bytes to the memory at the given offset.
@@ -133,22 +148,26 @@ impl<'a> MemoryView<'a> {
     /// This method is guaranteed to be safe (from the host side) in the face of
     /// concurrent reads/writes.
     pub fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
-        self.0.write(offset, data)
+        self.buffer.write(offset, data)
     }
 
-    /// Safely writes a single byte from memory at the given offset
+    /// Safely reads a single byte from memory at the given offset
     ///
     /// This method is guaranteed to be safe (from the host side) in the face of
     /// concurrent writes.
     pub fn write_u8(&self, offset: u64, val: u8) -> Result<(), MemoryAccessError> {
-        self.0.write_u8(offset, val)
+        let buf = [val];
+        self.write(offset, &buf)?;
+        Ok(())
     }
 
+    #[allow(unused)]
     /// Copies the memory and returns it as a vector of bytes
     pub fn copy_to_vec(&self) -> Result<Vec<u8>, MemoryAccessError> {
         self.copy_range_to_vec(0..self.data_size())
     }
 
+    #[allow(unused)]
     /// Copies a range of the memory and returns it as a vector of bytes
     pub fn copy_range_to_vec(&self, range: Range<u64>) -> Result<Vec<u8>, MemoryAccessError> {
         let mut new_memory = Vec::new();
@@ -165,6 +184,7 @@ impl<'a> MemoryView<'a> {
         Ok(new_memory)
     }
 
+    #[allow(unused)]
     /// Copies the memory to another new memory object
     pub fn copy_to_memory(&self, amount: u64, new_memory: &Self) -> Result<(), MemoryAccessError> {
         let mut offset = 0;
diff --git a/lib/api/src/backend/v8/entities/mod.rs b/lib/api/src/backend/v8/entities/mod.rs
new file mode 100644
index 0000000000..9cb3801d8c
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/mod.rs
@@ -0,0 +1,20 @@
+pub mod engine;
+pub(crate) mod exception;
+pub(crate) mod external;
+pub(crate) mod function;
+pub(crate) mod global;
+pub(crate) mod instance;
+pub(crate) mod memory;
+pub(crate) mod module;
+pub(crate) mod store;
+pub(crate) mod table;
+pub(crate) mod tag;
+
+pub(self) fn check_isolate(store: &impl crate::AsStoreRef) {
+    let store = store.as_store_ref();
+    let v8_store = store.inner.store.as_v8();
+
+    if v8_store.thread_id != std::thread::current().id() {
+        panic!("Fatal error (v8): current thread is different from the thread the store was created in!");
+    }
+}
diff --git a/lib/api/src/backend/v8/entities/module.rs b/lib/api/src/backend/v8/entities/module.rs
new file mode 100644
index 0000000000..6a965dad43
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/module.rs
@@ -0,0 +1,400 @@
+//! Data types, functions and traits for `v8` runtime's `Module` implementation.
+use std::{path::Path, sync::Arc};
+
+use crate::{
+    backend::v8::bindings::*, v8::utils::convert::IntoWasmerExternType, AsEngineRef, BackendModule,
+    IntoBytes, Store,
+};
+
+use bytes::Bytes;
+use wasmer_types::{
+    CompileError, DeserializeError, ExportType, ExportsIterator, ExternType, FunctionType,
+    GlobalType, ImportType, ImportsIterator, MemoryType, ModuleInfo, Mutability, Pages,
+    SerializeError, TableType, Type,
+};
+
+#[derive(Debug)]
+pub(crate) struct ModuleHandle {
+    pub(crate) v8_shared_module_handle: *mut wasm_shared_module_t,
+    pub(crate) orig_store: Store,
+}
+
+impl PartialEq for ModuleHandle {
+    fn eq(&self, other: &Self) -> bool {
+        unsafe {
+            wasm_module_same(
+                wasm_module_obtain(self.orig_store.as_v8().inner, self.v8_shared_module_handle),
+                wasm_module_obtain(
+                    other.orig_store.as_v8().inner,
+                    other.v8_shared_module_handle,
+                ),
+            )
+        }
+    }
+}
+
+impl Eq for ModuleHandle {}
+
+impl ModuleHandle {
+    fn new(engine: &impl AsEngineRef, binary: &[u8]) -> Result<Self, CompileError> {
+        let bytes = wasm_byte_vec_t {
+            size: binary.len(),
+            data: binary.as_ptr() as _,
+        };
+
+        let engine = engine.as_engine_ref().engine().clone();
+        let store = Store::new(engine.clone());
+        let engine = engine.as_v8().inner.engine;
+
+        let inner = unsafe { wasm_module_new(store.as_v8().inner, &bytes as *const _) };
+
+        if inner.is_null() {
+            return Err(CompileError::Validate(format!(
+                "Failed to create V8 module: null module reference returned from V8"
+            )));
+        }
+
+        let inner = unsafe { wasm_module_share(inner) };
+
+        if inner.is_null() {
+            return Err(CompileError::Validate(format!(
+                "Failed to create V8 module: null module reference returned from V8"
+            )));
+        }
+
+        Ok(ModuleHandle {
+            v8_shared_module_handle: inner,
+            orig_store: store,
+        })
+    }
+
+    fn deserialize(engine: &impl AsEngineRef, binary: &[u8]) -> Result<Self, CompileError> {
+        let bytes = wasm_byte_vec_t {
+            size: binary.len(),
+            data: binary.as_ptr() as _,
+        };
+
+        let engine = engine.as_engine_ref().engine().clone();
+        let store = Store::new(engine.clone());
+        let inner = unsafe { wasm_module_deserialize(store.as_v8().inner, &bytes as *const _) };
+        if inner.is_null() {
+            return Err(CompileError::Validate(format!(
+                "Failed to deserialize V8 module: null module reference returned from V8"
+            )));
+        }
+
+        let inner = unsafe { wasm_module_share(inner) };
+
+        if inner.is_null() {
+            return Err(CompileError::Validate(format!(
+                "Failed to create V8 module: null module reference returned from V8"
+            )));
+        }
+
+        Ok(ModuleHandle {
+            v8_shared_module_handle: inner,
+            orig_store: store,
+        })
+    }
+
+    #[tracing::instrument(skip(self))]
+    pub fn serialize(&self) -> Result<Vec<u8>, SerializeError> {
+        let handle = unsafe {
+            wasm_module_obtain(
+                self.orig_store.as_v8().inner,
+                self.v8_shared_module_handle as *const _,
+            )
+        };
+
+        let mut bytes = wasm_byte_vec_t {
+            size: 0,
+            data: std::ptr::null_mut(),
+        };
+
+        let bytes = unsafe {
+            wasm_module_serialize(handle, &mut bytes as *mut _);
+            if bytes.data.is_null() || bytes.size == 0 {
+                return Err(SerializeError::Generic(String::from(
+                    "V8 returned an empty vector as serialized module",
+                )));
+            }
+            std::slice::from_raw_parts(bytes.data as *mut u8, bytes.size)
+        };
+
+        Ok(bytes.to_vec())
+    }
+}
+
+impl Drop for ModuleHandle {
+    fn drop(&mut self) {
+        unsafe { wasm_shared_module_delete(self.v8_shared_module_handle) }
+    }
+}
+
+#[derive(Clone, PartialEq, Eq)]
+/// A WebAssembly `module` in the `v8` runtime.
+pub struct Module {
+    pub(crate) handle: Arc<ModuleHandle>,
+    name: Option<String>,
+}
+
+unsafe impl Send for Module {}
+unsafe impl Sync for Module {}
+
+impl Module {
+    #[tracing::instrument(skip(engine, binary))]
+    pub(crate) fn from_binary(
+        engine: &impl AsEngineRef,
+        binary: &[u8],
+    ) -> Result<Self, CompileError> {
+        tracing::info!("Creating module from binary");
+        unsafe { Self::from_binary_unchecked(engine, binary) }
+    }
+
+    #[tracing::instrument(skip(engine, binary))]
+    pub(crate) unsafe fn from_binary_unchecked(
+        engine: &impl AsEngineRef,
+        binary: &[u8],
+    ) -> Result<Self, CompileError> {
+        tracing::info!("Creating module from binary unchecked");
+        let mut binary = binary.to_vec();
+        let binary = binary.into_bytes();
+        let module = ModuleHandle::new(engine, &binary)?;
+        let info = crate::utils::polyfill::translate_module(&binary[..])
+            .unwrap()
+            .info;
+
+        Ok(Self {
+            handle: Arc::new(module),
+            name: info.name,
+        })
+    }
+
+    pub fn validate(engine: &impl AsEngineRef, binary: &[u8]) -> Result<(), CompileError> {
+        let engine = engine.as_engine_ref().engine().clone();
+        let store = super::store::Store::new(engine);
+        let bytes = wasm_byte_vec_t {
+            size: binary.len(),
+            data: binary.as_ptr() as _,
+        };
+        let store = store.inner;
+        unsafe {
+            if !wasm_module_validate(store, &bytes as *const _) {
+                return Err(CompileError::Validate(String::from(
+                    "V8 could not validate the given module",
+                )));
+            }
+        }
+
+        Ok(())
+    }
+
+    pub fn name(&self) -> Option<&str> {
+        self.name.as_ref().map(|s| s.as_ref())
+    }
+
+    #[tracing::instrument(skip(self))]
+    pub fn serialize(&self) -> Result<Bytes, SerializeError> {
+        let mut raw_bytes = self
+            .name
+            .clone()
+            .unwrap_or_default()
+            .bytes()
+            .collect::<Vec<u8>>();
+        let raw_bytes_off = raw_bytes.len();
+        let mut v8_module_bytes = self.handle.serialize()?;
+
+        let mut data = raw_bytes_off.to_ne_bytes().to_vec();
+
+        data.append(&mut raw_bytes);
+        data.append(&mut v8_module_bytes);
+
+        Ok(data.into())
+    }
+
+    pub unsafe fn deserialize_unchecked(
+        engine: &impl AsEngineRef,
+        bytes: impl IntoBytes,
+    ) -> Result<Self, DeserializeError> {
+        tracing::info!("Creating module from deserialize_unchecked");
+        let binary = bytes.into_bytes();
+        let off = &binary[0..8];
+        let off = usize::from_ne_bytes(off.try_into().unwrap());
+        let name_bytes = &binary[8..(8 + off)];
+        let name = String::from_utf8_lossy(name_bytes).to_string();
+        let mod_bytes = &binary[(8 + off)..];
+        let module = ModuleHandle::deserialize(engine, mod_bytes)?;
+
+        Ok(Self {
+            handle: Arc::new(module),
+            name: Some(name),
+        })
+    }
+
+    pub unsafe fn deserialize(
+        engine: &impl AsEngineRef,
+        bytes: impl IntoBytes,
+    ) -> Result<Self, DeserializeError> {
+        Self::deserialize_unchecked(engine, bytes)
+    }
+
+    pub unsafe fn deserialize_from_file_unchecked(
+        engine: &impl AsEngineRef,
+        path: impl AsRef<Path>,
+    ) -> Result<Self, DeserializeError> {
+        let bytes = std::fs::read(path.as_ref())?;
+        Self::deserialize_unchecked(engine, bytes)
+    }
+
+    pub unsafe fn deserialize_from_file(
+        engine: &impl AsEngineRef,
+        path: impl AsRef<Path>,
+    ) -> Result<Self, DeserializeError> {
+        let bytes = std::fs::read(path.as_ref())?;
+        Self::deserialize(engine, bytes)
+    }
+
+    pub fn set_name(&mut self, name: &str) -> bool {
+        self.name = Some(name.to_string());
+        true
+    }
+
+    pub fn imports<'a>(&'a self) -> ImportsIterator<Box<dyn Iterator<Item = ImportType> + 'a>> {
+        let mut imports = wasm_importtype_vec_t {
+            size: 0,
+            data: std::ptr::null_mut(),
+        };
+
+        let store = self.handle.orig_store.as_v8().inner;
+        let shared_handle = self.handle.v8_shared_module_handle;
+        let imports = unsafe {
+            let module = wasm_module_obtain(store, shared_handle);
+            if module.is_null() {
+                panic!("Could not get imports: underlying module is null!");
+            }
+
+            wasm_module_imports(module as *const _, &mut imports as *mut _);
+
+            let imports =
+                if imports.data.is_null() || !imports.data.is_aligned() || imports.size == 0 {
+                    vec![]
+                } else {
+                    std::slice::from_raw_parts(imports.data, imports.size).to_vec()
+                };
+            let mut wasmer_imports = vec![];
+
+            for i in imports.into_iter() {
+                if i.is_null() {
+                    panic!("null import returned from V8!");
+                }
+
+                let name = wasm_importtype_name(i as *const _);
+                let name = std::slice::from_raw_parts((*name).data as *const u8, (*name).size);
+                let name_str = String::from_utf8_lossy(name).to_string();
+                let module = wasm_importtype_module(i as *const _);
+                let module_str = if module.is_null()
+                    || (*module).data.is_null()
+                    || !(*module).data.is_aligned()
+                    || (*module).size == 0
+                {
+                    String::new()
+                } else {
+                    let str =
+                        std::slice::from_raw_parts((*module).data as *const u8, (*module).size);
+                    String::from_utf8_lossy(str).to_string()
+                };
+
+                let ty = IntoWasmerExternType::into_wextt(wasm_importtype_type(i as *const _));
+                if ty.is_err() {
+                    panic!("{}", ty.unwrap_err());
+                }
+
+                let ty = ty.unwrap();
+                wasmer_imports.push(ImportType::new(&module_str, &name_str, ty))
+            }
+
+            wasmer_imports
+        };
+        let len = imports.len();
+        wasmer_types::ImportsIterator::new(Box::new(imports.into_iter()), len)
+    }
+
+    pub fn exports<'a>(&'a self) -> ExportsIterator<Box<dyn Iterator<Item = ExportType> + 'a>> {
+        let mut exports = wasm_exporttype_vec_t {
+            size: 0,
+            data: std::ptr::null_mut(),
+        };
+
+        let store = self.handle.orig_store.as_v8().inner;
+        let shared_handle = self.handle.v8_shared_module_handle;
+        let exports = unsafe {
+            let module = wasm_module_obtain(store, shared_handle);
+            if module.is_null() {
+                panic!("Could not get imports: underlying module is null!");
+            }
+
+            wasm_module_exports(module as *const _, &mut exports as *mut _);
+
+            let exports = std::slice::from_raw_parts(exports.data, exports.size).to_vec();
+            let mut wasmer_exports = vec![];
+
+            for e in exports.into_iter() {
+                if e.is_null() {
+                    panic!("null import returned from V8!");
+                }
+
+                let name = wasm_exporttype_name(e as *const _);
+                let name = std::slice::from_raw_parts((*name).data as *const u8, (*name).size);
+                let name_str = String::from_utf8_lossy(name).to_string();
+                let ty = IntoWasmerExternType::into_wextt(wasm_exporttype_type(e as *const _));
+                if ty.is_err() {
+                    panic!("{}", ty.unwrap_err());
+                }
+
+                let ty = ty.unwrap();
+                wasmer_exports.push(ExportType::new(&name_str, ty))
+            }
+
+            wasmer_exports
+        };
+        let len = exports.len();
+        wasmer_types::ExportsIterator::new(Box::new(exports.into_iter()), len)
+    }
+
+    pub fn custom_sections<'a>(
+        &'a self,
+        name: &'a str,
+    ) -> Box<dyn Iterator<Item = Box<[u8]>> + 'a> {
+        Box::new(vec![].into_iter())
+    }
+
+    pub(crate) fn info(&self) -> &ModuleInfo {
+        panic!("no info for V8 modules")
+    }
+}
+
+impl crate::Module {
+    /// Consume [`self`] into a reference [`crate::backend::v8::module::Module`].
+    pub fn into_v8(self) -> crate::backend::v8::module::Module {
+        match self.0 {
+            BackendModule::V8(s) => s,
+            _ => panic!("Not a `v8` module!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::v8::module::Module`].
+    pub fn as_v8(&self) -> &crate::backend::v8::module::Module {
+        match self.0 {
+            BackendModule::V8(ref s) => s,
+            _ => panic!("Not a `v8` module!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::v8::module::Module`].
+    pub fn as_v8_mut(&mut self) -> &mut crate::backend::v8::module::Module {
+        match self.0 {
+            BackendModule::V8(ref mut s) => s,
+            _ => panic!("Not a `v8` module!"),
+        }
+    }
+}
diff --git a/lib/api/src/backend/v8/entities/store/mod.rs b/lib/api/src/backend/v8/entities/store/mod.rs
new file mode 100644
index 0000000000..2bf988dde7
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/store/mod.rs
@@ -0,0 +1,111 @@
+//! Data types, functions and traits for `v8` runtime's `Store` implementation.
+use std::thread::ThreadId;
+
+use crate::{
+    backend::v8::bindings::{wasm_store_delete, wasm_store_new, wasm_store_t},
+    engine::{AsEngineRef, Engine, EngineRef},
+    AsStoreRef, BackendStore, StoreRef,
+};
+
+mod obj;
+pub use obj::*;
+
+/// A WebAssembly `store` in the `v8` runtime.
+pub struct Store {
+    pub(crate) engine: Engine,
+    pub(crate) inner: *mut wasm_store_t,
+    pub(crate) thread_id: ThreadId,
+}
+
+impl std::fmt::Debug for Store {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Store")
+            .field("engine", &self.engine)
+            .finish()
+    }
+}
+
+impl Store {
+    pub(crate) fn new(engine: crate::engine::Engine) -> Self {
+        let inner: *mut wasm_store_t = unsafe { wasm_store_new(engine.as_v8().inner.engine) };
+        let thread_id = std::thread::current().id();
+        Store {
+            inner,
+            engine,
+            thread_id,
+        }
+    }
+
+    pub(crate) fn engine(&self) -> &Engine {
+        &self.engine
+    }
+
+    pub(crate) fn engine_mut(&mut self) -> &mut Engine {
+        &mut self.engine
+    }
+}
+
+impl Drop for Store {
+    fn drop(&mut self) {
+        unsafe { wasm_store_delete(self.inner) }
+    }
+}
+
+impl AsEngineRef for Store {
+    fn as_engine_ref(&self) -> EngineRef<'_> {
+        EngineRef::new(&self.engine)
+    }
+}
+
+impl crate::BackendStore {
+    /// Consume [`self`] into [`crate::backend::v8::store::Store`].
+    pub fn into_v8(self) -> crate::backend::v8::store::Store {
+        match self {
+            Self::V8(s) => s,
+            _ => panic!("Not a `v8` store!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::v8::store::Store`].
+    pub fn as_v8(&self) -> &crate::backend::v8::store::Store {
+        match self {
+            Self::V8(s) => s,
+            _ => panic!("Not a `v8` store!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::v8::store::Store`].
+    pub fn as_v8_mut(&mut self) -> &mut crate::backend::v8::store::Store {
+        match self {
+            Self::V8(s) => s,
+            _ => panic!("Not a `v8` store!"),
+        }
+    }
+
+    /// Return true if [`self`] is a store from the `v8` runtime.
+    pub fn is_v8(&self) -> bool {
+        matches!(self, Self::V8(_))
+    }
+}
+
+impl crate::Store {
+    /// Consume [`self`] into [`crate::backend::v8::store::Store`].
+    pub(crate) fn into_v8(self) -> crate::backend::v8::store::Store {
+        self.inner.store.into_v8()
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::v8::store::Store`].
+    pub(crate) fn as_v8(&self) -> &crate::backend::v8::store::Store {
+        self.inner.store.as_v8()
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::v8::store::Store`].
+    pub(crate) fn as_v8_mut(&mut self) -> &mut crate::backend::v8::store::Store {
+        self.inner.store.as_v8_mut()
+    }
+
+    /// Return true if [`self`] is a store from the `v8` runtime.
+    pub fn is_v8(&self) -> bool {
+        self.inner.store.is_v8()
+    }
+}
diff --git a/lib/api/src/backend/v8/entities/store/obj.rs b/lib/api/src/backend/v8/entities/store/obj.rs
new file mode 100644
index 0000000000..6f69a2d99f
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/store/obj.rs
@@ -0,0 +1,288 @@
+use std::{fmt, marker::PhantomData, num::NonZeroUsize};
+
+use crate::{
+    backend::v8::vm::{VMFunctionEnvironment, VMGlobal},
+    AsStoreMut,
+};
+
+pub use wasmer_types::StoreId;
+
+impl crate::StoreObjects {
+    /// Consume [`self`] into [`crate::backend::v8::store::StoreObjects`].
+    pub fn into_v8(self) -> crate::backend::v8::store::StoreObjects {
+        match self {
+            crate::StoreObjects::V8(s) => s,
+            _ => panic!("Not a `v8` store!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::v8::store::StoreObjects`].
+    pub fn as_v8(&self) -> &crate::backend::v8::store::StoreObjects {
+        match self {
+            crate::StoreObjects::V8(s) => s,
+            _ => panic!("Not a `v8` store!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::v8::store::StoreObjects`].
+    pub fn as_v8_mut(&mut self) -> &mut crate::backend::v8::store::StoreObjects {
+        match self {
+            crate::StoreObjects::V8(s) => s,
+            _ => panic!("Not a `v8` store!"),
+        }
+    }
+}
+
+/// Trait to represent an object managed by a context. This is implemented on
+/// the VM types managed by the context.
+pub trait StoreObject: Sized {
+    fn list(store: &StoreObjects) -> &Vec<Self>;
+    fn list_mut(store: &mut StoreObjects) -> &mut Vec<Self>;
+}
+
+macro_rules! impl_store_object {
+    ($($field:ident => $ty:ty,)*) => {
+        $(
+            impl StoreObject for $ty {
+                fn list(store: &StoreObjects) -> &Vec<Self> {
+                    &store.$field
+                }
+                fn list_mut(store: &mut StoreObjects) -> &mut Vec<Self> {
+                    &mut store.$field
+                }
+            }
+        )*
+    };
+}
+
+impl_store_object! {
+    // Note: we store the globals in order to be able to access them later via
+    // `StoreObjects::iter_globals`.
+    globals => VMGlobal,
+    // functions => VMFunction,
+    // tables => VMTable,
+    // memories => VMMemory,
+    // The function environments are the only things attached to a store,
+    // since the other JS objects (table, globals, memory and functions)
+    // live in the JS VM Store by default
+    function_environments => VMFunctionEnvironment,
+}
+
+/// Set of objects managed by a context.
+#[derive(Default, Debug)]
+pub struct StoreObjects {
+    id: StoreId,
+    globals: Vec<VMGlobal>,
+    function_environments: Vec<VMFunctionEnvironment>,
+}
+
+impl StoreObjects {
+    /// Returns the ID of this context.
+    pub fn id(&self) -> StoreId {
+        self.id
+    }
+
+    /// Sets the ID of this store
+    pub fn set_id(&mut self, id: StoreId) {
+        self.id = id;
+    }
+
+    /// Returns a pair of mutable references from two handles.
+    ///
+    /// Panics if both handles point to the same object.
+    pub fn get_2_mut<T: StoreObject>(
+        &mut self,
+        a: InternalStoreHandle<T>,
+        b: InternalStoreHandle<T>,
+    ) -> (&mut T, &mut T) {
+        assert_ne!(a.index(), b.index());
+        let list = T::list_mut(self);
+        if a.index() < b.index() {
+            let (low, high) = list.split_at_mut(b.index());
+            (&mut low[a.index()], &mut high[0])
+        } else {
+            let (low, high) = list.split_at_mut(a.index());
+            (&mut high[0], &mut low[a.index()])
+        }
+    }
+
+    /// Return an immutable iterator over all globals
+    pub fn iter_globals(&self) -> core::slice::Iter<VMGlobal> {
+        self.globals.iter()
+    }
+
+    /// Return an vector of all globals and converted to u128
+    pub fn as_u128_globals(&self) -> Vec<u128> {
+        vec![]
+        // self.iter_globals()
+        //     .map(|v| v.global.value().as_f64().unwrap() as u128)
+        //     .collect()
+    }
+
+    /// Set a global, at index idx. Will panic if idx is out of range
+    /// Safety: the caller should check taht the raw value is compatible
+    /// with destination VMGlobal type
+    pub fn set_global_unchecked(&self, idx: usize, new_val: u128) {
+        assert!(idx < self.globals.len());
+        // let g = &self.globals[idx].global;
+        // let cur_val = g.value().as_f64().unwrap();
+        // let new_val = new_val as f64;
+        // if cur_val != new_val {
+        //     let new_value = JSValue::from(new_val);
+        //     g.set_value(&new_value);
+        // }
+    }
+}
+
+/// Handle to an object managed by a context.
+///
+/// Internally this is just an integer index into a context. A reference to the
+/// context must be passed in separately to access the actual object.
+pub struct StoreHandle<T> {
+    id: StoreId,
+    internal: InternalStoreHandle<T>,
+}
+
+impl<T> core::cmp::PartialEq for StoreHandle<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+
+impl<T> std::hash::Hash for StoreHandle<T> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.id.hash(state);
+        self.internal.idx.hash(state);
+    }
+}
+
+impl<T> Clone for StoreHandle<T> {
+    fn clone(&self) -> Self {
+        Self {
+            id: self.id,
+            internal: self.internal,
+        }
+    }
+}
+
+impl<T: StoreObject> fmt::Debug for StoreHandle<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("StoreHandle")
+            .field("id", &self.id)
+            .field("internal", &self.internal.index())
+            .finish()
+    }
+}
+
+impl<T: StoreObject> StoreHandle<T> {
+    /// Moves the given object into a context and returns a handle to it.
+    pub fn new(store: &mut StoreObjects, val: T) -> Self {
+        Self {
+            id: store.id,
+            internal: InternalStoreHandle::new(store, val),
+        }
+    }
+
+    /// Returns a reference to the object that this handle points to.
+    pub fn get<'a>(&self, store: &'a StoreObjects) -> &'a T {
+        assert_eq!(self.id, store.id, "object used with the wrong context");
+        self.internal.get(store)
+    }
+
+    /// Returns a mutable reference to the object that this handle points to.
+    pub fn get_mut<'a>(&self, store: &'a mut StoreObjects) -> &'a mut T {
+        assert_eq!(self.id, store.id, "object used with the wrong context");
+        self.internal.get_mut(store)
+    }
+
+    /// Returns the internal handle contains within this handle.
+    pub fn internal_handle(&self) -> InternalStoreHandle<T> {
+        self.internal
+    }
+
+    /// Returns the ID of the context associated with the handle.
+    #[allow(unused)]
+    pub fn store_id(&self) -> StoreId {
+        self.id
+    }
+
+    /// Overrides the store id with a new ID
+    #[allow(unused)]
+    pub fn set_store_id(&mut self, id: StoreId) {
+        self.id = id;
+    }
+
+    /// Constructs a `StoreHandle` from a `StoreId` and an `InternalStoreHandle`.
+    ///
+    /// # Safety
+    /// Handling `InternalStoreHandle` values is unsafe because they do not track context ID.
+    pub unsafe fn from_internal(id: StoreId, internal: InternalStoreHandle<T>) -> Self {
+        Self { id, internal }
+    }
+}
+
+/// Internal handle to an object owned by the current context.
+///
+/// Unlike `StoreHandle` this does not track the context ID: it is only
+/// intended to be used within objects already owned by a context.
+#[repr(transparent)]
+pub struct InternalStoreHandle<T> {
+    // Use a NonZero here to reduce the size of Option<InternalStoreHandle>.
+    idx: NonZeroUsize,
+    marker: PhantomData<fn() -> T>,
+}
+
+impl<T> Clone for InternalStoreHandle<T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl<T> Copy for InternalStoreHandle<T> {}
+
+impl<T> fmt::Debug for InternalStoreHandle<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("InternalStoreHandle")
+            .field("idx", &self.idx)
+            .finish()
+    }
+}
+impl<T> PartialEq for InternalStoreHandle<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.idx == other.idx
+    }
+}
+impl<T> Eq for InternalStoreHandle<T> {}
+
+impl<T: StoreObject> InternalStoreHandle<T> {
+    /// Moves the given object into a context and returns a handle to it.
+    pub fn new(store: &mut StoreObjects, val: T) -> Self {
+        let list = T::list_mut(store);
+        let idx = NonZeroUsize::new(list.len() + 1).unwrap();
+        list.push(val);
+        Self {
+            idx,
+            marker: PhantomData,
+        }
+    }
+
+    /// Returns a reference to the object that this handle points to.
+    pub fn get<'a>(&self, store: &'a StoreObjects) -> &'a T {
+        &T::list(store)[self.idx.get() - 1]
+    }
+
+    /// Returns a mutable reference to the object that this handle points to.
+    pub fn get_mut<'a>(&self, store: &'a mut StoreObjects) -> &'a mut T {
+        &mut T::list_mut(store)[self.idx.get() - 1]
+    }
+
+    pub(crate) fn index(&self) -> usize {
+        self.idx.get()
+    }
+
+    pub(crate) fn from_index(idx: usize) -> Option<Self> {
+        NonZeroUsize::new(idx).map(|idx| Self {
+            idx,
+            marker: PhantomData,
+        })
+    }
+}
diff --git a/lib/api/src/backend/v8/entities/table.rs b/lib/api/src/backend/v8/entities/table.rs
new file mode 100644
index 0000000000..30ff4465cb
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/table.rs
@@ -0,0 +1,252 @@
+//! Data types, functions and traits for `v8` runtime's `Table` implementation.
+use wasmer_types::TableType;
+
+use crate::{
+    v8::{
+        bindings::{self, *},
+        utils::convert::{IntoCApiType, IntoCApiValue, IntoWasmerType, IntoWasmerValue},
+        vm::VMTable,
+    },
+    vm::{VMExtern, VMExternTable},
+    AsStoreMut, AsStoreRef, BackendTable, RuntimeError, Value,
+};
+
+use super::check_isolate;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// A WebAssembly `table` in the `v8` runtime.
+pub struct Table {
+    pub(crate) handle: VMTable,
+}
+
+unsafe impl Send for Table {}
+unsafe impl Sync for Table {}
+
+impl Table {
+    pub(crate) fn type_to_v8(ty: TableType) -> *mut wasm_tabletype_t {
+        let valtype = unsafe { wasm_valtype_new(ty.ty.into_ct()) };
+
+        let limits = Box::into_raw(Box::new(wasm_limits_t {
+            min: ty.minimum,
+            max: match ty.maximum {
+                Some(v) => v,
+                None => 0,
+            },
+            shared: false,
+        }));
+
+        unsafe { wasm_tabletype_new(valtype, limits) }
+    }
+
+    pub fn new(
+        store: &mut impl AsStoreMut,
+        ty: TableType,
+        init: Value,
+    ) -> Result<Self, RuntimeError> {
+        check_isolate(store);
+        let store_mut = store.as_store_mut();
+        let v8_store = store_mut.inner.store.as_v8();
+
+        let engine = store_mut.engine();
+
+        let wasm_tablety = Self::type_to_v8(ty);
+        let init: wasm_val_t = init.into_cv();
+
+        Ok(Self {
+            handle: unsafe { wasm_table_new(v8_store.inner, wasm_tablety, init.of.ref_) },
+        })
+    }
+
+    pub fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::V8(unsafe { wasm_table_as_extern(self.handle) })
+    }
+
+    pub fn ty(&self, store: &impl AsStoreRef) -> TableType {
+        check_isolate(store);
+
+        let store = store.as_store_ref();
+
+        let table_type: *mut wasm_tabletype_t = unsafe { wasm_table_type(self.handle) };
+        let table_limits = unsafe { wasm_tabletype_limits(table_type) };
+        let table_type = unsafe { wasm_tabletype_element(table_type) };
+
+        TableType {
+            ty: table_type.into_wt(),
+            minimum: unsafe { (*table_limits).min },
+            maximum: unsafe {
+                if (*table_limits).max == 0 {
+                    None
+                } else {
+                    Some((*table_limits).max)
+                }
+            },
+        }
+    }
+
+    pub fn get(&self, store: &mut impl AsStoreMut, index: u32) -> Option<Value> {
+        check_isolate(store);
+        let store_mut = store.as_store_mut();
+
+        unsafe {
+            let ref_ = wasm_table_get(self.handle, index);
+
+            if ref_.is_null() {
+                return None;
+            }
+
+            let kind = match self.ty(store).ty {
+                wasmer_types::Type::ExternRef => wasm_valkind_enum_WASM_EXTERNREF,
+                wasmer_types::Type::FuncRef => wasm_valkind_enum_WASM_FUNCREF,
+                ty => panic!("unsupported table type: {ty:?}"),
+            } as u8;
+
+            let value = wasm_val_t {
+                kind,
+                of: bindings::wasm_val_t__bindgen_ty_1 { ref_ },
+            };
+
+            Some(value.into_wv())
+        }
+    }
+
+    pub fn set(
+        &self,
+        store: &mut impl AsStoreMut,
+        index: u32,
+        val: Value,
+    ) -> Result<(), RuntimeError> {
+        check_isolate(store);
+        let store_mut = store.as_store_mut();
+
+        unsafe {
+            let init = match val {
+                Value::ExternRef(None) | Value::FuncRef(None) => std::ptr::null_mut(),
+                Value::FuncRef(Some(ref r)) => wasm_func_as_ref(r.as_v8().handle),
+                _ => {
+                    return Err(RuntimeError::new(format!(
+                        "Could not grow table due to unsupported init value type: {val:?} "
+                    )))
+                }
+            };
+
+            if !wasm_table_set(self.handle, index, init) {
+                return Err(RuntimeError::new(format!(
+                    "Could not set value {val:?} table at index {index}"
+                )));
+            }
+
+            Ok(())
+        }
+    }
+
+    pub fn size(&self, store: &impl AsStoreRef) -> u32 {
+        check_isolate(store);
+        let store = store.as_store_ref();
+        unsafe { wasm_table_size(self.handle) }
+    }
+
+    pub fn grow(
+        &self,
+        store: &mut impl AsStoreMut,
+        delta: u32,
+        init: Value,
+    ) -> Result<u32, RuntimeError> {
+        check_isolate(store);
+        let store_mut = store.as_store_mut();
+
+        unsafe {
+            let size = wasm_table_size(self.handle);
+            let init = match init {
+                Value::ExternRef(None) | Value::FuncRef(None) => std::ptr::null_mut(),
+                Value::FuncRef(Some(r)) => wasm_func_as_ref(r.as_v8().handle),
+                _ => {
+                    return Err(RuntimeError::new(format!(
+                        "Could not grow table due to unsupported init value type: {init:?} "
+                    )))
+                }
+            };
+            if !wasm_table_grow(self.handle, delta, init) {
+                return Err(RuntimeError::new("Could not grow table"));
+            }
+
+            Ok(size)
+        }
+    }
+
+    pub fn copy(
+        _store: &mut impl AsStoreMut,
+        _dst_table: &Self,
+        _dst_index: u32,
+        _src_table: &Self,
+        _src_index: u32,
+        _len: u32,
+    ) -> Result<(), RuntimeError> {
+        unimplemented!("Copying tables is currently not implemented!")
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternTable) -> Self {
+        check_isolate(store);
+        let store_mut = store.as_store_mut();
+
+        Self {
+            handle: vm_extern.into_v8(),
+        }
+    }
+
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        check_isolate(store);
+        true
+    }
+}
+
+impl crate::Table {
+    /// Consume [`self`] into [`crate::backend::v8::table::Table`].
+    pub fn into_v8(self) -> crate::backend::v8::table::Table {
+        match self.0 {
+            BackendTable::V8(s) => s,
+            _ => panic!("Not a `v8` table!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::v8::table::Table`].
+    pub fn as_v8(&self) -> &crate::backend::v8::table::Table {
+        match self.0 {
+            BackendTable::V8(ref s) => s,
+            _ => panic!("Not a `v8` table!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::v8::table::Table`].
+    pub fn as_v8_mut(&mut self) -> &mut crate::backend::v8::table::Table {
+        match self.0 {
+            BackendTable::V8(ref mut s) => s,
+            _ => panic!("Not a `v8` table!"),
+        }
+    }
+}
+
+impl crate::BackendTable {
+    /// Consume [`self`] into [`crate::backend::v8::table::Table`].
+    pub fn into_v8(self) -> crate::backend::v8::table::Table {
+        match self {
+            Self::V8(s) => s,
+            _ => panic!("Not a `v8` table!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::v8::table::Table`].
+    pub fn as_v8(&self) -> &crate::backend::v8::table::Table {
+        match self {
+            Self::V8(ref s) => s,
+            _ => panic!("Not a `v8` table!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::v8::table::Table`].
+    pub fn as_v8_mut(&mut self) -> &mut crate::backend::v8::table::Table {
+        match self {
+            Self::V8(ref mut s) => s,
+            _ => panic!("Not a `v8` table!"),
+        }
+    }
+}
diff --git a/lib/api/src/backend/v8/entities/tag.rs b/lib/api/src/backend/v8/entities/tag.rs
new file mode 100644
index 0000000000..bc2aeeb9f7
--- /dev/null
+++ b/lib/api/src/backend/v8/entities/tag.rs
@@ -0,0 +1,96 @@
+//! Data types, functions and traits for `v8` runtime's `Tag` implementation.
+use wasmer_types::{TagType, Type};
+
+use crate::{
+    v8::{
+        bindings::*,
+        utils::convert::{IntoCApiType, IntoWasmerType},
+        vm::VMTag,
+    },
+    vm::{VMExtern, VMExternTag},
+    AsStoreMut, AsStoreRef,
+};
+
+use super::check_isolate;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// A WebAssembly `tag` in the `v8` runtime.
+pub(crate) struct Tag {
+    pub(crate) handle: VMTag,
+}
+
+unsafe impl Send for Tag {}
+unsafe impl Sync for Tag {}
+
+impl Tag {
+    pub fn new<P: Into<Box<[Type]>>>(store: &mut impl AsStoreMut, params: P) -> Self {
+        check_isolate(store);
+        let store_mut = store.as_store_mut();
+        let v8_store = store_mut.inner.store.as_v8();
+
+        let params = Into::<Box<[Type]>>::into(params).into_vec();
+        let params = params
+            .into_iter()
+            .map(|param| {
+                let kind = param.into_ct();
+                unsafe { wasm_valtype_new(kind) }
+            })
+            .collect::<Vec<_>>();
+
+        let mut params = unsafe {
+            let mut vec: wasm_valtype_vec_t = Default::default();
+            wasm_valtype_vec_new(&mut vec, params.len(), params.as_ptr());
+            vec
+        };
+
+        let tag_type = unsafe { wasm_tagtype_new(&mut params) };
+        if tag_type.is_null() {
+            panic!("failed to create new tag: returned tag type is null");
+        }
+
+        let handle = unsafe { wasm_tag_new(v8_store.inner, tag_type) };
+        if handle.is_null() {
+            panic!("failed to create new tag: returned tag is null");
+        }
+
+        Self { handle }
+    }
+
+    pub fn ty(&self, store: &impl AsStoreRef) -> TagType {
+        check_isolate(store);
+        let type_ = unsafe { wasm_tag_type(self.handle) };
+        let params: *const wasm_valtype_vec_t = unsafe { wasm_tagtype_params(type_) };
+
+        let params: Vec<wasmer_types::Type> = unsafe {
+            let mut res = vec![];
+            for i in 0..(*params).size {
+                res.push((*(*params).data.wrapping_add(i)).into_wt());
+            }
+            res
+        };
+
+        TagType::new(wasmer_types::TagKind::Exception, params)
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_tag: VMExternTag) -> Self {
+        check_isolate(store);
+        Self {
+            handle: vm_tag.into_v8(),
+        }
+    }
+
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        check_isolate(store);
+        true
+    }
+
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        let extern_ = unsafe { wasm_tag_as_extern(self.handle) };
+        assert!(
+            !extern_.is_null(),
+            "Returned null Tag extern from wasm-c-api"
+        );
+
+        VMExtern::V8(extern_)
+    }
+}
diff --git a/lib/api/src/backend/v8/error.rs b/lib/api/src/backend/v8/error.rs
new file mode 100644
index 0000000000..7f9b26e98a
--- /dev/null
+++ b/lib/api/src/backend/v8/error.rs
@@ -0,0 +1,151 @@
+use std::{
+    error::Error,
+    ffi::{c_char, CStr},
+};
+
+use crate::{v8::bindings::*, AsStoreMut};
+
+#[derive(Debug)]
+enum InnerTrap {
+    User(Box<dyn Error + Send + Sync>),
+    CApi(*mut wasm_trap_t),
+}
+
+/// A struct representing a Trap
+#[derive(Debug)]
+pub struct Trap {
+    inner: InnerTrap,
+}
+
+unsafe impl Send for Trap {}
+unsafe impl Sync for Trap {}
+
+impl Trap {
+    pub fn user(error: Box<dyn Error + Send + Sync>) -> Self {
+        Self {
+            inner: InnerTrap::User(error),
+        }
+    }
+
+    /// Attempts to downcast the `Trap` to a concrete type.
+    pub fn downcast<T: Error + 'static>(self) -> Result<T, Self> {
+        match self.inner {
+            // We only try to downcast user errors
+            InnerTrap::User(err) if err.is::<T>() => Ok(*err.downcast::<T>().unwrap()),
+            _ => Err(self),
+        }
+    }
+
+    /// Attempts to downcast the `Trap` to a concrete type.
+    pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T> {
+        match &self.inner {
+            // We only try to downcast user errors
+            InnerTrap::User(err) if err.is::<T>() => err.downcast_ref::<T>(),
+            _ => None,
+        }
+    }
+
+    /// Returns true if the `Trap` is the same as T
+    pub fn is<T: Error + 'static>(&self) -> bool {
+        match &self.inner {
+            InnerTrap::User(err) => err.is::<T>(),
+            _ => false,
+        }
+    }
+
+    pub unsafe fn into_wasm_trap(self, store: &mut impl AsStoreMut) -> *mut wasm_trap_t {
+        match self.inner {
+            InnerTrap::CApi(t) => t,
+            InnerTrap::User(err) => {
+                let err_ptr = Box::leak(Box::new(err));
+                let mut data = std::mem::zeroed();
+                // let x = format!("")
+                let s1 = format!("🐛{err_ptr:p}");
+                let _s = s1.into_bytes().into_boxed_slice();
+                wasm_byte_vec_new(&mut data, _s.len(), _s.as_ptr() as _);
+                std::mem::forget(_s);
+                let store = store.as_store_mut();
+                wasm_trap_new(store.inner.store.as_v8().inner, &mut data)
+            }
+        }
+    }
+
+    // pub unsafe fn deserialize_from_wasm_trap(trap: *mut wasm_trap_t) -> Self {
+    //     let mut data = std::mem::zeroed();
+    //     wasm_trap_message(trap, data);
+    //     println!("data: {data:p}");
+
+    //     std::ptr::read(data as *const _)
+    // }
+}
+
+impl From<*mut wasm_trap_t> for Trap {
+    fn from(value: *mut wasm_trap_t) -> Self {
+        let message = unsafe {
+            let mut message = std::mem::zeroed();
+            wasm_trap_message(value, &mut message);
+
+            CStr::from_ptr(message.data as *const c_char)
+                .to_str()
+                .unwrap()
+        };
+
+        if message.starts_with("Exception: 🐛") {
+            let ptr_str = message.replace("Exception: 🐛", "");
+            let ptr: Box<dyn Error + Send + Sync + 'static> = unsafe {
+                let r = ptr_str.trim_start_matches("0x");
+                std::ptr::read(
+                    (usize::from_str_radix(&r, 16).unwrap()
+                        as *const Box<dyn Error + Send + Sync + 'static>),
+                )
+            };
+
+            Self {
+                inner: InnerTrap::User(ptr),
+            }
+        } else {
+            Self {
+                inner: InnerTrap::CApi(value),
+            }
+        }
+    }
+}
+
+impl std::error::Error for Trap {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match &self.inner {
+            InnerTrap::User(err) => Some(&**err),
+            _ => None,
+        }
+    }
+}
+
+impl std::fmt::Display for Trap {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self.inner {
+            InnerTrap::User(e) => write!(f, "{e}"),
+            InnerTrap::CApi(value) => {
+                // let message: wasm_message_t;
+                // wasm_trap_message(value, &mut message);
+                let mut out = unsafe {
+                    let mut vec: wasm_byte_vec_t = Default::default();
+                    wasm_byte_vec_new_empty(&mut vec);
+                    &mut vec as *mut _
+                };
+                unsafe { wasm_trap_message(*value, out) };
+                let cstr = unsafe { CStr::from_ptr((*out).data) };
+                write!(f, "wasm-c-api trap: {}", cstr.to_str().unwrap())
+            }
+        }
+    }
+}
+
+impl From<Trap> for crate::RuntimeError {
+    fn from(trap: Trap) -> Self {
+        if trap.is::<Self>() {
+            return trap.downcast::<Self>().unwrap();
+        }
+
+        crate::RuntimeError::new_from_source(crate::BackendTrap::V8(trap), vec![], None)
+    }
+}
diff --git a/lib/api/src/backend/v8/mod.rs b/lib/api/src/backend/v8/mod.rs
new file mode 100644
index 0000000000..f7be9f943a
--- /dev/null
+++ b/lib/api/src/backend/v8/mod.rs
@@ -0,0 +1,9 @@
+//! Data types, functions and traits for the `v8` backend.
+
+pub(crate) mod bindings;
+pub(crate) mod entities;
+pub(crate) mod error;
+pub(crate) mod utils;
+pub(crate) mod vm;
+
+pub use entities::{engine::Engine as V8, *};
diff --git a/lib/api/src/backend/v8/utils/convert.rs b/lib/api/src/backend/v8/utils/convert.rs
new file mode 100644
index 0000000000..d7540b264a
--- /dev/null
+++ b/lib/api/src/backend/v8/utils/convert.rs
@@ -0,0 +1,261 @@
+use wasmer_types::{ExternType, FunctionType, Mutability, Type};
+
+/// Utilities to convert between `v8` and `wasmer` values
+use crate::{
+    v8::{
+        bindings::{self, *},
+        function,
+    },
+    BackendFunction, Function, Value,
+};
+
+pub trait IntoCApiValue {
+    /// Consume [`self`] to produce a [`wasm_val_t`].
+    fn into_cv(self) -> wasm_val_t;
+}
+
+impl IntoCApiValue for Value {
+    fn into_cv(self) -> wasm_val_t {
+        match self {
+            Value::I32(val) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_I32 as _,
+                of: wasm_val_t__bindgen_ty_1 { i32_: val },
+            },
+            Value::I64(val) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_I64 as _,
+                of: wasm_val_t__bindgen_ty_1 { i64_: val },
+            },
+            Value::F32(val) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_F32 as _,
+                of: wasm_val_t__bindgen_ty_1 { f32_: val },
+            },
+            Value::F64(val) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_F64 as _,
+                of: wasm_val_t__bindgen_ty_1 { f64_: val },
+            },
+            Value::FuncRef(Some(val)) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_FUNCREF as _,
+                of: wasm_val_t__bindgen_ty_1 {
+                    ref_: unsafe { wasm_func_as_ref(val.as_v8().handle) },
+                },
+            },
+            Value::FuncRef(None) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_FUNCREF as _,
+                of: wasm_val_t__bindgen_ty_1 {
+                    ref_: unsafe { wasm_func_as_ref(std::ptr::null_mut()) },
+                },
+            },
+            Value::ExternRef(_) => panic!(
+                "Creating host values from guest ExternRefs is not currently supported in V8."
+            ),
+            Value::ExceptionRef(_) => {
+                panic!("Creating host values from guest V128s is not currently supported in V8.")
+            }
+            Value::V128(_) => {
+                panic!("Creating host values from guest V128s is not currently supported in V8.")
+            }
+        }
+    }
+}
+
+pub trait IntoWasmerValue {
+    /// Consume [`self`] to produce a [`Value`].
+    fn into_wv(self) -> Value;
+}
+
+impl IntoWasmerValue for wasm_val_t {
+    fn into_wv(self) -> Value {
+        match self.kind as _ {
+            bindings::wasm_valkind_enum_WASM_I32 => Value::I32(unsafe { self.of.i32_ }),
+            bindings::wasm_valkind_enum_WASM_I64 => Value::I64(unsafe { self.of.i64_ }),
+            bindings::wasm_valkind_enum_WASM_F32 => Value::F32(unsafe { self.of.f32_ }),
+            bindings::wasm_valkind_enum_WASM_F64 => Value::F64(unsafe { self.of.f64_ }),
+            bindings::wasm_valkind_enum_WASM_FUNCREF => Value::FuncRef(Some(Function(
+                BackendFunction::V8(crate::backend::v8::function::Function {
+                    handle: unsafe { self.of.ref_ as _ },
+                }),
+            ))),
+            bindings::wasm_valkind_enum_WASM_EXTERNREF => {
+                panic!("ExternRefs are not currently supported through wasm_c_api")
+            }
+            _ => unreachable!("v8 kind {} has no matching wasmer type", self.kind),
+        }
+    }
+}
+
+pub trait IntoWasmerType {
+    /// Consume [`self`] to produce a [`Type`].
+    fn into_wt(self) -> Type;
+}
+
+impl IntoWasmerType for wasm_valkind_t {
+    fn into_wt(self) -> Type {
+        match self as _ {
+            bindings::wasm_valkind_enum_WASM_I32 => Type::I32,
+            bindings::wasm_valkind_enum_WASM_I64 => Type::I64,
+            bindings::wasm_valkind_enum_WASM_F32 => Type::F32,
+            bindings::wasm_valkind_enum_WASM_F64 => Type::F64,
+            bindings::wasm_valkind_enum_WASM_EXTERNREF => Type::ExternRef,
+            bindings::wasm_valkind_enum_WASM_FUNCREF => Type::FuncRef,
+            _ => unreachable!("v8 kind {self:?} has no matching wasmer type"),
+        }
+    }
+}
+
+pub trait IntoCApiType {
+    /// Consume [`self`] to produce a [`wasm_valkind_t`].
+    fn into_ct(self) -> wasm_valkind_t;
+}
+
+impl IntoCApiType for Type {
+    fn into_ct(self) -> wasm_valkind_t {
+        match self as _ {
+            Type::I32 => bindings::wasm_valkind_enum_WASM_I32 as _,
+            Type::I64 => bindings::wasm_valkind_enum_WASM_I64 as _,
+            Type::F32 => bindings::wasm_valkind_enum_WASM_F32 as _,
+            Type::F64 => bindings::wasm_valkind_enum_WASM_F64 as _,
+            Type::FuncRef => bindings::wasm_valkind_enum_WASM_FUNCREF as _,
+            Type::ExternRef => bindings::wasm_valkind_enum_WASM_EXTERNREF as _,
+            Type::V128 => panic!("v8 currently does not support V128 types"),
+            Type::ExceptionRef => panic!("v8 currently does not support exnrefs"),
+        }
+    }
+}
+
+impl IntoWasmerType for wasm_valtype_t {
+    fn into_wt(self) -> Type {
+        let type_: wasm_valkind_t = unsafe { wasm_valtype_kind(&self as *const _) };
+        type_.into_wt()
+    }
+}
+
+impl IntoWasmerType for *const wasm_valtype_t {
+    fn into_wt(self) -> Type {
+        let type_: wasm_valkind_t = unsafe { wasm_valtype_kind(self as _) };
+        type_.into_wt()
+    }
+}
+
+impl IntoWasmerType for *mut wasm_valtype_t {
+    fn into_wt(self) -> Type {
+        let type_: wasm_valkind_t = unsafe { wasm_valtype_kind(self as _) };
+        type_.into_wt()
+    }
+}
+
+pub trait IntoWasmerExternType {
+    /// Consume [`self`] to produce a [`wasm_valkind_t`].
+    unsafe fn into_wextt(self) -> Result<ExternType, String>;
+}
+
+impl IntoWasmerExternType for wasm_externtype_t {
+    unsafe fn into_wextt(mut self) -> Result<ExternType, String> {
+        (&self as *const wasm_externtype_t).into_wextt()
+    }
+}
+
+impl IntoWasmerExternType for *mut wasm_externtype_t {
+    unsafe fn into_wextt(self) -> Result<ExternType, String> {
+        (self as *const wasm_externtype_t).into_wextt()
+    }
+}
+
+impl IntoWasmerExternType for *const wasm_externtype_t {
+    unsafe fn into_wextt(self) -> Result<ExternType, String> {
+        let ret = unsafe {
+            let kind = wasm_externtype_kind(self);
+            match kind as _ {
+                bindings::wasm_externkind_enum_WASM_EXTERN_FUNC => {
+                    let functype = wasm_externtype_as_functype_const(self);
+                    let params = wasm_functype_params(functype);
+                    let params = if params.is_null() || (*params).size == 0 {
+                        vec![]
+                    } else {
+                        std::slice::from_raw_parts((*params).data, (*params).size)
+                            .to_vec()
+                            .into_iter()
+                            .map(|v| v.into_wt())
+                            .collect::<Vec<_>>()
+                    };
+
+                    let returns = wasm_functype_results(functype);
+                    let returns = if returns.is_null() || (*returns).size == 0 {
+                        vec![]
+                    } else {
+                        std::slice::from_raw_parts((*returns).data, (*returns).size)
+                            .to_vec()
+                            .into_iter()
+                            .map(|v| v.into_wt())
+                            .collect::<Vec<_>>()
+                    };
+
+                    ExternType::Function(FunctionType::new(params, returns))
+                }
+                bindings::wasm_externkind_enum_WASM_EXTERN_GLOBAL => {
+                    let globaltype = wasm_externtype_as_globaltype_const(self);
+                    let valtype = wasm_globaltype_content(globaltype);
+                    let mutability = if wasm_globaltype_mutability(globaltype)
+                        == bindings::wasm_mutability_enum_WASM_CONST as u8
+                    {
+                        Mutability::Const
+                    } else {
+                        Mutability::Var
+                    };
+                    ExternType::Global(wasmer_types::GlobalType {
+                        ty: valtype.into_wt(),
+                        mutability,
+                    })
+                }
+
+                bindings::wasm_externkind_enum_WASM_EXTERN_TABLE => {
+                    let tabletype = wasm_externtype_as_tabletype_const(self);
+                    let valtype = wasm_tabletype_element(tabletype);
+                    let limits = *wasm_tabletype_limits(tabletype);
+                    ExternType::Table(wasmer_types::TableType {
+                        ty: valtype.into_wt(),
+                        minimum: limits.min,
+                        maximum: if limits.max == 0 || limits.max == u32::MAX {
+                            None
+                        } else {
+                            Some(limits.max)
+                        },
+                    })
+                }
+                bindings::wasm_externkind_enum_WASM_EXTERN_MEMORY => {
+                    let memorytype = wasm_externtype_as_memorytype_const(self);
+                    let limits = *wasm_memorytype_limits(memorytype);
+                    ExternType::Memory(wasmer_types::MemoryType {
+                        minimum: wasmer_types::Pages(limits.min),
+                        maximum: if limits.max == 0 || limits.max == u32::MAX {
+                            None
+                        } else {
+                            Some(wasmer_types::Pages(limits.max))
+                        },
+                        shared: limits.shared,
+                    })
+                }
+                bindings::wasm_externkind_enum_WASM_EXTERN_TAG => {
+                    let tagtype = wasm_externtype_as_tagtype_const(self);
+                    let params = wasm_tagtype_params(tagtype);
+                    let params = if params.is_null() || (*params).size == 0 {
+                        vec![]
+                    } else {
+                        std::slice::from_raw_parts((*params).data, (*params).size)
+                            .to_vec()
+                            .into_iter()
+                            .map(|v| v.into_wt())
+                            .collect::<Vec<_>>()
+                    };
+
+                    ExternType::Tag(wasmer_types::TagType {
+                        kind: wasmer_types::TagKind::Exception,
+                        params: params.into(),
+                    })
+                }
+                _ => return Err(String::from("Unsupported extern kind!")),
+            }
+        };
+
+        Ok(ret)
+    }
+}
diff --git a/lib/api/src/backend/v8/utils/mod.rs b/lib/api/src/backend/v8/utils/mod.rs
new file mode 100644
index 0000000000..02d63d4e14
--- /dev/null
+++ b/lib/api/src/backend/v8/utils/mod.rs
@@ -0,0 +1 @@
+pub(crate) mod convert;
diff --git a/lib/api/src/backend/v8/vm/env.rs b/lib/api/src/backend/v8/vm/env.rs
new file mode 100644
index 0000000000..d2a93d5f63
--- /dev/null
+++ b/lib/api/src/backend/v8/vm/env.rs
@@ -0,0 +1,28 @@
+use std::any::Any;
+
+/// Underlying FunctionEnvironment used by a `VMFunction`.
+#[derive(Debug)]
+pub struct VMFunctionEnvironment {
+    pub(crate) contents: Box<dyn Any + Send + 'static>,
+}
+
+impl VMFunctionEnvironment {
+    /// Wraps the given value to expose it to Wasm code as a function context.
+    pub fn new(val: impl Any + Send + 'static) -> Self {
+        Self {
+            contents: Box::new(val),
+        }
+    }
+
+    #[allow(clippy::should_implement_trait)]
+    /// Returns a reference to the underlying value.
+    pub fn as_ref(&self) -> &(dyn Any + Send + 'static) {
+        &*self.contents
+    }
+
+    #[allow(clippy::should_implement_trait)]
+    /// Returns a mutable reference to the underlying value.
+    pub fn as_mut(&mut self) -> &mut (dyn Any + Send + 'static) {
+        &mut *self.contents
+    }
+}
diff --git a/lib/api/src/backend/v8/vm/mod.rs b/lib/api/src/backend/v8/vm/mod.rs
new file mode 100644
index 0000000000..4c11590ec9
--- /dev/null
+++ b/lib/api/src/backend/v8/vm/mod.rs
@@ -0,0 +1,149 @@
+mod env;
+pub use env::*;
+
+use super::{
+    bindings::*, entities::function::env::FunctionEnv, function::Function, global::Global,
+    memory::Memory, table::Table,
+};
+use crate::{AsStoreMut, BackendFunction, BackendGlobal, BackendMemory, BackendTable, Extern};
+use wasmer_types::RawValue;
+
+pub use super::error::Trap;
+
+pub(crate) type VMExtern = *mut wasm_extern_t;
+
+// No EH for now.
+pub(crate) type VMException = ();
+pub(crate) type VMTag = *mut wasm_tag_t;
+pub(crate) type VMExternTag = *mut wasm_tag_t;
+
+pub(crate) type VMFunction = *mut wasm_func_t;
+pub(crate) type VMFunctionBody = ();
+pub(crate) type VMFunctionCallback = *mut ::std::os::raw::c_void;
+pub(crate) type VMTrampoline = *mut ::std::os::raw::c_void;
+pub(crate) type VMExternFunction = *mut wasm_func_t;
+
+pub(crate) type VMGlobal = *mut wasm_global_t;
+pub(crate) type VMExternGlobal = *mut wasm_global_t;
+
+pub(crate) type VMMemory = *mut wasm_memory_t;
+pub type VMSharedMemory = VMMemory;
+pub(crate) type VMExternMemory = *mut wasm_memory_t;
+
+pub(crate) type VMTable = *mut wasm_table_t;
+pub(crate) type VMExternTable = *mut wasm_table_t;
+
+pub(crate) type VMInstance = *mut wasm_instance_t;
+
+pub(crate) type VMExternObj = ();
+pub(crate) type VMConfig = ();
+
+impl crate::VMExternToExtern for VMExtern {
+    fn to_extern(self, store: &mut impl AsStoreMut) -> Extern {
+        let kind = unsafe { wasm_extern_kind(&mut *self) };
+
+        match kind as u32 {
+            0 => {
+                let func = unsafe { wasm_extern_as_func(&mut *self) };
+                if func.is_null() {
+                    panic!("V8 reported extern as function, but is not");
+                }
+                Extern::Function(crate::Function::from_vm_extern(
+                    store,
+                    crate::vm::VMExternFunction::V8(func),
+                ))
+            }
+            1 => {
+                let global = unsafe { wasm_extern_as_global(&mut *self) };
+                if global.is_null() {
+                    panic!("V8 reported extern as a global, but is not");
+                }
+                Extern::Global(crate::Global::from_vm_extern(
+                    store,
+                    crate::vm::VMExternGlobal::V8(global),
+                ))
+            }
+            2 => {
+                let table = unsafe { wasm_extern_as_table(&mut *self) };
+                if table.is_null() {
+                    panic!("V8 reported extern as a table, but is not");
+                }
+                Extern::Table(crate::Table::from_vm_extern(
+                    store,
+                    crate::vm::VMExternTable::V8(table),
+                ))
+            }
+            3 => {
+                let memory = unsafe { wasm_extern_as_memory(&mut *self) };
+                if memory.is_null() {
+                    panic!("V8 reported extern as a memory, but is not");
+                }
+                Extern::Memory(crate::Memory::from_vm_extern(
+                    store,
+                    crate::vm::VMExternMemory::V8(memory),
+                ))
+            }
+            4 => {
+                let tag = unsafe { wasm_extern_as_tag(&mut *self) };
+                if tag.is_null() {
+                    panic!("V8 reported extern as a tag, but is not");
+                }
+                Extern::Tag(crate::Tag::from_vm_extern(
+                    store,
+                    crate::vm::VMExternTag::V8(tag),
+                ))
+            }
+            _ => {
+                unimplemented!()
+            }
+        }
+    }
+}
+
+pub(crate) struct VMExternRef(*mut wasm_ref_t);
+impl VMExternRef {
+    /// Converts the `VMExternRef` into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        unimplemented!()
+    }
+
+    /// Extracts a `VMExternRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw` must be a valid `VMExternRef` instance.
+    pub unsafe fn from_raw(_raw: RawValue) -> Option<Self> {
+        unimplemented!();
+    }
+}
+
+pub(crate) struct VMFuncRef(*mut wasm_ref_t);
+impl VMFuncRef {
+    /// Converts the `VMExternRef` into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        unimplemented!()
+    }
+
+    /// Extracts a `VMExternRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw` must be a valid `VMExternRef` instance.
+    pub unsafe fn from_raw(_raw: RawValue) -> Option<Self> {
+        unimplemented!();
+    }
+}
+
+pub(crate) struct VMExceptionRef(*mut wasm_ref_t);
+impl VMExceptionRef {
+    /// Converts the `VMExceptionRef` into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        unimplemented!()
+    }
+
+    /// Extracts a `VMExceptionRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw` must be a valid `VMExceptionRef` instance.
+    pub unsafe fn from_raw(_raw: RawValue) -> Option<Self> {
+        unimplemented!();
+    }
+}
diff --git a/lib/api/src/backend/wamr/bindings.rs b/lib/api/src/backend/wamr/bindings.rs
new file mode 100644
index 0000000000..9e9ae39fb2
--- /dev/null
+++ b/lib/api/src/backend/wamr/bindings.rs
@@ -0,0 +1,7 @@
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(unused)]
+
+// This matches bindgen::Builder output
+include!(concat!(env!("OUT_DIR"), "/wamr_bindings.rs"));
diff --git a/lib/api/src/backend/wamr/entities/engine.rs b/lib/api/src/backend/wamr/entities/engine.rs
new file mode 100644
index 0000000000..6e30b96cf3
--- /dev/null
+++ b/lib/api/src/backend/wamr/entities/engine.rs
@@ -0,0 +1,108 @@
+//! Data types, functions and traits for `wamr` runtime's `Engine` implementation.
+use crate::{
+    backend::wamr::bindings::{wasm_engine_delete, wasm_engine_new, wasm_engine_t},
+    BackendEngine,
+};
+use std::sync::Arc;
+use wasmer_types::{target::Target, Features};
+
+#[derive(Debug)]
+pub(crate) struct CApiEngine {
+    pub(crate) engine: *mut wasm_engine_t,
+}
+
+impl Default for CApiEngine {
+    fn default() -> Self {
+        let engine: *mut wasm_engine_t = unsafe { wasm_engine_new() };
+        Self { engine }
+    }
+}
+
+impl Drop for CApiEngine {
+    fn drop(&mut self) {
+        unsafe { wasm_engine_delete(self.engine) }
+    }
+}
+
+/// The engine for the Web Assembly Micro Runtime.
+#[derive(Clone, Debug, Default)]
+pub struct Engine {
+    pub(crate) inner: Arc<CApiEngine>,
+}
+
+impl Engine {
+    /// Create a new instance of the `wamr` engine.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub(crate) fn deterministic_id(&self) -> String {
+        String::from("wamr")
+    }
+
+    /// Returns the WebAssembly features supported by the WAMR engine.
+    pub fn supported_features() -> Features {
+        // WAMR-specific features
+        let mut features = Features::default();
+        features.bulk_memory(true);
+        features.reference_types(true);
+        features.multi_value(true);
+        features.simd(false);
+        features.threads(false);
+        features.exceptions(false);
+        features
+    }
+
+    /// Returns the default features for the WAMR engine.
+    pub fn default_features() -> Features {
+        Self::supported_features()
+    }
+}
+
+unsafe impl Send for Engine {}
+unsafe impl Sync for Engine {}
+
+/// Returns the default engine for the wamr engine
+pub(crate) fn default_engine() -> Engine {
+    Engine::default()
+}
+
+impl crate::Engine {
+    /// Consume [`self`] into a [`crate::backend::wamr::engine::Engine`].
+    pub fn into_wamr(self) -> crate::backend::wamr::engine::Engine {
+        match self.be {
+            BackendEngine::Wamr(s) => s,
+            _ => panic!("Not a `wamr` engine!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::wamr::engine::Engine`].
+    pub fn as_wamr(&self) -> &crate::backend::wamr::engine::Engine {
+        match &self.be {
+            BackendEngine::Wamr(s) => s,
+            _ => panic!("Not a `wamr` engine!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wamr::engine::Engine`].
+    pub fn as_wamr_mut(&mut self) -> &mut crate::backend::wamr::engine::Engine {
+        match self.be {
+            BackendEngine::Wamr(ref mut s) => s,
+            _ => panic!("Not a `wamr` engine!"),
+        }
+    }
+
+    /// Return true if [`self`] is an engine from the `wamr` runtime.
+    pub fn is_wamr(&self) -> bool {
+        matches!(self.be, BackendEngine::Wamr(_))
+    }
+}
+
+impl From<Engine> for crate::Engine {
+    fn from(value: Engine) -> Self {
+        crate::Engine {
+            be: BackendEngine::Wamr(value),
+            id: crate::Engine::atomic_next_engine_id(),
+        }
+    }
+}
diff --git a/lib/api/src/backend/wamr/entities/exception.rs b/lib/api/src/backend/wamr/entities/exception.rs
new file mode 100644
index 0000000000..437511562a
--- /dev/null
+++ b/lib/api/src/backend/wamr/entities/exception.rs
@@ -0,0 +1,63 @@
+//! Data types, functions and traits for `sys` runtime's `Tag` implementation.
+use std::any::Any;
+
+use wasmer_types::{TagType, Type};
+
+use crate::{
+    wamr::vm::{VMException, VMExceptionRef},
+    AsStoreMut, AsStoreRef, Tag, Value,
+};
+
+use super::store::StoreHandle;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// A WebAssembly `tag` in the `v8` runtime.
+pub(crate) struct Exception {
+    pub(crate) handle: VMException,
+}
+
+unsafe impl Send for Exception {}
+unsafe impl Sync for Exception {}
+
+impl Exception {
+    /// Create a new [`Exception`].
+    pub fn new(store: &mut impl AsStoreMut, tag: Tag, payload: &[Value]) -> Self {
+        todo!()
+    }
+}
+
+#[derive(Debug, Clone)]
+#[repr(transparent)]
+/// A WebAssembly `extern ref` in `wamr`.
+pub(crate) struct ExceptionRef;
+
+impl ExceptionRef {
+    pub fn new<T>(_store: &mut impl AsStoreMut, _value: T) -> Self
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        unimplemented!("ExceptionRef is not yet supported in wamr");
+    }
+
+    pub fn downcast<'a, T>(&self, _store: &'a impl AsStoreRef) -> Option<&'a T>
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        unimplemented!("ExceptionRef is not yet supported in wamr");
+    }
+
+    pub(crate) fn vm_exceptionref(&self) -> VMExceptionRef {
+        unimplemented!("ExceptionRef is not yet supported in wamr");
+    }
+
+    pub(crate) unsafe fn from_vm_exceptionref(
+        _store: &mut impl AsStoreMut,
+        _vm_exceptionref: VMExceptionRef,
+    ) -> Self {
+        unimplemented!("ExceptionRef is not yet supported in wamr");
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
diff --git a/lib/api/src/backend/wamr/entities/external.rs b/lib/api/src/backend/wamr/entities/external.rs
new file mode 100644
index 0000000000..b5fbad27f6
--- /dev/null
+++ b/lib/api/src/backend/wamr/entities/external.rs
@@ -0,0 +1,42 @@
+//! Data types, functions and traits for `wamr`'s `ExternRef` implementation.
+use crate::{
+    store::{AsStoreMut, AsStoreRef},
+    wamr::vm::VMExternRef,
+};
+use std::any::Any;
+
+#[derive(Debug, Clone)]
+#[repr(transparent)]
+/// A WebAssembly `extern ref` in `wamr`.
+pub struct ExternRef;
+
+impl ExternRef {
+    pub fn new<T>(_store: &mut impl AsStoreMut, _value: T) -> Self
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        unimplemented!("ExternRef is not yet supported with wasm_c_api");
+    }
+
+    pub fn downcast<'a, T>(&self, _store: &'a impl AsStoreRef) -> Option<&'a T>
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        unimplemented!("ExternRef is not yet supported in wasm_c_api");
+    }
+
+    pub(crate) fn vm_externref(&self) -> VMExternRef {
+        unimplemented!("ExternRef is not yet supported in wasm_c_api");
+    }
+
+    pub(crate) unsafe fn from_vm_externref(
+        _store: &mut impl AsStoreMut,
+        _vm_externref: VMExternRef,
+    ) -> Self {
+        unimplemented!("ExternRef is not yet supported in wasm_c_api");
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
diff --git a/lib/api/src/backend/wamr/entities/function/env.rs b/lib/api/src/backend/wamr/entities/function/env.rs
new file mode 100644
index 0000000000..266022b205
--- /dev/null
+++ b/lib/api/src/backend/wamr/entities/function/env.rs
@@ -0,0 +1,213 @@
+use std::{any::Any, fmt::Debug, marker::PhantomData};
+
+use crate::{
+    store::{AsStoreMut, AsStoreRef, StoreRef},
+    wamr::{store::StoreHandle, vm::VMFunctionEnvironment},
+    StoreMut,
+};
+
+#[derive(Debug)]
+#[repr(transparent)]
+/// An opaque reference to a function environment.
+/// The function environment data is owned by the `Store`.
+pub struct FunctionEnv<T> {
+    pub(crate) handle: StoreHandle<VMFunctionEnvironment>,
+    marker: PhantomData<T>,
+}
+
+impl<T> FunctionEnv<T> {
+    /// Make a new FunctionEnv
+    pub fn new(store: &mut impl AsStoreMut, value: T) -> Self
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        Self {
+            handle: StoreHandle::new(
+                store.as_store_mut().objects_mut().as_wamr_mut(),
+                VMFunctionEnvironment::new(value),
+            ),
+            marker: PhantomData,
+        }
+    }
+
+    /// Get the data as reference
+    pub fn as_ref<'a>(&self, store: &'a impl AsStoreRef) -> &'a T
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        self.handle
+            .get(store.as_store_ref().objects().as_wamr())
+            .as_ref()
+            .downcast_ref::<T>()
+            .unwrap()
+    }
+
+    pub(crate) fn from_handle(handle: StoreHandle<VMFunctionEnvironment>) -> Self {
+        Self {
+            handle,
+            marker: PhantomData,
+        }
+    }
+
+    /// Get the data as mutable
+    pub fn as_mut<'a>(&self, store: &'a mut impl AsStoreMut) -> &'a mut T
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        self.handle
+            .get_mut(store.objects_mut().as_wamr_mut())
+            .as_mut()
+            .downcast_mut::<T>()
+            .unwrap()
+    }
+
+    /// Convert it into a `FunctionEnvMut`
+    pub fn into_mut(self, store: &mut impl AsStoreMut) -> FunctionEnvMut<T>
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        FunctionEnvMut {
+            store_mut: store.as_store_mut(),
+            func_env: self,
+        }
+    }
+}
+
+impl<T> PartialEq for FunctionEnv<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.handle == other.handle
+    }
+}
+
+impl<T> Eq for FunctionEnv<T> {}
+
+impl<T> std::hash::Hash for FunctionEnv<T> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.handle.hash(state);
+        self.marker.hash(state);
+    }
+}
+
+impl<T> Clone for FunctionEnv<T> {
+    fn clone(&self) -> Self {
+        Self {
+            handle: self.handle.clone(),
+            marker: self.marker,
+        }
+    }
+}
+
+/// A temporary handle to a [`FunctionEnv`].
+pub struct FunctionEnvMut<'a, T: 'a> {
+    pub(crate) store_mut: StoreMut<'a>,
+    pub(crate) func_env: FunctionEnv<T>,
+}
+
+impl<'a, T> Debug for FunctionEnvMut<'a, T>
+where
+    T: Send + Debug + 'static,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.func_env.as_ref(&self.store_mut).fmt(f)
+    }
+}
+
+impl<T: Send + 'static> FunctionEnvMut<'_, T> {
+    /// Returns a reference to the host state in this function environement.
+    pub fn data(&self) -> &T {
+        self.func_env.as_ref(&self.store_mut)
+    }
+
+    /// Returns a mutable- reference to the host state in this function environement.
+    pub fn data_mut(&mut self) -> &mut T {
+        self.func_env.as_mut(&mut self.store_mut)
+    }
+
+    /// Borrows a new immmutable reference
+    pub fn as_ref(&self) -> FunctionEnv<T> {
+        self.func_env.clone()
+    }
+
+    /// Borrows a new mutable reference
+    pub fn as_mut(&mut self) -> FunctionEnvMut<'_, T> {
+        FunctionEnvMut {
+            store_mut: self.store_mut.as_store_mut(),
+            func_env: self.func_env.clone(),
+        }
+    }
+
+    /// Borrows a new mutable reference of both the attached Store and host state
+    pub fn data_and_store_mut(&mut self) -> (&mut T, StoreMut) {
+        let data = self.func_env.as_mut(&mut self.store_mut) as *mut T;
+        // telling the borrow check to close his eyes here
+        // this is still relatively safe to do as func_env are
+        // stored in a specific vec of Store, separate from the other objects
+        // and not really directly accessible with the StoreMut
+        let data = unsafe { &mut *data };
+        (data, self.store_mut.as_store_mut())
+    }
+}
+
+//impl<T> Into<crate::FunctionEnv<T>> for FunctionEnv<T> {
+//    fn into(self) -> crate::FunctionEnv<T> {
+//        crate::FunctionEnv::Wamr(self)
+//    }
+//}
+
+impl<T> AsStoreRef for FunctionEnvMut<'_, T> {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        StoreRef {
+            inner: self.store_mut.inner,
+        }
+    }
+}
+
+impl<T> AsStoreMut for FunctionEnvMut<'_, T> {
+    fn as_store_mut(&mut self) -> StoreMut<'_> {
+        StoreMut {
+            inner: self.store_mut.inner,
+        }
+    }
+
+    fn objects_mut(&mut self) -> &mut crate::StoreObjects {
+        self.store_mut.objects_mut()
+    }
+}
+
+impl<T> crate::FunctionEnv<T> {
+    /// Consume [`self`] into [`crate::backend::wamr::function::env::FunctionEnv`].
+    pub fn into_wamr(self) -> FunctionEnv<T> {
+        match self.0 {
+            crate::BackendFunctionEnv::Wamr(s) => s,
+            _ => panic!("Not a `wamr` function env!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference to [`crate::backend::wamr::function::env::FunctionEnv`].
+    pub fn as_wamr(&self) -> &FunctionEnv<T> {
+        match self.0 {
+            crate::BackendFunctionEnv::Wamr(ref s) => s,
+            _ => panic!("Not a `wamr` function env!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wamr::function::env::FunctionEnv`].
+    pub fn as_wamr_mut(&mut self) -> &mut FunctionEnv<T> {
+        match self.0 {
+            crate::BackendFunctionEnv::Wamr(ref mut s) => s,
+            _ => panic!("Not a `wamr` function env!"),
+        }
+    }
+}
+
+impl<'a, T> From<FunctionEnvMut<'a, T>> for crate::FunctionEnvMut<'a, T> {
+    fn from(value: FunctionEnvMut<'a, T>) -> Self {
+        crate::FunctionEnvMut(crate::BackendFunctionEnvMut::Wamr(value))
+    }
+}
+
+impl<T> From<FunctionEnv<T>> for crate::FunctionEnv<T> {
+    fn from(value: FunctionEnv<T>) -> Self {
+        crate::FunctionEnv(crate::BackendFunctionEnv::Wamr(value))
+    }
+}
diff --git a/lib/api/src/backend/wamr/entities/function/mod.rs b/lib/api/src/backend/wamr/entities/function/mod.rs
new file mode 100644
index 0000000000..3e4bbf6605
--- /dev/null
+++ b/lib/api/src/backend/wamr/entities/function/mod.rs
@@ -0,0 +1,712 @@
+//! Data types, functions and traits for `wamr`'s `Function` implementation.
+
+#![allow(non_snake_case)]
+use std::{
+    ffi::c_void,
+    panic::{self, AssertUnwindSafe},
+};
+
+use crate::{
+    vm::{VMExtern, VMExternFunction},
+    wamr::{
+        bindings::*,
+        utils::convert::{IntoCApiType, IntoCApiValue, IntoWasmerType, IntoWasmerValue},
+        vm::{VMFuncRef, VMFunction, VMFunctionCallback, VMFunctionEnvironment},
+    },
+    AsStoreMut, AsStoreRef, BackendFunction, BackendFunctionEnvMut, BackendTrap,
+    FromToNativeWasmType, FunctionEnv, FunctionEnvMut, IntoResult, NativeWasmType,
+    NativeWasmTypeInto, RuntimeError, StoreMut, Value, WasmTypeList, WithEnv, WithoutEnv,
+};
+
+use super::{super::error::Trap, store::StoreHandle};
+use wasmer_types::{FunctionType, RawValue};
+
+pub(crate) mod env;
+pub(crate) mod typed;
+
+pub use typed::*;
+
+type CCallback = unsafe extern "C" fn(
+    *mut c_void,
+    *const wasm_val_vec_t,
+    *mut wasm_val_vec_t,
+) -> *mut wasm_trap_t;
+
+#[derive(Clone, PartialEq, Eq)]
+/// A WebAssembly `function` in `wamr`.
+pub struct Function {
+    pub(crate) handle: VMFunction,
+}
+
+unsafe impl Send for Function {}
+unsafe impl Sync for Function {}
+
+impl From<VMFunction> for Function {
+    fn from(handle: VMFunction) -> Self {
+        Self { handle }
+    }
+}
+
+pub(crate) struct FunctionCallbackEnv<'a, F> {
+    pub(crate) store: StoreMut<'a>,
+    pub(crate) func: F,
+    pub(crate) env_handle: Option<StoreHandle<VMFunctionEnvironment>>,
+}
+
+impl<'a, F> std::fmt::Debug for FunctionCallbackEnv<'a, F> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("FunctionCallbackEnv")
+            .field("env_is_some", &self.env_handle.is_some())
+            .finish()
+    }
+}
+
+impl Function {
+    /// To `VMExtern`.
+    pub fn to_vm_extern(&self) -> VMExtern {
+        let extern_ = unsafe { wasm_func_as_extern(self.handle) };
+        assert!(
+            !extern_.is_null(),
+            "Returned null Function extern from wasm-c-api"
+        );
+        VMExtern::Wamr(extern_)
+    }
+
+    #[allow(clippy::cast_ptr_alignment)]
+    pub fn new_with_env<FT, F, T: Send + 'static>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        ty: FT,
+        func: F,
+    ) -> Self
+    where
+        FT: Into<FunctionType>,
+        F: Fn(FunctionEnvMut<'_, T>, &[Value]) -> Result<Vec<Value>, RuntimeError>
+            + 'static
+            + Send
+            + Sync,
+    {
+        let fn_ty: FunctionType = ty.into();
+        let params = fn_ty.params();
+
+        let mut param_types = params
+            .into_iter()
+            .map(|param| {
+                let kind = param.into_ct();
+                unsafe { wasm_valtype_new(kind) }
+            })
+            .collect::<Vec<_>>();
+
+        let mut wasm_param_types = unsafe {
+            let mut vec = Default::default();
+            wasm_valtype_vec_new(&mut vec, param_types.len(), param_types.as_ptr());
+            vec
+        };
+
+        let results = fn_ty.results();
+        let mut result_types = results
+            .into_iter()
+            .map(|param| {
+                let kind = param.into_ct();
+                unsafe { wasm_valtype_new(kind) }
+            })
+            .collect::<Vec<_>>();
+
+        let mut wasm_result_types = unsafe {
+            let mut vec = Default::default();
+            wasm_valtype_vec_new(&mut vec, result_types.len(), result_types.as_ptr());
+            vec
+        };
+
+        let wasm_functype = unsafe {
+            wasm_functype_new(
+                &mut wasm_param_types as *mut _,
+                &mut wasm_result_types as *mut _,
+            )
+        };
+
+        let mut store = store.as_store_mut();
+        let inner = store.inner.store.as_wamr().inner;
+
+        let callback: CCallback = make_fn_callback(&func, param_types.len());
+
+        let mut callback_env: *mut FunctionCallbackEnv<'_, F> =
+            Box::leak(Box::new(FunctionCallbackEnv {
+                store,
+                func,
+                env_handle: Some(env.as_wamr().handle.clone()),
+            }));
+
+        let wasm_function = unsafe {
+            wasm_func_new_with_env(
+                inner,
+                wasm_functype,
+                Some(callback),
+                callback_env as *mut _ as _,
+                None,
+            )
+        };
+
+        if wasm_function.is_null() {
+            panic!("failed when creating new typed function");
+        }
+
+        Function {
+            handle: wasm_function,
+        }
+    }
+
+    /// Creates a new host `Function` from a native function.
+    pub fn new_typed<F, Args, Rets>(store: &mut impl AsStoreMut, func: F) -> Self
+    where
+        F: crate::HostFunction<(), Args, Rets, WithoutEnv> + 'static + Send + Sync,
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+    {
+        let mut param_types = Args::wasm_types()
+            .into_iter()
+            .map(|param| {
+                let kind = param.into_ct();
+                unsafe { wasm_valtype_new(kind) }
+            })
+            .collect::<Vec<_>>();
+
+        let mut wasm_param_types = unsafe {
+            let mut vec = Default::default();
+            wasm_valtype_vec_new(&mut vec, param_types.len(), param_types.as_ptr());
+            vec
+        };
+
+        let mut result_types = Rets::wasm_types()
+            .into_iter()
+            .map(|param| {
+                let kind = param.into_ct();
+                unsafe { wasm_valtype_new(kind) }
+            })
+            .collect::<Vec<_>>();
+
+        let mut wasm_result_types = unsafe {
+            let mut vec = Default::default();
+            wasm_valtype_vec_new(&mut vec, result_types.len(), result_types.as_ptr());
+            vec
+        };
+
+        let wasm_functype =
+            unsafe { wasm_functype_new(&mut wasm_param_types, &mut wasm_result_types) };
+
+        let mut store = store.as_store_mut();
+        let inner = store.inner.store.as_wamr().inner;
+
+        let callback: CCallback = unsafe {
+            std::mem::transmute(func.function_callback(crate::BackendKind::Wamr).into_wamr())
+        };
+
+        let mut callback_env: *mut FunctionCallbackEnv<'_, F> =
+            Box::into_raw(Box::new(FunctionCallbackEnv {
+                store,
+                func,
+                env_handle: None,
+            }));
+
+        let wasm_function = unsafe {
+            wasm_func_new_with_env(
+                inner,
+                wasm_functype,
+                Some(callback),
+                callback_env as _,
+                None,
+            )
+        };
+
+        if wasm_function.is_null() {
+            panic!("failed when creating new typed function");
+        }
+
+        Function {
+            handle: wasm_function,
+        }
+    }
+
+    pub fn new_typed_with_env<T, F, Args, Rets>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        func: F,
+    ) -> Self
+    where
+        F: crate::HostFunction<T, Args, Rets, WithEnv>,
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+        T: Send + 'static,
+    {
+        let mut param_types = Args::wasm_types()
+            .into_iter()
+            .map(|param| {
+                let kind = param.into_ct();
+                unsafe { wasm_valtype_new(kind) }
+            })
+            .collect::<Vec<_>>();
+
+        let mut wasm_param_types = unsafe {
+            let mut vec = wasm_valtype_vec_t::default();
+            wasm_valtype_vec_new(&mut vec, param_types.len(), param_types.as_ptr());
+            vec
+        };
+
+        let mut result_types = Rets::wasm_types()
+            .into_iter()
+            .map(|param| {
+                let kind = param.into_ct();
+                unsafe { wasm_valtype_new(kind) }
+            })
+            .collect::<Vec<_>>();
+
+        let mut wasm_result_types = unsafe {
+            let mut vec: wasm_valtype_vec_t = Default::default();
+            wasm_valtype_vec_new(&mut vec, result_types.len(), result_types.as_ptr());
+            vec
+        };
+
+        let wasm_functype = unsafe {
+            wasm_functype_new(
+                &mut wasm_param_types as *mut _,
+                &mut wasm_result_types as *mut _,
+            )
+        };
+
+        let mut store = store.as_store_mut();
+        let inner = store.inner.store.as_wamr().inner;
+
+        let callback: CCallback = unsafe {
+            std::mem::transmute(func.function_callback(crate::BackendKind::Wamr).into_wamr())
+        };
+
+        let mut callback_env: *mut FunctionCallbackEnv<'_, F> =
+            Box::into_raw(Box::new(FunctionCallbackEnv {
+                store,
+                func,
+                env_handle: Some(env.as_wamr().handle.clone()),
+            }));
+
+        let wasm_function = unsafe {
+            wasm_func_new_with_env(
+                inner,
+                wasm_functype,
+                Some(callback),
+                callback_env as _,
+                None,
+            )
+        };
+
+        if wasm_function.is_null() {
+            panic!("failed when creating new typed function");
+        }
+
+        Function {
+            handle: wasm_function,
+        }
+    }
+
+    pub fn ty(&self, _store: &impl AsStoreRef) -> FunctionType {
+        let type_ = unsafe { wasm_func_type(self.handle) };
+        let params: *const wasm_valtype_vec_t = unsafe { wasm_functype_params(type_) };
+        let returns: *const wasm_valtype_vec_t = unsafe { wasm_functype_results(type_) };
+
+        let params: Vec<wasmer_types::Type> = unsafe {
+            let mut res = vec![];
+            for i in 0..(*params).size {
+                res.push((*(*params).data.wrapping_add(i)).into_wt());
+            }
+            res
+        };
+
+        let returns: Vec<wasmer_types::Type> = unsafe {
+            let mut res = vec![];
+            for i in 0..(*returns).size {
+                res.push((*(*returns).data.wrapping_add(i)).into_wt());
+            }
+            res
+        };
+
+        FunctionType::new(params, returns)
+    }
+
+    pub fn call_raw(
+        &self,
+        _store: &mut impl AsStoreMut,
+        _params: Vec<RawValue>,
+    ) -> Result<Box<[Value]>, RuntimeError> {
+        // There is no optimal call_raw in JSC, so we just
+        // simply rely the call
+        // self.call(store, params)
+        unimplemented!();
+    }
+
+    pub fn call(
+        &self,
+        store: &mut impl AsStoreMut,
+        params: &[Value],
+    ) -> Result<Box<[Value]>, RuntimeError> {
+        // unimplemented!();
+        let store_mut = store.as_store_mut();
+        // let wasm_func_param_arity(self.handle)
+
+        let mut args = {
+            unsafe {
+                let mut wasm_params = params
+                    .into_iter()
+                    .map(|v| IntoCApiValue::into_cv(v.clone()))
+                    .collect::<Vec<_>>()
+                    .into_boxed_slice();
+                let mut vec = Default::default();
+                wasm_val_vec_new(&mut vec, wasm_params.len(), wasm_params.as_ptr());
+                vec
+            }
+        };
+
+        let size = unsafe { wasm_func_result_arity(self.handle) };
+
+        let mut results = {
+            unsafe {
+                let mut vec = Default::default();
+                wasm_val_vec_new_uninitialized(&mut vec, size);
+                vec
+            }
+        };
+
+        let mut trap;
+
+        loop {
+            trap = unsafe { wasm_func_call(self.handle, &mut args as _, &mut results as *mut _) };
+            let store_mut = store.as_store_mut();
+            if let Some(callback) = store_mut.inner.on_called.take() {
+                match callback(store_mut) {
+                    Ok(wasmer_types::OnCalledAction::InvokeAgain) => {
+                        continue;
+                    }
+                    Ok(wasmer_types::OnCalledAction::Finish) => {
+                        break;
+                    }
+                    Ok(wasmer_types::OnCalledAction::Trap(trap)) => {
+                        return Err(RuntimeError::user(trap))
+                    }
+                    Err(trap) => return Err(RuntimeError::user(trap)),
+                }
+            }
+            break;
+        }
+
+        if !trap.is_null() {
+            return Err(Into::<Trap>::into(trap).into());
+        }
+
+        unsafe {
+            let results = std::ptr::slice_from_raw_parts(results.data, results.size);
+            return Ok((*results)
+                .into_iter()
+                .map(|v| IntoWasmerValue::into_wv(*v))
+                .collect::<Vec<_>>()
+                .into_boxed_slice());
+        }
+    }
+
+    pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, internal: VMExternFunction) -> Self {
+        Self {
+            handle: internal.into_wamr(),
+        }
+    }
+
+    pub(crate) fn vm_funcref(&self, _store: &impl AsStoreRef) -> VMFuncRef {
+        unimplemented!();
+    }
+
+    pub(crate) unsafe fn from_vm_funcref(
+        _store: &mut impl AsStoreMut,
+        _funcref: VMFuncRef,
+    ) -> Self {
+        unimplemented!();
+    }
+
+    /// Checks whether this `Function` can be used with the given context.
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
+
+fn make_fn_callback<F, T: Send + 'static>(func: &F, args: usize) -> CCallback
+where
+    F: Fn(FunctionEnvMut<'_, T>, &[Value]) -> Result<Vec<Value>, RuntimeError>
+        + 'static
+        + Send
+        + Sync,
+{
+    unsafe extern "C" fn fn_callback<F, T: Send + 'static>(
+        env: *mut c_void,
+        args: *const wasm_val_vec_t,
+        rets: *mut wasm_val_vec_t,
+    ) -> *mut wasm_trap_t
+    where
+        F: Fn(FunctionEnvMut<'_, T>, &[Value]) -> Result<Vec<Value>, RuntimeError>
+            + 'static
+            + Send
+            + Sync,
+    {
+        let r: *mut (FunctionCallbackEnv<'_, F>) = env as _;
+
+        let mut store = (*r).store.as_store_mut();
+        let env_handle = (*r).env_handle.as_ref().unwrap().clone();
+        let mut fn_env = env::FunctionEnv::from_handle(env_handle).into_mut(&mut store);
+        let func: &F = &(*r).func;
+
+        let mut wasmer_args = vec![];
+
+        for i in 0..(*args).size {
+            wasmer_args.push((*(*args).data.wrapping_add(i)).into_wv().clone());
+        }
+
+        let result = panic::catch_unwind(AssertUnwindSafe(|| unsafe {
+            func(fn_env.into(), wasmer_args.as_slice())
+        }));
+
+        match result {
+            Ok(Ok(native_results)) => {
+                let mut c_results: Vec<wasm_val_t> = native_results
+                    .into_iter()
+                    .map(IntoCApiValue::into_cv)
+                    .collect();
+
+                if c_results.len() != (*rets).size {
+                    panic!("when calling host function: number of observed results differ from wanted results")
+                }
+
+                unsafe {
+                    for i in 0..(*rets).size {
+                        *((*rets).data.wrapping_add(i)) = c_results[i]
+                    }
+                }
+
+                unsafe { std::ptr::null_mut() }
+            }
+
+            Ok(Err(e)) => {
+                let trap: Trap = Trap::user(Box::new(e));
+                unsafe { trap.into_wasm_trap(&mut store) }
+            }
+
+            Err(e) => {
+                unimplemented!("host function panicked");
+            }
+        }
+    }
+
+    return fn_callback::<F, T>;
+}
+
+impl std::fmt::Debug for Function {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.debug_struct("Function").finish()
+    }
+}
+
+impl crate::Function {
+    /// Consume [`self`] into [`crate::backend::wamr::function::Function`].
+    pub fn into_wamr(self) -> crate::backend::wamr::function::Function {
+        match self.0 {
+            BackendFunction::Wamr(s) => s,
+            _ => panic!("Not a `wamr` function!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference to [`crate::backend::wamr::function::Function`].
+    pub fn as_wamr(&self) -> &crate::backend::wamr::function::Function {
+        match self.0 {
+            BackendFunction::Wamr(ref s) => s,
+            _ => panic!("Not a `wamr` function!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wamr::function::Function`].
+    pub fn as_wamr_mut(&mut self) -> &mut crate::backend::wamr::function::Function {
+        match self.0 {
+            BackendFunction::Wamr(ref mut s) => s,
+            _ => panic!("Not a `wamr` function!"),
+        }
+    }
+}
+
+macro_rules! impl_host_function {
+    ([$c_struct_representation:ident] $c_struct_name:ident, $( $x:ident ),* ) => {
+        paste::paste! {
+        #[allow(non_snake_case)]
+        pub(crate) fn [<gen_fn_callback_ $c_struct_name:lower _no_env>]
+            <$( $x: FromToNativeWasmType, )* Rets: WasmTypeList, RetsAsResult: IntoResult<Rets>, Func: Fn($( $x , )*) -> RetsAsResult + 'static>
+            (this: &Func) -> crate::backend::wamr::vm::VMFunctionCallback {
+
+            /// This is a function that wraps the real host
+            /// function. Its address will be used inside the
+            /// runtime.
+            unsafe extern "C" fn func_wrapper<$( $x, )* Rets, RetsAsResult, Func>(env: *mut c_void, args: *const wasm_val_vec_t, results: *mut wasm_val_vec_t) -> *mut wasm_trap_t
+            where
+                $( $x: FromToNativeWasmType, )*
+                Rets: WasmTypeList,
+                RetsAsResult: IntoResult<Rets>,
+                Func: Fn($( $x , )*) -> RetsAsResult + 'static,
+            {
+                let mut r: *mut crate::backend::wamr::function::FunctionCallbackEnv<Func> = unsafe {std::mem::transmute(env)};
+                let store = &mut (*r).store.as_store_mut();
+                let mut i = 0;
+
+                $(
+                    let c_arg = (*(*args).data.wrapping_add(i)).clone();
+                    let wasmer_arg = c_arg.into_wv();
+                    let raw_arg : RawValue = wasmer_arg.as_raw(store);
+                    let $x : $x = FromToNativeWasmType::from_native($x::Native::from_raw(store, raw_arg));
+
+                    i += 1;
+                )*
+
+                let result = panic::catch_unwind(AssertUnwindSafe(|| unsafe {
+                    ((*r).func)( $( $x, )* ).into_result()
+                }));
+
+                match result {
+                    Ok(Ok(result)) => {
+
+                        let types = Rets::wasm_types();
+                        let mut native_results = result.into_array(store);
+                        let native_results = native_results.as_mut();
+
+                        let native_results: Vec<Value> = native_results.into_iter().enumerate()
+                            .map(|(i, r)| Value::from_raw(store, types[i], r.clone()))
+                            .collect();
+
+                        let mut c_results: Vec<wasm_val_t> = native_results.into_iter().map(IntoCApiValue::into_cv).collect();
+
+                        if c_results.len() != (*results).size {
+                            panic!("when calling host function: number of observed results differ from wanted results")
+                        }
+
+                        unsafe {
+                            for i in 0..(*results).size {
+                                *((*results).data.wrapping_add(i)) = c_results[i]
+                            }
+                        }
+
+                         unsafe { std::ptr::null_mut() }
+                    },
+
+                    Ok(Err(e)) => {
+                        let trap =  crate::backend::wamr::error::Trap::user(Box::new(e));
+                        unsafe { trap.into_wasm_trap(store) }
+                        // unimplemented!("host function panicked");
+                    },
+
+                    Err(e) => {
+                        unimplemented!("host function panicked");
+                    }
+                }
+            }
+            func_wrapper::< $( $x, )* Rets, RetsAsResult, Func> as _
+        }
+
+
+        #[allow(non_snake_case)]
+        pub(crate) fn [<gen_fn_callback_ $c_struct_name:lower>]
+            <$( $x: FromToNativeWasmType, )* Rets: WasmTypeList, RetsAsResult: IntoResult<Rets>, T: Send + 'static,  Func: Fn(FunctionEnvMut<T>, $( $x , )*) -> RetsAsResult + 'static>
+            (this: &Func) -> crate::backend::wamr::vm::VMFunctionCallback {
+            unsafe extern "C" fn func_wrapper<$( $x, )* Rets, RetsAsResult, Func, T>(env: *mut c_void, args: *const wasm_val_vec_t, results: *mut wasm_val_vec_t) -> *mut wasm_trap_t
+	        where
+	          $( $x: FromToNativeWasmType, )*
+	          Rets: WasmTypeList,
+	          RetsAsResult: IntoResult<Rets>,
+	          T: Send + 'static,
+	          Func: Fn(FunctionEnvMut<'_, T>, $( $x , )*) -> RetsAsResult + 'static,
+            {
+
+	          let r: *mut (crate::backend::wamr::function::FunctionCallbackEnv<'_, Func>) = env as _;
+	          let store = &mut (*r).store.as_store_mut();
+
+	          let mut i = 0;
+
+	          $(
+	          let c_arg = (*(*args).data.wrapping_add(i)).clone();
+	          let wasmer_arg = c_arg.into_wv();
+	          let raw_arg : RawValue = wasmer_arg.as_raw(store);
+	          let $x : $x = FromToNativeWasmType::from_native($x::Native::from_raw(store, raw_arg));
+
+	          i += 1;
+              )*
+
+	          let env_handle = (*r).env_handle.as_ref().unwrap().clone();
+	          let mut fn_env = crate::backend::wamr::function::env::FunctionEnv::from_handle(env_handle).into_mut(store);
+	          let func: &Func = &(*r).func;
+
+	          let result = panic::catch_unwind(AssertUnwindSafe(|| unsafe {
+	              ((*r).func)(BackendFunctionEnvMut::Wamr(fn_env).into(), $( $x, )* ).into_result()
+	          }));
+
+
+	          match result {
+	              Ok(Ok(result)) => {
+	          	  let types = Rets::wasm_types();
+	          	  let mut native_results = result.into_array(store);
+	          	  let native_results = native_results.as_mut();
+
+	          	  let native_results: Vec<Value> = native_results.into_iter().enumerate().map(|(i, r)| Value::from_raw(store, types[i], r.clone())).collect();
+
+	          	  let mut c_results: Vec<wasm_val_t> = native_results.into_iter().map(IntoCApiValue::into_cv).collect();
+
+	          	  if c_results.len() != (*results).size {
+	          	      panic!("when calling host function: number of observed results differ from wanted results")
+	          	  }
+
+	          	  unsafe {
+	          	      for i in 0..(*results).size {
+	          	          *((*results).data.wrapping_add(i)) = c_results[i]
+	          	      }
+
+	          	  }
+
+	          	  unsafe { std::ptr::null_mut() }
+	            },
+
+	            Ok(Err(e)) => { let trap = crate::backend::wamr::error::Trap::user(Box::new(e)); unsafe { trap.into_wasm_trap(store) } },
+
+	            Err(e) => { unimplemented!("host function panicked"); }
+	          }
+	        }
+
+	        func_wrapper::< $( $x, )* Rets, RetsAsResult, Func, T> as _
+        }
+        }
+    };
+}
+
+// Here we go! Let's generate all the C struct, `WasmTypeList`
+// implementations and `HostFunction` implementations.
+impl_host_function!([C] S0,);
+impl_host_function!([transparent] S1, A1);
+impl_host_function!([C] S2, A1, A2);
+impl_host_function!([C] S3, A1, A2, A3);
+impl_host_function!([C] S4, A1, A2, A3, A4);
+impl_host_function!([C] S5, A1, A2, A3, A4, A5);
+impl_host_function!([C] S6, A1, A2, A3, A4, A5, A6);
+impl_host_function!([C] S7, A1, A2, A3, A4, A5, A6, A7);
+impl_host_function!([C] S8, A1, A2, A3, A4, A5, A6, A7, A8);
+impl_host_function!([C] S9, A1, A2, A3, A4, A5, A6, A7, A8, A9);
+impl_host_function!([C] S10, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+impl_host_function!([C] S11, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
+impl_host_function!([C] S12, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
+impl_host_function!([C] S13, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
+impl_host_function!([C] S14, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
+impl_host_function!([C] S15, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
+impl_host_function!([C] S16, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16);
+impl_host_function!([C] S17, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17);
+impl_host_function!([C] S18, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18);
+impl_host_function!([C] S19, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19);
+impl_host_function!([C] S20, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20);
+impl_host_function!([C] S21, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21);
+impl_host_function!([C] S22, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22);
+impl_host_function!([C] S23, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23);
+impl_host_function!([C] S24, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24);
+impl_host_function!([C] S25, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25);
+impl_host_function!([C] S26, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26);
diff --git a/lib/api/src/backend/wamr/entities/function/typed.rs b/lib/api/src/backend/wamr/entities/function/typed.rs
new file mode 100644
index 0000000000..c40acd82cb
--- /dev/null
+++ b/lib/api/src/backend/wamr/entities/function/typed.rs
@@ -0,0 +1,147 @@
+//! Native Functions.
+//!
+//! This module creates the helper `TypedFunction` that let us call WebAssembly
+//! functions with the native ABI, that is:
+//!
+//! ```ignore
+//! let add_one = instance.exports.get_function("function_name")?;
+//! let add_one_native: TypedFunction<i32, i32> = add_one.typed().unwrap();
+//! ```
+
+use std::iter::FromIterator;
+
+use crate::{
+    backend::wamr::{bindings::*, error::Trap, function::Function, utils::convert::*},
+    AsStoreMut, FromToNativeWasmType, NativeWasmType, NativeWasmTypeInto, RuntimeError,
+    TypedFunction, Value, WasmTypeList,
+};
+use wasmer_types::RawValue;
+
+macro_rules! impl_native_traits {
+    (  $( $x:ident ),* ) => {
+        #[allow(unused_parens, non_snake_case)]
+         impl<$( $x , )* Rets> TypedFunction<( $( $x ),* ), Rets>
+         where
+             $( $x: FromToNativeWasmType, )*
+             Rets: WasmTypeList,
+         {
+             /// Call the typed func and return results.
+            #[allow(clippy::too_many_arguments)]
+            pub fn call_wamr(&self, mut store: &mut impl AsStoreMut, $( $x: $x, )* ) -> Result<Rets, RuntimeError> where
+            $( $x: FromToNativeWasmType, )*
+            {
+
+                 // // let store_ptr = Value::I64(store.as_store_mut().as_raw() as _).as_jsvalue(store);
+                 #[allow(unused_unsafe)]
+                 let params_list: Vec<_> = unsafe {
+                     vec![ $( {
+                         let raw = $x.to_native().into_raw(store);
+                         let value = Value::from_raw(&mut store, <$x::Native as NativeWasmType>::WASM_TYPE, raw);
+                         value.into_cv()
+                     } ),* ]
+                 };
+
+                 let mut results = {
+                    unsafe {
+                        let mut ret = std::mem::zeroed();
+                        wasm_val_vec_new_uninitialized(&mut ret, Rets::wasm_types().len());
+                        ret
+                    }
+                };
+
+
+                 let func = unsafe { wasm_extern_as_func(self.func.to_vm_extern().into_wamr()) };
+
+                let mut params = unsafe {std::mem::zeroed()};
+                unsafe {wasm_val_vec_new(&mut params, params_list.len(), params_list.as_ptr())};
+
+                 let mut trap;
+
+                 loop {
+                    trap = unsafe { wasm_func_call(func, &params, &mut results) };
+
+                    let store_mut = store.as_store_mut();
+                    if let Some(callback) = store_mut.inner.on_called.take() {
+                        match callback(store_mut) {
+                            Ok(wasmer_types::OnCalledAction::InvokeAgain) => { continue; }
+                            Ok(wasmer_types::OnCalledAction::Finish) => { break; }
+                            Ok(wasmer_types::OnCalledAction::Trap(trap)) => { return Err(RuntimeError::user(trap)) },
+                            Err(trap) => { return Err(RuntimeError::user(trap)) },
+                        }
+                    }
+                    break;
+                };
+
+
+
+                 if !trap.is_null() {
+                     unsafe {
+                        let trap: Trap = trap.into();
+                        return Err(RuntimeError::from(trap));
+                     }
+                }
+
+                unsafe {
+                    let mut rets_list_array = Rets::empty_array();
+                    let mut_rets = rets_list_array.as_mut() as *mut [RawValue] as *mut RawValue;
+
+                    match Rets::size() {
+                        0 => {},
+                        1 => {
+                            let val = (*results.data.wrapping_add(0)).clone();
+                            let val = val.into_wv();
+                            *mut_rets = val.as_raw(&mut store);
+                        }
+                        _n => {
+                            for (i, ret_type) in Rets::wasm_types().iter().enumerate() {
+                                    let val = (*results.data.wrapping_add(i)).clone();
+                                    let val = val.into_wv();
+                                    let slot = mut_rets.add(i);
+                                    *slot = val.as_raw(&mut store);
+                            }
+                        }
+                    }
+
+                    Ok(unsafe { Rets::from_array(store, rets_list_array) })
+                }
+            }
+
+            #[doc(hidden)]
+            #[allow(missing_docs)]
+            #[allow(unused_mut)]
+            #[allow(clippy::too_many_arguments)]
+            pub fn call_raw_wamr(&self, store: &mut impl AsStoreMut, mut params_list: Vec<RawValue> ) -> Result<Rets, RuntimeError> {
+                todo!("Raw calls from wamr are not supported yet!")
+            }
+        }
+    };
+
+}
+
+impl_native_traits!();
+impl_native_traits!(A1);
+impl_native_traits!(A1, A2);
+impl_native_traits!(A1, A2, A3);
+impl_native_traits!(A1, A2, A3, A4);
+impl_native_traits!(A1, A2, A3, A4, A5);
+impl_native_traits!(A1, A2, A3, A4, A5, A6);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17);
+impl_native_traits!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18
+);
+impl_native_traits!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19
+);
+impl_native_traits!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20
+);
diff --git a/lib/api/src/backend/wamr/entities/global.rs b/lib/api/src/backend/wamr/entities/global.rs
new file mode 100644
index 0000000000..51ae7c87ae
--- /dev/null
+++ b/lib/api/src/backend/wamr/entities/global.rs
@@ -0,0 +1,122 @@
+//! Data types, functions and traits for `wamr`'s `Global` implementation.
+use wasmer_types::{GlobalType, Mutability};
+
+use crate::{
+    vm::{VMExtern, VMExternGlobal},
+    wamr::{
+        bindings::{
+            self, wasm_global_as_extern, wasm_global_get, wasm_global_new, wasm_global_set,
+            wasm_global_type, wasm_globaltype_content, wasm_globaltype_mutability,
+            wasm_globaltype_new, wasm_mutability_t, wasm_valtype_new,
+        },
+        utils::convert::{IntoCApiType, IntoCApiValue, IntoWasmerType, IntoWasmerValue},
+        vm::VMGlobal,
+    },
+    AsStoreMut, AsStoreRef, RuntimeError, Value,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// A WebAssembly `global` in `wamr`.
+pub struct Global {
+    pub(crate) handle: VMGlobal,
+}
+
+unsafe impl Send for Global {}
+unsafe impl Sync for Global {}
+
+// Global can't be Send in js because it dosen't support `structuredClone`
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// unsafe impl Send for Global {}
+
+impl Global {
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        let extern_ = unsafe { wasm_global_as_extern(self.handle) };
+        assert!(
+            !extern_.is_null(),
+            "Returned null Global extern from wasm-c-api"
+        );
+        VMExtern::Wamr(extern_)
+    }
+
+    /// Create a `Global` with the initial value [`Value`] and the provided [`Mutability`].
+    pub(crate) fn from_value(
+        store: &mut impl AsStoreMut,
+        val: Value,
+        mutability: Mutability,
+    ) -> Result<Self, RuntimeError> {
+        let store = store.as_store_mut();
+
+        let wamr_type = val.ty().into_ct();
+        let wamr_value = val.into_cv();
+        let wamr_mutability = if mutability.is_mutable() {
+            bindings::wasm_mutability_enum_WASM_VAR
+        } else {
+            bindings::wasm_mutability_enum_WASM_CONST
+        } as wasm_mutability_t;
+
+        let wamr_global_type =
+            unsafe { wasm_globaltype_new(wasm_valtype_new(wamr_type), wamr_mutability) };
+
+        Ok(Self {
+            handle: unsafe {
+                wasm_global_new(
+                    store.inner.store.as_wamr().inner,
+                    wamr_global_type,
+                    &wamr_value,
+                )
+            },
+        })
+    }
+
+    pub fn ty(&self, _store: &impl AsStoreRef) -> GlobalType {
+        let r#type = unsafe { wasm_global_type(self.handle) };
+        let mutability = unsafe { wasm_globaltype_mutability(&*r#type) };
+        let valtype = unsafe { wasm_globaltype_content(r#type) };
+        let wasmer_type = valtype.into_wt();
+
+        GlobalType::new(
+            wasmer_type,
+            if mutability == bindings::wasm_mutability_enum_WASM_VAR as u8 {
+                Mutability::Var
+            } else {
+                Mutability::Const
+            },
+        )
+    }
+
+    pub fn get(&self, store: &mut impl AsStoreMut) -> Value {
+        let mut out = unsafe { std::mem::zeroed() };
+        unsafe { wasm_global_get(self.handle, &mut out) };
+        out.into_wv()
+    }
+
+    pub fn set(&self, store: &mut impl AsStoreMut, val: Value) -> Result<(), RuntimeError> {
+        if val.ty() != self.ty(store).ty {
+            return Err(RuntimeError::new(format!(
+                "Incompatible types: {} != {}",
+                val.ty(),
+                self.ty(store)
+            )));
+        }
+
+        if self.ty(store).mutability == Mutability::Const {
+            return Err(RuntimeError::new("The global is immutable".to_owned()));
+        }
+
+        let value = val.into_cv();
+
+        unsafe { wasm_global_set(self.handle, &value) };
+
+        Ok(())
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_global: VMExternGlobal) -> Self {
+        Self {
+            handle: vm_global.into_wamr(),
+        }
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
diff --git a/lib/api/src/backend/wamr/entities/instance.rs b/lib/api/src/backend/wamr/entities/instance.rs
new file mode 100644
index 0000000000..30a61b39d0
--- /dev/null
+++ b/lib/api/src/backend/wamr/entities/instance.rs
@@ -0,0 +1,189 @@
+//! Data types, functions and traits for `wamr`'s `Instance` implementation.
+use std::sync::Arc;
+
+use crate::entities::external::VMExternToExtern;
+use crate::{
+    backend::wamr::bindings::*, vm::VMExtern, wamr::error::Trap, AsStoreMut, AsStoreRef, Exports,
+    Extern, Imports, InstantiationError, Module,
+};
+
+#[derive(PartialEq, Eq)]
+pub(crate) struct InstanceHandle(pub(crate) *mut wasm_instance_t);
+
+unsafe impl Send for InstanceHandle {}
+unsafe impl Sync for InstanceHandle {}
+
+impl InstanceHandle {
+    fn new(
+        store: *mut wasm_store_t,
+        module: *mut wasm_module_t,
+        mut externs: Vec<VMExtern>,
+    ) -> Result<Self, InstantiationError> {
+        // Check if the thread env was already initialised.
+        //unsafe {
+        //    if !wasm_runtime_thread_env_inited() {
+        //        if !wasm_runtime_init_thread_env() {
+        //            panic!("Failed to initialize the thread environment!");
+        //        }
+        //    }
+        //}
+
+        let mut trap: *mut wasm_trap_t = std::ptr::null_mut() as _;
+        let externs: Vec<_> = externs.into_iter().map(|v| v.into_wamr()).collect();
+
+        let instance = unsafe {
+            let mut imports = unsafe {
+                let mut vec = Default::default();
+                wasm_extern_vec_new(&mut vec, externs.len(), externs.as_ptr());
+                vec
+            };
+
+            std::mem::forget(externs);
+
+            wasm_instance_new(store, module, &mut imports, &mut trap)
+        };
+
+        if instance.is_null() {
+            let trap = Trap::from(trap);
+            return Err(InstantiationError::Start(trap.into()));
+        }
+
+        Ok(InstanceHandle(instance))
+    }
+
+    fn get_exports(&self, mut store: &mut impl AsStoreMut, module: &Module) -> Exports {
+        let mut c_api_externs = unsafe {
+            let mut vec = Default::default();
+            wasm_instance_exports(self.0, &mut vec);
+            vec
+        };
+
+        let c_api_externs: Vec<*mut wasm_extern_t> = if c_api_externs.data.is_null()
+            || !c_api_externs.data.is_aligned()
+            || c_api_externs.size == 0
+        {
+            vec![]
+        } else {
+            unsafe { std::slice::from_raw_parts(c_api_externs.data, c_api_externs.size) }.to_vec()
+        };
+        let c_api_externs = c_api_externs.to_vec();
+        let mut exports = unsafe {
+            let mut vec = Default::default();
+            wasm_module_exports(module.as_wamr().handle.inner, &mut vec);
+            vec
+        };
+
+        let c_api_exports: Vec<*mut wasm_exporttype_t> =
+            if exports.data.is_null() || !exports.data.is_aligned() || exports.size == 0 {
+                vec![]
+            } else {
+                unsafe { std::slice::from_raw_parts(exports.data, exports.size) }.to_vec()
+            };
+
+        // We need to use the order of the exports from the polyfill info to get the right
+        // one, i.e. the from the declaration.
+        let module_exports = module.exports().collect::<Vec<_>>();
+
+        let c_api_exports: Exports = c_api_exports
+            .into_iter()
+            .zip(c_api_externs.into_iter())
+            .map(|(export, ext)| unsafe {
+                let name = wasm_exporttype_name(export);
+                let name = std::slice::from_raw_parts((*name).data as *const u8, (*name).size);
+                let mut name = name.to_vec();
+                // Remove the '\0' at the end of the NULL-terminated string.
+                name.pop();
+                let name = String::from_utf8(name.to_vec()).unwrap_or_default();
+                let ext = ext.to_extern(&mut store);
+                (name, ext)
+            })
+            .collect();
+
+        let mut exports = Exports::new();
+
+        for e in module_exports {
+            let ext: Extern = c_api_exports
+                .get::<Extern>(e.name())
+                .expect(&format!(
+                    "c_api_exports: {c_api_exports:?} (name: {})",
+                    e.name()
+                ))
+                .clone();
+            exports.insert(e.name().to_string(), ext);
+        }
+
+        exports
+    }
+}
+impl Drop for InstanceHandle {
+    fn drop(&mut self) {
+        unsafe { wasm_instance_delete(self.0) }
+    }
+}
+
+#[derive(Clone, PartialEq, Eq)]
+/// A WebAssembly `instance` in `wamr`.
+pub struct Instance {
+    pub(crate) handle: Arc<InstanceHandle>,
+}
+
+impl Instance {
+    pub(crate) fn new(
+        store: &mut impl AsStoreMut,
+        module: &Module,
+        imports: &Imports,
+    ) -> Result<(Self, Exports), InstantiationError> {
+        let externs = module
+            .imports()
+            .map(|import_ty| {
+                imports
+                    .get_export(import_ty.module(), import_ty.name())
+                    .expect("Extern not found")
+            })
+            .collect::<Vec<_>>();
+
+        _ = store;
+        // Hacky: we need to tie a *module* to a store before instantiating it..
+        let wamr_module = module.as_wamr();
+        let mut store_from_module = wamr_module.handle.store.lock().unwrap();
+        let mut store = store_from_module.as_store_mut();
+
+        return Self::new_by_index(&mut store, module, &externs);
+    }
+
+    pub(crate) fn new_by_index(
+        store: &mut impl AsStoreMut,
+        module: &Module,
+        externs: &[Extern],
+    ) -> Result<(Self, Exports), InstantiationError> {
+        let store_ref = store.as_store_ref();
+        let externs: Vec<VMExtern> = externs
+            .iter()
+            .map(|extern_| extern_.to_vm_extern())
+            .collect::<Vec<_>>();
+
+        let instance = InstanceHandle::new(
+            store_ref.inner.store.as_wamr().inner,
+            module.as_wamr().handle.inner,
+            externs,
+        )?;
+        let exports = instance.get_exports(store, module);
+
+        Ok((
+            Self {
+                handle: Arc::new(instance),
+            },
+            exports,
+        ))
+    }
+}
+
+impl crate::BackendInstance {
+    /// Consume [`self`] into a [`crate::backend::wamr::instance::Instance`].
+    pub(crate) fn into_wamr(self) -> crate::backend::wamr::instance::Instance {
+        match self {
+            Self::Wamr(s) => s,
+            _ => panic!("Not a `wamr` instance"),
+        }
+    }
+}
diff --git a/lib/api/src/jsc/externals/memory.rs b/lib/api/src/backend/wamr/entities/memory/mod.rs
similarity index 52%
rename from lib/api/src/jsc/externals/memory.rs
rename to lib/api/src/backend/wamr/entities/memory/mod.rs
index bcb9361866..c6d2eec24f 100644
--- a/lib/api/src/jsc/externals/memory.rs
+++ b/lib/api/src/backend/wamr/entities/memory/mod.rs
@@ -1,97 +1,94 @@
-use crate::jsc::vm::{VMExtern, VMMemory};
-use crate::mem_access::MemoryAccessError;
-use crate::store::{AsStoreMut, AsStoreRef, StoreObjects};
-use crate::MemoryType;
-use rusty_jsc::{JSObject, JSValue};
-use std::convert::TryInto;
-use std::marker::PhantomData;
-use std::mem::{self, MaybeUninit};
-use std::slice;
+//! Data types, functions and traits for `wamr`'s `Memory` implementation.
+//!
+use std::{marker::PhantomData, mem::MaybeUninit};
 
 use tracing::warn;
+pub use wasmer_types::MemoryError;
+use wasmer_types::{MemoryType, Pages, WASM_PAGE_SIZE};
 
-use wasmer_types::{Pages, WASM_PAGE_SIZE};
-
-use super::memory_view::MemoryView;
+use crate::{
+    shared::SharedMemory,
+    vm::{VMExtern, VMExternMemory},
+    wamr::{bindings::*, vm::VMMemory},
+    AsStoreMut, AsStoreRef, BackendMemory, MemoryAccessError,
+};
 
-pub use wasmer_types::MemoryError;
+pub(crate) mod view;
+pub use view::*;
 
 #[derive(Debug, Clone)]
+/// A WebAssembly `memory` in `wamr`.
 pub struct Memory {
     pub(crate) handle: VMMemory,
 }
 
-// Only SharedMemories can be Send in js, becuase they support `structuredClone`.
-// Normal memories will fail while doing structuredClone.
-// In this case, we implement Send just in case as it can be a shared memory.
-// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
-// ```js
-// const memory = new WebAssembly.Memory({
-//   initial: 10,
-//   maximum: 100,
-//   shared: true // <--- It must be shared, otherwise structuredClone will fail
-// });
-// structuredClone(memory)
-// ```
 unsafe impl Send for Memory {}
 unsafe impl Sync for Memory {}
 
 impl Memory {
     pub fn new(store: &mut impl AsStoreMut, ty: MemoryType) -> Result<Self, MemoryError> {
-        let vm_memory = VMMemory::new(Self::js_memory_from_type(store, &ty)?, ty);
-        Ok(Self::from_vm_extern(store, vm_memory))
-    }
+        let max_requested = ty.maximum.unwrap_or(Pages::max_value());
 
-    pub(crate) fn js_memory_from_type(
-        store: &impl AsStoreRef,
-        ty: &MemoryType,
-    ) -> Result<JSObject, MemoryError> {
-        let store_ref = store.as_store_ref();
-        let engine = store_ref.engine();
-        let context = engine.0.context();
-
-        let mut descriptor = JSObject::new(&context);
-        descriptor.set_property(
-            &context,
-            "initial".to_string(),
-            JSValue::number(&context, ty.minimum.0.into()),
-        );
-        if let Some(max) = ty.maximum {
-            descriptor.set_property(
-                &context,
-                "maximum".to_string(),
-                JSValue::number(&context, max.0.into()),
-            );
+        let min = ty.minimum.0;
+        let max = max_requested.0;
+
+        if max < min {
+            return Err(MemoryError::InvalidMemory {
+                reason: format!("the maximum ({max} pages) is less than the minimum ({min} pages)",),
+            });
+        }
+
+        let max_allowed = Pages::max_value();
+        if max_requested > max_allowed {
+            return Err(MemoryError::MaximumMemoryTooLarge {
+                max_requested,
+                max_allowed,
+            });
         }
-        descriptor.set_property(
-            &context,
-            "shared".to_string(),
-            JSValue::boolean(&context, ty.shared),
-        );
 
-        engine
-            .0
-            .wasm_memory_type()
-            .construct(&context, &[descriptor.to_jsvalue()])
-            .map_err(|e| MemoryError::Generic(format!("{:?}", e)))
+        let limits = Box::into_raw(Box::new(wasm_limits_t { min, max }));
+
+        eprintln!("limits: {limits:?}");
+        let memorytype = unsafe { wasm_memorytype_new(limits) };
+
+        let mut store = store.as_store_mut();
+        let inner = store.inner.store.as_wamr().inner;
+        let c_memory = unsafe { wasm_memory_new(inner, memorytype) };
+
+        Ok(Self { handle: c_memory })
     }
 
     pub fn new_from_existing(new_store: &mut impl AsStoreMut, memory: VMMemory) -> Self {
-        Self::from_vm_extern(new_store, memory)
+        Self { handle: memory }
     }
 
     pub(crate) fn to_vm_extern(&self) -> VMExtern {
-        VMExtern::Memory(self.handle.clone())
+        VMExtern::Wamr(unsafe { wasm_memory_as_extern(self.handle) })
     }
 
     pub fn ty(&self, _store: &impl AsStoreRef) -> MemoryType {
-        self.handle.ty
+        let memory_type: *mut wasm_memorytype_t = unsafe { wasm_memory_type(self.handle) };
+        let limits: *const wasm_limits_t = unsafe { wasm_memorytype_limits(memory_type) };
+
+        MemoryType {
+            // [TODO]: Find a way to extract this from the inner memory type instead
+            // of hardcoding.
+            shared: true,
+            minimum: unsafe { wasmer_types::Pages((*limits).min) },
+            maximum: unsafe { Some(wasmer_types::Pages((*limits).max)) },
+        }
+    }
+
+    pub fn size(&self, store: &impl AsStoreRef) -> Pages {
+        let size = unsafe { wasm_memory_size(self.handle) };
+        Pages(size)
     }
 
     pub fn view<'a>(&self, store: &'a impl AsStoreRef) -> MemoryView<'a> {
         MemoryView::new(self, store)
     }
 
+    // Note: the return value is the memory size (in [`Pages`]) *before* growing it.
     pub fn grow<IntoPages>(
         &self,
         store: &mut impl AsStoreMut,
@@ -100,44 +97,9 @@ impl Memory {
     where
         IntoPages: Into<Pages>,
     {
-        let pages = delta.into();
-
-        let store_mut = store.as_store_mut();
-        let engine = store_mut.engine();
-        let context = engine.0.context();
-        let func = self
-            .handle
-            .memory
-            .get_property(&context, "grow".to_string())
-            .to_object(&context)
-            .unwrap();
-        match func.call(
-            &context,
-            Some(&self.handle.memory),
-            &[JSValue::number(&context, pages.0 as _)],
-        ) {
-            Ok(val) => Ok(Pages(val.to_number(&context).unwrap() as _)),
-            Err(e) => {
-                let old_pages = pages;
-                Err(MemoryError::CouldNotGrow {
-                    current: old_pages,
-                    attempted_delta: pages,
-                })
-            }
-        }
-        // let js_memory = &self.handle.memory;
-        // let our_js_memory: &JSMemory = JsCast::unchecked_from_js_ref(js_memory);
-        // let new_pages = our_js_memory.grow(pages.0).map_err(|err| {
-        //     if err.is_instance_of::<js_sys::RangeError>() {
-        //         MemoryError::CouldNotGrow {
-        //             current: self.view(&store.as_store_ref()).size(),
-        //             attempted_delta: pages,
-        //         }
-        //     } else {
-        //         MemoryError::Generic(err.as_string().unwrap())
-        //     }
-        // })?;
-        // Ok(Pages(new_pages))
+        unimplemented!(
+            "calling grow from host is not supported! Use the memory.grow opcode instead."
+        );
     }
 
     pub fn grow_at_least(
@@ -145,14 +107,9 @@ impl Memory {
         store: &mut impl AsStoreMut,
         min_size: u64,
     ) -> Result<(), MemoryError> {
-        let cur_size = self.view(store).data_size();
-        if min_size > cur_size {
-            let delta = min_size - cur_size;
-            let pages = ((delta - 1) / wasmer_types::WASM_PAGE_SIZE as u64) + 1;
-
-            self.grow(store, Pages(pages as u32))?;
-        }
-        Ok(())
+        unimplemented!(
+            "calling grow from host is not supported! Use the memory.grow opcode instead."
+        );
     }
 
     pub fn reset(&self, _store: &mut impl AsStoreMut) -> Result<(), MemoryError> {
@@ -164,42 +121,49 @@ impl Memory {
         store: &impl AsStoreRef,
         new_store: &mut impl AsStoreMut,
     ) -> Result<Self, MemoryError> {
-        let view = self.view(store);
-        let ty = self.ty(store);
-        let amount = view.data_size() as usize;
-
-        let new_memory = Self::new(new_store, ty)?;
-        let mut new_view = new_memory.view(&new_store);
-        let new_view_size = new_view.data_size() as usize;
-        if amount > new_view_size {
-            let delta = amount - new_view_size;
-            let pages = ((delta - 1) / wasmer_types::WASM_PAGE_SIZE) + 1;
-            new_memory.grow(new_store, Pages(pages as u32))?;
-            new_view = new_memory.view(&new_store);
-        }
-
-        // Copy the bytes
-        view.copy_to_memory(amount as u64, &new_view)
-            .map_err(|err| MemoryError::Generic(err.to_string()))?;
-        // // Return the new memory
-        Ok(new_memory)
+        unimplemented!();
+        // let view = self.view(store);
+        // let ty = self.ty(store);
+        // let amount = view.data_size() as usize;
+
+        // let new_memory = Self::new(new_store, ty)?;
+        // let mut new_view = new_memory.view(&new_store);
+        // let new_view_size = new_view.data_size() as usize;
+        // if amount > new_view_size {
+        //     let delta = amount - new_view_size;
+        //     let pages = ((delta - 1) / wasmer_types::WASM_PAGE_SIZE) + 1;
+        //     new_memory.grow(new_store, Pages(pages as u32))?;
+        //     new_view = new_memory.view(&new_store);
+        // }
+
+        // // Copy the bytes
+        // view.copy_to_memory(amount as u64, &new_view)
+        //     .map_err(|err| MemoryError::Generic(err.to_string()))?;
+        // // // Return the new memory
+        // Ok(new_memory)
     }
 
-    pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, internal: VMMemory) -> Self {
-        Self { handle: internal }
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, internal: VMExternMemory) -> Self {
+        Self {
+            handle: internal.into_wamr(),
+        }
     }
 
     /// Cloning memory will create another reference to the same memory that
     /// can be put into a new store
     pub fn try_clone(&self, _store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
-        self.handle.try_clone()
+        Ok(self.handle.clone())
     }
 
     /// Copying the memory will actually copy all the bytes in the memory to
     /// a identical byte copy of the original that can be put into a new store
     pub fn try_copy(&self, store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
-        let mut cloned = self.try_clone(store)?;
-        cloned.copy(store)
+        let res = unsafe { wasm_memory_copy(self.handle) };
+        if res.is_null() {
+            Err(MemoryError::Generic("memory copy failed".to_owned()))
+        } else {
+            Ok(res)
+        }
     }
 
     pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
@@ -208,10 +172,11 @@ impl Memory {
 
     #[allow(unused)]
     pub fn duplicate(&mut self, store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
-        self.handle.duplicate(store)
+        unimplemented!();
+        // self.handle.duplicate(store)
     }
 
-    pub fn as_shared(&self, _store: &impl AsStoreRef) -> Option<crate::SharedMemory> {
+    pub fn as_shared(&self, _store: &impl AsStoreRef) -> Option<SharedMemory> {
         // Not supported.
         None
     }
@@ -238,12 +203,15 @@ impl<'a> MemoryBuffer<'a> {
         let end = offset
             .checked_add(buf.len() as u64)
             .ok_or(MemoryAccessError::Overflow)?;
-        if end > self.len.try_into().unwrap() {
+
+        let len: u64 = self.len.try_into().unwrap();
+        if end > len {
             warn!(
-                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
+                "attempted to read {} bytes, but the end offset is beyond the bounds of the memory view ({} > {}, diff. {} bytes)",
                 buf.len(),
                 end,
-                self.len
+                len,
+                end - len,
             );
             return Err(MemoryAccessError::HeapOutOfBounds);
         }
@@ -261,12 +229,15 @@ impl<'a> MemoryBuffer<'a> {
         let end = offset
             .checked_add(buf.len() as u64)
             .ok_or(MemoryAccessError::Overflow)?;
-        if end > self.len.try_into().unwrap() {
+
+        let len: u64 = self.len.try_into().unwrap();
+        if end > len {
             warn!(
-                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
+                "attempted to read {} bytes, but the end offset is beyond the bounds of the memory view ({} > {}, diff. {} bytes)",
                 buf.len(),
                 end,
-                self.len
+                len,
+                end - len,
             );
             return Err(MemoryAccessError::HeapOutOfBounds);
         }
@@ -275,7 +246,7 @@ impl<'a> MemoryBuffer<'a> {
             volatile_memcpy_read(self.base.add(offset as usize), buf_ptr, buf.len());
         }
 
-        Ok(unsafe { slice::from_raw_parts_mut(buf_ptr, buf.len()) })
+        Ok(unsafe { std::slice::from_raw_parts_mut(buf_ptr, buf.len()) })
     }
 
     pub(crate) fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
@@ -313,9 +284,9 @@ unsafe fn volatile_memcpy_read(mut src: *const u8, mut dst: *mut u8, mut len: us
         struct Unaligned<T>(T);
         let val = (*src as *const Unaligned<T>).read_volatile();
         (*dst as *mut Unaligned<T>).write(val);
-        *src = src.add(mem::size_of::<T>());
-        *dst = dst.add(mem::size_of::<T>());
-        *len -= mem::size_of::<T>();
+        *src = src.add(std::mem::size_of::<T>());
+        *dst = dst.add(std::mem::size_of::<T>());
+        *len -= std::mem::size_of::<T>();
     }
 
     while len >= 8 {
@@ -331,6 +302,7 @@ unsafe fn volatile_memcpy_read(mut src: *const u8, mut dst: *mut u8, mut len: us
         copy_one::<u8>(&mut src, &mut dst, &mut len);
     }
 }
+
 #[inline]
 unsafe fn volatile_memcpy_write(mut src: *const u8, mut dst: *mut u8, mut len: usize) {
     #[inline]
@@ -339,9 +311,9 @@ unsafe fn volatile_memcpy_write(mut src: *const u8, mut dst: *mut u8, mut len: u
         struct Unaligned<T>(T);
         let val = (*src as *const Unaligned<T>).read();
         (*dst as *mut Unaligned<T>).write_volatile(val);
-        *src = src.add(mem::size_of::<T>());
-        *dst = dst.add(mem::size_of::<T>());
-        *len -= mem::size_of::<T>();
+        *src = src.add(std::mem::size_of::<T>());
+        *dst = dst.add(std::mem::size_of::<T>());
+        *len -= std::mem::size_of::<T>();
     }
 
     while len >= 8 {
@@ -357,3 +329,29 @@ unsafe fn volatile_memcpy_write(mut src: *const u8, mut dst: *mut u8, mut len: u
         copy_one::<u8>(&mut src, &mut dst, &mut len);
     }
 }
+
+impl crate::Memory {
+    /// Consume [`self`] into a [`crate::backend::wamr::memory::Memory`].
+    pub fn into_wamr(self) -> crate::backend::wamr::memory::Memory {
+        match self.0 {
+            BackendMemory::Wamr(s) => s,
+            _ => panic!("Not a `wamr` memory!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference to [`crate::backend::wamr::memory::Memory`].
+    pub fn as_wamr(&self) -> &crate::backend::wamr::memory::Memory {
+        match self.0 {
+            BackendMemory::Wamr(ref s) => s,
+            _ => panic!("Not a `wamr` memory!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference to [`crate::backend::wamr::memory::Memory`].
+    pub fn as_wamr_mut(&mut self) -> &mut crate::backend::wamr::memory::Memory {
+        match self.0 {
+            BackendMemory::Wamr(ref mut s) => s,
+            _ => panic!("Not a `wamr` memory!"),
+        }
+    }
+}
diff --git a/lib/api/src/backend/wamr/entities/memory/view.rs b/lib/api/src/backend/wamr/entities/memory/view.rs
new file mode 100644
index 0000000000..206c1a0f15
--- /dev/null
+++ b/lib/api/src/backend/wamr/entities/memory/view.rs
@@ -0,0 +1,203 @@
+use std::{marker::PhantomData, mem::MaybeUninit, ops::Range};
+
+use wasmer_types::Pages;
+
+use super::{Memory, MemoryBuffer};
+use crate::{
+    backend::wamr::bindings::{wasm_memory_data, wasm_memory_data_size, wasm_memory_size},
+    wamr::bindings::wasm_memory_t,
+    AsStoreRef, MemoryAccessError,
+};
+
+/// A WebAssembly `memory` view.
+///
+/// A memory view is used to read and write to the linear memory.
+///
+/// After a memory is grown a view must not be used anymore. Views are
+/// created using the Memory.grow() method.
+#[derive(Debug)]
+pub struct MemoryView<'a> {
+    pub(crate) buffer: MemoryBuffer<'a>,
+    pub(crate) size: u32,
+}
+
+impl<'a> MemoryView<'a> {
+    pub(crate) fn new(memory: &Memory, store: &'a (impl AsStoreRef + ?Sized)) -> Self {
+        let c_memory: *mut wasm_memory_t = memory.handle;
+
+        let len = unsafe { wasm_memory_data_size(c_memory as _).try_into().unwrap() };
+        let base: *mut u8 = unsafe { wasm_memory_data(c_memory as _) as _ };
+        let size = unsafe { wasm_memory_size(c_memory as _) };
+
+        Self {
+            buffer: MemoryBuffer {
+                base,
+                len,
+                marker: PhantomData,
+            },
+            size,
+        }
+    }
+
+    /// Returns the pointer to the raw bytes of the `Memory`.
+    //
+    // This used by wasmer-c-api, but should be treated
+    // as deprecated and not used in future code.
+    #[doc(hidden)]
+    pub fn data_ptr(&self) -> *mut u8 {
+        self.buffer.base
+    }
+
+    /// Returns the size (in bytes) of the `Memory`.
+    pub fn data_size(&self) -> u64 {
+        self.buffer.len.try_into().unwrap()
+    }
+
+    /// Retrieve a slice of the memory contents.
+    ///
+    /// # Safety
+    ///
+    /// Until the returned slice is dropped, it is undefined behaviour to
+    /// modify the memory contents in any way including by calling a wasm
+    /// function that writes to the memory or by resizing the memory.
+    #[doc(hidden)]
+    pub unsafe fn data_unchecked(&self) -> &[u8] {
+        self.data_unchecked_mut()
+    }
+
+    /// Retrieve a mutable slice of the memory contents.
+    ///
+    /// # Safety
+    ///
+    /// This method provides interior mutability without an UnsafeCell. Until
+    /// the returned value is dropped, it is undefined behaviour to read or
+    /// write to the pointed-to memory in any way except through this slice,
+    /// including by calling a wasm function that reads the memory contents or
+    /// by resizing this Memory.
+    #[allow(clippy::mut_from_ref)]
+    #[doc(hidden)]
+    pub unsafe fn data_unchecked_mut(&self) -> &mut [u8] {
+        std::slice::from_raw_parts_mut(self.buffer.base, self.buffer.len)
+    }
+
+    /// Returns the size (in [`Pages`]) of the `Memory`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let m = Memory::new(&mut store, MemoryType::new(1, None, false)).unwrap();
+    ///
+    /// assert_eq!(m.view(&mut store).size(), Pages(1));
+    /// ```
+    pub fn size(&self) -> Pages {
+        Pages(self.size)
+    }
+
+    #[inline]
+    pub(crate) fn buffer(&'a self) -> MemoryBuffer<'a> {
+        self.buffer
+    }
+
+    /// Safely reads bytes from the memory at the given offset.
+    ///
+    /// The full buffer will be filled, otherwise a `MemoryAccessError` is returned
+    /// to indicate an out-of-bounds access.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn read(&self, offset: u64, buf: &mut [u8]) -> Result<(), MemoryAccessError> {
+        self.buffer.read(offset, buf)
+    }
+
+    /// Safely reads a single byte from memory at the given offset
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn read_u8(&self, offset: u64) -> Result<u8, MemoryAccessError> {
+        let mut buf = [0u8; 1];
+        self.read(offset, &mut buf)?;
+        Ok(buf[0])
+    }
+
+    /// Safely reads bytes from the memory at the given offset.
+    ///
+    /// This method is similar to `read` but allows reading into an
+    /// uninitialized buffer. An initialized view of the buffer is returned.
+    ///
+    /// The full buffer will be filled, otherwise a `MemoryAccessError` is returned
+    /// to indicate an out-of-bounds access.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn read_uninit<'b>(
+        &self,
+        offset: u64,
+        buf: &'b mut [MaybeUninit<u8>],
+    ) -> Result<&'b mut [u8], MemoryAccessError> {
+        self.buffer.read_uninit(offset, buf)
+    }
+
+    /// Safely writes bytes to the memory at the given offset.
+    ///
+    /// If the write exceeds the bounds of the memory then a `MemoryAccessError` is
+    /// returned.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent reads/writes.
+    pub fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
+        self.buffer.write(offset, data)
+    }
+
+    /// Safely reads a single byte from memory at the given offset
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn write_u8(&self, offset: u64, val: u8) -> Result<(), MemoryAccessError> {
+        let buf = [val];
+        self.write(offset, &buf)?;
+        Ok(())
+    }
+
+    #[allow(unused)]
+    /// Copies the memory and returns it as a vector of bytes
+    pub fn copy_to_vec(&self) -> Result<Vec<u8>, MemoryAccessError> {
+        self.copy_range_to_vec(0..self.data_size())
+    }
+
+    #[allow(unused)]
+    /// Copies a range of the memory and returns it as a vector of bytes
+    pub fn copy_range_to_vec(&self, range: Range<u64>) -> Result<Vec<u8>, MemoryAccessError> {
+        let mut new_memory = Vec::new();
+        let mut offset = range.start;
+        let end = range.end.min(self.data_size());
+        let mut chunk = [0u8; 40960];
+        while offset < end {
+            let remaining = end - offset;
+            let sublen = remaining.min(chunk.len() as u64) as usize;
+            self.read(offset, &mut chunk[..sublen])?;
+            new_memory.extend_from_slice(&chunk[..sublen]);
+            offset += sublen as u64;
+        }
+        Ok(new_memory)
+    }
+
+    #[allow(unused)]
+    /// Copies the memory to another new memory object
+    pub fn copy_to_memory(&self, amount: u64, new_memory: &Self) -> Result<(), MemoryAccessError> {
+        let mut offset = 0;
+        let mut chunk = [0u8; 40960];
+        while offset < amount {
+            let remaining = amount - offset;
+            let sublen = remaining.min(chunk.len() as u64) as usize;
+            self.read(offset, &mut chunk[..sublen])?;
+
+            new_memory.write(offset, &chunk[..sublen])?;
+
+            offset += sublen as u64;
+        }
+        Ok(())
+    }
+}
diff --git a/lib/api/src/backend/wamr/entities/mod.rs b/lib/api/src/backend/wamr/entities/mod.rs
new file mode 100644
index 0000000000..09a19c7eb9
--- /dev/null
+++ b/lib/api/src/backend/wamr/entities/mod.rs
@@ -0,0 +1,11 @@
+pub mod engine;
+pub(crate) mod exception;
+pub(crate) mod external;
+pub(crate) mod function;
+pub(crate) mod global;
+pub(crate) mod instance;
+pub(crate) mod memory;
+pub(crate) mod module;
+pub(crate) mod store;
+pub(crate) mod table;
+pub(crate) mod tag;
diff --git a/lib/api/src/backend/wamr/entities/module.rs b/lib/api/src/backend/wamr/entities/module.rs
new file mode 100644
index 0000000000..0b12f36c54
--- /dev/null
+++ b/lib/api/src/backend/wamr/entities/module.rs
@@ -0,0 +1,206 @@
+//! Data types, functions and traits for `wamr`'s `Module` implementation.
+use std::{path::Path, sync::Arc};
+
+use crate::{backend::wamr::bindings::*, AsEngineRef, BackendModule, IntoBytes};
+
+use bytes::Bytes;
+use wasmer_types::{
+    CompileError, DeserializeError, ExportType, ExportsIterator, ExternType, FunctionType,
+    GlobalType, ImportType, ImportsIterator, MemoryType, ModuleInfo, Mutability, Pages,
+    SerializeError, TableType, Type,
+};
+pub(crate) struct ModuleHandle {
+    pub(crate) inner: *mut wasm_module_t,
+    pub(crate) store: std::sync::Mutex<crate::store::Store>,
+}
+
+impl PartialEq for ModuleHandle {
+    fn eq(&self, other: &Self) -> bool {
+        self.inner == other.inner
+        // && self.store.lock() == other.store.lock()
+    }
+}
+
+impl Eq for ModuleHandle {}
+
+impl ModuleHandle {
+    fn new(engine: &impl AsEngineRef, binary: &[u8]) -> Result<Self, CompileError> {
+        let bytes = wasm_byte_vec_t {
+            size: binary.len(),
+            data: binary.as_ptr() as _,
+            num_elems: binary.len(),
+            size_of_elem: 1,
+            lock: std::ptr::null_mut(),
+        };
+
+        let store = crate::store::Store::new(engine.as_engine_ref().engine().clone());
+
+        let inner =
+            unsafe { wasm_module_new(store.inner.store.as_wamr().inner, &bytes as *const _) };
+        let store = std::sync::Mutex::new(store);
+
+        if inner.is_null() {
+            return Err(CompileError::Validate(format!("module is null")));
+        }
+
+        Ok(ModuleHandle { inner, store })
+    }
+}
+impl Drop for ModuleHandle {
+    fn drop(&mut self) {
+        unsafe { wasm_module_delete(self.inner) }
+    }
+}
+
+#[derive(Clone, PartialEq, Eq)]
+/// A WebAssembly `module` in `wamr`.
+pub struct Module {
+    pub(crate) handle: Arc<ModuleHandle>,
+    name: Option<String>,
+    raw_bytes: Option<Bytes>,
+    info: ModuleInfo,
+}
+
+unsafe impl Send for Module {}
+unsafe impl Sync for Module {}
+
+impl Module {
+    pub(crate) fn from_binary(
+        _engine: &impl AsEngineRef,
+        binary: &[u8],
+    ) -> Result<Self, CompileError> {
+        unsafe { Self::from_binary_unchecked(_engine, binary) }
+    }
+
+    pub(crate) unsafe fn from_binary_unchecked(
+        engine: &impl AsEngineRef,
+        binary: &[u8],
+    ) -> Result<Self, CompileError> {
+        let mut binary = binary.to_vec();
+        let binary = binary.into_bytes();
+        let module = ModuleHandle::new(engine, &binary)?;
+        let info = crate::utils::polyfill::translate_module(&binary[..])
+            .unwrap()
+            .info;
+
+        Ok(Self {
+            handle: Arc::new(module),
+            name: info.name.clone(),
+            raw_bytes: Some(binary.into_bytes()),
+            info,
+        })
+    }
+
+    pub fn validate(engine: &impl AsEngineRef, binary: &[u8]) -> Result<(), CompileError> {
+        let engine = engine.as_engine_ref().engine().clone();
+        let store = super::store::Store::new(engine);
+        let bytes = wasm_byte_vec_t {
+            size: binary.len(),
+            data: binary.as_ptr() as _,
+            num_elems: binary.len(),
+            size_of_elem: 1,
+            lock: std::ptr::null_mut(),
+        };
+        let store = store.inner;
+        unsafe {
+            if !wasm_module_validate(store, &bytes as *const _) {
+                return Err(CompileError::Validate(String::from(
+                    "WAMR could not validate the given module",
+                )));
+            }
+        }
+
+        Ok(())
+    }
+
+    pub fn name(&self) -> Option<&str> {
+        self.name.as_ref().map(|s| s.as_ref())
+    }
+
+    pub fn serialize(&self) -> Result<Bytes, SerializeError> {
+        return self.raw_bytes.clone().ok_or(SerializeError::Generic(
+            "Not able to serialize module".to_string(),
+        ));
+    }
+
+    pub unsafe fn deserialize_unchecked(
+        engine: &impl AsEngineRef,
+        bytes: impl IntoBytes,
+    ) -> Result<Self, DeserializeError> {
+        Self::deserialize(engine, bytes)
+    }
+
+    pub unsafe fn deserialize(
+        engine: &impl AsEngineRef,
+        bytes: impl IntoBytes,
+    ) -> Result<Self, DeserializeError> {
+        return Self::from_binary(engine, &bytes.into_bytes())
+            .map_err(|e| DeserializeError::Compiler(e));
+    }
+
+    pub unsafe fn deserialize_from_file_unchecked(
+        engine: &impl AsEngineRef,
+        path: impl AsRef<Path>,
+    ) -> Result<Self, DeserializeError> {
+        let bytes = std::fs::read(path.as_ref())?;
+        Self::deserialize_unchecked(engine, bytes)
+    }
+
+    pub unsafe fn deserialize_from_file(
+        engine: &impl AsEngineRef,
+        path: impl AsRef<Path>,
+    ) -> Result<Self, DeserializeError> {
+        let bytes = std::fs::read(path.as_ref())?;
+        Self::deserialize(engine, bytes)
+    }
+
+    pub fn set_name(&mut self, name: &str) -> bool {
+        self.name = Some(name.to_string());
+        true
+    }
+
+    pub fn imports<'a>(&'a self) -> ImportsIterator<Box<dyn Iterator<Item = ImportType> + 'a>> {
+        self.info().imports()
+    }
+
+    pub fn exports<'a>(&'a self) -> ExportsIterator<Box<dyn Iterator<Item = ExportType> + 'a>> {
+        self.info().exports()
+    }
+
+    pub fn custom_sections<'a>(
+        &'a self,
+        name: &'a str,
+    ) -> Box<dyn Iterator<Item = Box<[u8]>> + 'a> {
+        self.info().custom_sections(name)
+    }
+
+    pub(crate) fn info(&self) -> &ModuleInfo {
+        &self.info
+    }
+}
+
+impl crate::Module {
+    /// Consume [`self`] into a reference [`crate::backend::wamr::module::Module`].
+    pub fn into_wamr(self) -> crate::backend::wamr::module::Module {
+        match self.0 {
+            BackendModule::Wamr(s) => s,
+            _ => panic!("Not a `wamr` module!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::wamr::module::Module`].
+    pub fn as_wamr(&self) -> &crate::backend::wamr::module::Module {
+        match self.0 {
+            BackendModule::Wamr(ref s) => s,
+            _ => panic!("Not a `wamr` module!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wamr::module::Module`].
+    pub fn as_wamr_mut(&mut self) -> &mut crate::backend::wamr::module::Module {
+        match self.0 {
+            BackendModule::Wamr(ref mut s) => s,
+            _ => panic!("Not a `wamr` module!"),
+        }
+    }
+}
diff --git a/lib/api/src/backend/wamr/entities/store/mod.rs b/lib/api/src/backend/wamr/entities/store/mod.rs
new file mode 100644
index 0000000000..2e556e16bf
--- /dev/null
+++ b/lib/api/src/backend/wamr/entities/store/mod.rs
@@ -0,0 +1,103 @@
+//! Data types, functions and traits for `wamr`'s `Store` implementation.
+use crate::{
+    backend::wamr::bindings::{wasm_store_delete, wasm_store_new, wasm_store_t},
+    engine::{AsEngineRef, Engine, EngineRef},
+    AsStoreRef, BackendStore, StoreRef,
+};
+
+mod obj;
+pub use obj::*;
+
+/// A WebAssembly `store` in `wamr`.
+pub(crate) struct Store {
+    pub(crate) engine: Engine,
+    pub(crate) inner: *mut wasm_store_t,
+}
+
+impl std::fmt::Debug for Store {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Store")
+            .field("engine", &self.engine)
+            .finish()
+    }
+}
+
+impl Store {
+    pub(crate) fn new(engine: crate::engine::Engine) -> Self {
+        let inner: *mut wasm_store_t = unsafe { wasm_store_new(engine.as_wamr().inner.engine) };
+        Store { inner, engine }
+    }
+
+    pub(crate) fn engine(&self) -> &Engine {
+        &self.engine
+    }
+
+    pub(crate) fn engine_mut(&mut self) -> &mut Engine {
+        &mut self.engine
+    }
+}
+
+impl Drop for Store {
+    fn drop(&mut self) {
+        unsafe { wasm_store_delete(self.inner) }
+    }
+}
+
+impl AsEngineRef for Store {
+    fn as_engine_ref(&self) -> EngineRef<'_> {
+        EngineRef::new(&self.engine)
+    }
+}
+
+impl crate::BackendStore {
+    /// Consume [`self`] into [`crate::backend::wamr::store::Store`].
+    pub fn into_wamr(self) -> crate::backend::wamr::store::Store {
+        match self {
+            Self::Wamr(s) => s,
+            _ => panic!("Not a `wamr` store!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::wamr::store::Store`].
+    pub fn as_wamr(&self) -> &crate::backend::wamr::store::Store {
+        match self {
+            Self::Wamr(s) => s,
+            _ => panic!("Not a `wamr` store!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wamr::store::Store`].
+    pub fn as_wamr_mut(&mut self) -> &mut crate::backend::wamr::store::Store {
+        match self {
+            Self::Wamr(s) => s,
+            _ => panic!("Not a `wamr` store!"),
+        }
+    }
+
+    /// Return true if [`self`] is a store from the `wamr` runtime.
+    pub fn is_wamr(&self) -> bool {
+        matches!(self, Self::Wamr(_))
+    }
+}
+
+impl crate::Store {
+    /// Consume [`self`] into [`crate::backend::wamr::store::Store`].
+    pub(crate) fn into_wamr(self) -> crate::backend::wamr::store::Store {
+        self.inner.store.into_wamr()
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::wamr::store::Store`].
+    pub(crate) fn as_wamr(&self) -> &crate::backend::wamr::store::Store {
+        self.inner.store.as_wamr()
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wamr::store::Store`].
+    pub(crate) fn as_wamr_mut(&mut self) -> &mut crate::backend::wamr::store::Store {
+        self.inner.store.as_wamr_mut()
+    }
+
+    /// Return true if [`self`] is a store from the `wamr` runtime.
+    pub fn is_wamr(&self) -> bool {
+        self.inner.store.is_wamr()
+    }
+}
diff --git a/lib/api/src/backend/wamr/entities/store/obj.rs b/lib/api/src/backend/wamr/entities/store/obj.rs
new file mode 100644
index 0000000000..9c35d5fa57
--- /dev/null
+++ b/lib/api/src/backend/wamr/entities/store/obj.rs
@@ -0,0 +1,288 @@
+use std::{fmt, marker::PhantomData, num::NonZeroUsize};
+
+use crate::{
+    backend::wamr::vm::{VMFunctionEnvironment, VMGlobal},
+    AsStoreMut,
+};
+
+pub use wasmer_types::StoreId;
+
+impl crate::StoreObjects {
+    /// Consume [`self`] into [`crate::backend::wamr::store::StoreObjects`].
+    pub fn into_wamr(self) -> crate::backend::wamr::store::StoreObjects {
+        match self {
+            crate::StoreObjects::Wamr(s) => s,
+            _ => panic!("Not a `wamr` store!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::wamr::store::StoreObjects`].
+    pub fn as_wamr(&self) -> &crate::backend::wamr::store::StoreObjects {
+        match self {
+            crate::StoreObjects::Wamr(s) => s,
+            _ => panic!("Not a `wamr` store!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wamr::store::StoreObjects`].
+    pub fn as_wamr_mut(&mut self) -> &mut crate::backend::wamr::store::StoreObjects {
+        match self {
+            crate::StoreObjects::Wamr(s) => s,
+            _ => panic!("Not a `wamr` store!"),
+        }
+    }
+}
+
+/// Trait to represent an object managed by a context. This is implemented on
+/// the VM types managed by the context.
+pub trait StoreObject: Sized {
+    fn list(store: &StoreObjects) -> &Vec<Self>;
+    fn list_mut(store: &mut StoreObjects) -> &mut Vec<Self>;
+}
+
+macro_rules! impl_store_object {
+    ($($field:ident => $ty:ty,)*) => {
+        $(
+            impl StoreObject for $ty {
+                fn list(store: &StoreObjects) -> &Vec<Self> {
+                    &store.$field
+                }
+                fn list_mut(store: &mut StoreObjects) -> &mut Vec<Self> {
+                    &mut store.$field
+                }
+            }
+        )*
+        };
+    }
+
+impl_store_object! {
+    // Note: we store the globals in order to be able to access them later via
+    // `StoreObjects::iter_globals`.
+    globals => VMGlobal,
+    // functions => VMFunction,
+    // tables => VMTable,
+    // memories => VMMemory,
+    // The function environments are the only things attached to a store,
+    // since the other JS objects (table, globals, memory and functions)
+    // live in the JS VM Store by default
+    function_environments => VMFunctionEnvironment,
+}
+
+/// Set of objects managed by a context.
+#[derive(Default, Debug)]
+pub struct StoreObjects {
+    id: StoreId,
+    globals: Vec<VMGlobal>,
+    function_environments: Vec<VMFunctionEnvironment>,
+}
+
+impl StoreObjects {
+    /// Returns the ID of this context.
+    pub fn id(&self) -> StoreId {
+        self.id
+    }
+
+    /// Sets the ID of this store
+    pub fn set_id(&mut self, id: StoreId) {
+        self.id = id;
+    }
+
+    /// Returns a pair of mutable references from two handles.
+    ///
+    /// Panics if both handles point to the same object.
+    pub fn get_2_mut<T: StoreObject>(
+        &mut self,
+        a: InternalStoreHandle<T>,
+        b: InternalStoreHandle<T>,
+    ) -> (&mut T, &mut T) {
+        assert_ne!(a.index(), b.index());
+        let list = T::list_mut(self);
+        if a.index() < b.index() {
+            let (low, high) = list.split_at_mut(b.index());
+            (&mut low[a.index()], &mut high[0])
+        } else {
+            let (low, high) = list.split_at_mut(a.index());
+            (&mut high[0], &mut low[a.index()])
+        }
+    }
+
+    /// Return an immutable iterator over all globals
+    pub fn iter_globals(&self) -> core::slice::Iter<VMGlobal> {
+        self.globals.iter()
+    }
+
+    /// Return an vector of all globals and converted to u128
+    pub fn as_u128_globals(&self) -> Vec<u128> {
+        vec![]
+        // self.iter_globals()
+        //     .map(|v| v.global.value().as_f64().unwrap() as u128)
+        //     .collect()
+    }
+
+    /// Set a global, at index idx. Will panic if idx is out of range
+    /// Safety: the caller should check taht the raw value is compatible
+    /// with destination VMGlobal type
+    pub fn set_global_unchecked(&self, idx: usize, new_val: u128) {
+        assert!(idx < self.globals.len());
+        // let g = &self.globals[idx].global;
+        // let cur_val = g.value().as_f64().unwrap();
+        // let new_val = new_val as f64;
+        // if cur_val != new_val {
+        //     let new_value = JSValue::from(new_val);
+        //     g.set_value(&new_value);
+        // }
+    }
+}
+
+/// Handle to an object managed by a context.
+///
+/// Internally this is just an integer index into a context. A reference to the
+/// context must be passed in separately to access the actual object.
+pub struct StoreHandle<T> {
+    id: StoreId,
+    internal: InternalStoreHandle<T>,
+}
+
+impl<T> core::cmp::PartialEq for StoreHandle<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+
+impl<T> std::hash::Hash for StoreHandle<T> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.id.hash(state);
+        self.internal.idx.hash(state);
+    }
+}
+
+impl<T> Clone for StoreHandle<T> {
+    fn clone(&self) -> Self {
+        Self {
+            id: self.id,
+            internal: self.internal,
+        }
+    }
+}
+
+impl<T: StoreObject> fmt::Debug for StoreHandle<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("StoreHandle")
+            .field("id", &self.id)
+            .field("internal", &self.internal.index())
+            .finish()
+    }
+}
+
+impl<T: StoreObject> StoreHandle<T> {
+    /// Moves the given object into a context and returns a handle to it.
+    pub fn new(store: &mut StoreObjects, val: T) -> Self {
+        Self {
+            id: store.id,
+            internal: InternalStoreHandle::new(store, val),
+        }
+    }
+
+    /// Returns a reference to the object that this handle points to.
+    pub fn get<'a>(&self, store: &'a StoreObjects) -> &'a T {
+        assert_eq!(self.id, store.id, "object used with the wrong context");
+        self.internal.get(store)
+    }
+
+    /// Returns a mutable reference to the object that this handle points to.
+    pub fn get_mut<'a>(&self, store: &'a mut StoreObjects) -> &'a mut T {
+        assert_eq!(self.id, store.id, "object used with the wrong context");
+        self.internal.get_mut(store)
+    }
+
+    /// Returns the internal handle contains within this handle.
+    pub fn internal_handle(&self) -> InternalStoreHandle<T> {
+        self.internal
+    }
+
+    /// Returns the ID of the context associated with the handle.
+    #[allow(unused)]
+    pub fn store_id(&self) -> StoreId {
+        self.id
+    }
+
+    /// Overrides the store id with a new ID
+    #[allow(unused)]
+    pub fn set_store_id(&mut self, id: StoreId) {
+        self.id = id;
+    }
+
+    /// Constructs a `StoreHandle` from a `StoreId` and an `InternalStoreHandle`.
+    ///
+    /// # Safety
+    /// Handling `InternalStoreHandle` values is unsafe because they do not track context ID.
+    pub unsafe fn from_internal(id: StoreId, internal: InternalStoreHandle<T>) -> Self {
+        Self { id, internal }
+    }
+}
+
+/// Internal handle to an object owned by the current context.
+///
+/// Unlike `StoreHandle` this does not track the context ID: it is only
+/// intended to be used within objects already owned by a context.
+#[repr(transparent)]
+pub struct InternalStoreHandle<T> {
+    // Use a NonZero here to reduce the size of Option<InternalStoreHandle>.
+    idx: NonZeroUsize,
+    marker: PhantomData<fn() -> T>,
+}
+
+impl<T> Clone for InternalStoreHandle<T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl<T> Copy for InternalStoreHandle<T> {}
+
+impl<T> fmt::Debug for InternalStoreHandle<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("InternalStoreHandle")
+            .field("idx", &self.idx)
+            .finish()
+    }
+}
+impl<T> PartialEq for InternalStoreHandle<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.idx == other.idx
+    }
+}
+impl<T> Eq for InternalStoreHandle<T> {}
+
+impl<T: StoreObject> InternalStoreHandle<T> {
+    /// Moves the given object into a context and returns a handle to it.
+    pub fn new(store: &mut StoreObjects, val: T) -> Self {
+        let list = T::list_mut(store);
+        let idx = NonZeroUsize::new(list.len() + 1).unwrap();
+        list.push(val);
+        Self {
+            idx,
+            marker: PhantomData,
+        }
+    }
+
+    /// Returns a reference to the object that this handle points to.
+    pub fn get<'a>(&self, store: &'a StoreObjects) -> &'a T {
+        &T::list(store)[self.idx.get() - 1]
+    }
+
+    /// Returns a mutable reference to the object that this handle points to.
+    pub fn get_mut<'a>(&self, store: &'a mut StoreObjects) -> &'a mut T {
+        &mut T::list_mut(store)[self.idx.get() - 1]
+    }
+
+    pub(crate) fn index(&self) -> usize {
+        self.idx.get()
+    }
+
+    pub(crate) fn from_index(idx: usize) -> Option<Self> {
+        NonZeroUsize::new(idx).map(|idx| Self {
+            idx,
+            marker: PhantomData,
+        })
+    }
+}
diff --git a/lib/api/src/backend/wamr/entities/table.rs b/lib/api/src/backend/wamr/entities/table.rs
new file mode 100644
index 0000000000..79b05764d4
--- /dev/null
+++ b/lib/api/src/backend/wamr/entities/table.rs
@@ -0,0 +1,234 @@
+//! Data types, functions and traits for `wamr`'s `Table` implementation.
+use wasmer_types::TableType;
+
+use crate::{
+    vm::{VMExtern, VMExternTable},
+    wamr::{
+        bindings::{self, *},
+        utils::convert::{IntoCApiType, IntoCApiValue, IntoWasmerType, IntoWasmerValue},
+        vm::VMTable,
+    },
+    AsStoreMut, AsStoreRef, BackendKind, BackendTable, RuntimeError, Value,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// A WebAssembly `table` in `wamr`.
+pub struct Table {
+    pub(crate) handle: VMTable,
+}
+
+unsafe impl Send for Table {}
+unsafe impl Sync for Table {}
+
+impl Table {
+    pub(crate) fn type_to_wamr(ty: TableType) -> *mut wasm_tabletype_t {
+        let valtype = unsafe { wasm_valtype_new(ty.ty.into_ct()) };
+
+        let limits = Box::into_raw(Box::new(wasm_limits_t {
+            min: ty.minimum,
+            max: match ty.maximum {
+                Some(v) => v,
+                None => 0,
+            },
+        }));
+
+        unsafe { wasm_tabletype_new(valtype, limits) }
+    }
+
+    pub fn new(
+        store: &mut impl AsStoreMut,
+        ty: TableType,
+        init: Value,
+    ) -> Result<Self, RuntimeError> {
+        let store_mut = store.as_store_mut();
+        let engine = store_mut.engine();
+
+        let wasm_tablety = Self::type_to_wamr(ty);
+        let init: wasm_val_t = init.into_cv();
+
+        Ok(Self {
+            handle: unsafe {
+                wasm_table_new(
+                    store_mut.inner.store.as_wamr().inner,
+                    wasm_tablety,
+                    init.of.ref_,
+                )
+            },
+        })
+    }
+
+    pub fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Wamr(unsafe { wasm_table_as_extern(self.handle) })
+    }
+
+    pub fn ty(&self, _store: &impl AsStoreRef) -> TableType {
+        let table_type: *mut wasm_tabletype_t = unsafe { wasm_table_type(self.handle) };
+        let table_limits = unsafe { wasm_tabletype_limits(table_type) };
+        let table_type = unsafe { wasm_tabletype_element(table_type) };
+
+        TableType {
+            ty: table_type.into_wt(),
+            minimum: unsafe { (*table_limits).min },
+            maximum: unsafe {
+                if (*table_limits).max == 0 {
+                    None
+                } else {
+                    Some((*table_limits).max)
+                }
+            },
+        }
+    }
+
+    pub fn get(&self, store: &mut impl AsStoreMut, index: u32) -> Option<Value> {
+        unsafe {
+            let ref_ = wasm_table_get(self.handle, index);
+
+            if ref_.is_null() {
+                return None;
+            }
+
+            let kind = match self.ty(store).ty {
+                wasmer_types::Type::ExternRef => wasm_valkind_enum_WASM_EXTERNREF,
+                wasmer_types::Type::FuncRef => wasm_valkind_enum_WASM_FUNCREF,
+                ty => panic!("unsupported table type: {ty:?}"),
+            } as u8;
+
+            let value = wasm_val_t {
+                kind,
+                _paddings: Default::default(),
+                of: bindings::wasm_val_t__bindgen_ty_1 { ref_ },
+            };
+
+            Some(value.into_wv())
+        }
+    }
+
+    pub fn set(
+        &self,
+        store: &mut impl AsStoreMut,
+        index: u32,
+        val: Value,
+    ) -> Result<(), RuntimeError> {
+        unsafe {
+            let init = match val {
+                Value::ExternRef(None) | Value::FuncRef(None) => std::ptr::null_mut(),
+                Value::FuncRef(Some(ref r)) => wasm_func_as_ref(r.as_wamr().handle),
+                _ => {
+                    return Err(RuntimeError::new(format!(
+                        "Could not grow table due to unsupported init value type: {val:?} "
+                    )))
+                }
+            };
+
+            if !wasm_table_set(self.handle, index, init) {
+                return Err(RuntimeError::new(format!(
+                    "Could not set value {val:?} table at index {index}"
+                )));
+            }
+
+            Ok(())
+        }
+    }
+
+    pub fn size(&self, store: &impl AsStoreRef) -> u32 {
+        unsafe { wasm_table_size(self.handle) }
+    }
+
+    pub fn grow(
+        &self,
+        store: &mut impl AsStoreMut,
+        delta: u32,
+        init: Value,
+    ) -> Result<u32, RuntimeError> {
+        unsafe {
+            let size = wasm_table_size(self.handle);
+            let init = match init {
+                Value::ExternRef(None) | Value::FuncRef(None) => std::ptr::null_mut(),
+                Value::FuncRef(Some(r)) => wasm_func_as_ref(r.as_wamr().handle),
+                _ => {
+                    return Err(RuntimeError::new(format!(
+                        "Could not grow table due to unsupported init value type: {init:?} "
+                    )))
+                }
+            };
+            if !wasm_table_grow(self.handle, delta, init) {
+                return Err(RuntimeError::new("Could not grow table"));
+            }
+
+            Ok(size)
+        }
+    }
+
+    pub fn copy(
+        _store: &mut impl AsStoreMut,
+        _dst_table: &Self,
+        _dst_index: u32,
+        _src_table: &Self,
+        _src_index: u32,
+        _len: u32,
+    ) -> Result<(), RuntimeError> {
+        unimplemented!("Copying tables is currently not implemented!")
+    }
+
+    pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, vm_extern: VMExternTable) -> Self {
+        Self {
+            handle: vm_extern.into_wamr(),
+        }
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
+
+impl crate::Table {
+    /// Consume [`self`] into [`crate::backend::wamr::table::Table`].
+    pub fn into_wamr(self) -> crate::backend::wamr::table::Table {
+        match self.0 {
+            BackendTable::Wamr(s) => s,
+            _ => panic!("Not a `wamr` table!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::wamr::table::Table`].
+    pub fn as_wamr(&self) -> &crate::backend::wamr::table::Table {
+        match self.0 {
+            BackendTable::Wamr(ref s) => s,
+            _ => panic!("Not a `wamr` table!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wamr::table::Table`].
+    pub fn as_wamr_mut(&mut self) -> &mut crate::backend::wamr::table::Table {
+        match self.0 {
+            BackendTable::Wamr(ref mut s) => s,
+            _ => panic!("Not a `wamr` table!"),
+        }
+    }
+}
+
+impl crate::BackendTable {
+    /// Consume [`self`] into [`crate::backend::wamr::table::Table`].
+    pub fn into_wamr(self) -> crate::backend::wamr::table::Table {
+        match self {
+            Self::Wamr(s) => s,
+            _ => panic!("Not a `wamr` table!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::wamr::table::Table`].
+    pub fn as_wamr(&self) -> &crate::backend::wamr::table::Table {
+        match self {
+            Self::Wamr(ref s) => s,
+            _ => panic!("Not a `wamr` table!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wamr::table::Table`].
+    pub fn as_wamr_mut(&mut self) -> &mut crate::backend::wamr::table::Table {
+        match self {
+            Self::Wamr(ref mut s) => s,
+            _ => panic!("Not a `wamr` table!"),
+        }
+    }
+}
diff --git a/lib/api/src/backend/wamr/entities/tag.rs b/lib/api/src/backend/wamr/entities/tag.rs
new file mode 100644
index 0000000000..d7daa2274f
--- /dev/null
+++ b/lib/api/src/backend/wamr/entities/tag.rs
@@ -0,0 +1,43 @@
+//! Data types, functions and traits for `wamr` runtime's `Tag` implementation.
+use wasmer_types::{TagType, Type};
+
+use crate::{
+    vm::{VMExtern, VMExternTag},
+    wamr::vm::VMTag,
+    AsStoreMut, AsStoreRef,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// A WebAssembly `tag` in the `v8` runtime.
+pub(crate) struct Tag {
+    pub(crate) handle: VMTag,
+}
+
+unsafe impl Send for Tag {}
+unsafe impl Sync for Tag {}
+
+// Tag can't be Send in js because it dosen't support `structuredClone`
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// unsafe impl Send for Tag {}
+
+impl Tag {
+    pub fn new<P: Into<Box<[Type]>>>(store: &mut impl AsStoreMut, params: P) -> Self {
+        panic!("EH not supported yet!")
+    }
+
+    pub fn ty(&self, store: &impl AsStoreRef) -> TagType {
+        panic!("EH not supported yet!")
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternTag) -> Self {
+        panic!("EH not supported yet!")
+    }
+
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        panic!("EH not supported yet!")
+    }
+
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        panic!("EH not supported yet!")
+    }
+}
diff --git a/lib/api/src/backend/wamr/error.rs b/lib/api/src/backend/wamr/error.rs
new file mode 100644
index 0000000000..4d1b7790d5
--- /dev/null
+++ b/lib/api/src/backend/wamr/error.rs
@@ -0,0 +1,172 @@
+use std::{
+    error::Error,
+    ffi::{c_char, CStr},
+};
+
+use crate::{wamr::bindings::*, AsStoreMut};
+
+#[derive(Debug)]
+enum InnerTrap {
+    User(Box<dyn Error + Send + Sync>),
+    CApi(*mut wasm_trap_t),
+}
+
+/// A struct representing a Trap
+pub struct Trap {
+    inner: InnerTrap,
+}
+
+unsafe impl Send for Trap {}
+unsafe impl Sync for Trap {}
+
+impl Trap {
+    pub fn user(error: Box<dyn Error + Send + Sync>) -> Self {
+        Self {
+            inner: InnerTrap::User(error),
+        }
+    }
+
+    /// Attempts to downcast the `Trap` to a concrete type.
+    pub fn downcast<T: Error + 'static>(self) -> Result<T, Self> {
+        match self.inner {
+            // We only try to downcast user errors
+            InnerTrap::User(err) if err.is::<T>() => Ok(*err.downcast::<T>().unwrap()),
+            _ => Err(self),
+        }
+    }
+
+    /// Attempts to downcast the `Trap` to a concrete type.
+    pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T> {
+        match &self.inner {
+            // We only try to downcast user errors
+            InnerTrap::User(err) if err.is::<T>() => err.downcast_ref::<T>(),
+            _ => None,
+        }
+    }
+
+    /// Returns true if the `Trap` is the same as T
+    pub fn is<T: Error + 'static>(&self) -> bool {
+        match &self.inner {
+            InnerTrap::User(err) => err.is::<T>(),
+            _ => false,
+        }
+    }
+
+    pub unsafe fn into_wasm_trap(self, store: &mut impl AsStoreMut) -> *mut wasm_trap_t {
+        match self.inner {
+            InnerTrap::CApi(t) => t,
+            InnerTrap::User(err) => {
+                let err_ptr = Box::leak(Box::new(err));
+                let mut data = std::mem::zeroed();
+                // let x = format!("")
+                let s1 = format!("🐛{:p}", err_ptr);
+                let _s = s1.into_bytes().into_boxed_slice();
+                wasm_byte_vec_new(&mut data, _s.len(), _s.as_ptr() as _);
+                std::mem::forget(_s);
+                let store = store.as_store_mut();
+                wasm_trap_new(store.inner.store.as_wamr().inner, &mut data)
+            }
+        }
+    }
+
+    // pub unsafe fn deserialize_from_wasm_trap(trap: *mut wasm_trap_t) -> Self {
+    //     let mut data = std::mem::zeroed();
+    //     wasm_trap_message(trap, data);
+    //     println!("data: {:p}", data);
+
+    //     std::ptr::read(data as *const _)
+    // }
+}
+
+impl From<*mut wasm_trap_t> for Trap {
+    fn from(value: *mut wasm_trap_t) -> Self {
+        let message = unsafe {
+            let mut message = std::mem::zeroed();
+            wasm_trap_message(value, &mut message);
+
+            CStr::from_ptr(message.data as *const c_char)
+                .to_str()
+                .unwrap()
+        };
+
+        println!("{message}");
+
+        if message.starts_with("Exception: 🐛") {
+            let ptr_str = message.replace("Exception: 🐛", "");
+            let ptr: Box<dyn Error + Send + Sync + 'static> = unsafe {
+                let r = ptr_str.trim_start_matches("0x");
+                std::ptr::read(
+                    (usize::from_str_radix(&r, 16).unwrap()
+                        as *const Box<dyn Error + Send + Sync + 'static>),
+                )
+            };
+
+            Self {
+                inner: InnerTrap::User(ptr),
+            }
+        } else {
+            Self {
+                inner: InnerTrap::CApi(value),
+            }
+        }
+    }
+}
+
+impl std::error::Error for Trap {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match &self.inner {
+            InnerTrap::User(err) => Some(&**err),
+            _ => None,
+        }
+    }
+}
+
+impl std::fmt::Display for Trap {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self.inner {
+            InnerTrap::User(e) => write!(f, "{}", e),
+            InnerTrap::CApi(value) => {
+                // let message: wasm_message_t;
+                // wasm_trap_message(value, &mut message);
+                let mut out = unsafe {
+                    let mut vec: wasm_byte_vec_t = Default::default();
+                    wasm_byte_vec_new_empty(&mut vec);
+                    &mut vec as *mut _
+                };
+                unsafe { wasm_trap_message(*value, out) };
+                let cstr = unsafe { CStr::from_ptr((*out).data) };
+                write!(f, "wasm-c-api trap: {}", cstr.to_str().unwrap())
+            }
+        }
+    }
+}
+
+impl std::fmt::Debug for Trap {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self.inner {
+            InnerTrap::User(e) => write!(f, "{}", e),
+            InnerTrap::CApi(value) => {
+                // let message: wasm_message_t;
+                // wasm_trap_message(value, &mut message);
+                let mut out = unsafe {
+                    let mut vec: wasm_byte_vec_t = Default::default();
+                    wasm_byte_vec_new_empty(&mut vec);
+                    &mut vec as *mut _
+                };
+                unsafe { wasm_trap_message(*value, out) };
+                let cstr = unsafe { CStr::from_ptr((*out).data) };
+                write!(f, "wasm-c-api trap: {}", cstr.to_str().unwrap())
+            }
+        }
+    }
+}
+
+impl From<Trap> for crate::RuntimeError {
+    fn from(trap: Trap) -> Self {
+        if trap.is::<Self>() {
+            return trap.downcast::<Self>().unwrap();
+        }
+
+        crate::RuntimeError::new_from_source(crate::BackendTrap::Wamr(trap), vec![], None)
+    }
+}
diff --git a/lib/api/src/backend/wamr/mod.rs b/lib/api/src/backend/wamr/mod.rs
new file mode 100644
index 0000000000..9c1cec4ad1
--- /dev/null
+++ b/lib/api/src/backend/wamr/mod.rs
@@ -0,0 +1,9 @@
+//! Data types, functions and traits for the `wamr` backend.
+
+pub(crate) mod bindings;
+pub(crate) mod entities;
+pub(crate) mod error;
+pub(crate) mod utils;
+pub(crate) mod vm;
+
+pub use entities::{engine::Engine as Wamr, *};
diff --git a/lib/api/src/backend/wamr/utils/convert.rs b/lib/api/src/backend/wamr/utils/convert.rs
new file mode 100644
index 0000000000..484baeba3e
--- /dev/null
+++ b/lib/api/src/backend/wamr/utils/convert.rs
@@ -0,0 +1,153 @@
+/// Utilities to convert between `wamr` and `wasmer` values
+use crate::{
+    wamr::{
+        bindings::{
+            self, wasm_func_as_ref, wasm_val_t, wasm_val_t__bindgen_ty_1, wasm_valkind_t,
+            wasm_valtype_kind, wasm_valtype_t,
+        },
+        function,
+    },
+    BackendFunction, Function, Value,
+};
+use wasmer_types::Type;
+
+pub trait IntoCApiValue {
+    /// Consume [`self`] to produce a [`wasm_val_t`].
+    fn into_cv(self) -> wasm_val_t;
+}
+
+impl IntoCApiValue for Value {
+    fn into_cv(self) -> wasm_val_t {
+        match self {
+            Value::I32(val) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_I32 as _,
+                _paddings: Default::default(),
+                of: wasm_val_t__bindgen_ty_1 { i32_: val },
+            },
+            Value::I64(val) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_I64 as _,
+                _paddings: Default::default(),
+                of: wasm_val_t__bindgen_ty_1 { i64_: val },
+            },
+            Value::F32(val) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_F32 as _,
+                _paddings: Default::default(),
+                of: wasm_val_t__bindgen_ty_1 { f32_: val },
+            },
+            Value::F64(val) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_F64 as _,
+                _paddings: Default::default(),
+                of: wasm_val_t__bindgen_ty_1 { f64_: val },
+            },
+            Value::FuncRef(Some(val)) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_FUNCREF as _,
+                _paddings: Default::default(),
+                of: wasm_val_t__bindgen_ty_1 {
+                    ref_: unsafe { wasm_func_as_ref(val.as_wamr().handle) },
+                },
+            },
+            Value::FuncRef(None) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_FUNCREF as _,
+                _paddings: Default::default(),
+                of: wasm_val_t__bindgen_ty_1 {
+                    ref_: unsafe { wasm_func_as_ref(std::ptr::null_mut()) },
+                },
+            },
+            Value::ExternRef(_) => panic!(
+                "Creating host values from guest ExternRefs is not currently supported in wamr ."
+            ),
+            Value::ExceptionRef(_) => {
+                panic!("Creating host values from guest V128s is not currently supported in wamr.")
+            }
+            Value::V128(_) => {
+                panic!("Creating host values from guest V128s is not currently supported in wamr.")
+            }
+        }
+    }
+}
+
+pub trait IntoWasmerValue {
+    /// Consume [`self`] to produce a [`Value`].
+    fn into_wv(self) -> Value;
+}
+
+impl IntoWasmerValue for wasm_val_t {
+    fn into_wv(self) -> Value {
+        match self.kind as _ {
+            bindings::wasm_valkind_enum_WASM_I32 => Value::I32(unsafe { self.of.i32_ }),
+            bindings::wasm_valkind_enum_WASM_I64 => Value::I64(unsafe { self.of.i64_ }),
+            bindings::wasm_valkind_enum_WASM_F32 => Value::F32(unsafe { self.of.f32_ }),
+            bindings::wasm_valkind_enum_WASM_F64 => Value::F64(unsafe { self.of.f64_ }),
+            bindings::wasm_valkind_enum_WASM_FUNCREF => Value::FuncRef(Some(Function(
+                BackendFunction::Wamr(crate::backend::wamr::function::Function {
+                    handle: unsafe { self.of.ref_ as _ },
+                }),
+            ))),
+            bindings::wasm_valkind_enum_WASM_EXTERNREF => {
+                panic!("ExternRefs are not currently supported through wasm_c_api")
+            }
+            _ => panic!("wamr kind {} has no matching type", self.kind),
+        }
+    }
+}
+
+pub trait IntoWasmerType {
+    /// Consume [`self`] to produce a [`Type`].
+    fn into_wt(self) -> Type;
+}
+
+impl IntoWasmerType for wasm_valkind_t {
+    fn into_wt(self) -> Type {
+        match self as _ {
+            bindings::wasm_valkind_enum_WASM_I32 => Type::I32,
+            bindings::wasm_valkind_enum_WASM_I64 => Type::I64,
+            bindings::wasm_valkind_enum_WASM_F32 => Type::F32,
+            bindings::wasm_valkind_enum_WASM_F64 => Type::F64,
+            bindings::wasm_valkind_enum_WASM_V128 => Type::V128,
+            bindings::wasm_valkind_enum_WASM_EXTERNREF => Type::ExternRef,
+            bindings::wasm_valkind_enum_WASM_FUNCREF => Type::FuncRef,
+            _ => unreachable!("wamr kind {self:?} has no matching wasmer_types::Type"),
+        }
+    }
+}
+
+pub trait IntoCApiType {
+    /// Consume [`self`] to produce a [`wasm_valkind_t`].
+    fn into_ct(self) -> wasm_valkind_t;
+}
+
+impl IntoCApiType for Type {
+    fn into_ct(self) -> wasm_valkind_t {
+        match self as _ {
+            Type::I32 => bindings::wasm_valkind_enum_WASM_I32 as _,
+            Type::I64 => bindings::wasm_valkind_enum_WASM_I64 as _,
+            Type::F32 => bindings::wasm_valkind_enum_WASM_F32 as _,
+            Type::F64 => bindings::wasm_valkind_enum_WASM_F64 as _,
+            Type::FuncRef => bindings::wasm_valkind_enum_WASM_FUNCREF as _,
+            Type::ExternRef => bindings::wasm_valkind_enum_WASM_EXTERNREF as _,
+            Type::V128 => bindings::wasm_valkind_enum_WASM_V128 as _,
+            Type::ExceptionRef => panic!("v8 currently does not support exnrefs"),
+        }
+    }
+}
+
+impl IntoWasmerType for wasm_valtype_t {
+    fn into_wt(self) -> Type {
+        let type_: wasm_valkind_t = unsafe { wasm_valtype_kind(&self as *const _) };
+        type_.into_wt()
+    }
+}
+
+impl IntoWasmerType for *const wasm_valtype_t {
+    fn into_wt(self) -> Type {
+        let type_: wasm_valkind_t = unsafe { wasm_valtype_kind(self as _) };
+        type_.into_wt()
+    }
+}
+
+impl IntoWasmerType for *mut wasm_valtype_t {
+    fn into_wt(self) -> Type {
+        let type_: wasm_valkind_t = unsafe { wasm_valtype_kind(self as _) };
+        type_.into_wt()
+    }
+}
diff --git a/lib/api/src/backend/wamr/utils/mod.rs b/lib/api/src/backend/wamr/utils/mod.rs
new file mode 100644
index 0000000000..02d63d4e14
--- /dev/null
+++ b/lib/api/src/backend/wamr/utils/mod.rs
@@ -0,0 +1 @@
+pub(crate) mod convert;
diff --git a/lib/api/src/backend/wamr/vm/env.rs b/lib/api/src/backend/wamr/vm/env.rs
new file mode 100644
index 0000000000..d2a93d5f63
--- /dev/null
+++ b/lib/api/src/backend/wamr/vm/env.rs
@@ -0,0 +1,28 @@
+use std::any::Any;
+
+/// Underlying FunctionEnvironment used by a `VMFunction`.
+#[derive(Debug)]
+pub struct VMFunctionEnvironment {
+    pub(crate) contents: Box<dyn Any + Send + 'static>,
+}
+
+impl VMFunctionEnvironment {
+    /// Wraps the given value to expose it to Wasm code as a function context.
+    pub fn new(val: impl Any + Send + 'static) -> Self {
+        Self {
+            contents: Box::new(val),
+        }
+    }
+
+    #[allow(clippy::should_implement_trait)]
+    /// Returns a reference to the underlying value.
+    pub fn as_ref(&self) -> &(dyn Any + Send + 'static) {
+        &*self.contents
+    }
+
+    #[allow(clippy::should_implement_trait)]
+    /// Returns a mutable reference to the underlying value.
+    pub fn as_mut(&mut self) -> &mut (dyn Any + Send + 'static) {
+        &mut *self.contents
+    }
+}
diff --git a/lib/api/src/backend/wamr/vm/mod.rs b/lib/api/src/backend/wamr/vm/mod.rs
new file mode 100644
index 0000000000..01e04abdd4
--- /dev/null
+++ b/lib/api/src/backend/wamr/vm/mod.rs
@@ -0,0 +1,144 @@
+mod env;
+pub use env::*;
+
+pub use super::bindings::{
+    wasm_extern_as_func, wasm_extern_as_global, wasm_extern_as_memory, wasm_extern_as_table,
+    wasm_extern_kind, wasm_extern_t, wasm_func_t, wasm_global_t, wasm_instance_t, wasm_memory_t,
+    wasm_ref_t, wasm_table_t,
+};
+use super::{
+    entities::function::env::FunctionEnv, function::Function, global::Global, memory::Memory,
+    table::Table,
+};
+use crate::{AsStoreMut, BackendFunction, BackendGlobal, BackendMemory, BackendTable, Extern};
+use wasmer_types::RawValue;
+
+pub use super::error::Trap;
+
+pub(crate) type VMExtern = *mut wasm_extern_t;
+
+// No EH for now.
+pub(crate) type VMException = ();
+pub(crate) type VMTag = ();
+pub(crate) type VMExternTag = ();
+
+pub(crate) type VMFunction = *mut wasm_func_t;
+pub(crate) type VMFunctionBody = ();
+pub(crate) type VMFunctionCallback = *mut ::std::os::raw::c_void;
+pub(crate) type VMTrampoline = *mut ::std::os::raw::c_void;
+pub(crate) type VMExternFunction = *mut wasm_func_t;
+
+pub(crate) type VMGlobal = *mut wasm_global_t;
+pub(crate) type VMExternGlobal = *mut wasm_global_t;
+
+pub(crate) type VMMemory = *mut wasm_memory_t;
+pub type VMSharedMemory = VMMemory;
+pub(crate) type VMExternMemory = *mut wasm_memory_t;
+
+pub(crate) type VMTable = *mut wasm_table_t;
+pub(crate) type VMExternTable = *mut wasm_table_t;
+
+pub(crate) type VMInstance = *mut wasm_instance_t;
+
+pub(crate) type VMExternObj = ();
+pub(crate) type VMConfig = ();
+
+impl crate::VMExternToExtern for VMExtern {
+    fn to_extern(self, store: &mut impl AsStoreMut) -> Extern {
+        let kind = unsafe { wasm_extern_kind(&mut *self) };
+
+        match kind as u32 {
+            0 => {
+                let func = unsafe { wasm_extern_as_func(&mut *self) };
+                if func.is_null() {
+                    panic!("The wasm-c-api reported extern as function, but is not");
+                }
+                Extern::Function(crate::Function::from_vm_extern(
+                    store,
+                    crate::vm::VMExternFunction::Wamr(func),
+                ))
+            }
+            1 => {
+                let global = unsafe { wasm_extern_as_global(&mut *self) };
+                if global.is_null() {
+                    panic!("The wasm-c-api reported extern as a global, but is not");
+                }
+                Extern::Global(crate::Global::from_vm_extern(
+                    store,
+                    crate::vm::VMExternGlobal::Wamr(global),
+                ))
+            }
+            2 => {
+                let table = unsafe { wasm_extern_as_table(&mut *self) };
+                if table.is_null() {
+                    panic!("The wasm-c-api reported extern as a table, but is not");
+                }
+                Extern::Table(crate::Table::from_vm_extern(
+                    store,
+                    crate::vm::VMExternTable::Wamr(table),
+                ))
+            }
+            3 => {
+                let memory = unsafe { wasm_extern_as_memory(&mut *self) };
+                if memory.is_null() {
+                    panic!("The wasm-c-api reported extern as a table, but is not");
+                }
+                Extern::Memory(crate::Memory::from_vm_extern(
+                    store,
+                    crate::vm::VMExternMemory::Wamr(memory),
+                ))
+            }
+            _ => {
+                unimplemented!()
+            }
+        }
+    }
+}
+
+pub struct VMExceptionRef(*mut wasm_ref_t);
+impl VMExceptionRef {
+    /// Converts the `VMExceptionRef` into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        unimplemented!()
+    }
+
+    /// Extracts a `VMExceptionRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw` must be a valid `VMExceptionRef` instance.
+    pub unsafe fn from_raw(_raw: RawValue) -> Option<Self> {
+        unimplemented!();
+    }
+}
+
+pub(crate) struct VMExternRef(*mut wasm_ref_t);
+impl VMExternRef {
+    /// Converts the `VMExternRef` into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        unimplemented!()
+    }
+
+    /// Extracts a `VMExternRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw` must be a valid `VMExternRef` instance.
+    pub unsafe fn from_raw(_raw: RawValue) -> Option<Self> {
+        unimplemented!();
+    }
+}
+
+pub(crate) struct VMFuncRef(*mut wasm_ref_t);
+impl VMFuncRef {
+    /// Converts the `VMExternRef` into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        unimplemented!()
+    }
+
+    /// Extracts a `VMExternRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw` must be a valid `VMExternRef` instance.
+    pub unsafe fn from_raw(_raw: RawValue) -> Option<Self> {
+        unimplemented!();
+    }
+}
diff --git a/lib/api/src/backend/wasmi/bindings.rs b/lib/api/src/backend/wasmi/bindings.rs
new file mode 100644
index 0000000000..cc5fc874c5
--- /dev/null
+++ b/lib/api/src/backend/wasmi/bindings.rs
@@ -0,0 +1,10 @@
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(unused)]
+
+include!(concat!(env!("OUT_DIR"), "/wasmi_bindings.rs"));
+
+#[allow(unused_imports)]
+// This is here to force its linking.
+use wasmi_c_api::*;
diff --git a/lib/api/src/backend/wasmi/entities/engine.rs b/lib/api/src/backend/wasmi/entities/engine.rs
new file mode 100644
index 0000000000..896d40fce3
--- /dev/null
+++ b/lib/api/src/backend/wasmi/entities/engine.rs
@@ -0,0 +1,108 @@
+//! Data types, functions and traits for `wasmi` runtime's `Engine` implementation.
+use crate::{
+    backend::wasmi::bindings::{wasm_engine_delete, wasm_engine_new, wasm_engine_t},
+    BackendEngine,
+};
+use std::sync::Arc;
+use wasmer_types::{target::Target, Features};
+
+#[derive(Debug)]
+pub(crate) struct CApiEngine {
+    pub(crate) engine: *mut wasm_engine_t,
+}
+
+impl Default for CApiEngine {
+    fn default() -> Self {
+        let engine: *mut wasm_engine_t = unsafe { wasm_engine_new() };
+        Self { engine }
+    }
+}
+
+impl Drop for CApiEngine {
+    fn drop(&mut self) {
+        unsafe { wasm_engine_delete(self.engine) }
+    }
+}
+
+/// The engine for the Web Assembly Micro Runtime.
+#[derive(Clone, Debug, Default)]
+pub struct Engine {
+    pub(crate) inner: Arc<CApiEngine>,
+}
+
+impl Engine {
+    /// Create a new instance of the `wasmi` engine.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub(crate) fn deterministic_id(&self) -> String {
+        String::from("wasmi")
+    }
+
+    /// Returns the WebAssembly features supported by the WASMI engine.
+    pub fn supported_features() -> Features {
+        // WASMI-specific features
+        let mut features = Features::default();
+        features.bulk_memory(true);
+        features.reference_types(true);
+        features.multi_value(true);
+        features.simd(false);
+        features.threads(false);
+        features.exceptions(false);
+        features
+    }
+
+    /// Returns the default features for the WASMI engine.
+    pub fn default_features() -> Features {
+        Self::supported_features()
+    }
+}
+
+unsafe impl Send for Engine {}
+unsafe impl Sync for Engine {}
+
+/// Returns the default engine for the wasmi engine
+pub(crate) fn default_engine() -> Engine {
+    Engine::default()
+}
+
+impl crate::Engine {
+    /// Consume [`self`] into a [`crate::backend::wasmi::engine::Engine`].
+    pub fn into_wasmi(self) -> crate::backend::wasmi::engine::Engine {
+        match self.be {
+            BackendEngine::Wasmi(s) => s,
+            _ => panic!("Not a `wasmi` engine!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::wasmi::engine::Engine`].
+    pub fn as_wasmi(&self) -> &crate::backend::wasmi::engine::Engine {
+        match &self.be {
+            BackendEngine::Wasmi(s) => s,
+            _ => panic!("Not a `wasmi` engine!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wasmi::engine::Engine`].
+    pub fn as_wasmi_mut(&mut self) -> &mut crate::backend::wasmi::engine::Engine {
+        match self.be {
+            BackendEngine::Wasmi(ref mut s) => s,
+            _ => panic!("Not a `wasmi` engine!"),
+        }
+    }
+
+    /// Return true if [`self`] is an engine from the `wasmi` runtime.
+    pub fn is_wasmi(&self) -> bool {
+        matches!(self.be, BackendEngine::Wasmi(_))
+    }
+}
+
+impl From<Engine> for crate::Engine {
+    fn from(value: Engine) -> Self {
+        crate::Engine {
+            be: BackendEngine::Wasmi(value),
+            id: crate::Engine::atomic_next_engine_id(),
+        }
+    }
+}
diff --git a/lib/api/src/backend/wasmi/entities/exception.rs b/lib/api/src/backend/wasmi/entities/exception.rs
new file mode 100644
index 0000000000..4ae913cfa0
--- /dev/null
+++ b/lib/api/src/backend/wasmi/entities/exception.rs
@@ -0,0 +1,63 @@
+//! Data types, functions and traits for `sys` runtime's `Tag` implementation.
+use std::any::Any;
+
+use wasmer_types::{TagType, Type};
+
+use crate::{
+    wasmi::vm::{VMException, VMExceptionRef},
+    AsStoreMut, AsStoreRef, Tag, Value,
+};
+
+use super::store::StoreHandle;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// A WebAssembly `tag` in the `v8` runtime.
+pub(crate) struct Exception {
+    pub(crate) handle: VMException,
+}
+
+unsafe impl Send for Exception {}
+unsafe impl Sync for Exception {}
+
+impl Exception {
+    /// Create a new [`Exception`].
+    pub fn new(store: &mut impl AsStoreMut, tag: Tag, payload: &[Value]) -> Self {
+        todo!()
+    }
+}
+
+#[derive(Debug, Clone)]
+#[repr(transparent)]
+/// A WebAssembly `extern ref` in `wasmi`.
+pub(crate) struct ExceptionRef;
+
+impl ExceptionRef {
+    pub fn new<T>(_store: &mut impl AsStoreMut, _value: T) -> Self
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        unimplemented!("ExceptionRef is not yet supported in wasmi");
+    }
+
+    pub fn downcast<'a, T>(&self, _store: &'a impl AsStoreRef) -> Option<&'a T>
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        unimplemented!("ExceptionRef is not yet supported in wasmi");
+    }
+
+    pub(crate) fn vm_exceptionref(&self) -> VMExceptionRef {
+        unimplemented!("ExceptionRef is not yet supported in wasmi");
+    }
+
+    pub(crate) unsafe fn from_vm_exceptionref(
+        _store: &mut impl AsStoreMut,
+        _vm_exceptionref: VMExceptionRef,
+    ) -> Self {
+        unimplemented!("ExceptionRef is not yet supported in wasmi");
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
diff --git a/lib/api/src/backend/wasmi/entities/external.rs b/lib/api/src/backend/wasmi/entities/external.rs
new file mode 100644
index 0000000000..b6224e52f7
--- /dev/null
+++ b/lib/api/src/backend/wasmi/entities/external.rs
@@ -0,0 +1,42 @@
+//! Data types, functions and traits for `wasmi`'s `ExternRef` implementation.
+use crate::{
+    store::{AsStoreMut, AsStoreRef},
+    wasmi::vm::VMExternRef,
+};
+use std::any::Any;
+
+#[derive(Debug, Clone)]
+#[repr(transparent)]
+/// A WebAssembly `extern ref` in `wasmi`.
+pub struct ExternRef;
+
+impl ExternRef {
+    pub fn new<T>(_store: &mut impl AsStoreMut, _value: T) -> Self
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        unimplemented!("ExternRef is not yet supported with wasm_c_api");
+    }
+
+    pub fn downcast<'a, T>(&self, _store: &'a impl AsStoreRef) -> Option<&'a T>
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        unimplemented!("ExternRef is not yet supported in wasm_c_api");
+    }
+
+    pub(crate) fn vm_externref(&self) -> VMExternRef {
+        unimplemented!("ExternRef is not yet supported in wasm_c_api");
+    }
+
+    pub(crate) unsafe fn from_vm_externref(
+        _store: &mut impl AsStoreMut,
+        _vm_externref: VMExternRef,
+    ) -> Self {
+        unimplemented!("ExternRef is not yet supported in wasm_c_api");
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
diff --git a/lib/api/src/backend/wasmi/entities/function/env.rs b/lib/api/src/backend/wasmi/entities/function/env.rs
new file mode 100644
index 0000000000..c5062e897e
--- /dev/null
+++ b/lib/api/src/backend/wasmi/entities/function/env.rs
@@ -0,0 +1,213 @@
+use std::{any::Any, fmt::Debug, marker::PhantomData};
+
+use crate::{
+    store::{AsStoreMut, AsStoreRef, StoreRef},
+    wasmi::{store::StoreHandle, vm::VMFunctionEnvironment},
+    StoreMut,
+};
+
+#[derive(Debug)]
+#[repr(transparent)]
+/// An opaque reference to a function environment.
+/// The function environment data is owned by the `Store`.
+pub struct FunctionEnv<T> {
+    pub(crate) handle: StoreHandle<VMFunctionEnvironment>,
+    marker: PhantomData<T>,
+}
+
+impl<T> FunctionEnv<T> {
+    /// Make a new FunctionEnv
+    pub fn new(store: &mut impl AsStoreMut, value: T) -> Self
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        Self {
+            handle: StoreHandle::new(
+                store.as_store_mut().objects_mut().as_wasmi_mut(),
+                VMFunctionEnvironment::new(value),
+            ),
+            marker: PhantomData,
+        }
+    }
+
+    /// Get the data as reference
+    pub fn as_ref<'a>(&self, store: &'a impl AsStoreRef) -> &'a T
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        self.handle
+            .get(store.as_store_ref().objects().as_wasmi())
+            .as_ref()
+            .downcast_ref::<T>()
+            .unwrap()
+    }
+
+    pub(crate) fn from_handle(handle: StoreHandle<VMFunctionEnvironment>) -> Self {
+        Self {
+            handle,
+            marker: PhantomData,
+        }
+    }
+
+    /// Get the data as mutable
+    pub fn as_mut<'a>(&self, store: &'a mut impl AsStoreMut) -> &'a mut T
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        self.handle
+            .get_mut(store.objects_mut().as_wasmi_mut())
+            .as_mut()
+            .downcast_mut::<T>()
+            .unwrap()
+    }
+
+    /// Convert it into a `FunctionEnvMut`
+    pub fn into_mut(self, store: &mut impl AsStoreMut) -> FunctionEnvMut<T>
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        FunctionEnvMut {
+            store_mut: store.as_store_mut(),
+            func_env: self,
+        }
+    }
+}
+
+impl<T> PartialEq for FunctionEnv<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.handle == other.handle
+    }
+}
+
+impl<T> Eq for FunctionEnv<T> {}
+
+impl<T> std::hash::Hash for FunctionEnv<T> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.handle.hash(state);
+        self.marker.hash(state);
+    }
+}
+
+impl<T> Clone for FunctionEnv<T> {
+    fn clone(&self) -> Self {
+        Self {
+            handle: self.handle.clone(),
+            marker: self.marker,
+        }
+    }
+}
+
+/// A temporary handle to a [`FunctionEnv`].
+pub struct FunctionEnvMut<'a, T: 'a> {
+    pub(crate) store_mut: StoreMut<'a>,
+    pub(crate) func_env: FunctionEnv<T>,
+}
+
+impl<'a, T> Debug for FunctionEnvMut<'a, T>
+where
+    T: Send + Debug + 'static,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.func_env.as_ref(&self.store_mut).fmt(f)
+    }
+}
+
+impl<T: Send + 'static> FunctionEnvMut<'_, T> {
+    /// Returns a reference to the host state in this function environement.
+    pub fn data(&self) -> &T {
+        self.func_env.as_ref(&self.store_mut)
+    }
+
+    /// Returns a mutable- reference to the host state in this function environement.
+    pub fn data_mut(&mut self) -> &mut T {
+        self.func_env.as_mut(&mut self.store_mut)
+    }
+
+    /// Borrows a new immmutable reference
+    pub fn as_ref(&self) -> FunctionEnv<T> {
+        self.func_env.clone()
+    }
+
+    /// Borrows a new mutable reference
+    pub fn as_mut(&mut self) -> FunctionEnvMut<'_, T> {
+        FunctionEnvMut {
+            store_mut: self.store_mut.as_store_mut(),
+            func_env: self.func_env.clone(),
+        }
+    }
+
+    /// Borrows a new mutable reference of both the attached Store and host state
+    pub fn data_and_store_mut(&mut self) -> (&mut T, StoreMut) {
+        let data = self.func_env.as_mut(&mut self.store_mut) as *mut T;
+        // telling the borrow check to close his eyes here
+        // this is still relatively safe to do as func_env are
+        // stored in a specific vec of Store, separate from the other objects
+        // and not really directly accessible with the StoreMut
+        let data = unsafe { &mut *data };
+        (data, self.store_mut.as_store_mut())
+    }
+}
+
+//impl<T> Into<crate::FunctionEnv<T>> for FunctionEnv<T> {
+//    fn into(self) -> crate::FunctionEnv<T> {
+//        crate::FunctionEnv::Wasmi(self)
+//    }
+//}
+
+impl<T> AsStoreRef for FunctionEnvMut<'_, T> {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        StoreRef {
+            inner: self.store_mut.inner,
+        }
+    }
+}
+
+impl<T> AsStoreMut for FunctionEnvMut<'_, T> {
+    fn as_store_mut(&mut self) -> StoreMut<'_> {
+        StoreMut {
+            inner: self.store_mut.inner,
+        }
+    }
+
+    fn objects_mut(&mut self) -> &mut crate::StoreObjects {
+        self.store_mut.objects_mut()
+    }
+}
+
+impl<T> crate::FunctionEnv<T> {
+    /// Consume [`self`] into [`crate::backend::wasmi::function::env::FunctionEnv`].
+    pub fn into_wasmi(self) -> FunctionEnv<T> {
+        match self.0 {
+            crate::BackendFunctionEnv::Wasmi(s) => s,
+            _ => panic!("Not a `wasmi` function env!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference to [`crate::backend::wasmi::function::env::FunctionEnv`].
+    pub fn as_wasmi(&self) -> &FunctionEnv<T> {
+        match self.0 {
+            crate::BackendFunctionEnv::Wasmi(ref s) => s,
+            _ => panic!("Not a `wasmi` function env!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wasmi::function::env::FunctionEnv`].
+    pub fn as_wasmi_mut(&mut self) -> &mut FunctionEnv<T> {
+        match self.0 {
+            crate::BackendFunctionEnv::Wasmi(ref mut s) => s,
+            _ => panic!("Not a `wasmi` function env!"),
+        }
+    }
+}
+
+impl<'a, T> From<FunctionEnvMut<'a, T>> for crate::FunctionEnvMut<'a, T> {
+    fn from(value: FunctionEnvMut<'a, T>) -> Self {
+        crate::FunctionEnvMut(crate::BackendFunctionEnvMut::Wasmi(value))
+    }
+}
+
+impl<T> From<FunctionEnv<T>> for crate::FunctionEnv<T> {
+    fn from(value: FunctionEnv<T>) -> Self {
+        crate::FunctionEnv(crate::BackendFunctionEnv::Wasmi(value))
+    }
+}
diff --git a/lib/api/src/backend/wasmi/entities/function/mod.rs b/lib/api/src/backend/wasmi/entities/function/mod.rs
new file mode 100644
index 0000000000..fef411bce7
--- /dev/null
+++ b/lib/api/src/backend/wasmi/entities/function/mod.rs
@@ -0,0 +1,719 @@
+//! Data types, functions and traits for `wasmi`'s `Function` implementation.
+
+#![allow(non_snake_case)]
+use std::{
+    ffi::c_void,
+    panic::{self, AssertUnwindSafe},
+};
+
+use crate::{
+    vm::{VMExtern, VMExternFunction},
+    wasmi::{
+        bindings::*,
+        utils::convert::{IntoCApiType, IntoCApiValue, IntoWasmerType, IntoWasmerValue},
+        vm::{VMFuncRef, VMFunction, VMFunctionCallback, VMFunctionEnvironment},
+    },
+    AsStoreMut, AsStoreRef, BackendFunction, BackendFunctionEnvMut, BackendTrap,
+    FromToNativeWasmType, FunctionEnv, FunctionEnvMut, IntoResult, NativeWasmType,
+    NativeWasmTypeInto, RuntimeError, StoreMut, Value, WasmTypeList, WithEnv, WithoutEnv,
+};
+
+use super::{super::error::Trap, store::StoreHandle};
+use wasmer_types::{FunctionType, RawValue};
+
+pub(crate) mod env;
+pub(crate) mod typed;
+
+pub use typed::*;
+
+type CCallback = unsafe extern "C" fn(
+    *mut c_void,
+    *const wasm_val_vec_t,
+    *mut wasm_val_vec_t,
+) -> *mut wasm_trap_t;
+
+#[derive(Clone, PartialEq, Eq)]
+/// A WebAssembly `function` in `wasmi`.
+pub struct Function {
+    pub(crate) handle: VMFunction,
+}
+
+unsafe impl Send for Function {}
+unsafe impl Sync for Function {}
+
+impl From<VMFunction> for Function {
+    fn from(handle: VMFunction) -> Self {
+        Self { handle }
+    }
+}
+
+pub(crate) struct FunctionCallbackEnv<'a, F> {
+    pub(crate) store: StoreMut<'a>,
+    pub(crate) func: F,
+    pub(crate) env_handle: Option<StoreHandle<VMFunctionEnvironment>>,
+}
+
+impl<'a, F> std::fmt::Debug for FunctionCallbackEnv<'a, F> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("FunctionCallbackEnv")
+            .field("env_is_some", &self.env_handle.is_some())
+            .finish()
+    }
+}
+
+impl Function {
+    /// To `VMExtern`.
+    pub fn to_vm_extern(&self) -> VMExtern {
+        let extern_ = unsafe { wasm_func_as_extern(self.handle) };
+        assert!(
+            !extern_.is_null(),
+            "Returned null Function extern from wasm-c-api"
+        );
+        VMExtern::Wasmi(extern_)
+    }
+
+    #[allow(clippy::cast_ptr_alignment)]
+    pub fn new_with_env<FT, F, T: Send + 'static>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        ty: FT,
+        func: F,
+    ) -> Self
+    where
+        FT: Into<FunctionType>,
+        F: Fn(FunctionEnvMut<'_, T>, &[Value]) -> Result<Vec<Value>, RuntimeError>
+            + 'static
+            + Send
+            + Sync,
+    {
+        let fn_ty: FunctionType = ty.into();
+        let params = fn_ty.params();
+
+        let mut param_types = params
+            .into_iter()
+            .map(|param| {
+                let kind = param.into_ct();
+                unsafe { wasm_valtype_new(kind) }
+            })
+            .collect::<Vec<_>>();
+
+        let mut wasm_param_types = unsafe {
+            let mut vec = Default::default();
+            wasm_valtype_vec_new(&mut vec, param_types.len(), param_types.as_ptr());
+            vec
+        };
+
+        let results = fn_ty.results();
+        let mut result_types = results
+            .into_iter()
+            .map(|param| {
+                let kind = param.into_ct();
+                unsafe { wasm_valtype_new(kind) }
+            })
+            .collect::<Vec<_>>();
+
+        let mut wasm_result_types = unsafe {
+            let mut vec = Default::default();
+            wasm_valtype_vec_new(&mut vec, result_types.len(), result_types.as_ptr());
+            vec
+        };
+
+        let wasm_functype = unsafe {
+            wasm_functype_new(
+                &mut wasm_param_types as *mut _,
+                &mut wasm_result_types as *mut _,
+            )
+        };
+
+        let mut store = store.as_store_mut();
+        let inner = store.inner.store.as_wasmi().inner;
+
+        let callback: CCallback = make_fn_callback(&func, param_types.len());
+
+        let mut callback_env: *mut FunctionCallbackEnv<'_, F> =
+            Box::leak(Box::new(FunctionCallbackEnv {
+                store,
+                func,
+                env_handle: Some(env.as_wasmi().handle.clone()),
+            }));
+
+        let wasm_function = unsafe {
+            wasm_func_new_with_env(
+                inner,
+                wasm_functype,
+                Some(callback),
+                callback_env as *mut _ as _,
+                None,
+            )
+        };
+
+        if wasm_function.is_null() {
+            panic!("failed when creating new typed function");
+        }
+
+        Function {
+            handle: wasm_function,
+        }
+    }
+
+    /// Creates a new host `Function` from a native function.
+    pub fn new_typed<F, Args, Rets>(store: &mut impl AsStoreMut, func: F) -> Self
+    where
+        F: crate::HostFunction<(), Args, Rets, WithoutEnv> + 'static + Send + Sync,
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+    {
+        let mut param_types = Args::wasm_types()
+            .into_iter()
+            .map(|param| {
+                let kind = param.into_ct();
+                unsafe { wasm_valtype_new(kind) }
+            })
+            .collect::<Vec<_>>();
+
+        let mut wasm_param_types = unsafe {
+            let mut vec = Default::default();
+            wasm_valtype_vec_new(&mut vec, param_types.len(), param_types.as_ptr());
+            vec
+        };
+
+        let mut result_types = Rets::wasm_types()
+            .into_iter()
+            .map(|param| {
+                let kind = param.into_ct();
+                unsafe { wasm_valtype_new(kind) }
+            })
+            .collect::<Vec<_>>();
+
+        let mut wasm_result_types = unsafe {
+            let mut vec = Default::default();
+            wasm_valtype_vec_new(&mut vec, result_types.len(), result_types.as_ptr());
+            vec
+        };
+
+        let wasm_functype =
+            unsafe { wasm_functype_new(&mut wasm_param_types, &mut wasm_result_types) };
+
+        let mut store = store.as_store_mut();
+        let inner = store.inner.store.as_wasmi().inner;
+
+        let callback: CCallback = unsafe {
+            std::mem::transmute(
+                func.function_callback(crate::BackendKind::Wasmi)
+                    .into_wasmi(),
+            )
+        };
+
+        let mut callback_env: *mut FunctionCallbackEnv<'_, F> =
+            Box::into_raw(Box::new(FunctionCallbackEnv {
+                store,
+                func,
+                env_handle: None,
+            }));
+
+        let wasm_function = unsafe {
+            wasm_func_new_with_env(
+                inner,
+                wasm_functype,
+                Some(callback),
+                callback_env as _,
+                None,
+            )
+        };
+
+        if wasm_function.is_null() {
+            panic!("failed when creating new typed function");
+        }
+
+        Function {
+            handle: wasm_function,
+        }
+    }
+
+    pub fn new_typed_with_env<T, F, Args, Rets>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        func: F,
+    ) -> Self
+    where
+        F: crate::HostFunction<T, Args, Rets, WithEnv>,
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+        T: Send + 'static,
+    {
+        let mut param_types = Args::wasm_types()
+            .into_iter()
+            .map(|param| {
+                let kind = param.into_ct();
+                unsafe { wasm_valtype_new(kind) }
+            })
+            .collect::<Vec<_>>();
+
+        let mut wasm_param_types = unsafe {
+            let mut vec = wasm_valtype_vec_t::default();
+            wasm_valtype_vec_new(&mut vec, param_types.len(), param_types.as_ptr());
+            vec
+        };
+
+        let mut result_types = Rets::wasm_types()
+            .into_iter()
+            .map(|param| {
+                let kind = param.into_ct();
+                unsafe { wasm_valtype_new(kind) }
+            })
+            .collect::<Vec<_>>();
+
+        let mut wasm_result_types = unsafe {
+            let mut vec: wasm_valtype_vec_t = Default::default();
+            wasm_valtype_vec_new(&mut vec, result_types.len(), result_types.as_ptr());
+            vec
+        };
+
+        let wasm_functype = unsafe {
+            wasm_functype_new(
+                &mut wasm_param_types as *mut _,
+                &mut wasm_result_types as *mut _,
+            )
+        };
+
+        let mut store = store.as_store_mut();
+        let inner = store.inner.store.as_wasmi().inner;
+
+        let callback: CCallback = unsafe {
+            std::mem::transmute(
+                func.function_callback(crate::BackendKind::Wasmi)
+                    .into_wasmi(),
+            )
+        };
+
+        let mut callback_env: *mut FunctionCallbackEnv<'_, F> =
+            Box::into_raw(Box::new(FunctionCallbackEnv {
+                store,
+                func,
+                env_handle: Some(env.as_wasmi().handle.clone()),
+            }));
+
+        let wasm_function = unsafe {
+            wasm_func_new_with_env(
+                inner,
+                wasm_functype,
+                Some(callback),
+                callback_env as _,
+                None,
+            )
+        };
+
+        if wasm_function.is_null() {
+            panic!("failed when creating new typed function");
+        }
+
+        Function {
+            handle: wasm_function,
+        }
+    }
+
+    pub fn ty(&self, _store: &impl AsStoreRef) -> FunctionType {
+        let type_ = unsafe { wasm_func_type(self.handle) };
+        let params: *const wasm_valtype_vec_t = unsafe { wasm_functype_params(type_) };
+        let returns: *const wasm_valtype_vec_t = unsafe { wasm_functype_results(type_) };
+
+        let params: Vec<wasmer_types::Type> = unsafe {
+            let mut res = vec![];
+            for i in 0..(*params).size {
+                res.push((*(*params).data.wrapping_add(i)).into_wt());
+            }
+            res
+        };
+
+        let returns: Vec<wasmer_types::Type> = unsafe {
+            let mut res = vec![];
+            for i in 0..(*returns).size {
+                res.push((*(*returns).data.wrapping_add(i)).into_wt());
+            }
+            res
+        };
+
+        FunctionType::new(params, returns)
+    }
+
+    pub fn call_raw(
+        &self,
+        _store: &mut impl AsStoreMut,
+        _params: Vec<RawValue>,
+    ) -> Result<Box<[Value]>, RuntimeError> {
+        // There is no optimal call_raw in JSC, so we just
+        // simply rely the call
+        // self.call(store, params)
+        unimplemented!();
+    }
+
+    pub fn call(
+        &self,
+        store: &mut impl AsStoreMut,
+        params: &[Value],
+    ) -> Result<Box<[Value]>, RuntimeError> {
+        // unimplemented!();
+        let store_mut = store.as_store_mut();
+        // let wasm_func_param_arity(self.handle)
+
+        let mut args = {
+            unsafe {
+                let mut wasm_params = params
+                    .into_iter()
+                    .map(|v| IntoCApiValue::into_cv(v.clone()))
+                    .collect::<Vec<_>>()
+                    .into_boxed_slice();
+                let mut vec = Default::default();
+                wasm_val_vec_new(&mut vec, wasm_params.len(), wasm_params.as_ptr());
+                vec
+            }
+        };
+
+        let size = unsafe { wasm_func_result_arity(self.handle) };
+
+        let mut results = {
+            unsafe {
+                let mut vec = Default::default();
+                wasm_val_vec_new_uninitialized(&mut vec, size);
+                vec
+            }
+        };
+
+        let mut trap;
+
+        loop {
+            trap = unsafe { wasm_func_call(self.handle, &mut args as _, &mut results as *mut _) };
+
+            let store_mut = store.as_store_mut();
+            if let Some(callback) = store_mut.inner.on_called.take() {
+                match callback(store_mut) {
+                    Ok(wasmer_types::OnCalledAction::InvokeAgain) => {
+                        continue;
+                    }
+                    Ok(wasmer_types::OnCalledAction::Finish) => {
+                        break;
+                    }
+                    Ok(wasmer_types::OnCalledAction::Trap(trap)) => {
+                        return Err(RuntimeError::user(trap))
+                    }
+                    Err(trap) => return Err(RuntimeError::user(trap)),
+                }
+            }
+            break;
+        }
+
+        if !trap.is_null() {
+            return Err(Into::<Trap>::into(trap).into());
+        }
+
+        unsafe {
+            let results = std::ptr::slice_from_raw_parts(results.data, results.size);
+            return Ok((*results)
+                .into_iter()
+                .map(|v| IntoWasmerValue::into_wv(*v))
+                .collect::<Vec<_>>()
+                .into_boxed_slice());
+        }
+    }
+
+    pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, internal: VMExternFunction) -> Self {
+        Self {
+            handle: internal.into_wasmi(),
+        }
+    }
+
+    pub(crate) fn vm_funcref(&self, _store: &impl AsStoreRef) -> VMFuncRef {
+        unimplemented!();
+    }
+
+    pub(crate) unsafe fn from_vm_funcref(
+        _store: &mut impl AsStoreMut,
+        _funcref: VMFuncRef,
+    ) -> Self {
+        unimplemented!();
+    }
+
+    /// Checks whether this `Function` can be used with the given context.
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
+
+fn make_fn_callback<F, T: Send + 'static>(func: &F, args: usize) -> CCallback
+where
+    F: Fn(FunctionEnvMut<'_, T>, &[Value]) -> Result<Vec<Value>, RuntimeError>
+        + 'static
+        + Send
+        + Sync,
+{
+    unsafe extern "C" fn fn_callback<F, T: Send + 'static>(
+        env: *mut c_void,
+        args: *const wasm_val_vec_t,
+        rets: *mut wasm_val_vec_t,
+    ) -> *mut wasm_trap_t
+    where
+        F: Fn(FunctionEnvMut<'_, T>, &[Value]) -> Result<Vec<Value>, RuntimeError>
+            + 'static
+            + Send
+            + Sync,
+    {
+        let r: *mut (FunctionCallbackEnv<'_, F>) = env as _;
+
+        let mut store = (*r).store.as_store_mut();
+        let env_handle = (*r).env_handle.as_ref().unwrap().clone();
+        let mut fn_env = env::FunctionEnv::from_handle(env_handle).into_mut(&mut store);
+        let func: &F = &(*r).func;
+
+        let mut wasmer_args = vec![];
+
+        for i in 0..(*args).size {
+            wasmer_args.push((*(*args).data.wrapping_add(i)).into_wv().clone());
+        }
+
+        let result = panic::catch_unwind(AssertUnwindSafe(|| unsafe {
+            func(fn_env.into(), wasmer_args.as_slice())
+        }));
+
+        match result {
+            Ok(Ok(native_results)) => {
+                let mut c_results: Vec<wasm_val_t> = native_results
+                    .into_iter()
+                    .map(IntoCApiValue::into_cv)
+                    .collect();
+
+                if c_results.len() != (*rets).size {
+                    panic!("when calling host function: number of observed results differ from wanted results")
+                }
+
+                unsafe {
+                    for i in 0..(*rets).size {
+                        *((*rets).data.wrapping_add(i)) = c_results[i]
+                    }
+                }
+
+                unsafe { std::ptr::null_mut() }
+            }
+
+            Ok(Err(e)) => {
+                let trap: Trap = Trap::user(Box::new(e));
+                unsafe { trap.into_wasm_trap(&mut store) }
+            }
+
+            Err(e) => {
+                unimplemented!("host function panicked");
+            }
+        }
+    }
+
+    return fn_callback::<F, T>;
+}
+
+impl std::fmt::Debug for Function {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.debug_struct("Function").finish()
+    }
+}
+
+impl crate::Function {
+    /// Consume [`self`] into [`crate::backend::wasmi::function::Function`].
+    pub fn into_wasmi(self) -> crate::backend::wasmi::function::Function {
+        match self.0 {
+            BackendFunction::Wasmi(s) => s,
+            _ => panic!("Not a `wasmi` function!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference to [`crate::backend::wasmi::function::Function`].
+    pub fn as_wasmi(&self) -> &crate::backend::wasmi::function::Function {
+        match self.0 {
+            BackendFunction::Wasmi(ref s) => s,
+            _ => panic!("Not a `wasmi` function!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wasmi::function::Function`].
+    pub fn as_wasmi_mut(&mut self) -> &mut crate::backend::wasmi::function::Function {
+        match self.0 {
+            BackendFunction::Wasmi(ref mut s) => s,
+            _ => panic!("Not a `wasmi` function!"),
+        }
+    }
+}
+
+macro_rules! impl_host_function {
+    ([$c_struct_representation:ident] $c_struct_name:ident, $( $x:ident ),* ) => {
+        paste::paste! {
+        #[allow(non_snake_case)]
+        pub(crate) fn [<gen_fn_callback_ $c_struct_name:lower _no_env>]
+            <$( $x: FromToNativeWasmType, )* Rets: WasmTypeList, RetsAsResult: IntoResult<Rets>, Func: Fn($( $x , )*) -> RetsAsResult + 'static>
+            (this: &Func) -> crate::backend::wasmi::vm::VMFunctionCallback {
+
+            /// This is a function that wraps the real host
+            /// function. Its address will be used inside the
+            /// runtime.
+            unsafe extern "C" fn func_wrapper<$( $x, )* Rets, RetsAsResult, Func>(env: *mut c_void, args: *const wasm_val_vec_t, results: *mut wasm_val_vec_t) -> *mut wasm_trap_t
+            where
+                $( $x: FromToNativeWasmType, )*
+                Rets: WasmTypeList,
+                RetsAsResult: IntoResult<Rets>,
+                Func: Fn($( $x , )*) -> RetsAsResult + 'static,
+            {
+                let mut r: *mut crate::backend::wasmi::function::FunctionCallbackEnv<Func> = unsafe {std::mem::transmute(env)};
+                let store = &mut (*r).store.as_store_mut();
+                let mut i = 0;
+
+                $(
+                    let c_arg = (*(*args).data.wrapping_add(i)).clone();
+                    let wasmer_arg = c_arg.into_wv();
+                    let raw_arg : RawValue = wasmer_arg.as_raw(store);
+                    let $x : $x = FromToNativeWasmType::from_native($x::Native::from_raw(store, raw_arg));
+
+                    i += 1;
+                )*
+
+                let result = panic::catch_unwind(AssertUnwindSafe(|| unsafe {
+                    ((*r).func)( $( $x, )* ).into_result()
+                }));
+
+                match result {
+                    Ok(Ok(result)) => {
+
+                        let types = Rets::wasm_types();
+                        let mut native_results = result.into_array(store);
+                        let native_results = native_results.as_mut();
+
+                        let native_results: Vec<Value> = native_results.into_iter().enumerate()
+                            .map(|(i, r)| Value::from_raw(store, types[i], r.clone()))
+                            .collect();
+
+                        let mut c_results: Vec<wasm_val_t> = native_results.into_iter().map(IntoCApiValue::into_cv).collect();
+
+                        if c_results.len() != (*results).size {
+                            panic!("when calling host function: number of observed results differ from wanted results")
+                        }
+
+                        unsafe {
+                            for i in 0..(*results).size {
+                                *((*results).data.wrapping_add(i)) = c_results[i]
+                            }
+                        }
+
+                         unsafe { std::ptr::null_mut() }
+                    },
+
+                    Ok(Err(e)) => {
+                        let trap =  crate::backend::wasmi::error::Trap::user(Box::new(e));
+                        unsafe { trap.into_wasm_trap(store) }
+                        // unimplemented!("host function panicked");
+                    },
+
+                    Err(e) => {
+                        unimplemented!("host function panicked");
+                    }
+                }
+            }
+            func_wrapper::< $( $x, )* Rets, RetsAsResult, Func> as _
+        }
+
+
+        #[allow(non_snake_case)]
+        pub(crate) fn [<gen_fn_callback_ $c_struct_name:lower>]
+            <$( $x: FromToNativeWasmType, )* Rets: WasmTypeList, RetsAsResult: IntoResult<Rets>, T: Send + 'static,  Func: Fn(FunctionEnvMut<T>, $( $x , )*) -> RetsAsResult + 'static>
+            (this: &Func) -> crate::backend::wasmi::vm::VMFunctionCallback {
+            unsafe extern "C" fn func_wrapper<$( $x, )* Rets, RetsAsResult, Func, T>(env: *mut c_void, args: *const wasm_val_vec_t, results: *mut wasm_val_vec_t) -> *mut wasm_trap_t
+            where
+              $( $x: FromToNativeWasmType, )*
+              Rets: WasmTypeList,
+              RetsAsResult: IntoResult<Rets>,
+              T: Send + 'static,
+              Func: Fn(FunctionEnvMut<'_, T>, $( $x , )*) -> RetsAsResult + 'static,
+            {
+
+              let r: *mut (crate::backend::wasmi::function::FunctionCallbackEnv<'_, Func>) = env as _;
+              let store = &mut (*r).store.as_store_mut();
+
+              let mut i = 0;
+
+              $(
+              let c_arg = (*(*args).data.wrapping_add(i)).clone();
+              let wasmer_arg = c_arg.into_wv();
+              let raw_arg : RawValue = wasmer_arg.as_raw(store);
+              let $x : $x = FromToNativeWasmType::from_native($x::Native::from_raw(store, raw_arg));
+
+              i += 1;
+              )*
+
+              let env_handle = (*r).env_handle.as_ref().unwrap().clone();
+              let mut fn_env = crate::backend::wasmi::function::env::FunctionEnv::from_handle(env_handle).into_mut(store);
+              let func: &Func = &(*r).func;
+
+              let result = panic::catch_unwind(AssertUnwindSafe(|| unsafe {
+                  ((*r).func)(BackendFunctionEnvMut::Wasmi(fn_env).into(), $( $x, )* ).into_result()
+              }));
+
+
+              match result {
+                  Ok(Ok(result)) => {
+                    let types = Rets::wasm_types();
+                    let mut native_results = result.into_array(store);
+                    let native_results = native_results.as_mut();
+
+                    let native_results: Vec<Value> = native_results.into_iter().enumerate().map(|(i, r)| Value::from_raw(store, types[i], r.clone())).collect();
+
+                    let mut c_results: Vec<wasm_val_t> = native_results.into_iter().map(IntoCApiValue::into_cv).collect();
+
+                    if c_results.len() != (*results).size {
+                        panic!("when calling host function: number of observed results differ from wanted results")
+                    }
+
+                    unsafe {
+                        for i in 0..(*results).size {
+                            *((*results).data.wrapping_add(i)) = c_results[i]
+                        }
+
+                    }
+
+                    unsafe { std::ptr::null_mut() }
+                },
+
+                Ok(Err(e)) => { let trap = crate::backend::wasmi::error::Trap::user(Box::new(e)); unsafe { trap.into_wasm_trap(store) } },
+
+                Err(e) => { unimplemented!("host function panicked"); }
+              }
+            }
+
+            func_wrapper::< $( $x, )* Rets, RetsAsResult, Func, T> as _
+        }
+        }
+    };
+}
+
+// Here we go! Let's generate all the C struct, `WasmTypeList`
+// implementations and `HostFunction` implementations.
+impl_host_function!([C] S0,);
+impl_host_function!([transparent] S1, A1);
+impl_host_function!([C] S2, A1, A2);
+impl_host_function!([C] S3, A1, A2, A3);
+impl_host_function!([C] S4, A1, A2, A3, A4);
+impl_host_function!([C] S5, A1, A2, A3, A4, A5);
+impl_host_function!([C] S6, A1, A2, A3, A4, A5, A6);
+impl_host_function!([C] S7, A1, A2, A3, A4, A5, A6, A7);
+impl_host_function!([C] S8, A1, A2, A3, A4, A5, A6, A7, A8);
+impl_host_function!([C] S9, A1, A2, A3, A4, A5, A6, A7, A8, A9);
+impl_host_function!([C] S10, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+impl_host_function!([C] S11, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
+impl_host_function!([C] S12, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
+impl_host_function!([C] S13, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
+impl_host_function!([C] S14, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
+impl_host_function!([C] S15, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
+impl_host_function!([C] S16, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16);
+impl_host_function!([C] S17, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17);
+impl_host_function!([C] S18, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18);
+impl_host_function!([C] S19, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19);
+impl_host_function!([C] S20, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20);
+impl_host_function!([C] S21, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21);
+impl_host_function!([C] S22, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22);
+impl_host_function!([C] S23, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23);
+impl_host_function!([C] S24, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24);
+impl_host_function!([C] S25, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25);
+impl_host_function!([C] S26, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26);
diff --git a/lib/api/src/backend/wasmi/entities/function/typed.rs b/lib/api/src/backend/wasmi/entities/function/typed.rs
new file mode 100644
index 0000000000..d4f4806768
--- /dev/null
+++ b/lib/api/src/backend/wasmi/entities/function/typed.rs
@@ -0,0 +1,145 @@
+//! Native Functions.
+//!
+//! This module creates the helper `TypedFunction` that let us call WebAssembly
+//! functions with the native ABI, that is:
+//!
+//! ```ignore
+//! let add_one = instance.exports.get_function("function_name")?;
+//! let add_one_native: TypedFunction<i32, i32> = add_one.typed().unwrap();
+//! ```
+
+use std::iter::FromIterator;
+
+use crate::{
+    backend::wasmi::{bindings::*, error::Trap, function::Function, utils::convert::*},
+    AsStoreMut, FromToNativeWasmType, NativeWasmType, NativeWasmTypeInto, RuntimeError,
+    TypedFunction, Value, WasmTypeList,
+};
+use wasmer_types::RawValue;
+
+macro_rules! impl_native_traits {
+    (  $( $x:ident ),* ) => {
+        #[allow(unused_parens, non_snake_case)]
+         impl<$( $x , )* Rets> TypedFunction<( $( $x ),* ), Rets>
+         where
+             $( $x: FromToNativeWasmType, )*
+             Rets: WasmTypeList,
+         {
+             /// Call the typed func and return results.
+            #[allow(clippy::too_many_arguments)]
+            pub fn call_wasmi(&self, mut store: &mut impl AsStoreMut, $( $x: $x, )* ) -> Result<Rets, RuntimeError> where
+            $( $x: FromToNativeWasmType, )*
+            {
+
+                 // // let store_ptr = Value::I64(store.as_store_mut().as_raw() as _).as_jsvalue(store);
+                 #[allow(unused_unsafe)]
+                 let params_list: Vec<_> = unsafe {
+                     vec![ $( {
+                         let raw = $x.to_native().into_raw(store);
+                         let value = Value::from_raw(&mut store, <$x::Native as NativeWasmType>::WASM_TYPE, raw);
+                         value.into_cv()
+                     } ),* ]
+                 };
+
+                 let mut results = {
+                    unsafe {
+                        let mut ret = std::mem::zeroed();
+                        wasm_val_vec_new_uninitialized(&mut ret, Rets::wasm_types().len());
+                        ret
+                    }
+                };
+
+
+                let func = unsafe { wasm_extern_as_func(self.func.to_vm_extern().into_wasmi()) };
+
+                let mut params = unsafe {std::mem::zeroed()};
+                unsafe {wasm_val_vec_new(&mut params, params_list.len(), params_list.as_ptr())};
+
+                 let mut trap;
+
+                 loop {
+                    trap = unsafe { wasm_func_call(func, &params, &mut results) };
+
+                    let store_mut = store.as_store_mut();
+                    if let Some(callback) = store_mut.inner.on_called.take() {
+                        match callback(store_mut) {
+                            Ok(wasmer_types::OnCalledAction::InvokeAgain) => { continue; }
+                            Ok(wasmer_types::OnCalledAction::Finish) => { break; }
+                            Ok(wasmer_types::OnCalledAction::Trap(trap)) => { return Err(RuntimeError::user(trap)) },
+                            Err(trap) => { return Err(RuntimeError::user(trap)) },
+                        }
+                    }
+                    break;
+                };
+
+                 if !trap.is_null() {
+                     unsafe {
+                        let trap: Trap = trap.into();
+                        return Err(RuntimeError::from(trap));
+                     }
+                }
+
+                unsafe {
+                    let mut rets_list_array = Rets::empty_array();
+                    let mut_rets = rets_list_array.as_mut() as *mut [RawValue] as *mut RawValue;
+
+                    match Rets::size() {
+                        0 => {},
+                        1 => {
+                            let val = (*results.data.wrapping_add(0)).clone();
+                            let val = val.into_wv();
+                            *mut_rets = val.as_raw(&mut store);
+                        }
+                        _n => {
+                            for (i, ret_type) in Rets::wasm_types().iter().enumerate() {
+                                    let val = (*results.data.wrapping_add(i)).clone();
+                                    let val = val.into_wv();
+                                    let slot = mut_rets.add(i);
+                                    *slot = val.as_raw(&mut store);
+                            }
+                        }
+                    }
+
+                    Ok(unsafe { Rets::from_array(store, rets_list_array) })
+                }
+            }
+
+            #[doc(hidden)]
+            #[allow(missing_docs)]
+            #[allow(unused_mut)]
+            #[allow(clippy::too_many_arguments)]
+            pub fn call_raw_wasmi(&self, store: &mut impl AsStoreMut, mut params_list: Vec<RawValue> ) -> Result<Rets, RuntimeError> {
+                todo!("Raw calls from wasmi are not supported yet!")
+            }
+        }
+    };
+
+}
+
+impl_native_traits!();
+impl_native_traits!(A1);
+impl_native_traits!(A1, A2);
+impl_native_traits!(A1, A2, A3);
+impl_native_traits!(A1, A2, A3, A4);
+impl_native_traits!(A1, A2, A3, A4, A5);
+impl_native_traits!(A1, A2, A3, A4, A5, A6);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17);
+impl_native_traits!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18
+);
+impl_native_traits!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19
+);
+impl_native_traits!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20
+);
diff --git a/lib/api/src/backend/wasmi/entities/global.rs b/lib/api/src/backend/wasmi/entities/global.rs
new file mode 100644
index 0000000000..3304083423
--- /dev/null
+++ b/lib/api/src/backend/wasmi/entities/global.rs
@@ -0,0 +1,122 @@
+//! Data types, functions and traits for `wasmi`'s `Global` implementation.
+use wasmer_types::{GlobalType, Mutability};
+
+use crate::{
+    vm::{VMExtern, VMExternGlobal},
+    wasmi::{
+        bindings::{
+            self, wasm_global_as_extern, wasm_global_get, wasm_global_new, wasm_global_set,
+            wasm_global_type, wasm_globaltype_content, wasm_globaltype_mutability,
+            wasm_globaltype_new, wasm_mutability_t, wasm_valtype_new,
+        },
+        utils::convert::{IntoCApiType, IntoCApiValue, IntoWasmerType, IntoWasmerValue},
+        vm::VMGlobal,
+    },
+    AsStoreMut, AsStoreRef, RuntimeError, Value,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// A WebAssembly `global` in `wasmi`.
+pub struct Global {
+    pub(crate) handle: VMGlobal,
+}
+
+unsafe impl Send for Global {}
+unsafe impl Sync for Global {}
+
+// Global can't be Send in js because it dosen't support `structuredClone`
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// unsafe impl Send for Global {}
+
+impl Global {
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        let extern_ = unsafe { wasm_global_as_extern(self.handle) };
+        assert!(
+            !extern_.is_null(),
+            "Returned null Global extern from wasm-c-api"
+        );
+        VMExtern::Wasmi(extern_)
+    }
+
+    /// Create a `Global` with the initial value [`Value`] and the provided [`Mutability`].
+    pub(crate) fn from_value(
+        store: &mut impl AsStoreMut,
+        val: Value,
+        mutability: Mutability,
+    ) -> Result<Self, RuntimeError> {
+        let store = store.as_store_mut();
+
+        let wasmi_type = val.ty().into_ct();
+        let wasmi_value = val.into_cv();
+        let wasmi_mutability = if mutability.is_mutable() {
+            bindings::wasm_mutability_enum_WASM_VAR
+        } else {
+            bindings::wasm_mutability_enum_WASM_CONST
+        } as wasm_mutability_t;
+
+        let wasmi_global_type =
+            unsafe { wasm_globaltype_new(wasm_valtype_new(wasmi_type), wasmi_mutability) };
+
+        Ok(Self {
+            handle: unsafe {
+                wasm_global_new(
+                    store.inner.store.as_wasmi().inner,
+                    wasmi_global_type,
+                    &wasmi_value,
+                )
+            },
+        })
+    }
+
+    pub fn ty(&self, _store: &impl AsStoreRef) -> GlobalType {
+        let r#type = unsafe { wasm_global_type(self.handle) };
+        let mutability = unsafe { wasm_globaltype_mutability(&*r#type) };
+        let valtype = unsafe { wasm_globaltype_content(r#type) };
+        let wasmer_type = valtype.into_wt();
+
+        GlobalType::new(
+            wasmer_type,
+            if mutability == bindings::wasm_mutability_enum_WASM_VAR as u8 {
+                Mutability::Var
+            } else {
+                Mutability::Const
+            },
+        )
+    }
+
+    pub fn get(&self, store: &mut impl AsStoreMut) -> Value {
+        let mut out = unsafe { std::mem::zeroed() };
+        unsafe { wasm_global_get(self.handle, &mut out) };
+        out.into_wv()
+    }
+
+    pub fn set(&self, store: &mut impl AsStoreMut, val: Value) -> Result<(), RuntimeError> {
+        if val.ty() != self.ty(store).ty {
+            return Err(RuntimeError::new(format!(
+                "Incompatible types: {} != {}",
+                val.ty(),
+                self.ty(store)
+            )));
+        }
+
+        if self.ty(store).mutability == Mutability::Const {
+            return Err(RuntimeError::new("The global is immutable".to_owned()));
+        }
+
+        let value = val.into_cv();
+
+        unsafe { wasm_global_set(self.handle, &value) };
+
+        Ok(())
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_global: VMExternGlobal) -> Self {
+        Self {
+            handle: vm_global.into_wasmi(),
+        }
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
diff --git a/lib/api/src/backend/wasmi/entities/instance.rs b/lib/api/src/backend/wasmi/entities/instance.rs
new file mode 100644
index 0000000000..5b3bcc14e2
--- /dev/null
+++ b/lib/api/src/backend/wasmi/entities/instance.rs
@@ -0,0 +1,165 @@
+//! Data types, functions and traits for `wasmi`'s `Instance` implementation.
+use std::sync::Arc;
+
+use crate::{
+    backend::wasmi::bindings::*, entities::external::VMExternToExtern, vm::VMExtern,
+    wasmi::error::Trap, AsStoreMut, AsStoreRef, Exports, Extern, Imports, InstantiationError,
+    Module,
+};
+
+#[derive(PartialEq, Eq)]
+pub(crate) struct InstanceHandle(pub(crate) *mut wasm_instance_t);
+
+unsafe impl Send for InstanceHandle {}
+unsafe impl Sync for InstanceHandle {}
+
+impl InstanceHandle {
+    fn new(
+        store: *mut wasm_store_t,
+        module: *mut wasm_module_t,
+        mut externs: Vec<VMExtern>,
+    ) -> Result<Self, InstantiationError> {
+        // Check if the thread env was already initialised.
+        //unsafe {
+        //    if !wasm_runtime_thread_env_inited() {
+        //        if !wasm_runtime_init_thread_env() {
+        //            panic!("Failed to initialize the thread environment!");
+        //        }
+        //    }
+        //}
+
+        let mut trap: *mut wasm_trap_t = std::ptr::null_mut() as _;
+        let externs: Vec<_> = externs.into_iter().map(|v| v.into_wasmi()).collect();
+
+        let instance = unsafe {
+            let mut imports = unsafe {
+                let mut vec = Default::default();
+                wasm_extern_vec_new(&mut vec, externs.len(), externs.as_ptr());
+                vec
+            };
+
+            std::mem::forget(externs);
+
+            wasm_instance_new(store, module, &mut imports, &mut trap)
+        };
+
+        if instance.is_null() {
+            let trap = Trap::from(trap);
+            return Err(InstantiationError::Start(trap.into()));
+        }
+
+        Ok(InstanceHandle(instance))
+    }
+
+    fn get_exports(&self, mut store: &mut impl AsStoreMut, module: &Module) -> Exports {
+        let mut c_api_externs = unsafe {
+            let mut vec = Default::default();
+            wasm_instance_exports(self.0, &mut vec);
+            vec
+        };
+
+        let c_api_externs: &[*mut wasm_extern_t] =
+            unsafe { std::slice::from_raw_parts(c_api_externs.data, c_api_externs.size) };
+        let c_api_externs = c_api_externs.to_vec();
+        let mut exports = unsafe {
+            let mut vec = Default::default();
+            wasm_module_exports(module.as_wasmi().handle.inner, &mut vec);
+            vec
+        };
+
+        let c_api_exports: &[*mut wasm_exporttype_t] =
+            unsafe { std::slice::from_raw_parts(exports.data, exports.size) };
+        let c_api_exports = c_api_exports.to_vec();
+
+        // We need to use the order of the exports from the polyfill info to get the right
+        // one, i.e. the from the declaration.
+        let module_exports = module.exports().collect::<Vec<_>>();
+
+        let c_api_exports: Exports = c_api_exports
+            .into_iter()
+            .zip(c_api_externs.into_iter())
+            .map(|(export, ext)| unsafe {
+                let name = wasm_exporttype_name(export);
+                let name = std::slice::from_raw_parts((*name).data as *const u8, (*name).size);
+                let name = String::from_utf8(name.to_vec()).unwrap_or_default();
+                let ext = ext.to_extern(&mut store);
+                (name, ext)
+            })
+            .collect();
+
+        let mut exports = Exports::new();
+
+        for e in module_exports {
+            let ext: Extern = c_api_exports.get::<Extern>(e.name()).unwrap().clone();
+            exports.insert(e.name().to_string(), ext);
+        }
+
+        exports
+    }
+}
+impl Drop for InstanceHandle {
+    fn drop(&mut self) {
+        unsafe { wasm_instance_delete(self.0) }
+    }
+}
+
+#[derive(Clone, PartialEq, Eq)]
+/// A WebAssembly `instance` in `wasmi`.
+pub struct Instance {
+    pub(crate) handle: Arc<InstanceHandle>,
+}
+
+impl Instance {
+    pub(crate) fn new(
+        store: &mut impl AsStoreMut,
+        module: &Module,
+        imports: &Imports,
+    ) -> Result<(Self, Exports), InstantiationError> {
+        let externs = module
+            .imports()
+            .map(|import_ty| {
+                imports
+                    .get_export(import_ty.module(), import_ty.name())
+                    .expect("Extern not found")
+            })
+            .collect::<Vec<_>>();
+
+        return Self::new_by_index(store, module, &externs);
+    }
+
+    pub(crate) fn new_by_index(
+        store: &mut impl AsStoreMut,
+        module: &Module,
+        externs: &[Extern],
+    ) -> Result<(Self, Exports), InstantiationError> {
+        let store_ref = store.as_store_ref();
+        let externs: Vec<VMExtern> = externs
+            .iter()
+            .map(|extern_| extern_.to_vm_extern())
+            .collect::<Vec<_>>();
+
+        let instance = InstanceHandle::new(
+            store_ref.inner.store.as_wasmi().inner,
+            module.as_wasmi().handle.inner,
+            externs,
+        )?;
+        let exports = instance.get_exports(store, module);
+
+        Ok((
+            Self {
+                handle: Arc::new(instance),
+            },
+            exports,
+        ))
+    }
+}
+
+impl crate::BackendInstance {
+    /// Consume [`self`] into a [`crate::backend::wasmi::instance::Instance`].
+    pub(crate) fn into_wasmi(self) -> crate::backend::wasmi::instance::Instance {
+        match self {
+            Self::Wasmi(s) => s,
+            _ => panic!("Not a `wasmi` instance"),
+        }
+    }
+}
diff --git a/lib/api/src/backend/wasmi/entities/memory/mod.rs b/lib/api/src/backend/wasmi/entities/memory/mod.rs
new file mode 100644
index 0000000000..f7c0c64b60
--- /dev/null
+++ b/lib/api/src/backend/wasmi/entities/memory/mod.rs
@@ -0,0 +1,372 @@
+//! Data types, functions and traits for `wasmi`'s `Memory` implementation.
+//!
+use std::{marker::PhantomData, mem::MaybeUninit};
+
+use tracing::warn;
+pub use wasmer_types::MemoryError;
+use wasmer_types::{MemoryType, Pages, WASM_PAGE_SIZE};
+
+use crate::{
+    shared::SharedMemory,
+    vm::{VMExtern, VMExternMemory},
+    wasmi::{bindings::*, vm::VMMemory},
+    AsStoreMut, AsStoreRef, BackendMemory, MemoryAccessError,
+};
+
+pub(crate) mod view;
+pub use view::*;
+
+#[derive(Debug, Clone)]
+/// A WebAssembly `memory` in `wasmi`.
+pub struct Memory {
+    pub(crate) handle: VMMemory,
+}
+
+unsafe impl Send for Memory {}
+unsafe impl Sync for Memory {}
+
+impl Memory {
+    pub fn new(store: &mut impl AsStoreMut, ty: MemoryType) -> Result<Self, MemoryError> {
+        let max_requested = ty.maximum.unwrap_or(Pages::max_value());
+
+        let min = ty.minimum.0;
+        let max = max_requested.0;
+
+        if max < min {
+            return Err(MemoryError::InvalidMemory {
+                reason: format!("the maximum ({max} pages) is less than the minimum ({min} pages)",),
+            });
+        }
+
+        let max_allowed = Pages::max_value();
+        if max_requested > max_allowed {
+            return Err(MemoryError::MaximumMemoryTooLarge {
+                max_requested,
+                max_allowed,
+            });
+        }
+
+        let limits = Box::into_raw(Box::new(wasm_limits_t { min, max }));
+
+        let memorytype = unsafe { wasm_memorytype_new(limits) };
+
+        let mut store = store.as_store_mut();
+        let inner = store.inner.store.as_wasmi().inner;
+        let c_memory = unsafe { wasm_memory_new(inner, memorytype) };
+
+        Ok(Self { handle: c_memory })
+    }
+
+    pub fn new_from_existing(new_store: &mut impl AsStoreMut, memory: VMMemory) -> Self {
+        Self { handle: memory }
+    }
+
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Wasmi(unsafe { wasm_memory_as_extern(self.handle) })
+    }
+
+    pub fn ty(&self, _store: &impl AsStoreRef) -> MemoryType {
+        let memory_type: *mut wasm_memorytype_t = unsafe { wasm_memory_type(self.handle) };
+        let limits: *const wasm_limits_t = unsafe { wasm_memorytype_limits(memory_type) };
+
+        MemoryType {
+            // [TODO]: Find a way to extract this from the inner memory type instead
+            // of hardcoding.
+            shared: false,
+            minimum: unsafe { wasmer_types::Pages((*limits).min) },
+            maximum: unsafe { Some(wasmer_types::Pages((*limits).max)) },
+        }
+    }
+
+    pub fn size(&self, store: &impl AsStoreRef) -> Pages {
+        let size = unsafe { wasm_memory_size(self.handle) };
+        Pages(size)
+    }
+
+    pub fn view<'a>(&self, store: &'a impl AsStoreRef) -> MemoryView<'a> {
+        MemoryView::new(self, store)
+    }
+
+    // Note: the return value is the memory size (in [`Pages`]) *before* growing it.
+    pub fn grow<IntoPages>(
+        &self,
+        store: &mut impl AsStoreMut,
+        delta: IntoPages,
+    ) -> Result<Pages, MemoryError>
+    where
+        IntoPages: Into<Pages>,
+    {
+        unsafe {
+            let delta: Pages = delta.into();
+            let current = Pages(wasm_memory_size(self.handle));
+
+            if !wasm_memory_grow(self.handle, delta.0) {
+                Err(MemoryError::CouldNotGrow {
+                    current,
+                    attempted_delta: delta,
+                })
+            } else {
+                Ok(current)
+            }
+        }
+    }
+
+    pub fn grow_at_least(
+        &self,
+        store: &mut impl AsStoreMut,
+        min_size: u64,
+    ) -> Result<(), MemoryError> {
+        unsafe {
+            let current = wasm_memory_size(self.handle);
+            let delta = (min_size as u32) - current;
+            if delta > 0 {
+                self.grow(store, delta)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    pub fn reset(&self, _store: &mut impl AsStoreMut) -> Result<(), MemoryError> {
+        Ok(())
+    }
+
+    pub fn copy_to_store(
+        &self,
+        store: &impl AsStoreRef,
+        new_store: &mut impl AsStoreMut,
+    ) -> Result<Self, MemoryError> {
+        unimplemented!();
+        // let view = self.view(store);
+        // let ty = self.ty(store);
+        // let amount = view.data_size() as usize;
+
+        // let new_memory = Self::new(new_store, ty)?;
+        // let mut new_view = new_memory.view(&new_store);
+        // let new_view_size = new_view.data_size() as usize;
+        // if amount > new_view_size {
+        //     let delta = amount - new_view_size;
+        //     let pages = ((delta - 1) / wasmer_types::WASM_PAGE_SIZE) + 1;
+        //     new_memory.grow(new_store, Pages(pages as u32))?;
+        //     new_view = new_memory.view(&new_store);
+        // }
+
+        // // Copy the bytes
+        // view.copy_to_memory(amount as u64, &new_view)
+        //     .map_err(|err| MemoryError::Generic(err.to_string()))?;
+        // // // Return the new memory
+        // Ok(new_memory)
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, internal: VMExternMemory) -> Self {
+        Self {
+            handle: internal.into_wasmi(),
+        }
+    }
+
+    /// Cloning memory will create another reference to the same memory that
+    /// can be put into a new store
+    pub fn try_clone(&self, _store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
+        Ok(self.handle.clone())
+    }
+
+    /// Copying the memory will actually copy all the bytes in the memory to
+    /// a identical byte copy of the original that can be put into a new store
+    pub fn try_copy(&self, store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
+        let res = unsafe { wasm_memory_copy(self.handle) };
+        if res.is_null() {
+            Err(MemoryError::Generic("memory copy failed".to_owned()))
+        } else {
+            Ok(res)
+        }
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+
+    #[allow(unused)]
+    pub fn duplicate(&mut self, store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
+        unimplemented!();
+        // self.handle.duplicate(store)
+    }
+
+    pub fn as_shared(&self, _store: &impl AsStoreRef) -> Option<SharedMemory> {
+        // Not supported.
+        None
+    }
+}
+
+impl std::cmp::PartialEq for Memory {
+    fn eq(&self, other: &Self) -> bool {
+        self.handle == other.handle
+    }
+}
+
+impl std::cmp::Eq for Memory {}
+
+/// Underlying buffer for a memory.
+#[derive(Debug, Copy, Clone)]
+pub(crate) struct MemoryBuffer<'a> {
+    pub(crate) base: *mut u8,
+    pub(crate) len: usize,
+    pub(crate) marker: PhantomData<&'a MemoryView<'a>>,
+}
+
+impl<'a> MemoryBuffer<'a> {
+    pub(crate) fn read(&self, offset: u64, buf: &mut [u8]) -> Result<(), MemoryAccessError> {
+        let end = offset
+            .checked_add(buf.len() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+
+        let len: u64 = self.len.try_into().unwrap();
+        if end > len {
+            warn!(
+                "attempted to read {} bytes, but the end offset is beyond the bounds of the memory view ({} > {}, diff. {} bytes)",
+                buf.len(),
+                end,
+                len,
+                end - len,
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        unsafe {
+            volatile_memcpy_read(self.base.add(offset as usize), buf.as_mut_ptr(), buf.len());
+        }
+        Ok(())
+    }
+
+    pub(crate) fn read_uninit<'b>(
+        &self,
+        offset: u64,
+        buf: &'b mut [MaybeUninit<u8>],
+    ) -> Result<&'b mut [u8], MemoryAccessError> {
+        let end = offset
+            .checked_add(buf.len() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+
+        let len: u64 = self.len.try_into().unwrap();
+        if end > len {
+            warn!(
+                "attempted to read {} bytes, but the end offset is beyond the bounds of the memory view ({} > {}, diff. {} bytes)",
+                buf.len(),
+                end,
+                len,
+                end - len,
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        let buf_ptr = buf.as_mut_ptr() as *mut u8;
+        unsafe {
+            volatile_memcpy_read(self.base.add(offset as usize), buf_ptr, buf.len());
+        }
+
+        Ok(unsafe { std::slice::from_raw_parts_mut(buf_ptr, buf.len()) })
+    }
+
+    pub(crate) fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
+        let end = offset
+            .checked_add(data.len() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        if end > self.len.try_into().unwrap() {
+            warn!(
+                "attempted to write ({} bytes) beyond the bounds of the memory view ({} > {})",
+                data.len(),
+                end,
+                self.len
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        unsafe {
+            volatile_memcpy_write(data.as_ptr(), self.base.add(offset as usize), data.len());
+        }
+        Ok(())
+    }
+}
+
+// We can't use a normal memcpy here because it has undefined behavior if the
+// memory is being concurrently modified. So we need to write our own memcpy
+// implementation which uses volatile operations.
+//
+// The implementation of these functions can optimize very well when inlined
+// with a fixed length: they should compile down to a single load/store
+// instruction for small (8/16/32/64-bit) copies.
+#[inline]
+unsafe fn volatile_memcpy_read(mut src: *const u8, mut dst: *mut u8, mut len: usize) {
+    #[inline]
+    unsafe fn copy_one<T>(src: &mut *const u8, dst: &mut *mut u8, len: &mut usize) {
+        #[repr(packed)]
+        struct Unaligned<T>(T);
+        let val = (*src as *const Unaligned<T>).read_volatile();
+        (*dst as *mut Unaligned<T>).write(val);
+        *src = src.add(std::mem::size_of::<T>());
+        *dst = dst.add(std::mem::size_of::<T>());
+        *len -= std::mem::size_of::<T>();
+    }
+
+    while len >= 8 {
+        copy_one::<u64>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 4 {
+        copy_one::<u32>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 2 {
+        copy_one::<u16>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 1 {
+        copy_one::<u8>(&mut src, &mut dst, &mut len);
+    }
+}
+
+#[inline]
+unsafe fn volatile_memcpy_write(mut src: *const u8, mut dst: *mut u8, mut len: usize) {
+    #[inline]
+    unsafe fn copy_one<T>(src: &mut *const u8, dst: &mut *mut u8, len: &mut usize) {
+        #[repr(packed)]
+        struct Unaligned<T>(T);
+        let val = (*src as *const Unaligned<T>).read();
+        (*dst as *mut Unaligned<T>).write_volatile(val);
+        *src = src.add(std::mem::size_of::<T>());
+        *dst = dst.add(std::mem::size_of::<T>());
+        *len -= std::mem::size_of::<T>();
+    }
+
+    while len >= 8 {
+        copy_one::<u64>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 4 {
+        copy_one::<u32>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 2 {
+        copy_one::<u16>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 1 {
+        copy_one::<u8>(&mut src, &mut dst, &mut len);
+    }
+}
+
+impl crate::Memory {
+    /// Consume [`self`] into a [`crate::backend::wasmi::memory::Memory`].
+    pub fn into_wasmi(self) -> crate::backend::wasmi::memory::Memory {
+        match self.0 {
+            BackendMemory::Wasmi(s) => s,
+            _ => panic!("Not a `wasmi` memory!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference to [`crate::backend::wasmi::memory::Memory`].
+    pub fn as_wasmi(&self) -> &crate::backend::wasmi::memory::Memory {
+        match self.0 {
+            BackendMemory::Wasmi(ref s) => s,
+            _ => panic!("Not a `wasmi` memory!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference to [`crate::backend::wasmi::memory::Memory`].
+    pub fn as_wasmi_mut(&mut self) -> &mut crate::backend::wasmi::memory::Memory {
+        match self.0 {
+            BackendMemory::Wasmi(ref mut s) => s,
+            _ => panic!("Not a `wasmi` memory!"),
+        }
+    }
+}
diff --git a/lib/api/src/backend/wasmi/entities/memory/view.rs b/lib/api/src/backend/wasmi/entities/memory/view.rs
new file mode 100644
index 0000000000..51adca872b
--- /dev/null
+++ b/lib/api/src/backend/wasmi/entities/memory/view.rs
@@ -0,0 +1,203 @@
+use std::{marker::PhantomData, mem::MaybeUninit, ops::Range};
+
+use wasmer_types::Pages;
+
+use super::{Memory, MemoryBuffer};
+use crate::{
+    backend::wasmi::bindings::{wasm_memory_data, wasm_memory_data_size, wasm_memory_size},
+    wasmi::bindings::wasm_memory_t,
+    AsStoreRef, MemoryAccessError,
+};
+
+/// A WebAssembly `memory` view.
+///
+/// A memory view is used to read and write to the linear memory.
+///
+/// After a memory is grown a view must not be used anymore. Views are
+/// created using the Memory.grow() method.
+#[derive(Debug)]
+pub struct MemoryView<'a> {
+    pub(crate) buffer: MemoryBuffer<'a>,
+    pub(crate) size: u32,
+}
+
+impl<'a> MemoryView<'a> {
+    pub(crate) fn new(memory: &Memory, store: &'a (impl AsStoreRef + ?Sized)) -> Self {
+        let c_memory: *mut wasm_memory_t = memory.handle;
+
+        let len = unsafe { wasm_memory_data_size(c_memory as _).try_into().unwrap() };
+        let base: *mut u8 = unsafe { wasm_memory_data(c_memory as _) as _ };
+        let size = unsafe { wasm_memory_size(c_memory as _) };
+
+        Self {
+            buffer: MemoryBuffer {
+                base,
+                len,
+                marker: PhantomData,
+            },
+            size,
+        }
+    }
+
+    /// Returns the pointer to the raw bytes of the `Memory`.
+    //
+    // This used by wasmer-c-api, but should be treated
+    // as deprecated and not used in future code.
+    #[doc(hidden)]
+    pub fn data_ptr(&self) -> *mut u8 {
+        self.buffer.base
+    }
+
+    /// Returns the size (in bytes) of the `Memory`.
+    pub fn data_size(&self) -> u64 {
+        self.buffer.len.try_into().unwrap()
+    }
+
+    /// Retrieve a slice of the memory contents.
+    ///
+    /// # Safety
+    ///
+    /// Until the returned slice is dropped, it is undefined behaviour to
+    /// modify the memory contents in any way including by calling a wasm
+    /// function that writes to the memory or by resizing the memory.
+    #[doc(hidden)]
+    pub unsafe fn data_unchecked(&self) -> &[u8] {
+        self.data_unchecked_mut()
+    }
+
+    /// Retrieve a mutable slice of the memory contents.
+    ///
+    /// # Safety
+    ///
+    /// This method provides interior mutability without an UnsafeCell. Until
+    /// the returned value is dropped, it is undefined behaviour to read or
+    /// write to the pointed-to memory in any way except through this slice,
+    /// including by calling a wasm function that reads the memory contents or
+    /// by resizing this Memory.
+    #[allow(clippy::mut_from_ref)]
+    #[doc(hidden)]
+    pub unsafe fn data_unchecked_mut(&self) -> &mut [u8] {
+        std::slice::from_raw_parts_mut(self.buffer.base, self.buffer.len)
+    }
+
+    /// Returns the size (in [`Pages`]) of the `Memory`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let m = Memory::new(&mut store, MemoryType::new(1, None, false)).unwrap();
+    ///
+    /// assert_eq!(m.view(&mut store).size(), Pages(1));
+    /// ```
+    pub fn size(&self) -> Pages {
+        Pages(self.size)
+    }
+
+    #[inline]
+    pub(crate) fn buffer(&'a self) -> MemoryBuffer<'a> {
+        self.buffer
+    }
+
+    /// Safely reads bytes from the memory at the given offset.
+    ///
+    /// The full buffer will be filled, otherwise a `MemoryAccessError` is returned
+    /// to indicate an out-of-bounds access.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn read(&self, offset: u64, buf: &mut [u8]) -> Result<(), MemoryAccessError> {
+        self.buffer.read(offset, buf)
+    }
+
+    /// Safely reads a single byte from memory at the given offset
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn read_u8(&self, offset: u64) -> Result<u8, MemoryAccessError> {
+        let mut buf = [0u8; 1];
+        self.read(offset, &mut buf)?;
+        Ok(buf[0])
+    }
+
+    /// Safely reads bytes from the memory at the given offset.
+    ///
+    /// This method is similar to `read` but allows reading into an
+    /// uninitialized buffer. An initialized view of the buffer is returned.
+    ///
+    /// The full buffer will be filled, otherwise a `MemoryAccessError` is returned
+    /// to indicate an out-of-bounds access.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn read_uninit<'b>(
+        &self,
+        offset: u64,
+        buf: &'b mut [MaybeUninit<u8>],
+    ) -> Result<&'b mut [u8], MemoryAccessError> {
+        self.buffer.read_uninit(offset, buf)
+    }
+
+    /// Safely writes bytes to the memory at the given offset.
+    ///
+    /// If the write exceeds the bounds of the memory then a `MemoryAccessError` is
+    /// returned.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent reads/writes.
+    pub fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
+        self.buffer.write(offset, data)
+    }
+
+    /// Safely reads a single byte from memory at the given offset
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn write_u8(&self, offset: u64, val: u8) -> Result<(), MemoryAccessError> {
+        let buf = [val];
+        self.write(offset, &buf)?;
+        Ok(())
+    }
+
+    #[allow(unused)]
+    /// Copies the memory and returns it as a vector of bytes
+    pub fn copy_to_vec(&self) -> Result<Vec<u8>, MemoryAccessError> {
+        self.copy_range_to_vec(0..self.data_size())
+    }
+
+    #[allow(unused)]
+    /// Copies a range of the memory and returns it as a vector of bytes
+    pub fn copy_range_to_vec(&self, range: Range<u64>) -> Result<Vec<u8>, MemoryAccessError> {
+        let mut new_memory = Vec::new();
+        let mut offset = range.start;
+        let end = range.end.min(self.data_size());
+        let mut chunk = [0u8; 40960];
+        while offset < end {
+            let remaining = end - offset;
+            let sublen = remaining.min(chunk.len() as u64) as usize;
+            self.read(offset, &mut chunk[..sublen])?;
+            new_memory.extend_from_slice(&chunk[..sublen]);
+            offset += sublen as u64;
+        }
+        Ok(new_memory)
+    }
+
+    #[allow(unused)]
+    /// Copies the memory to another new memory object
+    pub fn copy_to_memory(&self, amount: u64, new_memory: &Self) -> Result<(), MemoryAccessError> {
+        let mut offset = 0;
+        let mut chunk = [0u8; 40960];
+        while offset < amount {
+            let remaining = amount - offset;
+            let sublen = remaining.min(chunk.len() as u64) as usize;
+            self.read(offset, &mut chunk[..sublen])?;
+
+            new_memory.write(offset, &chunk[..sublen])?;
+
+            offset += sublen as u64;
+        }
+        Ok(())
+    }
+}
diff --git a/lib/api/src/backend/wasmi/entities/mod.rs b/lib/api/src/backend/wasmi/entities/mod.rs
new file mode 100644
index 0000000000..09a19c7eb9
--- /dev/null
+++ b/lib/api/src/backend/wasmi/entities/mod.rs
@@ -0,0 +1,11 @@
+pub mod engine;
+pub(crate) mod exception;
+pub(crate) mod external;
+pub(crate) mod function;
+pub(crate) mod global;
+pub(crate) mod instance;
+pub(crate) mod memory;
+pub(crate) mod module;
+pub(crate) mod store;
+pub(crate) mod table;
+pub(crate) mod tag;
diff --git a/lib/api/src/backend/wasmi/entities/module.rs b/lib/api/src/backend/wasmi/entities/module.rs
new file mode 100644
index 0000000000..ad0aa9d39d
--- /dev/null
+++ b/lib/api/src/backend/wasmi/entities/module.rs
@@ -0,0 +1,191 @@
+//! Data types, functions and traits for `wasmi`'s `Module` implementation.
+use std::{path::Path, sync::Arc};
+
+use crate::{
+    backend::wasmi::bindings::{
+        wasm_byte_vec_t, wasm_module_delete, wasm_module_new, wasm_module_t,
+    },
+    AsEngineRef, BackendModule, IntoBytes,
+};
+
+use bytes::Bytes;
+use wasmer_types::{
+    CompileError, DeserializeError, ExportType, ExportsIterator, ExternType, FunctionType,
+    GlobalType, ImportType, ImportsIterator, MemoryType, ModuleInfo, Mutability, Pages,
+    SerializeError, TableType, Type,
+};
+pub(crate) struct ModuleHandle {
+    pub(crate) inner: *mut wasm_module_t,
+    pub(crate) store: std::sync::Mutex<crate::store::Store>,
+}
+
+impl PartialEq for ModuleHandle {
+    fn eq(&self, other: &Self) -> bool {
+        self.inner == other.inner
+        // && self.store.lock() == other.store.lock()
+    }
+}
+
+impl Eq for ModuleHandle {}
+
+impl ModuleHandle {
+    fn new(engine: &impl AsEngineRef, binary: &[u8]) -> Result<Self, CompileError> {
+        let bytes = wasm_byte_vec_t {
+            size: binary.len(),
+            data: binary.as_ptr() as _,
+        };
+
+        let store = crate::store::Store::new(engine.as_engine_ref().engine().clone());
+
+        let inner =
+            unsafe { wasm_module_new(store.inner.store.as_wasmi().inner, &bytes as *const _) };
+        let store = std::sync::Mutex::new(store);
+
+        if inner.is_null() {
+            return Err(CompileError::Validate(format!("module is null")));
+        }
+
+        Ok(ModuleHandle { inner, store })
+    }
+}
+impl Drop for ModuleHandle {
+    fn drop(&mut self) {
+        unsafe { wasm_module_delete(self.inner) }
+    }
+}
+
+#[derive(Clone, PartialEq, Eq)]
+/// A WebAssembly `module` in `wasmi`.
+pub struct Module {
+    pub(crate) handle: Arc<ModuleHandle>,
+    name: Option<String>,
+    raw_bytes: Option<Bytes>,
+    info: ModuleInfo,
+}
+
+unsafe impl Send for Module {}
+unsafe impl Sync for Module {}
+
+impl Module {
+    pub(crate) fn from_binary(
+        _engine: &impl AsEngineRef,
+        binary: &[u8],
+    ) -> Result<Self, CompileError> {
+        unsafe { Self::from_binary_unchecked(_engine, binary) }
+    }
+
+    pub(crate) unsafe fn from_binary_unchecked(
+        engine: &impl AsEngineRef,
+        binary: &[u8],
+    ) -> Result<Self, CompileError> {
+        let mut binary = binary.to_vec();
+        let binary = binary.into_bytes();
+        let module = ModuleHandle::new(engine, &binary)?;
+        let info = crate::utils::polyfill::translate_module(&binary[..])
+            .unwrap()
+            .info;
+
+        Ok(Self {
+            handle: Arc::new(module),
+            name: info.name.clone(),
+            raw_bytes: Some(binary.into_bytes()),
+            info,
+        })
+    }
+
+    pub fn validate(engine: &impl AsEngineRef, binary: &[u8]) -> Result<(), CompileError> {
+        let engine = engine.as_engine_ref();
+        unimplemented!();
+    }
+
+    pub fn name(&self) -> Option<&str> {
+        self.name.as_ref().map(|s| s.as_ref())
+    }
+
+    pub fn serialize(&self) -> Result<Bytes, SerializeError> {
+        return self.raw_bytes.clone().ok_or(SerializeError::Generic(
+            "Not able to serialize module".to_string(),
+        ));
+    }
+
+    pub unsafe fn deserialize_unchecked(
+        engine: &impl AsEngineRef,
+        bytes: impl IntoBytes,
+    ) -> Result<Self, DeserializeError> {
+        Self::deserialize(engine, bytes)
+    }
+
+    pub unsafe fn deserialize(
+        engine: &impl AsEngineRef,
+        bytes: impl IntoBytes,
+    ) -> Result<Self, DeserializeError> {
+        return Self::from_binary(engine, &bytes.into_bytes())
+            .map_err(|e| DeserializeError::Compiler(e));
+    }
+
+    pub unsafe fn deserialize_from_file_unchecked(
+        engine: &impl AsEngineRef,
+        path: impl AsRef<Path>,
+    ) -> Result<Self, DeserializeError> {
+        let bytes = std::fs::read(path.as_ref())?;
+        Self::deserialize_unchecked(engine, bytes)
+    }
+
+    pub unsafe fn deserialize_from_file(
+        engine: &impl AsEngineRef,
+        path: impl AsRef<Path>,
+    ) -> Result<Self, DeserializeError> {
+        let bytes = std::fs::read(path.as_ref())?;
+        Self::deserialize(engine, bytes)
+    }
+
+    pub fn set_name(&mut self, name: &str) -> bool {
+        self.name = Some(name.to_string());
+        true
+    }
+
+    pub fn imports<'a>(&'a self) -> ImportsIterator<Box<dyn Iterator<Item = ImportType> + 'a>> {
+        self.info().imports()
+    }
+
+    pub fn exports<'a>(&'a self) -> ExportsIterator<Box<dyn Iterator<Item = ExportType> + 'a>> {
+        self.info().exports()
+    }
+
+    pub fn custom_sections<'a>(
+        &'a self,
+        name: &'a str,
+    ) -> Box<dyn Iterator<Item = Box<[u8]>> + 'a> {
+        self.info().custom_sections(name)
+    }
+
+    pub(crate) fn info(&self) -> &ModuleInfo {
+        &self.info
+    }
+}
+
+impl crate::Module {
+    /// Consume [`self`] into a reference [`crate::backend::wasmi::module::Module`].
+    pub fn into_wasmi(self) -> crate::backend::wasmi::module::Module {
+        match self.0 {
+            BackendModule::Wasmi(s) => s,
+            _ => panic!("Not a `wasmi` module!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::wasmi::module::Module`].
+    pub fn as_wasmi(&self) -> &crate::backend::wasmi::module::Module {
+        match self.0 {
+            BackendModule::Wasmi(ref s) => s,
+            _ => panic!("Not a `wasmi` module!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wasmi::module::Module`].
+    pub fn as_wasmi_mut(&mut self) -> &mut crate::backend::wasmi::module::Module {
+        match self.0 {
+            BackendModule::Wasmi(ref mut s) => s,
+            _ => panic!("Not a `wasmi` module!"),
+        }
+    }
+}
diff --git a/lib/api/src/backend/wasmi/entities/store/mod.rs b/lib/api/src/backend/wasmi/entities/store/mod.rs
new file mode 100644
index 0000000000..f971d270e6
--- /dev/null
+++ b/lib/api/src/backend/wasmi/entities/store/mod.rs
@@ -0,0 +1,103 @@
+//! Data types, functions and traits for `wasmi`'s `Store` implementation.
+use crate::{
+    backend::wasmi::bindings::{wasm_store_delete, wasm_store_new, wasm_store_t},
+    engine::{AsEngineRef, Engine, EngineRef},
+    AsStoreRef, BackendStore, StoreRef,
+};
+
+mod obj;
+pub use obj::*;
+
+/// A WebAssembly `store` in `wasmi`.
+pub(crate) struct Store {
+    pub(crate) engine: Engine,
+    pub(crate) inner: *mut wasm_store_t,
+}
+
+impl std::fmt::Debug for Store {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Store")
+            .field("engine", &self.engine)
+            .finish()
+    }
+}
+
+impl Store {
+    pub(crate) fn new(engine: crate::engine::Engine) -> Self {
+        let inner: *mut wasm_store_t = unsafe { wasm_store_new(engine.as_wasmi().inner.engine) };
+        Store { inner, engine }
+    }
+
+    pub(crate) fn engine(&self) -> &Engine {
+        &self.engine
+    }
+
+    pub(crate) fn engine_mut(&mut self) -> &mut Engine {
+        &mut self.engine
+    }
+}
+
+impl Drop for Store {
+    fn drop(&mut self) {
+        unsafe { wasm_store_delete(self.inner) }
+    }
+}
+
+impl AsEngineRef for Store {
+    fn as_engine_ref(&self) -> EngineRef<'_> {
+        EngineRef::new(&self.engine)
+    }
+}
+
+impl crate::BackendStore {
+    /// Consume [`self`] into [`crate::backend::wasmi::store::Store`].
+    pub fn into_wasmi(self) -> crate::backend::wasmi::store::Store {
+        match self {
+            Self::Wasmi(s) => s,
+            _ => panic!("Not a `wasmi` store!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::wasmi::store::Store`].
+    pub fn as_wasmi(&self) -> &crate::backend::wasmi::store::Store {
+        match self {
+            Self::Wasmi(s) => s,
+            _ => panic!("Not a `wasmi` store!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wasmi::store::Store`].
+    pub fn as_wasmi_mut(&mut self) -> &mut crate::backend::wasmi::store::Store {
+        match self {
+            Self::Wasmi(s) => s,
+            _ => panic!("Not a `wasmi` store!"),
+        }
+    }
+
+    /// Return true if [`self`] is a store from the `wasmi` runtime.
+    pub fn is_wasmi(&self) -> bool {
+        matches!(self, Self::Wasmi(_))
+    }
+}
+
+impl crate::Store {
+    /// Consume [`self`] into [`crate::backend::wasmi::store::Store`].
+    pub(crate) fn into_wasmi(self) -> crate::backend::wasmi::store::Store {
+        self.inner.store.into_wasmi()
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::wasmi::store::Store`].
+    pub(crate) fn as_wasmi(&self) -> &crate::backend::wasmi::store::Store {
+        self.inner.store.as_wasmi()
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wasmi::store::Store`].
+    pub(crate) fn as_wasmi_mut(&mut self) -> &mut crate::backend::wasmi::store::Store {
+        self.inner.store.as_wasmi_mut()
+    }
+
+    /// Return true if [`self`] is a store from the `wasmi` runtime.
+    pub fn is_wasmi(&self) -> bool {
+        self.inner.store.is_wasmi()
+    }
+}
diff --git a/lib/api/src/backend/wasmi/entities/store/obj.rs b/lib/api/src/backend/wasmi/entities/store/obj.rs
new file mode 100644
index 0000000000..e22eb78b18
--- /dev/null
+++ b/lib/api/src/backend/wasmi/entities/store/obj.rs
@@ -0,0 +1,288 @@
+use std::{fmt, marker::PhantomData, num::NonZeroUsize};
+
+use crate::{
+    backend::wasmi::vm::{VMFunctionEnvironment, VMGlobal},
+    AsStoreMut,
+};
+
+pub use wasmer_types::StoreId;
+
+impl crate::StoreObjects {
+    /// Consume [`self`] into [`crate::backend::wasmi::store::StoreObjects`].
+    pub fn into_wasmi(self) -> crate::backend::wasmi::store::StoreObjects {
+        match self {
+            crate::StoreObjects::Wasmi(s) => s,
+            _ => panic!("Not a `wasmi` store!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::wasmi::store::StoreObjects`].
+    pub fn as_wasmi(&self) -> &crate::backend::wasmi::store::StoreObjects {
+        match self {
+            crate::StoreObjects::Wasmi(s) => s,
+            _ => panic!("Not a `wasmi` store!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wasmi::store::StoreObjects`].
+    pub fn as_wasmi_mut(&mut self) -> &mut crate::backend::wasmi::store::StoreObjects {
+        match self {
+            crate::StoreObjects::Wasmi(s) => s,
+            _ => panic!("Not a `wasmi` store!"),
+        }
+    }
+}
+
+/// Trait to represent an object managed by a context. This is implemented on
+/// the VM types managed by the context.
+pub trait StoreObject: Sized {
+    fn list(store: &StoreObjects) -> &Vec<Self>;
+    fn list_mut(store: &mut StoreObjects) -> &mut Vec<Self>;
+}
+
+macro_rules! impl_store_object {
+    ($($field:ident => $ty:ty,)*) => {
+        $(
+            impl StoreObject for $ty {
+                fn list(store: &StoreObjects) -> &Vec<Self> {
+                    &store.$field
+                }
+                fn list_mut(store: &mut StoreObjects) -> &mut Vec<Self> {
+                    &mut store.$field
+                }
+            }
+        )*
+        };
+    }
+
+impl_store_object! {
+    // Note: we store the globals in order to be able to access them later via
+    // `StoreObjects::iter_globals`.
+    globals => VMGlobal,
+    // functions => VMFunction,
+    // tables => VMTable,
+    // memories => VMMemory,
+    // The function environments are the only things attached to a store,
+    // since the other JS objects (table, globals, memory and functions)
+    // live in the JS VM Store by default
+    function_environments => VMFunctionEnvironment,
+}
+
+/// Set of objects managed by a context.
+#[derive(Default, Debug)]
+pub struct StoreObjects {
+    id: StoreId,
+    globals: Vec<VMGlobal>,
+    function_environments: Vec<VMFunctionEnvironment>,
+}
+
+impl StoreObjects {
+    /// Returns the ID of this context.
+    pub fn id(&self) -> StoreId {
+        self.id
+    }
+
+    /// Sets the ID of this store
+    pub fn set_id(&mut self, id: StoreId) {
+        self.id = id;
+    }
+
+    /// Returns a pair of mutable references from two handles.
+    ///
+    /// Panics if both handles point to the same object.
+    pub fn get_2_mut<T: StoreObject>(
+        &mut self,
+        a: InternalStoreHandle<T>,
+        b: InternalStoreHandle<T>,
+    ) -> (&mut T, &mut T) {
+        assert_ne!(a.index(), b.index());
+        let list = T::list_mut(self);
+        if a.index() < b.index() {
+            let (low, high) = list.split_at_mut(b.index());
+            (&mut low[a.index()], &mut high[0])
+        } else {
+            let (low, high) = list.split_at_mut(a.index());
+            (&mut high[0], &mut low[a.index()])
+        }
+    }
+
+    /// Return an immutable iterator over all globals
+    pub fn iter_globals(&self) -> core::slice::Iter<VMGlobal> {
+        self.globals.iter()
+    }
+
+    /// Return an vector of all globals and converted to u128
+    pub fn as_u128_globals(&self) -> Vec<u128> {
+        vec![]
+        // self.iter_globals()
+        //     .map(|v| v.global.value().as_f64().unwrap() as u128)
+        //     .collect()
+    }
+
+    /// Set a global, at index idx. Will panic if idx is out of range
+    /// Safety: the caller should check taht the raw value is compatible
+    /// with destination VMGlobal type
+    pub fn set_global_unchecked(&self, idx: usize, new_val: u128) {
+        assert!(idx < self.globals.len());
+        // let g = &self.globals[idx].global;
+        // let cur_val = g.value().as_f64().unwrap();
+        // let new_val = new_val as f64;
+        // if cur_val != new_val {
+        //     let new_value = JSValue::from(new_val);
+        //     g.set_value(&new_value);
+        // }
+    }
+}
+
+/// Handle to an object managed by a context.
+///
+/// Internally this is just an integer index into a context. A reference to the
+/// context must be passed in separately to access the actual object.
+pub struct StoreHandle<T> {
+    id: StoreId,
+    internal: InternalStoreHandle<T>,
+}
+
+impl<T> core::cmp::PartialEq for StoreHandle<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+
+impl<T> std::hash::Hash for StoreHandle<T> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.id.hash(state);
+        self.internal.idx.hash(state);
+    }
+}
+
+impl<T> Clone for StoreHandle<T> {
+    fn clone(&self) -> Self {
+        Self {
+            id: self.id,
+            internal: self.internal,
+        }
+    }
+}
+
+impl<T: StoreObject> fmt::Debug for StoreHandle<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("StoreHandle")
+            .field("id", &self.id)
+            .field("internal", &self.internal.index())
+            .finish()
+    }
+}
+
+impl<T: StoreObject> StoreHandle<T> {
+    /// Moves the given object into a context and returns a handle to it.
+    pub fn new(store: &mut StoreObjects, val: T) -> Self {
+        Self {
+            id: store.id,
+            internal: InternalStoreHandle::new(store, val),
+        }
+    }
+
+    /// Returns a reference to the object that this handle points to.
+    pub fn get<'a>(&self, store: &'a StoreObjects) -> &'a T {
+        assert_eq!(self.id, store.id, "object used with the wrong context");
+        self.internal.get(store)
+    }
+
+    /// Returns a mutable reference to the object that this handle points to.
+    pub fn get_mut<'a>(&self, store: &'a mut StoreObjects) -> &'a mut T {
+        assert_eq!(self.id, store.id, "object used with the wrong context");
+        self.internal.get_mut(store)
+    }
+
+    /// Returns the internal handle contains within this handle.
+    pub fn internal_handle(&self) -> InternalStoreHandle<T> {
+        self.internal
+    }
+
+    /// Returns the ID of the context associated with the handle.
+    #[allow(unused)]
+    pub fn store_id(&self) -> StoreId {
+        self.id
+    }
+
+    /// Overrides the store id with a new ID
+    #[allow(unused)]
+    pub fn set_store_id(&mut self, id: StoreId) {
+        self.id = id;
+    }
+
+    /// Constructs a `StoreHandle` from a `StoreId` and an `InternalStoreHandle`.
+    ///
+    /// # Safety
+    /// Handling `InternalStoreHandle` values is unsafe because they do not track context ID.
+    pub unsafe fn from_internal(id: StoreId, internal: InternalStoreHandle<T>) -> Self {
+        Self { id, internal }
+    }
+}
+
+/// Internal handle to an object owned by the current context.
+///
+/// Unlike `StoreHandle` this does not track the context ID: it is only
+/// intended to be used within objects already owned by a context.
+#[repr(transparent)]
+pub struct InternalStoreHandle<T> {
+    // Use a NonZero here to reduce the size of Option<InternalStoreHandle>.
+    idx: NonZeroUsize,
+    marker: PhantomData<fn() -> T>,
+}
+
+impl<T> Clone for InternalStoreHandle<T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl<T> Copy for InternalStoreHandle<T> {}
+
+impl<T> fmt::Debug for InternalStoreHandle<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("InternalStoreHandle")
+            .field("idx", &self.idx)
+            .finish()
+    }
+}
+impl<T> PartialEq for InternalStoreHandle<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.idx == other.idx
+    }
+}
+impl<T> Eq for InternalStoreHandle<T> {}
+
+impl<T: StoreObject> InternalStoreHandle<T> {
+    /// Moves the given object into a context and returns a handle to it.
+    pub fn new(store: &mut StoreObjects, val: T) -> Self {
+        let list = T::list_mut(store);
+        let idx = NonZeroUsize::new(list.len() + 1).unwrap();
+        list.push(val);
+        Self {
+            idx,
+            marker: PhantomData,
+        }
+    }
+
+    /// Returns a reference to the object that this handle points to.
+    pub fn get<'a>(&self, store: &'a StoreObjects) -> &'a T {
+        &T::list(store)[self.idx.get() - 1]
+    }
+
+    /// Returns a mutable reference to the object that this handle points to.
+    pub fn get_mut<'a>(&self, store: &'a mut StoreObjects) -> &'a mut T {
+        &mut T::list_mut(store)[self.idx.get() - 1]
+    }
+
+    pub(crate) fn index(&self) -> usize {
+        self.idx.get()
+    }
+
+    pub(crate) fn from_index(idx: usize) -> Option<Self> {
+        NonZeroUsize::new(idx).map(|idx| Self {
+            idx,
+            marker: PhantomData,
+        })
+    }
+}
diff --git a/lib/api/src/backend/wasmi/entities/table.rs b/lib/api/src/backend/wasmi/entities/table.rs
new file mode 100644
index 0000000000..52bc54f695
--- /dev/null
+++ b/lib/api/src/backend/wasmi/entities/table.rs
@@ -0,0 +1,233 @@
+//! Data types, functions and traits for `wasmi`'s `Table` implementation.
+use wasmer_types::TableType;
+
+use crate::{
+    vm::{VMExtern, VMExternTable},
+    wasmi::{
+        bindings::{self, *},
+        utils::convert::{IntoCApiType, IntoCApiValue, IntoWasmerType, IntoWasmerValue},
+        vm::VMTable,
+    },
+    AsStoreMut, AsStoreRef, BackendKind, BackendTable, RuntimeError, Value,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// A WebAssembly `table` in `wasmi`.
+pub struct Table {
+    pub(crate) handle: VMTable,
+}
+
+unsafe impl Send for Table {}
+unsafe impl Sync for Table {}
+
+impl Table {
+    pub(crate) fn type_to_wasmi(ty: TableType) -> *mut wasm_tabletype_t {
+        let valtype = unsafe { wasm_valtype_new(ty.ty.into_ct()) };
+
+        let limits = Box::into_raw(Box::new(wasm_limits_t {
+            min: ty.minimum,
+            max: match ty.maximum {
+                Some(v) => v,
+                None => 0,
+            },
+        }));
+
+        unsafe { wasm_tabletype_new(valtype, limits) }
+    }
+
+    pub fn new(
+        store: &mut impl AsStoreMut,
+        ty: TableType,
+        init: Value,
+    ) -> Result<Self, RuntimeError> {
+        let store_mut = store.as_store_mut();
+        let engine = store_mut.engine();
+
+        let wasm_tablety = Self::type_to_wasmi(ty);
+        let init: wasm_val_t = init.into_cv();
+
+        Ok(Self {
+            handle: unsafe {
+                wasm_table_new(
+                    store_mut.inner.store.as_wasmi().inner,
+                    wasm_tablety,
+                    init.of.ref_,
+                )
+            },
+        })
+    }
+
+    pub fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Wasmi(unsafe { wasm_table_as_extern(self.handle) })
+    }
+
+    pub fn ty(&self, _store: &impl AsStoreRef) -> TableType {
+        let table_type: *mut wasm_tabletype_t = unsafe { wasm_table_type(self.handle) };
+        let table_limits = unsafe { wasm_tabletype_limits(table_type) };
+        let table_type = unsafe { wasm_tabletype_element(table_type) };
+
+        TableType {
+            ty: table_type.into_wt(),
+            minimum: unsafe { (*table_limits).min },
+            maximum: unsafe {
+                if (*table_limits).max == 0 {
+                    None
+                } else {
+                    Some((*table_limits).max)
+                }
+            },
+        }
+    }
+
+    pub fn get(&self, store: &mut impl AsStoreMut, index: u32) -> Option<Value> {
+        unsafe {
+            let ref_ = wasm_table_get(self.handle, index);
+
+            if ref_.is_null() {
+                return None;
+            }
+
+            let kind = match self.ty(store).ty {
+                wasmer_types::Type::ExternRef => wasm_valkind_enum_WASM_EXTERNREF,
+                wasmer_types::Type::FuncRef => wasm_valkind_enum_WASM_FUNCREF,
+                ty => panic!("unsupported table type: {ty:?}"),
+            } as u8;
+
+            let value = wasm_val_t {
+                kind,
+                of: bindings::wasm_val_t__bindgen_ty_1 { ref_ },
+            };
+
+            Some(value.into_wv())
+        }
+    }
+
+    pub fn set(
+        &self,
+        store: &mut impl AsStoreMut,
+        index: u32,
+        val: Value,
+    ) -> Result<(), RuntimeError> {
+        unsafe {
+            let init = match val {
+                Value::ExternRef(None) | Value::FuncRef(None) => std::ptr::null_mut(),
+                Value::FuncRef(Some(ref r)) => wasm_func_as_ref(r.as_wasmi().handle),
+                _ => {
+                    return Err(RuntimeError::new(format!(
+                        "Could not grow table due to unsupported init value type: {val:?} "
+                    )))
+                }
+            };
+
+            if !wasm_table_set(self.handle, index, init) {
+                return Err(RuntimeError::new(format!(
+                    "Could not set value {val:?} table at index {index}"
+                )));
+            }
+
+            Ok(())
+        }
+    }
+
+    pub fn size(&self, store: &impl AsStoreRef) -> u32 {
+        unsafe { wasm_table_size(self.handle) }
+    }
+
+    pub fn grow(
+        &self,
+        store: &mut impl AsStoreMut,
+        delta: u32,
+        init: Value,
+    ) -> Result<u32, RuntimeError> {
+        unsafe {
+            let size = wasm_table_size(self.handle);
+            let init = match init {
+                Value::ExternRef(None) | Value::FuncRef(None) => std::ptr::null_mut(),
+                Value::FuncRef(Some(r)) => wasm_func_as_ref(r.as_wasmi().handle),
+                _ => {
+                    return Err(RuntimeError::new(format!(
+                        "Could not grow table due to unsupported init value type: {init:?} "
+                    )))
+                }
+            };
+            if !wasm_table_grow(self.handle, delta, init) {
+                return Err(RuntimeError::new("Could not grow table"));
+            }
+
+            Ok(size)
+        }
+    }
+
+    pub fn copy(
+        _store: &mut impl AsStoreMut,
+        _dst_table: &Self,
+        _dst_index: u32,
+        _src_table: &Self,
+        _src_index: u32,
+        _len: u32,
+    ) -> Result<(), RuntimeError> {
+        unimplemented!("Copying tables is currently not implemented!")
+    }
+
+    pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, vm_extern: VMExternTable) -> Self {
+        Self {
+            handle: vm_extern.into_wasmi(),
+        }
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
+
+impl crate::Table {
+    /// Consume [`self`] into [`crate::backend::wasmi::table::Table`].
+    pub fn into_wasmi(self) -> crate::backend::wasmi::table::Table {
+        match self.0 {
+            BackendTable::Wasmi(s) => s,
+            _ => panic!("Not a `wasmi` table!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::wasmi::table::Table`].
+    pub fn as_wasmi(&self) -> &crate::backend::wasmi::table::Table {
+        match self.0 {
+            BackendTable::Wasmi(ref s) => s,
+            _ => panic!("Not a `wasmi` table!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wasmi::table::Table`].
+    pub fn as_wasmi_mut(&mut self) -> &mut crate::backend::wasmi::table::Table {
+        match self.0 {
+            BackendTable::Wasmi(ref mut s) => s,
+            _ => panic!("Not a `wasmi` table!"),
+        }
+    }
+}
+
+impl crate::BackendTable {
+    /// Consume [`self`] into [`crate::backend::wasmi::table::Table`].
+    pub fn into_wasmi(self) -> crate::backend::wasmi::table::Table {
+        match self {
+            Self::Wasmi(s) => s,
+            _ => panic!("Not a `wasmi` table!"),
+        }
+    }
+
+    /// Convert a reference to [`self`] into a reference [`crate::backend::wasmi::table::Table`].
+    pub fn as_wasmi(&self) -> &crate::backend::wasmi::table::Table {
+        match self {
+            Self::Wasmi(ref s) => s,
+            _ => panic!("Not a `wasmi` table!"),
+        }
+    }
+
+    /// Convert a mutable reference to [`self`] into a mutable reference [`crate::backend::wasmi::table::Table`].
+    pub fn as_wasmi_mut(&mut self) -> &mut crate::backend::wasmi::table::Table {
+        match self {
+            Self::Wasmi(ref mut s) => s,
+            _ => panic!("Not a `wasmi` table!"),
+        }
+    }
+}
diff --git a/lib/api/src/backend/wasmi/entities/tag.rs b/lib/api/src/backend/wasmi/entities/tag.rs
new file mode 100644
index 0000000000..901c9ac4bb
--- /dev/null
+++ b/lib/api/src/backend/wasmi/entities/tag.rs
@@ -0,0 +1,43 @@
+//! Data types, functions and traits for `wasmi` runtime's `Tag` implementation.
+use wasmer_types::{TagType, Type};
+
+use crate::{
+    vm::{VMExtern, VMExternTag},
+    wasmi::vm::VMTag,
+    AsStoreMut, AsStoreRef,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// A WebAssembly `tag` in the `v8` runtime.
+pub(crate) struct Tag {
+    pub(crate) handle: VMTag,
+}
+
+unsafe impl Send for Tag {}
+unsafe impl Sync for Tag {}
+
+// Tag can't be Send in js because it dosen't support `structuredClone`
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// unsafe impl Send for Tag {}
+
+impl Tag {
+    pub fn new<P: Into<Box<[Type]>>>(store: &mut impl AsStoreMut, params: P) -> Self {
+        panic!("EH not supported yet!")
+    }
+
+    pub fn ty(&self, store: &impl AsStoreRef) -> TagType {
+        panic!("EH not supported yet!")
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternTag) -> Self {
+        panic!("EH not supported yet!")
+    }
+
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        panic!("EH not supported yet!")
+    }
+
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        panic!("EH not supported yet!")
+    }
+}
diff --git a/lib/api/src/backend/wasmi/error.rs b/lib/api/src/backend/wasmi/error.rs
new file mode 100644
index 0000000000..4c96960419
--- /dev/null
+++ b/lib/api/src/backend/wasmi/error.rs
@@ -0,0 +1,172 @@
+use std::{
+    error::Error,
+    ffi::{c_char, CStr},
+};
+
+use crate::{wasmi::bindings::*, AsStoreMut};
+
+#[derive(Debug)]
+enum InnerTrap {
+    User(Box<dyn Error + Send + Sync>),
+    CApi(*mut wasm_trap_t),
+}
+
+/// A struct representing a Trap
+pub struct Trap {
+    inner: InnerTrap,
+}
+
+unsafe impl Send for Trap {}
+unsafe impl Sync for Trap {}
+
+impl Trap {
+    pub fn user(error: Box<dyn Error + Send + Sync>) -> Self {
+        Self {
+            inner: InnerTrap::User(error),
+        }
+    }
+
+    /// Attempts to downcast the `Trap` to a concrete type.
+    pub fn downcast<T: Error + 'static>(self) -> Result<T, Self> {
+        match self.inner {
+            // We only try to downcast user errors
+            InnerTrap::User(err) if err.is::<T>() => Ok(*err.downcast::<T>().unwrap()),
+            _ => Err(self),
+        }
+    }
+
+    /// Attempts to downcast the `Trap` to a concrete type.
+    pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T> {
+        match &self.inner {
+            // We only try to downcast user errors
+            InnerTrap::User(err) if err.is::<T>() => err.downcast_ref::<T>(),
+            _ => None,
+        }
+    }
+
+    /// Returns true if the `Trap` is the same as T
+    pub fn is<T: Error + 'static>(&self) -> bool {
+        match &self.inner {
+            InnerTrap::User(err) => err.is::<T>(),
+            _ => false,
+        }
+    }
+
+    pub unsafe fn into_wasm_trap(self, store: &mut impl AsStoreMut) -> *mut wasm_trap_t {
+        match self.inner {
+            InnerTrap::CApi(t) => t,
+            InnerTrap::User(err) => {
+                let err_ptr = Box::leak(Box::new(err));
+                let mut data = std::mem::zeroed();
+                // let x = format!("")
+                let s1 = format!("🐛{:p}", err_ptr);
+                let _s = s1.into_bytes().into_boxed_slice();
+                wasm_byte_vec_new(&mut data, _s.len(), _s.as_ptr() as _);
+                std::mem::forget(_s);
+                let store = store.as_store_mut();
+                wasm_trap_new(store.inner.store.as_wasmi().inner, &mut data)
+            }
+        }
+    }
+
+    // pub unsafe fn deserialize_from_wasm_trap(trap: *mut wasm_trap_t) -> Self {
+    //     let mut data = std::mem::zeroed();
+    //     wasm_trap_message(trap, data);
+    //     println!("data: {:p}", data);
+
+    //     std::ptr::read(data as *const _)
+    // }
+}
+
+impl From<*mut wasm_trap_t> for Trap {
+    fn from(value: *mut wasm_trap_t) -> Self {
+        let message = unsafe {
+            let mut message = std::mem::zeroed();
+            wasm_trap_message(value, &mut message);
+
+            CStr::from_ptr(message.data as *const c_char)
+                .to_str()
+                .unwrap()
+        };
+
+        println!("{message}");
+
+        if message.starts_with("Exception: 🐛") {
+            let ptr_str = message.replace("Exception: 🐛", "");
+            let ptr: Box<dyn Error + Send + Sync + 'static> = unsafe {
+                let r = ptr_str.trim_start_matches("0x");
+                std::ptr::read(
+                    (usize::from_str_radix(&r, 16).unwrap()
+                        as *const Box<dyn Error + Send + Sync + 'static>),
+                )
+            };
+
+            Self {
+                inner: InnerTrap::User(ptr),
+            }
+        } else {
+            Self {
+                inner: InnerTrap::CApi(value),
+            }
+        }
+    }
+}
+
+impl std::error::Error for Trap {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match &self.inner {
+            InnerTrap::User(err) => Some(&**err),
+            _ => None,
+        }
+    }
+}
+
+impl std::fmt::Display for Trap {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self.inner {
+            InnerTrap::User(e) => write!(f, "{}", e),
+            InnerTrap::CApi(value) => {
+                // let message: wasm_message_t;
+                // wasm_trap_message(value, &mut message);
+                let mut out = unsafe {
+                    let mut vec: wasm_byte_vec_t = Default::default();
+                    wasm_byte_vec_new_empty(&mut vec);
+                    &mut vec as *mut _
+                };
+                unsafe { wasm_trap_message(*value, out) };
+                let cstr = unsafe { CStr::from_ptr((*out).data) };
+                write!(f, "wasm-c-api trap: {}", cstr.to_str().unwrap())
+            }
+        }
+    }
+}
+
+impl std::fmt::Debug for Trap {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self.inner {
+            InnerTrap::User(e) => write!(f, "{}", e),
+            InnerTrap::CApi(value) => {
+                // let message: wasm_message_t;
+                // wasm_trap_message(value, &mut message);
+                let mut out = unsafe {
+                    let mut vec: wasm_byte_vec_t = Default::default();
+                    wasm_byte_vec_new_empty(&mut vec);
+                    &mut vec as *mut _
+                };
+                unsafe { wasm_trap_message(*value, out) };
+                let cstr = unsafe { CStr::from_ptr((*out).data) };
+                write!(f, "wasm-c-api trap: {}", cstr.to_str().unwrap())
+            }
+        }
+    }
+}
+
+impl From<Trap> for crate::RuntimeError {
+    fn from(trap: Trap) -> Self {
+        if trap.is::<Self>() {
+            return trap.downcast::<Self>().unwrap();
+        }
+
+        crate::RuntimeError::new_from_source(crate::BackendTrap::Wasmi(trap), vec![], None)
+    }
+}
diff --git a/lib/api/src/backend/wasmi/mod.rs b/lib/api/src/backend/wasmi/mod.rs
new file mode 100644
index 0000000000..0e2080b5e6
--- /dev/null
+++ b/lib/api/src/backend/wasmi/mod.rs
@@ -0,0 +1,9 @@
+//! Data types, functions and traits for the `wasmi` backend.
+
+pub(crate) mod bindings;
+pub(crate) mod entities;
+pub(crate) mod error;
+pub(crate) mod utils;
+pub(crate) mod vm;
+
+pub use entities::{engine::Engine as Wasmi, *};
diff --git a/lib/api/src/backend/wasmi/utils/convert.rs b/lib/api/src/backend/wasmi/utils/convert.rs
new file mode 100644
index 0000000000..9c2746821e
--- /dev/null
+++ b/lib/api/src/backend/wasmi/utils/convert.rs
@@ -0,0 +1,143 @@
+/// Utilities to convert between `wasmi` and `wasmer` values
+use crate::{
+    wasmi::{
+        bindings::{
+            self, wasm_func_as_ref, wasm_val_t, wasm_val_t__bindgen_ty_1, wasm_valkind_t,
+            wasm_valtype_kind, wasm_valtype_t,
+        },
+        function,
+    },
+    BackendFunction, Function, Value,
+};
+use wasmer_types::Type;
+
+pub trait IntoCApiValue {
+    /// Consume [`self`] to produce a [`wasm_val_t`].
+    fn into_cv(self) -> wasm_val_t;
+}
+
+impl IntoCApiValue for Value {
+    fn into_cv(self) -> wasm_val_t {
+        match self {
+            Value::I32(val) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_I32 as _,
+                of: wasm_val_t__bindgen_ty_1 { i32_: val },
+            },
+            Value::I64(val) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_I64 as _,
+                of: wasm_val_t__bindgen_ty_1 { i64_: val },
+            },
+            Value::F32(val) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_F32 as _,
+                of: wasm_val_t__bindgen_ty_1 { f32_: val },
+            },
+            Value::F64(val) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_F64 as _,
+                of: wasm_val_t__bindgen_ty_1 { f64_: val },
+            },
+            Value::FuncRef(Some(val)) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_FUNCREF as _,
+                of: wasm_val_t__bindgen_ty_1 {
+                    ref_: unsafe { wasm_func_as_ref(val.as_wasmi().handle) },
+                },
+            },
+            Value::FuncRef(None) => wasm_val_t {
+                kind: bindings::wasm_valkind_enum_WASM_FUNCREF as _,
+                of: wasm_val_t__bindgen_ty_1 {
+                    ref_: unsafe { wasm_func_as_ref(std::ptr::null_mut()) },
+                },
+            },
+            Value::ExternRef(_) => panic!("Creating host values from guest ExternRefs is not currently supported in wasmi.") ,
+            Value::ExceptionRef(_) => panic!("Creating host values from guest ExceptionRefs is not currently supported in wasmi.") ,
+            Value::V128(_) => panic!("Creating host values from guest V128s is not currently supported in wasmi."),
+        }
+    }
+}
+
+pub trait IntoWasmerValue {
+    /// Consume [`self`] to produce a [`Value`].
+    fn into_wv(self) -> Value;
+}
+
+impl IntoWasmerValue for wasm_val_t {
+    fn into_wv(self) -> Value {
+        match self.kind as _ {
+            bindings::wasm_valkind_enum_WASM_I32 => Value::I32(unsafe { self.of.i32_ }),
+            bindings::wasm_valkind_enum_WASM_I64 => Value::I64(unsafe { self.of.i64_ }),
+            bindings::wasm_valkind_enum_WASM_F32 => Value::F32(unsafe { self.of.f32_ }),
+            bindings::wasm_valkind_enum_WASM_F64 => Value::F64(unsafe { self.of.f64_ }),
+            bindings::wasm_valkind_enum_WASM_FUNCREF => Value::FuncRef(Some(Function(
+                BackendFunction::Wasmi(crate::backend::wasmi::function::Function {
+                    handle: unsafe { self.of.ref_ as _ },
+                }),
+            ))),
+            bindings::wasm_valkind_enum_WASM_EXTERNREF => {
+                panic!("ExternRefs are not currently supported through wasm_c_api")
+            }
+
+            _ => {
+                panic!("wasmi currently does not support V128 values")
+            }
+        }
+    }
+}
+
+pub trait IntoWasmerType {
+    /// Consume [`self`] to produce a [`Type`].
+    fn into_wt(self) -> Type;
+}
+
+impl IntoWasmerType for wasm_valkind_t {
+    fn into_wt(self) -> Type {
+        match self as _ {
+            bindings::wasm_valkind_enum_WASM_I32 => Type::I32,
+            bindings::wasm_valkind_enum_WASM_I64 => Type::I64,
+            bindings::wasm_valkind_enum_WASM_F32 => Type::F32,
+            bindings::wasm_valkind_enum_WASM_F64 => Type::F64,
+            bindings::wasm_valkind_enum_WASM_EXTERNREF => Type::ExternRef,
+            bindings::wasm_valkind_enum_WASM_FUNCREF => Type::FuncRef,
+            _ => unreachable!("wasmi kind has no matching wasmer_types::Type"),
+        }
+    }
+}
+
+pub trait IntoCApiType {
+    /// Consume [`self`] to produce a [`wasm_valkind_t`].
+    fn into_ct(self) -> wasm_valkind_t;
+}
+
+impl IntoCApiType for Type {
+    fn into_ct(self) -> wasm_valkind_t {
+        match self as _ {
+            Type::I32 => bindings::wasm_valkind_enum_WASM_I32 as _,
+            Type::I64 => bindings::wasm_valkind_enum_WASM_I64 as _,
+            Type::F32 => bindings::wasm_valkind_enum_WASM_F32 as _,
+            Type::F64 => bindings::wasm_valkind_enum_WASM_F64 as _,
+            Type::FuncRef => bindings::wasm_valkind_enum_WASM_FUNCREF as _,
+            Type::ExternRef => bindings::wasm_valkind_enum_WASM_EXTERNREF as _,
+            Type::V128 => panic!("wasmi does not support V128!"),
+            Type::ExceptionRef => panic!("wasmi does not support exnrefs!"),
+        }
+    }
+}
+
+impl IntoWasmerType for wasm_valtype_t {
+    fn into_wt(self) -> Type {
+        let type_: wasm_valkind_t = unsafe { wasm_valtype_kind(&self as *const _) };
+        type_.into_wt()
+    }
+}
+
+impl IntoWasmerType for *const wasm_valtype_t {
+    fn into_wt(self) -> Type {
+        let type_: wasm_valkind_t = unsafe { wasm_valtype_kind(self as _) };
+        type_.into_wt()
+    }
+}
+
+impl IntoWasmerType for *mut wasm_valtype_t {
+    fn into_wt(self) -> Type {
+        let type_: wasm_valkind_t = unsafe { wasm_valtype_kind(self as _) };
+        type_.into_wt()
+    }
+}
diff --git a/lib/api/src/backend/wasmi/utils/mod.rs b/lib/api/src/backend/wasmi/utils/mod.rs
new file mode 100644
index 0000000000..02d63d4e14
--- /dev/null
+++ b/lib/api/src/backend/wasmi/utils/mod.rs
@@ -0,0 +1 @@
+pub(crate) mod convert;
diff --git a/lib/api/src/backend/wasmi/vm/env.rs b/lib/api/src/backend/wasmi/vm/env.rs
new file mode 100644
index 0000000000..d2a93d5f63
--- /dev/null
+++ b/lib/api/src/backend/wasmi/vm/env.rs
@@ -0,0 +1,28 @@
+use std::any::Any;
+
+/// Underlying FunctionEnvironment used by a `VMFunction`.
+#[derive(Debug)]
+pub struct VMFunctionEnvironment {
+    pub(crate) contents: Box<dyn Any + Send + 'static>,
+}
+
+impl VMFunctionEnvironment {
+    /// Wraps the given value to expose it to Wasm code as a function context.
+    pub fn new(val: impl Any + Send + 'static) -> Self {
+        Self {
+            contents: Box::new(val),
+        }
+    }
+
+    #[allow(clippy::should_implement_trait)]
+    /// Returns a reference to the underlying value.
+    pub fn as_ref(&self) -> &(dyn Any + Send + 'static) {
+        &*self.contents
+    }
+
+    #[allow(clippy::should_implement_trait)]
+    /// Returns a mutable reference to the underlying value.
+    pub fn as_mut(&mut self) -> &mut (dyn Any + Send + 'static) {
+        &mut *self.contents
+    }
+}
diff --git a/lib/api/src/backend/wasmi/vm/mod.rs b/lib/api/src/backend/wasmi/vm/mod.rs
new file mode 100644
index 0000000000..43f490b86c
--- /dev/null
+++ b/lib/api/src/backend/wasmi/vm/mod.rs
@@ -0,0 +1,144 @@
+mod env;
+pub use env::*;
+
+pub use super::bindings::{
+    wasm_extern_as_func, wasm_extern_as_global, wasm_extern_as_memory, wasm_extern_as_table,
+    wasm_extern_kind, wasm_extern_t, wasm_func_t, wasm_global_t, wasm_instance_t, wasm_memory_t,
+    wasm_ref_t, wasm_table_t,
+};
+use super::{
+    entities::function::env::FunctionEnv, function::Function, global::Global, memory::Memory,
+    table::Table,
+};
+use crate::{AsStoreMut, BackendFunction, BackendGlobal, BackendMemory, BackendTable, Extern};
+use wasmer_types::RawValue;
+
+pub use super::error::Trap;
+
+pub(crate) type VMExtern = *mut wasm_extern_t;
+
+// No EH for now.
+pub(crate) type VMException = ();
+pub(crate) type VMTag = ();
+pub(crate) type VMExternTag = ();
+
+pub(crate) type VMFunction = *mut wasm_func_t;
+pub(crate) type VMFunctionBody = ();
+pub(crate) type VMFunctionCallback = *mut ::std::os::raw::c_void;
+pub(crate) type VMTrampoline = *mut ::std::os::raw::c_void;
+pub(crate) type VMExternFunction = *mut wasm_func_t;
+
+pub(crate) type VMGlobal = *mut wasm_global_t;
+pub(crate) type VMExternGlobal = *mut wasm_global_t;
+
+pub(crate) type VMMemory = *mut wasm_memory_t;
+pub type VMSharedMemory = VMMemory;
+pub(crate) type VMExternMemory = *mut wasm_memory_t;
+
+pub(crate) type VMTable = *mut wasm_table_t;
+pub(crate) type VMExternTable = *mut wasm_table_t;
+
+pub(crate) type VMInstance = *mut wasm_instance_t;
+
+pub(crate) type VMExternObj = ();
+pub(crate) type VMConfig = ();
+
+impl crate::VMExternToExtern for VMExtern {
+    fn to_extern(self, store: &mut impl AsStoreMut) -> Extern {
+        let kind = unsafe { wasm_extern_kind(&mut *self) };
+
+        match kind as u32 {
+            0 => {
+                let func = unsafe { wasm_extern_as_func(&mut *self) };
+                if func.is_null() {
+                    panic!("The wasm-c-api reported extern as function, but is not");
+                }
+                Extern::Function(crate::Function::from_vm_extern(
+                    store,
+                    crate::vm::VMExternFunction::Wasmi(func),
+                ))
+            }
+            1 => {
+                let global = unsafe { wasm_extern_as_global(&mut *self) };
+                if global.is_null() {
+                    panic!("The wasm-c-api reported extern as a global, but is not");
+                }
+                Extern::Global(crate::Global::from_vm_extern(
+                    store,
+                    crate::vm::VMExternGlobal::Wasmi(global),
+                ))
+            }
+            2 => {
+                let table = unsafe { wasm_extern_as_table(&mut *self) };
+                if table.is_null() {
+                    panic!("The wasm-c-api reported extern as a table, but is not");
+                }
+                Extern::Table(crate::Table::from_vm_extern(
+                    store,
+                    crate::vm::VMExternTable::Wasmi(table),
+                ))
+            }
+            3 => {
+                let memory = unsafe { wasm_extern_as_memory(&mut *self) };
+                if memory.is_null() {
+                    panic!("The wasm-c-api reported extern as a table, but is not");
+                }
+                Extern::Memory(crate::Memory::from_vm_extern(
+                    store,
+                    crate::vm::VMExternMemory::Wasmi(memory),
+                ))
+            }
+            _ => {
+                unimplemented!()
+            }
+        }
+    }
+}
+
+pub(crate) struct VMExternRef(*mut wasm_ref_t);
+impl VMExternRef {
+    /// Converts the `VMExternRef` into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        unimplemented!()
+    }
+
+    /// Extracts a `VMExternRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw` must be a valid `VMExternRef` instance.
+    pub unsafe fn from_raw(_raw: RawValue) -> Option<Self> {
+        unimplemented!();
+    }
+}
+
+pub(crate) struct VMFuncRef(*mut wasm_ref_t);
+impl VMFuncRef {
+    /// Converts the `VMExternRef` into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        unimplemented!()
+    }
+
+    /// Extracts a `VMExternRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw` must be a valid `VMExternRef` instance.
+    pub unsafe fn from_raw(_raw: RawValue) -> Option<Self> {
+        unimplemented!();
+    }
+}
+
+pub(crate) struct VMExceptionRef(*mut wasm_ref_t);
+impl VMExceptionRef {
+    /// Converts the `VMExceptionRef` into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        unimplemented!()
+    }
+
+    /// Extracts a `VMExceptionRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw` must be a valid `VMExceptionRef` instance.
+    pub unsafe fn from_raw(_raw: RawValue) -> Option<Self> {
+        unimplemented!();
+    }
+}
diff --git a/lib/api/src/engine.rs b/lib/api/src/engine.rs
deleted file mode 100644
index 820d4d9054..0000000000
--- a/lib/api/src/engine.rs
+++ /dev/null
@@ -1,170 +0,0 @@
-use core::ops::Deref;
-
-#[cfg(feature = "sys")]
-use crate::sys::engine as engine_imp;
-#[cfg(feature = "sys")]
-pub(crate) use crate::sys::engine::default_engine;
-#[cfg(feature = "sys")]
-use crate::IntoBytes;
-#[cfg(feature = "sys")]
-use shared_buffer::OwnedBuffer;
-#[cfg(feature = "sys")]
-use std::path::Path;
-#[cfg(feature = "sys")]
-use std::sync::Arc;
-#[cfg(feature = "sys")]
-#[allow(unused_imports)]
-pub use wasmer_compiler::{Artifact, CompilerConfig, EngineInner, Features, Tunables};
-#[cfg(feature = "sys")]
-use wasmer_types::DeserializeError;
-
-#[cfg(feature = "js")]
-use crate::js::engine as engine_imp;
-#[cfg(feature = "js")]
-pub(crate) use crate::js::engine::default_engine;
-
-#[cfg(feature = "jsc")]
-use crate::jsc::engine as engine_imp;
-#[cfg(feature = "jsc")]
-pub(crate) use crate::jsc::engine::default_engine;
-
-/// The engine type
-#[derive(Clone, Debug)]
-pub struct Engine(pub(crate) engine_imp::Engine);
-
-impl Engine {
-    /// Returns the deterministic id of this engine
-    pub fn deterministic_id(&self) -> &str {
-        self.0.deterministic_id()
-    }
-
-    #[cfg(all(feature = "sys", not(target_arch = "wasm32")))]
-    /// Deserializes a WebAssembly module which was previously serialized with
-    /// `Module::serialize`.
-    ///
-    /// NOTE: you should almost always prefer [`Self::deserialize`].
-    ///
-    /// # Safety
-    /// See [`Artifact::deserialize_unchecked`].
-    pub unsafe fn deserialize_unchecked(
-        &self,
-        bytes: impl IntoBytes,
-    ) -> Result<Arc<Artifact>, DeserializeError> {
-        Ok(Arc::new(Artifact::deserialize_unchecked(
-            &self.0,
-            bytes.into_bytes().into(),
-        )?))
-    }
-
-    #[cfg(all(feature = "sys", not(target_arch = "wasm32")))]
-    /// Deserializes a WebAssembly module which was previously serialized with
-    /// `Module::serialize`.
-    ///
-    /// # Safety
-    /// See [`Artifact::deserialize`].
-    pub unsafe fn deserialize(
-        &self,
-        bytes: impl IntoBytes,
-    ) -> Result<Arc<Artifact>, DeserializeError> {
-        Ok(Arc::new(Artifact::deserialize(
-            &self.0,
-            bytes.into_bytes().into(),
-        )?))
-    }
-
-    #[cfg(all(feature = "sys", not(target_arch = "wasm32")))]
-    /// Load a serialized WebAssembly module from a file and deserialize it.
-    ///
-    /// NOTE: you should almost always prefer [`Self::deserialize_from_file`].
-    ///
-    /// # Safety
-    /// See [`Artifact::deserialize_unchecked`].
-    pub unsafe fn deserialize_from_file_unchecked(
-        &self,
-        file_ref: &Path,
-    ) -> Result<Arc<Artifact>, DeserializeError> {
-        let file = std::fs::File::open(file_ref)?;
-        Ok(Arc::new(Artifact::deserialize_unchecked(
-            &self.0,
-            OwnedBuffer::from_file(&file)
-                .map_err(|e| DeserializeError::Generic(format!("{e:?}")))?,
-        )?))
-    }
-
-    #[cfg(all(feature = "sys", not(target_arch = "wasm32")))]
-    /// Load a serialized WebAssembly module from a file and deserialize it.
-    ///
-    /// # Safety
-    /// See [`Artifact::deserialize`].
-    pub unsafe fn deserialize_from_file(
-        &self,
-        file_ref: &Path,
-    ) -> Result<Arc<Artifact>, DeserializeError> {
-        let bytes = std::fs::read(file_ref)?;
-        Ok(Arc::new(Artifact::deserialize(&self.0, bytes.into())?))
-    }
-}
-
-impl AsEngineRef for Engine {
-    #[inline]
-    fn as_engine_ref(&self) -> EngineRef {
-        EngineRef { inner: self }
-    }
-}
-
-impl Default for Engine {
-    fn default() -> Self {
-        Self(default_engine())
-    }
-}
-
-impl<T: Into<engine_imp::Engine>> From<T> for Engine {
-    fn from(t: T) -> Self {
-        Self(t.into())
-    }
-}
-
-/// A temporary handle to an [`Engine`]
-/// EngineRef can be used to build a [`Module`][super::Module]
-/// It can be created directly with an [`Engine`]
-/// Or from anything implementing [`AsEngineRef`]
-/// like from [`Store`][super::Store] typicaly.
-pub struct EngineRef<'a> {
-    /// The inner engine
-    pub(crate) inner: &'a Engine,
-}
-
-impl<'a> EngineRef<'a> {
-    /// Get inner [`Engine`]
-    pub fn engine(&self) -> &Engine {
-        self.inner
-    }
-    /// Create an EngineRef from an Engine
-    pub fn new(engine: &'a Engine) -> Self {
-        EngineRef { inner: engine }
-    }
-}
-
-/// Helper trait for a value that is convertible to a [`EngineRef`].
-pub trait AsEngineRef {
-    /// Returns a `EngineRef` pointing to the underlying context.
-    fn as_engine_ref(&self) -> EngineRef<'_>;
-}
-
-impl AsEngineRef for EngineRef<'_> {
-    #[inline]
-    fn as_engine_ref(&self) -> EngineRef<'_> {
-        EngineRef { inner: self.inner }
-    }
-}
-
-impl<P> AsEngineRef for P
-where
-    P: Deref,
-    P::Target: AsEngineRef,
-{
-    #[inline]
-    fn as_engine_ref(&self) -> EngineRef<'_> {
-        (**self).as_engine_ref()
-    }
-}
diff --git a/lib/api/src/entities/engine/engine_ref.rs b/lib/api/src/entities/engine/engine_ref.rs
new file mode 100644
index 0000000000..d33eb04860
--- /dev/null
+++ b/lib/api/src/entities/engine/engine_ref.rs
@@ -0,0 +1,67 @@
+use crate::entities::store::StoreRef;
+
+use super::Engine;
+
+/// A temporary handle to an [`Engine`].
+///
+/// An [`EngineRef`] can be used to build a [`Module`][crate::entities::Module], and can be created directly
+/// from an [`Engine`] or from anything implementing [`AsEngineRef`], like a
+/// [`Store`][crate::entities::Store].
+pub struct EngineRef<'a> {
+    /// The inner engine
+    pub(crate) inner: &'a Engine,
+}
+
+impl<'a> EngineRef<'a> {
+    /// Get inner [`Engine`]
+    pub fn engine(&self) -> &Engine {
+        self.inner
+    }
+    /// Create an EngineRef from an Engine
+    pub fn new(engine: &'a Engine) -> Self {
+        EngineRef { inner: engine }
+    }
+}
+
+/// Helper trait for a value that is convertible to a [`EngineRef`].
+pub trait AsEngineRef {
+    /// Create an [`EngineRef`] pointing to the underlying context.
+    fn as_engine_ref(&self) -> EngineRef<'_>;
+
+    /// Create a [`StoreRef`].
+    ///
+    /// NOTE: this function will return [`None`] if the [`AsEngineRef`] implementor is not an
+    /// actual [`crate::Store`].
+    fn maybe_as_store(&self) -> Option<StoreRef<'_>> {
+        None
+    }
+}
+
+impl AsEngineRef for EngineRef<'_> {
+    #[inline]
+    fn as_engine_ref(&self) -> EngineRef<'_> {
+        EngineRef { inner: self.inner }
+    }
+}
+
+impl<P> AsEngineRef for P
+where
+    P: std::ops::Deref,
+    P::Target: AsEngineRef,
+{
+    #[inline]
+    fn as_engine_ref(&self) -> EngineRef<'_> {
+        (**self).as_engine_ref()
+    }
+
+    fn maybe_as_store(&self) -> Option<StoreRef<'_>> {
+        (**self).maybe_as_store()
+    }
+}
+
+impl AsEngineRef for Engine {
+    #[inline]
+    fn as_engine_ref(&self) -> EngineRef {
+        EngineRef { inner: self }
+    }
+}
diff --git a/lib/api/src/entities/engine/inner.rs b/lib/api/src/entities/engine/inner.rs
new file mode 100644
index 0000000000..8c0326e1d6
--- /dev/null
+++ b/lib/api/src/entities/engine/inner.rs
@@ -0,0 +1,194 @@
+use bytes::Bytes;
+use std::{path::Path, sync::Arc};
+use wasmer_types::{target::Target, DeserializeError, Features};
+
+#[cfg(feature = "sys")]
+use wasmer_compiler::Artifact;
+#[cfg(feature = "compiler")]
+use wasmer_compiler::CompilerConfig;
+
+use crate::{
+    macros::backend::{gen_rt_ty, match_rt},
+    BackendKind, IntoBytes, Store,
+};
+
+gen_rt_ty!(Engine @derives Debug, Clone);
+
+impl BackendEngine {
+    /// Returns the deterministic id of this engine.
+    #[inline]
+    pub fn deterministic_id(&self) -> String {
+        match_rt!(on self  => s {
+            s.deterministic_id()
+        })
+    }
+
+    #[cfg(all(feature = "sys", not(target_arch = "wasm32")))]
+    /// Deserializes a WebAssembly module which was previously serialized with
+    /// `Module::serialize`,
+    ///
+    /// # Note
+    /// You should almost always prefer [`Self::deserialize`].
+    ///
+    /// # Errors
+    /// Not every implementer supports serializing and deserializing modules.
+    /// Currently, only the `sys` engines support it, and only when the target
+    /// architecture is not `wasm32`.
+    ///
+    /// # Safety
+    /// See [`Artifact::deserialize_unchecked`].
+    #[inline]
+    pub(crate) unsafe fn deserialize_unchecked(
+        &self,
+        bytes: impl IntoBytes,
+    ) -> Result<Arc<Artifact>, DeserializeError> {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(s) => s.deserialize_unchecked(bytes.into_bytes().to_owned().into()),
+            _ => Err(DeserializeError::Generic(
+                "The selected runtime does not support `deserialize_unchecked`".into(),
+            )),
+        }
+    }
+
+    #[cfg(all(feature = "sys", not(target_arch = "wasm32")))]
+    /// Deserializes a WebAssembly module which was previously serialized with
+    /// `Module::serialize`,
+    ///
+    /// # Errors
+    /// Not every implementer supports serializing and deserializing modules.
+    /// Currently, only the `sys` engines support it, and only when the target
+    /// architecture is not `wasm32`.
+    #[inline]
+    pub(crate) unsafe fn deserialize(
+        &self,
+        bytes: impl IntoBytes,
+    ) -> Result<Arc<Artifact>, DeserializeError> {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(s) => s.deserialize(bytes.into_bytes().to_owned().into()),
+            _ => Err(DeserializeError::Generic(
+                "The selected runtime does not support `deserialize`".into(),
+            )),
+        }
+    }
+
+    #[cfg(all(feature = "sys", not(target_arch = "wasm32")))]
+    /// Load a serialized WebAssembly module from a file and deserialize it.
+    ///
+    /// # Note
+    /// You should almost always prefer [`Self::deserialize_from_file`].
+    ///
+    /// # Errors
+    /// Not every implementer supports serializing and deserializing modules.
+    /// Currently, only the `sys` engines support it, and only when the target
+    /// architecture is not `wasm32`.
+    ///
+    /// # Safety
+    /// See [`Artifact::deserialize_unchecked`].
+    #[inline]
+    pub(crate) unsafe fn deserialize_from_file_unchecked(
+        &self,
+        file_ref: &Path,
+    ) -> Result<Arc<Artifact>, DeserializeError> {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(s) => s.deserialize_from_file_unchecked(file_ref),
+            _ => Err(DeserializeError::Generic(
+                "The selected runtime does not support `deserialize_from_file_unchecked`".into(),
+            )),
+        }
+    }
+
+    #[cfg(all(feature = "sys", not(target_arch = "wasm32")))]
+    /// Load a serialized WebAssembly module from a file and deserialize it.
+    ///
+    /// # Errors
+    /// Not every implementer supports serializing and deserializing modules.
+    /// Currently, only the `sys` engines support it, and only when the target
+    /// architecture is not `wasm32`.
+    ///
+    /// # Safety
+    /// See [`Artifact::deserialize`].
+    #[inline]
+    pub(crate) unsafe fn deserialize_from_file(
+        &self,
+        file_ref: &Path,
+    ) -> Result<Arc<Artifact>, DeserializeError> {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(s) => s.deserialize_from_file(file_ref),
+            _ => Err(DeserializeError::Generic(
+                "The selected runtime does not support `deserialize_from_file`".into(),
+            )),
+        }
+    }
+}
+
+impl Default for BackendEngine {
+    #[allow(unreachable_code)]
+    #[inline]
+    fn default() -> Self {
+        #[cfg(feature = "sys-default")]
+        {
+            return Self::Sys(crate::backend::sys::entities::engine::default_engine());
+        }
+
+        #[cfg(feature = "wamr-default")]
+        {
+            return Self::Wamr(crate::backend::wamr::entities::engine::default_engine());
+        }
+
+        #[cfg(feature = "wasmi-default")]
+        {
+            return Self::Wasmi(crate::backend::wasmi::entities::engine::default_engine());
+        }
+
+        #[cfg(feature = "v8-default")]
+        {
+            return Self::V8(crate::backend::v8::entities::engine::default_engine());
+        }
+
+        #[cfg(feature = "js-default")]
+        {
+            return Self::Js(crate::backend::js::entities::engine::default_engine());
+        }
+
+        #[cfg(feature = "jsc-default")]
+        {
+            return Self::Jsc(crate::backend::jsc::entities::engine::default_engine());
+        }
+
+        #[cfg(feature = "sys")]
+        {
+            return Self::Sys(crate::backend::sys::entities::engine::default_engine());
+        }
+
+        #[cfg(feature = "wamr")]
+        {
+            return Self::Wamr(crate::backend::wamr::entities::engine::default_engine());
+        }
+
+        #[cfg(feature = "wasmi")]
+        {
+            return Self::Wasmi(crate::backend::wasmi::entities::engine::default_engine());
+        }
+
+        #[cfg(feature = "v8")]
+        {
+            return Self::V8(crate::backend::v8::entities::engine::default_engine());
+        }
+
+        #[cfg(feature = "js")]
+        {
+            return Self::Js(crate::backend::js::entities::engine::default_engine());
+        }
+
+        #[cfg(feature = "jsc")]
+        {
+            return Self::Jsc(crate::backend::jsc::entities::engine::default_engine());
+        }
+
+        panic!("No runtime enabled!")
+    }
+}
diff --git a/lib/api/src/entities/engine/mod.rs b/lib/api/src/entities/engine/mod.rs
new file mode 100644
index 0000000000..b28b250918
--- /dev/null
+++ b/lib/api/src/entities/engine/mod.rs
@@ -0,0 +1,258 @@
+//! Defines the [`self::Engine`] type and useful traits and data types to interact with an engine.
+
+use bytes::Bytes;
+use std::{path::Path, sync::Arc};
+use wasmer_types::{
+    target::{Target, UserCompilerOptimizations},
+    CompileError, DeserializeError, Features,
+};
+
+#[cfg(feature = "sys")]
+use wasmer_compiler::Artifact;
+
+#[cfg(feature = "compiler")]
+use wasmer_compiler::CompilerConfig;
+
+use crate::{BackendKind, IntoBytes, Store};
+
+/// Create temporary handles to engines.
+mod engine_ref;
+
+/// The actual (private) definition of the engines.
+mod inner;
+pub(crate) use inner::BackendEngine;
+
+pub use engine_ref::*;
+
+/// An engine identifier.
+#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]
+pub struct EngineId(u64);
+
+/// The [`Engine`] is the entrypoint type for the runtime. It defines the kind of steps the runtime must take to execute
+/// the WebAssembly module (compile, interpret..) and the place of execution (in-browser, host,
+/// ..).
+#[derive(Debug, Clone)]
+pub struct Engine {
+    pub(crate) be: BackendEngine,
+    pub(crate) id: u64,
+}
+
+impl Default for Engine {
+    fn default() -> Self {
+        Self {
+            be: Default::default(),
+            id: Self::atomic_next_engine_id(),
+        }
+    }
+}
+
+impl Engine {
+    pub(crate) fn atomic_next_engine_id() -> u64 {
+        #[cfg(target_has_atomic = "64")]
+        {
+            static ENGINE_ID_COUNTER: std::sync::atomic::AtomicU64 =
+                std::sync::atomic::AtomicU64::new(0);
+            return ENGINE_ID_COUNTER.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+        }
+
+        #[allow(unreachable_code)]
+        #[cfg(target_has_atomic = "32")]
+        {
+            static ENGINE_ID_COUNTER: std::sync::atomic::AtomicU32 =
+                std::sync::atomic::AtomicU32::new(0);
+            ENGINE_ID_COUNTER.fetch_add(1, std::sync::atomic::Ordering::SeqCst) as _
+        }
+    }
+
+    /// Returns the deterministic id of this engine.
+    pub fn deterministic_id(&self) -> String {
+        self.be.deterministic_id()
+    }
+
+    /// Returns the unique id of this engine.
+    pub fn id(&self) -> EngineId {
+        EngineId(self.id)
+    }
+
+    /// Returns the default WebAssembly features supported by this backend for a given target.
+    ///
+    /// These are the features that will be enabled by default without any user configuration.
+    pub fn default_features_for_backend(backend: &crate::BackendKind, target: &Target) -> Features {
+        match backend {
+            #[cfg(feature = "cranelift")]
+            crate::BackendKind::Cranelift => {
+                wasmer_compiler_cranelift::Cranelift::default().default_features_for_target(target)
+            }
+            #[cfg(feature = "llvm")]
+            crate::BackendKind::LLVM => {
+                wasmer_compiler_llvm::LLVM::default().default_features_for_target(target)
+            }
+            #[cfg(feature = "singlepass")]
+            crate::BackendKind::Singlepass => wasmer_compiler_singlepass::Singlepass::default()
+                .default_features_for_target(target),
+            #[cfg(feature = "v8")]
+            crate::BackendKind::V8 => {
+                // Get V8-specific features
+                crate::backend::v8::engine::Engine::default_features()
+            }
+            #[cfg(feature = "wamr")]
+            crate::BackendKind::Wamr => {
+                // Get WAMR-specific features
+                crate::backend::wamr::engine::Engine::default_features()
+            }
+            #[cfg(feature = "wasmi")]
+            crate::BackendKind::Wasmi => {
+                // Get WASMI-specific features
+                crate::backend::wasmi::engine::Engine::default_features()
+            }
+            #[cfg(feature = "js")]
+            crate::BackendKind::Js => {
+                // Get JS-specific features
+                crate::backend::js::engine::Engine::default_features()
+            }
+            #[cfg(feature = "jsc")]
+            crate::BackendKind::Jsc => {
+                // Get JSC-specific features
+                crate::backend::jsc::engine::Engine::default_features()
+            }
+            // Default case
+            _ => Features::default(),
+        }
+    }
+
+    /// Returns all WebAssembly features supported by the specified backend for a given target.
+    ///
+    /// This static method allows checking features for any backend, not just the current one.
+    pub fn supported_features_for_backend(
+        backend: &crate::BackendKind,
+        target: &Target,
+    ) -> Features {
+        match backend {
+            #[cfg(feature = "cranelift")]
+            crate::BackendKind::Cranelift => wasmer_compiler_cranelift::Cranelift::default()
+                .supported_features_for_target(target),
+            #[cfg(feature = "llvm")]
+            crate::BackendKind::LLVM => {
+                wasmer_compiler_llvm::LLVM::default().supported_features_for_target(target)
+            }
+            #[cfg(feature = "singlepass")]
+            crate::BackendKind::Singlepass => wasmer_compiler_singlepass::Singlepass::default()
+                .supported_features_for_target(target),
+            #[cfg(feature = "v8")]
+            crate::BackendKind::V8 => {
+                // Get V8-specific features
+                crate::backend::v8::engine::Engine::supported_features()
+            }
+            #[cfg(feature = "wamr")]
+            crate::BackendKind::Wamr => {
+                // Get WAMR-specific features
+                crate::backend::wamr::engine::Engine::supported_features()
+            }
+            #[cfg(feature = "wasmi")]
+            crate::BackendKind::Wasmi => {
+                // Get WASMI-specific features
+                crate::backend::wasmi::engine::Engine::supported_features()
+            }
+            #[cfg(feature = "js")]
+            crate::BackendKind::Js => {
+                // Get JS-specific features
+                crate::backend::js::engine::Engine::supported_features()
+            }
+            #[cfg(feature = "jsc")]
+            crate::BackendKind::Jsc => {
+                // Get JSC-specific features
+                crate::backend::jsc::engine::Engine::supported_features()
+            }
+            // Default case
+            _ => Features::default(),
+        }
+    }
+
+    #[cfg(all(feature = "sys", not(target_arch = "wasm32")))]
+    /// Deserializes a WebAssembly module which was previously serialized with
+    /// `Module::serialize`,
+    ///
+    /// # Note
+    /// You should almost always prefer [`Self::deserialize`].
+    ///
+    /// # Errors
+    /// Not every implementer supports serializing and deserializing modules.
+    /// Currently, only the `sys` engines support it, and only when the target
+    /// architecture is not `wasm32`.
+    ///
+    /// # Safety
+    /// See [`Artifact::deserialize_unchecked`].
+    unsafe fn deserialize_unchecked(
+        &self,
+        bytes: impl IntoBytes,
+    ) -> Result<Arc<Artifact>, DeserializeError> {
+        self.be.deserialize_unchecked(bytes)
+    }
+
+    #[cfg(all(feature = "sys", not(target_arch = "wasm32")))]
+    /// Deserializes a WebAssembly module which was previously serialized with
+    /// `Module::serialize`,
+    ///
+    /// # Errors
+    /// Not every implementer supports serializing and deserializing modules.
+    /// Currently, only the `sys` engines support it, and only when the target
+    /// architecture is not `wasm32`.
+    unsafe fn deserialize(&self, bytes: impl IntoBytes) -> Result<Arc<Artifact>, DeserializeError> {
+        self.be.deserialize(bytes)
+    }
+
+    #[cfg(all(feature = "sys", not(target_arch = "wasm32")))]
+    /// Load a serialized WebAssembly module from a file and deserialize it.
+    ///
+    /// # Note
+    /// You should almost always prefer [`Self::deserialize_from_file`].
+    ///
+    /// # Errors
+    /// Not every implementer supports serializing and deserializing modules.
+    /// Currently, only the `sys` engines support it, and only when the target
+    /// architecture is not `wasm32`.
+    ///
+    /// # Safety
+    /// See [`Artifact::deserialize_unchecked`].
+    unsafe fn deserialize_from_file_unchecked(
+        &self,
+        file_ref: &Path,
+    ) -> Result<Arc<Artifact>, DeserializeError> {
+        self.be.deserialize_from_file_unchecked(file_ref)
+    }
+
+    #[cfg(all(feature = "sys", not(target_arch = "wasm32")))]
+    /// Load a serialized WebAssembly module from a file and deserialize it.
+    ///
+    /// # Errors
+    /// Not every implementer supports serializing and deserializing modules.
+    /// Currently, only the `sys` engines support it, and only when the target
+    /// architecture is not `wasm32`.
+    ///
+    /// # Safety
+    /// See [`Artifact::deserialize`].
+    unsafe fn deserialize_from_file(
+        &self,
+        file_ref: &Path,
+    ) -> Result<Arc<Artifact>, DeserializeError> {
+        self.be.deserialize_from_file_unchecked(file_ref)
+    }
+
+    /// Add suggested optimizations to this engine.
+    ///
+    /// # Note
+    ///
+    /// Not every backend supports every optimization. This function may fail (i.e. not set the
+    /// suggested optimizations) silently if the underlying engine backend does not support one or
+    /// more optimizations.
+    pub fn with_opts(
+        &mut self,
+        suggested_opts: &UserCompilerOptimizations,
+    ) -> Result<(), CompileError> {
+        match self.be {
+            #[cfg(feature = "sys")]
+            BackendEngine::Sys(ref mut e) => e.with_opts(suggested_opts),
+            _ => Ok(()),
+        }
+    }
+}
diff --git a/lib/api/src/entities/exception/exnref/inner.rs b/lib/api/src/entities/exception/exnref/inner.rs
new file mode 100644
index 0000000000..9940a78a2f
--- /dev/null
+++ b/lib/api/src/entities/exception/exnref/inner.rs
@@ -0,0 +1,135 @@
+use std::any::Any;
+
+use crate::entities::store::{AsStoreMut, AsStoreRef};
+use crate::macros::backend::{gen_rt_ty, match_rt};
+use crate::vm::VMExceptionRef;
+use crate::StoreRef;
+
+gen_rt_ty!(ExceptionRef @derives derive_more::From, Debug, Clone ; @path exception);
+
+impl BackendExceptionRef {
+    /// Make a new extern reference
+    pub fn new<T>(store: &mut impl AsStoreMut, value: T) -> Self
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(s) => Self::Sys(
+                crate::backend::sys::entities::exception::ExceptionRef::new(store, value),
+            ),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(s) => Self::Wamr(
+                crate::backend::wamr::entities::exception::ExceptionRef::new(store, value),
+            ),
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(s) => Self::Wasmi(
+                crate::backend::wasmi::entities::exception::ExceptionRef::new(store, value),
+            ),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(s) => Self::V8(
+                crate::backend::v8::entities::exception::ExceptionRef::new(store, value),
+            ),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(s) => Self::Js(
+                crate::backend::js::entities::exception::ExceptionRef::new(store, value),
+            ),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(s) => Self::Jsc(
+                crate::backend::jsc::entities::exception::ExceptionRef::new(store, value),
+            ),
+        }
+    }
+
+    /// Try to downcast to the given value.
+    pub fn downcast<'a, T>(&self, store: &'a impl AsStoreRef) -> Option<&'a T>
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        match_rt!(on self => r {
+            r.downcast::<T>(store)
+        })
+    }
+
+    /// Create a [`VMExceptionRef`] from [`Self`].
+    pub(crate) fn vm_exceptionref(&self) -> VMExceptionRef {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(r) => VMExceptionRef::Sys(r.vm_exceptionref()),
+            #[cfg(feature = "wamr")]
+            Self::Wamr(r) => VMExceptionRef::Wamr(r.vm_exceptionref()),
+            #[cfg(feature = "wasmi")]
+            Self::Wasmi(r) => VMExceptionRef::Wasmi(r.vm_exceptionref()),
+            #[cfg(feature = "v8")]
+            Self::V8(r) => VMExceptionRef::V8(r.vm_exceptionref()),
+            #[cfg(feature = "js")]
+            Self::Js(r) => VMExceptionRef::Js(r.vm_exceptionref()),
+            #[cfg(feature = "jsc")]
+            Self::Jsc(r) => VMExceptionRef::Jsc(r.vm_exceptionref()),
+        }
+    }
+
+    /// Create an instance of [`Self`] from a [`VMExceptionRef`].
+    pub(crate) unsafe fn from_vm_exceptionref(
+        store: &mut impl AsStoreMut,
+        vm_externref: VMExceptionRef,
+    ) -> Self {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(_) => Self::Sys(
+                crate::backend::sys::entities::exception::ExceptionRef::from_vm_exceptionref(
+                    store,
+                    vm_externref.into_sys(),
+                ),
+            ),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => Self::Wamr(
+                crate::backend::wamr::entities::exception::ExceptionRef::from_vm_exceptionref(
+                    store,
+                    vm_externref.into_wamr(),
+                ),
+            ),
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => Self::Wasmi(
+                crate::backend::wasmi::entities::exception::ExceptionRef::from_vm_exceptionref(
+                    store,
+                    vm_externref.into_wasmi(),
+                ),
+            ),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => Self::V8(
+                crate::backend::v8::entities::exception::ExceptionRef::from_vm_exceptionref(
+                    store,
+                    vm_externref.into_v8(),
+                ),
+            ),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => Self::Js(
+                crate::backend::js::entities::exception::ExceptionRef::from_vm_exceptionref(
+                    store,
+                    vm_externref.into_js(),
+                ),
+            ),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => Self::Jsc(
+                crate::backend::jsc::entities::exception::ExceptionRef::from_vm_exceptionref(
+                    store,
+                    vm_externref.into_jsc(),
+                ),
+            ),
+        }
+    }
+
+    /// Checks whether this `ExceptionRef` can be used with the given context.
+    ///
+    /// Primitive (`i32`, `i64`, etc) and null funcref/externref values are not
+    /// tied to a context and can be freely shared between contexts.
+    ///
+    /// Externref and funcref values are tied to a context and can only be used
+    /// with that context.
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        match_rt!(on self => r {
+            r.is_from_store(store)
+        })
+    }
+}
diff --git a/lib/api/src/entities/exception/exnref/mod.rs b/lib/api/src/entities/exception/exnref/mod.rs
new file mode 100644
index 0000000000..c1f8ca02e6
--- /dev/null
+++ b/lib/api/src/entities/exception/exnref/mod.rs
@@ -0,0 +1,57 @@
+use std::any::Any;
+
+use crate::entities::store::{AsStoreMut, AsStoreRef};
+use crate::vm::{VMExceptionRef, VMExternRef};
+use crate::StoreRef;
+
+pub(crate) mod inner;
+pub(crate) use inner::*;
+
+#[derive(Debug, Clone, derive_more::From)]
+/// An opaque reference to some data. This reference can be passed through Wasm.
+pub struct ExceptionRef(pub(crate) BackendExceptionRef);
+
+impl ExceptionRef {
+    /// Make a new extern reference
+    pub fn new<T>(store: &mut impl AsStoreMut, value: T) -> Self
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        Self(BackendExceptionRef::new(store, value))
+    }
+
+    /// Try to downcast to the given value.
+    pub fn downcast<'a, T>(&self, store: &'a impl AsStoreRef) -> Option<&'a T>
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        self.0.downcast(store)
+    }
+
+    /// Create a [`VMExceptionRef`] from [`Self`].
+    pub(crate) fn vm_exceptionref(&self) -> VMExceptionRef {
+        self.0.vm_exceptionref()
+    }
+
+    /// Create an instance of [`Self`] from a [`VMExceptionRef`].
+    pub(crate) unsafe fn from_vm_exceptionref(
+        store: &mut impl AsStoreMut,
+        vm_externref: VMExceptionRef,
+    ) -> Self {
+        Self(BackendExceptionRef::from_vm_exceptionref(
+            store,
+            vm_externref,
+        ))
+    }
+
+    /// Checks whether this `ExceptionRef` can be used with the given context.
+    ///
+    /// Primitive (`i32`, `i64`, etc) and null funcref/externref values are not
+    /// tied to a context and can be freely shared between contexts.
+    ///
+    /// Externref and funcref values are tied to a context and can only be used
+    /// with that context.
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.0.is_from_store(store)
+    }
+}
diff --git a/lib/api/src/entities/exception/inner.rs b/lib/api/src/entities/exception/inner.rs
new file mode 100644
index 0000000000..3b7c601050
--- /dev/null
+++ b/lib/api/src/entities/exception/inner.rs
@@ -0,0 +1,55 @@
+use crate::{
+    macros::backend::{gen_rt_ty, match_rt},
+    vm::{VMExtern, VMExternTag},
+    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, Tag, Value,
+};
+
+/// A WebAssembly `global` instance.
+///
+/// A global instance is the runtime representation of a global variable.
+/// It consists of an individual value and a flag indicating whether it is mutable.
+///
+/// Spec: <https://webassembly.github.io/spec/core/exec/runtime.html#global-instances>
+gen_rt_ty!(Exception
+    @cfg feature = "artifact-size" => derive(loupe::MemoryUsage)
+    @derives Debug, Clone, PartialEq, Eq, derive_more::From
+);
+
+impl BackendException {
+    /// Create a new exception with the given tag type and payload.
+    #[inline]
+    pub fn new(store: &mut impl AsStoreMut, tag: Tag, payload: &[Value]) -> Self {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(_) => Self::Sys(
+                crate::backend::sys::exception::Exception::new(store, tag, payload),
+            ),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => Self::Wamr(
+                crate::backend::wamr::exception::Exception::new(store, tag, payload),
+            ),
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => Self::Wasmi(
+                crate::backend::wasmi::exception::Exception::new(store, tag, payload),
+            ),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => Self::V8(crate::backend::v8::exception::Exception::new(
+                store, tag, payload,
+            )),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => Self::Js(crate::backend::js::exception::Exception::new(
+                store, tag, payload,
+            )),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => Self::Jsc(
+                crate::backend::jsc::exception::Exception::new(store, tag, payload),
+            ),
+        }
+    }
+
+    /// Checks whether this `Exception` can be used with the given store.
+    #[inline]
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        todo!()
+    }
+}
diff --git a/lib/api/src/entities/exception/mod.rs b/lib/api/src/entities/exception/mod.rs
new file mode 100644
index 0000000000..47c562df4e
--- /dev/null
+++ b/lib/api/src/entities/exception/mod.rs
@@ -0,0 +1,33 @@
+pub(crate) mod exnref;
+pub use exnref::*;
+
+pub(crate) mod inner;
+pub(crate) use inner::*;
+use wasmer_types::{TagType, Type};
+
+use crate::{
+    vm::{VMExtern, VMExternTag},
+    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, Tag, Value,
+};
+
+/// A WebAssembly `exception` instance.
+///
+/// An exception is an internal construct in WebAssembly that represents a runtime object that can
+/// be thrown. A WebAssembly exception consists of an exception tag and its runtime arguments.
+///
+/// Spec: <https://github.com/WebAssembly/exception-handling/blob/main/proposals/exception-handling/Exceptions.md#exceptions>
+#[derive(Debug, Clone, PartialEq, Eq, derive_more::From)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+pub struct Exception(pub(crate) BackendException);
+
+impl Exception {
+    /// Create a new exception with the given tag type and payload.
+    pub fn new(store: &mut impl AsStoreMut, tag: Tag, payload: &[Value]) -> Self {
+        Self(BackendException::new(store, tag, payload))
+    }
+
+    /// Checks whether this `Exception` comes from the given store.
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.0.is_from_store(store)
+    }
+}
diff --git a/lib/api/src/exports.rs b/lib/api/src/entities/exports.rs
similarity index 98%
rename from lib/api/src/exports.rs
rename to lib/api/src/entities/exports.rs
index d2f821145f..21a5f902d9 100644
--- a/lib/api/src/exports.rs
+++ b/lib/api/src/entities/exports.rs
@@ -58,6 +58,7 @@ pub enum ExportError {
 ///
 /// TODO: add examples of using exports
 #[derive(Clone, Default, PartialEq, Eq)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 pub struct Exports {
     map: IndexMap<String, Extern>,
 }
@@ -301,6 +302,6 @@ pub trait ExportableWithGenerics<'a, Args: WasmTypeList, Rets: WasmTypeList>: Si
 /// with empty `Args` and `Rets`.
 impl<'a, T: Exportable<'a> + Clone + 'static> ExportableWithGenerics<'a, (), ()> for T {
     fn get_self_from_extern_with_generics(_extern: &'a Extern) -> Result<Self, ExportError> {
-        T::get_self_from_extern(_extern).map(|i| i.clone())
+        T::get_self_from_extern(_extern).cloned()
     }
 }
diff --git a/lib/api/src/entities/external/extref/inner.rs b/lib/api/src/entities/external/extref/inner.rs
new file mode 100644
index 0000000000..124218aa89
--- /dev/null
+++ b/lib/api/src/entities/external/extref/inner.rs
@@ -0,0 +1,140 @@
+use std::any::Any;
+
+use crate::entities::store::{AsStoreMut, AsStoreRef};
+use crate::macros::backend::{gen_rt_ty, match_rt};
+use crate::vm::VMExternRef;
+use crate::StoreRef;
+
+gen_rt_ty!(ExternRef @derives derive_more::From, Debug, Clone ; @path external);
+
+impl BackendExternRef {
+    /// Make a new extern reference
+    #[inline]
+    pub fn new<T>(store: &mut impl AsStoreMut, value: T) -> Self
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(s) => Self::Sys(
+                crate::backend::sys::entities::external::ExternRef::new(store, value),
+            ),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(s) => Self::Wamr(
+                crate::backend::wamr::entities::external::ExternRef::new(store, value),
+            ),
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(s) => Self::Wasmi(
+                crate::backend::wasmi::entities::external::ExternRef::new(store, value),
+            ),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(s) => Self::V8(
+                crate::backend::v8::entities::external::ExternRef::new(store, value),
+            ),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(s) => Self::Js(
+                crate::backend::js::entities::external::ExternRef::new(store, value),
+            ),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(s) => Self::Jsc(
+                crate::backend::jsc::entities::external::ExternRef::new(store, value),
+            ),
+        }
+    }
+
+    /// Try to downcast to the given value.
+    #[inline]
+    pub fn downcast<'a, T>(&self, store: &'a impl AsStoreRef) -> Option<&'a T>
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        match_rt!(on self => r {
+            r.downcast::<T>(store)
+        })
+    }
+
+    /// Create a [`VMExternRef`] from [`Self`].
+    #[inline]
+    pub(crate) fn vm_externref(&self) -> VMExternRef {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(r) => VMExternRef::Sys(r.vm_externref()),
+            #[cfg(feature = "wamr")]
+            Self::Wamr(r) => VMExternRef::Wamr(r.vm_externref()),
+            #[cfg(feature = "wasmi")]
+            Self::Wasmi(r) => VMExternRef::Wasmi(r.vm_externref()),
+            #[cfg(feature = "v8")]
+            Self::V8(r) => VMExternRef::V8(r.vm_externref()),
+            #[cfg(feature = "js")]
+            Self::Js(r) => VMExternRef::Js(r.vm_externref()),
+            #[cfg(feature = "jsc")]
+            Self::Jsc(r) => VMExternRef::Jsc(r.vm_externref()),
+        }
+    }
+
+    /// Create an instance of [`Self`] from a [`VMExternRef`].
+    #[inline]
+    pub(crate) unsafe fn from_vm_externref(
+        store: &mut impl AsStoreMut,
+        vm_externref: VMExternRef,
+    ) -> Self {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(_) => Self::Sys(
+                crate::backend::sys::entities::external::ExternRef::from_vm_externref(
+                    store,
+                    vm_externref.into_sys(),
+                ),
+            ),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => Self::Wamr(
+                crate::backend::wamr::entities::external::ExternRef::from_vm_externref(
+                    store,
+                    vm_externref.into_wamr(),
+                ),
+            ),
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => Self::Wasmi(
+                crate::backend::wasmi::entities::external::ExternRef::from_vm_externref(
+                    store,
+                    vm_externref.into_wasmi(),
+                ),
+            ),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => Self::V8(
+                crate::backend::v8::entities::external::ExternRef::from_vm_externref(
+                    store,
+                    vm_externref.into_v8(),
+                ),
+            ),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => Self::Js(
+                crate::backend::js::entities::external::ExternRef::from_vm_externref(
+                    store,
+                    vm_externref.into_js(),
+                ),
+            ),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => Self::Jsc(
+                crate::backend::jsc::entities::external::ExternRef::from_vm_externref(
+                    store,
+                    vm_externref.into_jsc(),
+                ),
+            ),
+        }
+    }
+
+    /// Checks whether this `ExternRef` can be used with the given context.
+    ///
+    /// Primitive (`i32`, `i64`, etc) and null funcref/externref values are not
+    /// tied to a context and can be freely shared between contexts.
+    ///
+    /// Externref and funcref values are tied to a context and can only be used
+    /// with that context.
+    #[inline]
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        match_rt!(on self => r {
+            r.is_from_store(store)
+        })
+    }
+}
diff --git a/lib/api/src/extern_ref.rs b/lib/api/src/entities/external/extref/mod.rs
similarity index 69%
rename from lib/api/src/extern_ref.rs
rename to lib/api/src/entities/external/extref/mod.rs
index 038c7e4d8d..39c60d5d59 100644
--- a/lib/api/src/extern_ref.rs
+++ b/lib/api/src/entities/external/extref/mod.rs
@@ -1,19 +1,15 @@
 use std::any::Any;
 
-use crate::store::{AsStoreMut, AsStoreRef};
-
-#[cfg(feature = "js")]
-use crate::js::extern_ref as extern_ref_imp;
-#[cfg(feature = "jsc")]
-use crate::jsc::extern_ref as extern_ref_imp;
-#[cfg(feature = "sys")]
-use crate::sys::extern_ref as extern_ref_imp;
+use crate::entities::store::{AsStoreMut, AsStoreRef};
 use crate::vm::VMExternRef;
+use crate::StoreRef;
 
-#[derive(Debug, Clone)]
-#[repr(transparent)]
+pub(crate) mod inner;
+pub(crate) use inner::*;
+
+#[derive(Debug, Clone, derive_more::From)]
 /// An opaque reference to some data. This reference can be passed through Wasm.
-pub struct ExternRef(pub(crate) extern_ref_imp::ExternRef);
+pub struct ExternRef(pub(crate) BackendExternRef);
 
 impl ExternRef {
     /// Make a new extern reference
@@ -21,7 +17,7 @@ impl ExternRef {
     where
         T: Any + Send + Sync + 'static + Sized,
     {
-        Self(extern_ref_imp::ExternRef::new(store, value))
+        Self(BackendExternRef::new(store, value))
     }
 
     /// Try to downcast to the given value.
@@ -32,18 +28,17 @@ impl ExternRef {
         self.0.downcast(store)
     }
 
+    /// Create a [`VMExternRef`] from [`Self`].
     pub(crate) fn vm_externref(&self) -> VMExternRef {
         self.0.vm_externref()
     }
 
+    /// Create an instance of [`Self`] from a [`VMExternRef`].
     pub(crate) unsafe fn from_vm_externref(
         store: &mut impl AsStoreMut,
         vm_externref: VMExternRef,
     ) -> Self {
-        Self(extern_ref_imp::ExternRef::from_vm_externref(
-            store,
-            vm_externref,
-        ))
+        Self(BackendExternRef::from_vm_externref(store, vm_externref))
     }
 
     /// Checks whether this `ExternRef` can be used with the given context.
diff --git a/lib/api/src/externals/mod.rs b/lib/api/src/entities/external/mod.rs
similarity index 68%
rename from lib/api/src/externals/mod.rs
rename to lib/api/src/entities/external/mod.rs
index c5b46e8972..77891b5b5f 100644
--- a/lib/api/src/externals/mod.rs
+++ b/lib/api/src/entities/external/mod.rs
@@ -1,42 +1,36 @@
-pub(crate) mod function;
-mod global;
-pub(crate) mod memory;
-mod memory_view;
-mod table;
+pub(crate) mod extref;
+pub use extref::*;
 
-pub use self::function::{Function, HostFunction};
-pub use self::global::Global;
-pub use self::memory::{Memory, MemoryLocation, SharedMemory};
-pub use self::memory_view::MemoryView;
-pub use self::table::Table;
+use wasmer_types::ExternType;
 
-use crate::exports::{ExportError, Exportable};
-use crate::ExternType;
-use std::fmt;
+use crate::{
+    vm::VMExtern, AsStoreMut, AsStoreRef, ExportError, Exportable, Function, Global, Memory, Table,
+    Tag,
+};
 
-#[cfg(feature = "js")]
-use crate::js::vm::VMExtern;
-#[cfg(feature = "jsc")]
-use crate::jsc::vm::VMExtern;
-#[cfg(feature = "sys")]
-use wasmer_vm::VMExtern;
-
-use crate::store::{AsStoreMut, AsStoreRef};
+/// Trait convert a VMExtern to a Extern
+pub trait VMExternToExtern {
+    /// Convert to [`Extern`]
+    fn to_extern(self, store: &mut impl AsStoreMut) -> Extern;
+}
 
 /// An `Extern` is the runtime representation of an entity that
 /// can be imported or exported.
 ///
 /// Spec: <https://webassembly.github.io/spec/core/exec/runtime.html#external-values>
 #[derive(Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 pub enum Extern {
-    /// A external [`Function`].
+    /// An external [`Function`].
     Function(Function),
-    /// A external [`Global`].
+    /// An external [`Global`].
     Global(Global),
-    /// A external [`Table`].
+    /// An external [`Table`].
     Table(Table),
-    /// A external [`Memory`].
+    /// An external [`Memory`].
     Memory(Memory),
+    /// An external [`Memory`].
+    Tag(Tag),
 }
 
 impl Extern {
@@ -47,17 +41,13 @@ impl Extern {
             Self::Memory(ft) => ExternType::Memory(ft.ty(store)),
             Self::Table(tt) => ExternType::Table(tt.ty(store)),
             Self::Global(gt) => ExternType::Global(gt.ty(store)),
+            Self::Tag(tt) => ExternType::Tag(tt.ty(store)),
         }
     }
 
     /// Create an `Extern` from an `wasmer_engine::Export`.
     pub fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExtern) -> Self {
-        match vm_extern {
-            VMExtern::Function(f) => Self::Function(Function::from_vm_extern(store, f)),
-            VMExtern::Memory(m) => Self::Memory(Memory::from_vm_extern(store, m)),
-            VMExtern::Global(g) => Self::Global(Global::from_vm_extern(store, g)),
-            VMExtern::Table(t) => Self::Table(Table::from_vm_extern(store, t)),
-        }
+        vm_extern.to_extern(store)
     }
 
     /// Checks whether this `Extern` can be used with the given context.
@@ -65,6 +55,7 @@ impl Extern {
         match self {
             Self::Function(f) => f.is_from_store(store),
             Self::Global(g) => g.is_from_store(store),
+            Self::Tag(t) => t.is_from_store(store),
             Self::Memory(m) => m.is_from_store(store),
             Self::Table(t) => t.is_from_store(store),
         }
@@ -75,6 +66,7 @@ impl Extern {
         match self {
             Self::Function(f) => f.to_vm_extern(),
             Self::Global(g) => g.to_vm_extern(),
+            Self::Tag(t) => t.to_vm_extern(),
             Self::Memory(m) => m.to_vm_extern(),
             Self::Table(t) => t.to_vm_extern(),
         }
@@ -88,14 +80,15 @@ impl<'a> Exportable<'a> for Extern {
     }
 }
 
-impl fmt::Debug for Extern {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+impl std::fmt::Debug for Extern {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(
             f,
             "{}",
             match self {
                 Self::Function(_) => "Function(...)",
                 Self::Global(_) => "Global(...)",
+                Self::Tag(_) => "Tag(...)",
                 Self::Memory(_) => "Memory(...)",
                 Self::Table(_) => "Table(...)",
             }
@@ -115,6 +108,12 @@ impl From<Global> for Extern {
     }
 }
 
+impl From<Tag> for Extern {
+    fn from(r: Tag) -> Self {
+        Self::Tag(r)
+    }
+}
+
 impl From<Memory> for Extern {
     fn from(r: Memory) -> Self {
         Self::Memory(r)
diff --git a/lib/api/src/entities/function/env/inner.rs b/lib/api/src/entities/function/env/inner.rs
new file mode 100644
index 0000000000..62427e5108
--- /dev/null
+++ b/lib/api/src/entities/function/env/inner.rs
@@ -0,0 +1,240 @@
+use crate::{
+    macros::backend::match_rt, AsStoreMut, AsStoreRef, FunctionEnv, FunctionEnvMut, StoreMut,
+    StoreRef,
+};
+use std::{any::Any, marker::PhantomData};
+
+#[derive(Debug, derive_more::From)]
+/// An opaque reference to a function environment.
+/// The function environment data is owned by the `Store`.
+pub enum BackendFunctionEnv<T> {
+    #[cfg(feature = "sys")]
+    /// The function environment for the `sys` runtime.
+    Sys(crate::backend::sys::function::env::FunctionEnv<T>),
+    #[cfg(feature = "wamr")]
+    /// The function environment for the `wamr` runtime.
+    Wamr(crate::backend::wamr::function::env::FunctionEnv<T>),
+    #[cfg(feature = "wasmi")]
+    /// The function environment for the `wasmi` runtime.
+    Wasmi(crate::backend::wasmi::function::env::FunctionEnv<T>),
+    #[cfg(feature = "v8")]
+    /// The function environment for the `v8` runtime.
+    V8(crate::backend::v8::function::env::FunctionEnv<T>),
+    #[cfg(feature = "js")]
+    /// The function environment for the `js` runtime.
+    Js(crate::backend::js::function::env::FunctionEnv<T>),
+    #[cfg(feature = "jsc")]
+    /// The function environment for the `jsc` runtime.
+    Jsc(crate::backend::jsc::function::env::FunctionEnv<T>),
+}
+
+impl<T> Clone for BackendFunctionEnv<T> {
+    fn clone(&self) -> Self {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(s) => Self::Sys(s.clone()),
+            #[cfg(feature = "wamr")]
+            Self::Wamr(s) => Self::Wamr(s.clone()),
+
+            #[cfg(feature = "wasmi")]
+            Self::Wasmi(s) => Self::Wasmi(s.clone()),
+            #[cfg(feature = "v8")]
+            Self::V8(s) => Self::V8(s.clone()),
+            #[cfg(feature = "js")]
+            Self::Js(s) => Self::Js(s.clone()),
+            #[cfg(feature = "jsc")]
+            Self::Jsc(s) => Self::Jsc(s.clone()),
+        }
+    }
+}
+
+impl<T> BackendFunctionEnv<T> {
+    /// Make a new FunctionEnv
+    pub fn new(store: &mut impl AsStoreMut, value: T) -> Self
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        match store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(_) => Self::Sys(
+                crate::backend::sys::function::env::FunctionEnv::new(store, value),
+            ),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => Self::Wamr(
+                crate::backend::wamr::function::env::FunctionEnv::new(store, value),
+            ),
+
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => Self::Wasmi(
+                crate::backend::wasmi::function::env::FunctionEnv::new(store, value),
+            ),
+
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => Self::V8(
+                crate::backend::v8::function::env::FunctionEnv::new(store, value),
+            ),
+
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => Self::Js(
+                crate::backend::js::function::env::FunctionEnv::new(store, value),
+            ),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => Self::Jsc(
+                crate::backend::jsc::function::env::FunctionEnv::new(store, value),
+            ),
+        }
+    }
+
+    //#[allow(dead_code)] // This function is only used in js
+    //pub(crate) fn from_handle(handle: StoreHandle<VMFunctionEnvironment>) -> Self {
+    //    todo!()
+    //}
+
+    /// Get the data as reference
+    pub fn as_ref<'a>(&self, store: &'a impl AsStoreRef) -> &'a T
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        match_rt!(on self => f {
+            f.as_ref(store)
+        })
+    }
+
+    /// Get the data as mutable
+    pub fn as_mut<'a>(&self, store: &'a mut impl AsStoreMut) -> &'a mut T
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        match_rt!(on self => s {
+            s.as_mut(store)
+        })
+    }
+
+    /// Convert it into a `FunctionEnvMut`
+    pub fn into_mut(self, store: &mut impl AsStoreMut) -> FunctionEnvMut<T>
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        match_rt!(on self => f {
+            f.into_mut(store).into()
+        })
+    }
+}
+
+/// A temporary handle to a [`FunctionEnv`].
+#[derive(derive_more::From)]
+pub enum BackendFunctionEnvMut<'a, T: 'a> {
+    #[cfg(feature = "sys")]
+    /// The function environment for the `sys` runtime.
+    Sys(crate::backend::sys::function::env::FunctionEnvMut<'a, T>),
+    #[cfg(feature = "wamr")]
+    /// The function environment for the `wamr` runtime.
+    Wamr(crate::backend::wamr::function::env::FunctionEnvMut<'a, T>),
+
+    #[cfg(feature = "wasmi")]
+    /// The function environment for the `wasmi` runtime.
+    Wasmi(crate::backend::wasmi::function::env::FunctionEnvMut<'a, T>),
+    #[cfg(feature = "v8")]
+    /// The function environment for the `v8` runtime.
+    V8(crate::backend::v8::function::env::FunctionEnvMut<'a, T>),
+
+    #[cfg(feature = "js")]
+    /// The function environment for the `js` runtime.
+    Js(crate::backend::js::function::env::FunctionEnvMut<'a, T>),
+
+    #[cfg(feature = "jsc")]
+    /// The function environment for the `jsc` runtime.
+    Jsc(crate::backend::jsc::function::env::FunctionEnvMut<'a, T>),
+}
+
+impl<T: Send + 'static> BackendFunctionEnvMut<'_, T> {
+    /// Returns a reference to the host state in this function environement.
+    pub fn data(&self) -> &T {
+        match_rt!(on self => f {
+            f.data()
+        })
+    }
+
+    /// Returns a mutable- reference to the host state in this function environement.
+    pub fn data_mut(&mut self) -> &mut T {
+        match_rt!(on self => f {
+            f.data_mut()
+        })
+    }
+
+    /// Borrows a new immmutable reference
+    pub fn as_ref(&self) -> FunctionEnv<T> {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(ref f) => BackendFunctionEnv::Sys(f.as_ref()).into(),
+            #[cfg(feature = "wamr")]
+            Self::Wamr(ref f) => BackendFunctionEnv::Wamr(f.as_ref()).into(),
+            #[cfg(feature = "wasmi")]
+            Self::Wasmi(ref f) => BackendFunctionEnv::Wasmi(f.as_ref()).into(),
+            #[cfg(feature = "v8")]
+            Self::V8(ref f) => BackendFunctionEnv::V8(f.as_ref()).into(),
+            #[cfg(feature = "js")]
+            Self::Js(ref f) => BackendFunctionEnv::Js(f.as_ref()).into(),
+            #[cfg(feature = "jsc")]
+            Self::Jsc(ref f) => BackendFunctionEnv::Jsc(f.as_ref()).into(),
+        }
+    }
+
+    /// Borrows a new mutable reference
+    pub fn as_mut(&mut self) -> FunctionEnvMut<'_, T> {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(ref mut f) => BackendFunctionEnvMut::Sys(f.as_mut()).into(),
+            #[cfg(feature = "wamr")]
+            Self::Wamr(ref mut f) => BackendFunctionEnvMut::Wamr(f.as_mut()).into(),
+            #[cfg(feature = "wasmi")]
+            Self::Wasmi(ref mut f) => BackendFunctionEnvMut::Wasmi(f.as_mut()).into(),
+            #[cfg(feature = "v8")]
+            Self::V8(ref mut f) => BackendFunctionEnvMut::V8(f.as_mut()).into(),
+            #[cfg(feature = "js")]
+            Self::Js(ref mut f) => BackendFunctionEnvMut::Js(f.as_mut()).into(),
+            #[cfg(feature = "jsc")]
+            Self::Jsc(ref mut f) => BackendFunctionEnvMut::Jsc(f.as_mut()).into(),
+        }
+    }
+
+    /// Borrows a new mutable reference of both the attached Store and host state
+    pub fn data_and_store_mut(&mut self) -> (&mut T, StoreMut) {
+        match_rt!(on self => f {
+            f.data_and_store_mut()
+        })
+    }
+}
+
+impl<T> AsStoreRef for BackendFunctionEnvMut<'_, T> {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        match_rt!(on &self => f {
+            f.as_store_ref()
+        })
+    }
+}
+
+impl<T> AsStoreMut for BackendFunctionEnvMut<'_, T> {
+    fn as_store_mut(&mut self) -> StoreMut<'_> {
+        match_rt!(on self => s {
+            s.as_store_mut()
+        })
+    }
+
+    fn objects_mut(&mut self) -> &mut crate::StoreObjects {
+        match_rt!(on self => s {
+            s.objects_mut()
+        })
+    }
+}
+
+impl<T> std::fmt::Debug for BackendFunctionEnvMut<'_, T>
+where
+    T: Send + std::fmt::Debug + 'static,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match_rt!(on self => s {
+            write!(f, "{s:?}")
+        })
+    }
+}
diff --git a/lib/api/src/entities/function/env/mod.rs b/lib/api/src/entities/function/env/mod.rs
new file mode 100644
index 0000000000..5d24212e3b
--- /dev/null
+++ b/lib/api/src/entities/function/env/mod.rs
@@ -0,0 +1,111 @@
+pub(crate) mod inner;
+pub(crate) use inner::*;
+
+use crate::{macros::backend::match_rt, AsStoreMut, AsStoreRef, StoreMut, StoreRef};
+use std::{any::Any, fmt::Debug, marker::PhantomData};
+
+#[derive(Debug, derive_more::From)]
+/// An opaque reference to a function environment.
+/// The function environment data is owned by the `Store`.
+pub struct FunctionEnv<T>(pub(crate) BackendFunctionEnv<T>);
+
+impl<T> Clone for FunctionEnv<T> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+impl<T> FunctionEnv<T> {
+    /// Make a new FunctionEnv
+    pub fn new(store: &mut impl AsStoreMut, value: T) -> Self
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        Self(BackendFunctionEnv::new(store, value))
+    }
+
+    //#[allow(dead_code)] // This function is only used in js
+    //pub(crate) fn from_handle(handle: StoreHandle<VMFunctionEnvironment>) -> Self {
+    //    todo!()
+    //}
+
+    /// Get the data as reference
+    pub fn as_ref<'a>(&self, store: &'a impl AsStoreRef) -> &'a T
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        self.0.as_ref(store)
+    }
+
+    /// Get the data as mutable
+    pub fn as_mut<'a>(&self, store: &'a mut impl AsStoreMut) -> &'a mut T
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        self.0.as_mut(store)
+    }
+
+    /// Convert it into a `FunctionEnvMut`
+    pub fn into_mut(self, store: &mut impl AsStoreMut) -> FunctionEnvMut<T>
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        self.0.into_mut(store)
+    }
+}
+
+/// A temporary handle to a [`FunctionEnv`].
+#[derive(derive_more::From)]
+pub struct FunctionEnvMut<'a, T: 'a>(pub(crate) BackendFunctionEnvMut<'a, T>);
+
+impl<T: Send + 'static> FunctionEnvMut<'_, T> {
+    /// Returns a reference to the host state in this function environement.
+    pub fn data(&self) -> &T {
+        self.0.data()
+    }
+
+    /// Returns a mutable- reference to the host state in this function environement.
+    pub fn data_mut(&mut self) -> &mut T {
+        self.0.data_mut()
+    }
+
+    /// Borrows a new immmutable reference
+    pub fn as_ref(&self) -> FunctionEnv<T> {
+        self.0.as_ref()
+    }
+
+    /// Borrows a new mutable reference
+    pub fn as_mut(&mut self) -> FunctionEnvMut<'_, T> {
+        self.0.as_mut()
+    }
+
+    /// Borrows a new mutable reference of both the attached Store and host state
+    pub fn data_and_store_mut(&mut self) -> (&mut T, StoreMut) {
+        self.0.data_and_store_mut()
+    }
+}
+
+impl<T> AsStoreRef for FunctionEnvMut<'_, T> {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        self.0.as_store_ref()
+    }
+}
+
+impl<T> AsStoreMut for FunctionEnvMut<'_, T> {
+    fn as_store_mut(&mut self) -> StoreMut<'_> {
+        self.0.as_store_mut()
+    }
+
+    fn objects_mut(&mut self) -> &mut crate::StoreObjects {
+        self.0.objects_mut()
+    }
+}
+
+impl<T> std::fmt::Debug for FunctionEnvMut<'_, T>
+where
+    T: Send + std::fmt::Debug + 'static,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.fmt(f)
+    }
+}
diff --git a/lib/api/src/entities/function/host/imp.rs b/lib/api/src/entities/function/host/imp.rs
new file mode 100644
index 0000000000..db006b9cb2
--- /dev/null
+++ b/lib/api/src/entities/function/host/imp.rs
@@ -0,0 +1,175 @@
+use crate::{
+    utils::{FromToNativeWasmType, IntoResult, NativeWasmTypeInto, WasmTypeList},
+    AsStoreMut, AsStoreRef, BackendFunctionEnv, BackendFunctionEnvMut, FunctionEnvMut,
+    FunctionType, HostFunction, RuntimeError, StoreInner, StoreMut, StoreRef, Value, WithEnv,
+    WithoutEnv,
+};
+
+use std::panic::{self, AssertUnwindSafe};
+use std::{cell::UnsafeCell, cmp::max, ffi::c_void};
+use wasmer_types::{NativeWasmType, RawValue};
+
+macro_rules! impl_host_function {
+    ([$c_struct_representation:ident] $c_struct_name:ident, $( $x:ident ),* ) => {
+        #[allow(unused_parens)]
+        impl< $( $x, )* Rets, RetsAsResult, T, Func> crate::HostFunction<T, ( $( $x ),* ), Rets, WithEnv> for Func where
+            $( $x: FromToNativeWasmType, )*
+            Rets: WasmTypeList,
+            RetsAsResult: IntoResult<Rets>,
+            T: Send + 'static,
+            Func: Fn(FunctionEnvMut<'_, T>, $( $x , )*) -> RetsAsResult + 'static,
+        {
+            #[allow(non_snake_case)]
+            fn function_callback(&self, rt: crate::backend::BackendKind) -> crate::vm::VMFunctionCallback {
+                paste::paste! {
+                    match rt {
+                        #[cfg(feature = "sys")]
+                        crate::backend::BackendKind::Headless => crate::vm::VMFunctionCallback::Sys(crate::backend::sys::function::[<gen_fn_callback_ $c_struct_name:lower >](self)),
+                        #[cfg(feature = "llvm")]
+                        crate::backend::BackendKind::LLVM => crate::vm::VMFunctionCallback::Sys(crate::backend::sys::function::[<gen_fn_callback_ $c_struct_name:lower >](self)),
+                        #[cfg(feature = "cranelift")]
+                        crate::backend::BackendKind::Cranelift => crate::vm::VMFunctionCallback::Sys(crate::backend::sys::function::[<gen_fn_callback_ $c_struct_name:lower >](self)),
+                        #[cfg(feature = "singlepass")]
+                        crate::backend::BackendKind::Singlepass => crate::vm::VMFunctionCallback::Sys(crate::backend::sys::function::[<gen_fn_callback_ $c_struct_name:lower >](self)),
+                        #[cfg(feature = "js")]
+                        crate::backend::BackendKind::Js => crate::vm::VMFunctionCallback::Js(crate::backend::js::function::[<gen_fn_callback_ $c_struct_name:lower >](self)),
+                        #[cfg(feature = "jsc")]
+                        crate::backend::BackendKind::Jsc => crate::vm::VMFunctionCallback::Jsc(crate::backend::jsc::function::[<gen_fn_callback_ $c_struct_name:lower >](self)),
+                        #[cfg(feature = "wamr")]
+                        crate::backend::BackendKind::Wamr => crate::vm::VMFunctionCallback::Wamr(crate::backend::wamr::function::[<gen_fn_callback_ $c_struct_name:lower >](self)),
+                        #[cfg(feature = "wasmi")]
+                        crate::backend::BackendKind::Wasmi => crate::vm::VMFunctionCallback::Wasmi(crate::backend::wasmi::function::[<gen_fn_callback_ $c_struct_name:lower >](self)),
+                        #[cfg(feature = "v8")]
+                        crate::backend::BackendKind::V8 => crate::vm::VMFunctionCallback::V8(crate::backend::v8::function::[<gen_fn_callback_ $c_struct_name:lower >](self))
+                    }
+                }
+            }
+
+            #[cfg(feature = "sys")]
+            fn function_callback_sys(&self) -> crate::vm::VMFunctionCallback {
+                paste::paste! {
+                    crate::vm::VMFunctionCallback::Sys(crate::backend::sys::function::[<gen_fn_callback_ $c_struct_name:lower >](self))
+                }
+            }
+
+            #[allow(non_snake_case)]
+            fn call_trampoline_address() -> crate::vm::VMTrampoline {
+                paste::paste! {
+                    #[cfg(feature = "sys")]
+                    {
+                        crate::vm::VMTrampoline::Sys(crate::backend::sys::function::[<gen_call_trampoline_address_ $c_struct_name:lower >]::<$($x,)* Rets>())
+                    }
+
+                    #[cfg(not(feature = "sys"))]
+                    {
+                        unimplemented!("No backend available")
+                    }
+                }
+            }
+        }
+
+        // Implement `HostFunction` for a function that has the same arity than the tuple.
+        #[allow(unused_parens)]
+        impl< $( $x, )* Rets, RetsAsResult, Func >
+            crate::HostFunction<(), ( $( $x ),* ), Rets, WithoutEnv>
+        for
+            Func
+        where
+            $( $x: FromToNativeWasmType, )*
+            Rets: WasmTypeList,
+            RetsAsResult: IntoResult<Rets>,
+            Func: Fn($( $x , )*) -> RetsAsResult + 'static
+        {
+            #[allow(non_snake_case)]
+            fn function_callback(&self, rt: crate::backend::BackendKind) -> crate::vm::VMFunctionCallback {
+                paste::paste! {
+                    match rt {
+                        #[cfg(feature = "sys")]
+                        crate::backend::BackendKind::Headless => crate::vm::VMFunctionCallback::Sys(crate::backend::sys::function::[<gen_fn_callback_ $c_struct_name:lower _no_env>](self)),
+                        #[cfg(feature = "llvm")]
+                        crate::backend::BackendKind::LLVM => crate::vm::VMFunctionCallback::Sys(crate::backend::sys::function::[<gen_fn_callback_ $c_struct_name:lower _no_env>](self)),
+                        #[cfg(feature = "cranelift")]
+                        crate::backend::BackendKind::Cranelift => crate::vm::VMFunctionCallback::Sys(crate::backend::sys::function::[<gen_fn_callback_ $c_struct_name:lower _no_env>](self)),
+                        #[cfg(feature = "singlepass")]
+                        crate::backend::BackendKind::Singlepass => crate::vm::VMFunctionCallback::Sys(crate::backend::sys::function::[<gen_fn_callback_ $c_struct_name:lower _no_env>](self)),
+                        #[cfg(feature = "js")]
+                        crate::backend::BackendKind::Js => crate::vm::VMFunctionCallback::Js(crate::backend::js::function::[<gen_fn_callback_ $c_struct_name:lower _no_env>](self)),
+                        #[cfg(feature = "jsc")]
+                        crate::backend::BackendKind::Jsc => crate::vm::VMFunctionCallback::Jsc(crate::backend::jsc::function::[<gen_fn_callback_ $c_struct_name:lower _no_env>](self)),
+                        #[cfg(feature = "wamr")]
+                        crate::backend::BackendKind::Wamr => crate::vm::VMFunctionCallback::Wamr(crate::backend::wamr::function::[<gen_fn_callback_ $c_struct_name:lower _no_env>](self)),
+                        #[cfg(feature = "wasmi")]
+                        crate::backend::BackendKind::Wasmi => crate::vm::VMFunctionCallback::Wasmi(crate::backend::wasmi::function::[<gen_fn_callback_ $c_struct_name:lower _no_env>](self)),
+                        #[cfg(feature = "v8")]
+                        crate::backend::BackendKind::V8 => crate::vm::VMFunctionCallback::V8(crate::backend::v8::function::[<gen_fn_callback_ $c_struct_name:lower _no_env>](self))
+                    }
+                }
+            }
+
+            #[allow(non_snake_case)]
+            #[cfg(feature = "sys")]
+            fn function_callback_sys(&self) -> crate::vm::VMFunctionCallback {
+                paste::paste! {
+                    crate::vm::VMFunctionCallback::Sys(crate::backend::sys::function::[<gen_fn_callback_ $c_struct_name:lower _no_env>](self))
+                }
+            }
+
+            #[allow(non_snake_case)]
+            fn call_trampoline_address() -> crate::vm::VMTrampoline {
+                paste::paste! {
+                    #[cfg(feature = "sys")]
+                    {
+                        crate::vm::VMTrampoline::Sys(crate::backend::sys::function::[<gen_call_trampoline_address_ $c_struct_name:lower _no_env>]::<$($x,)* Rets>())
+                    }
+
+                    #[cfg(not(feature = "sys"))]
+                    {
+                        unimplemented!("No backend available")
+                    }
+                }
+            }
+        }
+    };
+}
+
+// Black-magic to count the number of identifiers at compile-time.
+macro_rules! count_idents {
+    ( $($idents:ident),* ) => {
+        {
+            #[allow(dead_code, non_camel_case_types)]
+            enum Idents { $( $idents, )* __CountIdentsLast }
+            const COUNT: usize = Idents::__CountIdentsLast as usize;
+            COUNT
+        }
+    };
+}
+
+// Here we go! Let's generate all the C struct, `WasmTypeList`
+// implementations and `HostFunction` implementations.
+impl_host_function!([C] S0,);
+impl_host_function!([transparent] S1, A1);
+impl_host_function!([C] S2, A1, A2);
+impl_host_function!([C] S3, A1, A2, A3);
+impl_host_function!([C] S4, A1, A2, A3, A4);
+impl_host_function!([C] S5, A1, A2, A3, A4, A5);
+impl_host_function!([C] S6, A1, A2, A3, A4, A5, A6);
+impl_host_function!([C] S7, A1, A2, A3, A4, A5, A6, A7);
+impl_host_function!([C] S8, A1, A2, A3, A4, A5, A6, A7, A8);
+impl_host_function!([C] S9, A1, A2, A3, A4, A5, A6, A7, A8, A9);
+impl_host_function!([C] S10, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+impl_host_function!([C] S11, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
+impl_host_function!([C] S12, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
+impl_host_function!([C] S13, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
+impl_host_function!([C] S14, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
+impl_host_function!([C] S15, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
+impl_host_function!([C] S16, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16);
+impl_host_function!([C] S17, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17);
+impl_host_function!([C] S18, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18);
+impl_host_function!([C] S19, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19);
+impl_host_function!([C] S20, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20);
+impl_host_function!([C] S21, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21);
+impl_host_function!([C] S22, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22);
+impl_host_function!([C] S23, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23);
+impl_host_function!([C] S24, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24);
+impl_host_function!([C] S25, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25);
+impl_host_function!([C] S26, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26);
diff --git a/lib/api/src/entities/function/host/mod.rs b/lib/api/src/entities/function/host/mod.rs
new file mode 100644
index 0000000000..aadc3555ad
--- /dev/null
+++ b/lib/api/src/entities/function/host/mod.rs
@@ -0,0 +1,59 @@
+mod imp;
+
+use crate::{
+    vm::{VMFunctionCallback, VMTrampoline},
+    BackendKind, WasmTypeList,
+};
+
+/// The `HostFunction` trait represents the set of functions that
+/// can be used as host function. To uphold this statement, it is
+/// necessary for a function to be transformed into a
+/// `VMFunctionCallback`.
+pub trait HostFunction<T, Args, Rets, Kind>
+where
+    Args: WasmTypeList,
+    Rets: WasmTypeList,
+    Kind: HostFunctionKind,
+{
+    /// Get the pointer to the function body for a given runtime.
+    fn function_callback(&self, rt: BackendKind) -> crate::vm::VMFunctionCallback;
+
+    /// Get the pointer to the function body for a given runtime.
+    fn function_callback_sys(&self) -> crate::vm::VMFunctionCallback {
+        unimplemented!()
+    }
+
+    /// Get the pointer to the function call trampoline for a given runtime.
+    fn call_trampoline_address() -> crate::vm::VMTrampoline;
+}
+
+/// Empty trait to specify the kind of `HostFunction`: With or
+/// without an environment.
+///
+/// This trait is never aimed to be used by a user. It is used by
+/// the trait system to automatically generate the appropriate
+/// host functions.
+#[doc(hidden)]
+pub trait HostFunctionKind: private::HostFunctionKindSealed {}
+
+/// An empty struct to help Rust typing to determine
+/// when a `HostFunction` does have an environment.
+pub struct WithEnv;
+
+impl HostFunctionKind for WithEnv {}
+
+/// An empty struct to help Rust typing to determine
+/// when a `HostFunction` does not have an environment.
+pub struct WithoutEnv;
+
+impl HostFunctionKind for WithoutEnv {}
+
+mod private {
+    //! Sealing the HostFunctionKind because it shouldn't be implemented
+    //! by any type outside.
+    //! See:
+    //! <https://rust-lang.github.io/api-guidelines/future-proofing.html#c-sealed>
+    pub trait HostFunctionKindSealed {}
+    impl HostFunctionKindSealed for super::WithEnv {}
+    impl HostFunctionKindSealed for super::WithoutEnv {}
+}
diff --git a/lib/api/src/entities/function/inner.rs b/lib/api/src/entities/function/inner.rs
new file mode 100644
index 0000000000..76e4b09253
--- /dev/null
+++ b/lib/api/src/entities/function/inner.rs
@@ -0,0 +1,615 @@
+use wasmer_types::{FunctionType, RawValue};
+
+use crate::{
+    error::RuntimeError,
+    macros::backend::{gen_rt_ty, match_rt},
+    vm::{VMExtern, VMExternFunction, VMFuncRef},
+    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, FunctionEnv, FunctionEnvMut,
+    HostFunction, StoreMut, StoreRef, TypedFunction, Value, WasmTypeList, WithEnv, WithoutEnv,
+};
+
+/// A WebAssembly `function` instance.
+///
+/// A function instance is the runtime representation of a function.
+/// It effectively is a closure of the original function (defined in either
+/// the host or the WebAssembly module) over the runtime `Instance` of its
+/// originating `Module`.
+///
+/// The module instance is used to resolve references to other definitions
+/// during execution of the function.
+///
+/// Spec: <https://webassembly.github.io/spec/core/exec/runtime.html#function-instances>
+///
+/// # Panics
+/// - Closures (functions with captured environments) are not currently supported
+///   with native functions. Attempting to create a native `Function` with one will
+///   result in a panic.
+///   [Closures as host functions tracking issue](https://github.com/wasmerio/wasmer/issues/1840)
+gen_rt_ty!(Function
+    @cfg feature = "artifact-size" => derive(loupe::MemoryUsage)
+    @derives Debug, Clone, PartialEq, Eq
+);
+
+impl BackendFunction {
+    /// Creates a new host `Function` (dynamic) with the provided signature.
+    ///
+    /// If you know the signature of the host function at compile time,
+    /// consider using [`Self::new_typed`] for less runtime overhead.
+    #[inline]
+    pub fn new<FT, F>(store: &mut impl AsStoreMut, ty: FT, func: F) -> Self
+    where
+        FT: Into<FunctionType>,
+        F: Fn(&[Value]) -> Result<Vec<Value>, RuntimeError> + 'static + Send + Sync,
+    {
+        let env = FunctionEnv::new(&mut store.as_store_mut(), ());
+        let wrapped_func = move |_env: FunctionEnvMut<()>,
+                                 args: &[Value]|
+              -> Result<Vec<Value>, RuntimeError> { func(args) };
+        Self::new_with_env(store, &env, ty, wrapped_func)
+    }
+
+    /// Creates a new host `Function` (dynamic) with the provided signature.
+    ///
+    /// If you know the signature of the host function at compile time,
+    /// consider using [`Self::new_typed_with_env`] for less runtime overhead.
+    ///
+    /// Takes a [`FunctionEnv`] that is passed into func. If that is not required,
+    /// [`Self::new`] might be an option as well.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmer::{Function, FunctionEnv, FunctionType, Type, Store, Value};
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// #
+    /// let signature = FunctionType::new(vec![Type::I32, Type::I32], vec![Type::I32]);
+    ///
+    /// let f = Function::new_with_env(&mut store, &env, &signature, |_env, args| {
+    ///     let sum = args[0].unwrap_i32() + args[1].unwrap_i32();
+    ///     Ok(vec![Value::I32(sum)])
+    /// });
+    /// ```
+    ///
+    /// With constant signature:
+    ///
+    /// ```
+    /// # use wasmer::{Function, FunctionEnv, FunctionType, Type, Store, Value};
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// #
+    /// const I32_I32_TO_I32: ([Type; 2], [Type; 1]) = ([Type::I32, Type::I32], [Type::I32]);
+    ///
+    /// let f = Function::new_with_env(&mut store, &env, I32_I32_TO_I32, |_env, args| {
+    ///     let sum = args[0].unwrap_i32() + args[1].unwrap_i32();
+    ///     Ok(vec![Value::I32(sum)])
+    /// });
+    /// ```
+    #[inline]
+    pub fn new_with_env<FT, F, T: Send + 'static>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        ty: FT,
+        func: F,
+    ) -> Self
+    where
+        FT: Into<FunctionType>,
+        F: Fn(FunctionEnvMut<T>, &[Value]) -> Result<Vec<Value>, RuntimeError>
+            + 'static
+            + Send
+            + Sync,
+    {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(_) => Self::Sys(
+                crate::backend::sys::entities::function::Function::new_with_env(
+                    store, env, ty, func,
+                ),
+            ),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => Self::Wamr(
+                crate::backend::wamr::entities::function::Function::new_with_env(
+                    store, env, ty, func,
+                ),
+            ),
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => Self::Wasmi(
+                crate::backend::wasmi::entities::function::Function::new_with_env(
+                    store, env, ty, func,
+                ),
+            ),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => Self::V8(
+                crate::backend::v8::entities::function::Function::new_with_env(
+                    store, env, ty, func,
+                ),
+            ),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => Self::Js(
+                crate::backend::js::entities::function::Function::new_with_env(
+                    store, env, ty, func,
+                ),
+            ),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => Self::Jsc(
+                crate::backend::jsc::entities::function::Function::new_with_env(
+                    store, env, ty, func,
+                ),
+            ),
+        }
+    }
+
+    /// Creates a new host `Function` from a native function.
+    #[inline]
+    pub fn new_typed<F, Args, Rets>(store: &mut impl AsStoreMut, func: F) -> Self
+    where
+        F: HostFunction<(), Args, Rets, WithoutEnv> + 'static + Send + Sync,
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+    {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(_) => {
+                Self::Sys(crate::backend::sys::entities::function::Function::new_typed(store, func))
+            }
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => Self::Wamr(
+                crate::backend::wamr::entities::function::Function::new_typed(store, func),
+            ),
+
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => Self::Wasmi(
+                crate::backend::wasmi::entities::function::Function::new_typed(store, func),
+            ),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => Self::V8(
+                crate::backend::v8::entities::function::Function::new_typed(store, func),
+            ),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => Self::Js(
+                crate::backend::js::entities::function::Function::new_typed(store, func),
+            ),
+
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => {
+                Self::Jsc(crate::backend::jsc::entities::function::Function::new_typed(store, func))
+            }
+        }
+    }
+
+    /// Creates a new host `Function` with an environment from a typed function.
+    ///
+    /// The function signature is automatically retrieved using the
+    /// Rust typing system.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Store, Function, FunctionEnv, FunctionEnvMut};
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// #
+    /// fn sum(_env: FunctionEnvMut<()>, a: i32, b: i32) -> i32 {
+    ///     a + b
+    /// }
+    ///
+    /// let f = Function::new_typed_with_env(&mut store, &env, sum);
+    /// ```
+    #[inline]
+    pub fn new_typed_with_env<T: Send + 'static, F, Args, Rets>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        func: F,
+    ) -> Self
+    where
+        F: HostFunction<T, Args, Rets, WithEnv> + 'static + Send + Sync,
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+    {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(s) => Self::Sys(
+                crate::backend::sys::entities::function::Function::new_typed_with_env(
+                    store, env, func,
+                ),
+            ),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(s) => Self::Wamr(
+                crate::backend::wamr::entities::function::Function::new_typed_with_env(
+                    store, env, func,
+                ),
+            ),
+
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(s) => Self::Wasmi(
+                crate::backend::wasmi::entities::function::Function::new_typed_with_env(
+                    store, env, func,
+                ),
+            ),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(s) => Self::V8(
+                crate::backend::v8::entities::function::Function::new_typed_with_env(
+                    store, env, func,
+                ),
+            ),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(s) => Self::Js(
+                crate::backend::js::entities::function::Function::new_typed_with_env(
+                    store, env, func,
+                ),
+            ),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(s) => Self::Jsc(
+                crate::backend::jsc::entities::function::Function::new_typed_with_env(
+                    store, env, func,
+                ),
+            ),
+        }
+    }
+
+    /// Returns the [`FunctionType`] of the `Function`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Function, FunctionEnv, FunctionEnvMut, Store, Type};
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// #
+    /// fn sum(_env: FunctionEnvMut<()>, a: i32, b: i32) -> i32 {
+    ///     a + b
+    /// }
+    ///
+    /// let f = Function::new_typed_with_env(&mut store, &env, sum);
+    ///
+    /// assert_eq!(f.ty(&mut store).params(), vec![Type::I32, Type::I32]);
+    /// assert_eq!(f.ty(&mut store).results(), vec![Type::I32]);
+    /// ```
+    #[inline]
+    pub fn ty(&self, store: &impl AsStoreRef) -> FunctionType {
+        match_rt!(on self => f {
+            f.ty(store)
+        })
+    }
+
+    /// Returns the number of parameters that this function takes.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Function, FunctionEnv, FunctionEnvMut, Store, Type};
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// #
+    /// fn sum(_env: FunctionEnvMut<()>, a: i32, b: i32) -> i32 {
+    ///     a + b
+    /// }
+    ///
+    /// let f = Function::new_typed_with_env(&mut store, &env, sum);
+    ///
+    /// assert_eq!(f.param_arity(&mut store), 2);
+    /// ```
+    #[inline]
+    pub fn param_arity(&self, store: &impl AsStoreRef) -> usize {
+        self.ty(store).params().len()
+    }
+
+    /// Returns the number of results this function produces.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Function, FunctionEnv, FunctionEnvMut, Store, Type};
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// #
+    /// fn sum(_env: FunctionEnvMut<()>, a: i32, b: i32) -> i32 {
+    ///     a + b
+    /// }
+    ///
+    /// let f = Function::new_typed_with_env(&mut store, &env, sum);
+    ///
+    /// assert_eq!(f.result_arity(&mut store), 1);
+    /// ```
+    #[inline]
+    pub fn result_arity(&self, store: &impl AsStoreRef) -> usize {
+        self.ty(store).params().len()
+    }
+
+    /// Call the `Function` function.
+    ///
+    /// Depending on where the Function is defined, it will call it.
+    /// 1. If the function is defined inside a WebAssembly, it will call the trampoline
+    ///    for the function signature.
+    /// 2. If the function is defined in the host (in a native way), it will
+    ///    call the trampoline.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmer::{imports, wat2wasm, Function, Instance, Module, Store, Type, Value};
+    /// # use wasmer::FunctionEnv;
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// # let wasm_bytes = wat2wasm(r#"
+    /// # (module
+    /// #   (func (export "sum") (param $x i32) (param $y i32) (result i32)
+    /// #     local.get $x
+    /// #     local.get $y
+    /// #     i32.add
+    /// #   ))
+    /// # "#.as_bytes()).unwrap();
+    /// # let module = Module::new(&store, wasm_bytes).unwrap();
+    /// # let import_object = imports! {};
+    /// # let instance = Instance::new(&mut store, &module, &import_object).unwrap();
+    /// #
+    /// let sum = instance.exports.get_function("sum").unwrap();
+    ///
+    /// assert_eq!(sum.call(&mut store, &[Value::I32(1), Value::I32(2)]).unwrap().to_vec(), vec![Value::I32(3)]);
+    /// ```
+    #[inline]
+    pub fn call(
+        &self,
+        store: &mut impl AsStoreMut,
+        params: &[Value],
+    ) -> Result<Box<[Value]>, RuntimeError> {
+        match_rt!(on self => f {
+            f.call(store, params)
+        })
+    }
+
+    #[doc(hidden)]
+    #[allow(missing_docs)]
+    #[inline]
+    pub fn call_raw(
+        &self,
+        store: &mut impl AsStoreMut,
+        params: Vec<RawValue>,
+    ) -> Result<Box<[Value]>, RuntimeError> {
+        match_rt!(on self => f {
+            f.call_raw(store, params)
+        })
+    }
+
+    #[inline]
+    pub(crate) fn vm_funcref(&self, store: &impl AsStoreRef) -> VMFuncRef {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(f) => VMFuncRef::Sys(f.vm_funcref(store)),
+            #[cfg(feature = "wamr")]
+            Self::Wamr(f) => VMFuncRef::Wamr(f.vm_funcref(store)),
+            #[cfg(feature = "wasmi")]
+            Self::Wasmi(f) => VMFuncRef::Wasmi(f.vm_funcref(store)),
+            #[cfg(feature = "v8")]
+            Self::V8(f) => VMFuncRef::V8(f.vm_funcref(store)),
+            #[cfg(feature = "js")]
+            Self::Js(f) => VMFuncRef::Js(f.vm_funcref(store)),
+            #[cfg(feature = "jsc")]
+            Self::Jsc(f) => VMFuncRef::Jsc(f.vm_funcref(store)),
+        }
+    }
+
+    #[inline]
+    pub(crate) unsafe fn from_vm_funcref(store: &mut impl AsStoreMut, funcref: VMFuncRef) -> Self {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(s) => Self::Sys(
+                crate::backend::sys::entities::function::Function::from_vm_funcref(
+                    store,
+                    funcref.into_sys(),
+                ),
+            ),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(s) => Self::Wamr(
+                crate::backend::wamr::entities::function::Function::from_vm_funcref(
+                    store,
+                    funcref.into_wamr(),
+                ),
+            ),
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(s) => Self::Wasmi(
+                crate::backend::wasmi::entities::function::Function::from_vm_funcref(
+                    store,
+                    funcref.into_wasmi(),
+                ),
+            ),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(s) => Self::V8(
+                crate::backend::v8::entities::function::Function::from_vm_funcref(
+                    store,
+                    funcref.into_v8(),
+                ),
+            ),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(s) => Self::Js(
+                crate::backend::js::entities::function::Function::from_vm_funcref(
+                    store,
+                    funcref.into_js(),
+                ),
+            ),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(s) => Self::Jsc(
+                crate::backend::jsc::entities::function::Function::from_vm_funcref(
+                    store,
+                    funcref.into_jsc(),
+                ),
+            ),
+        }
+    }
+
+    /// Transform this WebAssembly function into a typed function.
+    /// See [`TypedFunction`] to learn more.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmer::{imports, wat2wasm, Function, Instance, Module, Store, Type, TypedFunction, Value};
+    /// # use wasmer::FunctionEnv;
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// # let wasm_bytes = wat2wasm(r#"
+    /// # (module
+    /// #   (func (export "sum") (param $x i32) (param $y i32) (result i32)
+    /// #     local.get $x
+    /// #     local.get $y
+    /// #     i32.add
+    /// #   ))
+    /// # "#.as_bytes()).unwrap();
+    /// # let module = Module::new(&store, wasm_bytes).unwrap();
+    /// # let import_object = imports! {};
+    /// # let instance = Instance::new(&mut store, &module, &import_object).unwrap();
+    /// #
+    /// let sum = instance.exports.get_function("sum").unwrap();
+    /// let sum_typed: TypedFunction<(i32, i32), i32> = sum.typed(&mut store).unwrap();
+    ///
+    /// assert_eq!(sum_typed.call(&mut store, 1, 2).unwrap(), 3);
+    /// ```
+    ///
+    /// # Errors
+    ///
+    /// If the `Args` generic parameter does not match the exported function
+    /// an error will be raised:
+    ///
+    /// ```should_panic
+    /// # use wasmer::{imports, wat2wasm, Function, Instance, Module, Store, Type, TypedFunction, Value};
+    /// # use wasmer::FunctionEnv;
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// # let wasm_bytes = wat2wasm(r#"
+    /// # (module
+    /// #   (func (export "sum") (param $x i32) (param $y i32) (result i32)
+    /// #     local.get $x
+    /// #     local.get $y
+    /// #     i32.add
+    /// #   ))
+    /// # "#.as_bytes()).unwrap();
+    /// # let module = Module::new(&store, wasm_bytes).unwrap();
+    /// # let import_object = imports! {};
+    /// # let instance = Instance::new(&mut store, &module, &import_object).unwrap();
+    /// #
+    /// let sum = instance.exports.get_function("sum").unwrap();
+    ///
+    /// // This results in an error: `RuntimeError`
+    /// let sum_typed : TypedFunction<(i64, i64), i32> = sum.typed(&mut store).unwrap();
+    /// ```
+    ///
+    /// If the `Rets` generic parameter does not match the exported function
+    /// an error will be raised:
+    ///
+    /// ```should_panic
+    /// # use wasmer::{imports, wat2wasm, Function, Instance, Module, Store, Type, TypedFunction, Value};
+    /// # use wasmer::FunctionEnv;
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// # let wasm_bytes = wat2wasm(r#"
+    /// # (module
+    /// #   (func (export "sum") (param $x i32) (param $y i32) (result i32)
+    /// #     local.get $x
+    /// #     local.get $y
+    /// #     i32.add
+    /// #   ))
+    /// # "#.as_bytes()).unwrap();
+    /// # let module = Module::new(&store, wasm_bytes).unwrap();
+    /// # let import_object = imports! {};
+    /// # let instance = Instance::new(&mut store, &module, &import_object).unwrap();
+    /// #
+    /// let sum = instance.exports.get_function("sum").unwrap();
+    ///
+    /// // This results in an error: `RuntimeError`
+    /// let sum_typed: TypedFunction<(i32, i32), i64> = sum.typed(&mut store).unwrap();
+    /// ```
+    #[inline]
+    pub fn typed<Args, Rets>(
+        &self,
+        store: &impl AsStoreRef,
+    ) -> Result<TypedFunction<Args, Rets>, RuntimeError>
+    where
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+    {
+        let ty = self.ty(store);
+
+        // type check
+        {
+            let expected = ty.params();
+            let given = Args::wasm_types();
+
+            if expected != given {
+                return Err(RuntimeError::new(format!(
+                    "given types (`{given:?}`) for the function arguments don't match the actual types (`{expected:?}`)",
+                )));
+            }
+        }
+
+        {
+            let expected = ty.results();
+            let given = Rets::wasm_types();
+
+            if expected != given {
+                // todo: error result types don't match
+                return Err(RuntimeError::new(format!(
+                    "given types (`{given:?}`) for the function results don't match the actual types (`{expected:?}`)",
+                )));
+            }
+        }
+
+        Ok(TypedFunction::new(store, super::Function(self.clone())))
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternFunction) -> Self {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(_) => Self::Sys(
+                crate::backend::sys::entities::function::Function::from_vm_extern(store, vm_extern),
+            ),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => Self::Wamr(
+                crate::backend::wamr::entities::function::Function::from_vm_extern(
+                    store, vm_extern,
+                ),
+            ),
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => Self::Wasmi(
+                crate::backend::wasmi::entities::function::Function::from_vm_extern(
+                    store, vm_extern,
+                ),
+            ),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => Self::V8(
+                crate::backend::v8::entities::function::Function::from_vm_extern(store, vm_extern),
+            ),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => Self::Js(
+                crate::backend::js::entities::function::Function::from_vm_extern(store, vm_extern),
+            ),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => Self::Jsc(
+                crate::backend::jsc::entities::function::Function::from_vm_extern(store, vm_extern),
+            ),
+        }
+    }
+
+    /// Checks whether this `Function` can be used with the given store.
+    #[inline]
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        match_rt!(on self => f {
+            f.is_from_store(store)
+        })
+    }
+
+    #[inline]
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        match_rt!(on self => f {
+            f.to_vm_extern()
+        })
+    }
+}
+
+impl<'a> Exportable<'a> for BackendFunction {
+    fn get_self_from_extern(_extern: &'a Extern) -> Result<&'a Self, ExportError> {
+        match _extern {
+            Extern::Function(func) => Ok(&func.0),
+            _ => Err(ExportError::IncompatibleType),
+        }
+    }
+}
diff --git a/lib/api/src/externals/function.rs b/lib/api/src/entities/function/mod.rs
similarity index 74%
rename from lib/api/src/externals/function.rs
rename to lib/api/src/entities/function/mod.rs
index 70d18c3ca4..1ff92ca609 100644
--- a/lib/api/src/externals/function.rs
+++ b/lib/api/src/entities/function/mod.rs
@@ -1,77 +1,30 @@
-#[cfg(feature = "js")]
-use crate::js::externals::function as function_impl;
-#[cfg(feature = "jsc")]
-use crate::jsc::externals::function as function_impl;
-#[cfg(feature = "sys")]
-use crate::sys::externals::function as function_impl;
+//! Defines the [`Function`] and [`HostFunction`] types and useful traits and data types to
+//! interact with them.
 
-use crate::exports::{ExportError, Exportable};
-use crate::store::{AsStoreMut, AsStoreRef};
-use crate::vm::{VMExtern, VMExternFunction, VMFuncRef, VMFunctionCallback, VMTrampoline};
-use crate::{
-    Extern, FunctionEnv, FunctionEnvMut, FunctionType, RuntimeError, TypedFunction, Value,
-};
-use wasmer_types::RawValue;
-
-use crate::native_type::WasmTypeList;
+pub(crate) mod inner;
+pub use inner::*;
 
-/// The `HostFunction` trait represents the set of functions that
-/// can be used as host function. To uphold this statement, it is
-/// necessary for a function to be transformed into a
-/// `VMFunctionCallback`.
-pub trait HostFunction<T, Args, Rets, Kind>
-where
-    Args: WasmTypeList,
-    Rets: WasmTypeList,
-    Kind: HostFunctionKind,
-{
-    /// Get the pointer to the function body.
-    fn function_callback(&self) -> VMFunctionCallback;
+pub(crate) mod host;
+pub use host::*;
 
-    /// Get the pointer to the function call trampoline.
-    fn call_trampoline_address() -> VMTrampoline {
-        // This is not implemented in JS
-        unimplemented!();
-    }
-}
+pub(crate) mod env;
+pub use env::*;
 
-/// Empty trait to specify the kind of `HostFunction`: With or
-/// without an environment.
-///
-/// This trait is never aimed to be used by a user. It is used by
-/// the trait system to automatically generate the appropriate
-/// host functions.
-#[doc(hidden)]
-pub trait HostFunctionKind: private::HostFunctionKindSealed {}
+use wasmer_types::{FunctionType, RawValue};
 
-/// An empty struct to help Rust typing to determine
-/// when a `HostFunction` does have an environment.
-pub struct WithEnv;
-
-impl HostFunctionKind for WithEnv {}
-
-/// An empty struct to help Rust typing to determine
-/// when a `HostFunction` does not have an environment.
-pub struct WithoutEnv;
-
-impl HostFunctionKind for WithoutEnv {}
-
-mod private {
-    //! Sealing the HostFunctionKind because it shouldn't be implemented
-    //! by any type outside.
-    //! See:
-    //! <https://rust-lang.github.io/api-guidelines/future-proofing.html#c-sealed>
-    pub trait HostFunctionKindSealed {}
-    impl HostFunctionKindSealed for super::WithEnv {}
-    impl HostFunctionKindSealed for super::WithoutEnv {}
-}
+use crate::{
+    error::RuntimeError,
+    vm::{VMExtern, VMExternFunction, VMFuncRef},
+    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, StoreMut, StoreRef, TypedFunction,
+    Value, WasmTypeList,
+};
 
 /// A WebAssembly `function` instance.
 ///
 /// A function instance is the runtime representation of a function.
 /// It effectively is a closure of the original function (defined in either
-/// the host or the WebAssembly module) over the runtime `Instance` of its
-/// originating `Module`.
+/// the host or the WebAssembly module) over the runtime [`crate::Instance`] of its
+/// originating [`crate::Module`].
 ///
 /// The module instance is used to resolve references to other definitions
 /// during execution of the function.
@@ -83,8 +36,9 @@ mod private {
 ///   with native functions. Attempting to create a native `Function` with one will
 ///   result in a panic.
 ///   [Closures as host functions tracking issue](https://github.com/wasmerio/wasmer/issues/1840)
-#[derive(Debug, Clone, PartialEq)]
-pub struct Function(pub(crate) function_impl::Function);
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+pub struct Function(pub(crate) BackendFunction);
 
 impl Function {
     /// Creates a new host `Function` (dynamic) with the provided signature.
@@ -96,11 +50,7 @@ impl Function {
         FT: Into<FunctionType>,
         F: Fn(&[Value]) -> Result<Vec<Value>, RuntimeError> + 'static + Send + Sync,
     {
-        let env = FunctionEnv::new(&mut store.as_store_mut(), ());
-        let wrapped_func = move |_env: FunctionEnvMut<()>,
-                                 args: &[Value]|
-              -> Result<Vec<Value>, RuntimeError> { func(args) };
-        Self::new_with_env(store, &env, ty, wrapped_func)
+        Self(BackendFunction::new(store, ty, func))
     }
 
     /// Creates a new host `Function` (dynamic) with the provided signature.
@@ -153,7 +103,7 @@ impl Function {
             + Send
             + Sync,
     {
-        Self(function_impl::Function::new_with_env(store, env, ty, func))
+        Self(BackendFunction::new_with_env(store, env, ty, func))
     }
 
     /// Creates a new host `Function` from a native function.
@@ -163,7 +113,7 @@ impl Function {
         Args: WasmTypeList,
         Rets: WasmTypeList,
     {
-        Self(function_impl::Function::new_typed(store, func))
+        Self(BackendFunction::new_typed(store, func))
     }
 
     /// Creates a new host `Function` with an environment from a typed function.
@@ -194,9 +144,7 @@ impl Function {
         Args: WasmTypeList,
         Rets: WasmTypeList,
     {
-        Self(function_impl::Function::new_typed_with_env(
-            store, env, func,
-        ))
+        Self(BackendFunction::new_typed_with_env(store, env, func))
     }
 
     /// Returns the [`FunctionType`] of the `Function`.
@@ -263,7 +211,7 @@ impl Function {
         self.ty(store).results().len()
     }
 
-    /// Call the `Function` function.
+    /// Call the function.
     ///
     /// Depending on where the Function is defined, it will call it.
     /// 1. If the function is defined inside a WebAssembly, it will call the trampoline
@@ -317,7 +265,7 @@ impl Function {
     }
 
     pub(crate) unsafe fn from_vm_funcref(store: &mut impl AsStoreMut, funcref: VMFuncRef) -> Self {
-        Self(function_impl::Function::from_vm_funcref(store, funcref))
+        Self(BackendFunction::from_vm_funcref(store, funcref))
     }
 
     /// Transform this WebAssembly function into a typed function.
@@ -409,41 +357,11 @@ impl Function {
         Args: WasmTypeList,
         Rets: WasmTypeList,
     {
-        let ty = self.ty(store);
-
-        // type check
-        {
-            let expected = ty.params();
-            let given = Args::wasm_types();
-
-            if expected != given {
-                return Err(RuntimeError::new(format!(
-                    "given types (`{:?}`) for the function arguments don't match the actual types (`{:?}`)",
-                    given,
-                    expected,
-                )));
-            }
-        }
-
-        {
-            let expected = ty.results();
-            let given = Rets::wasm_types();
-
-            if expected != given {
-                // todo: error result types don't match
-                return Err(RuntimeError::new(format!(
-                    "given types (`{:?}`) for the function results don't match the actual types (`{:?}`)",
-                    given,
-                    expected,
-                )));
-            }
-        }
-
-        Ok(TypedFunction::new(store, self.clone()))
+        self.0.typed(store)
     }
 
     pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternFunction) -> Self {
-        Self(function_impl::Function::from_vm_extern(store, vm_extern))
+        Self(BackendFunction::from_vm_extern(store, vm_extern))
     }
 
     /// Checks whether this `Function` can be used with the given store.
@@ -456,8 +374,6 @@ impl Function {
     }
 }
 
-impl std::cmp::Eq for Function {}
-
 impl<'a> Exportable<'a> for Function {
     fn get_self_from_extern(_extern: &'a Extern) -> Result<&'a Self, ExportError> {
         match _extern {
diff --git a/lib/api/src/entities/global/inner.rs b/lib/api/src/entities/global/inner.rs
new file mode 100644
index 0000000000..887864b205
--- /dev/null
+++ b/lib/api/src/entities/global/inner.rs
@@ -0,0 +1,228 @@
+use crate::{
+    error::RuntimeError,
+    macros::backend::{gen_rt_ty, match_rt},
+    store::{AsStoreMut, AsStoreRef, StoreMut, StoreRef},
+    value::Value,
+    vm::{VMExtern, VMExternGlobal},
+    ExportError, Exportable, Extern,
+};
+use wasmer_types::{GlobalType, Mutability};
+
+/// A WebAssembly `global` instance.
+///
+/// A global instance is the runtime representation of a global variable.
+/// It consists of an individual value and a flag indicating whether it is mutable.
+///
+/// Spec: <https://webassembly.github.io/spec/core/exec/runtime.html#global-instances>
+gen_rt_ty!(Global
+    @cfg feature = "artifact-size" => derive(loupe::MemoryUsage)
+    @derives Debug, Clone, PartialEq, Eq, derive_more::From
+);
+
+impl BackendGlobal {
+    /// Create a new global with the initial [`Value`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Global, Mutability, Store, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let g = Global::new(&mut store, Value::I32(1));
+    ///
+    /// assert_eq!(g.get(&mut store), Value::I32(1));
+    /// assert_eq!(g.ty(&mut store).mutability, Mutability::Const);
+    /// ```
+    #[inline]
+    pub fn new(store: &mut impl AsStoreMut, val: Value) -> Self {
+        Self::from_value(store, val, Mutability::Const).unwrap()
+    }
+
+    /// Create a mutable global with the initial [`Value`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Global, Mutability, Store, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let g = Global::new_mut(&mut store, Value::I32(1));
+    ///
+    /// assert_eq!(g.get(&mut store), Value::I32(1));
+    /// assert_eq!(g.ty(&mut store).mutability, Mutability::Var);
+    /// ```
+    #[inline]
+    pub fn new_mut(store: &mut impl AsStoreMut, val: Value) -> Self {
+        Self::from_value(store, val, Mutability::Var).unwrap()
+    }
+
+    /// Create a global with the initial [`Value`] and the provided [`Mutability`].
+    #[inline]
+    pub(crate) fn from_value(
+        store: &mut impl AsStoreMut,
+        val: Value,
+        mutability: Mutability,
+    ) -> Result<Self, RuntimeError> {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(_) => Ok(Self::Sys(
+                crate::backend::sys::global::Global::from_value(store, val, mutability)?,
+            )),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => Ok(Self::Wamr(
+                crate::backend::wamr::global::Global::from_value(store, val, mutability)?,
+            )),
+
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => Ok(Self::Wasmi(
+                crate::backend::wasmi::global::Global::from_value(store, val, mutability)?,
+            )),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => Ok(Self::V8(
+                crate::backend::v8::global::Global::from_value(store, val, mutability)?,
+            )),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => Ok(Self::Js(
+                crate::backend::js::global::Global::from_value(store, val, mutability)?,
+            )),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => Ok(Self::Jsc(
+                crate::backend::jsc::global::Global::from_value(store, val, mutability)?,
+            )),
+        }
+    }
+
+    /// Returns the [`GlobalType`] of the global.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Global, Mutability, Store, Type, Value, GlobalType};
+    /// # let mut store = Store::default();
+    /// #
+    /// let c = Global::new(&mut store, Value::I32(1));
+    /// let v = Global::new_mut(&mut store, Value::I64(1));
+    ///
+    /// assert_eq!(c.ty(&mut store), GlobalType::new(Type::I32, Mutability::Const));
+    /// assert_eq!(v.ty(&mut store), GlobalType::new(Type::I64, Mutability::Var));
+    /// ```
+    #[inline]
+    pub fn ty(&self, store: &impl AsStoreRef) -> GlobalType {
+        match_rt!(on self => g {
+            g.ty(store)
+        })
+    }
+
+    /// Retrieves the current value [`Value`] that the global has.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Global, Store, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let g = Global::new(&mut store, Value::I32(1));
+    ///
+    /// assert_eq!(g.get(&mut store), Value::I32(1));
+    /// ```
+    #[inline]
+    pub fn get(&self, store: &mut impl AsStoreMut) -> Value {
+        match_rt!(on self => g {
+            g.get(store)
+        })
+    }
+
+    /// Sets a custom [`Value`] to the runtime global.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Global, Store, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let g = Global::new_mut(&mut store, Value::I32(1));
+    ///
+    /// assert_eq!(g.get(&mut store), Value::I32(1));
+    ///
+    /// g.set(&mut store, Value::I32(2));
+    ///
+    /// assert_eq!(g.get(&mut store), Value::I32(2));
+    /// ```
+    ///
+    /// # Errors
+    ///
+    /// Trying to mutate a immutable global will raise an error:
+    ///
+    /// ```should_panic
+    /// # use wasmer::{Global, Store, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let g = Global::new(&mut store, Value::I32(1));
+    ///
+    /// g.set(&mut store, Value::I32(2)).unwrap();
+    /// ```
+    ///
+    /// Trying to set a value of a incompatible type will raise an error:
+    ///
+    /// ```should_panic
+    /// # use wasmer::{Global, Store, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let g = Global::new(&mut store, Value::I32(1));
+    ///
+    /// // This results in an error: `RuntimeError`.
+    /// g.set(&mut store, Value::I64(2)).unwrap();
+    /// ```
+    #[inline]
+    pub fn set(&self, store: &mut impl AsStoreMut, val: Value) -> Result<(), RuntimeError> {
+        match_rt!(on self => s {
+            s.set(store, val)
+        })
+    }
+
+    #[inline]
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternGlobal) -> Self {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(_) => Self::Sys(
+                crate::backend::sys::global::Global::from_vm_extern(store, vm_extern),
+            ),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => Self::Wamr(
+                crate::backend::wamr::global::Global::from_vm_extern(store, vm_extern),
+            ),
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => Self::Wasmi(
+                crate::backend::wasmi::global::Global::from_vm_extern(store, vm_extern),
+            ),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => Self::V8(
+                crate::backend::v8::global::Global::from_vm_extern(store, vm_extern),
+            ),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => Self::Js(
+                crate::backend::js::global::Global::from_vm_extern(store, vm_extern),
+            ),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => Self::Jsc(
+                crate::backend::jsc::global::Global::from_vm_extern(store, vm_extern),
+            ),
+        }
+    }
+
+    /// Checks whether this global can be used with the given context.
+    #[inline]
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        match_rt!(on self => s {
+            s.is_from_store(store)
+        })
+    }
+
+    /// Create a [`VMExtern`] from self.
+    #[inline]
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        match_rt!(on self => s {
+            s.to_vm_extern()
+        })
+    }
+}
diff --git a/lib/api/src/externals/global.rs b/lib/api/src/entities/global/mod.rs
similarity index 75%
rename from lib/api/src/externals/global.rs
rename to lib/api/src/entities/global/mod.rs
index 3420562ff4..0cf479b7cc 100644
--- a/lib/api/src/externals/global.rs
+++ b/lib/api/src/entities/global/mod.rs
@@ -1,19 +1,14 @@
-use crate::exports::{ExportError, Exportable};
-use crate::store::{AsStoreMut, AsStoreRef};
-use crate::value::Value;
-use crate::vm::VMExtern;
-use crate::vm::VMExternGlobal;
-use crate::Extern;
-use crate::GlobalType;
-use crate::Mutability;
-use crate::RuntimeError;
+use crate::{
+    error::RuntimeError,
+    store::{AsStoreMut, AsStoreRef, StoreMut, StoreRef},
+    value::Value,
+    vm::{VMExtern, VMExternGlobal},
+    ExportError, Exportable, Extern,
+};
+use wasmer_types::{GlobalType, Mutability};
 
-#[cfg(feature = "js")]
-use crate::js::externals::global as global_impl;
-#[cfg(feature = "jsc")]
-use crate::jsc::externals::global as global_impl;
-#[cfg(feature = "sys")]
-use crate::sys::externals::global as global_impl;
+pub(crate) mod inner;
+pub(crate) use inner::*;
 
 /// A WebAssembly `global` instance.
 ///
@@ -21,11 +16,12 @@ use crate::sys::externals::global as global_impl;
 /// It consists of an individual value and a flag indicating whether it is mutable.
 ///
 /// Spec: <https://webassembly.github.io/spec/core/exec/runtime.html#global-instances>
-#[derive(Debug, Clone, PartialEq)]
-pub struct Global(pub(crate) global_impl::Global);
+#[derive(Debug, Clone, PartialEq, Eq, derive_more::From)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+pub struct Global(pub(crate) BackendGlobal);
 
 impl Global {
-    /// Create a new `Global` with the initial value [`Value`].
+    /// Create a new global with the initial [`Value`].
     ///
     /// # Example
     ///
@@ -39,10 +35,10 @@ impl Global {
     /// assert_eq!(g.ty(&mut store).mutability, Mutability::Const);
     /// ```
     pub fn new(store: &mut impl AsStoreMut, val: Value) -> Self {
-        Self::from_value(store, val, Mutability::Const).unwrap()
+        Self(BackendGlobal::new(store, val))
     }
 
-    /// Create a mutable `Global` with the initial value [`Value`].
+    /// Create a mutable global with the initial [`Value`].
     ///
     /// # Example
     ///
@@ -56,21 +52,19 @@ impl Global {
     /// assert_eq!(g.ty(&mut store).mutability, Mutability::Var);
     /// ```
     pub fn new_mut(store: &mut impl AsStoreMut, val: Value) -> Self {
-        Self::from_value(store, val, Mutability::Var).unwrap()
+        Self(BackendGlobal::new_mut(store, val))
     }
 
-    /// Create a `Global` with the initial value [`Value`] and the provided [`Mutability`].
+    /// Create a global with the initial [`Value`] and the provided [`Mutability`].
     fn from_value(
         store: &mut impl AsStoreMut,
         val: Value,
         mutability: Mutability,
     ) -> Result<Self, RuntimeError> {
-        Ok(Self(global_impl::Global::from_value(
-            store, val, mutability,
-        )?))
+        BackendGlobal::from_value(store, val, mutability).map(Self)
     }
 
-    /// Returns the [`GlobalType`] of the `Global`.
+    /// Returns the [`GlobalType`] of the global.
     ///
     /// # Example
     ///
@@ -88,7 +82,7 @@ impl Global {
         self.0.ty(store)
     }
 
-    /// Retrieves the current value [`Value`] that the Global has.
+    /// Retrieves the current value [`Value`] that the global has.
     ///
     /// # Example
     ///
@@ -104,7 +98,7 @@ impl Global {
         self.0.get(store)
     }
 
-    /// Sets a custom value [`Value`] to the runtime Global.
+    /// Sets a custom [`Value`] to the runtime global.
     ///
     /// # Example
     ///
@@ -150,21 +144,20 @@ impl Global {
     }
 
     pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternGlobal) -> Self {
-        Self(global_impl::Global::from_vm_extern(store, vm_extern))
+        Self(BackendGlobal::from_vm_extern(store, vm_extern))
     }
 
-    /// Checks whether this `Global` can be used with the given context.
+    /// Checks whether this global can be used with the given context.
     pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
         self.0.is_from_store(store)
     }
 
+    /// Create a [`VMExtern`] from self.
     pub(crate) fn to_vm_extern(&self) -> VMExtern {
         self.0.to_vm_extern()
     }
 }
 
-impl std::cmp::Eq for Global {}
-
 impl<'a> Exportable<'a> for Global {
     fn get_self_from_extern(_extern: &'a Extern) -> Result<&'a Self, ExportError> {
         match _extern {
diff --git a/lib/api/src/imports.rs b/lib/api/src/entities/imports.rs
similarity index 98%
rename from lib/api/src/imports.rs
rename to lib/api/src/entities/imports.rs
index 344bc24e28..d0bd6b19c5 100644
--- a/lib/api/src/imports.rs
+++ b/lib/api/src/entities/imports.rs
@@ -1,7 +1,7 @@
 //! The import module contains the implementation data structures and helper functions used to
 //! manipulate and access a wasm module's imports including memories, tables, globals, and
 //! functions.
-use crate::{Exports, Extern, LinkError, Module};
+use crate::{error::LinkError, Exports, Extern, Module};
 use std::collections::HashMap;
 use std::fmt;
 use wasmer_types::ImportError;
@@ -166,12 +166,13 @@ impl Imports {
     }
 }
 
+/// An iterator over module imports.
 pub struct ImportsIterator<'a> {
     iter: std::collections::hash_map::Iter<'a, (String, String), Extern>,
 }
 
 impl<'a> ImportsIterator<'a> {
-    fn new(imports: &'a Imports) -> Self {
+    pub(crate) fn new(imports: &'a Imports) -> Self {
         let iter = imports.map.iter();
         Self { iter }
     }
@@ -225,7 +226,7 @@ impl fmt::Debug for Imports {
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                 match self {
                     Self::Empty => write!(f, "(empty)"),
-                    Self::Some(len) => write!(f, "(... {} item(s) ...)", len),
+                    Self::Some(len) => write!(f, "(... {len} item(s) ...)"),
                 }
             }
         }
@@ -462,6 +463,7 @@ mod test {
         };
 
         imports2.extend(&imports1);
+
         let _happy_dog_entry = imports2.get_export("dog", "happy").unwrap();
         /*
         assert!(
diff --git a/lib/api/src/entities/instance.rs b/lib/api/src/entities/instance.rs
new file mode 100644
index 0000000000..0a2e7ac18b
--- /dev/null
+++ b/lib/api/src/entities/instance.rs
@@ -0,0 +1,182 @@
+use crate::{
+    error::InstantiationError, exports::Exports, imports::Imports, macros::backend::gen_rt_ty,
+    module::Module, store::AsStoreMut, Extern,
+};
+
+/// A WebAssembly Instance is a stateful, executable
+/// instance of a WebAssembly [`Module`].
+///
+/// Instance objects contain all the exported WebAssembly
+/// functions, memories, tables and globals that allow
+/// interacting with WebAssembly.
+///
+/// Spec: <https://webassembly.github.io/spec/core/exec/runtime.html#module-instances>
+#[derive(Clone, PartialEq, Eq)]
+pub struct Instance {
+    pub(crate) _inner: BackendInstance,
+    pub(crate) module: Module,
+    /// The exports for an instance.
+    pub exports: Exports,
+}
+
+impl Instance {
+    /// Creates a new `Instance` from a WebAssembly [`Module`] and a
+    /// set of imports using [`Imports`] or the [`imports!`] macro helper.
+    ///
+    /// [`imports!`]: crate::imports!
+    /// [`Imports!`]: crate::Imports!
+    ///
+    /// ```
+    /// # use wasmer::{imports, Store, Module, Global, Value, Instance};
+    /// # use wasmer::FunctionEnv;
+    /// # fn main() -> anyhow::Result<()> {
+    /// let mut store = Store::default();
+    /// let env = FunctionEnv::new(&mut store, ());
+    /// let module = Module::new(&store, "(module)")?;
+    /// let imports = imports!{
+    ///   "host" => {
+    ///     "var" => Global::new(&mut store, Value::I32(2))
+    ///   }
+    /// };
+    /// let instance = Instance::new(&mut store, &module, &imports)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// ## Errors
+    ///
+    /// The function can return [`InstantiationError`]s.
+    ///
+    /// Those are, as defined by the spec:
+    ///  * Link errors that happen when plugging the imports into the instance
+    ///  * Runtime errors that happen when running the module `start` function.
+    #[allow(clippy::result_large_err)]
+    pub fn new(
+        store: &mut impl AsStoreMut,
+        module: &Module,
+        imports: &Imports,
+    ) -> Result<Self, InstantiationError> {
+        let (_inner, exports) = match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(_) => {
+                let (i, e) = crate::backend::sys::instance::Instance::new(store, module, imports)?;
+                (crate::BackendInstance::Sys(i), e)
+            }
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => {
+                let (i, e) = crate::backend::wamr::instance::Instance::new(store, module, imports)?;
+
+                (crate::BackendInstance::Wamr(i), e)
+            }
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => {
+                let (i, e) =
+                    crate::backend::wasmi::instance::Instance::new(store, module, imports)?;
+
+                (crate::BackendInstance::Wasmi(i), e)
+            }
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => {
+                let (i, e) = crate::backend::v8::instance::Instance::new(store, module, imports)?;
+                (crate::BackendInstance::V8(i), e)
+            }
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => {
+                let (i, e) = crate::backend::js::instance::Instance::new(store, module, imports)?;
+                (crate::BackendInstance::Js(i), e)
+            }
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => {
+                let (i, e) = crate::backend::jsc::instance::Instance::new(store, module, imports)?;
+                (crate::BackendInstance::Jsc(i), e)
+            }
+        };
+
+        Ok(Self {
+            _inner,
+            module: module.clone(),
+            exports,
+        })
+    }
+
+    /// Creates a new `Instance` from a WebAssembly [`Module`] and a
+    /// vector of imports.
+    ///
+    /// ## Errors
+    ///
+    /// The function can return [`InstantiationError`]s.
+    ///
+    /// Those are, as defined by the spec:
+    ///  * Link errors that happen when plugging the imports into the instance
+    ///  * Runtime errors that happen when running the module `start` function.
+    #[allow(clippy::result_large_err)]
+    pub fn new_by_index(
+        store: &mut impl AsStoreMut,
+        module: &Module,
+        externs: &[Extern],
+    ) -> Result<Self, InstantiationError> {
+        let (_inner, exports) = match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(_) => {
+                let (i, e) =
+                    crate::backend::sys::instance::Instance::new_by_index(store, module, externs)?;
+                (crate::BackendInstance::Sys(i), e)
+            }
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => {
+                let (i, e) =
+                    crate::backend::wamr::instance::Instance::new_by_index(store, module, externs)?;
+
+                (crate::BackendInstance::Wamr(i), e)
+            }
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => {
+                let (i, e) = crate::backend::wasmi::instance::Instance::new_by_index(
+                    store, module, externs,
+                )?;
+
+                (crate::BackendInstance::Wasmi(i), e)
+            }
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => {
+                let (i, e) =
+                    crate::backend::v8::instance::Instance::new_by_index(store, module, externs)?;
+                (crate::BackendInstance::V8(i), e)
+            }
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => {
+                let (i, e) =
+                    crate::backend::js::instance::Instance::new_by_index(store, module, externs)?;
+                (crate::BackendInstance::Js(i), e)
+            }
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => {
+                let (i, e) =
+                    crate::backend::jsc::instance::Instance::new_by_index(store, module, externs)?;
+                (crate::BackendInstance::Jsc(i), e)
+            }
+        };
+
+        Ok(Self {
+            _inner,
+            module: module.clone(),
+            exports,
+        })
+    }
+
+    /// Gets the [`Module`] associated with this instance.
+    pub fn module(&self) -> &Module {
+        &self.module
+    }
+}
+
+impl std::fmt::Debug for Instance {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("Instance")
+            .field("exports", &self.exports)
+            .finish()
+    }
+}
+
+/// An enumeration of all the possible instances kind supported by the runtimes.
+gen_rt_ty!(Instance @derives Clone, PartialEq, Eq);
diff --git a/lib/api/src/entities/memory/buffer/inner.rs b/lib/api/src/entities/memory/buffer/inner.rs
new file mode 100644
index 0000000000..6823b331ba
--- /dev/null
+++ b/lib/api/src/entities/memory/buffer/inner.rs
@@ -0,0 +1,92 @@
+use std::{marker::PhantomData, mem::MaybeUninit};
+
+use crate::{
+    macros::backend::{gen_rt_ty, match_rt},
+    MemoryAccessError,
+};
+
+/// Underlying buffer for a memory.
+gen_rt_ty!(MemoryBuffer<'a>
+    @derives Debug, Copy, Clone, derive_more::From;
+    @path memory
+);
+
+impl BackendMemoryBuffer<'_> {
+    #[allow(unused)]
+    #[inline]
+    pub(crate) fn read(&self, offset: u64, buf: &mut [u8]) -> Result<(), MemoryAccessError> {
+        match_rt!(on self => s {
+            s.read(offset, buf)
+        })
+    }
+
+    #[allow(unused)]
+    #[inline]
+    pub(crate) fn read_uninit<'b>(
+        &self,
+        offset: u64,
+        buf: &'b mut [MaybeUninit<u8>],
+    ) -> Result<&'b mut [u8], MemoryAccessError> {
+        match_rt!(on self => s {
+            s.read_uninit(offset, buf)
+        })
+    }
+
+    #[allow(unused)]
+    #[inline]
+    pub(crate) fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
+        match_rt!(on self => s {
+            s.write(offset, data)
+        })
+    }
+
+    #[inline]
+    pub(crate) fn len(&self) -> usize {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(s) => s.len,
+
+            #[cfg(feature = "wamr")]
+            Self::Wamr(s) => s.len,
+
+            #[cfg(feature = "wasmi")]
+            Self::Wasmi(s) => s.len,
+
+            #[cfg(feature = "v8")]
+            Self::V8(s) => s.len,
+
+            #[cfg(feature = "js")]
+            Self::Js(s) => s.len(),
+
+            #[cfg(feature = "jsc")]
+            Self::Jsc(s) => s.len,
+        }
+    }
+
+    #[inline]
+    pub(crate) fn is_owned(&self) -> bool {
+        match self {
+            #[cfg(feature = "js")]
+            Self::Js(_) => true,
+            _ => false,
+        }
+    }
+
+    #[inline]
+    pub(crate) fn base(&self) -> *mut u8 {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(s) => s.base,
+            #[cfg(feature = "wamr")]
+            Self::Wamr(s) => s.base,
+            #[cfg(feature = "wasmi")]
+            Self::Wasmi(s) => s.base,
+            #[cfg(feature = "v8")]
+            Self::V8(s) => s.base,
+            #[cfg(feature = "js")]
+            Self::Js(s) => panic!("js memory buffers do not support the `base` function!"),
+            #[cfg(feature = "jsc")]
+            Self::Jsc(s) => s.base,
+        }
+    }
+}
diff --git a/lib/api/src/entities/memory/buffer/mod.rs b/lib/api/src/entities/memory/buffer/mod.rs
new file mode 100644
index 0000000000..18bff5e48a
--- /dev/null
+++ b/lib/api/src/entities/memory/buffer/mod.rs
@@ -0,0 +1,47 @@
+use std::{marker::PhantomData, mem::MaybeUninit};
+
+use crate::MemoryAccessError;
+
+pub(crate) mod inner;
+pub(crate) use inner::*;
+
+/// Underlying buffer for a memory.
+#[derive(Debug, Copy, Clone, derive_more::From)]
+pub(crate) struct MemoryBuffer<'a>(pub(crate) BackendMemoryBuffer<'a>);
+
+impl MemoryBuffer<'_> {
+    #[allow(unused)]
+    pub(crate) fn read(&self, offset: u64, buf: &mut [u8]) -> Result<(), MemoryAccessError> {
+        self.0.read(offset, buf)
+    }
+
+    #[allow(unused)]
+    pub(crate) fn read_uninit<'b>(
+        &self,
+        offset: u64,
+        buf: &'b mut [MaybeUninit<u8>],
+    ) -> Result<&'b mut [u8], MemoryAccessError> {
+        self.0.read_uninit(offset, buf)
+    }
+
+    #[allow(unused)]
+    pub(crate) fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
+        self.0.write(offset, data)
+    }
+
+    pub(crate) fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    pub(crate) fn base(&self) -> *mut u8 {
+        self.0.base()
+    }
+
+    /// This is used to determine if the buffer is owned by the memory.
+    ///
+    /// This is only useful for JS memory buffers, as they will slowdown
+    /// if we always need to own the memory in other engines.
+    pub(crate) fn is_owned(&self) -> bool {
+        self.0.is_owned()
+    }
+}
diff --git a/lib/api/src/entities/memory/inner.rs b/lib/api/src/entities/memory/inner.rs
new file mode 100644
index 0000000000..f6ec7c471d
--- /dev/null
+++ b/lib/api/src/entities/memory/inner.rs
@@ -0,0 +1,381 @@
+use super::{shared::SharedMemory, view::*};
+use wasmer_types::{MemoryError, MemoryType, Pages};
+
+use crate::{
+    macros::backend::{gen_rt_ty, match_rt},
+    vm::{VMExtern, VMExternMemory, VMMemory},
+    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, StoreMut, StoreRef,
+};
+
+gen_rt_ty!(Memory
+    @cfg feature = "artifact-size" => derive(loupe::MemoryUsage)
+    @derives Debug, Clone, PartialEq, Eq, derive_more::From
+);
+
+impl BackendMemory {
+    /// Creates a new host [`BackendMemory`] from the provided [`MemoryType`].
+    ///
+    /// This function will construct the `Memory` using the store
+    /// `BaseTunables`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let m = Memory::new(&mut store, MemoryType::new(1, None, false)).unwrap();
+    /// ```
+    #[inline]
+    pub fn new(store: &mut impl AsStoreMut, ty: MemoryType) -> Result<Self, MemoryError> {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(s) => Ok(Self::Sys(
+                crate::backend::sys::entities::memory::Memory::new(store, ty)?,
+            )),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(s) => Ok(Self::Wamr(
+                crate::backend::wamr::entities::memory::Memory::new(store, ty)?,
+            )),
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(s) => Ok(Self::Wasmi(
+                crate::backend::wasmi::entities::memory::Memory::new(store, ty)?,
+            )),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(s) => Ok(Self::V8(
+                crate::backend::v8::entities::memory::Memory::new(store, ty)?,
+            )),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(s) => Ok(Self::Js(
+                crate::backend::js::entities::memory::Memory::new(store, ty)?,
+            )),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(s) => Ok(Self::Jsc(
+                crate::backend::jsc::entities::memory::Memory::new(store, ty)?,
+            )),
+        }
+    }
+
+    /// Create a memory object from an existing memory and attaches it to the store
+    #[inline]
+    pub fn new_from_existing(new_store: &mut impl AsStoreMut, memory: VMMemory) -> Self {
+        match new_store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(_) => Self::Sys(
+                crate::backend::sys::entities::memory::Memory::new_from_existing(
+                    new_store,
+                    memory.into_sys(),
+                ),
+            ),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => Self::Wamr(
+                crate::backend::wamr::entities::memory::Memory::new_from_existing(
+                    new_store,
+                    memory.into_wamr(),
+                ),
+            ),
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => Self::Wasmi(
+                crate::backend::wasmi::entities::memory::Memory::new_from_existing(
+                    new_store,
+                    memory.into_wasmi(),
+                ),
+            ),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => Self::V8(
+                crate::backend::v8::entities::memory::Memory::new_from_existing(
+                    new_store,
+                    memory.into_v8(),
+                ),
+            ),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => Self::Js(
+                crate::backend::js::entities::memory::Memory::new_from_existing(
+                    new_store,
+                    memory.into_js(),
+                ),
+            ),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => Self::Jsc(
+                crate::backend::jsc::entities::memory::Memory::new_from_existing(
+                    new_store,
+                    memory.into_jsc(),
+                ),
+            ),
+        }
+    }
+
+    /// Returns the [`MemoryType`] of the [`BackendMemory`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let mt = MemoryType::new(1, None, false);
+    /// let m = Memory::new(&mut store, mt).unwrap();
+    ///
+    /// assert_eq!(m.ty(&mut store), mt);
+    /// ```
+    #[inline]
+    pub fn ty(&self, store: &impl AsStoreRef) -> MemoryType {
+        match_rt!(on self => s {
+            s.ty(store)
+        })
+    }
+
+    /// Retrieve the size of the memory in pages.
+    pub fn size(&self, store: &impl AsStoreRef) -> Pages {
+        match_rt!(on self => s {
+            s.size(store)
+        })
+    }
+
+    /// Grow memory by the specified amount of WebAssembly [`Pages`] and return
+    /// the previous memory size.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value, WASM_MAX_PAGES};
+    /// # let mut store = Store::default();
+    /// #
+    /// let m = Memory::new(&mut store, MemoryType::new(1, Some(3), false)).unwrap();
+    /// let p = m.grow(&mut store, 2).unwrap();
+    ///
+    /// assert_eq!(p, Pages(1));
+    /// assert_eq!(m.view(&mut store).size(), Pages(3));
+    /// ```
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if memory can't be grown by the specified amount
+    /// of pages.
+    ///
+    /// ```should_panic
+    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value, WASM_MAX_PAGES};
+    /// # use wasmer::FunctionEnv;
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// #
+    /// let m = Memory::new(&mut store, MemoryType::new(1, Some(1), false)).unwrap();
+    ///
+    /// // This results in an error: `MemoryError::CouldNotGrow`.
+    /// let s = m.grow(&mut store, 1).unwrap();
+    /// ```
+    #[inline]
+    pub fn grow<IntoPages>(
+        &self,
+        store: &mut impl AsStoreMut,
+        delta: IntoPages,
+    ) -> Result<Pages, MemoryError>
+    where
+        IntoPages: Into<Pages>,
+    {
+        match_rt!(on self => s {
+            s.grow(store, delta)
+        })
+    }
+
+    /// Grows the memory to at least a minimum size.
+    ///
+    /// # Note
+    ///
+    /// If the memory is already big enough for the min size this function does nothing.
+    #[inline]
+    pub fn grow_at_least(
+        &self,
+        store: &mut impl AsStoreMut,
+        min_size: u64,
+    ) -> Result<(), MemoryError> {
+        match_rt!(on self => s {
+            s.grow_at_least(store, min_size)
+        })
+    }
+
+    /// Resets the memory back to zero length
+    #[inline]
+    pub fn reset(&self, store: &mut impl AsStoreMut) -> Result<(), MemoryError> {
+        match_rt!(on self => s {
+            s.reset(store)
+        })
+    }
+
+    /// Attempts to duplicate this memory (if its clonable) in a new store
+    /// (copied memory)
+    #[inline]
+    pub fn copy_to_store(
+        &self,
+        store: &impl AsStoreRef,
+        new_store: &mut impl AsStoreMut,
+    ) -> Result<Self, MemoryError> {
+        if !self.ty(store).shared {
+            // We should only be able to duplicate in a new store if the memory is shared
+            return Err(MemoryError::InvalidMemory {
+                reason: "memory is not a shared memory type".to_string(),
+            });
+        }
+
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(s) => s.try_copy(store).map(|new_memory| {
+                Self::new_from_existing(
+                    new_store,
+                    VMMemory::Sys(crate::backend::sys::vm::VMMemory(new_memory)),
+                )
+            }),
+            #[cfg(feature = "wamr")]
+            Self::Wamr(s) => s
+                .try_copy(store)
+                .map(|new_memory| Self::new_from_existing(new_store, VMMemory::Wamr(new_memory))),
+            #[cfg(feature = "wasmi")]
+            Self::Wasmi(s) => s
+                .try_copy(store)
+                .map(|new_memory| Self::new_from_existing(new_store, VMMemory::Wasmi(new_memory))),
+
+            #[cfg(feature = "v8")]
+            Self::V8(s) => s
+                .try_copy(store)
+                .map(|new_memory| Self::new_from_existing(new_store, VMMemory::V8(new_memory))),
+            #[cfg(feature = "js")]
+            Self::Js(s) => s
+                .try_copy(store)
+                .map(|new_memory| Self::new_from_existing(new_store, VMMemory::Js(new_memory))),
+            #[cfg(feature = "jsc")]
+            Self::Jsc(s) => s
+                .try_copy(store)
+                .map(|new_memory| Self::new_from_existing(new_store, VMMemory::Jsc(new_memory))),
+        }
+    }
+
+    #[inline]
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternMemory) -> Self {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(s) => Self::Sys(
+                crate::backend::sys::entities::memory::Memory::from_vm_extern(store, vm_extern),
+            ),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(s) => Self::Wamr(
+                crate::backend::wamr::entities::memory::Memory::from_vm_extern(store, vm_extern),
+            ),
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(s) => Self::Wasmi(
+                crate::backend::wasmi::entities::memory::Memory::from_vm_extern(store, vm_extern),
+            ),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(s) => Self::V8(
+                crate::backend::v8::entities::memory::Memory::from_vm_extern(store, vm_extern),
+            ),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(s) => Self::Js(
+                crate::backend::js::entities::memory::Memory::from_vm_extern(store, vm_extern),
+            ),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(s) => Self::Jsc(
+                crate::backend::jsc::entities::memory::Memory::from_vm_extern(store, vm_extern),
+            ),
+        }
+    }
+
+    /// Checks whether this `Memory` can be used with the given context.
+    #[inline]
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        match_rt!(on self => s {
+            s.is_from_store(store)
+        })
+    }
+
+    /// Attempt to create a new reference to the underlying memory; this new reference can then be
+    /// used within a different store (from the same implementer).
+    ///
+    /// # Errors
+    ///
+    /// Fails if the underlying memory is not clonable.
+    #[inline]
+    pub fn try_clone(&self, store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(s) => s.try_clone(store).map(VMMemory::Sys),
+            #[cfg(feature = "wamr")]
+            Self::Wamr(s) => s.try_clone(store).map(VMMemory::Wamr),
+            #[cfg(feature = "wasmi")]
+            Self::Wasmi(s) => s.try_clone(store).map(VMMemory::Wasmi),
+            #[cfg(feature = "v8")]
+            Self::V8(s) => s.try_clone(store).map(VMMemory::V8),
+            #[cfg(feature = "js")]
+            Self::Js(s) => s.try_clone(store).map(VMMemory::Js),
+            #[cfg(feature = "jsc")]
+            Self::Jsc(s) => s.try_clone(store).map(VMMemory::Jsc),
+        }
+    }
+
+    /// Attempts to clone this memory (if its clonable) in a new store
+    /// (cloned memory will be shared between those that clone it)
+    #[inline]
+    pub fn share_in_store(
+        &self,
+        store: &impl AsStoreRef,
+        new_store: &mut impl AsStoreMut,
+    ) -> Result<Self, MemoryError> {
+        if !self.ty(store).shared {
+            // We should only be able to duplicate in a new store if the memory is shared
+            return Err(MemoryError::InvalidMemory {
+                reason: "memory is not a shared memory type".to_string(),
+            });
+        }
+
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(s) => s
+                .try_clone(store)
+                .map(|new_memory| Self::new_from_existing(new_store, VMMemory::Sys(new_memory))),
+            #[cfg(feature = "wamr")]
+            Self::Wamr(s) => s
+                .try_clone(store)
+                .map(|new_memory| Self::new_from_existing(new_store, VMMemory::Wamr(new_memory))),
+            #[cfg(feature = "wasmi")]
+            Self::Wasmi(s) => s
+                .try_clone(store)
+                .map(|new_memory| Self::new_from_existing(new_store, VMMemory::Wasmi(new_memory))),
+            #[cfg(feature = "v8")]
+            Self::V8(s) => s
+                .try_clone(store)
+                .map(|new_memory| Self::new_from_existing(new_store, VMMemory::V8(new_memory))),
+            #[cfg(feature = "js")]
+            Self::Js(s) => s
+                .try_clone(store)
+                .map(|new_memory| Self::new_from_existing(new_store, VMMemory::Js(new_memory))),
+            #[cfg(feature = "jsc")]
+            Self::Jsc(s) => s
+                .try_clone(store)
+                .map(|new_memory| Self::new_from_existing(new_store, VMMemory::Jsc(new_memory))),
+        }
+    }
+
+    /// Get a [`SharedMemory`].
+    ///
+    /// Only returns `Some(_)` if the memory is shared, and if the target
+    /// backend supports shared memory operations.
+    ///
+    /// See [`SharedMemory`] and its methods for more information.
+    #[inline]
+    pub fn as_shared(&self, store: &impl AsStoreRef) -> Option<SharedMemory> {
+        if !self.ty(store).shared {
+            return None;
+        }
+
+        match_rt!(on self => s {
+            s.as_shared(store)
+        })
+    }
+
+    /// Create a [`VMExtern`] from self.
+    #[inline]
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        match_rt!(on self => s {
+            s.to_vm_extern()
+        })
+    }
+}
diff --git a/lib/api/src/entities/memory/location.rs b/lib/api/src/entities/memory/location.rs
new file mode 100644
index 0000000000..115210e3ea
--- /dev/null
+++ b/lib/api/src/entities/memory/location.rs
@@ -0,0 +1,52 @@
+use wasmer_types::MemoryError;
+
+use crate::error::AtomicsError;
+
+/// Location in a WebAssembly memory.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct MemoryLocation {
+    // NOTE: must be expanded to an enum that also supports 64bit memory in
+    // the future
+    // That's why this is private.
+    pub(crate) address: u32,
+}
+
+impl MemoryLocation {
+    /// Create a new memory location for a 32bit memory.
+    pub fn new_32(address: u32) -> Self {
+        Self { address }
+    }
+}
+
+impl From<u32> for MemoryLocation {
+    fn from(value: u32) -> Self {
+        Self::new_32(value)
+    }
+}
+
+/// See [`crate::SharedMemory`].
+pub(crate) trait SharedMemoryOps {
+    /// See [`crate::SharedMemory::disable_atomics`].
+    fn disable_atomics(&self) -> Result<(), MemoryError> {
+        Err(MemoryError::AtomicsNotSupported)
+    }
+
+    /// See [`crate::SharedMemory::wake_all_atomic_waiters`].
+    fn wake_all_atomic_waiters(&self) -> Result<(), MemoryError> {
+        Err(MemoryError::AtomicsNotSupported)
+    }
+
+    /// See [`crate::SharedMemory::notify`].
+    fn notify(&self, _dst: MemoryLocation, _count: u32) -> Result<u32, AtomicsError> {
+        Err(AtomicsError::Unimplemented)
+    }
+
+    /// See [`crate::SharedMemory::wait`].
+    fn wait(
+        &self,
+        _dst: MemoryLocation,
+        _timeout: Option<std::time::Duration>,
+    ) -> Result<u32, AtomicsError> {
+        Err(AtomicsError::Unimplemented)
+    }
+}
diff --git a/lib/api/src/entities/memory/mod.rs b/lib/api/src/entities/memory/mod.rs
new file mode 100644
index 0000000000..168aacc57d
--- /dev/null
+++ b/lib/api/src/entities/memory/mod.rs
@@ -0,0 +1,216 @@
+pub use shared::SharedMemory;
+use wasmer_types::{MemoryError, MemoryType, Pages};
+
+use crate::{
+    vm::{VMExtern, VMExternMemory, VMMemory},
+    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, StoreMut, StoreRef,
+};
+
+pub(crate) mod buffer;
+pub(crate) mod inner;
+pub(crate) mod location;
+pub(crate) mod shared;
+pub(crate) mod view;
+
+pub(crate) use inner::*;
+pub use view::*;
+
+/// A WebAssembly `memory` instance.
+///
+/// A memory instance is the runtime representation of a linear memory.
+/// It consists of a vector of bytes and an optional maximum size.
+///
+/// The length of the vector always is a multiple of the WebAssembly
+/// page size, which is defined to be the constant 65536 – abbreviated 64Ki.
+/// Like in a memory type, the maximum size in a memory instance is
+/// given in units of this page size.
+///
+/// A memory created by the host or in WebAssembly code will be accessible and
+/// mutable from both host and WebAssembly.
+///
+/// Spec: <https://webassembly.github.io/spec/core/exec/runtime.html#memory-instances>
+#[derive(Debug, Clone, PartialEq, Eq, derive_more::From)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+pub struct Memory(pub(crate) BackendMemory);
+
+impl Memory {
+    /// Creates a new host [`Memory`] from the provided [`MemoryType`].
+    ///
+    /// This function will construct the `Memory` using the store
+    /// `BaseTunables`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let m = Memory::new(&mut store, MemoryType::new(1, None, false)).unwrap();
+    /// ```
+    pub fn new(store: &mut impl AsStoreMut, ty: MemoryType) -> Result<Self, MemoryError> {
+        BackendMemory::new(store, ty).map(Self)
+    }
+
+    /// Create a memory object from an existing memory and attaches it to the store
+    pub fn new_from_existing<IntoVMMemory>(
+        new_store: &mut impl AsStoreMut,
+        memory: IntoVMMemory,
+    ) -> Self
+    where
+        IntoVMMemory: Into<VMMemory>,
+    {
+        Self(BackendMemory::new_from_existing(new_store, memory.into()))
+    }
+
+    /// Returns the [`MemoryType`] of the `Memory`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let mt = MemoryType::new(1, None, false);
+    /// let m = Memory::new(&mut store, mt).unwrap();
+    ///
+    /// assert_eq!(m.ty(&mut store), mt);
+    /// ```
+    pub fn ty(&self, store: &impl AsStoreRef) -> MemoryType {
+        self.0.ty(store)
+    }
+
+    /// Creates a view into the memory that then allows for
+    /// read and write
+    pub fn view<'a>(&self, store: &'a (impl AsStoreRef + ?Sized)) -> MemoryView<'a> {
+        MemoryView::new(self, store)
+    }
+
+    /// Retrieve the size of the memory in pages.
+    pub fn size(&self, store: &impl AsStoreRef) -> Pages {
+        self.0.size(store)
+    }
+
+    /// Grow memory by the specified amount of WebAssembly [`Pages`] and return
+    /// the previous memory size.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value, WASM_MAX_PAGES};
+    /// # let mut store = Store::default();
+    /// #
+    /// let m = Memory::new(&mut store, MemoryType::new(1, Some(3), false)).unwrap();
+    /// let p = m.grow(&mut store, 2).unwrap();
+    ///
+    /// assert_eq!(p, Pages(1));
+    /// assert_eq!(m.view(&mut store).size(), Pages(3));
+    /// ```
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if memory can't be grown by the specified amount
+    /// of pages.
+    ///
+    /// ```should_panic
+    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value, WASM_MAX_PAGES};
+    /// # use wasmer::FunctionEnv;
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// #
+    /// let m = Memory::new(&mut store, MemoryType::new(1, Some(1), false)).unwrap();
+    ///
+    /// // This results in an error: `MemoryError::CouldNotGrow`.
+    /// let s = m.grow(&mut store, 1).unwrap();
+    /// ```
+    pub fn grow<IntoPages>(
+        &self,
+        store: &mut impl AsStoreMut,
+        delta: IntoPages,
+    ) -> Result<Pages, MemoryError>
+    where
+        IntoPages: Into<Pages>,
+    {
+        self.0.grow(store, delta)
+    }
+
+    /// Grows the memory to at least a minimum size.
+    ///
+    /// # Note
+    ///
+    /// If the memory is already big enough for the min size this function does nothing.
+    pub fn grow_at_least(
+        &self,
+        store: &mut impl AsStoreMut,
+        min_size: u64,
+    ) -> Result<(), MemoryError> {
+        self.0.grow_at_least(store, min_size)
+    }
+
+    /// Resets the memory back to zero length
+    pub fn reset(&self, store: &mut impl AsStoreMut) -> Result<(), MemoryError> {
+        self.0.reset(store)
+    }
+
+    /// Attempts to duplicate this memory (if its clonable) in a new store
+    /// (copied memory)
+    pub fn copy_to_store(
+        &self,
+        store: &impl AsStoreRef,
+        new_store: &mut impl AsStoreMut,
+    ) -> Result<Self, MemoryError> {
+        self.0.copy_to_store(store, new_store).map(Self)
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternMemory) -> Self {
+        Self(BackendMemory::from_vm_extern(store, vm_extern))
+    }
+
+    /// Checks whether this `Memory` can be used with the given context.
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.0.is_from_store(store)
+    }
+
+    /// Attempt to create a new reference to the underlying memory; this new reference can then be
+    /// used within a different store (from the same implementer).
+    ///
+    /// # Errors
+    ///
+    /// Fails if the underlying memory is not clonable.
+    pub fn try_clone(&self, store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
+        self.0.try_clone(store)
+    }
+
+    /// Attempts to clone this memory (if its clonable) in a new store
+    /// (cloned memory will be shared between those that clone it)
+    pub fn share_in_store(
+        &self,
+        store: &impl AsStoreRef,
+        new_store: &mut impl AsStoreMut,
+    ) -> Result<Self, MemoryError> {
+        self.0.share_in_store(store, new_store).map(Self)
+    }
+
+    /// Get a [`SharedMemory`].
+    ///
+    /// Only returns `Some(_)` if the memory is shared, and if the target
+    /// backend supports shared memory operations.
+    ///
+    /// See [`SharedMemory`] and its methods for more information.
+    pub fn as_shared(&self, store: &impl AsStoreRef) -> Option<SharedMemory> {
+        self.0.as_shared(store)
+    }
+
+    /// Create a [`VMExtern`] from self.
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        self.0.to_vm_extern()
+    }
+}
+
+impl<'a> Exportable<'a> for Memory {
+    fn get_self_from_extern(_extern: &'a Extern) -> Result<&'a Self, ExportError> {
+        match _extern {
+            Extern::Memory(memory) => Ok(memory),
+            _ => Err(ExportError::IncompatibleType),
+        }
+    }
+}
diff --git a/lib/api/src/entities/memory/shared.rs b/lib/api/src/entities/memory/shared.rs
new file mode 100644
index 0000000000..45a31eb8f4
--- /dev/null
+++ b/lib/api/src/entities/memory/shared.rs
@@ -0,0 +1,78 @@
+use wasmer_types::MemoryError;
+
+use crate::{
+    error::AtomicsError,
+    location::{MemoryLocation, SharedMemoryOps},
+    Memory,
+};
+
+/// A handle that exposes operations only relevant for shared memories.
+///
+/// Enables interaction independent from the [`crate::Store`], and thus allows calling
+/// some methods an instane is running.
+///
+/// **NOTE**: Not all methods are supported by all backends.
+#[derive(Clone)]
+pub struct SharedMemory {
+    memory: Memory,
+    ops: std::sync::Arc<dyn SharedMemoryOps + Send + Sync>,
+}
+
+impl std::fmt::Debug for SharedMemory {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SharedMemory").finish()
+    }
+}
+
+impl SharedMemory {
+    /// Get the underlying memory.
+    pub fn memory(&self) -> &Memory {
+        &self.memory
+    }
+
+    /// Create a new handle from ops.
+    #[allow(unused)]
+    pub(crate) fn new(memory: Memory, ops: impl SharedMemoryOps + Send + Sync + 'static) -> Self {
+        Self {
+            memory,
+            ops: std::sync::Arc::new(ops),
+        }
+    }
+
+    /// Notify up to `count` waiters waiting for the memory location.
+    pub fn notify(&self, location: MemoryLocation, count: u32) -> Result<u32, AtomicsError> {
+        self.ops.notify(location, count)
+    }
+
+    /// Wait for the memory location to be notified.
+    pub fn wait(
+        &self,
+        location: MemoryLocation,
+        timeout: Option<std::time::Duration>,
+    ) -> Result<u32, AtomicsError> {
+        self.ops.wait(location, timeout)
+    }
+
+    /// Disable atomics for this memory.
+    ///
+    /// All subsequent atomic wait calls will produce a trap.
+    ///
+    /// This can be used or forced shutdown of instances that continuously try
+    /// to wait on atomics.
+    ///
+    /// NOTE: this operation might not be supported by all memory implementations.
+    /// In that case, this function will return an error.
+    pub fn disable_atomics(&self) -> Result<(), MemoryError> {
+        self.ops.disable_atomics()
+    }
+
+    /// Wake up all atomic waiters.
+    ///
+    /// This can be used to force-resume waiting execution.
+    ///
+    /// NOTE: this operation might not be supported by all memory implementations.
+    /// In that case, this function will return an error.
+    pub fn wake_all_atomic_waiters(&self) -> Result<(), MemoryError> {
+        self.ops.wake_all_atomic_waiters()
+    }
+}
diff --git a/lib/api/src/entities/memory/view/inner.rs b/lib/api/src/entities/memory/view/inner.rs
new file mode 100644
index 0000000000..6297d6802a
--- /dev/null
+++ b/lib/api/src/entities/memory/view/inner.rs
@@ -0,0 +1,262 @@
+use std::{mem::MaybeUninit, ops::Range};
+use wasmer_types::Pages;
+
+use crate::{
+    buffer::{BackendMemoryBuffer, MemoryBuffer},
+    macros::backend::{gen_rt_ty, match_rt},
+    AsStoreRef, Memory, MemoryAccessError,
+};
+
+/// A WebAssembly `memory` view.
+///
+/// A memory view is used to read and write to the linear memory.
+///
+/// After a memory is grown a view must not be used anymore. Views are
+/// created using the Memory.view() method.
+gen_rt_ty!(MemoryView<'a> @derives Debug, derive_more::From ; @path memory::view);
+
+impl<'a> BackendMemoryView<'a> {
+    #[inline]
+    #[allow(clippy::needless_return)]
+    pub(crate) fn new(memory: &Memory, store: &'a (impl AsStoreRef + ?Sized)) -> Self {
+        match &store.as_store_ref().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(s) => Self::Sys(
+                crate::backend::sys::entities::memory::view::MemoryView::new(
+                    memory.as_sys(),
+                    store,
+                ),
+            ),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(s) => Self::Wamr(
+                crate::backend::wamr::entities::memory::view::MemoryView::new(
+                    memory.as_wamr(),
+                    store,
+                ),
+            ),
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(s) => Self::Wasmi(
+                crate::backend::wasmi::entities::memory::view::MemoryView::new(
+                    memory.as_wasmi(),
+                    store,
+                ),
+            ),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(s) => Self::V8(
+                crate::backend::v8::entities::memory::view::MemoryView::new(memory.as_v8(), store),
+            ),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(s) => Self::Js(
+                crate::backend::js::entities::memory::view::MemoryView::new(memory.as_js(), store),
+            ),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(s) => Self::Jsc(
+                crate::backend::jsc::entities::memory::view::MemoryView::new(
+                    memory.as_jsc(),
+                    store,
+                ),
+            ),
+        }
+    }
+
+    /// Returns the pointer to the raw bytes of the `Memory`.
+    //
+    // This used by wasmer-c-api, but should be treated
+    // as deprecated and not used in future code.
+    #[doc(hidden)]
+    #[inline]
+    pub fn data_ptr(&self) -> *mut u8 {
+        match_rt!(on self => s {
+            s.data_ptr()
+        })
+    }
+
+    /// Returns the size (in bytes) of the `Memory`.
+    #[inline]
+    pub fn data_size(&self) -> u64 {
+        match_rt!(on self => s {
+            s.data_size()
+        })
+    }
+
+    /// Retrieve a slice of the memory contents.
+    ///
+    /// # Safety
+    ///
+    /// Until the returned slice is dropped, it is undefined behaviour to
+    /// modify the memory contents in any way including by calling a wasm
+    /// function that writes to the memory or by resizing the memory.
+    #[doc(hidden)]
+    #[inline]
+    pub unsafe fn data_unchecked(&self) -> &[u8] {
+        match_rt!(on self => s {
+            s.data_unchecked()
+        })
+    }
+
+    /// Retrieve a mutable slice of the memory contents.
+    ///
+    /// # Safety
+    ///
+    /// This method provides interior mutability without an UnsafeCell. Until
+    /// the returned value is dropped, it is undefined behaviour to read or
+    /// write to the pointed-to memory in any way except through this slice,
+    /// including by calling a wasm function that reads the memory contents or
+    /// by resizing this Memory.
+    #[allow(clippy::mut_from_ref)]
+    #[doc(hidden)]
+    #[inline]
+    pub unsafe fn data_unchecked_mut(&self) -> &mut [u8] {
+        match_rt!(on self => s {
+            s.data_unchecked_mut()
+        })
+    }
+
+    /// Returns the size (in [`Pages`]) of the `Memory`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let m = Memory::new(&mut store, MemoryType::new(1, None, false)).unwrap();
+    ///
+    /// assert_eq!(m.view(&mut store).size(), Pages(1));
+    /// ```
+    #[inline]
+    pub fn size(&self) -> Pages {
+        match_rt!(on self => s {
+            s.size()
+        })
+    }
+
+    #[inline]
+    pub(crate) fn buffer(&'a self) -> MemoryBuffer<'a> {
+        match self {
+            #[cfg(feature = "sys")]
+            Self::Sys(s) => MemoryBuffer(BackendMemoryBuffer::Sys(s.buffer())),
+            #[cfg(feature = "wamr")]
+            Self::Wamr(s) => MemoryBuffer(BackendMemoryBuffer::Wamr(s.buffer())),
+            #[cfg(feature = "wasmi")]
+            Self::Wasmi(s) => MemoryBuffer(BackendMemoryBuffer::Wasmi(s.buffer())),
+            #[cfg(feature = "v8")]
+            Self::V8(s) => MemoryBuffer(BackendMemoryBuffer::V8(s.buffer())),
+            #[cfg(feature = "js")]
+            Self::Js(s) => MemoryBuffer(BackendMemoryBuffer::Js(s.buffer())),
+            #[cfg(feature = "jsc")]
+            Self::Jsc(s) => MemoryBuffer(BackendMemoryBuffer::Jsc(s.buffer())),
+        }
+    }
+
+    /// Safely reads bytes from the memory at the given offset.
+    ///
+    /// The full buffer will be filled, otherwise a `MemoryAccessError` is returned
+    /// to indicate an out-of-bounds access.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    #[inline]
+    pub fn read(&self, offset: u64, buf: &mut [u8]) -> Result<(), MemoryAccessError> {
+        match_rt!(on self => s {
+            s.read(offset, buf)
+        })
+    }
+
+    /// Safely reads a single byte from memory at the given offset
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    #[inline]
+    pub fn read_u8(&self, offset: u64) -> Result<u8, MemoryAccessError> {
+        match_rt!(on self => s {
+            s.read_u8(offset)
+        })
+    }
+
+    /// Safely reads bytes from the memory at the given offset.
+    ///
+    /// This method is similar to `read` but allows reading into an
+    /// uninitialized buffer. An initialized view of the buffer is returned.
+    ///
+    /// The full buffer will be filled, otherwise a `MemoryAccessError` is returned
+    /// to indicate an out-of-bounds access.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    #[inline]
+    pub fn read_uninit<'b>(
+        &self,
+        offset: u64,
+        buf: &'b mut [MaybeUninit<u8>],
+    ) -> Result<&'b mut [u8], MemoryAccessError> {
+        match_rt!(on self => s {
+            s.read_uninit(offset, buf)
+        })
+    }
+
+    /// Safely writes bytes to the memory at the given offset.
+    ///
+    /// If the write exceeds the bounds of the memory then a `MemoryAccessError` is
+    /// returned.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent reads/writes.
+    #[inline]
+    pub fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
+        match_rt!(on self => s {
+            s.write(offset, data)
+        })
+    }
+
+    /// Safely writes a single byte from memory at the given offset
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    #[inline]
+    pub fn write_u8(&self, offset: u64, val: u8) -> Result<(), MemoryAccessError> {
+        match_rt!(on self => s {
+            s.write_u8(offset, val)
+        })
+    }
+
+    /// Copies the memory and returns it as a vector of bytes
+    #[inline]
+    pub fn copy_to_vec(&self) -> Result<Vec<u8>, MemoryAccessError> {
+        self.copy_range_to_vec(0..self.data_size())
+    }
+
+    /// Copies a range of the memory and returns it as a vector of bytes
+    #[inline]
+    pub fn copy_range_to_vec(&self, range: Range<u64>) -> Result<Vec<u8>, MemoryAccessError> {
+        let mut new_memory = Vec::new();
+        let mut offset = range.start;
+        let end = range.end.min(self.data_size());
+        let mut chunk = [0u8; 40960];
+        while offset < end {
+            let remaining = end - offset;
+            let sublen = remaining.min(chunk.len() as u64) as usize;
+            self.read(offset, &mut chunk[..sublen])?;
+            new_memory.extend_from_slice(&chunk[..sublen]);
+            offset += sublen as u64;
+        }
+        Ok(new_memory)
+    }
+
+    /// Copies the memory to another new memory object
+    #[inline]
+    pub fn copy_to_memory(&self, amount: u64, new_memory: &Self) -> Result<(), MemoryAccessError> {
+        let mut offset = 0;
+        let mut chunk = [0u8; 40960];
+        while offset < amount {
+            let remaining = amount - offset;
+            let sublen = remaining.min(chunk.len() as u64) as usize;
+            self.read(offset, &mut chunk[..sublen])?;
+
+            new_memory.write(offset, &chunk[..sublen])?;
+
+            offset += sublen as u64;
+        }
+        Ok(())
+    }
+}
diff --git a/lib/api/src/entities/memory/view/mod.rs b/lib/api/src/entities/memory/view/mod.rs
new file mode 100644
index 0000000000..32e55ce4b1
--- /dev/null
+++ b/lib/api/src/entities/memory/view/mod.rs
@@ -0,0 +1,155 @@
+use std::{mem::MaybeUninit, ops::Range};
+use wasmer_types::Pages;
+
+use crate::{buffer::MemoryBuffer, AsStoreRef, Memory, MemoryAccessError};
+
+pub(crate) mod inner;
+pub(crate) use inner::*;
+
+/// A WebAssembly `memory` view.
+///
+/// A memory view is used to read and write to the linear memory.
+///
+/// After a memory is grown a view must not be used anymore. Views are
+/// created using the Memory.view() method.
+#[derive(Debug, derive_more::From)]
+pub struct MemoryView<'a>(pub(crate) BackendMemoryView<'a>);
+
+impl<'a> MemoryView<'a> {
+    pub(crate) fn new(memory: &Memory, store: &'a (impl AsStoreRef + ?Sized)) -> Self {
+        Self(BackendMemoryView::new(memory, store))
+    }
+
+    /// Returns the pointer to the raw bytes of the `Memory`.
+    //
+    // This used by wasmer-c-api, but should be treated
+    // as deprecated and not used in future code.
+    #[doc(hidden)]
+    pub fn data_ptr(&self) -> *mut u8 {
+        self.0.data_ptr()
+    }
+
+    /// Returns the size (in bytes) of the `Memory`.
+    pub fn data_size(&self) -> u64 {
+        self.0.data_size()
+    }
+
+    /// Retrieve a slice of the memory contents.
+    ///
+    /// # Safety
+    ///
+    /// Until the returned slice is dropped, it is undefined behaviour to
+    /// modify the memory contents in any way including by calling a wasm
+    /// function that writes to the memory or by resizing the memory.
+    #[doc(hidden)]
+    pub unsafe fn data_unchecked(&self) -> &[u8] {
+        self.0.data_unchecked()
+    }
+
+    /// Retrieve a mutable slice of the memory contents.
+    ///
+    /// # Safety
+    ///
+    /// This method provides interior mutability without an UnsafeCell. Until
+    /// the returned value is dropped, it is undefined behaviour to read or
+    /// write to the pointed-to memory in any way except through this slice,
+    /// including by calling a wasm function that reads the memory contents or
+    /// by resizing this Memory.
+    #[allow(clippy::mut_from_ref)]
+    #[doc(hidden)]
+    pub unsafe fn data_unchecked_mut(&self) -> &mut [u8] {
+        self.0.data_unchecked_mut()
+    }
+
+    /// Returns the size (in [`Pages`]) of the `Memory`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let m = Memory::new(&mut store, MemoryType::new(1, None, false)).unwrap();
+    ///
+    /// assert_eq!(m.view(&mut store).size(), Pages(1));
+    /// ```
+    pub fn size(&self) -> Pages {
+        self.0.size()
+    }
+
+    #[inline]
+    pub(crate) fn buffer(&'a self) -> MemoryBuffer<'a> {
+        self.0.buffer()
+    }
+
+    /// Safely reads bytes from the memory at the given offset.
+    ///
+    /// The full buffer will be filled, otherwise a `MemoryAccessError` is returned
+    /// to indicate an out-of-bounds access.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn read(&self, offset: u64, buf: &mut [u8]) -> Result<(), MemoryAccessError> {
+        self.0.read(offset, buf)
+    }
+
+    /// Safely reads a single byte from memory at the given offset
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn read_u8(&self, offset: u64) -> Result<u8, MemoryAccessError> {
+        self.0.read_u8(offset)
+    }
+
+    /// Safely reads bytes from the memory at the given offset.
+    ///
+    /// This method is similar to `read` but allows reading into an
+    /// uninitialized buffer. An initialized view of the buffer is returned.
+    ///
+    /// The full buffer will be filled, otherwise a `MemoryAccessError` is returned
+    /// to indicate an out-of-bounds access.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn read_uninit<'b>(
+        &self,
+        offset: u64,
+        buf: &'b mut [MaybeUninit<u8>],
+    ) -> Result<&'b mut [u8], MemoryAccessError> {
+        self.0.read_uninit(offset, buf)
+    }
+
+    /// Safely writes bytes to the memory at the given offset.
+    ///
+    /// If the write exceeds the bounds of the memory then a `MemoryAccessError` is
+    /// returned.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent reads/writes.
+    pub fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
+        self.0.write(offset, data)
+    }
+
+    /// Safely writes a single byte from memory at the given offset
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn write_u8(&self, offset: u64, val: u8) -> Result<(), MemoryAccessError> {
+        self.0.write_u8(offset, val)
+    }
+
+    /// Copies the memory and returns it as a vector of bytes
+    pub fn copy_to_vec(&self) -> Result<Vec<u8>, MemoryAccessError> {
+        self.0.copy_to_vec()
+    }
+
+    /// Copies a range of the memory and returns it as a vector of bytes
+    pub fn copy_range_to_vec(&self, range: Range<u64>) -> Result<Vec<u8>, MemoryAccessError> {
+        self.0.copy_range_to_vec(range)
+    }
+
+    /// Copies the memory to another new memory object
+    pub fn copy_to_memory(&self, amount: u64, new_memory: &Self) -> Result<(), MemoryAccessError> {
+        self.0.copy_to_memory(amount, &new_memory.0)
+    }
+}
diff --git a/lib/api/src/entities/mod.rs b/lib/api/src/entities/mod.rs
new file mode 100644
index 0000000000..c3e236dd17
--- /dev/null
+++ b/lib/api/src/entities/mod.rs
@@ -0,0 +1,54 @@
+//! This module defines data types, functions and traits used to describe and interact with
+//! various WebAssembly entities such as [`Value`], [`Module`] and [`Store`]. It also describes
+//! entities related to the runtime, such as [`Engine`].
+//!
+//! For more informations, refer to the [WebAssembly specification] and the [Wasmer Runtime
+//! documentation].
+//!
+//! [WebAssembly specification]: https://webassembly.github.io/spec/core/
+//! [Wasmer Runtime documentation]: https://webassembly.github.io/spec/core/
+
+pub(crate) mod engine;
+pub use engine::*;
+
+pub(crate) mod store;
+pub use store::*;
+
+pub(crate) mod module;
+pub use module::*;
+
+pub(crate) mod instance;
+pub use instance::*;
+
+pub(crate) mod trap;
+pub use trap::*;
+
+pub(crate) mod value;
+pub use value::*;
+
+pub(crate) mod external;
+pub use external::*;
+
+pub(crate) mod function;
+pub use function::*;
+
+pub(crate) mod tag;
+pub use tag::*;
+
+pub(crate) mod exception;
+pub use exception::*;
+
+pub(crate) mod global;
+pub use global::*;
+
+pub(crate) mod table;
+pub use table::*;
+
+pub(crate) mod memory;
+pub use memory::*;
+
+pub(crate) mod exports;
+pub use exports::*;
+
+pub(crate) mod imports;
+pub use imports::*;
diff --git a/lib/api/src/entities/module/inner.rs b/lib/api/src/entities/module/inner.rs
new file mode 100644
index 0000000000..66afadc0ed
--- /dev/null
+++ b/lib/api/src/entities/module/inner.rs
@@ -0,0 +1,643 @@
+//! Defines the [`BackendModule`] data type and various useful traits and data types to interact with
+//! a concrete module from a backend.
+
+use std::{fs, path::Path};
+
+use bytes::Bytes;
+use thiserror::Error;
+#[cfg(feature = "wat")]
+use wasmer_types::WasmError;
+use wasmer_types::{
+    CompileError, DeserializeError, ExportType, ExportsIterator, ImportType, ImportsIterator,
+    ModuleInfo, SerializeError,
+};
+
+use crate::{
+    macros::backend::{gen_rt_ty, match_rt},
+    utils::IntoBytes,
+    AsEngineRef,
+};
+
+/// A WebAssembly Module contains stateless WebAssembly
+/// code that has already been compiled and can be instantiated
+/// multiple times.
+///
+/// ## Cloning a module
+///
+/// Cloning a module is cheap: it does a shallow copy of the compiled
+/// contents rather than a deep copy.
+gen_rt_ty!(Module
+    @cfg feature = "artifact-size" => derive(loupe::MemoryUsage)
+    @derives Clone, PartialEq, Eq, derive_more::From
+);
+
+impl BackendModule {
+    #[inline]
+    pub fn new(engine: &impl AsEngineRef, bytes: impl AsRef<[u8]>) -> Result<Self, CompileError> {
+        #[cfg(feature = "wat")]
+        let bytes = wat::parse_bytes(bytes.as_ref()).map_err(|e| {
+            CompileError::Wasm(WasmError::Generic(format!(
+                "Error when converting wat: {e}",
+            )))
+        })?;
+        Self::from_binary(engine, bytes.as_ref())
+    }
+
+    /// Creates a new WebAssembly module from a file path.
+    #[inline]
+    pub fn from_file(
+        engine: &impl AsEngineRef,
+        file: impl AsRef<Path>,
+    ) -> Result<Self, super::IoCompileError> {
+        let file_ref = file.as_ref();
+        let canonical = file_ref.canonicalize()?;
+        let wasm_bytes = std::fs::read(file_ref)?;
+        let mut module = Self::new(engine, wasm_bytes)?;
+        // Set the module name to the absolute path of the filename.
+        // This is useful for debugging the stack traces.
+        let filename = canonical.as_path().to_str().unwrap();
+        module.set_name(filename);
+        Ok(module)
+    }
+
+    /// Creates a new WebAssembly module from a Wasm binary.
+    ///
+    /// Opposed to [`Self::new`], this function is not compatible with
+    /// the WebAssembly text format (if the "wat" feature is enabled for
+    /// this crate).
+    #[inline]
+    pub fn from_binary(engine: &impl AsEngineRef, binary: &[u8]) -> Result<Self, CompileError> {
+        match engine.as_engine_ref().inner.be {
+            #[cfg(feature = "sys")]
+            crate::BackendEngine::Sys(_) => Ok(Self::Sys(
+                crate::backend::sys::entities::module::Module::from_binary(engine, binary)?,
+            )),
+
+            #[cfg(feature = "wamr")]
+            crate::BackendEngine::Wamr(_) => Ok(Self::Wamr(
+                crate::backend::wamr::entities::module::Module::from_binary(engine, binary)?,
+            )),
+
+            #[cfg(feature = "wasmi")]
+            crate::BackendEngine::Wasmi(_) => Ok(Self::Wasmi(
+                crate::backend::wasmi::entities::module::Module::from_binary(engine, binary)?,
+            )),
+
+            #[cfg(feature = "v8")]
+            crate::BackendEngine::V8(_) => Ok(Self::V8(
+                crate::backend::v8::entities::module::Module::from_binary(engine, binary)?,
+            )),
+
+            #[cfg(feature = "js")]
+            crate::BackendEngine::Js(_) => Ok(Self::Js(
+                crate::backend::js::entities::module::Module::from_binary(engine, binary)?,
+            )),
+
+            #[cfg(feature = "jsc")]
+            crate::BackendEngine::Jsc(_) => Ok(Self::Jsc(
+                crate::backend::jsc::entities::module::Module::from_binary(engine, binary)?,
+            )),
+        }
+    }
+
+    /// Creates a new WebAssembly module from a Wasm binary,
+    /// skipping any kind of validation on the WebAssembly file.
+    ///
+    /// # Safety
+    ///
+    /// This can speed up compilation time a bit, but it should be only used
+    /// in environments where the WebAssembly modules are trusted and validated
+    /// beforehand.
+    #[inline]
+    pub unsafe fn from_binary_unchecked(
+        engine: &impl AsEngineRef,
+        binary: &[u8],
+    ) -> Result<Self, CompileError> {
+        match engine.as_engine_ref().inner.be {
+            #[cfg(feature = "sys")]
+            crate::BackendEngine::Sys(_) => Ok(Self::Sys(
+                crate::backend::sys::entities::module::Module::from_binary_unchecked(
+                    engine, binary,
+                )?,
+            )),
+
+            #[cfg(feature = "wamr")]
+            crate::BackendEngine::Wamr(_) => Ok(Self::Wamr(
+                crate::backend::wamr::entities::module::Module::from_binary_unchecked(
+                    engine, binary,
+                )?,
+            )),
+
+            #[cfg(feature = "wasmi")]
+            crate::BackendEngine::Wasmi(_) => Ok(Self::Wasmi(
+                crate::backend::wasmi::entities::module::Module::from_binary_unchecked(
+                    engine, binary,
+                )?,
+            )),
+
+            #[cfg(feature = "v8")]
+            crate::BackendEngine::V8(_) => Ok(Self::V8(
+                crate::backend::v8::entities::module::Module::from_binary_unchecked(
+                    engine, binary,
+                )?,
+            )),
+            #[cfg(feature = "js")]
+            crate::BackendEngine::Js(_) => Ok(Self::Js(
+                crate::backend::js::entities::module::Module::from_binary_unchecked(
+                    engine, binary,
+                )?,
+            )),
+            #[cfg(feature = "jsc")]
+            crate::BackendEngine::Jsc(_) => Ok(Self::Jsc(
+                crate::backend::jsc::entities::module::Module::from_binary_unchecked(
+                    engine, binary,
+                )?,
+            )),
+        }
+    }
+
+    /// Validates a new WebAssembly Module given the configuration
+    /// in the Store.
+    ///
+    /// This validation is normally pretty fast and checks the enabled
+    /// WebAssembly features in the Store Engine to assure deterministic
+    /// validation of the Module.
+    #[inline]
+    pub fn validate(engine: &impl AsEngineRef, binary: &[u8]) -> Result<(), CompileError> {
+        match engine.as_engine_ref().inner.be {
+            #[cfg(feature = "sys")]
+            crate::BackendEngine::Sys(_) => {
+                crate::backend::sys::entities::module::Module::validate(engine, binary)?
+            }
+            #[cfg(feature = "wamr")]
+            crate::BackendEngine::Wamr(_) => {
+                crate::backend::wamr::entities::module::Module::validate(engine, binary)?
+            }
+
+            #[cfg(feature = "wasmi")]
+            crate::BackendEngine::Wasmi(_) => {
+                crate::backend::wasmi::entities::module::Module::validate(engine, binary)?
+            }
+            #[cfg(feature = "v8")]
+            crate::BackendEngine::V8(_) => {
+                crate::backend::v8::entities::module::Module::validate(engine, binary)?
+            }
+            #[cfg(feature = "js")]
+            crate::BackendEngine::Js(_) => {
+                crate::backend::js::entities::module::Module::validate(engine, binary)?
+            }
+            #[cfg(feature = "jsc")]
+            crate::BackendEngine::Jsc(_) => {
+                crate::backend::jsc::entities::module::Module::validate(engine, binary)?
+            }
+        }
+        Ok(())
+    }
+
+    /// Serializes a module into a binary representation that the `Engine`
+    /// can later process via [`Self::deserialize`].
+    ///
+    /// # Important
+    ///
+    /// This function will return a custom binary format that will be different than
+    /// the `wasm` binary format, but faster to load in Native hosts.
+    ///
+    /// # Usage
+    ///
+    /// ```ignore
+    /// # use wasmer::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
+    /// # let module = Module::from_file(&store, "path/to/foo.wasm")?;
+    /// let serialized = module.serialize()?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[inline]
+    pub fn serialize(&self) -> Result<Bytes, SerializeError> {
+        match_rt!(on self => s {
+            s.serialize()
+        })
+    }
+
+    /// Serializes a module into a file that the `Engine`
+    /// can later process via [`Self::deserialize_from_file`].
+    ///
+    /// # Usage
+    ///
+    /// ```ignore
+    /// # use wasmer::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
+    /// # let module = Module::from_file(&store, "path/to/foo.wasm")?;
+    /// module.serialize_to_file("path/to/foo.so")?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[inline]
+    pub fn serialize_to_file(&self, path: impl AsRef<Path>) -> Result<(), SerializeError> {
+        let serialized = self.serialize()?;
+        fs::write(path, serialized)?;
+        Ok(())
+    }
+
+    /// Deserializes a serialized module binary into a `Module`.
+    ///
+    /// Note: You should usually prefer the safer [`Self::deserialize`].
+    ///
+    /// # Important
+    ///
+    /// This function only accepts a custom binary format, which will be different
+    /// than the `wasm` binary format and may change among Wasmer versions.
+    /// (it should be the result of the serialization of a Module via the
+    /// `Module::serialize` method.).
+    ///
+    /// # Safety
+    ///
+    /// This function is inherently **unsafe** as the provided bytes:
+    /// 1. Are going to be deserialized directly into Rust objects.
+    /// 2. Contains the function assembly bodies and, if intercepted,
+    ///    a malicious actor could inject code into executable
+    ///    memory.
+    ///
+    /// And as such, the `deserialize_unchecked` method is unsafe.
+    ///
+    /// # Usage
+    ///
+    /// ```ignore
+    /// # use wasmer::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
+    /// let module = Module::deserialize_unchecked(&store, serialized_data)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[inline]
+    pub unsafe fn deserialize_unchecked(
+        engine: &impl AsEngineRef,
+        bytes: impl IntoBytes,
+    ) -> Result<Self, DeserializeError> {
+        match engine.as_engine_ref().inner.be {
+            #[cfg(feature = "sys")]
+            crate::BackendEngine::Sys(_) => Ok(Self::Sys(
+                crate::backend::sys::entities::module::Module::deserialize_unchecked(
+                    engine, bytes,
+                )?,
+            )),
+            #[cfg(feature = "wamr")]
+            crate::BackendEngine::Wamr(_) => Ok(Self::Wamr(
+                crate::backend::wamr::entities::module::Module::deserialize_unchecked(
+                    engine, bytes,
+                )?,
+            )),
+
+            #[cfg(feature = "wasmi")]
+            crate::BackendEngine::Wasmi(_) => Ok(Self::Wasmi(
+                crate::backend::wasmi::entities::module::Module::deserialize_unchecked(
+                    engine, bytes,
+                )?,
+            )),
+            #[cfg(feature = "v8")]
+            crate::BackendEngine::V8(_) => Ok(Self::V8(
+                crate::backend::v8::entities::module::Module::deserialize_unchecked(engine, bytes)?,
+            )),
+            #[cfg(feature = "js")]
+            crate::BackendEngine::Js(_) => Ok(Self::Js(
+                crate::backend::js::entities::module::Module::deserialize_unchecked(engine, bytes)?,
+            )),
+            #[cfg(feature = "jsc")]
+            crate::BackendEngine::Jsc(_) => Ok(Self::Jsc(
+                crate::backend::jsc::entities::module::Module::deserialize_unchecked(
+                    engine, bytes,
+                )?,
+            )),
+        }
+    }
+
+    /// Deserializes a serialized Module binary into a `Module`.
+    ///
+    /// # Important
+    ///
+    /// This function only accepts a custom binary format, which will be different
+    /// than the `wasm` binary format and may change among Wasmer versions.
+    /// (it should be the result of the serialization of a Module via the
+    /// [`Self::serialize`] method.).
+    ///
+    /// # Usage
+    ///
+    /// ```ignore
+    /// # use wasmer::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
+    /// let module = Module::deserialize(&store, serialized_data)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// # Safety
+    /// This function is inherently **unsafe**, because it loads executable code
+    /// into memory.
+    /// The loaded bytes must be trusted to contain a valid artifact previously
+    /// built with [`Self::serialize`].
+    #[inline]
+    pub unsafe fn deserialize(
+        engine: &impl AsEngineRef,
+        bytes: impl IntoBytes,
+    ) -> Result<Self, DeserializeError> {
+        match engine.as_engine_ref().inner.be {
+            #[cfg(feature = "sys")]
+            crate::BackendEngine::Sys(_) => Ok(Self::Sys(
+                crate::backend::sys::entities::module::Module::deserialize(engine, bytes)?,
+            )),
+            #[cfg(feature = "wamr")]
+            crate::BackendEngine::Wamr(_) => Ok(Self::Wamr(
+                crate::backend::wamr::entities::module::Module::deserialize(engine, bytes)?,
+            )),
+
+            #[cfg(feature = "wasmi")]
+            crate::BackendEngine::Wasmi(_) => Ok(Self::Wasmi(
+                crate::backend::wasmi::entities::module::Module::deserialize(engine, bytes)?,
+            )),
+            #[cfg(feature = "v8")]
+            crate::BackendEngine::V8(_) => Ok(Self::V8(
+                crate::backend::v8::entities::module::Module::deserialize(engine, bytes)?,
+            )),
+            #[cfg(feature = "js")]
+            crate::BackendEngine::Js(_) => Ok(Self::Js(
+                crate::backend::js::entities::module::Module::deserialize(engine, bytes)?,
+            )),
+            #[cfg(feature = "jsc")]
+            crate::BackendEngine::Jsc(_) => Ok(Self::Jsc(
+                crate::backend::jsc::entities::module::Module::deserialize(engine, bytes)?,
+            )),
+        }
+    }
+
+    /// Deserializes a serialized Module located in a `Path` into a `Module`.
+    /// > Note: the module has to be serialized before with the `serialize` method.
+    ///
+    /// # Usage
+    ///
+    /// ```ignore
+    /// # use wasmer::*;
+    /// # let mut store = Store::default();
+    /// # fn main() -> anyhow::Result<()> {
+    /// let module = Module::deserialize_from_file(&store, path)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// # Safety
+    ///
+    /// See [`Self::deserialize`].
+    #[inline]
+    pub unsafe fn deserialize_from_file(
+        engine: &impl AsEngineRef,
+        path: impl AsRef<Path>,
+    ) -> Result<Self, DeserializeError> {
+        match engine.as_engine_ref().inner.be {
+            #[cfg(feature = "sys")]
+            crate::BackendEngine::Sys(_) => Ok(Self::Sys(
+                crate::backend::sys::entities::module::Module::deserialize_from_file(engine, path)?,
+            )),
+            #[cfg(feature = "wamr")]
+            crate::BackendEngine::Wamr(_) => Ok(Self::Wamr(
+                crate::backend::wamr::entities::module::Module::deserialize_from_file(
+                    engine, path,
+                )?,
+            )),
+
+            #[cfg(feature = "wasmi")]
+            crate::BackendEngine::Wasmi(_) => Ok(Self::Wasmi(
+                crate::backend::wasmi::entities::module::Module::deserialize_from_file(
+                    engine, path,
+                )?,
+            )),
+            #[cfg(feature = "v8")]
+            crate::BackendEngine::V8(_) => Ok(Self::V8(
+                crate::backend::v8::entities::module::Module::deserialize_from_file(engine, path)?,
+            )),
+            #[cfg(feature = "js")]
+            crate::BackendEngine::Js(_) => Ok(Self::Js(
+                crate::backend::js::entities::module::Module::deserialize_from_file(engine, path)?,
+            )),
+            #[cfg(feature = "jsc")]
+            crate::BackendEngine::Jsc(_) => Ok(Self::Jsc(
+                crate::backend::jsc::entities::module::Module::deserialize_from_file(engine, path)?,
+            )),
+        }
+    }
+
+    /// Deserializes a serialized Module located in a `Path` into a `Module`.
+    /// > Note: the module has to be serialized before with the `serialize` method.
+    ///
+    /// You should usually prefer the safer [`Self::deserialize_from_file`].
+    ///
+    /// # Safety
+    ///
+    /// Please check [`Self::deserialize_unchecked`].
+    ///
+    /// # Usage
+    ///
+    /// ```ignore
+    /// # use wasmer::*;
+    /// # let mut store = Store::default();
+    /// # fn main() -> anyhow::Result<()> {
+    /// let module = Module::deserialize_from_file_unchecked(&store, path)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[inline]
+    pub unsafe fn deserialize_from_file_unchecked(
+        engine: &impl AsEngineRef,
+        path: impl AsRef<Path>,
+    ) -> Result<Self, DeserializeError> {
+        match engine.as_engine_ref().inner.be {
+            #[cfg(feature = "sys")]
+            crate::BackendEngine::Sys(_) => Ok(Self::Sys(
+                crate::backend::sys::entities::module::Module::deserialize_from_file_unchecked(
+                    engine, path,
+                )?,
+            )),
+            #[cfg(feature = "wamr")]
+            crate::BackendEngine::Wamr(_) => Ok(Self::Wamr(
+                crate::backend::wamr::entities::module::Module::deserialize_from_file_unchecked(
+                    engine, path,
+                )?,
+            )),
+
+            #[cfg(feature = "wasmi")]
+            crate::BackendEngine::Wasmi(_) => Ok(Self::Wasmi(
+                crate::backend::wasmi::entities::module::Module::deserialize_from_file_unchecked(
+                    engine, path,
+                )?,
+            )),
+            #[cfg(feature = "v8")]
+            crate::BackendEngine::V8(_) => Ok(Self::V8(
+                crate::backend::v8::entities::module::Module::deserialize_from_file_unchecked(
+                    engine, path,
+                )?,
+            )),
+            #[cfg(feature = "js")]
+            crate::BackendEngine::Js(_) => Ok(Self::Js(
+                crate::backend::js::entities::module::Module::deserialize_from_file_unchecked(
+                    engine, path,
+                )?,
+            )),
+            #[cfg(feature = "jsc")]
+            crate::BackendEngine::Jsc(_) => Ok(Self::Jsc(
+                crate::backend::jsc::entities::module::Module::deserialize_from_file_unchecked(
+                    engine, path,
+                )?,
+            )),
+        }
+    }
+
+    /// Returns the name of the current module.
+    ///
+    /// This name is normally set in the WebAssembly bytecode by some
+    /// compilers, but can be also overwritten using the [`Self::set_name`] method.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
+    /// let wat = "(module $moduleName)";
+    /// let module = Module::new(&store, wat)?;
+    /// assert_eq!(module.name(), Some("moduleName"));
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[inline]
+    pub fn name(&self) -> Option<&str> {
+        match_rt!(on self => s {
+            s.name()
+        })
+    }
+
+    /// Sets the name of the current module.
+    /// This is normally useful for stacktraces and debugging.
+    ///
+    /// It will return `true` if the module name was changed successfully,
+    /// and return `false` otherwise (in case the module is cloned or
+    /// already instantiated).
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
+    /// let wat = "(module)";
+    /// let mut module = Module::new(&store, wat)?;
+    /// assert_eq!(module.name(), None);
+    /// module.set_name("foo");
+    /// assert_eq!(module.name(), Some("foo"));
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[inline]
+    pub fn set_name(&mut self, name: &str) -> bool {
+        match_rt!(on self => s {
+            s.set_name(name)
+        })
+    }
+
+    /// Returns an iterator over the imported types in the Module.
+    ///
+    /// The order of the imports is guaranteed to be the same as in the
+    /// WebAssembly bytecode.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
+    /// let wat = r#"(module
+    ///     (import "host" "func1" (func))
+    ///     (import "host" "func2" (func))
+    /// )"#;
+    /// let module = Module::new(&store, wat)?;
+    /// for import in module.imports() {
+    ///     assert_eq!(import.module(), "host");
+    ///     assert!(import.name().contains("func"));
+    ///     import.ty();
+    /// }
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[inline]
+    pub fn imports(&self) -> ImportsIterator<Box<dyn Iterator<Item = ImportType> + '_>> {
+        match_rt!(on self => s {
+            s.imports()
+        })
+    }
+
+    /// Returns an iterator over the exported types in the Module.
+    ///
+    /// The order of the exports is guaranteed to be the same as in the
+    /// WebAssembly bytecode.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
+    /// let wat = r#"(module
+    ///     (func (export "namedfunc"))
+    ///     (memory (export "namedmemory") 1)
+    /// )"#;
+    /// let module = Module::new(&store, wat)?;
+    /// for export_ in module.exports() {
+    ///     assert!(export_.name().contains("named"));
+    ///     export_.ty();
+    /// }
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[inline]
+    pub fn exports(&self) -> ExportsIterator<Box<dyn Iterator<Item = ExportType> + '_>> {
+        match_rt!(on self => s {
+            s.exports()
+        })
+    }
+
+    /// Get the custom sections of the module given a `name`.
+    ///
+    /// # Important
+    ///
+    /// Following the WebAssembly spec, one name can have multiple
+    /// custom sections. That's why an iterator (rather than one element)
+    /// is returned.
+    #[inline]
+    pub fn custom_sections<'a>(&'a self, name: &'a str) -> impl Iterator<Item = Box<[u8]>> + 'a {
+        match_rt!(on self => s {
+            s.custom_sections(name)
+        })
+    }
+
+    /// The ABI of the [`ModuleInfo`] is very unstable, we refactor it very often.
+    /// This function is public because in some cases it can be useful to get some
+    /// extra information from the module.
+    ///
+    /// However, the usage is highly discouraged.
+    #[doc(hidden)]
+    #[inline]
+    pub fn info(&self) -> &ModuleInfo {
+        match_rt!(on self => s {
+            s.info()
+        })
+    }
+}
+
+impl std::fmt::Debug for BackendModule {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("BackendModule")
+            .field("name", &self.name())
+            .finish()
+    }
+}
diff --git a/lib/api/src/module.rs b/lib/api/src/entities/module/mod.rs
similarity index 85%
rename from lib/api/src/module.rs
rename to lib/api/src/entities/module/mod.rs
index 52bf98ae30..1162d03172 100644
--- a/lib/api/src/module.rs
+++ b/lib/api/src/entities/module/mod.rs
@@ -1,33 +1,28 @@
-use bytes::Bytes;
-use std::fmt;
-use std::fs;
-use std::io;
-use std::path::Path;
+//! Defines the [`Module`] data type and various useful traits and data types to interact with a
+//! module.
+
+pub(crate) mod inner;
+pub(crate) use inner::*;
 
-use crate::engine::AsEngineRef;
+use std::{fs, path::Path};
+
+use bytes::Bytes;
 use thiserror::Error;
 #[cfg(feature = "wat")]
 use wasmer_types::WasmError;
 use wasmer_types::{
-    CompileError, DeserializeError, ExportsIterator, ImportsIterator, ModuleInfo, SerializeError,
+    CompileError, DeserializeError, ExportType, ExportsIterator, ImportType, ImportsIterator,
+    ModuleInfo, SerializeError,
 };
-use wasmer_types::{ExportType, ImportType};
 
-use crate::into_bytes::IntoBytes;
+use crate::{macros::backend::match_rt, utils::IntoBytes, AsEngineRef};
 
-#[cfg(feature = "js")]
-use crate::js::module as module_imp;
-#[cfg(feature = "jsc")]
-use crate::jsc::module as module_imp;
-#[cfg(feature = "sys")]
-use crate::sys::module as module_imp;
-
-/// IO Error on a Module Compilation
+/// IO errors that can happen while compiling a [`Module`].
 #[derive(Error, Debug)]
 pub enum IoCompileError {
     /// An IO error
     #[error(transparent)]
-    Io(#[from] io::Error),
+    Io(#[from] std::io::Error),
     /// A compilation error
     #[error(transparent)]
     Compile(#[from] CompileError),
@@ -41,8 +36,9 @@ pub enum IoCompileError {
 ///
 /// Cloning a module is cheap: it does a shallow copy of the compiled
 /// contents rather than a deep copy.
-#[derive(Clone, PartialEq, Eq)]
-pub struct Module(pub(crate) module_imp::Module);
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[derive(Clone, PartialEq, Eq, derive_more::From)]
+pub struct Module(pub(crate) BackendModule);
 
 impl Module {
     /// Creates a new WebAssembly Module given the configuration
@@ -109,19 +105,12 @@ impl Module {
     /// ```
     /// # use wasmer::*;
     /// #
-    /// # let engine: Engine = Cranelift::default().into();
+    /// # let engine: Engine = Engine::default().into();
     ///
     /// let module = Module::from_file(&engine, "path/to/foo.wasm");
     /// ```
     pub fn new(engine: &impl AsEngineRef, bytes: impl AsRef<[u8]>) -> Result<Self, CompileError> {
-        #[cfg(feature = "wat")]
-        let bytes = wat::parse_bytes(bytes.as_ref()).map_err(|e| {
-            CompileError::Wasm(WasmError::Generic(format!(
-                "Error when converting wat: {}",
-                e
-            )))
-        })?;
-        Self::from_binary(engine, bytes.as_ref())
+        BackendModule::new(engine, bytes).map(Self)
     }
 
     /// Creates a new WebAssembly module from a file path.
@@ -129,15 +118,7 @@ impl Module {
         engine: &impl AsEngineRef,
         file: impl AsRef<Path>,
     ) -> Result<Self, IoCompileError> {
-        let file_ref = file.as_ref();
-        let canonical = file_ref.canonicalize()?;
-        let wasm_bytes = std::fs::read(file_ref)?;
-        let mut module = Self::new(engine, wasm_bytes)?;
-        // Set the module name to the absolute path of the filename.
-        // This is useful for debugging the stack traces.
-        let filename = canonical.as_path().to_str().unwrap();
-        module.set_name(filename);
-        Ok(module)
+        BackendModule::from_file(engine, file).map(Self)
     }
 
     /// Creates a new WebAssembly module from a Wasm binary.
@@ -146,7 +127,7 @@ impl Module {
     /// the WebAssembly text format (if the "wat" feature is enabled for
     /// this crate).
     pub fn from_binary(engine: &impl AsEngineRef, binary: &[u8]) -> Result<Self, CompileError> {
-        Ok(Self(module_imp::Module::from_binary(engine, binary)?))
+        BackendModule::from_binary(engine, binary).map(Self)
     }
 
     /// Creates a new WebAssembly module from a Wasm binary,
@@ -161,9 +142,7 @@ impl Module {
         engine: &impl AsEngineRef,
         binary: &[u8],
     ) -> Result<Self, CompileError> {
-        Ok(Self(module_imp::Module::from_binary_unchecked(
-            engine, binary,
-        )?))
+        BackendModule::from_binary_unchecked(engine, binary).map(Self)
     }
 
     /// Validates a new WebAssembly Module given the configuration
@@ -173,7 +152,8 @@ impl Module {
     /// WebAssembly features in the Store Engine to assure deterministic
     /// validation of the Module.
     pub fn validate(engine: &impl AsEngineRef, binary: &[u8]) -> Result<(), CompileError> {
-        module_imp::Module::validate(engine, binary)
+        BackendModule::validate(engine, binary)?;
+        Ok(())
     }
 
     /// Serializes a module into a binary representation that the `Engine`
@@ -214,7 +194,7 @@ impl Module {
     /// # }
     /// ```
     pub fn serialize_to_file(&self, path: impl AsRef<Path>) -> Result<(), SerializeError> {
-        let serialized = self.0.serialize()?;
+        let serialized = self.serialize()?;
         fs::write(path, serialized)?;
         Ok(())
     }
@@ -254,9 +234,7 @@ impl Module {
         engine: &impl AsEngineRef,
         bytes: impl IntoBytes,
     ) -> Result<Self, DeserializeError> {
-        Ok(Self(module_imp::Module::deserialize_unchecked(
-            engine, bytes,
-        )?))
+        BackendModule::deserialize_unchecked(engine, bytes).map(Self)
     }
 
     /// Deserializes a serialized Module binary into a `Module`.
@@ -288,7 +266,7 @@ impl Module {
         engine: &impl AsEngineRef,
         bytes: impl IntoBytes,
     ) -> Result<Self, DeserializeError> {
-        Ok(Self(module_imp::Module::deserialize(engine, bytes)?))
+        BackendModule::deserialize_unchecked(engine, bytes).map(Self)
     }
 
     /// Deserializes a serialized Module located in a `Path` into a `Module`.
@@ -312,9 +290,7 @@ impl Module {
         engine: &impl AsEngineRef,
         path: impl AsRef<Path>,
     ) -> Result<Self, DeserializeError> {
-        Ok(Self(module_imp::Module::deserialize_from_file(
-            engine, path,
-        )?))
+        BackendModule::deserialize_from_file(engine, path).map(Self)
     }
 
     /// Deserializes a serialized Module located in a `Path` into a `Module`.
@@ -340,9 +316,7 @@ impl Module {
         engine: &impl AsEngineRef,
         path: impl AsRef<Path>,
     ) -> Result<Self, DeserializeError> {
-        Ok(Self(module_imp::Module::deserialize_from_file_unchecked(
-            engine, path,
-        )?))
+        BackendModule::deserialize_from_file_unchecked(engine, path).map(Self)
     }
 
     /// Returns the name of the current module.
@@ -415,7 +389,7 @@ impl Module {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn imports(&self) -> ImportsIterator<impl Iterator<Item = ImportType> + '_> {
+    pub fn imports(&self) -> ImportsIterator<Box<dyn Iterator<Item = ImportType> + '_>> {
         self.0.imports()
     }
 
@@ -442,7 +416,7 @@ impl Module {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn exports(&self) -> ExportsIterator<impl Iterator<Item = ExportType> + '_> {
+    pub fn exports(&self) -> ExportsIterator<Box<dyn Iterator<Item = ExportType> + '_>> {
         self.0.exports()
     }
 
@@ -468,8 +442,8 @@ impl Module {
     }
 }
 
-impl fmt::Debug for Module {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl std::fmt::Debug for Module {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("Module")
             .field("name", &self.name())
             .finish()
@@ -479,6 +453,9 @@ impl fmt::Debug for Module {
 #[cfg(feature = "js")]
 impl From<Module> for wasm_bindgen::JsValue {
     fn from(value: Module) -> Self {
-        wasm_bindgen::JsValue::from(value.0)
+        match value.0 {
+            BackendModule::Js(module) => Self::from(module),
+            _ => unreachable!(),
+        }
     }
 }
diff --git a/lib/api/src/entities/store/inner.rs b/lib/api/src/entities/store/inner.rs
new file mode 100644
index 0000000000..c41bdbf7a8
--- /dev/null
+++ b/lib/api/src/entities/store/inner.rs
@@ -0,0 +1,66 @@
+use crate::{
+    entities::{
+        engine::{AsEngineRef, Engine},
+        store::{StoreMut, StoreObjects},
+    },
+    macros::backend::{gen_rt_ty, match_rt},
+    AsStoreMut,
+};
+
+#[cfg(feature = "sys")]
+use wasmer_vm::TrapHandlerFn;
+
+/// We require the context to have a fixed memory address for its lifetime since
+/// various bits of the VM have raw pointers that point back to it. Hence we
+/// wrap the actual context in a box.
+pub(crate) struct StoreInner {
+    pub(crate) objects: StoreObjects,
+    pub(crate) store: BackendStore,
+    pub(crate) on_called: Option<OnCalledHandler>,
+}
+
+impl std::fmt::Debug for StoreInner {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("StoreInner")
+            .field("objects", &self.objects)
+            .field("store", &self.store)
+            .field("on_called", &"<...>")
+            .finish()
+    }
+}
+
+/// Call handler for a store.
+// TODO: better documentation!
+pub type OnCalledHandler = Box<
+    dyn FnOnce(
+        StoreMut<'_>,
+    )
+        -> Result<wasmer_types::OnCalledAction, Box<dyn std::error::Error + Send + Sync>>,
+>;
+
+gen_rt_ty!(Store @derives derive_more::From, Debug; @path store);
+
+impl BackendStore {
+    #[inline]
+    pub(crate) fn engine(&self) -> &Engine {
+        match_rt!(on self => s {
+            s.engine()
+        })
+    }
+
+    #[inline]
+    pub(crate) fn engine_mut(&mut self) -> &mut Engine {
+        match_rt!(on self => s {
+            s.engine_mut()
+        })
+    }
+}
+
+impl AsEngineRef for BackendStore {
+    #[inline]
+    fn as_engine_ref(&self) -> crate::EngineRef<'_> {
+        match_rt!(on self => s {
+            s.as_engine_ref()
+        })
+    }
+}
diff --git a/lib/api/src/entities/store/mod.rs b/lib/api/src/entities/store/mod.rs
new file mode 100644
index 0000000000..cc403861f4
--- /dev/null
+++ b/lib/api/src/entities/store/mod.rs
@@ -0,0 +1,161 @@
+//! Defines the [`Store`] data type and various useful traits and data types to interact with a
+//! store.
+
+/// Defines the [`StoreInner`] data type.
+mod inner;
+
+/// Create temporary handles to engines.
+mod store_ref;
+pub use store_ref::*;
+
+mod obj;
+pub use obj::*;
+
+use crate::{AsEngineRef, BackendEngine, Engine, EngineRef};
+pub(crate) use inner::*;
+use wasmer_types::StoreId;
+
+#[cfg(feature = "sys")]
+use wasmer_vm::TrapHandlerFn;
+
+/// The store represents all global state that can be manipulated by
+/// WebAssembly programs. It consists of the runtime representation
+/// of all instances of functions, tables, memories, and globals that
+/// have been allocated during the lifetime of the abstract machine.
+///
+/// The [`Store`] is tied to the underlying [`Engine`] that is — among many things — used to
+/// compile the Wasm bytes into a valid module artifact.
+///
+/// For more informations, check out the [related WebAssembly specification]
+/// [related WebAssembly specification]: <https://webassembly.github.io/spec/core/exec/runtime.html#store>
+pub struct Store {
+    pub(crate) inner: Box<StoreInner>,
+}
+
+impl Store {
+    /// Creates a new `Store` with a specific [`Engine`].
+    pub fn new(engine: impl Into<Engine>) -> Self {
+        let engine: Engine = engine.into();
+
+        let store = match engine.be {
+            #[cfg(feature = "sys")]
+            BackendEngine::Sys(_) => {
+                BackendStore::Sys(crate::backend::sys::entities::store::Store::new(engine))
+            }
+            #[cfg(feature = "wamr")]
+            BackendEngine::Wamr(_) => {
+                BackendStore::Wamr(crate::backend::wamr::entities::store::Store::new(engine))
+            }
+            #[cfg(feature = "wasmi")]
+            BackendEngine::Wasmi(_) => {
+                BackendStore::Wasmi(crate::backend::wasmi::entities::store::Store::new(engine))
+            }
+            #[cfg(feature = "v8")]
+            BackendEngine::V8(_) => {
+                BackendStore::V8(crate::backend::v8::entities::store::Store::new(engine))
+            }
+            #[cfg(feature = "js")]
+            BackendEngine::Js(_) => {
+                BackendStore::Js(crate::backend::js::entities::store::Store::new(engine))
+            }
+            #[cfg(feature = "jsc")]
+            BackendEngine::Jsc(_) => {
+                BackendStore::Jsc(crate::backend::jsc::entities::store::Store::new(engine))
+            }
+        };
+
+        Self {
+            inner: Box::new(StoreInner {
+                objects: StoreObjects::from_store_ref(&store),
+                on_called: None,
+                store,
+            }),
+        }
+    }
+
+    #[cfg(feature = "sys")]
+    /// Set the [`TrapHandlerFn`] for this store.
+    ///
+    /// # Note
+    ///
+    /// Not every implementor allows changing the trap handler. In those store that
+    /// don't allow it, this function has no effect.
+    pub fn set_trap_handler(&mut self, handler: Option<Box<TrapHandlerFn<'static>>>) {
+        use crate::backend::sys::entities::store::NativeStoreExt;
+        #[allow(irrefutable_let_patterns)]
+        if let BackendStore::Sys(ref mut s) = self.inner.store {
+            s.set_trap_handler(handler)
+        }
+    }
+
+    /// Returns the [`Engine`].
+    pub fn engine(&self) -> &Engine {
+        self.inner.store.engine()
+    }
+
+    /// Returns mutable reference to [`Engine`].
+    pub fn engine_mut(&mut self) -> &mut Engine {
+        self.inner.store.engine_mut()
+    }
+
+    /// Checks whether two stores are identical. A store is considered
+    /// equal to another store if both have the same engine.
+    pub fn same(a: &Self, b: &Self) -> bool {
+        a.id() == b.id()
+    }
+
+    /// Returns the ID of this store
+    pub fn id(&self) -> StoreId {
+        self.inner.objects.id()
+    }
+}
+
+impl PartialEq for Store {
+    fn eq(&self, other: &Self) -> bool {
+        Self::same(self, other)
+    }
+}
+
+// This is required to be able to set the trap_handler in the
+// Store.
+unsafe impl Send for Store {}
+unsafe impl Sync for Store {}
+
+impl Default for Store {
+    fn default() -> Self {
+        Self::new(Engine::default())
+    }
+}
+
+impl std::fmt::Debug for Store {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("Store").finish()
+    }
+}
+
+impl AsEngineRef for Store {
+    fn as_engine_ref(&self) -> EngineRef<'_> {
+        self.inner.store.as_engine_ref()
+    }
+
+    fn maybe_as_store(&self) -> Option<StoreRef<'_>> {
+        Some(self.as_store_ref())
+    }
+}
+
+impl AsStoreRef for Store {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        StoreRef { inner: &self.inner }
+    }
+}
+impl AsStoreMut for Store {
+    fn as_store_mut(&mut self) -> StoreMut<'_> {
+        StoreMut {
+            inner: &mut self.inner,
+        }
+    }
+
+    fn objects_mut(&mut self) -> &mut StoreObjects {
+        &mut self.inner.objects
+    }
+}
diff --git a/lib/api/src/entities/store/obj.rs b/lib/api/src/entities/store/obj.rs
new file mode 100644
index 0000000000..8fa28ed5fe
--- /dev/null
+++ b/lib/api/src/entities/store/obj.rs
@@ -0,0 +1,102 @@
+use wasmer_types::StoreId;
+
+use crate::{macros::backend::match_rt, BackendStore};
+
+/// Set of objects managed by a context.
+#[derive(Debug)]
+pub enum StoreObjects {
+    #[cfg(feature = "sys")]
+    /// Store objects for the `sys` runtime.
+    Sys(crate::backend::sys::store::StoreObjects),
+
+    #[cfg(feature = "wamr")]
+    /// Store objects for the `wamr` runtime.
+    Wamr(crate::backend::wamr::store::StoreObjects),
+
+    #[cfg(feature = "wasmi")]
+    /// Store objects for the `wasmi` runtime.
+    Wasmi(crate::backend::wasmi::store::StoreObjects),
+
+    #[cfg(feature = "v8")]
+    /// Store objects for the `v8` runtime.
+    V8(crate::backend::v8::store::StoreObjects),
+
+    #[cfg(feature = "js")]
+    /// Store objects for the `js` runtime.
+    Js(crate::backend::js::store::StoreObjects),
+
+    #[cfg(feature = "jsc")]
+    /// Store objects for the `jsc` runtime.
+    Jsc(crate::backend::jsc::store::StoreObjects),
+}
+
+impl StoreObjects {
+    /// Checks whether two stores are identical. A store is considered
+    /// equal to another store if both have the same engine.
+    #[inline]
+    pub fn same(a: &Self, b: &Self) -> bool {
+        match (a, b) {
+            #[cfg(feature = "sys")]
+            (Self::Sys(ref a), Self::Sys(ref b)) => a.id() == b.id(),
+            #[cfg(feature = "wamr")]
+            (Self::Wamr(ref a), Self::Wamr(ref b)) => a.id() == b.id(),
+            #[cfg(feature = "v8")]
+            (Self::V8(ref a), Self::V8(ref b)) => a.id() == b.id(),
+            #[cfg(feature = "js")]
+            (Self::Js(ref a), Self::Js(ref b)) => a.id() == b.id(),
+
+            #[cfg(feature = "jsc")]
+            (Self::Jsc(ref a), Self::Jsc(ref b)) => a.id() == b.id(),
+
+            _ => panic!(
+                "Incompatible `StoreObjects` instance: {}, {}!",
+                a.id(),
+                b.id()
+            ),
+        }
+    }
+
+    /// Returns the ID of this store
+    #[inline]
+    pub fn id(&self) -> StoreId {
+        match_rt!(on self => s {
+            s.id()
+        })
+    }
+
+    #[inline]
+    pub(crate) fn from_store_ref(store: &BackendStore) -> Self {
+        match store {
+            #[cfg(feature = "sys")]
+            BackendStore::Sys(_) => Self::Sys(Default::default()),
+            #[cfg(feature = "wamr")]
+            BackendStore::Wamr(_) => Self::Wamr(Default::default()),
+            #[cfg(feature = "wasmi")]
+            BackendStore::Wasmi(_) => Self::Wasmi(Default::default()),
+            #[cfg(feature = "v8")]
+            BackendStore::V8(_) => Self::V8(Default::default()),
+            #[cfg(feature = "js")]
+            BackendStore::Js(_) => Self::Js(Default::default()),
+            #[cfg(feature = "jsc")]
+            BackendStore::Jsc(_) => Self::Jsc(Default::default()),
+        }
+    }
+
+    /// Return a vector of all globals and converted to u128
+    #[inline]
+    pub fn as_u128_globals(&self) -> Vec<u128> {
+        match_rt!(on self => s {
+            s.as_u128_globals()
+        })
+    }
+
+    /// Set a global, at index idx. Will panic if idx is out of range
+    /// Safety: the caller should check taht the raw value is compatible
+    /// with destination VMGlobal type
+    #[inline]
+    pub fn set_global_unchecked(&self, idx: usize, val: u128) {
+        match_rt!(on self => s {
+            s.set_global_unchecked(idx, val)
+        })
+    }
+}
diff --git a/lib/api/src/entities/store/store_ref.rs b/lib/api/src/entities/store/store_ref.rs
new file mode 100644
index 0000000000..1dae7b5ead
--- /dev/null
+++ b/lib/api/src/entities/store/store_ref.rs
@@ -0,0 +1,157 @@
+use std::ops::{Deref, DerefMut};
+
+use super::{inner::StoreInner, StoreObjects};
+use crate::entities::engine::{AsEngineRef, Engine, EngineRef};
+use wasmer_types::{ExternType, OnCalledAction};
+//use wasmer_vm::{StoreObjects, TrapHandlerFn};
+
+#[cfg(feature = "sys")]
+use wasmer_vm::TrapHandlerFn;
+
+/// A temporary handle to a [`crate::Store`].
+#[derive(Debug)]
+pub struct StoreRef<'a> {
+    pub(crate) inner: &'a StoreInner,
+}
+
+impl<'a> StoreRef<'a> {
+    pub(crate) fn objects(&self) -> &'a StoreObjects {
+        &self.inner.objects
+    }
+
+    /// Returns the [`Engine`].
+    pub fn engine(&self) -> &Engine {
+        self.inner.store.engine()
+    }
+
+    /// Checks whether two stores are identical. A store is considered
+    /// equal to another store if both have the same engine.
+    pub fn same(a: &Self, b: &Self) -> bool {
+        StoreObjects::same(&a.inner.objects, &b.inner.objects)
+    }
+
+    /// The signal handler
+    #[cfg(feature = "sys")]
+    #[inline]
+    pub fn signal_handler(&self) -> Option<*const TrapHandlerFn<'static>> {
+        use crate::backend::sys::entities::store::NativeStoreExt;
+        self.inner.store.as_sys().signal_handler()
+    }
+}
+
+/// A temporary handle to a [`crate::Store`].
+pub struct StoreMut<'a> {
+    pub(crate) inner: &'a mut StoreInner,
+}
+
+impl StoreMut<'_> {
+    /// Returns the [`Engine`].
+    pub fn engine(&self) -> &Engine {
+        self.inner.store.engine()
+    }
+
+    /// Checks whether two stores are identical. A store is considered
+    /// equal to another store if both have the same engine.
+    pub fn same(a: &Self, b: &Self) -> bool {
+        StoreObjects::same(&a.inner.objects, &b.inner.objects)
+    }
+
+    #[allow(unused)]
+    pub(crate) fn as_raw(&self) -> *mut StoreInner {
+        self.inner as *const StoreInner as *mut StoreInner
+    }
+
+    #[allow(unused)]
+    pub(crate) unsafe fn from_raw(raw: *mut StoreInner) -> Self {
+        Self { inner: &mut *raw }
+    }
+
+    #[allow(unused)]
+    pub(crate) fn engine_and_objects_mut(&mut self) -> (&Engine, &mut StoreObjects) {
+        (self.inner.store.engine(), &mut self.inner.objects)
+    }
+
+    // TODO: OnCalledAction is needed for asyncify. It will be refactored with https://github.com/wasmerio/wasmer/issues/3451
+    /// Sets the unwind callback which will be invoked when the call finishes
+    pub fn on_called<F>(&mut self, callback: F)
+    where
+        F: FnOnce(StoreMut<'_>) -> Result<OnCalledAction, Box<dyn std::error::Error + Send + Sync>>
+            + Send
+            + Sync
+            + 'static,
+    {
+        self.inner.on_called.replace(Box::new(callback));
+    }
+}
+
+/// Helper trait for a value that is convertible to a [`StoreRef`].
+pub trait AsStoreRef {
+    /// Returns a `StoreRef` pointing to the underlying context.
+    fn as_store_ref(&self) -> StoreRef<'_>;
+}
+
+/// Helper trait for a value that is convertible to a [`StoreMut`].
+pub trait AsStoreMut: AsStoreRef {
+    /// Returns a `StoreMut` pointing to the underlying context.
+    fn as_store_mut(&mut self) -> StoreMut<'_>;
+
+    /// Returns the ObjectMutable
+    fn objects_mut(&mut self) -> &mut StoreObjects;
+}
+
+impl AsStoreRef for StoreRef<'_> {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        StoreRef { inner: self.inner }
+    }
+}
+
+impl AsEngineRef for StoreRef<'_> {
+    fn as_engine_ref(&self) -> EngineRef<'_> {
+        self.inner.store.as_engine_ref()
+    }
+}
+
+impl AsStoreRef for StoreMut<'_> {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        StoreRef { inner: self.inner }
+    }
+}
+impl AsStoreMut for StoreMut<'_> {
+    fn as_store_mut(&mut self) -> StoreMut<'_> {
+        StoreMut { inner: self.inner }
+    }
+
+    fn objects_mut(&mut self) -> &mut StoreObjects {
+        &mut self.inner.objects
+    }
+}
+
+impl<P> AsStoreRef for P
+where
+    P: Deref,
+    P::Target: AsStoreRef,
+{
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        (**self).as_store_ref()
+    }
+}
+
+impl<P> AsStoreMut for P
+where
+    P: DerefMut,
+    P::Target: AsStoreMut,
+{
+    fn as_store_mut(&mut self) -> StoreMut<'_> {
+        (**self).as_store_mut()
+    }
+
+    fn objects_mut(&mut self) -> &mut StoreObjects {
+        (**self).objects_mut()
+    }
+}
+
+impl AsEngineRef for StoreMut<'_> {
+    fn as_engine_ref(&self) -> EngineRef<'_> {
+        self.inner.store.as_engine_ref()
+    }
+}
diff --git a/lib/api/src/entities/table/inner.rs b/lib/api/src/entities/table/inner.rs
new file mode 100644
index 0000000000..5cbe35b893
--- /dev/null
+++ b/lib/api/src/entities/table/inner.rs
@@ -0,0 +1,272 @@
+use wasmer_types::TableType;
+
+use crate::{
+    error::RuntimeError,
+    macros::backend::{gen_rt_ty, match_rt},
+    store::BackendStore,
+    vm::{VMExtern, VMExternTable},
+    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, StoreMut, StoreRef, Value,
+};
+/// A WebAssembly `table` instance.
+///
+/// The `Table` struct is an array-like structure representing a WebAssembly Table,
+/// which stores function references.
+///
+/// A table created by the host or in WebAssembly code will be accessible and
+/// mutable from both host and WebAssembly.
+///
+/// Spec: <https://webassembly.github.io/spec/core/exec/runtime.html#table-instances>
+gen_rt_ty!(Table
+    @cfg feature = "artifact-size" => derive(loupe::MemoryUsage)
+    @derives Debug, Clone, PartialEq, Eq, derive_more::From
+);
+
+impl BackendTable {
+    /// Creates a new table with the provided [`TableType`] definition.
+    ///
+    /// All the elements in the table will be set to the `init` value.
+    ///
+    /// This function will construct the table using the store `BaseTunables`.
+    #[inline]
+    pub fn new(
+        store: &mut impl AsStoreMut,
+        ty: TableType,
+        init: Value,
+    ) -> Result<Self, RuntimeError> {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            BackendStore::Sys(_) => Ok(Self::Sys(
+                crate::backend::sys::entities::table::Table::new(store, ty, init)?,
+            )),
+            #[cfg(feature = "wamr")]
+            BackendStore::Wamr(_) => Ok(Self::Wamr(
+                crate::backend::wamr::entities::table::Table::new(store, ty, init)?,
+            )),
+            #[cfg(feature = "wasmi")]
+            BackendStore::Wasmi(_) => Ok(Self::Wasmi(
+                crate::backend::wasmi::entities::table::Table::new(store, ty, init)?,
+            )),
+            #[cfg(feature = "v8")]
+            BackendStore::V8(_) => Ok(Self::V8(crate::backend::v8::entities::table::Table::new(
+                store, ty, init,
+            )?)),
+            #[cfg(feature = "js")]
+            BackendStore::Js(_) => Ok(Self::Js(crate::backend::js::entities::table::Table::new(
+                store, ty, init,
+            )?)),
+            #[cfg(feature = "jsc")]
+            BackendStore::Jsc(_) => Ok(Self::Jsc(
+                crate::backend::jsc::entities::table::Table::new(store, ty, init)?,
+            )),
+        }
+    }
+
+    /// Returns the [`TableType`] of the table.
+    #[inline]
+    pub fn ty(&self, store: &impl AsStoreRef) -> TableType {
+        match_rt!(on self => s {
+            s.ty(store)
+        })
+    }
+
+    /// Retrieves an element of the table at the provided `index`.
+    #[inline]
+    pub fn get(&self, store: &mut impl AsStoreMut, index: u32) -> Option<Value> {
+        match_rt!(on self => s {
+            s.get(store, index)
+        })
+    }
+
+    /// Sets an element `val` in the Table at the provided `index`.
+    #[inline]
+    pub fn set(
+        &self,
+        store: &mut impl AsStoreMut,
+        index: u32,
+        val: Value,
+    ) -> Result<(), RuntimeError> {
+        match_rt!(on self => s {
+            s.set(store, index, val)
+        })
+    }
+
+    /// Retrieves the size of the `Table` (in elements)
+    #[inline]
+    pub fn size(&self, store: &impl AsStoreRef) -> u32 {
+        match_rt!(on self => s {
+            s.size(store)
+        })
+    }
+
+    /// Grows the size of the `Table` by `delta`, initializating
+    /// the elements with the provided `init` value.
+    ///
+    /// It returns the previous size of the `Table` in case is able
+    /// to grow the Table successfully.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the `delta` is out of bounds for the table.
+    #[inline]
+    pub fn grow(
+        &self,
+        store: &mut impl AsStoreMut,
+        delta: u32,
+        init: Value,
+    ) -> Result<u32, RuntimeError> {
+        match_rt!(on self => s {
+            s.grow(store, delta, init)
+        })
+    }
+
+    /// Copies the `len` elements of `src_table` starting at `src_index`
+    /// to the destination table `dst_table` at index `dst_index`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the range is out of bounds of either the source or
+    /// destination tables.
+    #[inline]
+    pub fn copy(
+        store: &mut impl AsStoreMut,
+        dst_table: &Self,
+        dst_index: u32,
+        src_table: &Self,
+        src_index: u32,
+        len: u32,
+    ) -> Result<(), RuntimeError> {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            BackendStore::Sys(_) => crate::backend::sys::entities::table::Table::copy(
+                store,
+                dst_table.as_sys(),
+                dst_index,
+                src_table.as_sys(),
+                src_index,
+                len,
+            ),
+            #[cfg(feature = "wamr")]
+            BackendStore::Wamr(_) => crate::backend::wamr::entities::table::Table::copy(
+                store,
+                dst_table.as_wamr(),
+                dst_index,
+                src_table.as_wamr(),
+                src_index,
+                len,
+            ),
+            #[cfg(feature = "wasmi")]
+            BackendStore::Wasmi(_) => crate::backend::wasmi::entities::table::Table::copy(
+                store,
+                dst_table.as_wasmi(),
+                dst_index,
+                src_table.as_wasmi(),
+                src_index,
+                len,
+            ),
+
+            #[cfg(feature = "v8")]
+            BackendStore::V8(_) => crate::backend::v8::entities::table::Table::copy(
+                store,
+                dst_table.as_v8(),
+                dst_index,
+                src_table.as_v8(),
+                src_index,
+                len,
+            ),
+            #[cfg(feature = "js")]
+            BackendStore::Js(_) => crate::backend::js::entities::table::Table::copy(
+                store,
+                dst_table.as_js(),
+                dst_index,
+                src_table.as_js(),
+                src_index,
+                len,
+            ),
+            #[cfg(feature = "jsc")]
+            BackendStore::Jsc(_) => crate::backend::jsc::entities::table::Table::copy(
+                store,
+                dst_table.as_jsc(),
+                dst_index,
+                src_table.as_jsc(),
+                src_index,
+                len,
+            ),
+        }
+    }
+
+    #[inline]
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, ext: VMExternTable) -> Self {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            BackendStore::Sys(_) => Self::Sys(
+                crate::backend::sys::entities::table::Table::from_vm_extern(store, ext),
+            ),
+            #[cfg(feature = "wamr")]
+            BackendStore::Wamr(_) => {
+                Self::Wamr(crate::backend::wamr::entities::table::Table::from_vm_extern(store, ext))
+            }
+            #[cfg(feature = "wasmi")]
+            BackendStore::Wasmi(_) => Self::Wasmi(
+                crate::backend::wasmi::entities::table::Table::from_vm_extern(store, ext),
+            ),
+            #[cfg(feature = "v8")]
+            BackendStore::V8(_) => Self::V8(
+                crate::backend::v8::entities::table::Table::from_vm_extern(store, ext),
+            ),
+            #[cfg(feature = "js")]
+            BackendStore::Js(_) => Self::Js(
+                crate::backend::js::entities::table::Table::from_vm_extern(store, ext),
+            ),
+            #[cfg(feature = "jsc")]
+            BackendStore::Jsc(_) => Self::Jsc(
+                crate::backend::jsc::entities::table::Table::from_vm_extern(store, ext),
+            ),
+        }
+    }
+
+    /// Checks whether this `Table` can be used with the given context.
+    #[inline]
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        match_rt!(on self => s {
+            s.is_from_store(store)
+        })
+    }
+
+    #[inline]
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        match_rt!(on self => s {
+            s.to_vm_extern()
+        })
+    }
+}
+
+#[cfg(test)]
+mod test {
+    /// Check the example from <https://github.com/wasmerio/wasmer/issues/3197>.
+    #[test]
+    #[cfg_attr(
+        feature = "wamr",
+        ignore = "wamr does not support direct calls to grow table"
+    )]
+    #[cfg_attr(feature = "wasmi", ignore = "wasmi does not support funcrefs")]
+    #[cfg_attr(
+        feature = "v8",
+        ignore = "growing tables in v8 is not currently supported"
+    )]
+    fn table_grow_issue_3197() {
+        use crate::{imports, Instance, Module, Store, Table, TableType, Type, Value};
+
+        const WAT: &str = r#"(module (table (import "env" "table") 100 funcref))"#;
+
+        // Tests that the table type of `table` is compatible with the export in the WAT
+        // This tests that `wasmer_types::types::is_table_compatible` works as expected.
+        let mut store = Store::default();
+        let module = Module::new(&store, WAT).unwrap();
+        let ty = TableType::new(Type::FuncRef, 0, None);
+        let table = Table::new(&mut store, ty, Value::FuncRef(None)).unwrap();
+        table.grow(&mut store, 100, Value::FuncRef(None)).unwrap();
+        assert_eq!(table.ty(&store).minimum, 0);
+        let imports = imports! {"env" => {"table" => table}};
+        let _instance = Instance::new(&mut store, &module, &imports).unwrap();
+    }
+}
diff --git a/lib/api/src/externals/table.rs b/lib/api/src/entities/table/mod.rs
similarity index 55%
rename from lib/api/src/externals/table.rs
rename to lib/api/src/entities/table/mod.rs
index 49eb38924f..0ee1934df6 100644
--- a/lib/api/src/externals/table.rs
+++ b/lib/api/src/entities/table/mod.rs
@@ -1,17 +1,14 @@
-#[cfg(feature = "js")]
-use crate::js::externals::table as table_impl;
-#[cfg(feature = "jsc")]
-use crate::jsc::externals::table as table_impl;
-#[cfg(feature = "sys")]
-use crate::sys::externals::table as table_impl;
-
-use crate::exports::{ExportError, Exportable};
-use crate::store::{AsStoreMut, AsStoreRef};
-use crate::vm::{VMExtern, VMExternTable};
-use crate::Extern;
-use crate::RuntimeError;
-use crate::TableType;
-use crate::Value;
+use wasmer_types::TableType;
+
+pub(crate) mod inner;
+pub(crate) use inner::*;
+
+use crate::{
+    error::RuntimeError,
+    store::BackendStore,
+    vm::{VMExtern, VMExternTable},
+    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern, StoreMut, StoreRef, Value,
+};
 
 /// A WebAssembly `table` instance.
 ///
@@ -22,24 +19,25 @@ use crate::Value;
 /// mutable from both host and WebAssembly.
 ///
 /// Spec: <https://webassembly.github.io/spec/core/exec/runtime.html#table-instances>
-#[derive(Debug, Clone, PartialEq)]
-pub struct Table(pub(crate) table_impl::Table);
+#[derive(Debug, Clone, PartialEq, Eq, derive_more::From)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+pub struct Table(pub(crate) BackendTable);
 
 impl Table {
-    /// Creates a new `Table` with the provided [`TableType`] definition.
+    /// Creates a new table with the provided [`TableType`] definition.
     ///
     /// All the elements in the table will be set to the `init` value.
     ///
-    /// This function will construct the `Table` using the store `BaseTunables`.
+    /// This function will construct the table using the store `BaseTunables`.
     pub fn new(
         store: &mut impl AsStoreMut,
         ty: TableType,
         init: Value,
     ) -> Result<Self, RuntimeError> {
-        Ok(Self(table_impl::Table::new(store, ty, init)?))
+        BackendTable::new(store, ty, init).map(Self)
     }
 
-    /// Returns the [`TableType`] of the `Table`.
+    /// Returns the [`TableType`] of the table.
     pub fn ty(&self, store: &impl AsStoreRef) -> TableType {
         self.0.ty(store)
     }
@@ -97,11 +95,11 @@ impl Table {
         src_index: u32,
         len: u32,
     ) -> Result<(), RuntimeError> {
-        table_impl::Table::copy(store, &dst_table.0, dst_index, &src_table.0, src_index, len)
+        BackendTable::copy(store, &dst_table.0, dst_index, &src_table.0, src_index, len)
     }
 
-    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, extern_: VMExternTable) -> Self {
-        Self(table_impl::Table::from_vm_extern(store, extern_))
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, ext: VMExternTable) -> Self {
+        Self(BackendTable::from_vm_extern(store, ext))
     }
 
     /// Checks whether this `Table` can be used with the given context.
@@ -114,32 +112,42 @@ impl Table {
     }
 }
 
-impl std::cmp::Eq for Table {}
-
 impl<'a> Exportable<'a> for Table {
-    fn get_self_from_extern(_extern: &'a Extern) -> Result<&'a Self, ExportError> {
-        match _extern {
+    fn get_self_from_extern(ext: &'a Extern) -> Result<&'a Self, ExportError> {
+        match ext {
             Extern::Table(table) => Ok(table),
             _ => Err(ExportError::IncompatibleType),
         }
     }
 }
 
-/// Check the example from <https://github.com/wasmerio/wasmer/issues/3197>.
-#[test]
-fn test_table_grow_issue_3197() {
-    use crate::{imports, Instance, Module, Store, Table, TableType, Type, Value};
-
-    const WAT: &str = r#"(module (table (import "env" "table") 100 funcref))"#;
-
-    // Tests that the table type of `table` is compatible with the export in the WAT
-    // This tests that `wasmer_types::types::is_table_compatible` works as expected.
-    let mut store = Store::default();
-    let module = Module::new(&store, WAT).unwrap();
-    let ty = TableType::new(Type::FuncRef, 0, None);
-    let table = Table::new(&mut store, ty, Value::FuncRef(None)).unwrap();
-    table.grow(&mut store, 100, Value::FuncRef(None)).unwrap();
-    assert_eq!(table.ty(&store).minimum, 0);
-    let imports = imports! {"env" => {"table" => table}};
-    let _instance = Instance::new(&mut store, &module, &imports).unwrap();
+#[cfg(test)]
+mod test {
+    /// Check the example from <https://github.com/wasmerio/wasmer/issues/3197>.
+    #[test]
+    #[cfg_attr(
+        feature = "wamr",
+        ignore = "wamr does not support direct calls to grow table"
+    )]
+    #[cfg_attr(feature = "wasmi", ignore = "wasmi does not support funcrefs")]
+    #[cfg_attr(
+        feature = "v8",
+        ignore = "growing tables in v8 is not currently supported"
+    )]
+    fn table_grow_issue_3197() {
+        use crate::{imports, Instance, Module, Store, Table, TableType, Type, Value};
+
+        const WAT: &str = r#"(module (table (import "env" "table") 100 funcref))"#;
+
+        // Tests that the table type of `table` is compatible with the export in the WAT
+        // This tests that `wasmer_types::types::is_table_compatible` works as expected.
+        let mut store = Store::default();
+        let module = Module::new(&store, WAT).unwrap();
+        let ty = TableType::new(Type::FuncRef, 0, None);
+        let table = Table::new(&mut store, ty, Value::FuncRef(None)).unwrap();
+        table.grow(&mut store, 100, Value::FuncRef(None)).unwrap();
+        assert_eq!(table.ty(&store).minimum, 0);
+        let imports = imports! {"env" => {"table" => table}};
+        let _instance = Instance::new(&mut store, &module, &imports).unwrap();
+    }
 }
diff --git a/lib/api/src/entities/tag/inner.rs b/lib/api/src/entities/tag/inner.rs
new file mode 100644
index 0000000000..1a30f1ade0
--- /dev/null
+++ b/lib/api/src/entities/tag/inner.rs
@@ -0,0 +1,115 @@
+use wasmer_types::{TagType, Type};
+
+use crate::{
+    macros::backend::{gen_rt_ty, match_rt},
+    vm::{VMExtern, VMExternTag},
+    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern,
+};
+
+/// A WebAssembly `global` instance.
+///
+/// A global instance is the runtime representation of a global variable.
+/// It consists of an individual value and a flag indicating whether it is mutable.
+///
+/// Spec: <https://webassembly.github.io/spec/core/exec/runtime.html#global-instances>
+gen_rt_ty!(Tag
+    @cfg feature = "artifact-size" => derive(loupe::MemoryUsage)
+    @derives Debug, Clone, PartialEq, Eq, derive_more::From
+);
+
+impl BackendTag {
+    /// Create a new tag with event of type P -> [], that is a function that takes parameters `P`
+    /// and has no return value.
+    #[inline]
+    pub fn new<P: Into<Box<[Type]>>>(store: &mut impl AsStoreMut, params: P) -> Self {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(_) => {
+                Self::Sys(crate::backend::sys::tag::Tag::new(store, params))
+            }
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => {
+                Self::Wamr(crate::backend::wamr::tag::Tag::new(store, params))
+            }
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => {
+                Self::Wasmi(crate::backend::wasmi::tag::Tag::new(store, params))
+            }
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => {
+                Self::V8(crate::backend::v8::entities::tag::Tag::new(store, params))
+            }
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => {
+                Self::Js(crate::backend::js::tag::Tag::new(store, params))
+            }
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => {
+                Self::Jsc(crate::backend::jsc::tag::Tag::new(store, params))
+            }
+        }
+    }
+
+    /// Returns the [`TagType`] of the tag.
+    #[inline]
+    pub fn ty(&self, store: &impl AsStoreRef) -> TagType {
+        match_rt!(on self => f {
+            f.ty(store)
+        })
+    }
+
+    #[inline]
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternTag) -> Self {
+        match &store.as_store_mut().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(_) => Self::Sys(
+                crate::backend::sys::tag::Tag::from_vm_extern(store, vm_extern),
+            ),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => Self::Wamr(
+                crate::backend::wamr::tag::Tag::from_vm_extern(store, vm_extern),
+            ),
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => Self::Wasmi(
+                crate::backend::wasmi::tag::Tag::from_vm_extern(store, vm_extern),
+            ),
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => Self::V8(
+                crate::backend::v8::entities::tag::Tag::from_vm_extern(store, vm_extern),
+            ),
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => Self::Js(
+                crate::backend::js::entities::tag::Tag::from_vm_extern(store, vm_extern),
+            ),
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => Self::Jsc(
+                crate::backend::jsc::entities::tag::Tag::from_vm_extern(store, vm_extern),
+            ),
+        }
+    }
+
+    /// Checks whether this tag can be used with the given context.
+    #[inline]
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        match_rt!(on self => f {
+            f.is_from_store(store)
+        })
+    }
+
+    /// Create a [`VMExtern`] from self.
+    #[inline]
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        match_rt!(on self => f {
+            f.to_vm_extern()
+        })
+    }
+}
+
+impl<'a> Exportable<'a> for BackendTag {
+    fn get_self_from_extern(_extern: &'a Extern) -> Result<&'a Self, ExportError> {
+        match _extern {
+            Extern::Tag(func) => Ok(&func.0),
+            _ => Err(ExportError::IncompatibleType),
+        }
+    }
+}
diff --git a/lib/api/src/entities/tag/mod.rs b/lib/api/src/entities/tag/mod.rs
new file mode 100644
index 0000000000..e670d0a4fa
--- /dev/null
+++ b/lib/api/src/entities/tag/mod.rs
@@ -0,0 +1,62 @@
+pub(crate) mod inner;
+pub(crate) use inner::*;
+use wasmer_types::{TagType, Type};
+
+use crate::{
+    vm::{VMExtern, VMExternTag},
+    AsStoreMut, AsStoreRef, ExportError, Exportable, Extern,
+};
+
+/// A WebAssembly `tag` instance.
+///
+/// A tag instance is the runtime representation of a tag variable.
+///
+/// Spec: <https://webassembly.github.io/spec/core/exec/runtime.html#tag-instances>
+#[derive(Debug, Clone, PartialEq, Eq, derive_more::From)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+pub struct Tag(pub(crate) BackendTag);
+
+impl Tag {
+    /// Create a new tag with event of type P -> [], that is a function that takes parameters `P`
+    /// and has no return value.
+    //
+    // Note: in the future, a tag might express other kinds of events other than just exceptions.
+    // This would imply that the signature of this function becomes
+    //
+    // `pub fn new<R: Into<Box<[Type]>>, P: Into<Box<[Type]>>>(store: &mut impl AsStoreMut, kind: TagKind, params: P, rets: R) -> Self`
+    //
+    // For now, since the only possible kind is `TagKind::Exception`, we decided to make the
+    // external API easier to use, while having the internal types in place to allow the needed
+    // changes.
+    pub fn new<P: Into<Box<[Type]>>>(store: &mut impl AsStoreMut, params: P) -> Self {
+        Self(BackendTag::new(store, params))
+    }
+
+    /// Returns the [`TagType`] of the tag.
+    pub fn ty(&self, store: &impl AsStoreRef) -> TagType {
+        self.0.ty(store)
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternTag) -> Self {
+        Self(BackendTag::from_vm_extern(store, vm_extern))
+    }
+
+    /// Checks whether this tag can be used with the given context.
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.0.is_from_store(store)
+    }
+
+    /// Create a [`VMExtern`] from self.
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        self.0.to_vm_extern()
+    }
+}
+
+impl<'a> Exportable<'a> for Tag {
+    fn get_self_from_extern(_extern: &'a Extern) -> Result<&'a Self, ExportError> {
+        match _extern {
+            Extern::Tag(tag) => Ok(tag),
+            _ => Err(ExportError::IncompatibleType),
+        }
+    }
+}
diff --git a/lib/api/src/entities/trap.rs b/lib/api/src/entities/trap.rs
new file mode 100644
index 0000000000..06af0c198e
--- /dev/null
+++ b/lib/api/src/entities/trap.rs
@@ -0,0 +1,106 @@
+use std::{any::Any, error::Error, fmt::Debug};
+
+use crate::{macros::backend::match_rt, RuntimeError};
+
+/// An enumeration of all the trap kinds supported by the runtimes.
+#[derive(Debug, derive_more::From)]
+pub enum BackendTrap {
+    #[cfg(feature = "sys")]
+    /// The trap from the `sys` runtime.
+    Sys(crate::backend::sys::vm::Trap),
+
+    #[cfg(feature = "wamr")]
+    /// The trap from the `wamr` runtime.
+    Wamr(crate::backend::wamr::vm::Trap),
+
+    #[cfg(feature = "wasmi")]
+    /// The trap from the `wasmi` runtime.
+    Wasmi(crate::backend::wasmi::vm::Trap),
+
+    #[cfg(feature = "v8")]
+    /// The trap from the `v8` runtime.
+    V8(crate::backend::v8::vm::Trap),
+
+    #[cfg(feature = "js")]
+    /// The trap from the `js` runtime.
+    Js(crate::backend::js::vm::Trap),
+
+    #[cfg(feature = "jsc")]
+    /// The trap from the `jsc` runtime.
+    Jsc(crate::backend::jsc::vm::Trap),
+}
+
+impl BackendTrap {
+    /// Construct a new Error with the given a user error.
+    ///
+    /// Internally saves a backtrace when constructed.
+    pub fn user(err: Box<dyn Error + Send + Sync>) -> RuntimeError {
+        #[cfg(feature = "sys")]
+        {
+            return crate::backend::sys::vm::Trap::user(err).into();
+        }
+        #[cfg(feature = "wamr")]
+        {
+            return crate::backend::wamr::vm::Trap::user(err).into();
+        }
+
+        #[cfg(feature = "wasmi")]
+        {
+            return crate::backend::wasmi::vm::Trap::user(err).into();
+        }
+
+        #[cfg(feature = "v8")]
+        {
+            return crate::backend::v8::vm::Trap::user(err).into();
+        }
+        #[cfg(feature = "js")]
+        {
+            return crate::backend::js::vm::Trap::user(err).into();
+        }
+        #[cfg(feature = "jsc")]
+        {
+            return crate::backend::jsc::vm::Trap::user(err).into();
+        }
+
+        panic!("No runtime enabled!")
+    }
+    /// Attempts to downcast the `Trap` to a concrete type.
+    #[inline]
+    pub fn downcast<T: Error + 'static>(self) -> Result<T, Self> {
+        match_rt!(on self => s {
+            s.downcast::<T>().map_err(Into::into)
+        })
+    }
+
+    /// Attempts to downcast the `Trap` to a concrete type.
+    #[inline]
+    pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T> {
+        match_rt!(on self => s {
+            s.downcast_ref::<T>()
+        })
+    }
+
+    /// Returns true if the `Trap` is the same as T
+    #[inline]
+    pub fn is<T: Error + 'static>(&self) -> bool {
+        match_rt!(on self => s {
+            s.is::<T>()
+        })
+    }
+}
+
+impl std::fmt::Display for BackendTrap {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match_rt!(on self => s {
+            (s as &dyn std::fmt::Display).fmt(f)
+        })
+    }
+}
+
+impl std::error::Error for BackendTrap {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match_rt!(on self => s {
+            s.source()
+        })
+    }
+}
diff --git a/lib/api/src/value.rs b/lib/api/src/entities/value.rs
similarity index 58%
rename from lib/api/src/value.rs
rename to lib/api/src/entities/value.rs
index 15ec16edea..4ef22e45e4 100644
--- a/lib/api/src/value.rs
+++ b/lib/api/src/entities/value.rs
@@ -1,17 +1,10 @@
-use std::convert::TryFrom;
-use std::fmt;
-use std::string::{String, ToString};
+use wasmer_types::{RawValue, Type};
 
-use wasmer_types::Type;
-
-use crate::vm::{VMExternRef, VMFuncRef};
-
-use crate::ExternRef;
-use crate::Function;
-
-use crate::store::AsStoreRef;
-
-pub use wasmer_types::RawValue;
+use crate::{
+    entities::{ExceptionRef, ExternRef, Function},
+    vm::{VMExceptionRef, VMExternRef, VMFuncRef},
+    AsStoreRef, Tag,
+};
 
 /// WebAssembly computations manipulate values of basic value types:
 /// * Integers (32 or 64 bit width)
@@ -37,14 +30,18 @@ pub enum Value {
     /// A 64-bit float.
     F64(f64),
 
-    /// An `externref` value which can hold opaque data to the wasm instance itself.
+    /// A 128-bit number
+    V128(u128),
+
+    // -- references --
+    /// A nullable `externref` value which can hold opaque data to the wasm instance itself.
     ExternRef(Option<ExternRef>),
 
-    /// A first-class reference to a WebAssembly function.
+    /// A nullable first-class reference to a WebAssembly function.
     FuncRef(Option<Function>),
 
-    /// A 128-bit number
-    V128(u128),
+    /// A nullable first-class reference to a WebAssembly exception.
+    ExceptionRef(Option<ExceptionRef>),
 }
 
 macro_rules! accessors {
@@ -77,16 +74,17 @@ impl Value {
         Self::ExternRef(None)
     }
 
-    /// Returns the corresponding [`Type`] for this `Value`.
+    /// Returns the corresponding [`Type`] for this [`Value`].
     pub fn ty(&self) -> Type {
         match self {
             Self::I32(_) => Type::I32,
             Self::I64(_) => Type::I64,
             Self::F32(_) => Type::F32,
             Self::F64(_) => Type::F64,
+            Self::V128(_) => Type::V128,
             Self::ExternRef(_) => Type::ExternRef,
             Self::FuncRef(_) => Type::FuncRef,
-            Self::V128(_) => Type::V128,
+            Self::ExceptionRef(_) => Type::ExceptionRef,
         }
     }
 
@@ -98,8 +96,9 @@ impl Value {
             Self::F32(f32) => RawValue { f32 },
             Self::F64(f64) => RawValue { f64 },
             Self::V128(u128) => RawValue { u128 },
+            Self::ExceptionRef(Some(ref f)) => f.vm_exceptionref().into_raw(),
+            Self::ExceptionRef(None) => RawValue { funcref: 0 },
             Self::FuncRef(Some(ref f)) => f.vm_funcref(store).into_raw(),
-
             Self::FuncRef(None) => RawValue { funcref: 0 },
             Self::ExternRef(Some(ref e)) => e.vm_externref().into_raw(),
             Self::ExternRef(None) => RawValue { externref: 0 },
@@ -110,19 +109,134 @@ impl Value {
     ///
     /// # Safety
     ///
-    pub unsafe fn from_raw(store: &mut impl crate::AsStoreMut, ty: Type, raw: RawValue) -> Self {
+    pub unsafe fn from_raw(
+        store: &mut impl crate::entities::store::AsStoreMut,
+        ty: Type,
+        raw: RawValue,
+    ) -> Self {
         match ty {
             Type::I32 => Self::I32(raw.i32),
             Type::I64 => Self::I64(raw.i64),
             Type::F32 => Self::F32(raw.f32),
             Type::F64 => Self::F64(raw.f64),
             Type::V128 => Self::V128(raw.u128),
-            Type::FuncRef => {
-                Self::FuncRef(VMFuncRef::from_raw(raw).map(|f| Function::from_vm_funcref(store, f)))
-            }
-            Type::ExternRef => Self::ExternRef(
-                VMExternRef::from_raw(raw).map(|e| ExternRef::from_vm_externref(store, e)),
-            ),
+            Type::FuncRef => match store.as_store_ref().inner.store {
+                #[cfg(feature = "sys")]
+                crate::BackendStore::Sys(_) => Self::FuncRef(
+                    crate::backend::sys::vm::VMFuncRef::from_raw(raw)
+                        .map(VMFuncRef::Sys)
+                        .map(|f| Function::from_vm_funcref(store, f)),
+                ),
+                #[cfg(feature = "wamr")]
+                crate::BackendStore::Wamr(_) => Self::FuncRef(
+                    crate::backend::wamr::vm::VMFuncRef::from_raw(raw)
+                        .map(VMFuncRef::Wamr)
+                        .map(|f| Function::from_vm_funcref(store, f)),
+                ),
+                #[cfg(feature = "wasmi")]
+                crate::BackendStore::Wasmi(_) => Self::FuncRef(
+                    crate::backend::wasmi::vm::VMFuncRef::from_raw(raw)
+                        .map(VMFuncRef::Wasmi)
+                        .map(|f| Function::from_vm_funcref(store, f)),
+                ),
+
+                #[cfg(feature = "v8")]
+                crate::BackendStore::V8(_) => Self::FuncRef(
+                    crate::backend::v8::vm::VMFuncRef::from_raw(raw)
+                        .map(VMFuncRef::V8)
+                        .map(|f| Function::from_vm_funcref(store, f)),
+                ),
+                #[cfg(feature = "js")]
+                crate::BackendStore::Js(_) => Self::FuncRef(
+                    crate::backend::js::vm::VMFuncRef::from_raw(raw)
+                        .map(VMFuncRef::Js)
+                        .map(|f| Function::from_vm_funcref(store, f)),
+                ),
+                #[cfg(feature = "jsc")]
+                crate::BackendStore::Jsc(_) => Self::FuncRef(
+                    crate::backend::jsc::vm::VMFuncRef::from_raw(raw)
+                        .map(VMFuncRef::Jsc)
+                        .map(|f| Function::from_vm_funcref(store, f)),
+                ),
+            },
+            Type::ExternRef => match store.as_store_ref().inner.store {
+                #[cfg(feature = "sys")]
+                crate::BackendStore::Sys(_) => Self::ExternRef(
+                    crate::backend::sys::vm::VMExternRef::from_raw(raw)
+                        .map(VMExternRef::Sys)
+                        .map(|f| ExternRef::from_vm_externref(store, f)),
+                ),
+                #[cfg(feature = "wamr")]
+                crate::BackendStore::Wamr(_) => Self::ExternRef(
+                    crate::backend::wamr::vm::VMExternRef::from_raw(raw)
+                        .map(VMExternRef::Wamr)
+                        .map(|f| ExternRef::from_vm_externref(store, f)),
+                ),
+                #[cfg(feature = "wasmi")]
+                crate::BackendStore::Wasmi(_) => Self::ExternRef(
+                    crate::backend::wasmi::vm::VMExternRef::from_raw(raw)
+                        .map(VMExternRef::Wasmi)
+                        .map(|f| ExternRef::from_vm_externref(store, f)),
+                ),
+
+                #[cfg(feature = "v8")]
+                crate::BackendStore::V8(_) => Self::ExternRef(
+                    crate::backend::v8::vm::VMExternRef::from_raw(raw)
+                        .map(VMExternRef::V8)
+                        .map(|f| ExternRef::from_vm_externref(store, f)),
+                ),
+                #[cfg(feature = "js")]
+                crate::BackendStore::Js(_) => Self::ExternRef(
+                    crate::backend::js::vm::VMExternRef::from_raw(raw)
+                        .map(VMExternRef::Js)
+                        .map(|f| ExternRef::from_vm_externref(store, f)),
+                ),
+                #[cfg(feature = "jsc")]
+                crate::BackendStore::Jsc(_) => Self::ExternRef(
+                    crate::backend::jsc::vm::VMExternRef::from_raw(raw)
+                        .map(VMExternRef::Jsc)
+                        .map(|f| ExternRef::from_vm_externref(store, f)),
+                ),
+            },
+            Type::ExceptionRef => match store.as_store_ref().inner.store {
+                #[cfg(feature = "sys")]
+                crate::BackendStore::Sys(_) => Self::ExceptionRef(
+                    crate::backend::sys::vm::VMExceptionRef::from_raw(raw)
+                        .map(VMExceptionRef::Sys)
+                        .map(|f| ExceptionRef::from_vm_exceptionref(store, f)),
+                ),
+                #[cfg(feature = "wamr")]
+                crate::BackendStore::Wamr(_) => Self::ExceptionRef(
+                    crate::backend::wamr::vm::VMExceptionRef::from_raw(raw)
+                        .map(VMExceptionRef::Wamr)
+                        .map(|f| ExceptionRef::from_vm_exceptionref(store, f)),
+                ),
+                #[cfg(feature = "wasmi")]
+                crate::BackendStore::Wasmi(_) => Self::ExceptionRef(
+                    crate::backend::wasmi::vm::VMExceptionRef::from_raw(raw)
+                        .map(VMExceptionRef::Wasmi)
+                        .map(|f| ExceptionRef::from_vm_exceptionref(store, f)),
+                ),
+
+                #[cfg(feature = "v8")]
+                crate::BackendStore::V8(_) => Self::ExceptionRef(
+                    crate::backend::v8::vm::VMExceptionRef::from_raw(raw)
+                        .map(VMExceptionRef::V8)
+                        .map(|f| ExceptionRef::from_vm_exceptionref(store, f)),
+                ),
+                #[cfg(feature = "js")]
+                crate::BackendStore::Js(_) => Self::ExceptionRef(
+                    crate::backend::js::vm::VMExceptionRef::from_raw(raw)
+                        .map(VMExceptionRef::Js)
+                        .map(|f| ExceptionRef::from_vm_exceptionref(store, f)),
+                ),
+                #[cfg(feature = "jsc")]
+                crate::BackendStore::Jsc(_) => Self::ExceptionRef(
+                    crate::backend::jsc::vm::VMExceptionRef::from_raw(raw)
+                        .map(VMExceptionRef::Jsc)
+                        .map(|f| ExceptionRef::from_vm_exceptionref(store, f)),
+                ),
+            },
         }
     }
 
@@ -141,8 +255,10 @@ impl Value {
             | Self::F64(_)
             | Self::V128(_)
             | Self::ExternRef(None)
+            | Self::ExceptionRef(None)
             | Self::FuncRef(None) => true,
             Self::ExternRef(Some(e)) => e.is_from_store(store),
+            Self::ExceptionRef(Some(e)) => e.is_from_store(store),
             Self::FuncRef(Some(f)) => f.is_from_store(store),
         }
     }
@@ -159,33 +275,40 @@ impl Value {
     }
 }
 
-impl fmt::Debug for Value {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl std::fmt::Debug for Value {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::I32(v) => write!(f, "I32({:?})", v),
-            Self::I64(v) => write!(f, "I64({:?})", v),
-            Self::F32(v) => write!(f, "F32({:?})", v),
-            Self::F64(v) => write!(f, "F64({:?})", v),
+            Self::I32(v) => write!(f, "I32({v:?})"),
+            Self::I64(v) => write!(f, "I64({v:?})"),
+            Self::F32(v) => write!(f, "F32({v:?})"),
+            Self::F64(v) => write!(f, "F64({v:?})"),
+            Self::ExceptionRef(None) => write!(f, "Null ExceptionRef"),
+            Self::ExceptionRef(Some(v)) => write!(f, "ExceptionRef({v:?})"),
             Self::ExternRef(None) => write!(f, "Null ExternRef"),
-            Self::ExternRef(Some(v)) => write!(f, "ExternRef({:?})", v),
+            Self::ExternRef(Some(v)) => write!(f, "ExternRef({v:?})"),
             Self::FuncRef(None) => write!(f, "Null FuncRef"),
-            Self::FuncRef(Some(v)) => write!(f, "FuncRef({:?})", v),
-            Self::V128(v) => write!(f, "V128({:?})", v),
+            Self::FuncRef(Some(v)) => write!(f, "FuncRef({v:?})"),
+            Self::V128(v) => write!(f, "V128({v:?})"),
         }
     }
 }
 
-impl ToString for Value {
-    fn to_string(&self) -> String {
-        match self {
-            Self::I32(v) => v.to_string(),
-            Self::I64(v) => v.to_string(),
-            Self::F32(v) => v.to_string(),
-            Self::F64(v) => v.to_string(),
-            Self::ExternRef(_) => "externref".to_string(),
-            Self::FuncRef(_) => "funcref".to_string(),
-            Self::V128(v) => v.to_string(),
-        }
+impl std::fmt::Display for Value {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Self::I32(v) => v.to_string(),
+                Self::I64(v) => v.to_string(),
+                Self::F32(v) => v.to_string(),
+                Self::F64(v) => v.to_string(),
+                Self::ExceptionRef(_) => "exnref".to_string(),
+                Self::ExternRef(_) => "externref".to_string(),
+                Self::FuncRef(_) => "funcref".to_string(),
+                Self::V128(v) => v.to_string(),
+            }
+        )
     }
 }
 
@@ -264,12 +387,25 @@ impl From<Option<ExternRef>> for Value {
     }
 }
 
+impl From<ExceptionRef> for Value {
+    fn from(val: ExceptionRef) -> Self {
+        Self::ExceptionRef(Some(val))
+    }
+}
+
+impl From<Option<ExceptionRef>> for Value {
+    fn from(val: Option<ExceptionRef>) -> Self {
+        Self::ExceptionRef(val)
+    }
+}
+
 const NOT_I32: &str = "Value is not of Wasm type i32";
 const NOT_I64: &str = "Value is not of Wasm type i64";
 const NOT_F32: &str = "Value is not of Wasm type f32";
 const NOT_F64: &str = "Value is not of Wasm type f64";
 const NOT_FUNCREF: &str = "Value is not of Wasm type funcref";
 const NOT_EXTERNREF: &str = "Value is not of Wasm type externref";
+const NOT_EXCEPTIONREF: &str = "Value is not of Wasm type exceptionref";
 
 impl TryFrom<Value> for i32 {
     type Error = &'static str;
@@ -341,6 +477,17 @@ impl TryFrom<Value> for Option<ExternRef> {
     }
 }
 
+impl TryFrom<Value> for Option<ExceptionRef> {
+    type Error = &'static str;
+
+    fn try_from(value: Value) -> Result<Self, Self::Error> {
+        match value {
+            Value::ExceptionRef(e) => Ok(e),
+            _ => Err(NOT_EXCEPTIONREF),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/lib/api/src/errors.rs b/lib/api/src/error.rs
similarity index 92%
rename from lib/api/src/errors.rs
rename to lib/api/src/error.rs
index 88c596db38..35400775b7 100644
--- a/lib/api/src/errors.rs
+++ b/lib/api/src/error.rs
@@ -1,15 +1,8 @@
-#[cfg(feature = "js")]
-use crate::js::trap::Trap;
-#[cfg(feature = "jsc")]
-use crate::jsc::trap::Trap;
-use std::fmt;
 use std::sync::Arc;
 use thiserror::Error;
-use wasmer_types::{FrameInfo, TrapCode};
-#[cfg(feature = "sys")]
-use wasmer_vm::Trap;
+use wasmer_types::{FrameInfo, ImportError, TrapCode};
 
-use wasmer_types::ImportError;
+use crate::BackendTrap as Trap;
 
 /// The WebAssembly.LinkError object indicates an error during
 /// module instantiation (besides traps from the start function).
@@ -86,8 +79,8 @@ impl RuntimeStringError {
     }
 }
 
-impl fmt::Display for RuntimeStringError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+impl std::fmt::Display for RuntimeStringError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "{}", self.details)
     }
 }
@@ -207,8 +200,8 @@ impl RuntimeError {
     }
 }
 
-impl fmt::Debug for RuntimeError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl std::fmt::Debug for RuntimeError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("RuntimeError")
             .field("source", &self.inner.source)
             .field("wasm_trace", &self.inner.wasm_trace)
@@ -216,8 +209,8 @@ impl fmt::Debug for RuntimeError {
     }
 }
 
-impl fmt::Display for RuntimeError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl std::fmt::Display for RuntimeError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "RuntimeError: {}", self.message())?;
         let trace = self.trace();
         if trace.is_empty() {
@@ -230,8 +223,8 @@ impl fmt::Display for RuntimeError {
             write!(f, "    at ")?;
             match frame.function_name() {
                 Some(name) => match rustc_demangle::try_demangle(name) {
-                    Ok(name) => write!(f, "{}", name)?,
-                    Err(_) => write!(f, "{}", name)?,
+                    Ok(name) => write!(f, "{name}")?,
+                    Err(_) => write!(f, "{name}")?,
                 },
                 None => write!(f, "<unnamed>")?,
             }
@@ -258,7 +251,7 @@ impl From<Box<dyn std::error::Error + Send + Sync>> for RuntimeError {
         match error.downcast::<Self>() {
             // The error is already a RuntimeError, we return it directly
             Ok(runtime_error) => *runtime_error,
-            Err(error) => Trap::user(error).into(),
+            Err(error) => Trap::user(error),
         }
     }
 }
diff --git a/lib/api/src/externals/memory.rs b/lib/api/src/externals/memory.rs
deleted file mode 100644
index 3e2b07efa2..0000000000
--- a/lib/api/src/externals/memory.rs
+++ /dev/null
@@ -1,363 +0,0 @@
-#[cfg(feature = "js")]
-use crate::js::externals::memory as memory_impl;
-#[cfg(feature = "jsc")]
-use crate::jsc::externals::memory as memory_impl;
-#[cfg(feature = "sys")]
-use crate::sys::externals::memory as memory_impl;
-
-use super::memory_view::MemoryView;
-use crate::exports::{ExportError, Exportable};
-use crate::store::{AsStoreMut, AsStoreRef};
-use crate::vm::{VMExtern, VMExternMemory, VMMemory};
-use crate::MemoryAccessError;
-use crate::MemoryType;
-use crate::{AtomicsError, Extern};
-use std::mem::MaybeUninit;
-use wasmer_types::{MemoryError, Pages};
-
-/// A WebAssembly `memory` instance.
-///
-/// A memory instance is the runtime representation of a linear memory.
-/// It consists of a vector of bytes and an optional maximum size.
-///
-/// The length of the vector always is a multiple of the WebAssembly
-/// page size, which is defined to be the constant 65536 – abbreviated 64Ki.
-/// Like in a memory type, the maximum size in a memory instance is
-/// given in units of this page size.
-///
-/// A memory created by the host or in WebAssembly code will be accessible and
-/// mutable from both host and WebAssembly.
-///
-/// Spec: <https://webassembly.github.io/spec/core/exec/runtime.html#memory-instances>
-#[derive(Debug, Clone, PartialEq)]
-pub struct Memory(pub(crate) memory_impl::Memory);
-
-impl Memory {
-    /// Creates a new host `Memory` from the provided [`MemoryType`].
-    ///
-    /// This function will construct the `Memory` using the store
-    /// `BaseTunables`.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value};
-    /// # let mut store = Store::default();
-    /// #
-    /// let m = Memory::new(&mut store, MemoryType::new(1, None, false)).unwrap();
-    /// ```
-    pub fn new(store: &mut impl AsStoreMut, ty: MemoryType) -> Result<Self, MemoryError> {
-        Ok(Self(memory_impl::Memory::new(store, ty)?))
-    }
-
-    /// Create a memory object from an existing memory and attaches it to the store
-    pub fn new_from_existing(new_store: &mut impl AsStoreMut, memory: VMMemory) -> Self {
-        Self(memory_impl::Memory::new_from_existing(new_store, memory))
-    }
-
-    /// Returns the [`MemoryType`] of the `Memory`.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value};
-    /// # let mut store = Store::default();
-    /// #
-    /// let mt = MemoryType::new(1, None, false);
-    /// let m = Memory::new(&mut store, mt).unwrap();
-    ///
-    /// assert_eq!(m.ty(&mut store), mt);
-    /// ```
-    pub fn ty(&self, store: &impl AsStoreRef) -> MemoryType {
-        self.0.ty(store)
-    }
-
-    /// Creates a view into the memory that then allows for
-    /// read and write
-    pub fn view<'a>(&self, store: &'a (impl AsStoreRef + ?Sized)) -> MemoryView<'a> {
-        MemoryView::new(self, store)
-    }
-
-    /// Grow memory by the specified amount of WebAssembly [`Pages`] and return
-    /// the previous memory size.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value, WASM_MAX_PAGES};
-    /// # let mut store = Store::default();
-    /// #
-    /// let m = Memory::new(&mut store, MemoryType::new(1, Some(3), false)).unwrap();
-    /// let p = m.grow(&mut store, 2).unwrap();
-    ///
-    /// assert_eq!(p, Pages(1));
-    /// assert_eq!(m.view(&mut store).size(), Pages(3));
-    /// ```
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if memory can't be grown by the specified amount
-    /// of pages.
-    ///
-    /// ```should_panic
-    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value, WASM_MAX_PAGES};
-    /// # use wasmer::FunctionEnv;
-    /// # let mut store = Store::default();
-    /// # let env = FunctionEnv::new(&mut store, ());
-    /// #
-    /// let m = Memory::new(&mut store, MemoryType::new(1, Some(1), false)).unwrap();
-    ///
-    /// // This results in an error: `MemoryError::CouldNotGrow`.
-    /// let s = m.grow(&mut store, 1).unwrap();
-    /// ```
-    pub fn grow<IntoPages>(
-        &self,
-        store: &mut impl AsStoreMut,
-        delta: IntoPages,
-    ) -> Result<Pages, MemoryError>
-    where
-        IntoPages: Into<Pages>,
-    {
-        self.0.grow(store, delta)
-    }
-
-    /// Grows the memory to at least a minimum size. If the memory is already big enough
-    /// for the min size then this function does nothing
-    pub fn grow_at_least(
-        &self,
-        store: &mut impl AsStoreMut,
-        min_size: u64,
-    ) -> Result<(), MemoryError> {
-        self.0.grow_at_least(store, min_size)
-    }
-
-    /// Resets the memory back to zero length
-    pub fn reset(&self, store: &mut impl AsStoreMut) -> Result<(), MemoryError> {
-        self.0.reset(store)?;
-        Ok(())
-    }
-
-    /// Attempts to duplicate this memory (if its clonable) in a new store
-    /// (copied memory)
-    pub fn copy_to_store(
-        &self,
-        store: &impl AsStoreRef,
-        new_store: &mut impl AsStoreMut,
-    ) -> Result<Self, MemoryError> {
-        if !self.ty(store).shared {
-            // We should only be able to duplicate in a new store if the memory is shared
-            return Err(MemoryError::InvalidMemory {
-                reason: "memory is not a shared memory type".to_string(),
-            });
-        }
-        self.0
-            .try_copy(&store)
-            .map(|new_memory| Self::new_from_existing(new_store, new_memory.into()))
-    }
-
-    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternMemory) -> Self {
-        Self(memory_impl::Memory::from_vm_extern(store, vm_extern))
-    }
-
-    /// Checks whether this `Memory` can be used with the given context.
-    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
-        self.0.is_from_store(store)
-    }
-
-    /// Attempts to clone this memory (if its clonable)
-    pub fn try_clone(&self, store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
-        self.0.try_clone(store)
-    }
-
-    /// Attempts to clone this memory (if its clonable) in a new store
-    /// (cloned memory will be shared between those that clone it)
-    pub fn share_in_store(
-        &self,
-        store: &impl AsStoreRef,
-        new_store: &mut impl AsStoreMut,
-    ) -> Result<Self, MemoryError> {
-        if !self.ty(store).shared {
-            // We should only be able to duplicate in a new store if the memory is shared
-            return Err(MemoryError::InvalidMemory {
-                reason: "memory is not a shared memory type".to_string(),
-            });
-        }
-        self.0
-            .try_clone(&store)
-            .map(|new_memory| Self::new_from_existing(new_store, new_memory))
-    }
-
-    /// Get a [`SharedMemory`].
-    ///
-    /// Only returns `Some(_)` if the memory is shared, and if the target
-    /// backend supports shared memory operations.
-    ///
-    /// See [`SharedMemory`] and its methods for more information.
-    pub fn as_shared(&self, store: &impl AsStoreRef) -> Option<SharedMemory> {
-        if !self.ty(store).shared {
-            return None;
-        }
-        self.0.as_shared(store)
-    }
-
-    /// To `VMExtern`.
-    pub(crate) fn to_vm_extern(&self) -> VMExtern {
-        self.0.to_vm_extern()
-    }
-}
-
-impl std::cmp::Eq for Memory {}
-
-impl<'a> Exportable<'a> for Memory {
-    fn get_self_from_extern(_extern: &'a Extern) -> Result<&'a Self, ExportError> {
-        match _extern {
-            Extern::Memory(memory) => Ok(memory),
-            _ => Err(ExportError::IncompatibleType),
-        }
-    }
-}
-
-/// Location in a WebAssembly memory.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct MemoryLocation {
-    // NOTE: must be expanded to an enum that also supports 64bit memory in
-    // the future
-    // That's why this is private.
-    pub(crate) address: u32,
-}
-
-impl MemoryLocation {
-    /// Create a new memory location for a 32bit memory.
-    pub fn new_32(address: u32) -> Self {
-        Self { address }
-    }
-}
-
-impl From<u32> for MemoryLocation {
-    fn from(value: u32) -> Self {
-        Self::new_32(value)
-    }
-}
-
-/// See [`SharedMemory`].
-pub(crate) trait SharedMemoryOps {
-    /// See [`SharedMemory::disable_atomics`].
-    fn disable_atomics(&self) -> Result<(), MemoryError> {
-        Err(MemoryError::AtomicsNotSupported)
-    }
-
-    /// See [`SharedMemory::wake_all_atomic_waiters`].
-    fn wake_all_atomic_waiters(&self) -> Result<(), MemoryError> {
-        Err(MemoryError::AtomicsNotSupported)
-    }
-
-    /// See [`SharedMemory::notify`].
-    fn notify(&self, _dst: MemoryLocation, _count: u32) -> Result<u32, AtomicsError> {
-        Err(AtomicsError::Unimplemented)
-    }
-
-    /// See [`SharedMemory::wait`].
-    fn wait(
-        &self,
-        _dst: MemoryLocation,
-        _timeout: Option<std::time::Duration>,
-    ) -> Result<u32, AtomicsError> {
-        Err(AtomicsError::Unimplemented)
-    }
-}
-
-/// A handle that exposes operations only relevant for shared memories.
-///
-/// Enables interaction independent from the [`crate::Store`], and thus allows calling
-/// some methods an instane is running.
-///
-/// **NOTE**: Not all methods are supported by all backends.
-#[derive(Clone)]
-pub struct SharedMemory {
-    memory: Memory,
-    ops: std::sync::Arc<dyn SharedMemoryOps + Send + Sync>,
-}
-
-impl std::fmt::Debug for SharedMemory {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("SharedMemory").finish()
-    }
-}
-
-impl SharedMemory {
-    /// Get the underlying memory.
-    pub fn memory(&self) -> &Memory {
-        &self.memory
-    }
-
-    /// Create a new handle from ops.
-    #[allow(unused)]
-    pub(crate) fn new(memory: Memory, ops: impl SharedMemoryOps + Send + Sync + 'static) -> Self {
-        Self {
-            memory,
-            ops: std::sync::Arc::new(ops),
-        }
-    }
-
-    /// Notify up to `count` waiters waiting for the memory location.
-    pub fn notify(&self, location: MemoryLocation, count: u32) -> Result<u32, AtomicsError> {
-        self.ops.notify(location, count)
-    }
-
-    /// Wait for the memory location to be notified.
-    pub fn wait(
-        &self,
-        location: MemoryLocation,
-        timeout: Option<std::time::Duration>,
-    ) -> Result<u32, AtomicsError> {
-        self.ops.wait(location, timeout)
-    }
-
-    /// Disable atomics for this memory.
-    ///
-    /// All subsequent atomic wait calls will produce a trap.
-    ///
-    /// This can be used or forced shutdown of instances that continuously try
-    /// to wait on atomics.
-    ///
-    /// NOTE: this operation might not be supported by all memory implementations.
-    /// In that case, this function will return an error.
-    pub fn disable_atomics(&self) -> Result<(), MemoryError> {
-        self.ops.disable_atomics()
-    }
-
-    /// Wake up all atomic waiters.
-    ///
-    /// This can be used to force-resume waiting execution.
-    ///
-    /// NOTE: this operation might not be supported by all memory implementations.
-    /// In that case, this function will return an error.
-    pub fn wake_all_atomic_waiters(&self) -> Result<(), MemoryError> {
-        self.ops.wake_all_atomic_waiters()
-    }
-}
-
-/// Underlying buffer for a memory.
-#[derive(Debug, Copy, Clone)]
-pub(crate) struct MemoryBuffer<'a>(pub(crate) memory_impl::MemoryBuffer<'a>);
-
-impl<'a> MemoryBuffer<'a> {
-    #[allow(unused)]
-    pub(crate) fn read(&self, offset: u64, buf: &mut [u8]) -> Result<(), MemoryAccessError> {
-        self.0.read(offset, buf)
-    }
-
-    #[allow(unused)]
-    pub(crate) fn read_uninit<'b>(
-        &self,
-        offset: u64,
-        buf: &'b mut [MaybeUninit<u8>],
-    ) -> Result<&'b mut [u8], MemoryAccessError> {
-        self.0.read_uninit(offset, buf)
-    }
-
-    #[allow(unused)]
-    pub(crate) fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
-        self.0.write(offset, data)
-    }
-}
diff --git a/lib/api/src/instance.rs b/lib/api/src/instance.rs
deleted file mode 100644
index ff31210bf7..0000000000
--- a/lib/api/src/instance.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-use crate::exports::Exports;
-use crate::module::Module;
-use crate::{Extern, InstantiationError};
-use std::fmt;
-
-use crate::imports::Imports;
-use crate::store::AsStoreMut;
-
-#[cfg(feature = "js")]
-use crate::js::instance as instance_imp;
-#[cfg(feature = "jsc")]
-use crate::jsc::instance as instance_imp;
-#[cfg(feature = "sys")]
-use crate::sys::instance as instance_imp;
-
-/// A WebAssembly Instance is a stateful, executable
-/// instance of a WebAssembly [`Module`].
-///
-/// Instance objects contain all the exported WebAssembly
-/// functions, memories, tables and globals that allow
-/// interacting with WebAssembly.
-///
-/// Spec: <https://webassembly.github.io/spec/core/exec/runtime.html#module-instances>
-#[derive(Clone, PartialEq, Eq)]
-pub struct Instance {
-    pub(crate) _inner: instance_imp::Instance,
-    pub(crate) module: Module,
-    /// The exports for an instance.
-    pub exports: Exports,
-}
-
-impl Instance {
-    /// Creates a new `Instance` from a WebAssembly [`Module`] and a
-    /// set of imports using [`Imports`] or the [`imports!`] macro helper.
-    ///
-    /// [`imports!`]: crate::imports!
-    /// [`Imports!`]: crate::Imports!
-    ///
-    /// ```
-    /// # use wasmer::{imports, Store, Module, Global, Value, Instance};
-    /// # use wasmer::FunctionEnv;
-    /// # fn main() -> anyhow::Result<()> {
-    /// let mut store = Store::default();
-    /// let env = FunctionEnv::new(&mut store, ());
-    /// let module = Module::new(&store, "(module)")?;
-    /// let imports = imports!{
-    ///   "host" => {
-    ///     "var" => Global::new(&mut store, Value::I32(2))
-    ///   }
-    /// };
-    /// let instance = Instance::new(&mut store, &module, &imports)?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// ## Errors
-    ///
-    /// The function can return [`InstantiationError`]s.
-    ///
-    /// Those are, as defined by the spec:
-    ///  * Link errors that happen when plugging the imports into the instance
-    ///  * Runtime errors that happen when running the module `start` function.
-    #[allow(clippy::result_large_err)]
-    pub fn new(
-        store: &mut impl AsStoreMut,
-        module: &Module,
-        imports: &Imports,
-    ) -> Result<Self, InstantiationError> {
-        let (_inner, exports) = instance_imp::Instance::new(store, module, imports)?;
-        Ok(Self {
-            _inner,
-            module: module.clone(),
-            exports,
-        })
-    }
-
-    /// Creates a new `Instance` from a WebAssembly [`Module`] and a
-    /// vector of imports.
-    ///
-    /// ## Errors
-    ///
-    /// The function can return [`InstantiationError`]s.
-    ///
-    /// Those are, as defined by the spec:
-    ///  * Link errors that happen when plugging the imports into the instance
-    ///  * Runtime errors that happen when running the module `start` function.
-    #[allow(clippy::result_large_err)]
-    pub fn new_by_index(
-        store: &mut impl AsStoreMut,
-        module: &Module,
-        externs: &[Extern],
-    ) -> Result<Self, InstantiationError> {
-        let (_inner, exports) = instance_imp::Instance::new_by_index(store, module, externs)?;
-        Ok(Self {
-            _inner,
-            module: module.clone(),
-            exports,
-        })
-    }
-
-    /// Gets the [`Module`] associated with this instance.
-    pub fn module(&self) -> &Module {
-        &self.module
-    }
-}
-
-impl fmt::Debug for Instance {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("Instance")
-            .field("exports", &self.exports)
-            .finish()
-    }
-}
diff --git a/lib/api/src/js/engine.rs b/lib/api/src/js/engine.rs
deleted file mode 100644
index b56d104ec1..0000000000
--- a/lib/api/src/js/engine.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-/// A WebAssembly `Universal` Engine.
-#[derive(Clone, Debug)]
-pub struct Engine;
-
-impl Engine {
-    pub(crate) fn deterministic_id(&self) -> &str {
-        // All js engines have the same id
-        "js-generic"
-    }
-}
-
-impl Default for Engine {
-    fn default() -> Self {
-        Engine
-    }
-}
-
-/// Returns the default engine for the JS engine
-pub(crate) fn default_engine() -> Engine {
-    Engine::default()
-}
diff --git a/lib/api/src/js/errors.rs b/lib/api/src/js/errors.rs
deleted file mode 100644
index b4f6e02049..0000000000
--- a/lib/api/src/js/errors.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-use crate::js::trap::Trap;
-use crate::RuntimeError;
-use wasm_bindgen::prelude::*;
-
-impl From<Trap> for RuntimeError {
-    fn from(trap: Trap) -> Self {
-        if trap.is::<RuntimeError>() {
-            return trap.downcast::<RuntimeError>().unwrap();
-        }
-        let wasm_trace = vec![];
-        let trap_code = None;
-        // let (wasm_trace, trap_code) = wasmer_compiler::get_trace_and_trapcode(&trap);
-        RuntimeError::new_from_source(trap, wasm_trace, trap_code)
-    }
-}
-
-impl From<RuntimeError> for JsValue {
-    fn from(_err: RuntimeError) -> Self {
-        // err.inner.source.into()
-        unimplemented!();
-    }
-}
-
-pub(crate) fn raise(error: Box<dyn std::error::Error + Send + Sync>) -> ! {
-    let error = Trap::user(error);
-    let js_error: JsValue = error.into();
-    wasm_bindgen::throw_val(js_error)
-}
diff --git a/lib/api/src/js/externals/mod.rs b/lib/api/src/js/externals/mod.rs
deleted file mode 100644
index 3575fe23bb..0000000000
--- a/lib/api/src/js/externals/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-pub(crate) mod function;
-pub(crate) mod global;
-pub(crate) mod memory;
-pub(crate) mod memory_view;
-pub(crate) mod table;
diff --git a/lib/api/src/js/externals/table.rs b/lib/api/src/js/externals/table.rs
deleted file mode 100644
index f7c2cdda4e..0000000000
--- a/lib/api/src/js/externals/table.rs
+++ /dev/null
@@ -1,119 +0,0 @@
-use crate::errors::RuntimeError;
-use crate::store::{AsStoreMut, AsStoreRef};
-use crate::value::Value;
-use crate::vm::VMExternTable;
-use crate::vm::{VMExtern, VMFunction, VMTable};
-use crate::{FunctionType, TableType};
-use js_sys::Function;
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct Table {
-    pub(crate) handle: VMTable,
-}
-
-// Table can't be Send in js because it dosen't support `structuredClone`
-// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
-// unsafe impl Send for Table {}
-
-fn set_table_item(table: &VMTable, item_index: u32, item: &Function) -> Result<(), RuntimeError> {
-    table.table.set(item_index, item).map_err(|e| e.into())
-}
-
-fn get_function(store: &mut impl AsStoreMut, val: Value) -> Result<Function, RuntimeError> {
-    if !val.is_from_store(store) {
-        return Err(RuntimeError::new("cannot pass Value across contexts"));
-    }
-    match val {
-        Value::FuncRef(Some(ref func)) => Ok(func.0.handle.function.clone().into_inner()),
-        // Only funcrefs is supported by the spec atm
-        _ => unimplemented!("The {val:?} is not yet supported"),
-    }
-}
-
-impl Table {
-    pub fn new(
-        store: &mut impl AsStoreMut,
-        ty: TableType,
-        init: Value,
-    ) -> Result<Self, RuntimeError> {
-        let mut store = store;
-        let descriptor = js_sys::Object::new();
-        js_sys::Reflect::set(&descriptor, &"initial".into(), &ty.minimum.into())?;
-        if let Some(max) = ty.maximum {
-            js_sys::Reflect::set(&descriptor, &"maximum".into(), &max.into())?;
-        }
-        js_sys::Reflect::set(&descriptor, &"element".into(), &"anyfunc".into())?;
-
-        let js_table = js_sys::WebAssembly::Table::new(&descriptor)?;
-        let table = VMTable::new(js_table, ty);
-
-        let num_elements = table.table.length();
-        let func = get_function(&mut store, init)?;
-        for i in 0..num_elements {
-            set_table_item(&table, i, &func)?;
-        }
-
-        Ok(Self { handle: table })
-    }
-
-    pub fn to_vm_extern(&self) -> VMExtern {
-        VMExtern::Table(self.handle.clone())
-    }
-
-    pub fn ty(&self, _store: &impl AsStoreRef) -> TableType {
-        self.handle.ty
-    }
-
-    pub fn get(&self, store: &mut impl AsStoreMut, index: u32) -> Option<Value> {
-        if let Some(func) = self.handle.table.get(index).ok() {
-            let ty = FunctionType::new(vec![], vec![]);
-            let vm_function = VMFunction::new(func, ty);
-            let function = crate::Function::from_vm_extern(store, vm_function);
-            Some(Value::FuncRef(Some(function)))
-        } else {
-            None
-        }
-    }
-
-    pub fn set(
-        &self,
-        store: &mut impl AsStoreMut,
-        index: u32,
-        val: Value,
-    ) -> Result<(), RuntimeError> {
-        let item = get_function(store, val)?;
-        set_table_item(&self.handle, index, &item)
-    }
-
-    pub fn size(&self, _store: &impl AsStoreRef) -> u32 {
-        self.handle.table.length()
-    }
-
-    pub fn grow(
-        &self,
-        _store: &mut impl AsStoreMut,
-        _delta: u32,
-        _init: Value,
-    ) -> Result<u32, RuntimeError> {
-        unimplemented!();
-    }
-
-    pub fn copy(
-        _store: &mut impl AsStoreMut,
-        _dst_table: &Self,
-        _dst_index: u32,
-        _src_table: &Self,
-        _src_index: u32,
-        _len: u32,
-    ) -> Result<(), RuntimeError> {
-        unimplemented!("Table.copy is not natively supported in Javascript");
-    }
-
-    pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, vm_extern: VMExternTable) -> Self {
-        Self { handle: vm_extern }
-    }
-
-    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
-        true
-    }
-}
diff --git a/lib/api/src/js/mem_access.rs b/lib/api/src/js/mem_access.rs
deleted file mode 100644
index f8a822d132..0000000000
--- a/lib/api/src/js/mem_access.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-use crate::access::{RefCow, SliceCow, WasmRefAccess, WasmSliceAccess};
-use crate::{MemoryAccessError, WasmRef, WasmSlice};
-use std::mem::{self, MaybeUninit};
-use std::slice;
-
-impl<'a, T> WasmSliceAccess<'a, T>
-where
-    T: wasmer_types::ValueType,
-{
-    pub(crate) fn new(slice: WasmSlice<'a, T>) -> Result<Self, MemoryAccessError> {
-        let buf = slice.read_to_vec()?;
-        Ok(Self {
-            slice,
-            buf: SliceCow::Owned(buf, false),
-        })
-    }
-}
-
-impl<'a, T> WasmRefAccess<'a, T>
-where
-    T: wasmer_types::ValueType,
-{
-    pub(crate) fn new(ptr: WasmRef<'a, T>) -> Result<Self, MemoryAccessError> {
-        let mut out = MaybeUninit::uninit();
-        let buf =
-            unsafe { slice::from_raw_parts_mut(out.as_mut_ptr() as *mut u8, mem::size_of::<T>()) };
-        ptr.buffer.read(ptr.offset, buf)?;
-        let val = unsafe { out.assume_init() };
-
-        Ok(Self {
-            ptr,
-            buf: RefCow::Owned(val, false),
-        })
-    }
-}
-
-impl<'a, T> WasmRefAccess<'a, T>
-where
-    T: wasmer_types::ValueType,
-{
-    /// Reads the address pointed to by this `WasmPtr` in a memory.
-    #[inline]
-    #[allow(clippy::clone_on_copy)]
-    pub fn read(&self) -> T
-    where
-        T: Clone,
-    {
-        self.as_ref().clone()
-    }
-
-    /// Writes to the address pointed to by this `WasmPtr` in a memory.
-    #[inline]
-    pub fn write(&mut self, val: T) {
-        let mut data = MaybeUninit::new(val);
-        let data = unsafe {
-            slice::from_raw_parts_mut(
-                data.as_mut_ptr() as *mut MaybeUninit<u8>,
-                mem::size_of::<T>(),
-            )
-        };
-        val.zero_padding_bytes(data);
-        let data = unsafe { slice::from_raw_parts(data.as_ptr() as *const _, data.len()) };
-        self.ptr.buffer.write(self.ptr.offset, data).unwrap()
-    }
-}
diff --git a/lib/api/src/js/mod.rs b/lib/api/src/js/mod.rs
deleted file mode 100644
index 0584da25f2..0000000000
--- a/lib/api/src/js/mod.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-#[cfg(all(feature = "std", feature = "core"))]
-compile_error!(
-    "The `std` and `core` features are both enabled, which is an error. Please enable only once."
-);
-
-#[cfg(all(not(feature = "std"), not(feature = "core")))]
-compile_error!("Both the `std` and `core` features are disabled. Please enable one of them.");
-
-#[cfg(feature = "core")]
-pub(crate) extern crate alloc;
-
-mod lib {
-    #[cfg(feature = "core")]
-    pub mod std {
-        pub use crate::alloc::{borrow, boxed, str, string, sync, vec};
-        pub use core::fmt;
-        pub use hashbrown as collections;
-    }
-
-    #[cfg(feature = "std")]
-    pub mod std {
-        pub use std::{borrow, boxed, collections, fmt, str, string, sync, vec};
-    }
-}
-
-mod as_js;
-pub(crate) mod engine;
-pub(crate) mod errors;
-pub(crate) mod extern_ref;
-pub(crate) mod externals;
-pub(crate) mod instance;
-mod js_handle;
-pub(crate) mod mem_access;
-pub(crate) mod module;
-pub(crate) mod store;
-pub(crate) mod trap;
-pub(crate) mod typed_function;
-pub(crate) mod vm;
-mod wasm_bindgen_polyfill;
-
-pub use self::{as_js::AsJs, js_handle::current_thread_id, module::ModuleTypeHints};
diff --git a/lib/api/src/js/store.rs b/lib/api/src/js/store.rs
deleted file mode 100644
index 03f229af33..0000000000
--- a/lib/api/src/js/store.rs
+++ /dev/null
@@ -1,266 +0,0 @@
-pub(crate) use objects::{InternalStoreHandle, StoreObject};
-pub use objects::{StoreHandle, StoreObjects};
-
-mod objects {
-    use std::{fmt, marker::PhantomData, num::NonZeroUsize};
-
-    use wasm_bindgen::JsValue;
-
-    use crate::js::vm::{VMFunctionEnvironment, VMGlobal};
-
-    pub use wasmer_types::StoreId;
-
-    /// Trait to represent an object managed by a context. This is implemented on
-    /// the VM types managed by the context.
-    pub trait StoreObject: Sized {
-        fn list(store: &StoreObjects) -> &Vec<Self>;
-        fn list_mut(store: &mut StoreObjects) -> &mut Vec<Self>;
-    }
-
-    macro_rules! impl_store_object {
-    ($($field:ident => $ty:ty,)*) => {
-        $(
-            impl StoreObject for $ty {
-                fn list(store: &StoreObjects) -> &Vec<Self> {
-                    &store.$field
-                }
-                fn list_mut(store: &mut StoreObjects) -> &mut Vec<Self> {
-                    &mut store.$field
-                }
-            }
-        )*
-    };
-}
-
-    impl_store_object! {
-        // Note: we store the globals in order to be able to access them later via
-        // `StoreObjects::iter_globals`.
-        globals => VMGlobal,
-        // functions => VMFunction,
-        // tables => VMTable,
-        // memories => VMMemory,
-        // The function environments are the only things attached to a store,
-        // since the other JS objects (table, globals, memory and functions)
-        // live in the JS VM Store by default
-        function_environments => VMFunctionEnvironment,
-    }
-
-    /// Set of objects managed by a context.
-    #[derive(Default, Debug)]
-    pub struct StoreObjects {
-        id: StoreId,
-        globals: Vec<VMGlobal>,
-        function_environments: Vec<VMFunctionEnvironment>,
-    }
-
-    impl StoreObjects {
-        /// Returns the ID of this context.
-        pub fn id(&self) -> StoreId {
-            self.id
-        }
-
-        /// Sets the ID of this store
-        pub fn set_id(&mut self, id: StoreId) {
-            self.id = id;
-        }
-
-        /// Returns a pair of mutable references from two handles.
-        ///
-        /// Panics if both handles point to the same object.
-        pub fn get_2_mut<T: StoreObject>(
-            &mut self,
-            a: InternalStoreHandle<T>,
-            b: InternalStoreHandle<T>,
-        ) -> (&mut T, &mut T) {
-            assert_ne!(a.index(), b.index());
-            let list = T::list_mut(self);
-            if a.index() < b.index() {
-                let (low, high) = list.split_at_mut(b.index());
-                (&mut low[a.index()], &mut high[0])
-            } else {
-                let (low, high) = list.split_at_mut(a.index());
-                (&mut high[0], &mut low[a.index()])
-            }
-        }
-
-        /// Return an immutable iterator over all globals
-        pub fn iter_globals(&self) -> core::slice::Iter<VMGlobal> {
-            self.globals.iter()
-        }
-
-        /// Return an vector of all globals and converted to u128
-        pub fn as_u128_globals(&self) -> Vec<u128> {
-            self.iter_globals()
-                .map(|v| v.global.value().as_f64().unwrap() as u128)
-                .collect()
-        }
-
-        /// Set a global, at index idx. Will panic if idx is out of range
-        /// Safety: the caller should check that the raw value is compatible
-        /// with destination VMGlobal type
-        pub fn set_global_unchecked(&self, idx: usize, new_val: u128) {
-            assert!(idx < self.globals.len());
-
-            let g = &self.globals[idx].global;
-            let cur_val = g.value().as_f64().unwrap();
-            let new_val = new_val as f64;
-            if cur_val != new_val {
-                let new_value = JsValue::from(new_val);
-                g.set_value(&new_value);
-            }
-        }
-    }
-
-    /// Handle to an object managed by a context.
-    ///
-    /// Internally this is just an integer index into a context. A reference to the
-    /// context must be passed in separately to access the actual object.
-    pub struct StoreHandle<T> {
-        id: StoreId,
-        internal: InternalStoreHandle<T>,
-    }
-
-    impl<T> core::cmp::PartialEq for StoreHandle<T> {
-        fn eq(&self, other: &Self) -> bool {
-            self.id == other.id
-        }
-    }
-
-    impl<T> std::hash::Hash for StoreHandle<T> {
-        fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-            self.id.hash(state);
-            self.internal.idx.hash(state);
-        }
-    }
-
-    impl<T> Clone for StoreHandle<T> {
-        fn clone(&self) -> Self {
-            Self {
-                id: self.id,
-                internal: self.internal,
-            }
-        }
-    }
-
-    impl<T: StoreObject> fmt::Debug for StoreHandle<T> {
-        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            f.debug_struct("StoreHandle")
-                .field("id", &self.id)
-                .field("internal", &self.internal.index())
-                .finish()
-        }
-    }
-
-    impl<T: StoreObject> StoreHandle<T> {
-        /// Moves the given object into a context and returns a handle to it.
-        pub fn new(store: &mut StoreObjects, val: T) -> Self {
-            Self {
-                id: store.id,
-                internal: InternalStoreHandle::new(store, val),
-            }
-        }
-
-        /// Returns a reference to the object that this handle points to.
-        pub fn get<'a>(&self, store: &'a StoreObjects) -> &'a T {
-            assert_eq!(self.id, store.id, "object used with the wrong context");
-            self.internal.get(store)
-        }
-
-        /// Returns a mutable reference to the object that this handle points to.
-        pub fn get_mut<'a>(&self, store: &'a mut StoreObjects) -> &'a mut T {
-            assert_eq!(self.id, store.id, "object used with the wrong context");
-            self.internal.get_mut(store)
-        }
-
-        /// Returns the internal handle contains within this handle.
-        pub fn internal_handle(&self) -> InternalStoreHandle<T> {
-            self.internal
-        }
-
-        /// Returns the ID of the context associated with the handle.
-        #[allow(unused)]
-        pub fn store_id(&self) -> StoreId {
-            self.id
-        }
-
-        /// Overrides the store id with a new ID
-        #[allow(unused)]
-        pub fn set_store_id(&mut self, id: StoreId) {
-            self.id = id;
-        }
-
-        /// Constructs a `StoreHandle` from a `StoreId` and an `InternalStoreHandle`.
-        ///
-        /// # Safety
-        /// Handling `InternalStoreHandle` values is unsafe because they do not track context ID.
-        pub unsafe fn from_internal(id: StoreId, internal: InternalStoreHandle<T>) -> Self {
-            Self { id, internal }
-        }
-    }
-
-    /// Internal handle to an object owned by the current context.
-    ///
-    /// Unlike `StoreHandle` this does not track the context ID: it is only
-    /// intended to be used within objects already owned by a context.
-    #[repr(transparent)]
-    pub struct InternalStoreHandle<T> {
-        // Use a NonZero here to reduce the size of Option<InternalStoreHandle>.
-        idx: NonZeroUsize,
-        marker: PhantomData<fn() -> T>,
-    }
-
-    impl<T> Clone for InternalStoreHandle<T> {
-        fn clone(&self) -> Self {
-            *self
-        }
-    }
-    impl<T> Copy for InternalStoreHandle<T> {}
-
-    impl<T> fmt::Debug for InternalStoreHandle<T> {
-        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            f.debug_struct("InternalStoreHandle")
-                .field("idx", &self.idx)
-                .finish()
-        }
-    }
-    impl<T> PartialEq for InternalStoreHandle<T> {
-        fn eq(&self, other: &Self) -> bool {
-            self.idx == other.idx
-        }
-    }
-    impl<T> Eq for InternalStoreHandle<T> {}
-
-    impl<T: StoreObject> InternalStoreHandle<T> {
-        /// Moves the given object into a context and returns a handle to it.
-        pub fn new(store: &mut StoreObjects, val: T) -> Self {
-            let list = T::list_mut(store);
-            let idx = NonZeroUsize::new(list.len() + 1).unwrap();
-            list.push(val);
-            Self {
-                idx,
-                marker: PhantomData,
-            }
-        }
-
-        /// Returns a reference to the object that this handle points to.
-        pub fn get<'a>(&self, store: &'a StoreObjects) -> &'a T {
-            &T::list(store)[self.idx.get() - 1]
-        }
-
-        /// Returns a mutable reference to the object that this handle points to.
-        pub fn get_mut<'a>(&self, store: &'a mut StoreObjects) -> &'a mut T {
-            &mut T::list_mut(store)[self.idx.get() - 1]
-        }
-
-        pub(crate) fn index(&self) -> usize {
-            self.idx.get()
-        }
-
-        pub(crate) fn from_index(idx: usize) -> Option<Self> {
-            NonZeroUsize::new(idx).map(|idx| Self {
-                idx,
-                marker: PhantomData,
-            })
-        }
-    }
-}
diff --git a/lib/api/src/js/vm.rs b/lib/api/src/js/vm.rs
deleted file mode 100644
index 3d227050da..0000000000
--- a/lib/api/src/js/vm.rs
+++ /dev/null
@@ -1,291 +0,0 @@
-/// This module is mainly used to create the `VM` types that will hold both
-/// the JS values of the `Memory`, `Table`, `Global` and `Function` and also
-/// it's types.
-/// This module should not be needed any longer (with the exception of the memory)
-/// once the type reflection is added to the WebAssembly JS API.
-/// https://github.com/WebAssembly/js-types/
-use std::{any::Any, fmt};
-
-use js_sys::{
-    Function as JsFunction,
-    WebAssembly::{self, Memory as JsMemory, Table as JsTable},
-};
-use serde::{Deserialize, Serialize};
-use tracing::trace;
-use wasm_bindgen::{JsCast, JsValue};
-use wasmer_types::{
-    FunctionType, GlobalType, MemoryError, MemoryType, Pages, RawValue, TableType, WASM_PAGE_SIZE,
-};
-
-use crate::js::{js_handle::JsHandle, wasm_bindgen_polyfill::Global as JsGlobal};
-
-/// Represents linear memory that is managed by the javascript runtime
-#[derive(Clone, Debug, PartialEq)]
-pub struct VMMemory {
-    pub(crate) memory: JsHandle<JsMemory>,
-    pub(crate) ty: MemoryType,
-}
-
-unsafe impl Send for VMMemory {}
-unsafe impl Sync for VMMemory {}
-
-#[derive(Serialize, Deserialize)]
-struct DummyBuffer {
-    #[serde(rename = "byteLength")]
-    byte_length: u32,
-}
-
-impl VMMemory {
-    /// Creates a new memory directly from a WebAssembly javascript object
-    pub fn new(memory: JsMemory, ty: MemoryType) -> Self {
-        Self {
-            memory: JsHandle::new(memory),
-            ty,
-        }
-    }
-
-    /// Returns the size of the memory buffer in pages
-    pub fn get_runtime_size(&self) -> u32 {
-        let dummy: DummyBuffer = match serde_wasm_bindgen::from_value(self.memory.buffer()) {
-            Ok(o) => o,
-            Err(_) => return 0,
-        };
-        if dummy.byte_length == 0 {
-            return 0;
-        }
-        dummy.byte_length / WASM_PAGE_SIZE as u32
-    }
-
-    /// Attempts to clone this memory (if its clonable)
-    pub(crate) fn try_clone(&self) -> Result<VMMemory, MemoryError> {
-        Ok(self.clone())
-    }
-
-    /// Copies this memory to a new memory
-    #[deprecated = "use `copy` instead"]
-    pub fn duplicate(&mut self) -> Result<VMMemory, wasmer_types::MemoryError> {
-        self.copy()
-    }
-
-    /// Copies this memory to a new memory
-    pub fn copy(&mut self) -> Result<VMMemory, wasmer_types::MemoryError> {
-        let new_memory = crate::js::externals::memory::Memory::js_memory_from_type(&self.ty)?;
-
-        let src = crate::js::externals::memory_view::MemoryView::new_raw(&self.memory);
-        let amount = src.data_size() as usize;
-
-        trace!(%amount, "memory copy started");
-
-        let mut dst = crate::js::externals::memory_view::MemoryView::new_raw(&new_memory);
-        let dst_size = dst.data_size() as usize;
-
-        if amount > dst_size {
-            let delta = amount - dst_size;
-            let pages = ((delta - 1) / WASM_PAGE_SIZE) + 1;
-
-            let our_js_memory: &crate::js::externals::memory::JSMemory =
-                JsCast::unchecked_from_js_ref(&new_memory);
-            our_js_memory.grow(pages as u32).map_err(|err| {
-                if err.is_instance_of::<js_sys::RangeError>() {
-                    let cur_pages = dst_size;
-                    MemoryError::CouldNotGrow {
-                        current: Pages(cur_pages as u32),
-                        attempted_delta: Pages(pages as u32),
-                    }
-                } else {
-                    MemoryError::Generic(err.as_string().unwrap())
-                }
-            })?;
-
-            dst = crate::js::externals::memory_view::MemoryView::new_raw(&new_memory);
-        }
-
-        src.copy_to_memory(amount as u64, &dst).map_err(|err| {
-            wasmer_types::MemoryError::Generic(format!("failed to copy the memory - {}", err))
-        })?;
-
-        trace!("memory copy finished (size={})", dst.size().bytes().0);
-
-        Ok(Self {
-            memory: JsHandle::new(new_memory),
-            ty: self.ty.clone(),
-        })
-    }
-}
-
-impl From<VMMemory> for JsValue {
-    fn from(value: VMMemory) -> Self {
-        JsValue::from(value.memory)
-    }
-}
-
-impl From<VMMemory> for (JsValue, MemoryType) {
-    fn from(value: VMMemory) -> Self {
-        (JsValue::from(value.memory), value.ty)
-    }
-}
-
-/// The shared memory is the same as the normal memory
-pub type VMSharedMemory = VMMemory;
-
-/// The VM Global type
-#[derive(Clone, Debug, PartialEq)]
-pub struct VMGlobal {
-    pub(crate) global: JsGlobal,
-    pub(crate) ty: GlobalType,
-}
-
-impl VMGlobal {
-    pub(crate) fn new(global: JsGlobal, ty: GlobalType) -> Self {
-        Self { global, ty }
-    }
-}
-
-unsafe impl Send for VMGlobal {}
-unsafe impl Sync for VMGlobal {}
-
-/// The VM Table type
-#[derive(Clone, Debug, PartialEq)]
-pub struct VMTable {
-    pub(crate) table: JsTable,
-    pub(crate) ty: TableType,
-}
-
-unsafe impl Send for VMTable {}
-unsafe impl Sync for VMTable {}
-
-impl VMTable {
-    pub(crate) fn new(table: JsTable, ty: TableType) -> Self {
-        Self { table, ty }
-    }
-
-    /// Get the table size at runtime
-    pub fn get_runtime_size(&self) -> u32 {
-        self.table.length()
-    }
-}
-
-/// The VM Function type
-#[derive(Clone)]
-pub struct VMFunction {
-    pub(crate) function: JsHandle<JsFunction>,
-    pub(crate) ty: FunctionType,
-}
-
-unsafe impl Send for VMFunction {}
-unsafe impl Sync for VMFunction {}
-
-impl VMFunction {
-    pub(crate) fn new(function: JsFunction, ty: FunctionType) -> Self {
-        Self {
-            function: JsHandle::new(function),
-            ty,
-        }
-    }
-}
-
-impl PartialEq for VMFunction {
-    fn eq(&self, other: &Self) -> bool {
-        self.function == other.function
-    }
-}
-
-impl fmt::Debug for VMFunction {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("VMFunction")
-            .field("function", &self.function)
-            .finish()
-    }
-}
-
-/// The value of an export passed from one instance to another.
-pub enum VMExtern {
-    /// A function export value.
-    Function(VMFunction),
-
-    /// A table export value.
-    Table(VMTable),
-
-    /// A memory export value.
-    Memory(VMMemory),
-
-    /// A global export value.
-    Global(VMGlobal),
-}
-
-pub type VMInstance = WebAssembly::Instance;
-
-/// Underlying FunctionEnvironment used by a `VMFunction`.
-#[derive(Debug)]
-pub struct VMFunctionEnvironment {
-    contents: Box<dyn Any + Send + 'static>,
-}
-
-impl VMFunctionEnvironment {
-    /// Wraps the given value to expose it to Wasm code as a function context.
-    pub fn new(val: impl Any + Send + 'static) -> Self {
-        Self {
-            contents: Box::new(val),
-        }
-    }
-
-    #[allow(clippy::should_implement_trait)]
-    /// Returns a reference to the underlying value.
-    pub fn as_ref(&self) -> &(dyn Any + Send + 'static) {
-        &*self.contents
-    }
-
-    #[allow(clippy::should_implement_trait)]
-    /// Returns a mutable reference to the underlying value.
-    pub fn as_mut(&mut self) -> &mut (dyn Any + Send + 'static) {
-        &mut *self.contents
-    }
-}
-
-pub(crate) struct VMExternRef;
-
-impl VMExternRef {
-    /// Converts the `VMExternRef` into a `RawValue`.
-    pub fn into_raw(self) -> RawValue {
-        unimplemented!();
-    }
-
-    /// Extracts a `VMExternRef` from a `RawValue`.
-    ///
-    /// # Safety
-    /// `raw` must be a valid `VMExternRef` instance.
-    pub unsafe fn from_raw(_raw: RawValue) -> Option<Self> {
-        unimplemented!();
-    }
-}
-
-#[repr(C)]
-pub struct VMFunctionBody(u8);
-
-#[repr(transparent)]
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub(crate) struct VMFuncRef;
-
-impl VMFuncRef {
-    /// Converts the `VMFuncRef` into a `RawValue`.
-    pub fn into_raw(self) -> RawValue {
-        unimplemented!();
-    }
-
-    /// Extracts a `VMFuncRef` from a `RawValue`.
-    ///
-    /// # Safety
-    /// `raw.funcref` must be a valid pointer.
-    pub unsafe fn from_raw(_raw: RawValue) -> Option<Self> {
-        unimplemented!();
-    }
-}
-
-pub struct VMTrampoline;
-
-pub(crate) type VMExternTable = VMTable;
-pub(crate) type VMExternMemory = VMMemory;
-pub(crate) type VMExternGlobal = VMGlobal;
-pub(crate) type VMExternFunction = VMFunction;
-
-pub type VMFunctionCallback = *const VMFunctionBody;
diff --git a/lib/api/src/js/wasm_bindgen_polyfill.rs b/lib/api/src/js/wasm_bindgen_polyfill.rs
deleted file mode 100644
index 80f89a6a70..0000000000
--- a/lib/api/src/js/wasm_bindgen_polyfill.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-use js_sys::Object;
-use wasm_bindgen::prelude::*;
-
-// WebAssembly.Global
-#[wasm_bindgen]
-extern "C" {
-    /// The `WebAssembly.Global()` constructor creates a new `Global` object
-    /// of the given type and value.
-    ///
-    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global)
-    #[wasm_bindgen(js_namespace = WebAssembly, extends = Object, typescript_type = "WebAssembly.Global")]
-    #[derive(Clone, Debug, PartialEq, Eq)]
-    pub type Global;
-
-    /// The `WebAssembly.Global()` constructor creates a new `Global` object
-    /// of the given type and value.
-    ///
-    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global)
-    #[allow(unused_doc_comments)]
-    #[wasm_bindgen(constructor, js_namespace = WebAssembly, catch)]
-    pub fn new(global_descriptor: &Object, value: &JsValue) -> Result<Global, JsValue>;
-
-    /// The value prototype property of the `WebAssembly.Global` object
-    /// returns the value of the global.
-    ///
-    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global)
-    #[allow(unused_doc_comments)]
-    #[wasm_bindgen(method, getter, structural, js_namespace = WebAssembly)]
-    pub fn value(this: &Global) -> JsValue;
-
-    #[wasm_bindgen(method, setter = value, structural, js_namespace = WebAssembly)]
-    pub fn set_value(this: &Global, value: &JsValue);
-}
diff --git a/lib/api/src/jsc/errors.rs b/lib/api/src/jsc/errors.rs
deleted file mode 100644
index 88f20ba28e..0000000000
--- a/lib/api/src/jsc/errors.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-use rusty_jsc::JSValue;
-
-use crate::jsc::trap::Trap;
-use crate::RuntimeError;
-
-impl From<Trap> for RuntimeError {
-    fn from(trap: Trap) -> Self {
-        if trap.is::<RuntimeError>() {
-            return trap.downcast::<RuntimeError>().unwrap();
-        }
-        let wasm_trace = vec![];
-        let trap_code = None;
-        // let (wasm_trace, trap_code) = wasmer_compiler::get_trace_and_trapcode(&trap);
-        RuntimeError::new_from_source(trap, wasm_trace, trap_code)
-    }
-}
-
-impl From<RuntimeError> for JSValue {
-    fn from(_err: RuntimeError) -> Self {
-        // err.inner.source.into()
-        unimplemented!();
-    }
-}
-
-pub(crate) fn raise(error: Box<dyn std::error::Error + Send + Sync>) -> ! {
-    unimplemented!()
-    // let error = Trap::user(error);
-    // let js_error: JsValue = error.into();
-    // wasm_bindgen::throw_val(js_error)
-}
diff --git a/lib/api/src/jsc/externals/function.rs b/lib/api/src/jsc/externals/function.rs
deleted file mode 100644
index bfe64f5b94..0000000000
--- a/lib/api/src/jsc/externals/function.rs
+++ /dev/null
@@ -1,582 +0,0 @@
-use crate::errors::RuntimeError;
-use crate::externals::function::{HostFunction, HostFunctionKind, WithEnv, WithoutEnv};
-use crate::function_env::{FunctionEnv, FunctionEnvMut};
-use crate::jsc::as_js::{param_from_js, AsJs};
-use crate::jsc::engine::JSC;
-use crate::jsc::store::{InternalStoreHandle, StoreHandle};
-use crate::jsc::trap::Trap;
-use crate::jsc::vm::{VMExtern, VMFuncRef, VMFunction, VMFunctionCallback, VMFunctionEnvironment};
-use crate::native_type::{FromToNativeWasmType, IntoResult, NativeWasmTypeInto, WasmTypeList};
-use crate::store::{AsStoreMut, AsStoreRef, StoreMut};
-use crate::value::Value;
-use std::fmt;
-use std::marker::PhantomData;
-use std::panic::{self, AssertUnwindSafe};
-
-use wasmer_types::{FunctionType, RawValue};
-
-use rusty_jsc::{
-    callback, callback_closure, JSContext, JSObject, JSObjectCallAsFunctionCallback, JSValue,
-};
-
-#[derive(Clone, PartialEq)]
-pub struct Function {
-    pub(crate) handle: VMFunction,
-}
-
-// Function can't be Send in js because it dosen't support `structuredClone`
-// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
-// unsafe impl Send for Function {}
-
-impl From<VMFunction> for Function {
-    fn from(handle: VMFunction) -> Self {
-        Self { handle }
-    }
-}
-
-impl Function {
-    /// To `VMExtern`.
-    pub fn to_vm_extern(&self) -> VMExtern {
-        VMExtern::Function(self.handle.clone())
-    }
-
-    #[allow(clippy::cast_ptr_alignment)]
-    pub fn new_with_env<FT, F, T: Send + 'static>(
-        store: &mut impl AsStoreMut,
-        env: &FunctionEnv<T>,
-        ty: FT,
-        func: F,
-    ) -> Self
-    where
-        FT: Into<FunctionType>,
-        F: Fn(FunctionEnvMut<'_, T>, &[Value]) -> Result<Vec<Value>, RuntimeError>
-            + 'static
-            + Send
-            + Sync,
-    {
-        let store = store.as_store_mut();
-        let context = store.jsc().context();
-        let function_type = ty.into();
-
-        let new_function_type = function_type.clone();
-        let raw_env = env.clone();
-
-        let callback = callback_closure!(&context, move |ctx: JSContext,
-                                                         function: JSObject,
-                                                         this: JSObject,
-                                                         args: &[JSValue]|
-              -> Result<JSValue, JSValue> {
-            let global = ctx.get_global_object();
-            let store_ptr = global
-                .get_property(&ctx, "__store_ptr".to_string())
-                .to_number(&ctx)
-                .unwrap();
-
-            let mut store = unsafe { StoreMut::from_raw(store_ptr as usize as *mut _) };
-
-            let env: FunctionEnvMut<T> = raw_env.clone().into_mut(&mut store);
-
-            let wasm_arguments = new_function_type
-                .params()
-                .iter()
-                .enumerate()
-                .map(|(i, param)| param_from_js(&ctx, param, &args[i]))
-                .collect::<Vec<_>>();
-            let results = func(env, &wasm_arguments).map_err(|e| {
-                let value = format!("{}", e);
-                JSValue::string(&ctx, value)
-            })?;
-            match new_function_type.results().len() {
-                0 => Ok(JSValue::undefined(&ctx)),
-                1 => Ok(results[0].as_jsvalue(&mut store)),
-                _ => Ok(JSObject::new_array(
-                    &ctx,
-                    &results
-                        .into_iter()
-                        .map(|result| result.as_jsvalue(&mut store))
-                        .collect::<Vec<_>>(),
-                )?
-                .to_jsvalue()),
-            }
-        });
-
-        let vm_function = VMFunction::new(callback, function_type);
-        Self {
-            handle: vm_function,
-        }
-    }
-
-    /// Creates a new host `Function` from a native function.
-    pub fn new_typed<F, Args, Rets>(store: &mut impl AsStoreMut, func: F) -> Self
-    where
-        F: HostFunction<(), Args, Rets, WithoutEnv> + 'static + Send + Sync,
-        Args: WasmTypeList,
-        Rets: WasmTypeList,
-    {
-        let store = store.as_store_mut();
-        let function = WasmFunction::<Args, Rets>::new(func);
-        let callback = function.callback(store.jsc().context());
-
-        let ty = function.ty();
-        let vm_function = VMFunction::new(callback, ty);
-        Self {
-            handle: vm_function,
-        }
-    }
-
-    pub fn new_typed_with_env<T, F, Args, Rets>(
-        store: &mut impl AsStoreMut,
-        env: &FunctionEnv<T>,
-        func: F,
-    ) -> Self
-    where
-        F: HostFunction<T, Args, Rets, WithEnv>,
-        Args: WasmTypeList,
-        Rets: WasmTypeList,
-    {
-        let store = store.as_store_mut();
-        let context = store.jsc().context();
-        let function = WasmFunction::<Args, Rets>::new(func);
-        let callback = function.callback(store.jsc().context());
-
-        let bind = callback
-            .get_property(&context, "bind".to_string())
-            .to_object(&context)
-            .unwrap();
-        let callback_with_env = bind
-            .call(
-                &context,
-                Some(&callback),
-                &[
-                    JSValue::undefined(&context),
-                    JSValue::number(&context, env.handle.internal_handle().index() as f64),
-                ],
-            )
-            .unwrap()
-            .to_object(&context)
-            .unwrap();
-
-        let ty = function.ty();
-        let vm_function = VMFunction::new(callback_with_env, ty);
-        Self {
-            handle: vm_function,
-        }
-    }
-
-    pub fn ty(&self, _store: &impl AsStoreRef) -> FunctionType {
-        self.handle.ty.clone()
-    }
-
-    pub fn call_raw(
-        &self,
-        _store: &mut impl AsStoreMut,
-        _params: Vec<RawValue>,
-    ) -> Result<Box<[Value]>, RuntimeError> {
-        // There is no optimal call_raw in JSC, so we just
-        // simply rely the call
-        // self.call(store, params)
-        unimplemented!();
-    }
-
-    pub fn call(
-        &self,
-        store: &mut impl AsStoreMut,
-        params: &[Value],
-    ) -> Result<Box<[Value]>, RuntimeError> {
-        let store_mut = store.as_store_mut();
-        let engine = store_mut.engine();
-        let context = engine.0.context();
-
-        let mut global = context.get_global_object();
-        let store_ptr = store_mut.as_raw() as usize;
-        global.set_property(
-            &context,
-            "__store_ptr".to_string(),
-            JSValue::number(&context, store_ptr as _),
-        );
-
-        let params_list = params
-            .iter()
-            .map(|v| v.as_jsvalue(&store_mut))
-            .collect::<Vec<_>>();
-        let result = {
-            let mut r;
-            // TODO: This loop is needed for asyncify. It will be refactored with https://github.com/wasmerio/wasmer/issues/3451
-            loop {
-                let store_mut = store.as_store_mut();
-                let engine = store_mut.engine();
-                let context = engine.0.context();
-                r = self.handle.function.call(&context, None, &params_list);
-                if let Some(callback) = store_mut.inner.on_called.take() {
-                    match callback(store_mut) {
-                        Ok(wasmer_types::OnCalledAction::InvokeAgain) => {
-                            continue;
-                        }
-                        Ok(wasmer_types::OnCalledAction::Finish) => {
-                            break;
-                        }
-                        Ok(wasmer_types::OnCalledAction::Trap(trap)) => {
-                            return Err(RuntimeError::user(trap))
-                        }
-                        Err(trap) => return Err(RuntimeError::user(trap)),
-                    }
-                }
-                break;
-            }
-            r?
-        };
-        let result_types = self.handle.ty.results();
-        let store_mut = store.as_store_mut();
-        let engine = store_mut.engine();
-        let context = engine.0.context();
-        match result_types.len() {
-            0 => Ok(Box::new([])),
-            1 => {
-                let value = param_from_js(&context, &result_types[0], &result);
-                Ok(vec![value].into_boxed_slice())
-            }
-            n => {
-                let result = result.to_object(&context).unwrap();
-                Ok((0..n)
-                    .map(|i| {
-                        let js_val = result.get_property_at_index(&context, i as _).unwrap();
-                        param_from_js(&context, &result_types[i], &js_val)
-                    })
-                    .collect::<Vec<_>>()
-                    .into_boxed_slice())
-            }
-        }
-    }
-
-    pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, internal: VMFunction) -> Self {
-        Self { handle: internal }
-    }
-
-    pub(crate) fn vm_funcref(&self, _store: &impl AsStoreRef) -> VMFuncRef {
-        unimplemented!();
-    }
-
-    pub(crate) unsafe fn from_vm_funcref(
-        _store: &mut impl AsStoreMut,
-        _funcref: VMFuncRef,
-    ) -> Self {
-        unimplemented!();
-    }
-
-    /// Checks whether this `Function` can be used with the given context.
-    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
-        true
-    }
-}
-
-impl fmt::Debug for Function {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.debug_struct("Function").finish()
-    }
-}
-
-/// Represents a low-level Wasm static host function. See
-/// `super::Function::new` and `super::Function::new_env` to learn
-/// more.
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-pub struct WasmFunction<Args = (), Rets = ()> {
-    callback: JSObjectCallAsFunctionCallback,
-    _phantom: PhantomData<(Args, Rets)>,
-}
-
-unsafe impl<Args, Rets> Send for WasmFunction<Args, Rets> {}
-
-impl<Args, Rets> WasmFunction<Args, Rets>
-where
-    Args: WasmTypeList,
-    Rets: WasmTypeList,
-{
-    /// Creates a new `WasmFunction`.
-    #[allow(dead_code)]
-    pub fn new<F, T, Kind: HostFunctionKind>(function: F) -> Self
-    where
-        F: HostFunction<T, Args, Rets, Kind>,
-        T: Sized,
-    {
-        Self {
-            callback: function.function_callback(),
-            _phantom: PhantomData,
-        }
-    }
-
-    /// Get the function type of this `WasmFunction`.
-    #[allow(dead_code)]
-    pub fn ty(&self) -> FunctionType {
-        FunctionType::new(Args::wasm_types(), Rets::wasm_types())
-    }
-
-    /// Get the address of this `WasmFunction`.
-    #[allow(dead_code)]
-    pub fn callback(&self, context: &JSContext) -> JSObject {
-        JSObject::new_function_with_callback(context, "FunctionCallback".to_string(), self.callback)
-    }
-}
-
-macro_rules! impl_host_function {
-        ( [$c_struct_representation:ident]
-           $c_struct_name:ident,
-           $( $x:ident ),* ) => {
-
-            // Implement `HostFunction` for a function with a [`FunctionEnvMut`] that has the same
-            // arity than the tuple.
-            #[allow(unused_parens)]
-            impl< $( $x, )* Rets, RetsAsResult, T, Func >
-                HostFunction<T, ( $( $x ),* ), Rets, WithEnv>
-            for
-                Func
-            where
-                $( $x: FromToNativeWasmType, )*
-                Rets: WasmTypeList,
-                RetsAsResult: IntoResult<Rets>,
-                T: Send + 'static,
-                Func: Fn(FunctionEnvMut<'_, T>, $( $x , )*) -> RetsAsResult + 'static,
-            {
-                #[allow(non_snake_case)]
-                fn function_callback(&self) -> VMFunctionCallback {
-                    #[callback]
-                    fn fn_callback<T, $( $x, )* Rets, RetsAsResult, Func>(
-                        ctx: JSContext,
-                        function: JSObject,
-                        this_object: JSObject,
-                        arguments: &[JSValue],
-                    ) -> Result<JSValue, JSValue>
-                    where
-                        $( $x: FromToNativeWasmType, )*
-                        Rets: WasmTypeList,
-                        RetsAsResult: IntoResult<Rets>,
-                        Func: Fn(FunctionEnvMut<'_, T>, $( $x , )*) -> RetsAsResult + 'static,
-                        T: Send + 'static,
-                    {
-                        use std::convert::TryInto;
-
-                        let func: &Func = &*(&() as *const () as *const Func);
-                        let global = ctx.get_global_object();
-                        let store_ptr = global.get_property(&ctx, "__store_ptr".to_string()).to_number(&ctx).unwrap();
-                        if store_ptr.is_nan() {
-                            panic!("Store pointer is invalid. Received {}", store_ptr as usize)
-                        }
-                        let mut store = StoreMut::from_raw(store_ptr as usize as *mut _);
-
-                        let handle_index = arguments[0].to_number(&ctx).unwrap() as usize;
-                        let handle: StoreHandle<VMFunctionEnvironment> = StoreHandle::from_internal(store.objects_mut().id(), InternalStoreHandle::from_index(handle_index).unwrap());
-                        let env: FunctionEnvMut<T> = FunctionEnv::from_handle(handle).into_mut(&mut store);
-
-                        let result = panic::catch_unwind(AssertUnwindSafe(|| {
-                            type JSArray<'a> = &'a [JSValue; count_idents!( $( $x ),* )];
-                            let args_without_store: JSArray = arguments[1..].try_into().unwrap();
-                            let [ $( $x ),* ] = args_without_store;
-                            let mut store = StoreMut::from_raw(store_ptr as usize as *mut _);
-                            func(env, $( FromToNativeWasmType::from_native( $x::Native::from_raw(&mut store, RawValue { u128: {
-                                // TODO: This may not be the fastest way, but JSC doesn't expose a BigInt interface
-                                // so the only thing we can do is parse from the string repr
-                                if $x.is_number(&ctx) {
-                                    $x.to_number(&ctx).unwrap() as _
-                                }
-                                else {
-                                    $x.to_string(&ctx).unwrap().to_string().parse::<u128>().unwrap()
-                                }
-                            } }) ) ),* ).into_result()
-                        }));
-
-                        match result {
-                            Ok(Ok(result)) => {
-                                match Rets::size() {
-                                    0 => {Ok(JSValue::undefined(&ctx))},
-                                    1 => {
-                                        // unimplemented!();
-
-                                        let ty = Rets::wasm_types()[0];
-                                        let mut arr = result.into_array(&mut store);
-                                        // Value::from_raw(&store, ty, arr[0])
-                                        let val = Value::from_raw(&mut store, ty, arr.as_mut()[0]);
-                                        let value: JSValue = val.as_jsvalue(&store);
-                                        Ok(value)
-                                        // *mut_rets = val.as_raw(&mut store);
-                                    }
-                                    _n => {
-                                        // if !results.is_array(&context) {
-                                        //     panic!("Expected results to be an array.")
-                                        // }
-                                        let mut arr = result.into_array(&mut store);
-                                        let result_values = Rets::wasm_types().iter().enumerate().map(|(i, ret_type)| {
-                                            let raw = arr.as_mut()[i];
-                                            Value::from_raw(&mut store, *ret_type, raw).as_jsvalue(&mut store)
-                                        }).collect::<Vec<_>>();
-                                        Ok(JSObject::new_array(&ctx, &result_values).unwrap().to_jsvalue())
-                                    }
-                                }
-                            },
-                            #[cfg(feature = "std")]
-                            Ok(Err(err)) => {
-                                let trap: Trap = Trap::user(Box::new(err));
-                                Err(trap.into_jsvalue(&ctx))
-                            },
-                            #[cfg(feature = "core")]
-                            Ok(Err(err)) => {
-                                let trap: Trap = Trap::user(Box::new(err));
-                                Err(trap.into_jsvalue(&ctx))
-                            },
-                            Err(panic) => {
-                                Err(JSValue::string(&ctx, format!("panic: {:?}", panic)))
-                                // We can't just resume the unwind, because it will put
-                                // JavacriptCore in a bad state, so we need to transform
-                                // the error
-
-                                // std::panic::resume_unwind(panic)
-                            },
-                        }
-
-                    }
-                    Some(fn_callback::<T, $( $x, )* Rets, RetsAsResult, Self > as _)
-                }
-            }
-
-            // Implement `HostFunction` for a function that has the same arity than the tuple.
-            #[allow(unused_parens)]
-            impl< $( $x, )* Rets, RetsAsResult, Func >
-                HostFunction<(), ( $( $x ),* ), Rets, WithoutEnv>
-            for
-                Func
-            where
-                $( $x: FromToNativeWasmType, )*
-                Rets: WasmTypeList,
-                RetsAsResult: IntoResult<Rets>,
-                Func: Fn($( $x , )*) -> RetsAsResult + 'static,
-            {
-                #[allow(non_snake_case)]
-                fn function_callback(&self) -> VMFunctionCallback {
-
-                    #[callback]
-                    fn fn_callback<$( $x, )* Rets, RetsAsResult, Func>(
-                        ctx: JSContext,
-                        function: JSObject,
-                        this_object: JSObject,
-                        arguments: &[JSValue],
-                    ) -> Result<JSValue, JSValue>
-                    where
-                        $( $x: FromToNativeWasmType, )*
-                        Rets: WasmTypeList,
-                        RetsAsResult: IntoResult<Rets>,
-                        Func: Fn($( $x , )*) -> RetsAsResult + 'static,
-                        // $( $x: NativeWasmTypeInto, )*
-                    {
-                        use std::convert::TryInto;
-
-                        let func: &Func = &*(&() as *const () as *const Func);
-                        let global = ctx.get_global_object();
-                        let store_ptr = global.get_property(&ctx, "__store_ptr".to_string()).to_number(&ctx).unwrap();
-                        if store_ptr.is_nan() {
-                            panic!("Store pointer is invalid. Received {}", store_ptr as usize)
-                        }
-
-                        let mut store = StoreMut::from_raw(store_ptr as usize as *mut _);
-                        let result = panic::catch_unwind(AssertUnwindSafe(|| {
-                            type JSArray<'a> = &'a [JSValue; count_idents!( $( $x ),* )];
-                            let args_without_store: JSArray = arguments.try_into().unwrap();
-                            let [ $( $x ),* ] = args_without_store;
-                            func($( FromToNativeWasmType::from_native( $x::Native::from_raw(&mut store, RawValue { u128: {
-                                // TODO: This may not be the fastest way, but JSC doesn't expose a BigInt interface
-                                // so the only thing we can do is parse from the string repr
-                                if $x.is_number(&ctx) {
-                                    $x.to_number(&ctx).unwrap() as _
-                                }
-                                else {
-                                    $x.to_string(&ctx).unwrap().to_string().parse::<u128>().unwrap()
-                                }
-                            } }) ) ),* ).into_result()
-                        }));
-
-                        match result {
-                            Ok(Ok(result)) => {
-                                match Rets::size() {
-                                    0 => {Ok(JSValue::undefined(&ctx))},
-                                    1 => {
-                                        let ty = Rets::wasm_types()[0];
-                                        let mut arr = result.into_array(&mut store);
-                                        let val = Value::from_raw(&mut store, ty, arr.as_mut()[0]);
-                                        let value: JSValue = val.as_jsvalue(&store);
-                                        Ok(value)
-                                    }
-                                    _n => {
-                                        let mut arr = result.into_array(&mut store);
-                                        let result_values = Rets::wasm_types().iter().enumerate().map(|(i, ret_type)| {
-                                            let raw = arr.as_mut()[i];
-                                            Value::from_raw(&mut store, *ret_type, raw).as_jsvalue(&mut store)
-                                        }).collect::<Vec<_>>();
-                                        Ok(JSObject::new_array(&ctx, &result_values).unwrap().to_jsvalue())
-                                    }
-                                }
-                            },
-                            #[cfg(feature = "std")]
-                            Ok(Err(err)) => {
-                                let trap: Trap = Trap::user(Box::new(err));
-                                Err(trap.into_jsvalue(&ctx))
-                            },
-                            #[cfg(feature = "core")]
-                            Ok(Err(err)) => {
-                                let trap: Trap = Trap::user(Box::new(err));
-                                Err(trap.into_jsvalue(&ctx))
-                            },
-                            Err(panic) => {
-                                Err(JSValue::string(&ctx, format!("panic: {:?}", panic)))
-                                // We can't just resume the unwind, because it will put
-                                // JavacriptCore in a bad state, so we need to transform
-                                // the error
-
-                                // std::panic::resume_unwind(panic)
-                            },
-                        }
-
-                    }
-                    Some(fn_callback::< $( $x, )* Rets, RetsAsResult, Self > as _)
-                }
-            }
-        };
-    }
-
-// Black-magic to count the number of identifiers at compile-time.
-macro_rules! count_idents {
-    ( $($idents:ident),* ) => {
-        {
-            #[allow(dead_code, non_camel_case_types)]
-            enum Idents { $( $idents, )* __CountIdentsLast }
-            const COUNT: usize = Idents::__CountIdentsLast as usize;
-            COUNT
-        }
-    };
-}
-
-// Here we go! Let's generate all the C struct, `WasmTypeList`
-// implementations and `HostFunction` implementations.
-impl_host_function!([C] S0,);
-impl_host_function!([transparent] S1, A1);
-impl_host_function!([C] S2, A1, A2);
-impl_host_function!([C] S3, A1, A2, A3);
-impl_host_function!([C] S4, A1, A2, A3, A4);
-impl_host_function!([C] S5, A1, A2, A3, A4, A5);
-impl_host_function!([C] S6, A1, A2, A3, A4, A5, A6);
-impl_host_function!([C] S7, A1, A2, A3, A4, A5, A6, A7);
-impl_host_function!([C] S8, A1, A2, A3, A4, A5, A6, A7, A8);
-impl_host_function!([C] S9, A1, A2, A3, A4, A5, A6, A7, A8, A9);
-impl_host_function!([C] S10, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
-impl_host_function!([C] S11, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
-impl_host_function!([C] S12, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
-impl_host_function!([C] S13, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
-impl_host_function!([C] S14, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
-impl_host_function!([C] S15, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
-impl_host_function!([C] S16, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16);
-impl_host_function!([C] S17, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17);
-impl_host_function!([C] S18, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18);
-impl_host_function!([C] S19, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19);
-impl_host_function!([C] S20, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20);
-impl_host_function!([C] S21, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21);
-impl_host_function!([C] S22, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22);
-impl_host_function!([C] S23, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23);
-impl_host_function!([C] S24, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24);
-impl_host_function!([C] S25, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25);
-impl_host_function!([C] S26, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26);
diff --git a/lib/api/src/jsc/externals/mod.rs b/lib/api/src/jsc/externals/mod.rs
deleted file mode 100644
index 3575fe23bb..0000000000
--- a/lib/api/src/jsc/externals/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-pub(crate) mod function;
-pub(crate) mod global;
-pub(crate) mod memory;
-pub(crate) mod memory_view;
-pub(crate) mod table;
diff --git a/lib/api/src/jsc/mem_access.rs b/lib/api/src/jsc/mem_access.rs
deleted file mode 100644
index f878ed6e5c..0000000000
--- a/lib/api/src/jsc/mem_access.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-use crate::access::{RefCow, SliceCow, WasmRefAccess, WasmSliceAccess};
-use crate::{MemoryAccessError, WasmRef, WasmSlice};
-use std::mem;
-
-impl<'a, T> WasmSliceAccess<'a, T>
-where
-    T: wasmer_types::ValueType,
-{
-    pub(crate) fn new(slice: WasmSlice<'a, T>) -> Result<Self, MemoryAccessError> {
-        let total_len = slice
-            .len
-            .checked_mul(mem::size_of::<T>() as u64)
-            .ok_or(MemoryAccessError::Overflow)?;
-        let end = slice
-            .offset
-            .checked_add(total_len)
-            .ok_or(MemoryAccessError::Overflow)?;
-        if end > slice.buffer.0.len as u64 {
-            tracing::warn!(
-                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
-                total_len,
-                end,
-                slice.buffer.0.len
-            );
-            return Err(MemoryAccessError::HeapOutOfBounds);
-        }
-        let buf = unsafe {
-            let buf_ptr: *mut u8 = slice.buffer.0.base.add(slice.offset as usize);
-            let buf_ptr: *mut T = std::mem::transmute(buf_ptr);
-            std::slice::from_raw_parts_mut(buf_ptr, slice.len as usize)
-        };
-        Ok(Self {
-            slice,
-            buf: SliceCow::Borrowed(buf),
-        })
-    }
-}
-
-impl<'a, T> WasmRefAccess<'a, T>
-where
-    T: wasmer_types::ValueType,
-{
-    pub(crate) fn new(ptr: WasmRef<'a, T>) -> Result<Self, MemoryAccessError> {
-        let total_len = mem::size_of::<T>() as u64;
-        let end = ptr
-            .offset
-            .checked_add(total_len)
-            .ok_or(MemoryAccessError::Overflow)?;
-        if end > ptr.buffer.0.len as u64 {
-            tracing::warn!(
-                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
-                total_len,
-                end,
-                ptr.buffer.0.len
-            );
-            return Err(MemoryAccessError::HeapOutOfBounds);
-        }
-        let val = unsafe {
-            let val_ptr: *mut u8 = ptr.buffer.0.base.add(ptr.offset as usize);
-            let val_ptr: *mut T = std::mem::transmute(val_ptr);
-            &mut *val_ptr
-        };
-        Ok(Self {
-            ptr,
-            buf: RefCow::Borrowed(val),
-        })
-    }
-}
-
-impl<'a, T> WasmRefAccess<'a, T>
-where
-    T: wasmer_types::ValueType,
-{
-    /// Reads the address pointed to by this `WasmPtr` in a memory.
-    #[inline]
-    #[allow(clippy::clone_on_copy)]
-    pub fn read(&self) -> T
-    where
-        T: Clone,
-    {
-        self.as_ref().clone()
-    }
-
-    /// Writes to the address pointed to by this `WasmPtr` in a memory.
-    #[inline]
-    pub fn write(&mut self, val: T) {
-        // Note: Zero padding is not required here as its a typed copy which does
-        //       not leak the bytes into the memory
-        // https://stackoverflow.com/questions/61114026/does-stdptrwrite-transfer-the-uninitialized-ness-of-the-bytes-it-writes
-        *(self.as_mut()) = val;
-    }
-}
diff --git a/lib/api/src/jsc/mod.rs b/lib/api/src/jsc/mod.rs
deleted file mode 100644
index 3a195e3225..0000000000
--- a/lib/api/src/jsc/mod.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//! The JavascriptCore integration in the Wasmer API
-
-#[cfg(all(feature = "std", feature = "core"))]
-compile_error!(
-    "The `std` and `core` features are both enabled, which is an error. Please enable only once."
-);
-
-#[cfg(all(not(feature = "std"), not(feature = "core")))]
-compile_error!("Both the `std` and `core` features are disabled. Please enable one of them.");
-
-#[cfg(feature = "core")]
-pub(crate) extern crate alloc;
-
-mod lib {
-    #[cfg(feature = "core")]
-    pub mod std {
-        pub use crate::alloc::{borrow, boxed, str, string, sync, vec};
-        pub use core::fmt;
-        pub use hashbrown as collections;
-    }
-
-    #[cfg(feature = "std")]
-    pub mod std {
-        pub use std::{borrow, boxed, collections, fmt, str, string, sync, vec};
-    }
-}
-
-pub(crate) mod as_js;
-pub(crate) mod engine;
-pub(crate) mod errors;
-pub(crate) mod extern_ref;
-pub(crate) mod externals;
-pub(crate) mod instance;
-pub(crate) mod mem_access;
-pub(crate) mod module;
-pub(crate) mod store;
-pub(crate) mod trap;
-pub(crate) mod typed_function;
-pub(crate) mod vm;
diff --git a/lib/api/src/jsc/store.rs b/lib/api/src/jsc/store.rs
deleted file mode 100644
index b6e28dc409..0000000000
--- a/lib/api/src/jsc/store.rs
+++ /dev/null
@@ -1,264 +0,0 @@
-pub(crate) use objects::{InternalStoreHandle, StoreObject};
-pub use objects::{StoreHandle, StoreObjects};
-
-mod objects {
-    use rusty_jsc::{JSContext, JSObject, JSValue};
-
-    use crate::jsc::vm::{VMFunctionEnvironment, VMGlobal};
-    use std::{fmt, marker::PhantomData, num::NonZeroUsize};
-    pub use wasmer_types::StoreId;
-
-    /// Trait to represent an object managed by a context. This is implemented on
-    /// the VM types managed by the context.
-    pub trait StoreObject: Sized {
-        fn list(store: &StoreObjects) -> &Vec<Self>;
-        fn list_mut(store: &mut StoreObjects) -> &mut Vec<Self>;
-    }
-
-    macro_rules! impl_store_object {
-    ($($field:ident => $ty:ty,)*) => {
-        $(
-            impl StoreObject for $ty {
-                fn list(store: &StoreObjects) -> &Vec<Self> {
-                    &store.$field
-                }
-                fn list_mut(store: &mut StoreObjects) -> &mut Vec<Self> {
-                    &mut store.$field
-                }
-            }
-        )*
-    };
-}
-
-    impl_store_object! {
-        // Note: we store the globals in order to be able to access them later via
-        // `StoreObjects::iter_globals`.
-        globals => VMGlobal,
-        // functions => VMFunction,
-        // tables => VMTable,
-        // memories => VMMemory,
-        // The function environments are the only things attached to a store,
-        // since the other JS objects (table, globals, memory and functions)
-        // live in the JS VM Store by default
-        function_environments => VMFunctionEnvironment,
-    }
-
-    /// Set of objects managed by a context.
-    #[derive(Default, Debug)]
-    pub struct StoreObjects {
-        id: StoreId,
-        globals: Vec<VMGlobal>,
-        function_environments: Vec<VMFunctionEnvironment>,
-    }
-
-    impl StoreObjects {
-        /// Returns the ID of this context.
-        pub fn id(&self) -> StoreId {
-            self.id
-        }
-
-        /// Sets the ID of this store
-        pub fn set_id(&mut self, id: StoreId) {
-            self.id = id;
-        }
-
-        /// Returns a pair of mutable references from two handles.
-        ///
-        /// Panics if both handles point to the same object.
-        pub fn get_2_mut<T: StoreObject>(
-            &mut self,
-            a: InternalStoreHandle<T>,
-            b: InternalStoreHandle<T>,
-        ) -> (&mut T, &mut T) {
-            assert_ne!(a.index(), b.index());
-            let list = T::list_mut(self);
-            if a.index() < b.index() {
-                let (low, high) = list.split_at_mut(b.index());
-                (&mut low[a.index()], &mut high[0])
-            } else {
-                let (low, high) = list.split_at_mut(a.index());
-                (&mut high[0], &mut low[a.index()])
-            }
-        }
-
-        /// Return an immutable iterator over all globals
-        pub fn iter_globals(&self) -> core::slice::Iter<VMGlobal> {
-            self.globals.iter()
-        }
-
-        /// Return an vector of all globals and converted to u128
-        pub fn as_u128_globals(&self) -> Vec<u128> {
-            vec![]
-            // self.iter_globals()
-            //     .map(|v| v.global.value().as_f64().unwrap() as u128)
-            //     .collect()
-        }
-
-        /// Set a global, at index idx. Will panic if idx is out of range
-        /// Safety: the caller should check taht the raw value is compatible
-        /// with destination VMGlobal type
-        pub fn set_global_unchecked(&self, idx: usize, new_val: u128) {
-            assert!(idx < self.globals.len());
-            // let g = &self.globals[idx].global;
-            // let cur_val = g.value().as_f64().unwrap();
-            // let new_val = new_val as f64;
-            // if cur_val != new_val {
-            //     let new_value = JSValue::from(new_val);
-            //     g.set_value(&new_value);
-            // }
-        }
-    }
-
-    /// Handle to an object managed by a context.
-    ///
-    /// Internally this is just an integer index into a context. A reference to the
-    /// context must be passed in separately to access the actual object.
-    pub struct StoreHandle<T> {
-        id: StoreId,
-        internal: InternalStoreHandle<T>,
-    }
-
-    impl<T> core::cmp::PartialEq for StoreHandle<T> {
-        fn eq(&self, other: &Self) -> bool {
-            self.id == other.id
-        }
-    }
-
-    impl<T> std::hash::Hash for StoreHandle<T> {
-        fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-            self.id.hash(state);
-            self.internal.idx.hash(state);
-        }
-    }
-
-    impl<T> Clone for StoreHandle<T> {
-        fn clone(&self) -> Self {
-            Self {
-                id: self.id,
-                internal: self.internal,
-            }
-        }
-    }
-
-    impl<T: StoreObject> fmt::Debug for StoreHandle<T> {
-        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            f.debug_struct("StoreHandle")
-                .field("id", &self.id)
-                .field("internal", &self.internal.index())
-                .finish()
-        }
-    }
-
-    impl<T: StoreObject> StoreHandle<T> {
-        /// Moves the given object into a context and returns a handle to it.
-        pub fn new(store: &mut StoreObjects, val: T) -> Self {
-            Self {
-                id: store.id,
-                internal: InternalStoreHandle::new(store, val),
-            }
-        }
-
-        /// Returns a reference to the object that this handle points to.
-        pub fn get<'a>(&self, store: &'a StoreObjects) -> &'a T {
-            assert_eq!(self.id, store.id, "object used with the wrong context");
-            self.internal.get(store)
-        }
-
-        /// Returns a mutable reference to the object that this handle points to.
-        pub fn get_mut<'a>(&self, store: &'a mut StoreObjects) -> &'a mut T {
-            assert_eq!(self.id, store.id, "object used with the wrong context");
-            self.internal.get_mut(store)
-        }
-
-        /// Returns the internal handle contains within this handle.
-        pub fn internal_handle(&self) -> InternalStoreHandle<T> {
-            self.internal
-        }
-
-        /// Returns the ID of the context associated with the handle.
-        #[allow(unused)]
-        pub fn store_id(&self) -> StoreId {
-            self.id
-        }
-
-        /// Overrides the store id with a new ID
-        #[allow(unused)]
-        pub fn set_store_id(&mut self, id: StoreId) {
-            self.id = id;
-        }
-
-        /// Constructs a `StoreHandle` from a `StoreId` and an `InternalStoreHandle`.
-        ///
-        /// # Safety
-        /// Handling `InternalStoreHandle` values is unsafe because they do not track context ID.
-        pub unsafe fn from_internal(id: StoreId, internal: InternalStoreHandle<T>) -> Self {
-            Self { id, internal }
-        }
-    }
-
-    /// Internal handle to an object owned by the current context.
-    ///
-    /// Unlike `StoreHandle` this does not track the context ID: it is only
-    /// intended to be used within objects already owned by a context.
-    #[repr(transparent)]
-    pub struct InternalStoreHandle<T> {
-        // Use a NonZero here to reduce the size of Option<InternalStoreHandle>.
-        idx: NonZeroUsize,
-        marker: PhantomData<fn() -> T>,
-    }
-
-    impl<T> Clone for InternalStoreHandle<T> {
-        fn clone(&self) -> Self {
-            *self
-        }
-    }
-    impl<T> Copy for InternalStoreHandle<T> {}
-
-    impl<T> fmt::Debug for InternalStoreHandle<T> {
-        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            f.debug_struct("InternalStoreHandle")
-                .field("idx", &self.idx)
-                .finish()
-        }
-    }
-    impl<T> PartialEq for InternalStoreHandle<T> {
-        fn eq(&self, other: &Self) -> bool {
-            self.idx == other.idx
-        }
-    }
-    impl<T> Eq for InternalStoreHandle<T> {}
-
-    impl<T: StoreObject> InternalStoreHandle<T> {
-        /// Moves the given object into a context and returns a handle to it.
-        pub fn new(store: &mut StoreObjects, val: T) -> Self {
-            let list = T::list_mut(store);
-            let idx = NonZeroUsize::new(list.len() + 1).unwrap();
-            list.push(val);
-            Self {
-                idx,
-                marker: PhantomData,
-            }
-        }
-
-        /// Returns a reference to the object that this handle points to.
-        pub fn get<'a>(&self, store: &'a StoreObjects) -> &'a T {
-            &T::list(store)[self.idx.get() - 1]
-        }
-
-        /// Returns a mutable reference to the object that this handle points to.
-        pub fn get_mut<'a>(&self, store: &'a mut StoreObjects) -> &'a mut T {
-            &mut T::list_mut(store)[self.idx.get() - 1]
-        }
-
-        pub(crate) fn index(&self) -> usize {
-            self.idx.get()
-        }
-
-        pub(crate) fn from_index(idx: usize) -> Option<Self> {
-            NonZeroUsize::new(idx).map(|idx| Self {
-                idx,
-                marker: PhantomData,
-            })
-        }
-    }
-}
diff --git a/lib/api/src/jsc/vm.rs b/lib/api/src/jsc/vm.rs
deleted file mode 100644
index 23bcf683ae..0000000000
--- a/lib/api/src/jsc/vm.rs
+++ /dev/null
@@ -1,270 +0,0 @@
-/// This module is mainly used to create the `VM` types that will hold both
-/// the JS values of the `Memory`, `Table`, `Global` and `Function` and also
-/// it's types.
-/// This module should not be needed any longer (with the exception of the memory)
-/// once the type reflection is added to the WebAssembly JS API.
-/// https://github.com/WebAssembly/js-types/
-use crate::store::AsStoreRef;
-use rusty_jsc::{JSObject, JSObjectCallAsFunctionCallback, JSValue};
-use std::any::Any;
-use std::fmt;
-use tracing::trace;
-use wasmer_types::RawValue;
-use wasmer_types::{
-    FunctionType, GlobalType, MemoryError, MemoryType, Pages, TableType, WASM_PAGE_SIZE,
-};
-
-/// Represents linear memory that is managed by the javascript runtime
-#[derive(Clone, Debug, PartialEq)]
-pub struct VMMemory {
-    pub(crate) memory: JSObject,
-    pub(crate) ty: MemoryType,
-}
-
-unsafe impl Send for VMMemory {}
-unsafe impl Sync for VMMemory {}
-
-impl VMMemory {
-    /// Creates a new memory directly from a WebAssembly javascript object
-    pub fn new(memory: JSObject, ty: MemoryType) -> Self {
-        Self { memory, ty }
-    }
-
-    /// Returns the size of the memory buffer in pages
-    pub fn get_runtime_size(&self) -> u32 {
-        unimplemented!();
-        // let dummy: DummyBuffer = match serde_wasm_bindgen::from_value(self.memory.buffer()) {
-        //     Ok(o) => o,
-        //     Err(_) => return 0,
-        // };
-        // if dummy.byte_length == 0 {
-        //     return 0;
-        // }
-        // dummy.byte_length / WASM_PAGE_SIZE as u32
-    }
-
-    /// Attempts to clone this memory (if its clonable)
-    pub(crate) fn try_clone(&self) -> Result<VMMemory, MemoryError> {
-        Ok(self.clone())
-    }
-
-    /// Copies this memory to a new memory
-    #[deprecated = "use `copy` instead"]
-    pub fn duplicate(
-        &mut self,
-        store: &impl AsStoreRef,
-    ) -> Result<VMMemory, wasmer_types::MemoryError> {
-        self.copy(store)
-    }
-
-    /// Copies this memory to a new memory
-    pub fn copy(&self, store: &impl AsStoreRef) -> Result<VMMemory, wasmer_types::MemoryError> {
-        let new_memory =
-            crate::jsc::externals::memory::Memory::js_memory_from_type(&store, &self.ty)?;
-
-        trace!("memory copy started");
-
-        let src = crate::jsc::externals::memory_view::MemoryView::new_raw(&self.memory, store);
-        let amount = src.data_size() as usize;
-        let mut dst = crate::jsc::externals::memory_view::MemoryView::new_raw(&new_memory, store);
-        let dst_size = dst.data_size() as usize;
-
-        // if amount > dst_size {
-        //     let delta = amount - dst_size;
-        //     let pages = ((delta - 1) / WASM_PAGE_SIZE) + 1;
-
-        //     let our_js_memory: &crate::jsc::externals::memory::JSMemory =
-        //         JsCast::unchecked_from_js_ref(&new_memory);
-        //     our_js_memory.grow(pages as u32).map_err(|err| {
-        //         if err.is_instance_of::<js_sys::RangeError>() {
-        //             let cur_pages = dst_size;
-        //             MemoryError::CouldNotGrow {
-        //                 current: Pages(cur_pages as u32),
-        //                 attempted_delta: Pages(pages as u32),
-        //             }
-        //         } else {
-        //             MemoryError::Generic(err.as_string().unwrap())
-        //         }
-        //     })?;
-
-        //     dst = crate::jsc::externals::memory_view::MemoryView::new_raw(&new_memory);
-        // }
-
-        src.copy_to_memory(amount as u64, &dst).map_err(|err| {
-            wasmer_types::MemoryError::Generic(format!("failed to copy the memory - {}", err))
-        })?;
-
-        trace!("memory copy finished (size={})", dst.size().bytes().0);
-
-        Ok(Self {
-            memory: new_memory,
-            ty: self.ty.clone(),
-        })
-    }
-}
-
-// impl From<VMMemory> for JSValue {
-//     fn from(value: VMMemory) -> Self {
-//         JSValue::from(value.memory)
-//     }
-// }
-
-/// The shared memory is the same as the normal memory
-pub type VMSharedMemory = VMMemory;
-
-/// The VM Global type
-#[derive(Clone, Debug, PartialEq)]
-pub struct VMGlobal {
-    pub(crate) global: JSObject,
-    pub(crate) ty: GlobalType,
-}
-
-impl VMGlobal {
-    pub(crate) fn new(global: JSObject, ty: GlobalType) -> Self {
-        Self { global, ty }
-    }
-}
-
-unsafe impl Send for VMGlobal {}
-unsafe impl Sync for VMGlobal {}
-
-/// The VM Table type
-#[derive(Clone, Debug, PartialEq)]
-pub struct VMTable {
-    pub(crate) table: JSObject,
-    pub(crate) ty: TableType,
-}
-
-unsafe impl Send for VMTable {}
-unsafe impl Sync for VMTable {}
-
-impl VMTable {
-    pub(crate) fn new(table: JSObject, ty: TableType) -> Self {
-        Self { table, ty }
-    }
-
-    /// Get the table size at runtime
-    pub fn get_runtime_size(&self) -> u32 {
-        unimplemented!();
-        // self.table.length()
-    }
-}
-
-/// The VM Function type
-#[derive(Clone)]
-pub struct VMFunction {
-    pub(crate) function: JSObject,
-    pub(crate) ty: FunctionType,
-}
-
-unsafe impl Send for VMFunction {}
-unsafe impl Sync for VMFunction {}
-
-impl VMFunction {
-    pub(crate) fn new(function: JSObject, ty: FunctionType) -> Self {
-        Self { function, ty }
-    }
-}
-
-impl PartialEq for VMFunction {
-    fn eq(&self, other: &Self) -> bool {
-        self.function == other.function
-    }
-}
-
-impl fmt::Debug for VMFunction {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("VMFunction")
-            .field("function", &self.function)
-            .finish()
-    }
-}
-
-/// The value of an export passed from one instance to another.
-pub enum VMExtern {
-    /// A function export value.
-    Function(VMFunction),
-
-    /// A table export value.
-    Table(VMTable),
-
-    /// A memory export value.
-    Memory(VMMemory),
-
-    /// A global export value.
-    Global(VMGlobal),
-}
-
-pub type VMInstance = JSObject;
-
-/// Underlying FunctionEnvironment used by a `VMFunction`.
-#[derive(Debug)]
-pub struct VMFunctionEnvironment {
-    contents: Box<dyn Any + Send + 'static>,
-}
-
-impl VMFunctionEnvironment {
-    /// Wraps the given value to expose it to Wasm code as a function context.
-    pub fn new(val: impl Any + Send + 'static) -> Self {
-        Self {
-            contents: Box::new(val),
-        }
-    }
-
-    #[allow(clippy::should_implement_trait)]
-    /// Returns a reference to the underlying value.
-    pub fn as_ref(&self) -> &(dyn Any + Send + 'static) {
-        &*self.contents
-    }
-
-    #[allow(clippy::should_implement_trait)]
-    /// Returns a mutable reference to the underlying value.
-    pub fn as_mut(&mut self) -> &mut (dyn Any + Send + 'static) {
-        &mut *self.contents
-    }
-}
-
-pub(crate) struct VMExternRef;
-
-impl VMExternRef {
-    /// Converts the `VMExternRef` into a `RawValue`.
-    pub fn into_raw(self) -> RawValue {
-        unimplemented!();
-    }
-
-    /// Extracts a `VMExternRef` from a `RawValue`.
-    ///
-    /// # Safety
-    /// `raw` must be a valid `VMExternRef` instance.
-    pub unsafe fn from_raw(_raw: RawValue) -> Option<Self> {
-        unimplemented!();
-    }
-}
-
-#[repr(transparent)]
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub(crate) struct VMFuncRef;
-
-impl VMFuncRef {
-    /// Converts the `VMFuncRef` into a `RawValue`.
-    pub fn into_raw(self) -> RawValue {
-        unimplemented!();
-    }
-
-    /// Extracts a `VMFuncRef` from a `RawValue`.
-    ///
-    /// # Safety
-    /// `raw.funcref` must be a valid pointer.
-    pub unsafe fn from_raw(_raw: RawValue) -> Option<Self> {
-        unimplemented!();
-    }
-}
-
-pub struct VMTrampoline;
-
-pub(crate) type VMExternTable = VMTable;
-pub(crate) type VMExternMemory = VMMemory;
-pub(crate) type VMExternGlobal = VMGlobal;
-pub(crate) type VMExternFunction = VMFunction;
-
-pub type VMFunctionCallback = JSObjectCallAsFunctionCallback;
diff --git a/lib/api/src/lib.rs b/lib/api/src/lib.rs
old mode 100755
new mode 100644
index c1dd8814fd..3627094333
--- a/lib/api/src/lib.rs
+++ b/lib/api/src/lib.rs
@@ -9,7 +9,12 @@
     rustdoc::broken_intra_doc_links
 )]
 #![warn(unused_import_braces)]
-#![allow(clippy::new_without_default, clippy::vtable_address_comparisons)]
+#![allow(
+    clippy::new_without_default,
+    ambiguous_wide_pointer_comparisons,
+    unreachable_patterns,
+    unused
+)]
 #![warn(
     clippy::float_arithmetic,
     clippy::mut_mut,
@@ -19,13 +24,11 @@
     clippy::unicode_not_nfc,
     clippy::use_self
 )]
-#![allow(deprecated_cfg_attr_crate_type_name)]
-#![cfg_attr(feature = "js", crate_type = "cdylib")]
 
 //! [`Wasmer`](https://wasmer.io/) is the most popular
 //! [WebAssembly](https://webassembly.org/) runtime for Rust. It supports
 //! JIT (Just In Time) and AOT (Ahead Of Time) compilation as well as
-//! pluggable compilers suited to your needs.
+//! pluggable compilers suited to your needs and interpreters.
 //!
 //! It's designed to be safe and secure, and runnable in any kind of environment.
 //!
@@ -42,7 +45,7 @@
 //!     (module
 //!       (type $t0 (func (param i32) (result i32)))
 //!       (func $add_one (export "add_one") (type $t0) (param $p0 i32) (result i32)
-//!         get_local $p0
+//!         local.get $p0
 //!         i32.const 1
 //!         i32.add))
 //!     "#;
@@ -76,6 +79,10 @@
 //!   * [`wasmer-compiler-llvm`] provides a deeply optimized executable
 //!     code with the fastest runtime speed, ideal for production.
 //!
+//! * **Interpreters** - Wasmer supports interpeters such as [`wamr`] and [`wasmi`].
+//!
+//! * **Other runtimes** - Wasmer supports [`v8`].
+//!
 //! * **Headless mode** — Once a WebAssembly module has been compiled, it
 //!   is possible to serialize it in a file for example, and later execute
 //!   it with Wasmer with headless mode turned on. Headless Wasmer has no
@@ -227,8 +234,6 @@
 //! on top of this API that you may be interested in using, including:
 //!
 //! - [`wasmer-cache`] for caching compiled Wasm modules,
-//! - [`wasmer-emscripten`] for running Wasm modules compiled to the
-//!   Emscripten ABI,
 //! - [`wasmer-wasix`] for running Wasm modules compiled to the WASI ABI.
 //!
 //! The Wasmer project has two major abstractions:
@@ -243,31 +248,41 @@
 //! The engine is a system that uses a compiler to make a WebAssembly
 //! module executable.
 //!
-//! ## Compilers
+//! ## Runtimes
 //!
-//! A compiler is a system that handles the details of making a Wasm
-//! module executable. For example, by generating native machine code
-//! for each Wasm function.
+//! A runtime is a system that handles the details of making a Wasm module executable. We support
+//! multiple kinds of runtimes: compilers, which generate native machine code for each Wasm
+//! function and interpreter, in which no native machine code is generated and can be used on
+//! platforms where JIT compilation is not allowed, such as iOS.
 //!
 //! # Cargo Features
 //!
-//! This crate comes in 2 flavors:
-//!
 //! 1. `sys`
 #![cfg_attr(feature = "sys", doc = "(enabled),")]
 #![cfg_attr(not(feature = "sys"), doc = "(disabled),")]
 //!    where `wasmer` will be compiled to a native executable
 //!    which provides compilers, engines, a full VM etc.
-//! 2. `js`
+//!    By default, the `singlepass` and `cranelift` backends are enabled.
+//!
+//! 2. `v8`
+#![cfg_attr(feature = "v8", doc = "(enabled),")]
+#![cfg_attr(not(feature = "v8"), doc = "(disabled),")]
+//!   where `wasmer` will be compiled to a native executable
+//!   where the `v8` runtime is used for execution.
+//!
+//! 3. `wamr`
+#![cfg_attr(feature = "wamr", doc = "(enabled),")]
+#![cfg_attr(not(feature = "wamr"), doc = "(disabled),")]
+//!   where `wasmer` will be compiled to a native executable
+//!   where `wamr` (in interpreter mode) is used for execution.
+//!
+//! 4. `js`
 #![cfg_attr(feature = "js", doc = "(enabled),")]
 #![cfg_attr(not(feature = "js"), doc = "(disabled),")]
 //!    where `wasmer` will be compiled to WebAssembly to run in a
 //!    JavaScript host (see [Using Wasmer in a JavaScript
 //!    environment](#using-wasmer-in-a-javascript-environment)).
 //!
-//! Consequently, we can group the features by the `sys` or `js`
-//! features.
-//!
 #![cfg_attr(
     feature = "sys",
     doc = "## Features for the `sys` feature group (enabled)"
@@ -305,6 +320,10 @@
 #![cfg_attr(not(feature = "compiler"), doc = "(disabled),")]
 //!   enables compilation with the wasmer engine.
 //!
+//! Notice that the `sys`, `wamr` and `v8` features are composable together,
+//! so a single build of Wasmer using `llvm`, `cranelift`, `singlepass`, `wamr`, and `v8`
+//! (or any combination of them) is possible.
+//!
 #![cfg_attr(
     feature = "js",
     doc = "## Features for the `js` feature group (enabled)"
@@ -355,7 +374,7 @@
 //!     (module
 //!       (type $t0 (func (param i32) (result i32)))
 //!       (func $add_one (export "add_one") (type $t0) (param $p0 i32) (result i32)
-//!         get_local $p0
+//!         local.get $p0
 //!         i32.const 1
 //!         i32.add))
 //!     "#;
@@ -383,150 +402,118 @@
 //! [wasmer-examples]: https://github.com/wasmerio/wasmer/tree/main/examples
 //! [`wasmer-cache`]: https://docs.rs/wasmer-cache/
 //! [wasmer-compiler]: https://docs.rs/wasmer-compiler/
-//! [`wasmer-emscripten`]: https://docs.rs/wasmer-emscripten/
 //! [`wasmer-compiler-singlepass`]: https://docs.rs/wasmer-compiler-singlepass/
 //! [`wasmer-compiler-llvm`]: https://docs.rs/wasmer-compiler-llvm/
 //! [`wasmer-compiler-cranelift`]: https://docs.rs/wasmer-compiler-cranelift/
 //! [`wasmer-wasix`]: https://docs.rs/wasmer-wasix/
 //! [`wasm-pack`]: https://github.com/rustwasm/wasm-pack/
 //! [`wasm-bindgen`]: https://github.com/rustwasm/wasm-bindgen
+//! [`v8`]: https://v8.dev/
+//! [`wamr`]: https://github.com/bytecodealliance/wasm-micro-runtime
+//! [`wasmi`]: https://github.com/wasmi-labs/wasmi
 
-#[cfg(all(not(feature = "sys"), not(feature = "js"), not(feature = "jsc")))]
-compile_error!("One of: `sys`, `js` or `jsc` features must be enabled. Please, pick one.");
-
-#[cfg(all(feature = "sys", feature = "js"))]
-compile_error!(
-    "Cannot have both `sys` and `js` features enabled at the same time. Please, pick one."
-);
-
-#[cfg(all(feature = "js", feature = "jsc"))]
-compile_error!(
-    "Cannot have both `js` and `jsc` features enabled at the same time. Please, pick one."
-);
-
-#[cfg(all(feature = "sys", feature = "jsc"))]
-compile_error!(
-    "Cannot have both `sys` and `jsc` features enabled at the same time. Please, pick one."
-);
-
-#[cfg(all(feature = "sys", target_arch = "wasm32"))]
-compile_error!("The `sys` feature must be enabled only for non-`wasm32` target.");
-
-#[cfg(all(feature = "jsc", target_arch = "wasm32"))]
-compile_error!("The `jsc` feature must be enabled only for non-`wasm32` target.");
-
-#[cfg(all(feature = "js", not(target_arch = "wasm32")))]
+#[cfg(not(any(
+    feature = "sys",
+    feature = "js",
+    feature = "jsc",
+    feature = "wamr",
+    feature = "v8",
+    feature = "wasmi"
+)))]
 compile_error!(
-    "The `js` feature must be enabled only for the `wasm32` target (either `wasm32-unknown-unknown` or `wasm32-wasi`)."
+    "One of: `sys`, `js`, `jsc` `wamr`, `wasmi` or `v8` features must be enabled. Please, pick one."
 );
 
-mod access;
-mod engine;
-mod errors;
-mod exports;
-mod extern_ref;
-mod externals;
-mod function_env;
-mod imports;
-mod instance;
-mod into_bytes;
-mod mem_access;
-mod module;
-mod native_type;
-mod ptr;
-mod store;
-mod typed_function;
-mod value;
-pub mod vm;
-
-#[cfg(any(feature = "wasm-types-polyfill", feature = "jsc"))]
-mod module_info_polyfill;
+mod utils;
+pub use utils::*;
 
-#[cfg(feature = "sys")]
-/// sys
-pub mod sys;
+mod entities;
+pub use entities::memory::{location::MemoryLocation, MemoryView};
+pub use entities::*;
 
-#[cfg(feature = "sys")]
-pub use sys::*;
+mod error;
+pub use error::*;
 
-#[cfg(feature = "sys")]
-#[deprecated(note = "wasmer::Artifact is deprecated, use wasmer::sys::Artifact instead")]
-/// A compiled wasm module, ready to be instantiated.
-pub type Artifact = sys::Artifact;
-#[cfg(feature = "sys")]
-#[deprecated(note = "wasmer::EngineBuilder is deprecated, use wasmer::sys::EngineBuilder instead")]
-/// The Builder contents of `Engine`
-pub type EngineBuilder = sys::EngineBuilder;
-#[cfg(feature = "sys")]
-#[deprecated(note = "wasmer::Features is deprecated, use wasmer::sys::Features instead")]
-/// Controls which experimental features will be enabled.
-pub type Features = sys::Features;
-#[cfg(feature = "sys")]
-#[deprecated(note = "wasmer::BaseTunables is deprecated, use wasmer::sys::BaseTunables instead")]
-/// Tunable parameters for WebAssembly compilation.
-/// This is the reference implementation of the `Tunables` trait,
-/// used by default.
-pub type BaseTunables = sys::BaseTunables;
-#[cfg(feature = "sys")]
-#[deprecated(note = "wasmer::VMConfig is deprecated, use wasmer::sys::VMConfig instead")]
-/// Configuration for the runtime VM
-/// Currently only the stack size is configurable
-pub type VMConfig = sys::VMConfig;
+mod backend;
+pub use backend::*;
+mod vm;
 
-#[cfg(feature = "js")]
-mod js;
-
-#[cfg(feature = "js")]
-pub use js::*;
-
-#[cfg(feature = "jsc")]
-mod jsc;
-
-#[cfg(feature = "jsc")]
-pub use jsc::*;
-
-pub use crate::externals::{
-    Extern, Function, Global, HostFunction, Memory, MemoryLocation, MemoryView, SharedMemory, Table,
-};
-pub use access::WasmSliceAccess;
-pub use engine::{AsEngineRef, Engine, EngineRef};
-pub use errors::{AtomicsError, InstantiationError, LinkError, RuntimeError};
-pub use exports::{ExportError, Exportable, Exports, ExportsIterator};
-pub use extern_ref::ExternRef;
-pub use function_env::{FunctionEnv, FunctionEnvMut};
-pub use imports::Imports;
-pub use instance::Instance;
-pub use into_bytes::IntoBytes;
-pub use mem_access::{MemoryAccessError, WasmRef, WasmSlice, WasmSliceIter};
-pub use module::{IoCompileError, Module};
-pub use native_type::{FromToNativeWasmType, NativeWasmTypeInto, WasmTypeList};
-pub use ptr::{Memory32, Memory64, MemorySize, WasmPtr, WasmPtr64};
-pub use store::{
-    AsStoreMut, AsStoreRef, OnCalledHandler, Store, StoreId, StoreMut, StoreObjects, StoreRef,
+pub use wasmer_types::{
+    is_wasm, Bytes, CompileError, DeserializeError, ExportIndex, ExportType, ExternType, FrameInfo,
+    FunctionType, GlobalInit, GlobalType, ImportType, LocalFunctionIndex, MemoryError, MemoryStyle,
+    MemoryType, Mutability, OnCalledAction, Pages, ParseCpuFeatureError, SerializeError,
+    TableStyle, TableType, TagKind, TagType, Type, ValueType, WasmError, WasmResult,
+    WASM_MAX_PAGES, WASM_MIN_PAGES, WASM_PAGE_SIZE,
 };
-#[cfg(feature = "sys")]
-pub use store::{TrapHandlerFn, Tunables};
-#[cfg(any(feature = "sys", feature = "jsc"))]
-pub use target_lexicon::{Architecture, CallingConvention, OperatingSystem, Triple, HOST};
-pub use typed_function::TypedFunction;
-pub use value::Value;
 
-// Reexport from other modules
+#[cfg(feature = "wasmparser")]
+pub use wasmparser;
 
-pub use wasmer_derive::ValueType;
-// TODO: OnCalledAction is needed for asyncify. It will be refactored with https://github.com/wasmerio/wasmer/issues/3451
-pub use wasmer_types::{
-    is_wasm, Bytes, CompileError, CpuFeature, DeserializeError, ExportIndex, ExportType,
-    ExternType, FrameInfo, FunctionType, GlobalInit, GlobalType, ImportType, LocalFunctionIndex,
-    MemoryError, MemoryType, MiddlewareError, Mutability, OnCalledAction, Pages,
-    ParseCpuFeatureError, SerializeError, TableType, Target, Type, ValueType, WasmError,
-    WasmResult, WASM_MAX_PAGES, WASM_MIN_PAGES, WASM_PAGE_SIZE,
-};
 #[cfg(feature = "wat")]
 pub use wat::parse_bytes as wat2wasm;
 
-#[cfg(feature = "wasmparser")]
-pub use wasmparser;
+pub use wasmer_derive::ValueType;
 
-/// Version number of this crate.
-pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+#[cfg(any(
+    all(
+        feature = "sys-default",
+        any(
+            feature = "js-default",
+            feature = "jsc-default",
+            feature = "wamr-default",
+            feature = "v8-default",
+            feature = "wasmi-default"
+        )
+    ),
+    all(
+        feature = "js-default",
+        any(
+            feature = "sys-default",
+            feature = "jsc-default",
+            feature = "wamr-default",
+            feature = "v8-default",
+            feature = "wasmi-default"
+        )
+    ),
+    all(
+        feature = "jsc-default",
+        any(
+            feature = "sys-default",
+            feature = "js-default",
+            feature = "wamr-default",
+            feature = "v8-default",
+            feature = "wasmi-default"
+        )
+    ),
+    all(
+        feature = "wamr-default",
+        any(
+            feature = "sys-default",
+            feature = "js-default",
+            feature = "jsc-default",
+            feature = "v8-default",
+            feature = "wasmi-default"
+        )
+    ),
+    all(
+        feature = "v8-default",
+        any(
+            feature = "sys-default",
+            feature = "js-default",
+            feature = "jsc-default",
+            feature = "wasmi-default",
+            feature = "wasmi-default"
+        )
+    ),
+    all(
+        feature = "wasmi-default",
+        any(
+            feature = "sys-default",
+            feature = "js-default",
+            feature = "jsc-default",
+            feature = "v8-default",
+            feature = "wamr-default"
+        )
+    )
+))]
+compile_error!("Multiple *-default features selected. Please, pick one only!");
diff --git a/lib/api/src/store.rs b/lib/api/src/store.rs
deleted file mode 100644
index 1b11363050..0000000000
--- a/lib/api/src/store.rs
+++ /dev/null
@@ -1,296 +0,0 @@
-use crate::engine::{AsEngineRef, Engine, EngineRef};
-use derivative::Derivative;
-use std::{
-    fmt,
-    ops::{Deref, DerefMut},
-};
-#[cfg(feature = "sys")]
-pub use wasmer_compiler::Tunables;
-pub use wasmer_types::{OnCalledAction, StoreId};
-#[cfg(feature = "sys")]
-use wasmer_vm::init_traps;
-#[cfg(feature = "sys")]
-pub use wasmer_vm::TrapHandlerFn;
-
-#[cfg(feature = "sys")]
-pub use wasmer_vm::{StoreHandle, StoreObjects};
-
-#[cfg(feature = "js")]
-pub use crate::js::store::{StoreHandle, StoreObjects};
-
-#[cfg(feature = "jsc")]
-pub use crate::jsc::store::{StoreHandle, StoreObjects};
-
-/// Call handler for a store.
-// TODO: better documentation!
-pub type OnCalledHandler = Box<
-    dyn FnOnce(StoreMut<'_>) -> Result<OnCalledAction, Box<dyn std::error::Error + Send + Sync>>,
->;
-
-/// We require the context to have a fixed memory address for its lifetime since
-/// various bits of the VM have raw pointers that point back to it. Hence we
-/// wrap the actual context in a box.
-#[derive(Derivative)]
-#[derivative(Debug)]
-pub(crate) struct StoreInner {
-    pub(crate) objects: StoreObjects,
-    #[derivative(Debug = "ignore")]
-    pub(crate) engine: Engine,
-    #[cfg(feature = "sys")]
-    #[derivative(Debug = "ignore")]
-    pub(crate) trap_handler: Option<Box<TrapHandlerFn<'static>>>,
-    #[derivative(Debug = "ignore")]
-    pub(crate) on_called: Option<OnCalledHandler>,
-}
-
-/// The store represents all global state that can be manipulated by
-/// WebAssembly programs. It consists of the runtime representation
-/// of all instances of functions, tables, memories, and globals that
-/// have been allocated during the lifetime of the abstract machine.
-///
-/// The `Store` holds the engine (that is —amongst many things— used to compile
-/// the Wasm bytes into a valid module artifact).
-///
-/// Spec: <https://webassembly.github.io/spec/core/exec/runtime.html#store>
-pub struct Store {
-    pub(crate) inner: Box<StoreInner>,
-}
-
-impl Store {
-    /// Creates a new `Store` with a specific [`Engine`].
-    pub fn new(engine: impl Into<Engine>) -> Self {
-        // Make sure the signal handlers are installed.
-        // This is required for handling traps.
-        #[cfg(feature = "sys")]
-        init_traps();
-
-        Self {
-            inner: Box::new(StoreInner {
-                objects: Default::default(),
-                engine: engine.into(),
-                #[cfg(feature = "sys")]
-                trap_handler: None,
-                on_called: None,
-            }),
-        }
-    }
-
-    #[cfg(feature = "sys")]
-    /// Set the trap handler in this store.
-    pub fn set_trap_handler(&mut self, handler: Option<Box<TrapHandlerFn<'static>>>) {
-        self.inner.trap_handler = handler;
-    }
-
-    /// Returns the [`Engine`].
-    pub fn engine(&self) -> &Engine {
-        &self.inner.engine
-    }
-
-    /// Returns mutable reference to [`Engine`]
-    pub fn engine_mut(&mut self) -> &mut Engine {
-        &mut self.inner.engine
-    }
-
-    /// Checks whether two stores are identical. A store is considered
-    /// equal to another store if both have the same engine.
-    pub fn same(a: &Self, b: &Self) -> bool {
-        a.id() == b.id()
-    }
-
-    /// Returns the ID of this store
-    pub fn id(&self) -> StoreId {
-        self.inner.objects.id()
-    }
-}
-
-impl PartialEq for Store {
-    fn eq(&self, other: &Self) -> bool {
-        Self::same(self, other)
-    }
-}
-
-// This is required to be able to set the trap_handler in the
-// Store.
-unsafe impl Send for Store {}
-unsafe impl Sync for Store {}
-
-impl Default for Store {
-    fn default() -> Self {
-        Self::new(Engine::default())
-    }
-}
-
-impl AsStoreRef for Store {
-    fn as_store_ref(&self) -> StoreRef<'_> {
-        StoreRef { inner: &self.inner }
-    }
-}
-impl AsStoreMut for Store {
-    fn as_store_mut(&mut self) -> StoreMut<'_> {
-        StoreMut {
-            inner: &mut self.inner,
-        }
-    }
-    fn objects_mut(&mut self) -> &mut StoreObjects {
-        &mut self.inner.objects
-    }
-}
-
-impl AsEngineRef for Store {
-    fn as_engine_ref(&self) -> EngineRef<'_> {
-        EngineRef::new(&self.inner.engine)
-    }
-}
-
-impl AsEngineRef for StoreRef<'_> {
-    fn as_engine_ref(&self) -> EngineRef<'_> {
-        EngineRef::new(&self.inner.engine)
-    }
-}
-
-impl AsEngineRef for StoreMut<'_> {
-    fn as_engine_ref(&self) -> EngineRef<'_> {
-        EngineRef::new(&self.inner.engine)
-    }
-}
-
-impl fmt::Debug for Store {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("Store").finish()
-    }
-}
-
-/// A temporary handle to a [`Store`].
-#[derive(Debug)]
-pub struct StoreRef<'a> {
-    pub(crate) inner: &'a StoreInner,
-}
-
-impl<'a> StoreRef<'a> {
-    pub(crate) fn objects(&self) -> &'a StoreObjects {
-        &self.inner.objects
-    }
-
-    /// Returns the [`Engine`].
-    pub fn engine(&self) -> &Engine {
-        &self.inner.engine
-    }
-
-    /// Checks whether two stores are identical. A store is considered
-    /// equal to another store if both have the same engine.
-    pub fn same(a: &Self, b: &Self) -> bool {
-        a.inner.objects.id() == b.inner.objects.id()
-    }
-
-    /// The signal handler
-    #[cfg(feature = "sys")]
-    #[inline]
-    pub fn signal_handler(&self) -> Option<*const TrapHandlerFn<'static>> {
-        self.inner
-            .trap_handler
-            .as_ref()
-            .map(|handler| handler.as_ref() as *const _)
-    }
-}
-
-/// A temporary handle to a [`Store`].
-pub struct StoreMut<'a> {
-    pub(crate) inner: &'a mut StoreInner,
-}
-
-impl<'a> StoreMut<'a> {
-    /// Returns the [`Engine`].
-    pub fn engine(&self) -> &Engine {
-        &self.inner.engine
-    }
-
-    /// Checks whether two stores are identical. A store is considered
-    /// equal to another store if both have the same engine.
-    pub fn same(a: &Self, b: &Self) -> bool {
-        a.inner.objects.id() == b.inner.objects.id()
-    }
-
-    #[allow(unused)]
-    pub(crate) fn engine_and_objects_mut(&mut self) -> (&Engine, &mut StoreObjects) {
-        (&self.inner.engine, &mut self.inner.objects)
-    }
-
-    pub(crate) fn as_raw(&self) -> *mut StoreInner {
-        self.inner as *const StoreInner as *mut StoreInner
-    }
-
-    pub(crate) unsafe fn from_raw(raw: *mut StoreInner) -> Self {
-        Self { inner: &mut *raw }
-    }
-
-    // TODO: OnCalledAction is needed for asyncify. It will be refactored with https://github.com/wasmerio/wasmer/issues/3451
-    /// Sets the unwind callback which will be invoked when the call finishes
-    pub fn on_called<F>(&mut self, callback: F)
-    where
-        F: FnOnce(StoreMut<'_>) -> Result<OnCalledAction, Box<dyn std::error::Error + Send + Sync>>
-            + Send
-            + Sync
-            + 'static,
-    {
-        self.inner.on_called.replace(Box::new(callback));
-    }
-}
-
-/// Helper trait for a value that is convertible to a [`StoreRef`].
-pub trait AsStoreRef {
-    /// Returns a `StoreRef` pointing to the underlying context.
-    fn as_store_ref(&self) -> StoreRef<'_>;
-}
-
-/// Helper trait for a value that is convertible to a [`StoreMut`].
-pub trait AsStoreMut: AsStoreRef {
-    /// Returns a `StoreMut` pointing to the underlying context.
-    fn as_store_mut(&mut self) -> StoreMut<'_>;
-
-    /// Returns the ObjectMutable
-    fn objects_mut(&mut self) -> &mut StoreObjects;
-}
-
-impl AsStoreRef for StoreRef<'_> {
-    fn as_store_ref(&self) -> StoreRef<'_> {
-        StoreRef { inner: self.inner }
-    }
-}
-
-impl AsStoreRef for StoreMut<'_> {
-    fn as_store_ref(&self) -> StoreRef<'_> {
-        StoreRef { inner: self.inner }
-    }
-}
-impl AsStoreMut for StoreMut<'_> {
-    fn as_store_mut(&mut self) -> StoreMut<'_> {
-        StoreMut { inner: self.inner }
-    }
-    fn objects_mut(&mut self) -> &mut StoreObjects {
-        &mut self.inner.objects
-    }
-}
-
-impl<P> AsStoreRef for P
-where
-    P: Deref,
-    P::Target: AsStoreRef,
-{
-    fn as_store_ref(&self) -> StoreRef<'_> {
-        (**self).as_store_ref()
-    }
-}
-
-impl<P> AsStoreMut for P
-where
-    P: DerefMut,
-    P::Target: AsStoreMut,
-{
-    fn as_store_mut(&mut self) -> StoreMut<'_> {
-        (**self).as_store_mut()
-    }
-
-    fn objects_mut(&mut self) -> &mut StoreObjects {
-        (**self).objects_mut()
-    }
-}
diff --git a/lib/api/src/sys/engine.rs b/lib/api/src/sys/engine.rs
deleted file mode 100644
index 076bd40153..0000000000
--- a/lib/api/src/sys/engine.rs
+++ /dev/null
@@ -1,163 +0,0 @@
-use std::{path::Path, sync::Arc};
-
-use shared_buffer::OwnedBuffer;
-pub use wasmer_compiler::{
-    Artifact, BaseTunables, CompilerConfig, Engine, EngineBuilder, Tunables,
-};
-#[cfg(feature = "compiler")]
-use wasmer_types::Features;
-use wasmer_types::{DeserializeError, HashAlgorithm, Target};
-
-/// Get the default config for the sys Engine
-#[allow(unreachable_code)]
-pub fn get_default_compiler_config() -> Option<Box<dyn wasmer_compiler::CompilerConfig>> {
-    cfg_if::cfg_if! {
-        if #[cfg(feature = "cranelift")] {
-            Some(Box::<wasmer_compiler_cranelift::Cranelift>::default())
-        } else if #[cfg(feature = "llvm")] {
-            Some(Box::<wasmer_compiler_llvm::LLVM>::default())
-        } else if #[cfg(feature = "singlepass")] {
-            Some(Box::<wasmer_compiler_singlepass::Singlepass>::default())
-        }
-        else {
-            None
-        }
-    }
-}
-
-/// Returns the default engine for the Sys engine
-pub(crate) fn default_engine() -> Engine {
-    #[allow(unreachable_code, unused_mut)]
-    fn get_engine() -> Engine {
-        cfg_if::cfg_if! {
-            if #[cfg(feature = "compiler")] {
-                if let Some(config) = get_default_compiler_config() {
-                    EngineBuilder::new(config)
-                        .engine()
-                } else {
-                    EngineBuilder::headless()
-                        .engine()
-                }
-            } else {
-                EngineBuilder::headless().engine()
-            }
-        }
-    }
-
-    let mut engine = get_engine();
-    let tunables = BaseTunables::for_target(engine.target());
-    engine.set_tunables(tunables);
-    engine
-}
-
-/// The custom trait to access to all the `sys` function in the common
-/// engine.
-pub trait NativeEngineExt {
-    /// Create a new `Engine` with the given config
-    #[cfg(feature = "compiler")]
-    fn new(compiler_config: Box<dyn CompilerConfig>, target: Target, features: Features) -> Self;
-
-    /// Sets the hash algorithm
-    fn set_hash_algorithm(&mut self, hash_algorithm: Option<HashAlgorithm>);
-
-    /// Create a headless `Engine`
-    ///
-    /// A headless engine is an engine without any compiler attached.
-    /// This is useful for assuring a minimal runtime for running
-    /// WebAssembly modules.
-    ///
-    /// For example, for running in IoT devices where compilers are very
-    /// expensive, or also to optimize startup speed.
-    ///
-    /// # Important
-    ///
-    /// Headless engines can't compile or validate any modules,
-    /// they just take already processed Modules (via `Module::serialize`).
-    fn headless() -> Self;
-
-    /// Gets the target
-    fn target(&self) -> &Target;
-
-    /// Attach a Tunable to this engine
-    fn set_tunables(&mut self, tunables: impl Tunables + Send + Sync + 'static);
-
-    /// Get a reference to attached Tunable of this engine
-    fn tunables(&self) -> &dyn Tunables;
-
-    /// Load a serialized WebAssembly module from a memory mapped file and deserialize it.
-    ///
-    /// NOTE: you should almost always prefer [`Self::deserialize_from_mmapped_file`].
-    ///
-    /// # Safety
-    /// See [`Artifact::deserialize_unchecked`].
-    unsafe fn deserialize_from_mmapped_file_unchecked(
-        &self,
-        file_ref: &Path,
-    ) -> Result<crate::Module, DeserializeError>;
-
-    /// Load a serialized WebAssembly module from a memory mapped file and deserialize it.
-    ///
-    /// # Safety
-    /// See [`Artifact::deserialize`].
-    unsafe fn deserialize_from_mmapped_file(
-        &self,
-        file_ref: &Path,
-    ) -> Result<crate::Module, DeserializeError>;
-}
-
-impl NativeEngineExt for crate::engine::Engine {
-    #[cfg(feature = "compiler")]
-    fn new(compiler_config: Box<dyn CompilerConfig>, target: Target, features: Features) -> Self {
-        Self(Engine::new(compiler_config, target, features))
-    }
-
-    fn headless() -> Self {
-        Self(Engine::headless())
-    }
-
-    fn target(&self) -> &Target {
-        self.0.target()
-    }
-
-    fn set_tunables(&mut self, tunables: impl Tunables + Send + Sync + 'static) {
-        self.0.set_tunables(tunables)
-    }
-
-    fn tunables(&self) -> &dyn Tunables {
-        self.0.tunables()
-    }
-
-    unsafe fn deserialize_from_mmapped_file_unchecked(
-        &self,
-        file_ref: &Path,
-    ) -> Result<crate::Module, DeserializeError> {
-        let file = std::fs::File::open(file_ref)?;
-        let artifact = Arc::new(Artifact::deserialize_unchecked(
-            &self.0,
-            OwnedBuffer::from_file(&file)
-                .map_err(|e| DeserializeError::Generic(format!("{e:?}")))?,
-        )?);
-        Ok(crate::Module(super::module::Module::from_artifact(
-            artifact,
-        )))
-    }
-
-    unsafe fn deserialize_from_mmapped_file(
-        &self,
-        file_ref: &Path,
-    ) -> Result<crate::Module, DeserializeError> {
-        let file = std::fs::File::open(file_ref)?;
-        let artifact = Arc::new(Artifact::deserialize(
-            &self.0,
-            OwnedBuffer::from_file(&file)
-                .map_err(|e| DeserializeError::Generic(format!("{e:?}")))?,
-        )?);
-        Ok(crate::Module(super::module::Module::from_artifact(
-            artifact,
-        )))
-    }
-
-    fn set_hash_algorithm(&mut self, hash_algorithm: Option<HashAlgorithm>) {
-        self.0.set_hash_algorithm(hash_algorithm)
-    }
-}
diff --git a/lib/api/src/sys/extern_ref.rs b/lib/api/src/sys/extern_ref.rs
deleted file mode 100644
index 2f50751b6b..0000000000
--- a/lib/api/src/sys/extern_ref.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-use std::any::Any;
-use wasmer_vm::VMExternRef;
-use wasmer_vm::{StoreHandle, VMExternObj};
-
-use crate::store::{AsStoreMut, AsStoreRef};
-
-#[derive(Debug, Clone)]
-#[repr(transparent)]
-pub struct ExternRef {
-    handle: StoreHandle<VMExternObj>,
-}
-
-impl ExternRef {
-    pub fn new<T>(store: &mut impl AsStoreMut, value: T) -> Self
-    where
-        T: Any + Send + Sync + 'static + Sized,
-    {
-        Self {
-            handle: StoreHandle::new(store.objects_mut(), VMExternObj::new(value)),
-        }
-    }
-
-    pub fn downcast<'a, T>(&self, store: &'a impl AsStoreRef) -> Option<&'a T>
-    where
-        T: Any + Send + Sync + 'static + Sized,
-    {
-        self.handle
-            .get(store.as_store_ref().objects())
-            .as_ref()
-            .downcast_ref::<T>()
-    }
-
-    pub(crate) fn vm_externref(&self) -> VMExternRef {
-        VMExternRef(self.handle.internal_handle())
-    }
-
-    pub(crate) unsafe fn from_vm_externref(
-        store: &mut impl AsStoreMut,
-        vm_externref: VMExternRef,
-    ) -> Self {
-        Self {
-            handle: StoreHandle::from_internal(store.objects_mut().id(), vm_externref.0),
-        }
-    }
-
-    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
-        self.handle.store_id() == store.as_store_ref().objects().id()
-    }
-}
diff --git a/lib/api/src/sys/externals/mod.rs b/lib/api/src/sys/externals/mod.rs
deleted file mode 100644
index 3575fe23bb..0000000000
--- a/lib/api/src/sys/externals/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-pub(crate) mod function;
-pub(crate) mod global;
-pub(crate) mod memory;
-pub(crate) mod memory_view;
-pub(crate) mod table;
diff --git a/lib/api/src/sys/externals/table.rs b/lib/api/src/sys/externals/table.rs
deleted file mode 100644
index aba6844241..0000000000
--- a/lib/api/src/sys/externals/table.rs
+++ /dev/null
@@ -1,161 +0,0 @@
-use crate::store::{AsStoreMut, AsStoreRef};
-use crate::sys::engine::NativeEngineExt;
-use crate::TableType;
-use crate::Value;
-use crate::{vm::VMExternTable, ExternRef, Function, RuntimeError};
-use wasmer_vm::{StoreHandle, TableElement, Trap, VMExtern, VMTable};
-
-#[derive(Debug, Clone)]
-pub struct Table {
-    handle: StoreHandle<VMTable>,
-}
-
-fn set_table_item(
-    table: &mut VMTable,
-    item_index: u32,
-    item: TableElement,
-) -> Result<(), RuntimeError> {
-    table.set(item_index, item).map_err(|e| e.into())
-}
-
-fn value_to_table_element(
-    store: &mut impl AsStoreMut,
-    val: Value,
-) -> Result<wasmer_vm::TableElement, RuntimeError> {
-    if !val.is_from_store(store) {
-        return Err(RuntimeError::new("cannot pass Value across contexts"));
-    }
-    Ok(match val {
-        Value::ExternRef(extern_ref) => {
-            wasmer_vm::TableElement::ExternRef(extern_ref.map(|e| e.vm_externref()))
-        }
-        Value::FuncRef(func_ref) => {
-            wasmer_vm::TableElement::FuncRef(func_ref.map(|f| f.vm_funcref(store)))
-        }
-        _ => return Err(RuntimeError::new("val is not reference")),
-    })
-}
-
-fn value_from_table_element(store: &mut impl AsStoreMut, item: wasmer_vm::TableElement) -> Value {
-    match item {
-        wasmer_vm::TableElement::FuncRef(funcref) => {
-            Value::FuncRef(funcref.map(|f| unsafe { Function::from_vm_funcref(store, f) }))
-        }
-        wasmer_vm::TableElement::ExternRef(extern_ref) => {
-            Value::ExternRef(extern_ref.map(|e| unsafe { ExternRef::from_vm_externref(store, e) }))
-        }
-    }
-}
-
-impl Table {
-    pub fn new(
-        mut store: &mut impl AsStoreMut,
-        ty: TableType,
-        init: Value,
-    ) -> Result<Self, RuntimeError> {
-        let item = value_to_table_element(&mut store, init)?;
-        let mut store = store.as_store_mut();
-        let tunables = store.engine().tunables();
-        let style = tunables.table_style(&ty);
-        let mut table = tunables
-            .create_host_table(&ty, &style)
-            .map_err(RuntimeError::new)?;
-
-        let num_elements = table.size();
-        for i in 0..num_elements {
-            set_table_item(&mut table, i, item.clone())?;
-        }
-
-        Ok(Self {
-            handle: StoreHandle::new(store.objects_mut(), table),
-        })
-    }
-
-    pub fn ty(&self, store: &impl AsStoreRef) -> TableType {
-        *self.handle.get(store.as_store_ref().objects()).ty()
-    }
-
-    pub fn get(&self, store: &mut impl AsStoreMut, index: u32) -> Option<Value> {
-        let item = self.handle.get(store.as_store_ref().objects()).get(index)?;
-        Some(value_from_table_element(store, item))
-    }
-
-    pub fn set(
-        &self,
-        store: &mut impl AsStoreMut,
-        index: u32,
-        val: Value,
-    ) -> Result<(), RuntimeError> {
-        let item = value_to_table_element(store, val)?;
-        set_table_item(self.handle.get_mut(store.objects_mut()), index, item)
-    }
-
-    pub fn size(&self, store: &impl AsStoreRef) -> u32 {
-        self.handle.get(store.as_store_ref().objects()).size()
-    }
-
-    pub fn grow(
-        &self,
-        store: &mut impl AsStoreMut,
-        delta: u32,
-        init: Value,
-    ) -> Result<u32, RuntimeError> {
-        let item = value_to_table_element(store, init)?;
-        self.handle
-            .get_mut(store.objects_mut())
-            .grow(delta, item)
-            .ok_or_else(|| RuntimeError::new(format!("failed to grow table by `{}`", delta)))
-    }
-
-    pub fn copy(
-        store: &mut impl AsStoreMut,
-        dst_table: &Self,
-        dst_index: u32,
-        src_table: &Self,
-        src_index: u32,
-        len: u32,
-    ) -> Result<(), RuntimeError> {
-        if dst_table.handle.store_id() != src_table.handle.store_id() {
-            return Err(RuntimeError::new(
-                "cross-`Store` table copies are not supported",
-            ));
-        }
-        if dst_table.handle.internal_handle() == src_table.handle.internal_handle() {
-            let table = dst_table.handle.get_mut(store.objects_mut());
-            table.copy_within(dst_index, src_index, len)
-        } else {
-            let (src_table, dst_table) = store.objects_mut().get_2_mut(
-                src_table.handle.internal_handle(),
-                dst_table.handle.internal_handle(),
-            );
-            VMTable::copy(dst_table, src_table, dst_index, src_index, len)
-        }
-        .map_err(Into::<Trap>::into)?;
-        Ok(())
-    }
-
-    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternTable) -> Self {
-        Self {
-            handle: unsafe {
-                StoreHandle::from_internal(store.as_store_ref().objects().id(), vm_extern)
-            },
-        }
-    }
-
-    /// Checks whether this `Table` can be used with the given context.
-    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
-        self.handle.store_id() == store.as_store_ref().objects().id()
-    }
-
-    pub(crate) fn to_vm_extern(&self) -> VMExtern {
-        VMExtern::Table(self.handle.internal_handle())
-    }
-}
-
-impl std::cmp::PartialEq for Table {
-    fn eq(&self, other: &Self) -> bool {
-        self.handle == other.handle
-    }
-}
-
-impl std::cmp::Eq for Table {}
diff --git a/lib/api/src/sys/mem_access.rs b/lib/api/src/sys/mem_access.rs
deleted file mode 100644
index 376c724544..0000000000
--- a/lib/api/src/sys/mem_access.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-use std::mem;
-
-use crate::{
-    access::{RefCow, SliceCow, WasmRefAccess, WasmSliceAccess},
-    MemoryAccessError, WasmRef, WasmSlice,
-};
-
-impl<'a, T> WasmSliceAccess<'a, T>
-where
-    T: wasmer_types::ValueType,
-{
-    pub(crate) fn new(slice: WasmSlice<'a, T>) -> Result<Self, MemoryAccessError> {
-        let total_len = slice
-            .len
-            .checked_mul(mem::size_of::<T>() as u64)
-            .ok_or(MemoryAccessError::Overflow)?;
-        let end = slice
-            .offset
-            .checked_add(total_len)
-            .ok_or(MemoryAccessError::Overflow)?;
-        if end > slice.buffer.0.len as u64 {
-            tracing::warn!(
-                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
-                total_len,
-                end,
-                slice.buffer.0.len
-            );
-            return Err(MemoryAccessError::HeapOutOfBounds);
-        }
-        let buf = unsafe {
-            let buf_ptr: *mut u8 = slice.buffer.0.base.add(slice.offset as usize);
-            let buf_ptr: *mut T = std::mem::transmute(buf_ptr);
-            std::slice::from_raw_parts_mut(buf_ptr, slice.len as usize)
-        };
-        Ok(Self {
-            slice,
-            buf: SliceCow::Borrowed(buf),
-        })
-    }
-}
-
-impl<'a, T> WasmRefAccess<'a, T>
-where
-    T: wasmer_types::ValueType,
-{
-    pub(crate) fn new(ptr: WasmRef<'a, T>) -> Result<Self, MemoryAccessError> {
-        let total_len = mem::size_of::<T>() as u64;
-        let end = ptr
-            .offset
-            .checked_add(total_len)
-            .ok_or(MemoryAccessError::Overflow)?;
-        if end > ptr.buffer.0.len as u64 {
-            tracing::warn!(
-                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
-                total_len,
-                end,
-                ptr.buffer.0.len
-            );
-            return Err(MemoryAccessError::HeapOutOfBounds);
-        }
-        let val = unsafe {
-            let val_ptr: *mut u8 = ptr.buffer.0.base.add(ptr.offset as usize);
-            let val_ptr: *mut T = std::mem::transmute(val_ptr);
-            &mut *val_ptr
-        };
-        Ok(Self {
-            ptr,
-            buf: RefCow::Borrowed(val),
-        })
-    }
-}
-
-impl<'a, T> WasmRefAccess<'a, T>
-where
-    T: wasmer_types::ValueType,
-{
-    /// Reads the address pointed to by this `WasmPtr` in a memory.
-    #[inline]
-    #[allow(clippy::clone_on_copy)]
-    pub fn read(&self) -> T
-    where
-        T: Clone,
-    {
-        self.as_ref().clone()
-    }
-
-    /// Writes to the address pointed to by this `WasmPtr` in a memory.
-    #[inline]
-    pub fn write(&mut self, val: T) {
-        // Note: Zero padding is not required here as its a typed copy which does
-        //       not leak the bytes into the memory
-        // https://stackoverflow.com/questions/61114026/does-stdptrwrite-transfer-the-uninitialized-ness-of-the-bytes-it-writes
-        *(self.as_mut()) = val;
-    }
-}
diff --git a/lib/api/src/sys/mod.rs b/lib/api/src/sys/mod.rs
deleted file mode 100644
index 5ed4ebbcb2..0000000000
--- a/lib/api/src/sys/mod.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-pub(crate) mod engine;
-pub(crate) mod errors;
-pub(crate) mod extern_ref;
-pub(crate) mod externals;
-pub(crate) mod instance;
-pub(crate) mod mem_access;
-pub(crate) mod module;
-pub(super) mod tunables;
-pub(crate) mod typed_function;
-
-pub use crate::sys::engine::{get_default_compiler_config, NativeEngineExt};
-pub use crate::sys::tunables::BaseTunables;
-#[cfg(feature = "compiler")]
-pub use wasmer_compiler::{
-    wasmparser, CompilerConfig, FunctionMiddleware, MiddlewareReaderState, ModuleMiddleware,
-};
-pub use wasmer_compiler::{Artifact, EngineBuilder, Features, Tunables};
-#[cfg(feature = "cranelift")]
-pub use wasmer_compiler_cranelift::{Cranelift, CraneliftOptLevel};
-#[cfg(feature = "llvm")]
-pub use wasmer_compiler_llvm::{LLVMOptLevel, LLVM};
-#[cfg(feature = "singlepass")]
-pub use wasmer_compiler_singlepass::Singlepass;
-
-pub use wasmer_vm::VMConfig;
-
-pub(crate) mod vm {
-    //! The `vm` module re-exports wasmer-vm types.
-    use wasmer_vm::InternalStoreHandle;
-    pub(crate) use wasmer_vm::{
-        VMExtern, VMExternRef, VMFuncRef, VMFunction, VMFunctionBody, VMFunctionEnvironment,
-        VMGlobal, VMInstance, VMMemory, VMTable, VMTrampoline,
-    };
-
-    pub(crate) type VMExternTable = InternalStoreHandle<VMTable>;
-    pub(crate) type VMExternMemory = InternalStoreHandle<VMMemory>;
-    pub(crate) type VMExternGlobal = InternalStoreHandle<VMGlobal>;
-    pub(crate) type VMExternFunction = InternalStoreHandle<VMFunction>;
-
-    pub type VMFunctionCallback = *const VMFunctionBody;
-}
diff --git a/lib/api/src/typed_function.rs b/lib/api/src/typed_function.rs
deleted file mode 100644
index ccaadcfd4e..0000000000
--- a/lib/api/src/typed_function.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-//! Native Functions.
-//!
-//! This module creates the helper `TypedFunction` that let us call WebAssembly
-//! functions with the native ABI, that is:
-//!
-//! ```ignore
-//! let add_one = instance.exports.get_function("function_name")?;
-//! let add_one_native: TypedFunction<i32, i32> = add_one.native().unwrap();
-//! ```
-use crate::{Function, WasmTypeList};
-use std::marker::PhantomData;
-
-use crate::store::AsStoreRef;
-
-/// A WebAssembly function that can be called natively
-/// (using the Native ABI).
-#[derive(Clone)]
-pub struct TypedFunction<Args, Rets> {
-    pub(crate) func: Function,
-    _phantom: PhantomData<fn(Args) -> Rets>,
-}
-
-unsafe impl<Args, Rets> Send for TypedFunction<Args, Rets> {}
-unsafe impl<Args, Rets> Sync for TypedFunction<Args, Rets> {}
-
-impl<Args, Rets> TypedFunction<Args, Rets>
-where
-    Args: WasmTypeList,
-    Rets: WasmTypeList,
-{
-    #[allow(dead_code)]
-    pub(crate) fn new(_store: &impl AsStoreRef, func: Function) -> Self {
-        Self {
-            func,
-            _phantom: PhantomData,
-        }
-    }
-
-    pub(crate) fn into_function(self) -> Function {
-        self.func
-    }
-}
diff --git a/lib/api/src/into_bytes.rs b/lib/api/src/utils/into_bytes.rs
similarity index 100%
rename from lib/api/src/into_bytes.rs
rename to lib/api/src/utils/into_bytes.rs
diff --git a/lib/api/src/utils/macros/backend.rs b/lib/api/src/utils/macros/backend.rs
new file mode 100644
index 0000000000..32b77c23eb
--- /dev/null
+++ b/lib/api/src/utils/macros/backend.rs
@@ -0,0 +1,174 @@
+/// Automatically generate "backend" types.
+#[macro_use]
+macro_rules! gen_rt_ty {
+    // In this case we automatically try to create the struct following the canonical path to the
+    // same entity in each backend.
+    ($id:ident) => {
+        paste::paste! {
+            pub(crate) enum [<Backend $id>] {
+                #[cfg(feature = "sys")]
+                /// The implementation from the `sys` backend.
+                Sys(crate::backend::sys::entities::[<$id:lower>]::$id),
+
+                #[cfg(feature = "v8")]
+                /// The implementation from the `v8` backend.
+                V8(crate::backend::v8::entities::[<$id:lower>]::$id),
+
+                #[cfg(feature = "wamr")]
+                /// The implementation from the `wamr` backend.
+                Wamr(crate::backend::wamr::entities::[<$id:lower>]::$id),
+
+                #[cfg(feature = "wasmi")]
+                /// The implementation from the `wasmi` backend.
+                Wasmi(crate::backend::wasmi::entities::[<$id:lower>]::$id),
+
+                #[cfg(feature = "js")]
+                /// The implementation from the `js` backend.
+                Js(crate::backend::js::entities::[<$id:lower>]::$id),
+
+                #[cfg(feature = "jsc")]
+                /// The implementation from the `jsc` backend.
+                Jsc(crate::backend::jsc::entities::[<$id:lower>]::$id),
+            }
+        }
+    };
+
+    ($id:ident$(<$lt:lifetime>)? $(@cfg $($if:meta => $then: meta),*)? @derives $($derive:path),*) => {
+        paste::paste! {
+            $($(#[cfg_attr($if, $then)])*)?
+            #[derive($($derive,)*)]
+            pub(crate) enum [<Backend $id>]$(<$lt>)? {
+                #[cfg(feature = "sys")]
+                /// The implementation from the `sys` backend.
+                Sys(crate::backend::sys::entities::[<$id:lower>]::$id$(<$lt>)?),
+
+                #[cfg(feature = "v8")]
+                /// The implementation from the `v8` backend.
+                V8(crate::backend::v8::entities::[<$id:lower>]::$id$(<$lt>)?),
+
+                #[cfg(feature = "wamr")]
+                /// The implementation from the `wamr` backend.
+                Wamr(crate::backend::wamr::entities::[<$id:lower>]::$id$(<$lt>)?),
+
+                #[cfg(feature = "wasmi")]
+                /// The implementation from the `wasmi` backend.
+                Wasmi(crate::backend::wasmi::entities::[<$id:lower>]::$id$(<$lt>)?),
+
+                #[cfg(feature = "js")]
+                /// The implementation from the `js` backend.
+                Js(crate::backend::js::entities::[<$id:lower>]::$id$(<$lt>)?),
+
+
+                #[cfg(feature = "jsc")]
+                /// The implementation from the `jsc` backend.
+                Jsc(crate::backend::jsc::entities::[<$id:lower>]::$id$(<$lt>)?),
+            }
+        }
+    };
+
+    ($id:ident$(<$lt:lifetime>)? $(@cfg $($if:meta => $then: meta),*)? @derives $($derive:path),* ; @path $path:path ) => {
+        paste::paste! {
+            $($(#[cfg_attr($if, $then)])*)?
+            #[derive($($derive,)*)]
+            pub(crate) enum [<Backend $id>]$(<$lt>)? {
+                #[cfg(feature = "sys")]
+                /// The implementation from the `sys` backend.
+                Sys(crate::backend::sys::entities::$path::$id$(<$lt>)?),
+
+                #[cfg(feature = "v8")]
+                /// The implementation from the `v8` backend.
+                V8(crate::backend::v8::entities::$path::$id$(<$lt>)?),
+
+                #[cfg(feature = "wamr")]
+                /// The implementation from the `wamr` backend.
+                Wamr(crate::backend::wamr::entities::$path::$id$(<$lt>)?),
+
+                #[cfg(feature = "wasmi")]
+                /// The implementation from the `wasmi` backend.
+                Wasmi(crate::backend::wasmi::entities::$path::$id$(<$lt>)?),
+
+                #[cfg(feature = "js")]
+                /// The implementation from the `js` backend.
+                Js(crate::backend::js::entities::$path::$id$(<$lt>)?),
+
+
+                #[cfg(feature = "jsc")]
+                /// The implementation from the `jsc` backend.
+                Jsc(crate::backend::jsc::entities::$path::$id$(<$lt>)?),
+            }
+        }
+    };
+
+
+    ($id:ident @derives $($derive:path),* ; @path $path:path) => {
+        paste::paste! {
+            #[derive($($derive,)*)]
+            pub(crate) enum [<Backend $id>] {
+                #[cfg(feature = "sys")]
+                /// The implementation from the `sys` backend.
+                Sys(crate::backend::sys::entities::$path::$id),
+
+                #[cfg(feature = "v8")]
+                /// The implementation from the `v8` backend.
+                V8(crate::backend::v8::entities::$path::$id),
+
+                #[cfg(feature = "wamr")]
+                /// The implementation from the `wamr` backend.
+                Wamr(crate::backend::wamr::entities::$path::$id),
+
+                #[cfg(feature = "wasmi")]
+                /// The implementation from the `wasmi` backend.
+                Wasmi(crate::backend::wasmi::entities::$path::$id),
+
+                #[cfg(feature = "js")]
+                /// The implementation from the `js` backend.
+                Js(crate::backend::js::entities::$path::$id),
+
+
+                #[cfg(feature = "jsc")]
+                /// The implementation from the `jsc` backend.
+                Jsc(crate::backend::jsc::entities::$path::$id),
+            }
+        }
+    };
+}
+
+/// Automatically create a match statement, repeating the expression for each backend.
+#[macro_use]
+macro_rules! match_rt {
+    (on $self:expr => $var:ident { $stmt:expr }) => {
+        match $self {
+            #[cfg(feature = "sys")]
+            Self::Sys($var) => $stmt,
+            #[cfg(feature = "wamr")]
+            Self::Wamr($var) => $stmt,
+            #[cfg(feature = "wasmi")]
+            Self::Wasmi($var) => $stmt,
+            #[cfg(feature = "v8")]
+            Self::V8($var) => $stmt,
+            #[cfg(feature = "js")]
+            Self::Js($var) => $stmt,
+            #[cfg(feature = "jsc")]
+            Self::Jsc($var) => $stmt,
+        }
+    };
+
+    (on $value:expr ; $match:expr => $var:ident { $stmt:expr }) => {
+        match $self {
+            #[cfg(feature = "sys")]
+            Self::Sys($var) => $stmt,
+            #[cfg(feature = "wamr")]
+            Self::Wamr($var) => $stmt,
+            #[cfg(feature = "wasmi")]
+            Self::Wasmi($var) => $stmt,
+            #[cfg(feature = "v8")]
+            Self::V8($var) => $stmt,
+            #[cfg(feature = "js")]
+            Self::Js($var) => $stmt,
+            #[cfg(feature = "jsc")]
+            Self::Jsc($var) => $stmt,
+        }
+    };
+}
+
+pub(crate) use {gen_rt_ty, match_rt};
diff --git a/lib/api/src/utils/macros/mod.rs b/lib/api/src/utils/macros/mod.rs
new file mode 100644
index 0000000000..fdbe5b5c84
--- /dev/null
+++ b/lib/api/src/utils/macros/mod.rs
@@ -0,0 +1 @@
+pub(crate) mod backend;
diff --git a/lib/api/src/utils/mem/access.rs b/lib/api/src/utils/mem/access.rs
new file mode 100644
index 0000000000..8b921b6aaa
--- /dev/null
+++ b/lib/api/src/utils/mem/access.rs
@@ -0,0 +1,368 @@
+use std::mem::{self, MaybeUninit};
+use std::slice;
+
+use crate::{
+    utils::mem::{WasmRef, WasmSlice},
+    MemoryAccessError,
+};
+
+pub(crate) enum SliceCow<'a, T> {
+    #[allow(dead_code)]
+    Borrowed(&'a mut [T]),
+    #[allow(dead_code)]
+    Owned(Vec<T>, bool),
+}
+
+impl<T> AsRef<[T]> for SliceCow<'_, T> {
+    fn as_ref(&self) -> &[T] {
+        match self {
+            Self::Borrowed(buf) => buf,
+            Self::Owned(buf, _) => buf,
+        }
+    }
+}
+
+impl<T> AsMut<[T]> for SliceCow<'_, T> {
+    fn as_mut(&mut self) -> &mut [T] {
+        // Note: Zero padding is not required here as its a typed copy which does
+        //       not leak the bytes into the memory
+        // https://stackoverflow.com/questions/61114026/does-stdptrwrite-transfer-the-uninitialized-ness-of-the-bytes-it-writes
+        match self {
+            Self::Borrowed(buf) => buf,
+            Self::Owned(buf, modified) => {
+                *modified = true;
+                buf.as_mut()
+            }
+        }
+    }
+}
+
+/// Provides direct memory access to a piece of memory that
+/// is owned by WASM
+pub struct WasmSliceAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    pub(crate) slice: WasmSlice<'a, T>,
+    pub(crate) buf: SliceCow<'a, T>,
+}
+
+impl<T> AsRef<[T]> for WasmSliceAccess<'_, T>
+where
+    T: wasmer_types::ValueType,
+{
+    fn as_ref(&self) -> &[T] {
+        self.buf.as_ref()
+    }
+}
+
+impl<T> AsMut<[T]> for WasmSliceAccess<'_, T>
+where
+    T: wasmer_types::ValueType,
+{
+    fn as_mut(&mut self) -> &mut [T] {
+        self.buf.as_mut()
+    }
+}
+
+impl<'a, T> WasmSliceAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    /// Returns an iterator of all the elements in the slice
+    pub fn iter(&'a self) -> std::slice::Iter<'a, T> {
+        self.as_ref().iter()
+    }
+
+    /// Returns an iterator of all the elements in the slice
+    pub fn iter_mut(&'a mut self) -> std::slice::IterMut<'a, T> {
+        self.buf.as_mut().iter_mut()
+    }
+
+    /// Number of elements in this slice
+    pub fn len(&self) -> usize {
+        self.buf.as_ref().len()
+    }
+
+    /// If the slice is empty
+    pub fn is_empty(&self) -> bool {
+        self.buf.as_ref().is_empty()
+    }
+}
+
+impl WasmSliceAccess<'_, u8> {
+    /// Writes to the address pointed to by this `WasmPtr` in a memory.
+    #[inline]
+    pub fn copy_from_slice(&mut self, src: &[u8]) {
+        let dst = self.buf.as_mut();
+        dst.copy_from_slice(src);
+    }
+
+    /// Writes to the address pointed to by this `WasmPtr` in a memory.
+    ///
+    /// If the source buffer is smaller than the destination buffer
+    /// only the correct amount of bytes will be copied
+    ///
+    /// Returns the number of bytes copied
+    #[inline]
+    pub fn copy_from_slice_min(&mut self, src: &[u8]) -> usize {
+        let dst = self.buf.as_mut();
+        let amt = dst.len().min(src.len());
+        dst[..amt].copy_from_slice(&src[..amt]);
+        amt
+    }
+}
+
+impl<T> Drop for WasmSliceAccess<'_, T>
+where
+    T: wasmer_types::ValueType,
+{
+    fn drop(&mut self) {
+        if let SliceCow::Owned(buf, modified) = &self.buf {
+            if *modified {
+                self.slice.write_slice(buf.as_ref()).ok();
+            }
+        }
+    }
+}
+
+pub(crate) enum RefCow<'a, T> {
+    #[allow(dead_code)]
+    Borrowed(&'a mut T),
+    #[allow(dead_code)]
+    Owned(T, bool),
+}
+
+impl<T> AsRef<T> for RefCow<'_, T> {
+    fn as_ref(&self) -> &T {
+        match self {
+            Self::Borrowed(val) => val,
+            Self::Owned(val, _) => val,
+        }
+    }
+}
+
+impl<T> AsMut<T> for RefCow<'_, T> {
+    fn as_mut(&mut self) -> &mut T {
+        // Note: Zero padding is not required here as its a typed copy which does
+        //       not leak the bytes into the memory
+        // https://stackoverflow.com/questions/61114026/does-stdptrwrite-transfer-the-uninitialized-ness-of-the-bytes-it-writes
+        match self {
+            Self::Borrowed(val) => val,
+            Self::Owned(val, modified) => {
+                *modified = true;
+                val
+            }
+        }
+    }
+}
+
+/// Provides direct memory access to a piece of memory that
+/// is owned by WASM
+pub struct WasmRefAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    pub(crate) is_owned: bool,
+    pub(crate) ptr: WasmRef<'a, T>,
+    pub(crate) buf: RefCow<'a, T>,
+}
+
+impl<T> AsRef<T> for WasmRefAccess<'_, T>
+where
+    T: wasmer_types::ValueType,
+{
+    fn as_ref(&self) -> &T {
+        self.buf.as_ref()
+    }
+}
+
+impl<T> AsMut<T> for WasmRefAccess<'_, T>
+where
+    T: wasmer_types::ValueType,
+{
+    fn as_mut(&mut self) -> &mut T {
+        self.buf.as_mut()
+    }
+}
+
+impl<T> Drop for WasmRefAccess<'_, T>
+where
+    T: wasmer_types::ValueType,
+{
+    fn drop(&mut self) {
+        if let RefCow::Owned(val, modified) = &self.buf {
+            if *modified {
+                self.ptr.write(*val).ok();
+            }
+        }
+    }
+}
+
+impl<T> WasmSliceAccess<'_, T>
+where
+    T: wasmer_types::ValueType,
+{
+    /// Returns a mutable slice that is not yet initialized
+    pub fn as_mut_uninit(&mut self) -> &mut [MaybeUninit<T>] {
+        let ret: &mut [T] = self.buf.as_mut();
+        let ret: &mut [MaybeUninit<T>] = unsafe { std::mem::transmute(ret) };
+        ret
+    }
+}
+
+impl<T> WasmRefAccess<'_, T>
+where
+    T: wasmer_types::ValueType,
+{
+    /// Returns a reference to an unitialized reference to this value
+    pub fn as_mut_uninit(&mut self) -> &mut MaybeUninit<T> {
+        let ret: &mut T = self.buf.as_mut();
+        let ret: &mut MaybeUninit<T> = unsafe { std::mem::transmute(ret) };
+        ret
+    }
+}
+
+impl<'a, T> WasmSliceAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    pub(crate) fn new(slice: WasmSlice<'a, T>, is_owned: bool) -> Result<Self, MemoryAccessError> {
+        if is_owned {
+            Self::new_owned(slice)
+        } else {
+            Self::new_borrowed(slice)
+        }
+    }
+
+    pub(crate) fn new_borrowed(slice: WasmSlice<'a, T>) -> Result<Self, MemoryAccessError> {
+        let total_len = slice
+            .len
+            .checked_mul(std::mem::size_of::<T>() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        let end = slice
+            .offset
+            .checked_add(total_len)
+            .ok_or(MemoryAccessError::Overflow)?;
+        if end > slice.buffer.len() as u64 {
+            tracing::warn!(
+                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
+                total_len,
+                end,
+                slice.buffer.len()
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        let buf = unsafe {
+            let buf_ptr: *mut u8 = slice.buffer.base().add(slice.offset as usize);
+            let buf_ptr: *mut T = std::mem::transmute(buf_ptr);
+            if !buf_ptr.is_aligned() {
+                return Err(MemoryAccessError::UnalignedPointerRead);
+            }
+            std::slice::from_raw_parts_mut(buf_ptr, slice.len as usize)
+        };
+        Ok(Self {
+            slice,
+            buf: SliceCow::Borrowed(buf),
+        })
+    }
+
+    pub(crate) fn new_owned(slice: WasmSlice<'a, T>) -> Result<Self, MemoryAccessError> {
+        let buf = slice.read_to_vec()?;
+        Ok(Self {
+            slice,
+            buf: SliceCow::Owned(buf, false),
+        })
+    }
+}
+
+impl<'a, T> WasmRefAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    pub(crate) fn new(ptr: WasmRef<'a, T>, is_owned: bool) -> Result<Self, MemoryAccessError> {
+        if is_owned {
+            Self::new_owned(ptr)
+        } else {
+            Self::new_borrowed(ptr)
+        }
+    }
+
+    pub(crate) fn new_borrowed(ptr: WasmRef<'a, T>) -> Result<Self, MemoryAccessError> {
+        let total_len = std::mem::size_of::<T>() as u64;
+        let end = ptr
+            .offset
+            .checked_add(total_len)
+            .ok_or(MemoryAccessError::Overflow)?;
+        if end > ptr.buffer.len() as u64 {
+            tracing::warn!(
+                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
+                total_len,
+                end,
+                ptr.buffer.len()
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        let val = unsafe {
+            let val_ptr: *mut u8 = ptr.buffer.base().add(ptr.offset as usize);
+            let val_ptr: *mut T = std::mem::transmute(val_ptr);
+            &mut *val_ptr
+        };
+        Ok(Self {
+            is_owned: false,
+            ptr,
+            buf: RefCow::Borrowed(val),
+        })
+    }
+
+    pub(crate) fn new_owned(ptr: WasmRef<'a, T>) -> Result<Self, MemoryAccessError> {
+        let mut out = MaybeUninit::uninit();
+        let buf =
+            unsafe { slice::from_raw_parts_mut(out.as_mut_ptr() as *mut u8, mem::size_of::<T>()) };
+        ptr.buffer.read(ptr.offset, buf)?;
+        let val = unsafe { out.assume_init() };
+
+        Ok(Self {
+            is_owned: true,
+            ptr,
+            buf: RefCow::Owned(val, false),
+        })
+    }
+}
+
+impl<T> WasmRefAccess<'_, T>
+where
+    T: wasmer_types::ValueType,
+{
+    /// Reads the address pointed to by this `WasmPtr` in a memory.
+    #[inline]
+    #[allow(clippy::clone_on_copy)]
+    pub fn read(&self) -> T
+    where
+        T: Clone,
+    {
+        self.as_ref().clone()
+    }
+
+    /// Writes to the address pointed to by this `WasmPtr` in a memory.
+    #[inline]
+    pub fn write(&mut self, val: T) {
+        if self.is_owned {
+            let mut data = MaybeUninit::new(val);
+            let data = unsafe {
+                slice::from_raw_parts_mut(
+                    data.as_mut_ptr() as *mut MaybeUninit<u8>,
+                    mem::size_of::<T>(),
+                )
+            };
+            val.zero_padding_bytes(data);
+            let data = unsafe { slice::from_raw_parts(data.as_ptr() as *const _, data.len()) };
+            self.ptr.buffer.write(self.ptr.offset, data).unwrap()
+        } else {
+            // Note: Zero padding is not required here as its a typed copy which does
+            //       not leak the bytes into the memory
+            // https://stackoverflow.com/questions/61114026/does-stdptrwrite-transfer-the-uninitialized-ness-of-the-bytes-it-writes
+            *(self.as_mut()) = val;
+        }
+    }
+}
diff --git a/lib/api/src/mem_access.rs b/lib/api/src/utils/mem/mod.rs
similarity index 91%
rename from lib/api/src/mem_access.rs
rename to lib/api/src/utils/mem/mod.rs
index 7c0b031c98..f1ba66a70b 100644
--- a/lib/api/src/mem_access.rs
+++ b/lib/api/src/utils/mem/mod.rs
@@ -1,18 +1,21 @@
-use crate::access::WasmRefAccess;
-use crate::externals::memory::MemoryBuffer;
-use crate::{Memory32, Memory64, MemorySize, MemoryView, WasmPtr};
-use crate::{RuntimeError, WasmSliceAccess};
-use std::convert::TryInto;
-use std::fmt;
-use std::marker::PhantomData;
-use std::mem::{self, MaybeUninit};
-use std::ops::Range;
-use std::slice;
-use std::string::FromUtf8Error;
+pub(crate) mod access;
+pub(crate) mod ptr;
+pub use ptr::*;
+
+use std::{
+    marker::PhantomData,
+    mem::{self, MaybeUninit},
+    ops::Range,
+    slice,
+    string::FromUtf8Error,
+};
+
+use crate::{buffer::MemoryBuffer, error::RuntimeError, view::MemoryView};
+use access::{WasmRefAccess, WasmSliceAccess};
 use thiserror::Error;
-use wasmer_types::ValueType;
+pub use wasmer_types::{Memory32, Memory64, MemorySize, ValueType};
 
-/// Error for invalid [`Memory`][super::Memory] access.
+/// Error for invalid [`Memory`][crate::Memory] access.
 #[derive(Clone, Copy, Debug, Error)]
 #[non_exhaustive]
 pub enum MemoryAccessError {
@@ -25,6 +28,9 @@ pub enum MemoryAccessError {
     /// String is not valid UTF-8.
     #[error("string is not valid utf-8")]
     NonUtf8String,
+    /// Pointer to memory is unaligned.
+    #[error("unaligned pointer read")]
+    UnalignedPointerRead,
 }
 
 impl From<MemoryAccessError> for RuntimeError {
@@ -117,12 +123,12 @@ impl<'a, T: ValueType> WasmRef<'a, T> {
     /// Gains direct access to the memory of this slice
     #[inline]
     pub fn access(self) -> Result<WasmRefAccess<'a, T>, MemoryAccessError> {
-        WasmRefAccess::new(self)
+        WasmRefAccess::new(self, self.buffer.is_owned())
     }
 }
 
-impl<'a, T: ValueType> fmt::Debug for WasmRef<'a, T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+impl<T: ValueType> std::fmt::Debug for WasmRef<'_, T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(
             f,
             "WasmRef(offset: {}, pointer: {:#x})",
@@ -217,7 +223,7 @@ impl<'a, T: ValueType> WasmSlice<'a, T> {
 
     /// Get a `WasmSlice` for a subslice of this slice.
     #[inline]
-    pub fn subslice(self, range: Range<u64>) -> WasmSlice<'a, T> {
+    pub fn subslice(self, range: Range<u64>) -> Self {
         if range.start > range.end || range.end > self.len {
             panic!("WasmSlice out of bounds");
         }
@@ -239,7 +245,7 @@ impl<'a, T: ValueType> WasmSlice<'a, T> {
     /// Gains direct access to the memory of this slice
     #[inline]
     pub fn access(self) -> Result<WasmSliceAccess<'a, T>, MemoryAccessError> {
-        WasmSliceAccess::new(self)
+        WasmSliceAccess::new(self, self.buffer.is_owned())
     }
 
     /// Reads an element of this slice.
@@ -356,8 +362,8 @@ impl<'a, T: ValueType> WasmSlice<'a, T> {
     }
 }
 
-impl<'a, T: ValueType> fmt::Debug for WasmSlice<'a, T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+impl<T: ValueType> std::fmt::Debug for WasmSlice<'_, T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(
             f,
             "WasmSlice(offset: {}, len: {}, pointer: {:#x})",
@@ -389,7 +395,7 @@ impl<'a, T: ValueType> Iterator for WasmSliceIter<'a, T> {
     }
 }
 
-impl<'a, T: ValueType> DoubleEndedIterator for WasmSliceIter<'a, T> {
+impl<T: ValueType> DoubleEndedIterator for WasmSliceIter<'_, T> {
     fn next_back(&mut self) -> Option<Self::Item> {
         if !self.slice.is_empty() {
             let elem = self.slice.index(self.slice.len() - 1);
@@ -401,4 +407,4 @@ impl<'a, T: ValueType> DoubleEndedIterator for WasmSliceIter<'a, T> {
     }
 }
 
-impl<'a, T: ValueType> ExactSizeIterator for WasmSliceIter<'a, T> {}
+impl<T: ValueType> ExactSizeIterator for WasmSliceIter<'_, T> {}
diff --git a/lib/api/src/ptr.rs b/lib/api/src/utils/mem/ptr.rs
similarity index 92%
rename from lib/api/src/ptr.rs
rename to lib/api/src/utils/mem/ptr.rs
index b1443a24cb..257e2a1cb2 100644
--- a/lib/api/src/ptr.rs
+++ b/lib/api/src/utils/mem/ptr.rs
@@ -1,12 +1,10 @@
-use crate::access::WasmRefAccess;
-use crate::mem_access::{MemoryAccessError, WasmRef, WasmSlice};
-use crate::{AsStoreRef, FromToNativeWasmType, MemoryView, NativeWasmTypeInto};
-use std::convert::TryFrom;
-use std::{fmt, marker::PhantomData, mem};
-pub use wasmer_types::Memory32;
-pub use wasmer_types::Memory64;
-pub use wasmer_types::MemorySize;
-use wasmer_types::ValueType;
+use std::marker::PhantomData;
+use wasmer_types::{Memory32, Memory64, MemorySize, ValueType};
+
+use crate::{
+    access::WasmRefAccess, view::MemoryView, AsStoreRef, FromToNativeWasmType, MemoryAccessError,
+    NativeWasmTypeInto, WasmRef, WasmSlice,
+};
 
 /// Alias for `WasmPtr<T, Memory64>.
 pub type WasmPtr64<T> = WasmPtr<T, Memory64>;
@@ -109,7 +107,7 @@ impl<T, M: MemorySize> WasmPtr<T, M> {
         let base = self.offset.into();
         let index = offset.into();
         let offset = index
-            .checked_mul(mem::size_of::<T>() as u64)
+            .checked_mul(std::mem::size_of::<T>() as u64)
             .ok_or(MemoryAccessError::Overflow)?;
         let address = base
             .checked_add(offset)
@@ -127,7 +125,7 @@ impl<T, M: MemorySize> WasmPtr<T, M> {
         let base = self.offset.into();
         let index = offset.into();
         let offset = index
-            .checked_mul(mem::size_of::<T>() as u64)
+            .checked_mul(std::mem::size_of::<T>() as u64)
             .ok_or(MemoryAccessError::Overflow)?;
         let address = base
             .checked_sub(offset)
@@ -254,7 +252,7 @@ where
 }
 
 unsafe impl<T: ValueType, M: MemorySize> ValueType for WasmPtr<T, M> {
-    fn zero_padding_bytes(&self, _bytes: &mut [mem::MaybeUninit<u8>]) {}
+    fn zero_padding_bytes(&self, _bytes: &mut [std::mem::MaybeUninit<u8>]) {}
 }
 
 impl<T: ValueType, M: MemorySize> Clone for WasmPtr<T, M> {
@@ -273,8 +271,8 @@ impl<T: ValueType, M: MemorySize> PartialEq for WasmPtr<T, M> {
 
 impl<T: ValueType, M: MemorySize> Eq for WasmPtr<T, M> {}
 
-impl<T: ValueType, M: MemorySize> fmt::Debug for WasmPtr<T, M> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+impl<T: ValueType, M: MemorySize> std::fmt::Debug for WasmPtr<T, M> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "{}(@{})", std::any::type_name::<T>(), self.offset.into())
     }
 }
diff --git a/lib/api/src/utils/mod.rs b/lib/api/src/utils/mod.rs
new file mode 100644
index 0000000000..f3170c93e7
--- /dev/null
+++ b/lib/api/src/utils/mod.rs
@@ -0,0 +1,22 @@
+//! Useful data types, functions and traits used throughout the crate to interact with WebAssembly
+//! entities such as [`crate::Memory`] and [`crate::Value`].
+
+/// Convert bynary data into [`bytes::Bytes`].
+mod into_bytes;
+pub use into_bytes::IntoBytes;
+
+/// Useful data types, functions and traits for the interaction between host types and WebAssembly.
+pub(crate) mod native;
+pub use native::*;
+
+/// Useful data types, functions and traits for interacting with the memory of a [`crate::Instance`].
+pub(crate) mod mem;
+pub use mem::*;
+
+/// Useful macros to generate enums to represent `Runtime`-types.
+pub(crate) mod rt_macros;
+
+#[cfg(any(feature = "wasm-types-polyfill", feature = "jsc"))]
+pub(crate) mod polyfill;
+
+pub(crate) mod macros;
diff --git a/lib/api/src/native_type.rs b/lib/api/src/utils/native/convert.rs
similarity index 83%
rename from lib/api/src/native_type.rs
rename to lib/api/src/utils/native/convert.rs
index 5879ff3da7..e776ce6854 100644
--- a/lib/api/src/native_type.rs
+++ b/lib/api/src/utils/native/convert.rs
@@ -1,16 +1,17 @@
-//! This module permits to create native functions
-//! easily in Rust, thanks to its advanced typing system.
-
-use wasmer_types::{NativeWasmType, RawValue, Type};
+pub use wasmer_types::NativeWasmType;
+use wasmer_types::{RawValue, Type};
 
 use crate::store::AsStoreRef;
-use crate::vm::{VMExternRef, VMFuncRef};
+use crate::{
+    vm::{VMExternRef, VMFuncRef},
+    ExternRef, Function, TypedFunction,
+};
 
-use crate::{ExternRef, Function, TypedFunction};
-use std::array::TryFromSliceError;
-use std::convert::Infallible;
-use std::convert::TryInto;
 use std::error::Error;
+use std::{
+    array::TryFromSliceError,
+    convert::{Infallible, TryInto},
+};
 
 use crate::store::AsStoreMut;
 
@@ -195,8 +196,38 @@ impl NativeWasmType for ExternRef {
 impl NativeWasmTypeInto for Option<ExternRef> {
     #[inline]
     unsafe fn from_abi(store: &mut impl AsStoreMut, abi: Self::Abi) -> Self {
-        VMExternRef::from_raw(RawValue { externref: abi })
-            .map(|e| ExternRef::from_vm_externref(store, e))
+        match store.as_store_ref().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(_) => {
+                wasmer_vm::VMExternRef::from_raw(RawValue { externref: abi }).map(VMExternRef::Sys)
+            }
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => {
+                crate::backend::wamr::vm::VMExternRef::from_raw(RawValue { externref: abi })
+                    .map(VMExternRef::Wamr)
+            }
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => {
+                crate::backend::wasmi::vm::VMExternRef::from_raw(RawValue { externref: abi })
+                    .map(VMExternRef::Wasmi)
+            }
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => {
+                crate::backend::v8::vm::VMExternRef::from_raw(RawValue { externref: abi })
+                    .map(VMExternRef::V8)
+            }
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => {
+                crate::backend::js::vm::VMExternRef::from_raw(RawValue { externref: abi })
+                    .map(VMExternRef::Js)
+            }
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => {
+                crate::backend::jsc::vm::VMExternRef::from_raw(RawValue { externref: abi })
+                    .map(VMExternRef::Jsc)
+            }
+        }
+        .map(|e| ExternRef::from_vm_externref(store, e))
     }
 
     #[inline]
@@ -211,7 +242,33 @@ impl NativeWasmTypeInto for Option<ExternRef> {
 
     #[inline]
     unsafe fn from_raw(store: &mut impl AsStoreMut, raw: RawValue) -> Self {
-        VMExternRef::from_raw(raw).map(|e| ExternRef::from_vm_externref(store, e))
+        match store.as_store_ref().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(_) => {
+                wasmer_vm::VMExternRef::from_raw(raw).map(VMExternRef::Sys)
+            }
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => {
+                crate::backend::wamr::vm::VMExternRef::from_raw(raw).map(VMExternRef::Wamr)
+            }
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => {
+                crate::backend::wasmi::vm::VMExternRef::from_raw(raw).map(VMExternRef::Wasmi)
+            }
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => {
+                crate::backend::v8::vm::VMExternRef::from_raw(raw).map(VMExternRef::V8)
+            }
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => {
+                crate::backend::js::vm::VMExternRef::from_raw(raw).map(VMExternRef::Js)
+            }
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => {
+                crate::backend::jsc::vm::VMExternRef::from_raw(raw).map(VMExternRef::Jsc)
+            }
+        }
+        .map(|e| ExternRef::from_vm_externref(store, e))
     }
 }
 
@@ -233,7 +290,38 @@ impl NativeWasmType for Function {
 impl NativeWasmTypeInto for Option<Function> {
     #[inline]
     unsafe fn from_abi(store: &mut impl AsStoreMut, abi: Self::Abi) -> Self {
-        VMFuncRef::from_raw(RawValue { funcref: abi }).map(|f| Function::from_vm_funcref(store, f))
+        match store.as_store_ref().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(_) => {
+                wasmer_vm::VMFuncRef::from_raw(RawValue { funcref: abi }).map(VMFuncRef::Sys)
+            }
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => {
+                crate::backend::wamr::vm::VMFuncRef::from_raw(RawValue { funcref: abi })
+                    .map(VMFuncRef::Wamr)
+            }
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => {
+                crate::backend::wasmi::vm::VMFuncRef::from_raw(RawValue { funcref: abi })
+                    .map(VMFuncRef::Wasmi)
+            }
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => {
+                crate::backend::v8::vm::VMFuncRef::from_raw(RawValue { funcref: abi })
+                    .map(VMFuncRef::V8)
+            }
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => {
+                crate::backend::js::vm::VMFuncRef::from_raw(RawValue { funcref: abi })
+                    .map(VMFuncRef::Js)
+            }
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => {
+                crate::backend::jsc::vm::VMFuncRef::from_raw(RawValue { funcref: abi })
+                    .map(VMFuncRef::Jsc)
+            }
+        }
+        .map(|f| Function::from_vm_funcref(store, f))
     }
 
     #[inline]
@@ -250,7 +338,31 @@ impl NativeWasmTypeInto for Option<Function> {
 
     #[inline]
     unsafe fn from_raw(store: &mut impl AsStoreMut, raw: RawValue) -> Self {
-        VMFuncRef::from_raw(raw).map(|f| Function::from_vm_funcref(store, f))
+        match store.as_store_ref().inner.store {
+            #[cfg(feature = "sys")]
+            crate::BackendStore::Sys(_) => wasmer_vm::VMFuncRef::from_raw(raw).map(VMFuncRef::Sys),
+            #[cfg(feature = "wamr")]
+            crate::BackendStore::Wamr(_) => {
+                crate::backend::wamr::vm::VMFuncRef::from_raw(raw).map(VMFuncRef::Wamr)
+            }
+            #[cfg(feature = "wasmi")]
+            crate::BackendStore::Wasmi(_) => {
+                crate::backend::wasmi::vm::VMFuncRef::from_raw(raw).map(VMFuncRef::Wasmi)
+            }
+            #[cfg(feature = "v8")]
+            crate::BackendStore::V8(_) => {
+                crate::backend::v8::vm::VMFuncRef::from_raw(raw).map(VMFuncRef::V8)
+            }
+            #[cfg(feature = "js")]
+            crate::BackendStore::Js(_) => {
+                crate::backend::js::vm::VMFuncRef::from_raw(raw).map(VMFuncRef::Js)
+            }
+            #[cfg(feature = "jsc")]
+            crate::BackendStore::Jsc(_) => {
+                crate::backend::jsc::vm::VMFuncRef::from_raw(raw).map(VMFuncRef::Jsc)
+            }
+        }
+        .map(|f| Function::from_vm_funcref(store, f))
     }
 }
 
diff --git a/lib/api/src/utils/native/mod.rs b/lib/api/src/utils/native/mod.rs
new file mode 100644
index 0000000000..65eb315215
--- /dev/null
+++ b/lib/api/src/utils/native/mod.rs
@@ -0,0 +1,7 @@
+/// Traits and implementations used to convert between native values and WebAssembly ones.
+pub(crate) mod convert;
+pub use convert::*;
+
+/// Trait to interact with native functions.
+pub(crate) mod typed_func;
+pub use typed_func::*;
diff --git a/lib/api/src/utils/native/typed_func.rs b/lib/api/src/utils/native/typed_func.rs
new file mode 100644
index 0000000000..76ff59db95
--- /dev/null
+++ b/lib/api/src/utils/native/typed_func.rs
@@ -0,0 +1,132 @@
+//! Native Functions.
+//!
+//! This module creates the helper [`TypedFunction`] that let us call WebAssembly
+//! functions with the native ABI, that is:
+//!
+//! ```ignore
+//! let add_one = instance.exports.get_function("function_name")?;
+//! let add_one_native: TypedFunction<i32, i32> = add_one.native().unwrap();
+//! ```
+use crate::{
+    store::AsStoreRef, AsStoreMut, BackendStore, FromToNativeWasmType, Function,
+    NativeWasmTypeInto, RuntimeError, WasmTypeList,
+};
+use std::marker::PhantomData;
+use wasmer_types::RawValue;
+
+/// A WebAssembly function that can be called natively
+/// (using the Native ABI).
+#[derive(Clone, Debug)]
+pub struct TypedFunction<Args, Rets> {
+    pub(crate) func: Function,
+    _phantom: PhantomData<fn(Args) -> Rets>,
+}
+
+unsafe impl<Args, Rets> Send for TypedFunction<Args, Rets> {}
+unsafe impl<Args, Rets> Sync for TypedFunction<Args, Rets> {}
+
+impl<Args, Rets> TypedFunction<Args, Rets>
+where
+    Args: WasmTypeList,
+    Rets: WasmTypeList,
+{
+    #[allow(dead_code)]
+    pub(crate) fn new(_store: &impl AsStoreRef, func: Function) -> Self {
+        Self {
+            func,
+            _phantom: PhantomData,
+        }
+    }
+
+    pub(crate) fn into_function(self) -> Function {
+        self.func
+    }
+}
+
+macro_rules! impl_native_traits {
+    (  $( $x:ident ),* ) => {
+        paste::paste!{
+        #[allow(unused_parens, non_snake_case)]
+        impl<$( $x , )* Rets> TypedFunction<( $( $x ),* ), Rets>
+        where
+            $( $x: FromToNativeWasmType, )*
+            Rets: WasmTypeList,
+        {
+            /// Call the typed func and return results.
+            #[allow(unused_mut)]
+            #[allow(clippy::too_many_arguments)]
+            pub fn call(&self, store: &mut impl AsStoreMut, $( $x: $x, )* ) -> Result<Rets, RuntimeError> where $( $x: FromToNativeWasmType, )*
+
+            {
+                $(
+                    let [<p_ $x>] = $x;
+                )*
+                match store.as_store_mut().inner.store {
+                    #[cfg(feature = "sys")]
+                    BackendStore::Sys(_) => self.call_sys(store, $([<p_ $x>]),*),
+                    #[cfg(feature = "wamr")]
+                    BackendStore::Wamr(_) => self.call_wamr(store, $([<p_ $x>]),*),
+                    #[cfg(feature = "wasmi")]
+                    BackendStore::Wasmi(_) => self.call_wasmi(store, $([<p_ $x>]),*),
+                    #[cfg(feature = "v8")]
+                    BackendStore::V8(_) => self.call_v8(store, $([<p_ $x>]),*),
+                    #[cfg(feature = "js")]
+                    BackendStore::Js(_) => self.call_js(store, $([<p_ $x>]),*),
+                    #[cfg(feature = "jsc")]
+                    BackendStore::Jsc(_) => self.call_jsc(store, $([<p_ $x>]),*),
+
+                }
+            }
+
+            #[doc(hidden)]
+            #[allow(missing_docs)]
+            #[allow(unused_mut)]
+            #[allow(clippy::too_many_arguments)]
+            pub fn call_raw(&self, store: &mut impl AsStoreMut, mut params_list: Vec<RawValue> ) -> Result<Rets, RuntimeError> {
+                match store.as_store_mut().inner.store {
+                    #[cfg(feature = "sys")]
+                    BackendStore::Sys(_) => self.call_raw_sys(store, params_list),
+                    #[cfg(feature = "wamr")]
+                    BackendStore::Wamr(_) => self.call_raw_wamr(store, params_list),
+                    #[cfg(feature = "wasmi")]
+                    BackendStore::Wasmi(_) => self.call_raw_wasmi(store, params_list),
+                    #[cfg(feature = "v8")]
+                    BackendStore::V8(_) => self.call_raw_v8(store, params_list),
+                    #[cfg(feature = "js")]
+                    BackendStore::Js(_) => self.call_raw_js(store, params_list),
+                    #[cfg(feature = "jsc")]
+                    BackendStore::Jsc(_) => self.call_raw_jsc(store, params_list),
+                }
+            }
+        }
+        }
+    };
+}
+
+impl_native_traits!();
+impl_native_traits!(A1);
+impl_native_traits!(A1, A2);
+impl_native_traits!(A1, A2, A3);
+impl_native_traits!(A1, A2, A3, A4);
+impl_native_traits!(A1, A2, A3, A4, A5);
+impl_native_traits!(A1, A2, A3, A4, A5, A6);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17);
+impl_native_traits!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18
+);
+impl_native_traits!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19
+);
+impl_native_traits!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20
+);
diff --git a/lib/api/src/module_info_polyfill.rs b/lib/api/src/utils/polyfill.rs
similarity index 85%
rename from lib/api/src/module_info_polyfill.rs
rename to lib/api/src/utils/polyfill.rs
index 43c3aa3181..8b54de444b 100644
--- a/lib/api/src/module_info_polyfill.rs
+++ b/lib/api/src/utils/polyfill.rs
@@ -2,22 +2,21 @@
 //! creates the corresponding import and export types.
 //!
 //! This shall not be needed once the JS type reflection API is available
-//! for the Wasm imports and exports.
-//!
+//! for the Wasm imports and exports.//!
 //! <https://github.com/WebAssembly/js-types/blob/master/proposals/js-types/Overview.md>
 use core::convert::TryFrom;
 use std::vec::Vec;
 use wasmer_types::entity::EntityRef;
 use wasmer_types::{
     ExportIndex, FunctionIndex, FunctionType, GlobalIndex, GlobalType, ImportIndex, MemoryIndex,
-    MemoryType, ModuleInfo, Pages, SignatureIndex, TableIndex, TableType, Type,
+    MemoryType, ModuleInfo, Pages, SignatureIndex, TableIndex, TableType, TagIndex, TagType, Type,
 };
 
 use wasmparser::{
     self, BinaryReaderError, Export, ExportSectionReader, ExternalKind, FunctionSectionReader,
     GlobalSectionReader, GlobalType as WPGlobalType, ImportSectionReader, MemorySectionReader,
-    MemoryType as WPMemoryType, NameSectionReader, Parser, Payload, TableSectionReader, TypeRef,
-    TypeSectionReader,
+    MemoryType as WPMemoryType, NameSectionReader, Parser, Payload, TableSectionReader,
+    TagType as WPTagType, TypeRef, TypeSectionReader,
 };
 
 pub type WasmResult<T> = Result<T, String>;
@@ -85,6 +84,39 @@ impl ModuleInfoPolyfill {
         Ok(())
     }
 
+    pub(crate) fn declare_tag_import(
+        &mut self,
+        t: wasmparser::TagType,
+        module_name: &str,
+        field_name: &str,
+    ) -> WasmResult<()> {
+        debug_assert_eq!(
+            self.info.tags.len(),
+            self.info.num_imported_tags,
+            "Imported tags must be declared first"
+        );
+
+        let tag = SignatureIndex::from_u32(t.func_type_idx);
+        debug_assert!(
+            self.info
+                .signatures
+                .get(SignatureIndex::from_u32(t.func_type_idx))
+                .is_some(),
+            "Imported tags must mach a declared signature!"
+        );
+
+        self.declare_import(
+            ImportIndex::Tag(TagIndex::from_u32(self.info.num_imported_tags as _)),
+            module_name,
+            field_name,
+        )?;
+
+        self.info.num_imported_tags += 1;
+        self.info.tags.push(tag);
+
+        Ok(())
+    }
+
     pub(crate) fn declare_table_import(
         &mut self,
         table: TableType,
@@ -196,6 +228,16 @@ impl ModuleInfoPolyfill {
         Ok(())
     }
 
+    pub(crate) fn reserve_tags(&mut self, num: u32) -> WasmResult<()> {
+        self.info.tags.reserve_exact(usize::try_from(num).unwrap());
+        Ok(())
+    }
+
+    pub(crate) fn declare_tag(&mut self, tag: SignatureIndex) -> WasmResult<()> {
+        self.info.tags.push(tag);
+        Ok(())
+    }
+
     pub(crate) fn reserve_exports(&mut self, num: u32) -> WasmResult<()> {
         self.info.exports.reserve(usize::try_from(num).unwrap());
         Ok(())
@@ -238,6 +280,10 @@ impl ModuleInfoPolyfill {
         self.declare_export(ExportIndex::Global(global_index), name)
     }
 
+    pub(crate) fn declare_tag_export(&mut self, tag_index: TagIndex, name: &str) -> WasmResult<()> {
+        self.declare_export(ExportIndex::Tag(tag_index), name)
+    }
+
     pub(crate) fn declare_module_name(&mut self, name: &str) -> WasmResult<()> {
         self.info.name = Some(name.to_string());
         Ok(())
@@ -250,7 +296,7 @@ fn transform_err(err: BinaryReaderError) -> String {
 
 /// Translate a sequence of bytes forming a valid Wasm binary into a
 /// parsed ModuleInfo `ModuleInfoPolyfill`.
-pub fn translate_module<'data>(data: &'data [u8]) -> WasmResult<ModuleInfoPolyfill> {
+pub fn translate_module(data: &[u8]) -> WasmResult<ModuleInfoPolyfill> {
     let mut module_info: ModuleInfoPolyfill = Default::default();
 
     for payload in Parser::new(0).parse_all(data) {
@@ -283,12 +329,19 @@ pub fn translate_module<'data>(data: &'data [u8]) -> WasmResult<ModuleInfoPolyfi
                 parse_export_section(exports, &mut module_info)?;
             }
 
+            Payload::TagSection(tags) => {
+                parse_tag_section(tags, &mut module_info)?;
+            }
+
             Payload::CustomSection(sectionreader) => {
                 // We still add the custom section data, but also read it as name section reader
                 let name = sectionreader.name();
                 if name == "name" {
                     parse_name_section(
-                        NameSectionReader::new(sectionreader.data(), sectionreader.data_offset()),
+                        NameSectionReader::new(wasmparser::BinaryReader::new(
+                            sectionreader.data(),
+                            sectionreader.data_offset(),
+                        )),
                         &mut module_info,
                     )?;
                 }
@@ -335,8 +388,8 @@ pub fn parse_type_section(
         let group = res.map_err(transform_err)?;
 
         for ty in group.into_types() {
-            match ty.composite_type {
-                wasmparser::CompositeType::Func(functype) => {
+            match ty.composite_type.inner {
+                wasmparser::CompositeInnerType::Func(functype) => {
                     let params = functype.params();
                     let returns = functype.results();
                     let sig_params: Vec<Type> = params
@@ -367,8 +420,8 @@ pub fn parse_type_section(
 }
 
 /// Parses the Import section of the wasm module.
-pub fn parse_import_section<'data>(
-    imports: ImportSectionReader<'data>,
+pub fn parse_import_section(
+    imports: ImportSectionReader<'_>,
     module_info: &mut ModuleInfoPolyfill,
 ) -> WasmResult<()> {
     module_info.reserve_imports(imports.count())?;
@@ -386,14 +439,15 @@ pub fn parse_import_section<'data>(
                     field_name,
                 )?;
             }
-            TypeRef::Tag(_) => {
-                unimplemented!("exception handling not implemented yet")
+            TypeRef::Tag(t) => {
+                module_info.declare_tag_import(t, module_name, field_name)?;
             }
             TypeRef::Memory(WPMemoryType {
                 shared,
                 memory64,
                 initial,
                 maximum,
+                ..
             }) => {
                 if memory64 {
                     unimplemented!("64bit memory not implemented yet");
@@ -422,8 +476,8 @@ pub fn parse_import_section<'data>(
                 module_info.declare_table_import(
                     TableType {
                         ty: wpreftype_to_type(tab.element_type).unwrap(),
-                        minimum: tab.initial,
-                        maximum: tab.maximum,
+                        minimum: tab.initial as u32,
+                        maximum: tab.maximum.map(|v| v as u32),
                     },
                     module_name,
                     field_name,
@@ -461,8 +515,8 @@ pub fn parse_table_section(
         let table = entry.map_err(transform_err)?;
         module_info.declare_table(TableType {
             ty: wpreftype_to_type(table.ty.element_type).unwrap(),
-            minimum: table.ty.initial,
-            maximum: table.ty.maximum,
+            minimum: table.ty.initial as u32,
+            maximum: table.ty.maximum.map(|v| v as u32),
         })?;
     }
 
@@ -482,6 +536,7 @@ pub fn parse_memory_section(
             memory64,
             initial,
             maximum,
+            ..
         } = entry.map_err(transform_err)?;
         if memory64 {
             unimplemented!("64bit memory not implemented yet");
@@ -507,6 +562,7 @@ pub fn parse_global_section(
         let WPGlobalType {
             content_type,
             mutable,
+            ..
         } = entry.map_err(transform_err)?.ty;
         let global = GlobalType {
             ty: wptype_to_type(content_type).unwrap(),
@@ -518,9 +574,24 @@ pub fn parse_global_section(
     Ok(())
 }
 
+/// Parses the Tag section of the wasm module.
+fn parse_tag_section(
+    tags: wasmparser::SectionLimited<wasmparser::TagType>,
+    module_info: &mut ModuleInfoPolyfill,
+) -> WasmResult<()> {
+    module_info.reserve_tags(tags.count())?;
+
+    for entry in tags {
+        let WPTagType { func_type_idx, .. } = entry.map_err(transform_err)?;
+        module_info.declare_tag(SignatureIndex::from_u32(func_type_idx))?;
+    }
+
+    Ok(())
+}
+
 /// Parses the Export section of the wasm module.
-pub fn parse_export_section<'data>(
-    exports: ExportSectionReader<'data>,
+pub fn parse_export_section(
+    exports: ExportSectionReader<'_>,
     module_info: &mut ModuleInfoPolyfill,
 ) -> WasmResult<()> {
     module_info.reserve_exports(exports.count())?;
@@ -549,9 +620,7 @@ pub fn parse_export_section<'data>(
             ExternalKind::Global => {
                 module_info.declare_global_export(GlobalIndex::new(index), name)?
             }
-            ExternalKind::Tag => {
-                unimplemented!("exception handling not implemented yet")
-            }
+            ExternalKind::Tag => module_info.declare_tag_export(TagIndex::new(index), name)?,
         }
     }
     Ok(())
@@ -564,8 +633,8 @@ pub fn parse_export_section<'data>(
 // }
 
 /// Parses the Name section of the wasm module.
-pub fn parse_name_section<'data>(
-    mut names: NameSectionReader<'data>,
+pub fn parse_name_section(
+    mut names: NameSectionReader<'_>,
     module_info: &mut ModuleInfoPolyfill,
 ) -> WasmResult<()> {
     while let Some(Ok(subsection)) = names.next() {
@@ -595,6 +664,7 @@ pub fn parse_name_section<'data>(
             | wasmparser::Name::Element(_)
             | wasmparser::Name::Data(_)
             | wasmparser::Name::Tag(_)
+            | wasmparser::Name::Field(_)
             | wasmparser::Name::Unknown { .. } => {}
         };
     }
diff --git a/lib/api/src/utils/rt_macros.rs b/lib/api/src/utils/rt_macros.rs
new file mode 100644
index 0000000000..8b13789179
--- /dev/null
+++ b/lib/api/src/utils/rt_macros.rs
@@ -0,0 +1 @@
+
diff --git a/lib/api/src/vm.rs b/lib/api/src/vm.rs
deleted file mode 100644
index 2347c0ba96..0000000000
--- a/lib/api/src/vm.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-//! The `vm` module re-exports wasmer-vm types.
-
-#[cfg(feature = "js")]
-pub(crate) use crate::js::vm::{
-    VMExtern, VMExternFunction, VMExternGlobal, VMExternMemory, VMExternRef, VMExternTable,
-    VMFuncRef, VMFunctionCallback, VMFunctionEnvironment, VMInstance, VMTrampoline,
-};
-
-#[cfg(feature = "jsc")]
-pub(crate) use crate::jsc::vm::{
-    VMExtern, VMExternFunction, VMExternGlobal, VMExternMemory, VMExternRef, VMExternTable,
-    VMFuncRef, VMFunctionCallback, VMFunctionEnvironment, VMInstance, VMTrampoline,
-};
-
-#[cfg(feature = "sys")]
-pub(crate) use crate::sys::vm::{
-    VMExtern, VMExternFunction, VMExternGlobal, VMExternMemory, VMExternRef, VMExternTable,
-    VMFuncRef, VMFunctionCallback, VMFunctionEnvironment, VMInstance, VMTrampoline,
-};
-
-#[cfg(feature = "js")]
-pub use crate::js::vm::{VMFunction, VMGlobal, VMMemory, VMSharedMemory, VMTable};
-
-#[cfg(feature = "sys")]
-pub use wasmer_vm::{VMConfig, VMFunction, VMGlobal, VMMemory, VMSharedMemory, VMTable};
-
-#[cfg(feature = "jsc")]
-pub use crate::jsc::vm::{VMFunction, VMGlobal, VMMemory, VMSharedMemory, VMTable};
-
-// Needed for tunables customization (those are public types now)
-#[cfg(feature = "sys")]
-pub use wasmer_vm::{
-    // An extra one for VMMemory implementors
-    LinearMemory,
-    VMMemoryDefinition,
-    VMTableDefinition,
-};
-
-// Deprecated exports
-pub use wasmer_types::{MemoryError, MemoryStyle, TableStyle};
diff --git a/lib/api/src/vm/impls.rs b/lib/api/src/vm/impls.rs
new file mode 100644
index 0000000000..29877545d1
--- /dev/null
+++ b/lib/api/src/vm/impls.rs
@@ -0,0 +1,60 @@
+use crate::macros::backend::match_rt;
+
+use super::*;
+
+impl VMExternToExtern for VMExtern {
+    fn to_extern(self, store: &mut impl crate::AsStoreMut) -> crate::Extern {
+        match_rt!(on self => s {
+            s.to_extern(store)
+        })
+    }
+}
+
+impl VMFunctionEnvironment {
+    #[allow(clippy::should_implement_trait)]
+    /// Returns a reference to the underlying value.
+    pub fn as_ref(&self) -> &(dyn std::any::Any + Send + 'static) {
+        match_rt!(on self => s {
+            s.as_ref()
+        })
+    }
+
+    #[allow(clippy::should_implement_trait)]
+    /// Returns a mutable reference to the underlying value.
+    pub fn as_mut(&mut self) -> &mut (dyn std::any::Any + Send + 'static) {
+        match_rt!(on self => s {
+            s.as_mut()
+        })
+    }
+
+    pub fn contents(self) -> Box<(dyn std::any::Any + Send + 'static)> {
+        match_rt!(on self => s {
+            s.contents
+        })
+    }
+}
+
+impl VMFuncRef {
+    /// Converts the `VMFuncRef` into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        match_rt!(on self => s {
+            s.into_raw()
+        })
+    }
+}
+
+impl VMExternRef {
+    /// Converts the `VMExternRef` into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        match_rt!(on self => s {
+            s.into_raw()
+        })
+    }
+}
+
+impl VMExceptionRef {
+    /// Converts the `VMExternRef` into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        todo!()
+    }
+}
diff --git a/lib/api/src/vm/mod.rs b/lib/api/src/vm/mod.rs
new file mode 100644
index 0000000000..01825f9ca5
--- /dev/null
+++ b/lib/api/src/vm/mod.rs
@@ -0,0 +1,448 @@
+//! This module defines traits to handle abstractions created by the runtimes.
+
+mod impls;
+
+use crate::VMExternToExtern;
+use wasmer_types::RawValue;
+
+macro_rules! define_vm_like {
+    ($name: ident $(, $derive:ident)*) => {
+        paste::paste! {
+        /// The enum for all those VM values of this kind.
+        $(#[derive($derive)])*
+        #[repr(C)]
+        pub enum [<VM $name>] {
+            #[cfg(feature = "sys")]
+            Sys(crate::backend::sys::vm::[<VM $name>]),
+            #[cfg(feature = "wamr")]
+            Wamr(crate::backend::wamr::vm::[<VM $name>]),
+            #[cfg(feature = "wasmi")]
+            Wasmi(crate::backend::wasmi::vm::[<VM $name>]),
+            #[cfg(feature = "v8")]
+            V8(crate::backend::v8::vm::[<VM $name>]),
+            #[cfg(feature = "js")]
+            Js(crate::backend::js::vm::[<VM $name>]),
+            #[cfg(feature = "jsc")]
+            Jsc(crate::backend::jsc::vm::[<VM $name>]),
+        }
+
+        impl [<VM $name>] {
+            #[cfg(feature = "sys")]
+            /// Consume `self` into a `sys` VM kind.
+            pub fn into_sys(self) -> crate::backend::sys::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Sys(s) => s,
+                    _ => panic!("Not a `sys` value!")
+                }
+            }
+
+            #[cfg(feature = "sys")]
+            /// Convert a reference to [`self`] into a reference to the same `sys` VM kind.
+            pub fn as_sys(&self) -> &crate::backend::sys::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Sys(s) => s,
+                    _ => panic!("Not a `sys` value!")
+                }
+            }
+
+            #[cfg(feature = "sys")]
+            /// Convert a mutable reference to [`self`] into a mutable reference to the same `sys` VM kind.
+            pub fn as_sys_mut(&mut self) -> &mut crate::backend::sys::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Sys(s) => s,
+                    _ => panic!("Not a `sys` value!")
+                }
+            }
+
+            #[cfg(feature = "wamr")]
+            /// Consume `self` into a `wamr` VM kind.
+            pub fn into_wamr(self) -> crate::backend::wamr::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Wamr(s) => s,
+                    _ => panic!("Not a `wamr` value!")
+                }
+            }
+
+            #[cfg(feature = "wamr")]
+            /// Convert a reference to [`self`] into a reference to the same `wamr` VM kind.
+            pub fn as_wamr(&self) -> &crate::backend::wamr::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Wamr(s) => s,
+                    _ => panic!("Not a `wamr` value!")
+                }
+            }
+
+            #[cfg(feature = "wamr")]
+            /// Convert a mutable reference to [`self`] into a mutable reference to the same `wamr` VM kind.
+            pub fn as_wamr_mut(&mut self) -> &mut crate::backend::wamr::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Wamr(s) => s,
+                    _ => panic!("Not a `wamr` value!")
+                }
+            }
+
+            #[cfg(feature = "wasmi")]
+            /// Consume `self` into a `wasmi` VM kind.
+            pub fn into_wasmi(self) -> crate::backend::wasmi::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Wasmi(s) => s,
+                    _ => panic!("Not a `wasmi` value!")
+                }
+            }
+
+            #[cfg(feature = "wasmi")]
+            /// Convert a reference to [`self`] into a reference to the same `wasmi` VM kind.
+            pub fn as_wasmi(&self) -> &crate::backend::wasmi::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Wasmi(s) => s,
+                    _ => panic!("Not a `wasmi` value!")
+                }
+            }
+
+            #[cfg(feature = "wasmi")]
+            /// Convert a mutable reference to [`self`] into a mutable reference to the same `wasmi` VM kind.
+            pub fn as_wasmi_mut(&mut self) -> &mut crate::backend::wasmi::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Wasmi(s) => s,
+                    _ => panic!("Not a `wasmi` value!")
+                }
+            }
+
+            #[cfg(feature = "v8")]
+            /// Consume `self` into a `v8` VM kind.
+            pub fn into_v8(self) -> crate::backend::v8::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::V8(s) => s,
+                    _ => panic!("Not a `v8` value!")
+                }
+            }
+
+            #[cfg(feature = "v8")]
+            /// Convert a reference to [`self`] into a reference to the same `v8` VM kind.
+            pub fn as_v8(&self) -> &crate::backend::v8::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::V8(s) => s,
+                    _ => panic!("Not a `v8` value!")
+                }
+            }
+
+            #[cfg(feature = "v8")]
+            /// Convert a mutable reference to [`self`] into a mutable reference to the same `v8` VM kind.
+            pub fn as_v8_mut(&mut self) -> &mut crate::backend::v8::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::V8(s) => s,
+                    _ => panic!("Not a `v8` value!")
+                }
+            }
+
+            #[cfg(feature = "js")]
+            /// Consume `self` into a `js` VM kind.
+            pub fn into_js(self) -> crate::backend::js::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Js(s) => s,
+                    _ => panic!("Not a `js` value!")
+                }
+            }
+
+            #[cfg(feature = "js")]
+            /// Convert a reference to [`self`] into a reference to the same `js` VM kind.
+            pub fn as_js(&self) -> &crate::backend::js::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Js(s) => s,
+                    _ => panic!("Not a `js` value!")
+                }
+            }
+
+            #[cfg(feature = "js")]
+            /// Convert a mutable reference to [`self`] into a mutable reference to the same `js` VM kind.
+            pub fn as_js_mut(&mut self) -> &mut crate::backend::js::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Js(s) => s,
+                    _ => panic!("Not a `js` value!")
+                }
+            }
+
+            #[cfg(feature = "jsc")]
+            /// Consume `self` into a `jsc` VM kind.
+            pub fn into_jsc(self) -> crate::backend::jsc::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Jsc(s) => s,
+                    _ => panic!("Not a `jsc` value!")
+                }
+            }
+
+            #[cfg(feature = "jsc")]
+            /// Convert a reference to [`self`] into a reference to the same `jsc` VM kind.
+            pub fn as_jsc(&self) -> &crate::backend::jsc::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Jsc(s) => s,
+                    _ => panic!("Not a `jsc` value!")
+                }
+            }
+
+            #[cfg(feature = "jsc")]
+            /// Convert a mutable reference to [`self`] into a mutable reference to the same `jsc` VM kind.
+            pub fn as_jsc_mut(&mut self) -> &mut crate::backend::jsc::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Jsc(s) => s,
+                    _ => panic!("Not a `jsc` value!")
+                }
+            }
+        }
+        }
+    };
+
+    ($name: ident $(, $derive:ident)*, @From) => {
+        paste::paste! {
+        /// The enum for all those VM values of this kind.
+        $(#[derive($derive)])*
+        #[repr(C)]
+        pub enum [<VM $name>] {
+            #[cfg(feature = "sys")]
+            Sys(crate::backend::sys::vm::[<VM $name>]),
+            #[cfg(feature = "wamr")]
+            Wamr(crate::backend::wamr::vm::[<VM $name>]),
+            #[cfg(feature = "wasmi")]
+            Wasmi(crate::backend::wasmi::vm::[<VM $name>]),
+            #[cfg(feature = "v8")]
+            V8(crate::backend::v8::vm::[<VM $name>]),
+            #[cfg(feature = "js")]
+            Js(crate::backend::js::vm::[<VM $name>]),
+            #[cfg(feature = "jsc")]
+            Jsc(crate::backend::jsc::vm::[<VM $name>]),
+        }
+
+        #[cfg(feature = "sys")]
+        impl From<crate::backend::sys::vm::[<VM $name>]> for [<VM $name>] {
+            fn from(value: crate::backend::sys::vm::[<VM $name>]) -> Self {
+                [<VM $name>]::Sys(value)
+            }
+        }
+
+        #[cfg(feature = "wamr")]
+        impl From<crate::backend::wamr::vm::[<VM $name>]> for [<VM $name>] {
+            fn from(value: crate::backend::wamr::vm::[<VM $name>]) -> Self {
+                [<VM $name>]::Wamr(value)
+            }
+        }
+
+        #[cfg(feature = "wasmi")]
+        impl From<crate::backend::wasmi::vm::[<VM $name>]> for [<VM $name>] {
+            fn from(value: crate::backend::wasmi::vm::[<VM $name>]) -> Self {
+                [<VM $name>]::Wasmi(value)
+            }
+        }
+
+        #[cfg(feature = "v8")]
+        impl From<crate::backend::v8::vm::[<VM $name>]> for [<VM $name>] {
+            fn from(value: crate::backend::v8::vm::[<VM $name>]) -> Self {
+                [<VM $name>]::V8(value)
+            }
+        }
+
+        #[cfg(feature = "js")]
+        impl From<crate::backend::js::vm::[<VM $name>]> for [<VM $name>] {
+            fn from(value: crate::backend::js::vm::[<VM $name>]) -> Self {
+                [<VM $name>]::Js(value)
+            }
+        }
+
+        #[cfg(feature = "jsc")]
+        impl From<crate::backend::jsc::vm::[<VM $name>]> for [<VM $name>] {
+            fn from(value: crate::backend::jsc::vm::[<VM $name>]) -> Self {
+                [<VM $name>]::Jsc(value)
+            }
+        }
+
+        impl [<VM $name>] {
+            #[cfg(feature = "sys")]
+            /// Consume `self` into a `sys` VM kind.
+            pub fn into_sys(self) -> crate::backend::sys::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Sys(s) => s,
+                    _ => panic!("Not a `sys` value!")
+                }
+            }
+
+            #[cfg(feature = "sys")]
+            /// Convert a reference to [`self`] into a reference to the same `sys` VM kind.
+            pub fn as_sys(&self) -> &crate::backend::sys::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Sys(s) => s,
+                    _ => panic!("Not a `sys` value!")
+                }
+            }
+
+            #[cfg(feature = "sys")]
+            /// Convert a mutable reference to [`self`] into a mutable reference to the same `sys` VM kind.
+            pub fn as_sys_mut(&mut self) -> &mut crate::backend::sys::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Sys(s) => s,
+                    _ => panic!("Not a `sys` value!")
+                }
+            }
+
+            #[cfg(feature = "wamr")]
+            /// Consume `self` into a `wamr` VM kind.
+            pub fn into_wamr(self) -> crate::backend::wamr::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Wamr(s) => s,
+                    _ => panic!("Not a `wamr` value!")
+                }
+            }
+
+            #[cfg(feature = "wamr")]
+            /// Convert a reference to [`self`] into a reference to the same `wamr` VM kind.
+            pub fn as_wamr(&self) -> &crate::backend::wamr::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Wamr(s) => s,
+                    _ => panic!("Not a `wamr` value!")
+                }
+            }
+
+            #[cfg(feature = "wamr")]
+            /// Convert a mutable reference to [`self`] into a mutable reference to the same `wamr` VM kind.
+            pub fn as_wamr_mut(&mut self) -> &mut crate::backend::wamr::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Wamr(s) => s,
+                    _ => panic!("Not a `wamr` value!")
+                }
+            }
+
+            #[cfg(feature = "wasmi")]
+            /// Consume `self` into a `wasmi` VM kind.
+            pub fn into_wasmi(self) -> crate::backend::wasmi::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Wasmi(s) => s,
+                    _ => panic!("Not a `wasmi` value!")
+                }
+            }
+
+            #[cfg(feature = "wasmi")]
+            /// Convert a reference to [`self`] into a reference to the same `wasmi` VM kind.
+            pub fn as_wasmi(&self) -> &crate::backend::wasmi::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Wasmi(s) => s,
+                    _ => panic!("Not a `wasmi` value!")
+                }
+            }
+
+            #[cfg(feature = "wasmi")]
+            /// Convert a mutable reference to [`self`] into a mutable reference to the same `wasmi` VM kind.
+            pub fn as_wasmi_mut(&mut self) -> &mut crate::backend::wasmi::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Wasmi(s) => s,
+                    _ => panic!("Not a `wasmi` value!")
+                }
+            }
+
+            #[cfg(feature = "v8")]
+            /// Consume `self` into a `v8` VM kind.
+            pub fn into_v8(self) -> crate::backend::v8::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::V8(s) => s,
+                    _ => panic!("Not a `v8` value!")
+                }
+            }
+
+            #[cfg(feature = "v8")]
+            /// Convert a reference to [`self`] into a reference to the same `v8` VM kind.
+            pub fn as_v8(&self) -> &crate::backend::v8::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::V8(s) => s,
+                    _ => panic!("Not a `v8` value!")
+                }
+            }
+
+            #[cfg(feature = "v8")]
+            /// Convert a mutable reference to [`self`] into a mutable reference to the same `v8` VM kind.
+            pub fn as_v8_mut(&mut self) -> &mut crate::backend::v8::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::V8(s) => s,
+                    _ => panic!("Not a `v8` value!")
+                }
+            }
+
+            #[cfg(feature = "js")]
+            /// Consume `self` into a `js` VM kind.
+            pub fn into_js(self) -> crate::backend::js::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Js(s) => s,
+                    _ => panic!("Not a `js` value!")
+                }
+            }
+
+            #[cfg(feature = "js")]
+            /// Convert a reference to [`self`] into a reference to the same `js` VM kind.
+            pub fn as_js(&self) -> &crate::backend::js::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Js(s) => s,
+                    _ => panic!("Not a `js` value!")
+                }
+            }
+
+            #[cfg(feature = "js")]
+            /// Convert a mutable reference to [`self`] into a mutable reference to the same `js` VM kind.
+            pub fn as_js_mut(&mut self) -> &mut crate::backend::js::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Js(s) => s,
+                    _ => panic!("Not a `js` value!")
+                }
+            }
+
+            #[cfg(feature = "jsc")]
+            /// Consume `self` into a `jsc` VM kind.
+            pub fn into_jsc(self) -> crate::backend::jsc::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Jsc(s) => s,
+                    _ => panic!("Not a `jsc` value!")
+                }
+            }
+
+            #[cfg(feature = "jsc")]
+            /// Convert a reference to [`self`] into a reference to the same `jsc` VM kind.
+            pub fn as_jsc(&self) -> &crate::backend::jsc::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Jsc(s) => s,
+                    _ => panic!("Not a `jsc` value!")
+                }
+            }
+
+            #[cfg(feature = "jsc")]
+            /// Convert a mutable reference to [`self`] into a mutable reference to the same `jsc` VM kind.
+            pub fn as_jsc_mut(&mut self) -> &mut crate::backend::jsc::vm::[<VM $name>] {
+                match self {
+                    [<VM $name>]::Jsc(s) => s,
+                    _ => panic!("Not a `jsc` value!")
+                }
+            }
+        }
+        }
+    };
+}
+
+define_vm_like!(Extern);
+define_vm_like!(ExternFunction);
+define_vm_like!(ExternGlobal);
+define_vm_like!(ExternTag);
+define_vm_like!(ExternMemory);
+define_vm_like!(ExternTable);
+//define_vm_like!(ExternObj, Debug);
+define_vm_like!(FunctionCallback);
+define_vm_like!(FunctionBody);
+define_vm_like!(FunctionEnvironment, Debug);
+define_vm_like!(Instance, Debug);
+define_vm_like!(Trampoline);
+
+//define_vm_like!(Config);
+define_vm_like!(Function, Debug);
+define_vm_like!(Global, Debug);
+define_vm_like!(Tag, Debug);
+define_vm_like!(Exception, Debug);
+define_vm_like!(Memory, Debug, @From);
+define_vm_like!(SharedMemory);
+define_vm_like!(Table, Debug);
+
+define_vm_like!(ExceptionRef);
+define_vm_like!(ExternRef);
+define_vm_like!(FuncRef);
diff --git a/lib/api/tests/externals.rs b/lib/api/tests/externals.rs
index 9a991dcd0b..6a063f8d83 100644
--- a/lib/api/tests/externals.rs
+++ b/lib/api/tests/externals.rs
@@ -29,6 +29,10 @@ fn global_new() -> Result<(), String> {
 }
 
 #[universal_test]
+#[cfg_attr(
+    feature = "wamr",
+    ignore = "wamr does not support globals unattached to instances"
+)]
 fn global_get() -> Result<(), String> {
     let mut store = Store::default();
 
@@ -56,6 +60,10 @@ fn global_get() -> Result<(), String> {
 }
 
 #[universal_test]
+#[cfg_attr(
+    feature = "wamr",
+    ignore = "wamr does not support globals unattached to instances"
+)]
 fn global_set() -> Result<(), String> {
     let mut store = Store::default();
     let global_i32 = Global::new(&mut store, Value::I32(10));
@@ -76,6 +84,7 @@ fn global_set() -> Result<(), String> {
 }
 
 #[universal_test]
+#[cfg_attr(feature = "wasmi", ignore = "wasmi does not support funcrefs")]
 fn table_new() -> Result<(), String> {
     let mut store = Store::default();
     let table_type = TableType {
@@ -124,6 +133,77 @@ fn table_get() -> Result<(), String> {
 #[universal_test]
 fn table_set() -> Result<(), String> {
     // Table set not yet tested
+    #[cfg(feature = "sys")]
+    {
+        let mut store = Store::default();
+
+        let table_type = TableType {
+            ty: Type::ExternRef,
+            minimum: 1,
+            maximum: None,
+        };
+        let extern_ref = ExternRef::new(&mut store, 0u32);
+        let table = Table::new(
+            &mut store,
+            table_type,
+            Value::ExternRef(Some(extern_ref.clone())),
+        )
+        .map_err(|e| format!("{e:?}"))?;
+        assert_eq!(table.ty(&store), table_type);
+
+        let v = table.get(&mut store, 0);
+        assert!(v.is_some());
+
+        let v = v.unwrap();
+
+        let v = if let Value::ExternRef(Some(ext)) = v {
+            ext.downcast::<u32>(&mut store)
+        } else {
+            return Err("table.get does not match `ExternRef(Some(..))`!".into());
+        };
+
+        let v = v.unwrap();
+        assert_eq!(*v, 0u32);
+
+        let extern_ref = ExternRef::new(&mut store, 1u32);
+        table
+            .set(&mut store, 0, Value::ExternRef(Some(extern_ref)))
+            .map_err(|e| e.to_string())?;
+
+        let v = table.get(&mut store, 0);
+        assert!(v.is_some());
+        let v = v.unwrap();
+
+        let v = if let Value::ExternRef(Some(ext)) = v {
+            ext.downcast::<u32>(&mut store)
+        } else {
+            return Err("table.get does not match `ExternRef(Some(..))`!".into());
+        };
+
+        assert!(v.is_some());
+        let v = v.unwrap();
+        assert_eq!(*v, 1u32);
+
+        let extern_ref = ExternRef::new(&mut store, 2u32);
+        table
+            .set(&mut store, 0, Value::ExternRef(Some(extern_ref)))
+            .map_err(|e| e.to_string())?;
+
+        let v = table.get(&mut store, 0);
+        assert!(v.is_some());
+        let v = v.unwrap();
+
+        let v = if let Value::ExternRef(Some(ext)) = v {
+            ext.downcast::<u32>(&mut store)
+        } else {
+            return Err("table.get does not match `ExternRef(Some(..))`!".into());
+        };
+
+        assert!(v.is_some());
+        let v = v.unwrap();
+        assert_eq!(*v, 2u32);
+    }
+
     Ok(())
 }
 
@@ -141,15 +221,20 @@ fn table_grow() -> Result<(), String> {
         let f = Function::new_typed(&mut store, |num: i32| num + 1);
         let table = Table::new(&mut store, table_type, Value::FuncRef(Some(f.clone())))
             .map_err(|e| format!("{e:?}"))?;
+
+        let old_len = table.grow(&mut store, 1, Value::FuncRef(Some(f.clone())));
+        assert_eq!(0, old_len.unwrap());
+        let old_len = table.grow(&mut store, 1, Value::FuncRef(Some(f.clone())));
+        assert_eq!(1, old_len.unwrap());
+
         // Growing to a bigger maximum should return None
         let old_len = table.grow(&mut store, 12, Value::FuncRef(Some(f.clone())));
         assert!(old_len.is_err());
 
-        // Growing to a bigger maximum should return None
         let old_len = table
             .grow(&mut store, 5, Value::FuncRef(Some(f)))
             .map_err(|e| format!("{e:?}"))?;
-        assert_eq!(old_len, 0);
+        assert_eq!(old_len, 2);
     }
 
     Ok(())
@@ -165,7 +250,7 @@ fn table_copy() -> Result<(), String> {
 fn memory_new() -> Result<(), String> {
     let mut store = Store::default();
     let memory_type = MemoryType {
-        shared: false,
+        shared: if cfg!(feature = "wamr") { true } else { false },
         minimum: Pages(0),
         maximum: Some(Pages(10)),
     };
@@ -176,6 +261,10 @@ fn memory_new() -> Result<(), String> {
 }
 
 #[universal_test]
+#[cfg_attr(
+    feature = "wamr",
+    ignore = "wamr does not support direct calls to grow memory"
+)]
 fn memory_grow() -> Result<(), String> {
     let mut store = Store::default();
     let desc = MemoryType::new(Pages(10), Some(Pages(16)), false);
@@ -318,18 +407,22 @@ fn function_new_dynamic() -> Result<(), String> {
     );
     assert_eq!(function.ty(&store), function_type);
 
-    // Using array signature
-    let function_type = ([Type::V128], [Type::I32, Type::F32, Type::F64]);
-    let function = Function::new(
-        &mut store,
-        function_type,
-        |_values: &[Value]| unimplemented!(),
-    );
-    assert_eq!(function.ty(&store).params(), [Type::V128]);
-    assert_eq!(
-        function.ty(&store).results(),
-        [Type::I32, Type::F32, Type::F64]
-    );
+    // wasmi does not support V128 through its wasm_c_api bindings.
+    #[cfg(not(any(feature = "wasmi", feature = "v8")))]
+    {
+        // Using array signature
+        let function_type = ([Type::V128], [Type::I32, Type::F32, Type::F64]);
+        let function = Function::new(
+            &mut store,
+            function_type,
+            |_values: &[Value]| unimplemented!(),
+        );
+        assert_eq!(function.ty(&store).params(), [Type::V128]);
+        assert_eq!(
+            function.ty(&store).results(),
+            [Type::I32, Type::F32, Type::F64]
+        );
+    }
 
     Ok(())
 }
@@ -384,19 +477,22 @@ fn function_new_dynamic_env() -> Result<(), String> {
     );
     assert_eq!(function.ty(&store), function_type);
 
-    // Using array signature
-    let function_type = ([Type::V128], [Type::I32, Type::F32, Type::F64]);
-    let function = Function::new_with_env(
-        &mut store,
-        &env,
-        function_type,
-        |_env: FunctionEnvMut<MyEnv>, _values: &[Value]| unimplemented!(),
-    );
-    assert_eq!(function.ty(&store).params(), [Type::V128]);
-    assert_eq!(
-        function.ty(&store).results(),
-        [Type::I32, Type::F32, Type::F64]
-    );
-
+    // wasmi does not support V128 through its wasm_c_api bindings.
+    #[cfg(not(any(feature = "wasmi", feature = "v8")))]
+    {
+        // Using array signature
+        let function_type = ([Type::V128], [Type::I32, Type::F32, Type::F64]);
+        let function = Function::new_with_env(
+            &mut store,
+            &env,
+            function_type,
+            |_env: FunctionEnvMut<MyEnv>, _values: &[Value]| unimplemented!(),
+        );
+        assert_eq!(function.ty(&store).params(), [Type::V128]);
+        assert_eq!(
+            function.ty(&store).results(),
+            [Type::I32, Type::F32, Type::F64]
+        );
+    }
     Ok(())
 }
diff --git a/lib/api/tests/function_env.rs b/lib/api/tests/function_env.rs
index 2c5c525453..f6305dc019 100644
--- a/lib/api/tests/function_env.rs
+++ b/lib/api/tests/function_env.rs
@@ -1,10 +1,14 @@
 use macro_wasmer_universal_test::universal_test;
 #[cfg(feature = "js")]
-use wasm_bindgen_test::*;
+use wasm_bindgen_test::wasm_bindgen_test;
 
 use wasmer::*;
 
 #[universal_test]
+#[cfg_attr(
+    feature = "wamr",
+    ignore = "wamr does not support globals without an instance"
+)]
 fn data_and_store_mut() -> Result<(), String> {
     let mut store = Store::default();
     let global_mut = Global::new_mut(&mut store, Value::I32(10));
diff --git a/lib/api/tests/import_function.rs b/lib/api/tests/import_function.rs
index 007b82c9e8..fb8edec98b 100644
--- a/lib/api/tests/import_function.rs
+++ b/lib/api/tests/import_function.rs
@@ -6,6 +6,10 @@ use anyhow::Result;
 use wasmer::*;
 
 #[universal_test]
+#[cfg_attr(
+    all(target_os = "windows", feature = "v8"),
+    ignore = "flaky test on windows when using v8"
+)]
 fn pass_i64_between_host_and_plugin() -> Result<(), String> {
     let mut store = Store::default();
 
@@ -48,6 +52,10 @@ fn pass_i64_between_host_and_plugin() -> Result<(), String> {
 }
 
 #[universal_test]
+#[cfg_attr(
+    all(target_os = "windows", feature = "v8"),
+    ignore = "flaky test on windows when using v8"
+)]
 fn pass_u64_between_host_and_plugin() -> Result<(), String> {
     let mut store = Store::default();
 
@@ -132,7 +140,7 @@ fn back_and_forth_with_imports() -> Result<()> {
     )?;
 
     fn sum(a: i32, b: i32) -> i32 {
-        println!("Summing: {}+{}", a, b);
+        println!("Summing: {a}+{b}");
         a + b
     }
 
diff --git a/lib/api/tests/instance.rs b/lib/api/tests/instance.rs
index bffdfd8125..a0c5e48ed3 100644
--- a/lib/api/tests/instance.rs
+++ b/lib/api/tests/instance.rs
@@ -49,10 +49,14 @@ fn exports_work_after_multiple_instances_have_been_freed() -> Result<(), String>
 }
 
 #[universal_test]
+#[cfg_attr(
+    feature = "wamr",
+    ignore = "wamr does not support function calls without an instance"
+)]
 fn unit_native_function_env() -> Result<(), String> {
     let mut store = Store::default();
 
-    #[derive(Clone)]
+    #[derive(Clone, Debug)]
     struct Env {
         multiplier: u32,
     }
diff --git a/lib/api/tests/memory.rs b/lib/api/tests/memory.rs
index bf5f6ecb04..c79b6eed8c 100644
--- a/lib/api/tests/memory.rs
+++ b/lib/api/tests/memory.rs
@@ -2,10 +2,18 @@ use std::sync::{
     atomic::{AtomicBool, Ordering},
     Arc,
 };
-
-use wasmer::{imports, Instance, Memory, MemoryLocation, MemoryType, Module, Store};
+use wasmer::{
+    imports, Instance, Memory, MemoryAccessError, MemoryLocation, MemoryType, Module, Store,
+    WasmSlice,
+};
 
 #[test]
+#[cfg_attr(feature = "wamr", ignore = "wamr ignores import memories")]
+#[cfg_attr(feature = "wasmi", ignore = "wasmi does not support threads")]
+#[cfg_attr(
+    feature = "v8",
+    ignore = "v8 does not currently support shared memory through wasm_c_api"
+)]
 fn test_shared_memory_atomics_notify_send() {
     let mut store = Store::default();
     let wat = r#"(module
@@ -76,3 +84,61 @@ fn test_shared_memory_disable_atomics() {
     let err = mem.wait(MemoryLocation::new_32(1), None).unwrap_err();
     assert_eq!(err, AtomicsError::AtomicsDisabled);
 }
+
+/// See https://github.com/wasmerio/wasmer/issues/5444
+#[test]
+#[cfg(feature = "sys")]
+fn test_wasm_slice_issue_5444() {
+    let mut store = Store::default();
+    let wat = r#"(module
+(import "host" "memory" (memory 10 65536))
+)"#;
+    let module = Module::new(&store, wat)
+        .map_err(|e| format!("{e:?}"))
+        .unwrap();
+
+    let mem = Memory::new(&mut store, MemoryType::new(10, Some(65536), false)).unwrap();
+
+    let imports = imports! {
+        "host" => {
+            "memory" => mem.clone(),
+        },
+    };
+
+    let _inst = Instance::new(&mut store, &module, &imports).unwrap();
+
+    let view = mem.view(&store);
+    let slice = WasmSlice::<u64>::new(&view, 1, 10).unwrap();
+    let access = slice.access();
+
+    assert!(matches!(
+        access.err(),
+        Some(MemoryAccessError::UnalignedPointerRead)
+    ))
+}
+
+#[cfg_attr(
+    feature = "wamr",
+    ignore = "wamr reports memory size incorrectly in this scenario"
+)]
+#[test]
+fn test_wasm_memory_size() {
+    let mut store = Store::default();
+
+    // Test once with not-shared memory...
+    {
+        let memory = Memory::new(&mut store, MemoryType::new(10, Some(65536), false)).unwrap();
+        assert_eq!(memory.size(&store).0, 10);
+        memory.grow(&mut store, wasmer::Pages(1)).unwrap();
+        assert_eq!(memory.size(&store).0, 11);
+    }
+
+    // ... and once with shared memory, since JS and JSC (at least) have different
+    // representations for it
+    {
+        let memory = Memory::new(&mut store, MemoryType::new(10, Some(65536), true)).unwrap();
+        assert_eq!(memory.size(&store).0, 10);
+        memory.grow(&mut store, wasmer::Pages(1)).unwrap();
+        assert_eq!(memory.size(&store).0, 11);
+    }
+}
diff --git a/lib/api/tests/module.rs b/lib/api/tests/module.rs
index 22683f5248..cdfdd7d75e 100644
--- a/lib/api/tests/module.rs
+++ b/lib/api/tests/module.rs
@@ -8,9 +8,7 @@ use wasmer::*;
 fn module_get_name() -> Result<(), String> {
     let store = Store::default();
     let wat = r#"(module)"#;
-    let module = Module::new(&store, wat)
-        .map_err(|e| format!("{e:?}"))
-        .map_err(|e| format!("{e:?}"))?;
+    let module = Module::new(&store, wat).map_err(|e| format!("{e:?}"))?;
     assert_eq!(module.name(), None);
 
     Ok(())
@@ -35,7 +33,7 @@ fn imports() -> Result<(), String> {
     let wat = r#"(module
 (import "host" "func" (func))
 (import "host" "memory" (memory 1))
-(import "host" "table" (table 1 anyfunc))
+(import "host" "table" (table 1 funcref))
 (import "host" "global" (global i32))
 )"#;
     let module = Module::new(&store, wat).map_err(|e| format!("{e:?}"))?;
@@ -196,35 +194,35 @@ fn calling_host_functions_with_negative_values_works() -> Result<(), String> {
     let imports = imports! {
         "host" => {
             "host_func1" => Function::new_typed(&mut store, |p: u64| {
-                println!("host_func1: Found number {}", p);
+                println!("host_func1: Found number {p}");
                 assert_eq!(p, u64::max_value());
             }),
             "host_func2" => Function::new_typed(&mut store, |p: u32| {
-                println!("host_func2: Found number {}", p);
+                println!("host_func2: Found number {p}");
                 assert_eq!(p, u32::max_value());
             }),
             "host_func3" => Function::new_typed(&mut store, |p: i64| {
-                println!("host_func3: Found number {}", p);
+                println!("host_func3: Found number {p}");
                 assert_eq!(p, -1);
             }),
             "host_func4" => Function::new_typed(&mut store, |p: i32| {
-                println!("host_func4: Found number {}", p);
+                println!("host_func4: Found number {p}");
                 assert_eq!(p, -1);
             }),
             "host_func5" => Function::new_typed(&mut store, |p: i16| {
-                println!("host_func5: Found number {}", p);
+                println!("host_func5: Found number {p}");
                 assert_eq!(p, -1);
             }),
             "host_func6" => Function::new_typed(&mut store, |p: u16| {
-                println!("host_func6: Found number {}", p);
+                println!("host_func6: Found number {p}");
                 assert_eq!(p, u16::max_value());
             }),
             "host_func7" => Function::new_typed(&mut store, |p: i8| {
-                println!("host_func7: Found number {}", p);
+                println!("host_func7: Found number {p}");
                 assert_eq!(p, -1);
             }),
             "host_func8" => Function::new_typed(&mut store, |p: u8| {
-                println!("host_func8: Found number {}", p);
+                println!("host_func8: Found number {p}");
                 assert_eq!(p, u8::max_value());
             }),
         }
@@ -277,6 +275,9 @@ fn calling_host_functions_with_negative_values_works() -> Result<(), String> {
 }
 
 #[universal_test]
+#[cfg_attr(feature = "wamr", ignore = "wamr does not support custom sections")]
+#[cfg_attr(feature = "wasmi", ignore = "wasmi does not support custom sections")]
+#[cfg_attr(feature = "v8", ignore = "v8 does not support custom sections")]
 fn module_custom_sections() -> Result<(), String> {
     let store = Store::default();
     let custom_section_wasm_bytes = include_bytes!("simple-name-section.wasm");
diff --git a/lib/api/tests/reference_types.rs b/lib/api/tests/reference_types.rs
index b7138543f2..b014e6b2f4 100644
--- a/lib/api/tests/reference_types.rs
+++ b/lib/api/tests/reference_types.rs
@@ -487,4 +487,170 @@ pub mod reference_types {
 
         Ok(())
     }
+
+    #[universal_test]
+    fn extern_ref_ref_counting_table_instructions_in_module() -> Result<()> {
+        let mut store = Store::default();
+        let wat = r#"(module
+    (table $table1 (export "table1") 2 12 externref)
+    (table $table2 (export "table2") 6 12 externref)
+    (func $grow_table_with_ref (export "grow_table_with_ref") (param $er externref) (param $size i32) (result i32)
+          (table.grow $table1 (local.get $er) (local.get $size)))
+    (func $fill_table_with_ref (export "fill_table_with_ref") (param $er externref) (param $start i32) (param $end i32)
+          (table.fill $table1 (local.get $start) (local.get $er) (local.get $end)))
+    (func $copy_into_table2 (export "copy_into_table2")
+          (table.copy $table2 $table1 (i32.const 0) (i32.const 0) (i32.const 4)))
+    (func (export "call_set_value") (param $er externref) (param $idx i32)
+          (table.set $table2 (local.get $idx) (local.get $er)))
+)"#;
+        let module = Module::new(&store, wat)?;
+        let instance = Instance::new(&mut store, &module, &imports! {})?;
+
+        let grow_table_with_ref: TypedFunction<(Option<ExternRef>, i32), i32> = instance
+            .exports
+            .get_typed_function(&store, "grow_table_with_ref")?;
+        let fill_table_with_ref: TypedFunction<(Option<ExternRef>, i32, i32), ()> = instance
+            .exports
+            .get_typed_function(&store, "fill_table_with_ref")?;
+        let copy_into_table2: TypedFunction<(), ()> = instance
+            .exports
+            .get_typed_function(&store, "copy_into_table2")?;
+        let call_set_value: TypedFunction<(Option<ExternRef>, i32), ()> = instance
+            .exports
+            .get_typed_function(&store, "call_set_value")?;
+        let table1: &Table = instance.exports.get_table("table1")?;
+        let table2: &Table = instance.exports.get_table("table2")?;
+
+        let er1 = ExternRef::new(&mut store, 3usize);
+        let er2 = ExternRef::new(&mut store, 5usize);
+        let er3 = ExternRef::new(&mut store, 7usize);
+        {
+            let result = grow_table_with_ref.call(&mut store, Some(er1.clone()), 0)?;
+            assert_eq!(result, 2);
+
+            let result = grow_table_with_ref.call(&mut store, Some(er1.clone()), 10_000)?;
+            assert_eq!(result, -1);
+
+            let result = grow_table_with_ref.call(&mut store, Some(er1), 8)?;
+            assert_eq!(result, 2);
+
+            for i in 2..10 {
+                let v = table1.get(&mut store, i);
+                let e = v.as_ref().unwrap().unwrap_externref();
+                let e_val: Option<&usize> = e.as_ref().unwrap().downcast(&store);
+                assert_eq!(*e_val.unwrap(), 3);
+            }
+        }
+
+        {
+            fill_table_with_ref.call(&mut store, Some(er2), 0, 2)?;
+        }
+
+        {
+            call_set_value.call(&mut store, Some(er3.clone()), 0)?;
+            call_set_value.call(&mut store, Some(er3.clone()), 1)?;
+            call_set_value.call(&mut store, Some(er3.clone()), 2)?;
+            call_set_value.call(&mut store, Some(er3.clone()), 3)?;
+            call_set_value.call(&mut store, Some(er3), 4)?;
+        }
+
+        {
+            copy_into_table2.call(&mut store)?;
+            for i in 1..5 {
+                let v = table2.get(&mut store, i);
+                let e = v.as_ref().unwrap().unwrap_externref();
+                let value: &usize = e.as_ref().unwrap().downcast(&store).unwrap();
+                match i {
+                    0 | 1 => assert_eq!(*value, 5),
+                    4 => assert_eq!(*value, 7),
+                    _ => assert_eq!(*value, 3),
+                }
+            }
+        }
+
+        {
+            for i in 0..table1.size(&store) {
+                table1.set(&mut store, i, Value::ExternRef(None))?;
+            }
+            for i in 0..table2.size(&store) {
+                table2.set(&mut store, i, Value::ExternRef(None))?;
+            }
+        }
+
+        Ok(())
+    }
+
+    #[universal_test]
+    fn extern_ref_table_host_guest() -> Result<()> {
+        let mut store = Store::default();
+        let wat = r#"(module
+    (table $table (export "table") 1 12 externref)
+
+    (func (export "call_set_value") (param $er externref) (param $idx i32)
+          (table.set $table (local.get $idx) (local.get $er)))
+
+    (func (export "call_get_value") (param $idx i32) (result externref)
+          (table.get $table (local.get $idx)))
+
+)"#;
+        let module = Module::new(&store, wat)?;
+        let instance = Instance::new(&mut store, &module, &imports! {})?;
+        let call_set_value: TypedFunction<(Option<ExternRef>, i32), ()> = instance
+            .exports
+            .get_typed_function(&store, "call_set_value")?;
+
+        let call_get_value: TypedFunction<i32, Option<ExternRef>> = instance
+            .exports
+            .get_typed_function(&store, "call_get_value")?;
+
+        let table: &Table = instance.exports.get_table("table")?;
+
+        let er_even = ExternRef::new(&mut store, 4usize);
+        let er_odd = ExternRef::new(&mut store, 9usize);
+
+        for i in 0..table.size(&store) {
+            if i % 2 == 0 {
+                call_set_value.call(&mut store, Some(er_even.clone()), i as i32)?;
+            } else {
+                call_set_value.call(&mut store, Some(er_odd.clone()), i as i32)?;
+            }
+        }
+
+        for i in 0..table.size(&store) {
+            let v = table.get(&mut store, i);
+            let e = v.as_ref().unwrap().unwrap_externref();
+            let value: &usize = e.as_ref().unwrap().downcast(&store).unwrap();
+
+            if i % 2 == 0 {
+                assert_eq!(*value, 4)
+            } else {
+                assert_eq!(*value, 9)
+            }
+        }
+
+        let er_even = ExternRef::new(&mut store, 6usize);
+        let er_odd = ExternRef::new(&mut store, 11usize);
+
+        for i in 0..table.size(&store) {
+            if i % 2 == 0 {
+                table.set(&mut store, i, Value::ExternRef(Some(er_even.clone())))?;
+            } else {
+                table.set(&mut store, i, Value::ExternRef(Some(er_odd.clone())))?;
+            }
+        }
+
+        for i in 0..table.size(&store) {
+            let v = call_get_value.call(&mut store, i as i32)?;
+            let e = v.as_ref().unwrap();
+            let value: &usize = e.downcast(&store).unwrap();
+
+            if i % 2 == 0 {
+                assert_eq!(*value, 6)
+            } else {
+                assert_eq!(*value, 11)
+            }
+        }
+
+        Ok(())
+    }
 }
diff --git a/lib/api/tests/rt.rs b/lib/api/tests/rt.rs
new file mode 100644
index 0000000000..72af57f298
--- /dev/null
+++ b/lib/api/tests/rt.rs
@@ -0,0 +1,74 @@
+#[test]
+#[cfg(all(feature = "sys", feature = "wamr", feature = "v8"))]
+fn can_create_multiple_engines() {
+    use wasmer::{sys::Cranelift, v8::V8, wamr::Wamr, *};
+    let _: Engine = Cranelift::new().into();
+
+    #[cfg(feature = "v8")]
+    {
+        let _: Engine = V8::new().into();
+    }
+
+    #[cfg(feature = "wamr")]
+    {
+        let _: Engine = Wamr::new().into();
+    }
+}
+
+#[test]
+#[cfg(all(feature = "v8", feature = "sys"))]
+fn multiple_engines_can_run_together() {
+    use std::u8;
+    use wasmer::{sys::Cranelift, v8::V8, *};
+
+    let clift: Engine = Cranelift::new().into();
+    let mut clift_store = Store::new(clift);
+    let c_hello = Function::new_typed(&mut clift_store, move || {
+        println!("hello from cranelift!");
+    });
+
+    #[cfg(feature = "v8")]
+    {
+        let v8: Engine = V8::new().into();
+        let mut v8_store = Store::new(v8);
+        let v8_hello = Function::new_typed(&mut v8_store, move || {
+            println!("hello from v8!");
+        });
+        c_hello.call(&mut clift_store, &[]).unwrap();
+        v8_hello.call(&mut v8_store, &[]).unwrap();
+    }
+}
+
+#[test]
+#[cfg(all(feature = "sys", feature = "wamr", feature = "v8"))]
+fn engine_unique_id() {
+    use std::collections::HashSet;
+
+    use wasmer::{sys::Cranelift, v8::V8, wamr::Wamr, *};
+
+    let mut table = HashSet::new();
+
+    for _ in 0..100_000 {
+        let e: Engine = Cranelift::new().into();
+
+        let id = e.id();
+
+        assert!(!table.contains(&id));
+        table.insert(e.id());
+        assert!(table.contains(&id));
+
+        let e: Engine = V8::new().into();
+        let id = e.id();
+
+        assert!(!table.contains(&id));
+        table.insert(e.id());
+        assert!(table.contains(&id));
+
+        let e: Engine = Wamr::new().into();
+        let id = e.id();
+
+        assert!(!table.contains(&id));
+        table.insert(e.id());
+        assert!(table.contains(&id));
+    }
+}
diff --git a/lib/api/tests/typed_functions.rs b/lib/api/tests/typed_functions.rs
new file mode 100644
index 0000000000..12e52d9b28
--- /dev/null
+++ b/lib/api/tests/typed_functions.rs
@@ -0,0 +1,173 @@
+use macro_wasmer_universal_test::universal_test;
+use wasmer::*;
+
+#[cfg(feature = "js")]
+use wasm_bindgen_test::wasm_bindgen_test;
+
+#[universal_test]
+#[cfg_attr(
+    feature = "js",
+    ignore = "Closures with context are not supported in JS yet"
+)]
+fn typed_host_function_closure_panics() -> Result<(), String> {
+    let mut store = Store::default();
+    let state = 3;
+
+    Function::new_typed(&mut store, move |_: i32| {
+        println!("{state}");
+    });
+
+    Ok(())
+}
+
+#[universal_test]
+#[cfg_attr(
+    feature = "js",
+    ignore = "Closures with context are not supported in JS yet"
+)]
+fn typed_with_env_host_function_closure_panics() -> Result<(), String> {
+    let mut store = Store::default();
+    let env: i32 = 4;
+    let env = FunctionEnv::new(&mut store, env);
+    let state = 3;
+    Function::new_typed_with_env(
+        &mut store,
+        &env,
+        move |_env: FunctionEnvMut<i32>, _: i32| {
+            println!("{state}");
+        },
+    );
+
+    Ok(())
+}
+
+#[universal_test]
+#[cfg_attr(
+    feature = "js",
+    ignore = "Closures with context are not supported in JS yet"
+)]
+fn non_typed_functions_and_closures_with_no_env_work() -> anyhow::Result<()> {
+    let mut store = Store::default();
+    let wat = r#"(module
+        (func $multiply1 (import "env" "multiply1") (param i32 i32) (result i32))
+        (func $multiply2 (import "env" "multiply2") (param i32 i32) (result i32))
+        (func $multiply3 (import "env" "multiply3") (param i32 i32) (result i32))
+        (func $multiply4 (import "env" "multiply4") (param i32 i32) (result i32))
+
+        (func (export "test") (param i32 i32 i32 i32 i32) (result i32)
+           (call $multiply4
+             (call $multiply3
+               (call $multiply2
+                  (call $multiply1
+                    (local.get 0)
+                    (local.get 1))
+                  (local.get 2))
+               (local.get 3))
+              (local.get 4)))
+)"#;
+    let module = Module::new(&store, wat).unwrap();
+    let env: i32 = 10;
+    let env = FunctionEnv::new(&mut store, env);
+    let ty = FunctionType::new(vec![Type::I32, Type::I32], vec![Type::I32]);
+    let captured_by_closure = 20;
+    let import_object = imports! {
+        "env" => {
+            "multiply1" => Function::new_with_env(&mut store, &env, &ty, move |_env, args| {
+                if let (Value::I32(v1), Value::I32(v2)) = (&args[0], &args[1]) {
+                    Ok(vec![Value::I32(v1 * v2 * captured_by_closure)])
+                } else {
+                    panic!("Invalid arguments");
+                }
+            }),
+            "multiply2" => Function::new_with_env(&mut store, &env, &ty, move |env, args| {
+                if let (Value::I32(v1), Value::I32(v2)) = (&args[0], &args[1]) {
+                    Ok(vec![Value::I32(v1 * v2 * captured_by_closure * env.data())])
+                } else {
+                    panic!("Invalid arguments");
+                }
+            }),
+            "multiply3" => Function::new_typed_with_env(&mut store, &env, |_env: FunctionEnvMut<_>, arg1: i32, arg2: i32| -> i32
+                                                {arg1 * arg2 }),
+            "multiply4" => Function::new_typed_with_env(&mut store, &env, |env: FunctionEnvMut<i32>, arg1: i32, arg2: i32| -> i32
+                                                         {arg1 * arg2 * env.data() }),
+        },
+    };
+
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    let test: TypedFunction<(i32, i32, i32, i32, i32), i32> =
+        instance.exports.get_typed_function(&mut store, "test")?;
+
+    let result = test.call(&mut store, 2, 3, 4, 5, 6)?;
+    let manually_computed_result = 6 * (5 * (4 * (3 * 2 * 20) * 10 * 20)) * 10;
+    assert_eq!(result, manually_computed_result);
+    Ok(())
+}
+
+static STATIC_CONTEXT_VAL: i32 = 1234;
+
+#[universal_test]
+#[cfg_attr(
+    feature = "js",
+    ignore = "Closures with context are not supported in JS yet"
+)]
+fn holochain_typed_function() -> anyhow::Result<()> {
+    // Declare WASM Module
+    let wasm_bytes = wat2wasm(
+        br#"
+(module
+  (func $multiply_typed 
+      (import "env" "multiply_typed") 
+      (param i32) 
+      (result i32)
+  )
+  (type $sum_t 
+    (func (param i32) (param i32) (result i32))
+  )
+  (func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32)
+    (call $multiply_typed 
+      (local.get $y)
+    )
+  )
+(export "sum" (func $sum_f)))
+"#,
+    )?;
+    let mut store = Store::default();
+    struct MyEnv {}
+    let env = FunctionEnv::new(&mut store, MyEnv {});
+    let module = Module::new(&store, wasm_bytes)?;
+
+    // Define some context data that the host function closure will use
+    static STATIC_CONTEXT_VAL2: i32 = 1234;
+    let context_val = 1234;
+    fn my_val() -> i32 {
+        1234
+    }
+
+    // Define the host function closure
+    let multiply_by_3 = move |_env: FunctionEnvMut<MyEnv>, a: i32| -> i32 {
+        assert_eq!(STATIC_CONTEXT_VAL, 1234);
+        assert_eq!(STATIC_CONTEXT_VAL2, 1234);
+        assert_eq!(context_val, 1234);
+        assert_eq!(my_val(), 1234);
+
+        a * 3
+    };
+
+    // Define the host function and WASM instance
+    let multiply_typed = Function::new_typed_with_env(&mut store, &env, multiply_by_3);
+    let import_object = imports! {
+        "env" => {
+            "multiply_typed" => multiply_typed,
+        }
+    };
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    // Execute the WASM function 'sum'
+    let sum: TypedFunction<(i32, i32), i32> =
+        instance.exports.get_function("sum")?.typed(&mut store)?;
+    let result = sum.call(&mut store, 1, 2)?;
+    assert_eq!(result, 6);
+
+    Ok(())
+}
diff --git a/lib/api/third-party/wee8/wasm.h b/lib/api/third-party/wee8/wasm.h
new file mode 100644
index 0000000000..4f37e8ff89
--- /dev/null
+++ b/lib/api/third-party/wee8/wasm.h
@@ -0,0 +1,754 @@
+// WebAssembly C API
+
+#ifndef WASM_H
+#define WASM_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <assert.h>
+
+#ifndef WASM_API_EXTERN
+#if defined(_WIN32) && !defined(__MINGW32__) && !defined(LIBWASM_STATIC)
+#define WASM_API_EXTERN __declspec(dllimport)
+#else
+#define WASM_API_EXTERN
+#endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// Auxiliaries
+
+// Machine types
+
+inline void assertions(void) {
+  static_assert(sizeof(float) == sizeof(uint32_t), "incompatible float type");
+  static_assert(sizeof(double) == sizeof(uint64_t), "incompatible double type");
+  static_assert(sizeof(intptr_t) == sizeof(uint32_t) ||
+                sizeof(intptr_t) == sizeof(uint64_t),
+                "incompatible pointer type");
+}
+
+typedef char byte_t;
+typedef float float32_t;
+typedef double float64_t;
+
+
+// Ownership
+
+#define own
+
+// The qualifier `own` is used to indicate ownership of data in this API.
+// It is intended to be interpreted similar to a `const` qualifier:
+//
+// - `own wasm_xxx_t*` owns the pointed-to data
+// - `own wasm_xxx_t` distributes to all fields of a struct or union `xxx`
+// - `own wasm_xxx_vec_t` owns the vector as well as its elements(!)
+// - an `own` function parameter passes ownership from caller to callee
+// - an `own` function result passes ownership from callee to caller
+// - an exception are `own` pointer parameters named `out`, which are copy-back
+//   output parameters passing back ownership from callee to caller
+//
+// Own data is created by `wasm_xxx_new` functions and some others.
+// It must be released with the corresponding `wasm_xxx_delete` function.
+//
+// Deleting a reference does not necessarily delete the underlying object,
+// it merely indicates that this owner no longer uses it.
+//
+// For vectors, `const wasm_xxx_vec_t` is used informally to indicate that
+// neither the vector nor its elements should be modified.
+// TODO: introduce proper `wasm_xxx_const_vec_t`?
+
+
+#define WASM_DECLARE_OWN(name) \
+  typedef struct wasm_##name##_t wasm_##name##_t; \
+  \
+  WASM_API_EXTERN void wasm_##name##_delete(own wasm_##name##_t*);
+
+
+// Vectors
+
+#define WASM_DECLARE_VEC(name, ptr_or_none) \
+  typedef struct wasm_##name##_vec_t { \
+    size_t size; \
+    wasm_##name##_t ptr_or_none* data; \
+  } wasm_##name##_vec_t; \
+  \
+  WASM_API_EXTERN void wasm_##name##_vec_new_empty(own wasm_##name##_vec_t* out); \
+  WASM_API_EXTERN void wasm_##name##_vec_new_uninitialized( \
+    own wasm_##name##_vec_t* out, size_t); \
+  WASM_API_EXTERN void wasm_##name##_vec_new( \
+    own wasm_##name##_vec_t* out, \
+    size_t, own wasm_##name##_t ptr_or_none const[]); \
+  WASM_API_EXTERN void wasm_##name##_vec_copy( \
+    own wasm_##name##_vec_t* out, const wasm_##name##_vec_t*); \
+  WASM_API_EXTERN void wasm_##name##_vec_delete(own wasm_##name##_vec_t*);
+
+
+// Byte vectors
+
+typedef byte_t wasm_byte_t;
+WASM_DECLARE_VEC(byte, )
+
+typedef wasm_byte_vec_t wasm_name_t;
+
+#define wasm_name wasm_byte_vec
+#define wasm_name_new wasm_byte_vec_new
+#define wasm_name_new_empty wasm_byte_vec_new_empty
+#define wasm_name_new_new_uninitialized wasm_byte_vec_new_uninitialized
+#define wasm_name_copy wasm_byte_vec_copy
+#define wasm_name_delete wasm_byte_vec_delete
+
+static inline void wasm_name_new_from_string(
+  own wasm_name_t* out, const char* s
+) {
+  wasm_name_new(out, strlen(s), s);
+}
+
+static inline void wasm_name_new_from_string_nt(
+  own wasm_name_t* out, const char* s
+) {
+  wasm_name_new(out, strlen(s) + 1, s);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Runtime Environment
+
+// Configuration
+
+WASM_DECLARE_OWN(config)
+
+WASM_API_EXTERN own wasm_config_t* wasm_config_new(void);
+
+// Embedders may provide custom functions for manipulating configs.
+
+
+// Engine
+
+WASM_DECLARE_OWN(engine)
+
+WASM_API_EXTERN own wasm_engine_t* wasm_engine_new(void);
+WASM_API_EXTERN own wasm_engine_t* wasm_engine_new_with_config(own wasm_config_t*);
+
+
+// Store
+
+WASM_DECLARE_OWN(store)
+
+WASM_API_EXTERN own wasm_store_t* wasm_store_new(wasm_engine_t*);
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Type Representations
+
+// Type attributes
+
+typedef uint8_t wasm_mutability_t;
+enum wasm_mutability_enum {
+  WASM_CONST,
+  WASM_VAR,
+};
+
+typedef struct wasm_limits_t {
+  uint32_t min;
+  uint32_t max;
+  bool shared;
+} wasm_limits_t;
+
+static const uint32_t wasm_limits_max_default = 0xffffffff;
+
+
+// Generic
+
+#define WASM_DECLARE_TYPE(name) \
+  WASM_DECLARE_OWN(name) \
+  WASM_DECLARE_VEC(name, *) \
+  \
+  WASM_API_EXTERN own wasm_##name##_t* wasm_##name##_copy(const wasm_##name##_t*);
+
+
+// Value Types
+
+WASM_DECLARE_TYPE(valtype)
+
+typedef uint8_t wasm_valkind_t;
+enum wasm_valkind_enum {
+  WASM_I32,
+  WASM_I64,
+  WASM_F32,
+  WASM_F64,
+  WASM_EXTERNREF = 128,
+  WASM_FUNCREF,
+};
+
+WASM_API_EXTERN own wasm_valtype_t* wasm_valtype_new(wasm_valkind_t);
+
+WASM_API_EXTERN wasm_valkind_t wasm_valtype_kind(const wasm_valtype_t*);
+
+static inline bool wasm_valkind_is_num(wasm_valkind_t k) {
+  return k < WASM_EXTERNREF;
+}
+static inline bool wasm_valkind_is_ref(wasm_valkind_t k) {
+  return k >= WASM_EXTERNREF;
+}
+
+static inline bool wasm_valtype_is_num(const wasm_valtype_t* t) {
+  return wasm_valkind_is_num(wasm_valtype_kind(t));
+}
+static inline bool wasm_valtype_is_ref(const wasm_valtype_t* t) {
+  return wasm_valkind_is_ref(wasm_valtype_kind(t));
+}
+
+
+// Function Types
+
+WASM_DECLARE_TYPE(functype)
+
+WASM_API_EXTERN own wasm_functype_t* wasm_functype_new(
+  own wasm_valtype_vec_t* params, own wasm_valtype_vec_t* results);
+
+WASM_API_EXTERN const wasm_valtype_vec_t* wasm_functype_params(const wasm_functype_t*);
+WASM_API_EXTERN const wasm_valtype_vec_t* wasm_functype_results(const wasm_functype_t*);
+
+
+// Global Types
+
+WASM_DECLARE_TYPE(globaltype)
+
+WASM_API_EXTERN own wasm_globaltype_t* wasm_globaltype_new(
+  own wasm_valtype_t*, wasm_mutability_t);
+
+WASM_API_EXTERN const wasm_valtype_t* wasm_globaltype_content(const wasm_globaltype_t*);
+WASM_API_EXTERN wasm_mutability_t wasm_globaltype_mutability(const wasm_globaltype_t*);
+
+
+// Tag Types
+
+WASM_DECLARE_TYPE(tagtype)
+
+WASM_API_EXTERN own wasm_tagtype_t* wasm_tagtype_new(own wasm_valtype_vec_t* params);
+
+WASM_API_EXTERN const wasm_valtype_vec_t* wasm_tagtype_params(const wasm_tagtype_t*);
+
+
+// Table Types
+
+WASM_DECLARE_TYPE(tabletype)
+
+WASM_API_EXTERN own wasm_tabletype_t* wasm_tabletype_new(
+  own wasm_valtype_t*, const wasm_limits_t*);
+
+WASM_API_EXTERN const wasm_valtype_t* wasm_tabletype_element(const wasm_tabletype_t*);
+WASM_API_EXTERN const wasm_limits_t* wasm_tabletype_limits(const wasm_tabletype_t*);
+
+
+// Memory Types
+
+WASM_DECLARE_TYPE(memorytype)
+
+WASM_API_EXTERN own wasm_memorytype_t* wasm_memorytype_new(const wasm_limits_t*);
+
+WASM_API_EXTERN const wasm_limits_t* wasm_memorytype_limits(const wasm_memorytype_t*);
+
+
+// Extern Types
+
+WASM_DECLARE_TYPE(externtype)
+
+typedef uint8_t wasm_externkind_t;
+enum wasm_externkind_enum {
+  WASM_EXTERN_FUNC,
+  WASM_EXTERN_GLOBAL,
+  WASM_EXTERN_TABLE,
+  WASM_EXTERN_MEMORY,
+  WASM_EXTERN_TAG,
+};
+
+WASM_API_EXTERN wasm_externkind_t wasm_externtype_kind(const wasm_externtype_t*);
+
+WASM_API_EXTERN wasm_externtype_t* wasm_functype_as_externtype(wasm_functype_t*);
+WASM_API_EXTERN wasm_externtype_t* wasm_globaltype_as_externtype(wasm_globaltype_t*);
+WASM_API_EXTERN wasm_externtype_t* wasm_tagtype_as_externtype(wasm_tagtype_t*);
+WASM_API_EXTERN wasm_externtype_t* wasm_tabletype_as_externtype(wasm_tabletype_t*);
+WASM_API_EXTERN wasm_externtype_t* wasm_memorytype_as_externtype(wasm_memorytype_t*);
+
+WASM_API_EXTERN wasm_functype_t* wasm_externtype_as_functype(wasm_externtype_t*);
+WASM_API_EXTERN wasm_globaltype_t* wasm_externtype_as_globaltype(wasm_externtype_t*);
+WASM_API_EXTERN wasm_tagtype_t* wasm_externtype_as_tagtype(wasm_externtype_t*);
+WASM_API_EXTERN wasm_tabletype_t* wasm_externtype_as_tabletype(wasm_externtype_t*);
+WASM_API_EXTERN wasm_memorytype_t* wasm_externtype_as_memorytype(wasm_externtype_t*);
+
+WASM_API_EXTERN const wasm_externtype_t* wasm_functype_as_externtype_const(const wasm_functype_t*);
+WASM_API_EXTERN const wasm_externtype_t* wasm_globaltype_as_externtype_const(const wasm_globaltype_t*);
+WASM_API_EXTERN const wasm_externtype_t* wasm_tagtype_as_externtype_const(const wasm_tagtype_t*);
+WASM_API_EXTERN const wasm_externtype_t* wasm_tabletype_as_externtype_const(const wasm_tabletype_t*);
+WASM_API_EXTERN const wasm_externtype_t* wasm_memorytype_as_externtype_const(const wasm_memorytype_t*);
+
+WASM_API_EXTERN const wasm_functype_t* wasm_externtype_as_functype_const(const wasm_externtype_t*);
+WASM_API_EXTERN const wasm_globaltype_t* wasm_externtype_as_globaltype_const(const wasm_externtype_t*);
+WASM_API_EXTERN const wasm_tagtype_t* wasm_externtype_as_tagtype_const(const wasm_externtype_t*);
+WASM_API_EXTERN const wasm_tabletype_t* wasm_externtype_as_tabletype_const(const wasm_externtype_t*);
+WASM_API_EXTERN const wasm_memorytype_t* wasm_externtype_as_memorytype_const(const wasm_externtype_t*);
+
+
+// Import Types
+
+WASM_DECLARE_TYPE(importtype)
+
+WASM_API_EXTERN own wasm_importtype_t* wasm_importtype_new(
+  own wasm_name_t* module, own wasm_name_t* name, own wasm_externtype_t*);
+
+WASM_API_EXTERN const wasm_name_t* wasm_importtype_module(const wasm_importtype_t*);
+WASM_API_EXTERN const wasm_name_t* wasm_importtype_name(const wasm_importtype_t*);
+WASM_API_EXTERN const wasm_externtype_t* wasm_importtype_type(const wasm_importtype_t*);
+
+
+// Export Types
+
+WASM_DECLARE_TYPE(exporttype)
+
+WASM_API_EXTERN own wasm_exporttype_t* wasm_exporttype_new(
+  own wasm_name_t*, own wasm_externtype_t*);
+
+WASM_API_EXTERN const wasm_name_t* wasm_exporttype_name(const wasm_exporttype_t*);
+WASM_API_EXTERN const wasm_externtype_t* wasm_exporttype_type(const wasm_exporttype_t*);
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Runtime Objects
+
+// Values
+
+struct wasm_ref_t;
+
+typedef struct wasm_val_t {
+  wasm_valkind_t kind;
+  union {
+    int32_t i32;
+    int64_t i64;
+    float32_t f32;
+    float64_t f64;
+    struct wasm_ref_t* ref;
+  } of;
+} wasm_val_t;
+
+WASM_API_EXTERN void wasm_val_delete(own wasm_val_t* v);
+WASM_API_EXTERN void wasm_val_copy(own wasm_val_t* out, const wasm_val_t*);
+
+WASM_DECLARE_VEC(val, )
+
+
+// References
+
+#define WASM_DECLARE_REF_BASE(name) \
+  WASM_DECLARE_OWN(name) \
+  \
+  WASM_API_EXTERN own wasm_##name##_t* wasm_##name##_copy(const wasm_##name##_t*); \
+  WASM_API_EXTERN bool wasm_##name##_same(const wasm_##name##_t*, const wasm_##name##_t*); \
+  \
+  WASM_API_EXTERN void* wasm_##name##_get_host_info(const wasm_##name##_t*); \
+  WASM_API_EXTERN void wasm_##name##_set_host_info(wasm_##name##_t*, void*); \
+  WASM_API_EXTERN void wasm_##name##_set_host_info_with_finalizer( \
+    wasm_##name##_t*, void*, void (*)(void*));
+
+#define WASM_DECLARE_REF(name) \
+  WASM_DECLARE_REF_BASE(name) \
+  \
+  WASM_API_EXTERN wasm_ref_t* wasm_##name##_as_ref(wasm_##name##_t*); \
+  WASM_API_EXTERN wasm_##name##_t* wasm_ref_as_##name(wasm_ref_t*); \
+  WASM_API_EXTERN const wasm_ref_t* wasm_##name##_as_ref_const(const wasm_##name##_t*); \
+  WASM_API_EXTERN const wasm_##name##_t* wasm_ref_as_##name##_const(const wasm_ref_t*);
+
+#define WASM_DECLARE_SHARABLE_REF(name) \
+  WASM_DECLARE_REF(name) \
+  WASM_DECLARE_OWN(shared_##name) \
+  \
+  WASM_API_EXTERN own wasm_shared_##name##_t* wasm_##name##_share(const wasm_##name##_t*); \
+  WASM_API_EXTERN own wasm_##name##_t* wasm_##name##_obtain(wasm_store_t*, const wasm_shared_##name##_t*);
+
+
+WASM_DECLARE_REF_BASE(ref)
+
+
+// Frames
+
+WASM_DECLARE_OWN(frame)
+WASM_DECLARE_VEC(frame, *)
+WASM_API_EXTERN own wasm_frame_t* wasm_frame_copy(const wasm_frame_t*);
+
+WASM_API_EXTERN struct wasm_instance_t* wasm_frame_instance(const wasm_frame_t*);
+WASM_API_EXTERN uint32_t wasm_frame_func_index(const wasm_frame_t*);
+WASM_API_EXTERN size_t wasm_frame_func_offset(const wasm_frame_t*);
+WASM_API_EXTERN size_t wasm_frame_module_offset(const wasm_frame_t*);
+
+
+// Traps
+
+typedef wasm_name_t wasm_message_t;  // null terminated
+
+WASM_DECLARE_REF(trap)
+
+WASM_API_EXTERN own wasm_trap_t* wasm_trap_new(wasm_store_t* store, const wasm_message_t*);
+
+WASM_API_EXTERN void wasm_trap_message(const wasm_trap_t*, own wasm_message_t* out);
+WASM_API_EXTERN own wasm_frame_t* wasm_trap_origin(const wasm_trap_t*);
+WASM_API_EXTERN void wasm_trap_trace(const wasm_trap_t*, own wasm_frame_vec_t* out);
+
+
+// Foreign Objects
+
+WASM_DECLARE_REF(foreign)
+
+WASM_API_EXTERN own wasm_foreign_t* wasm_foreign_new(wasm_store_t*);
+
+
+// Modules
+
+WASM_DECLARE_SHARABLE_REF(module)
+
+WASM_API_EXTERN own wasm_module_t* wasm_module_new(
+  wasm_store_t*, const wasm_byte_vec_t* binary);
+
+WASM_API_EXTERN bool wasm_module_validate(wasm_store_t*, const wasm_byte_vec_t* binary);
+
+WASM_API_EXTERN void wasm_module_imports(const wasm_module_t*, own wasm_importtype_vec_t* out);
+WASM_API_EXTERN void wasm_module_exports(const wasm_module_t*, own wasm_exporttype_vec_t* out);
+
+WASM_API_EXTERN void wasm_module_serialize(const wasm_module_t*, own wasm_byte_vec_t* out);
+WASM_API_EXTERN own wasm_module_t* wasm_module_deserialize(wasm_store_t*, const wasm_byte_vec_t*);
+
+
+// Function Instances
+
+WASM_DECLARE_REF(func)
+
+typedef own wasm_trap_t* (*wasm_func_callback_t)(
+  const wasm_val_vec_t* args, own wasm_val_vec_t* results);
+typedef own wasm_trap_t* (*wasm_func_callback_with_env_t)(
+  void* env, const wasm_val_vec_t* args, wasm_val_vec_t* results);
+
+WASM_API_EXTERN own wasm_func_t* wasm_func_new(
+  wasm_store_t*, const wasm_functype_t*, wasm_func_callback_t);
+WASM_API_EXTERN own wasm_func_t* wasm_func_new_with_env(
+  wasm_store_t*, const wasm_functype_t* type, wasm_func_callback_with_env_t,
+  void* env, void (*finalizer)(void*));
+
+WASM_API_EXTERN own wasm_functype_t* wasm_func_type(const wasm_func_t*);
+WASM_API_EXTERN size_t wasm_func_param_arity(const wasm_func_t*);
+WASM_API_EXTERN size_t wasm_func_result_arity(const wasm_func_t*);
+
+WASM_API_EXTERN own wasm_trap_t* wasm_func_call(
+  const wasm_func_t*, const wasm_val_vec_t* args, wasm_val_vec_t* results);
+
+
+// Global Instances
+
+WASM_DECLARE_REF(global)
+
+WASM_API_EXTERN own wasm_global_t* wasm_global_new(
+  wasm_store_t*, const wasm_globaltype_t*, const wasm_val_t*);
+
+WASM_API_EXTERN own wasm_globaltype_t* wasm_global_type(const wasm_global_t*);
+
+WASM_API_EXTERN void wasm_global_get(const wasm_global_t*, own wasm_val_t* out);
+WASM_API_EXTERN void wasm_global_set(wasm_global_t*, const wasm_val_t*);
+
+
+// Tag Instances
+
+WASM_DECLARE_REF(tag)
+
+WASM_API_EXTERN own wasm_tag_t* wasm_tag_new(wasm_store_t*, const wasm_tagtype_t*);
+
+WASM_API_EXTERN own wasm_tagtype_t* wasm_tag_type(const wasm_tag_t*);
+
+WASM_API_EXTERN void wasm_tag_get(const wasm_tag_t*, own wasm_val_t* out);
+WASM_API_EXTERN void wasm_tag_set(wasm_tag_t*, const wasm_val_t*);
+
+
+// Table Instances
+
+WASM_DECLARE_REF(table)
+
+typedef uint32_t wasm_table_size_t;
+
+WASM_API_EXTERN own wasm_table_t* wasm_table_new(
+  wasm_store_t*, const wasm_tabletype_t*, wasm_ref_t* init);
+
+WASM_API_EXTERN own wasm_tabletype_t* wasm_table_type(const wasm_table_t*);
+
+WASM_API_EXTERN own wasm_ref_t* wasm_table_get(const wasm_table_t*, wasm_table_size_t index);
+WASM_API_EXTERN bool wasm_table_set(wasm_table_t*, wasm_table_size_t index, wasm_ref_t*);
+
+WASM_API_EXTERN wasm_table_size_t wasm_table_size(const wasm_table_t*);
+WASM_API_EXTERN bool wasm_table_grow(wasm_table_t*, wasm_table_size_t delta, wasm_ref_t* init);
+
+
+// Memory Instances
+
+WASM_DECLARE_REF(memory)
+
+typedef uint32_t wasm_memory_pages_t;
+
+static const size_t MEMORY_PAGE_SIZE = 0x10000;
+
+WASM_API_EXTERN own wasm_memory_t* wasm_memory_new(wasm_store_t*, const wasm_memorytype_t*);
+
+WASM_API_EXTERN own wasm_memorytype_t* wasm_memory_type(const wasm_memory_t*);
+
+WASM_API_EXTERN byte_t* wasm_memory_data(wasm_memory_t*);
+WASM_API_EXTERN size_t wasm_memory_data_size(const wasm_memory_t*);
+
+WASM_API_EXTERN wasm_memory_pages_t wasm_memory_size(const wasm_memory_t*);
+WASM_API_EXTERN bool wasm_memory_grow(wasm_memory_t*, wasm_memory_pages_t delta);
+
+
+// Externals
+
+WASM_DECLARE_REF(extern)
+WASM_DECLARE_VEC(extern, *)
+
+WASM_API_EXTERN wasm_externkind_t wasm_extern_kind(const wasm_extern_t*);
+WASM_API_EXTERN own wasm_externtype_t* wasm_extern_type(const wasm_extern_t*);
+
+WASM_API_EXTERN wasm_extern_t* wasm_func_as_extern(wasm_func_t*);
+WASM_API_EXTERN wasm_extern_t* wasm_global_as_extern(wasm_global_t*);
+WASM_API_EXTERN wasm_extern_t* wasm_tag_as_extern(wasm_tag_t*);
+WASM_API_EXTERN wasm_extern_t* wasm_table_as_extern(wasm_table_t*);
+WASM_API_EXTERN wasm_extern_t* wasm_memory_as_extern(wasm_memory_t*);
+
+WASM_API_EXTERN wasm_func_t* wasm_extern_as_func(wasm_extern_t*);
+WASM_API_EXTERN wasm_global_t* wasm_extern_as_global(wasm_extern_t*);
+WASM_API_EXTERN wasm_tag_t* wasm_extern_as_tag(wasm_extern_t*);
+WASM_API_EXTERN wasm_table_t* wasm_extern_as_table(wasm_extern_t*);
+WASM_API_EXTERN wasm_memory_t* wasm_extern_as_memory(wasm_extern_t*);
+
+WASM_API_EXTERN const wasm_extern_t* wasm_func_as_extern_const(const wasm_func_t*);
+WASM_API_EXTERN const wasm_extern_t* wasm_global_as_extern_const(const wasm_global_t*);
+WASM_API_EXTERN const wasm_extern_t* wasm_tag_as_extern_const(const wasm_tag_t*);
+WASM_API_EXTERN const wasm_extern_t* wasm_table_as_extern_const(const wasm_table_t*);
+WASM_API_EXTERN const wasm_extern_t* wasm_memory_as_extern_const(const wasm_memory_t*);
+
+WASM_API_EXTERN const wasm_func_t* wasm_extern_as_func_const(const wasm_extern_t*);
+WASM_API_EXTERN const wasm_global_t* wasm_extern_as_global_const(const wasm_extern_t*);
+WASM_API_EXTERN const wasm_tag_t* wasm_extern_as_tag_const(const wasm_extern_t*);
+WASM_API_EXTERN const wasm_table_t* wasm_extern_as_table_const(const wasm_extern_t*);
+WASM_API_EXTERN const wasm_memory_t* wasm_extern_as_memory_const(const wasm_extern_t*);
+
+
+// Module Instances
+
+WASM_DECLARE_REF(instance)
+
+WASM_API_EXTERN own wasm_instance_t* wasm_instance_new(
+  wasm_store_t*, const wasm_module_t*, const wasm_extern_vec_t* imports,
+  own wasm_trap_t**
+);
+
+WASM_API_EXTERN void wasm_instance_exports(const wasm_instance_t*, own wasm_extern_vec_t* out);
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Convenience
+
+// Vectors
+
+#define WASM_EMPTY_VEC {0, NULL}
+#define WASM_ARRAY_VEC(array) {sizeof(array)/sizeof(*(array)), array}
+
+
+// Value Type construction short-hands
+
+static inline own wasm_valtype_t* wasm_valtype_new_i32(void) {
+  return wasm_valtype_new(WASM_I32);
+}
+static inline own wasm_valtype_t* wasm_valtype_new_i64(void) {
+  return wasm_valtype_new(WASM_I64);
+}
+static inline own wasm_valtype_t* wasm_valtype_new_f32(void) {
+  return wasm_valtype_new(WASM_F32);
+}
+static inline own wasm_valtype_t* wasm_valtype_new_f64(void) {
+  return wasm_valtype_new(WASM_F64);
+}
+
+static inline own wasm_valtype_t* wasm_valtype_new_externref(void) {
+  return wasm_valtype_new(WASM_EXTERNREF);
+}
+static inline own wasm_valtype_t* wasm_valtype_new_funcref(void) {
+  return wasm_valtype_new(WASM_FUNCREF);
+}
+
+
+// Function Types construction short-hands
+
+static inline own wasm_functype_t* wasm_functype_new_0_0(void) {
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new_empty(&params);
+  wasm_valtype_vec_new_empty(&results);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_1_0(
+  own wasm_valtype_t* p
+) {
+  wasm_valtype_t* ps[1] = {p};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 1, ps);
+  wasm_valtype_vec_new_empty(&results);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_2_0(
+  own wasm_valtype_t* p1, own wasm_valtype_t* p2
+) {
+  wasm_valtype_t* ps[2] = {p1, p2};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 2, ps);
+  wasm_valtype_vec_new_empty(&results);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_3_0(
+  own wasm_valtype_t* p1, own wasm_valtype_t* p2, own wasm_valtype_t* p3
+) {
+  wasm_valtype_t* ps[3] = {p1, p2, p3};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 3, ps);
+  wasm_valtype_vec_new_empty(&results);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_0_1(
+  own wasm_valtype_t* r
+) {
+  wasm_valtype_t* rs[1] = {r};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new_empty(&params);
+  wasm_valtype_vec_new(&results, 1, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_1_1(
+  own wasm_valtype_t* p, own wasm_valtype_t* r
+) {
+  wasm_valtype_t* ps[1] = {p};
+  wasm_valtype_t* rs[1] = {r};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 1, ps);
+  wasm_valtype_vec_new(&results, 1, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_2_1(
+  own wasm_valtype_t* p1, own wasm_valtype_t* p2, own wasm_valtype_t* r
+) {
+  wasm_valtype_t* ps[2] = {p1, p2};
+  wasm_valtype_t* rs[1] = {r};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 2, ps);
+  wasm_valtype_vec_new(&results, 1, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_3_1(
+  own wasm_valtype_t* p1, own wasm_valtype_t* p2, own wasm_valtype_t* p3,
+  own wasm_valtype_t* r
+) {
+  wasm_valtype_t* ps[3] = {p1, p2, p3};
+  wasm_valtype_t* rs[1] = {r};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 3, ps);
+  wasm_valtype_vec_new(&results, 1, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_0_2(
+  own wasm_valtype_t* r1, own wasm_valtype_t* r2
+) {
+  wasm_valtype_t* rs[2] = {r1, r2};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new_empty(&params);
+  wasm_valtype_vec_new(&results, 2, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_1_2(
+  own wasm_valtype_t* p, own wasm_valtype_t* r1, own wasm_valtype_t* r2
+) {
+  wasm_valtype_t* ps[1] = {p};
+  wasm_valtype_t* rs[2] = {r1, r2};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 1, ps);
+  wasm_valtype_vec_new(&results, 2, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_2_2(
+  own wasm_valtype_t* p1, own wasm_valtype_t* p2,
+  own wasm_valtype_t* r1, own wasm_valtype_t* r2
+) {
+  wasm_valtype_t* ps[2] = {p1, p2};
+  wasm_valtype_t* rs[2] = {r1, r2};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 2, ps);
+  wasm_valtype_vec_new(&results, 2, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_3_2(
+  own wasm_valtype_t* p1, own wasm_valtype_t* p2, own wasm_valtype_t* p3,
+  own wasm_valtype_t* r1, own wasm_valtype_t* r2
+) {
+  wasm_valtype_t* ps[3] = {p1, p2, p3};
+  wasm_valtype_t* rs[2] = {r1, r2};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 3, ps);
+  wasm_valtype_vec_new(&results, 2, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+
+// Value construction short-hands
+
+static inline void wasm_val_init_ptr(own wasm_val_t* out, void* p) {
+#if UINTPTR_MAX == UINT32_MAX
+  out->kind = WASM_I32;
+  out->of.i32 = (intptr_t)p;
+#elif UINTPTR_MAX == UINT64_MAX
+  out->kind = WASM_I64;
+  out->of.i64 = (intptr_t)p;
+#endif
+}
+
+static inline void* wasm_val_ptr(const wasm_val_t* val) {
+#if UINTPTR_MAX == UINT32_MAX
+  return (void*)(intptr_t)val->of.i32;
+#elif UINTPTR_MAX == UINT64_MAX
+  return (void*)(intptr_t)val->of.i64;
+#endif
+}
+
+#define WASM_I32_VAL(i) {.kind = WASM_I32, .of = {.i32 = i}}
+#define WASM_I64_VAL(i) {.kind = WASM_I64, .of = {.i64 = i}}
+#define WASM_F32_VAL(z) {.kind = WASM_F32, .of = {.f32 = z}}
+#define WASM_F64_VAL(z) {.kind = WASM_F64, .of = {.f64 = z}}
+#define WASM_REF_VAL(r) {.kind = WASM_EXTERNREF, .of = {.ref = r}}
+#define WASM_INIT_VAL {.kind = WASM_EXTERNREF, .of = {.ref = NULL}}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+#undef own
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // #ifdef WASM_H
diff --git a/lib/backend-api/Cargo.toml b/lib/backend-api/Cargo.toml
index 2adc6a88bc..93fe18e216 100644
--- a/lib/backend-api/Cargo.toml
+++ b/lib/backend-api/Cargo.toml
@@ -1,9 +1,9 @@
 [package]
-name = "wasmer-api"
-version = "0.0.34"
+name = "wasmer-backend-api"
+version = "0.601.0"
 description = "Client library for the Wasmer GraphQL API"
 readme = "README.md"
-documentation = "https://docs.rs/wasmer-api"
+documentation = "https://docs.rs/wasmer-backend-api"
 
 authors.workspace = true
 edition.workspace = true
@@ -15,31 +15,54 @@ rust-version.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]
 # Wasmer dependencies.
-edge-schema.workspace = true
-wasmer-config = { version = "0.8.0", path = "../config" }
+wasmer-config = { version = "0.601.0", path = "../config" }
+wasmer-package.workspace = true
 webc.workspace = true
 
 # crates.io dependencies.
-anyhow = "1"
-serde = { version = "1", features = ["derive"] }
-time = { version = "0.3", features = ["formatting", "parsing"] }
-tokio = { version = "1.23.0" }
-serde_json = "1"
-url = { version = "2", features = ["serde"] }
+reqwest = { workspace = true, default-features = false, features = ["json"] }
+
+anyhow.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+serde_path_to_error = "0.1.14"
+time = { workspace = true, features = ["formatting", "parsing"] }
+tokio.workspace = true
+url = { workspace = true, features = ["serde"] }
 futures = "0.3"
-tracing = "0.1"
+tracing.workspace = true
 cynic = { version = "3.7.2", features = ["http-reqwest"] }
 pin-project-lite = "0.2.10"
-serde_path_to_error = "0.1.14"
 harsh = "0.2.2"
-reqwest = { workspace = true, default-features = false, features = ["json"] }
 merge-streams = "0.1.2"
 
+
+# Subscriptions. 
+graphql-ws-client = { version = "0.11.0", features = [
+	"tungstenite",
+	"client-cynic",
+], optional = true }
+tokio-tungstenite = { workspace = true, features = [
+	"rustls-tls-native-roots",
+], optional = true }
+async-tungstenite = { version = "0.28.0", features = [
+	"tokio-runtime",
+	"tokio-rustls-native-certs",
+], optional = true }
+
 [target.'cfg(target_family = "wasm")'.dependencies.getrandom]
-version = "0.2.14"
+workspace = true
 features = ["js"]
 
 [dev-dependencies]
-base64 = "0.13.1"
-tokio = { version = "1.3", features = ["macros", "rt"] }
+tokio = { workspace = true, features = ["macros", "rt"] }
+base64.workspace = true
 uuid = { version = "1", features = ["v4"] }
+
+[features]
+
+default = ["sys"]
+
+sys = ["graphql-ws-client", "tokio-tungstenite", "async-tungstenite"]
+
+js = []
diff --git a/lib/backend-api/README.md b/lib/backend-api/README.md
index f1583b1ae2..1d241bc0ff 100644
--- a/lib/backend-api/README.md
+++ b/lib/backend-api/README.md
@@ -1,4 +1,4 @@
-# wasmer-api
+# wasmer-backend-api
 
 GraphQL API client for the [Wasmer](https://wasmer.io) backend.
 
diff --git a/lib/backend-api/schema.graphql b/lib/backend-api/schema.graphql
index e90fbafb14..2fd6fbec6f 100644
--- a/lib/backend-api/schema.graphql
+++ b/lib/backend-api/schema.graphql
@@ -30,6 +30,7 @@ type User implements Node & PackageOwner & Owner {
   lastName: String!
   email: String!
   dateJoined: DateTime!
+  probationStartedAt: DateTime
 
   """Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only."""
   username: String!
@@ -46,6 +47,7 @@ type User implements Node & PackageOwner & Owner {
   globalId: ID!
   viewerCan(action: OwnerAction!): Boolean!
   avatar(size: Int = 80): String!
+  limitState: LimitState!
   isViewer: Boolean!
   hasUsablePassword: Boolean
   fullName: String!
@@ -59,19 +61,38 @@ type User implements Node & PackageOwner & Owner {
   namespaces(role: GrapheneRole, offset: Int, before: String, after: String, first: Int, last: Int): NamespaceConnection!
   packages(collaborating: Boolean = false, offset: Int, before: String, after: String, first: Int, last: Int): PackageConnection!
   apps(collaborating: Boolean = false, sortBy: DeployAppsSortBy, offset: Int, before: String, after: String, first: Int, last: Int): DeployAppConnection!
-  usageMetrics(forRange: MetricRange!, variant: MetricType!): [UsageMetric]!
+  usageMetrics(
+    variant: MetricType!
+    grouping: MetricGrouping
+
+    """List of app IDs. Metrics gets filtered for the specific apps."""
+    appIds: [ID]
+
+    """Optional time range filter."""
+    timeRange: TimeRangeInput
+  ): [UsageMetric]!
   domains(offset: Int, before: String, after: String, first: Int, last: Int): DNSDomainConnection!
   isStaff: Boolean
   packageVersions(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionConnection!
   packageTransfersIncoming(offset: Int, before: String, after: String, first: Int, last: Int): PackageTransferRequestConnection!
   packageInvitesIncoming(offset: Int, before: String, after: String, first: Int, last: Int): PackageCollaboratorInviteConnection!
   namespaceInvitesIncoming(offset: Int, before: String, after: String, first: Int, last: Int): NamespaceCollaboratorInviteConnection!
-  apiTokens(before: String, after: String, first: Int, last: Int): APITokenConnection!
-  notifications(before: String, after: String, first: Int, last: Int): UserNotificationConnection!
+  apiTokens(offset: Int, before: String, after: String, first: Int, last: Int): APITokenConnection!
+  notifications(offset: Int, before: String, after: String, first: Int, last: Int): UserNotificationConnection!
   dashboardActivity(offset: Int, before: String, after: String, first: Int, last: Int): ActivityEventConnection!
   loginMethods: [LoginMethod!]!
   githubUser: SocialAuth
   githubScopes: [String]!
+  githubRepositories: [GithubRepository]!
+  isPro: Boolean!
+  currentUsage(
+    """List of app IDs. Usage gets filtered for the specific apps."""
+    appIds: [ID]
+
+    """Optional time range filter."""
+    timeRange: TimeRangeInput
+  ): OwnerUsageSummary
+  webhooks: [Webhook]
 }
 
 """Setup for backwards compatibility with existing frontends."""
@@ -100,6 +121,14 @@ value as specified by
 """
 scalar DateTime
 
+"""An enumeration."""
+enum LimitState {
+  not_limited
+  nearing_limits
+  under_probation
+  limit_exceeded
+}
+
 type ActivityEventConnection {
   """Pagination data for this connection."""
   pageInfo: PageInfo!
@@ -199,6 +228,7 @@ type NamespaceEdge {
 type Namespace implements Node & PackageOwner & Owner {
   """The ID of the object"""
   id: ID!
+  probationStartedAt: DateTime
   name: String!
   displayName: String
   description: String!
@@ -214,12 +244,13 @@ type Namespace implements Node & PackageOwner & Owner {
   globalName: String!
   globalId: ID!
   viewerCan(action: OwnerAction!): Boolean!
+  limitState: LimitState!
   avatar: String!
   packages(offset: Int, before: String, after: String, first: Int, last: Int): PackageConnection!
   apps(sortBy: DeployAppsSortBy, offset: Int, before: String, after: String, first: Int, last: Int): DeployAppConnection!
   packageVersions(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionConnection!
   collaborators(offset: Int, before: String, after: String, first: Int, last: Int): NamespaceCollaboratorConnection!
-  publicActivity(before: String, after: String, first: Int, last: Int): ActivityEventConnection!
+  publicActivity(offset: Int, before: String, after: String, first: Int, last: Int): ActivityEventConnection!
   pendingInvites(offset: Int, before: String, after: String, first: Int, last: Int): NamespaceCollaboratorInviteConnection!
   viewerHasRole(role: GrapheneRole!): Boolean!
   viewerAsCollaborator(role: GrapheneRole): NamespaceCollaborator
@@ -230,8 +261,26 @@ type Namespace implements Node & PackageOwner & Owner {
   """The invitation for the current user to the namespace"""
   viewerInvitation: NamespaceCollaboratorInvite
   packageTransfersIncoming(offset: Int, before: String, after: String, first: Int, last: Int): PackageTransferRequestConnection!
-  usageMetrics(forRange: MetricRange!, variant: MetricType!): [UsageMetric]!
+  usageMetrics(
+    variant: MetricType!
+    grouping: MetricGrouping
+
+    """List of app IDs. Metrics gets filtered for the specific apps."""
+    appIds: [ID]
+
+    """Optional time range filter."""
+    timeRange: TimeRangeInput
+  ): [UsageMetric]!
   domains(offset: Int, before: String, after: String, first: Int, last: Int): DNSDomainConnection!
+  isPro: Boolean!
+  billing: Billing
+  currentUsage(
+    """List of app IDs. Usage gets filtered for the specific apps."""
+    appIds: [ID]
+
+    """Optional time range filter."""
+    timeRange: TimeRangeInput
+  ): OwnerUsageSummary
 }
 
 type NamespaceCollaboratorInviteConnection {
@@ -272,6 +321,7 @@ type NamespaceCollaboratorInvite implements Node {
   closedAt: DateTime
 }
 
+"""An enumeration."""
 enum RegistryNamespaceMaintainerInviteRoleChoices {
   """Owner"""
   OWNER
@@ -297,6 +347,7 @@ type NamespaceCollaborator implements Node {
   invite: NamespaceCollaboratorInvite
 }
 
+"""An enumeration."""
 enum RegistryNamespaceMaintainerRoleChoices {
   """Owner"""
   OWNER
@@ -371,12 +422,12 @@ type Package implements Likeable & Node & PackageOwner {
   likersCount: Int!
   watchersCount: Int!
   webcs(offset: Int, before: String, after: String, first: Int, last: Int): WebcImageConnection!
-
-  """List of app templates for this package"""
-  appTemplates(offset: Int, before: String, after: String, first: Int, last: Int): AppTemplateConnection!
   packagewebcSet(offset: Int, before: String, after: String, first: Int, last: Int): PackageWebcConnection!
   versions: [PackageVersion]
   collectionSet: [Collection!]!
+
+  """List of app templates for this package"""
+  appTemplates(offset: Int, before: String, after: String, first: Int, last: Int): AppTemplateConnection!
   categories(offset: Int, before: String, after: String, first: Int, last: Int): CategoryConnection!
   keywords(offset: Int, before: String, after: String, first: Int, last: Int): PackageKeywordConnection!
   viewerHasLiked: Boolean!
@@ -479,8 +530,8 @@ type PackageVersion implements Node & PackageReleaseInterface & PackageInstance
   isSigned: Boolean!
   moduleInterfaces: [InterfaceVersion!]!
   modules: [PackageVersionModule!]!
-  getPiritaContents(volume: String! = "atom", base: String! = ""): [PiritaFilesystemItem!]!
-  getWebcContents(volume: String! = "atom", base: String! = "/"): [WEBCFilesystemItem!]!
+  getPiritaContents(volume: String! = "atom", base: String! = ""): [PiritaFilesystemItem!]! @deprecated(reason: "File exploration is of the webc is not supported anymore, please get the files directly fromt he webc")
+  getWebcContents(volume: String! = "atom", base: String! = "/"): [WEBCFilesystemItem!]! @deprecated(reason: "File exploration is of the webc is not supported anymore, please get the files directly fromt he webc")
   nativeExecutables(triple: String, wasmerCompilerVersion: String): [NativeExecutable]
   bindings: [PackageVersionLanguageBinding]!
   npmBindings: PackageVersionNPMBinding
@@ -525,13 +576,13 @@ type WebcImage implements Node {
   """"""
   fileSize: BigInt!
   manifest: JSONString!
-  volumes: JSONString!
-  offsets: JSONString!
   webcSha256: String!
   targzSha256: String
   createdAt: DateTime!
   updatedAt: DateTime!
   webcUrl: String!
+  volumes: JSONString! @deprecated(reason: "Deprecated, use the webc_url to explore the webc file")
+  offsets: JSONString! @deprecated(reason: "Deprecated, use the webc_url to explore the webc file")
 }
 
 enum WebcVersion {
@@ -566,6 +617,7 @@ type PackageVersionEdge {
   cursor: String!
 }
 
+"""An enumeration."""
 enum RegistryPackageVersionBindingsStateChoices {
   """Bindings are not detected"""
   NOT_PRESENT
@@ -580,6 +632,7 @@ enum RegistryPackageVersionBindingsStateChoices {
   GENERATED_AND_PRESENT
 }
 
+"""An enumeration."""
 enum RegistryPackageVersionNativeExecutablesStateChoices {
   """Native Executables are not detected"""
   NOT_PRESENT
@@ -635,7 +688,7 @@ type PackageWebc implements Node & PackageReleaseInterface & PackageInstance {
 type Command {
   command: String!
   packageVersion: PackageVersion!
-  module: PackageVersionModule!
+  module: PackageVersionModule
 }
 
 type PackageVersionModule {
@@ -880,7 +933,9 @@ type DeployAppVersion implements Node {
   description: String
   publishedBy: User!
   disabledAt: DateTime
+  disabledBy: User
   disabledReason: String
+  disabledPermanently: Boolean!
   createdAt: DateTime!
   updatedAt: DateTime!
   configWebc: String @deprecated(reason: "webc support has been deprecated for apps")
@@ -917,24 +972,35 @@ type DeployAppVersion implements Node {
     first: Int
     last: Int
   ): LogConnection!
-  usageMetrics(forRange: MetricRange!, variant: MetricType!): [UsageMetric]!
+  usageMetrics(
+    variant: MetricType!
+    grouping: MetricGrouping
+
+    """Optional time range filter."""
+    timeRange: TimeRangeInput
+  ): [UsageMetric]!
   sourcePackageVersion: PackageVersion
   sourcePackageRelease: PackageWebc
   sourcePackage: Package!
   aggregateMetrics: AggregateMetrics!
   volumes: [AppVersionVolume]
+  gitSource: AutobuildRepository
   favicon: URL
   screenshot(viewportSize: AppScreenshotViewportSize, appearance: AppScreenshotAppearance): URL
+  isUploaded: Boolean!
 }
 
 type DeployApp implements Node & Owner {
   """The ID of the object"""
   id: ID!
+  state: String!
   forceHttps: Boolean!
   createdBy: User!
   createdAt: DateTime!
   updatedAt: DateTime!
-  activeVersion: DeployAppVersion!
+  activeVersion: DeployAppVersion
+  managed: Boolean!
+  willPerishAt: DateTime
   globalName: String!
   globalId: ID!
   viewerCan(action: OwnerAction!): Boolean!
@@ -948,15 +1014,29 @@ type DeployApp implements Node & Owner {
   versions(sortBy: DeployAppVersionsSortBy, createdAfter: DateTime, offset: Int, before: String, after: String, first: Int, last: Int): DeployAppVersionConnection!
   aggregateMetrics: AggregateMetrics!
   aliases(offset: Int, before: String, after: String, first: Int, last: Int): AppAliasConnection!
+  domains(sortBy: AppAliasSortBy! = NEWEST, offset: Int, before: String, after: String, first: Int, last: Int): AppAliasConnection!
   secrets(offset: Int, before: String, after: String, first: Int, last: Int): SecretConnection!
-  usageMetrics(forRange: MetricRange!, variant: MetricType!): [UsageMetric]!
+  databases(offset: Int, before: String, after: String, first: Int, last: Int): AppDatabaseConnection!
+  usageMetrics(
+    variant: MetricType!
+    grouping: MetricGrouping
+
+    """Optional time range filter."""
+    timeRange: TimeRangeInput
+  ): [UsageMetric]!
   s3Url: URL
   s3Credentials: S3Credentials
   deleted: Boolean!
   favicon: URL
   screenshot(viewportSize: AppScreenshotViewportSize, appearance: AppScreenshotAppearance): URL
+  deployments(before: String, after: String, first: Int, last: Int): DeploymentConnection
+  buildConfiguration: BuildConfiguration
+  sshServer: AppSshServer
+  mails: [AppMail]
+  kind: Kind
 }
 
+"""An enumeration."""
 enum DeployAppVersionsSortBy {
   NEWEST
   OLDEST
@@ -993,18 +1073,36 @@ type AppAliasEdge {
 }
 
 type AppAlias implements Node {
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  lastCheckedAt: DateTime
+  firstCheckedAt: DateTime
   name: String!
   app: DeployApp!
   isDefault: Boolean!
   hostname: String!
   text: String!
   kind: DeployAppAliasKindChoices!
+  redirectsTo: AppAlias
 
   """The ID of the object"""
   id: ID!
   url: String!
+  state: AppAliasVerificationStates!
+
+  """
+  List of records backend expects to move forward with domain verification
+  """
+  expectedDnsRecords: [AppAliasDNSRecord]
+
+  """HTTP code for redirection"""
+  redirectionHttpCode: HTTPRedirectType
+
+  """list of AppAlias objects that redirect to this one."""
+  redirectsFrom: [AppAlias]
 }
 
+"""An enumeration."""
 enum DeployAppAliasKindChoices {
   """Deployment"""
   DEPLOYMENT
@@ -1013,6 +1111,32 @@ enum DeployAppAliasKindChoices {
   DOMAIN
 }
 
+"""An enumeration."""
+enum AppAliasVerificationStates {
+  UNVERIFIED
+  VERIFIED
+  APEX_WITHOUT_REDIRECTION
+}
+
+type AppAliasDNSRecord {
+  recordType: String!
+  host: String!
+  value: String!
+}
+
+enum HTTPRedirectType {
+  TEMPORARY_REDIRECT
+  TEMPORARY_FOUND
+  PERMANENT_REDIRECT
+  PERMANENT_MOVED
+}
+
+"""An enumeration."""
+enum AppAliasSortBy {
+  NEWEST
+  OLDEST
+}
+
 type SecretConnection {
   """Pagination data for this connection."""
   pageInfo: PageInfo!
@@ -1042,6 +1166,43 @@ type Secret implements Node {
   id: ID!
 }
 
+type AppDatabaseConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [AppDatabaseEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `AppDatabase` and its cursor."""
+type AppDatabaseEdge {
+  """The item at the end of the edge"""
+  node: AppDatabase
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type AppDatabase implements Node {
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  deletedAt: DateTime
+  name: String!
+  username: String!
+  app: DeployApp!
+
+  """The ID of the object"""
+  id: ID!
+  host: String!
+  port: String!
+  phpmyadminUrl: String
+  dbExplorerUrl: String
+  password: String
+}
+
 type UsageMetric {
   variant: MetricType!
   value: Float!
@@ -1049,6 +1210,7 @@ type UsageMetric {
   timestamp: DateTime!
 }
 
+"""An enumeration."""
 enum MetricType {
   cpu_time
   memory_time
@@ -1067,9 +1229,15 @@ enum MetricUnit {
   """represents the unit of "milliseconds"."""
   MS
 
+  """represents the unit of "hours"."""
+  hours
+
   """represents the unit of "kilobytes"."""
   KB
 
+  """represents the unit of "bytes"."""
+  Bytes
+
   """represents the unit of "kilobytes per second"."""
   KBS
 
@@ -1080,10 +1248,21 @@ enum MetricUnit {
   DOLLARS
 }
 
-enum MetricRange {
-  LAST_24_HOURS
-  LAST_30_DAYS
-  LAST_1_HOUR
+"""Groupings for metrics"""
+enum MetricGrouping {
+  BY_15_MINUTES
+  BY_5_MINUTES
+  BY_HOUR
+  BY_DAY
+  BY_WEEK
+}
+
+input TimeRangeInput {
+  """Start of the time range."""
+  fromDt: DateTime!
+
+  """End of the time range."""
+  toDt: DateTime
 }
 
 """
@@ -1098,16 +1277,238 @@ type S3Credentials {
   endpoint: String!
 }
 
+"""An enumeration."""
 enum AppScreenshotViewportSize {
   MOBILE
   DESKTOP
 }
 
+"""An enumeration."""
 enum AppScreenshotAppearance {
   LIGHT
   DARK
 }
 
+type DeploymentConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [DeploymentEdge]!
+}
+
+"""A Relay edge containing a `Deployment` and its cursor."""
+type DeploymentEdge {
+  """The item at the end of the edge"""
+  node: Deployment
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+union Deployment = NakedDeployment | AutobuildRepository
+
+type NakedDeployment implements Node {
+  """The ID of the object"""
+  id: ID!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  appVersion: DeployAppVersion
+}
+
+type AutobuildRepository implements Node {
+  """The ID of the object"""
+  id: ID!
+  appVersion: DeployAppVersion
+  buildId: UUID!
+  buildCmd: String
+  installCmd: String
+  user: User!
+  name: String!
+  namespace: String!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  appName: String
+  repoUrl: String!
+  prevCommitHash: String
+  commitHash: String!
+  commitMessage: String!
+  commitAuthorUsername: String!
+  reference: String
+  status: StatusEnum!
+  logUrl: String
+  commitUrl: String
+  buildConfiguration: BuildConfiguration
+}
+
+"""
+Leverages the internal Python implementation of UUID (uuid.UUID) to provide native UUID objects
+in fields, resolvers and input.
+"""
+scalar UUID
+
+enum StatusEnum {
+  SUCCESS
+  WORKING
+  RUNNING
+  FAILURE
+  QUEUED
+  TIMEOUT
+  INTERNAL_ERROR
+  CANCELLED
+}
+
+type BuildConfiguration implements Node {
+  setupDb: Boolean!
+  buildCmd: String!
+  installCmd: String!
+  canDeployWithoutRepo: Boolean!
+  completionTimeInSeconds: Int!
+  kind: BuildKind
+  repo: String!
+
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  repoName: String!
+  repoNamespace: String!
+}
+
+type BuildKind implements Node {
+  setupDb: Boolean!
+  buildCmd: String!
+  installCmd: String!
+  canDeployWithoutRepo: Boolean!
+  name: String!
+
+  """The ID of the object"""
+  id: ID!
+}
+
+type AppSshServer implements Node {
+  enabled: Boolean!
+  users(offset: Int, before: String, after: String, first: Int, last: Int): SshUserConnection!
+
+  """The ID of the object"""
+  id: ID!
+}
+
+type SshUserConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [SshUserEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `SshUser` and its cursor."""
+type SshUserEdge {
+  """The item at the end of the edge"""
+  node: SshUser
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type SshUser implements Node {
+  """The ID of the object"""
+  id: ID!
+  username: String!
+  sftpRootFolder: String!
+  authorizedKeys(offset: Int, before: String, after: String, first: Int, last: Int): SshAuthorizedKeyConnection!
+  port: Int!
+  serverHost: String!
+  authenticationMethods: [SshAuthenticationMethod]
+}
+
+type SshAuthorizedKeyConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [SshAuthorizedKeyEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `SshAuthorizedKey` and its cursor."""
+type SshAuthorizedKeyEdge {
+  """The item at the end of the edge"""
+  node: SshAuthorizedKey
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+"""A public key authorised for a specific SSH user."""
+type SshAuthorizedKey implements Node {
+  """The ID of the object"""
+  id: ID!
+  createdAt: DateTime!
+  sshUser: SshUser!
+  name: String
+  publicKey: String!
+  createdBy: User!
+}
+
+enum SshAuthenticationMethod {
+  PASSWORD
+  PUBLIC_KEY
+}
+
+type AppMail implements Node {
+  emailAddr: String!
+  login: String!
+  passwordSecret: Secret!
+
+  """The ID of the object"""
+  id: ID!
+}
+
+union Kind = WordpressAppKind
+
+type WordpressAppKind {
+  adminUrl: String!
+  liveConfig(forceFetch: Boolean): WordpressLiveConfig
+}
+
+type WordpressLiveConfig {
+  checkedAt: DateTime!
+  wordpressVersion: String!
+  phpVersion: String!
+  phpArchitecture: String!
+  mysqlServer: String!
+  plugins: [WordPressPlugin]!
+  themes: [WordPressTheme]!
+  isLive: Boolean!
+  usersCount: Int!
+  publishedPostsCount: Int!
+  publishedPagesCount: Int!
+}
+
+type WordPressPlugin {
+  slug: String!
+  name: String!
+  icon: String
+  version: String!
+  latestVersion: String
+  active: Boolean!
+  description: String
+}
+
+type WordPressTheme {
+  slug: String!
+  name: String!
+  version: String!
+  latestVersion: String
+  active: Boolean!
+  description: String
+}
+
 type LogConnection {
   """Pagination data for this connection."""
   pageInfo: PageInfo!
@@ -1125,6 +1526,7 @@ type LogEdge {
   cursor: String!
 }
 
+"""An enumeration."""
 enum LogStream {
   STDOUT
   STDERR
@@ -1136,8 +1538,9 @@ type AppVersionVolume {
   name: String!
   s3Url: String!
   mountPaths: [AppVersionVolumeMountPath]!
-  size: Int
+  size: BigInt
   usedSize: BigInt
+  explorerUrl: String
 }
 
 type AppVersionVolumeMountPath {
@@ -1271,6 +1674,15 @@ type WebcImageEdge {
   cursor: String!
 }
 
+type Collection {
+  slug: String!
+  displayName: String!
+  description: String!
+  createdAt: DateTime!
+  banner: String!
+  packages(offset: Int, before: String, after: String, first: Int, last: Int): PackageConnection!
+}
+
 type AppTemplateConnection {
   """Pagination data for this connection."""
   pageInfo: PageInfo!
@@ -1299,6 +1711,7 @@ type AppTemplate implements Node {
   description: String!
   demoUrl: String!
   repoUrl: String!
+  branch: String
   category: AppTemplateCategory!
   isPublic: Boolean!
   createdAt: DateTime!
@@ -1307,6 +1720,9 @@ type AppTemplate implements Node {
   useCases: JSONString!
   repoLicense: String!
   usingPackage: Package
+  canDeployWithoutRepo: Boolean!
+  completionTimeInSeconds: Int!
+  highlighted: Boolean!
   defaultImage: String
   framework: String!
   templateFramework: TemplateFramework
@@ -1343,15 +1759,6 @@ type TemplateLanguage implements Node {
   slug: String!
 }
 
-type Collection {
-  slug: String!
-  displayName: String!
-  description: String!
-  createdAt: DateTime!
-  banner: String!
-  packages(before: String, after: String, first: Int, last: Int): PackageConnection!
-}
-
 type CategoryConnection {
   """Pagination data for this connection."""
   pageInfo: PageInfo!
@@ -1438,6 +1845,7 @@ type PackageCollaborator implements Node {
   invite: PackageCollaboratorInvite
 }
 
+"""An enumeration."""
 enum RegistryPackageMaintainerRoleChoices {
   """Owner"""
   OWNER
@@ -1468,6 +1876,7 @@ type PackageCollaboratorInvite implements Node {
   closedAt: DateTime
 }
 
+"""An enumeration."""
 enum RegistryPackageMaintainerInviteRoleChoices {
   """Owner"""
   OWNER
@@ -1563,6 +1972,7 @@ type DeployAppEdge {
   cursor: String!
 }
 
+"""An enumeration."""
 enum DeployAppsSortBy {
   NEWEST
   OLDEST
@@ -1768,6 +2178,7 @@ type CAARecord implements Node & DNSRecordInterface {
   domain: DNSDomain!
 }
 
+"""An enumeration."""
 enum DnsmanagerCertificationAuthorityAuthorizationRecordTagChoices {
   """issue"""
   ISSUE
@@ -1909,6 +2320,7 @@ type SSHFPRecord implements Node & DNSRecordInterface {
   domain: DNSDomain!
 }
 
+"""An enumeration."""
 enum DnsmanagerSshFingerprintRecordAlgorithmChoices {
   """RSA"""
   A_1
@@ -1923,6 +2335,7 @@ enum DnsmanagerSshFingerprintRecordAlgorithmChoices {
   A_4
 }
 
+"""An enumeration."""
 enum DnsmanagerSshFingerprintRecordTypeChoices {
   """SHA-1"""
   A_1
@@ -1931,12 +2344,41 @@ enum DnsmanagerSshFingerprintRecordTypeChoices {
   A_2
 }
 
+"""Usage summary for a specific owner."""
+type OwnerUsageSummary {
+  since: DateTime!
+  cpuTime: Usage!
+  noRequests: Usage!
+  ingress: Usage!
+  egress: Usage!
+  appCount: Usage!
+  buildMinutes: Usage!
+}
+
+"""Individual usage metrics for a specific app."""
+type Usage {
+  used: Int!
+  max: Int
+  charge: MoneyType!
+  usedPercent: Float!
+  unit: String
+  nearingLimits: Boolean!
+}
+
+type MoneyType {
+  amount: String
+  currency: String
+}
+
 type APITokenConnection {
   """Pagination data for this connection."""
   pageInfo: PageInfo!
 
   """Contains the nodes in this connection."""
   edges: [APITokenEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
 }
 
 """A Relay edge containing a `APIToken` and its cursor."""
@@ -1999,6 +2441,9 @@ type UserNotificationConnection {
 
   """Contains the nodes in this connection."""
   edges: [UserNotificationEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
   hasPendingNotifications: Boolean!
   pendingNotificationsCount: Int!
 }
@@ -2042,12 +2487,7 @@ type UserNotificationKindValidateEmail {
   user: User!
 }
 
-"""
-
-    Enum of ways a user can login. One user can have many login methods
-    associated with their account.
-    
-"""
+"\n    Enum of ways a user can login. One user can have many login methods\n    associated with their account.\n    "
 enum LoginMethod {
   GOOGLE
   GITHUB
@@ -2066,6 +2506,20 @@ type SocialAuth implements Node {
   username: String!
 }
 
+type GithubRepository {
+  url: String!
+  name: String!
+  namespace: String!
+}
+
+type Webhook implements Node {
+  url: String!
+  active: Boolean!
+
+  """The ID of the object"""
+  id: ID!
+}
+
 type Signature {
   id: ID!
   publicKey: PublicKey!
@@ -2080,6 +2534,7 @@ type StripeCustomer {
 type Billing {
   stripeCustomer: StripeCustomer!
   payments: [PaymentIntent]!
+  subscriptions: [WasmerSubscription]!
   paymentMethods: [PaymentMethod]!
 }
 
@@ -2100,6 +2555,7 @@ type PaymentIntent implements Node {
   amount: String!
 }
 
+"""An enumeration."""
 enum DjstripePaymentIntentStatusChoices {
   """
   Cancellation invalidates the intent for future confirmation and cannot be undone.
@@ -2125,24 +2581,108 @@ enum DjstripePaymentIntentStatusChoices {
   SUCCEEDED
 }
 
-union PaymentMethod = CardPaymentMethod
+type WasmerSubscription implements Node {
+  """The datetime this object was created in stripe."""
+  created: DateTime
 
-type CardPaymentMethod implements Node {
-  """The ID of the object"""
-  id: ID!
-  brand: CardBrand!
-  country: String!
-  expMonth: Int!
-  expYear: Int!
-  funding: CardFunding!
-  last4: String!
-  isDefault: Boolean!
-}
+  """A description of this object."""
+  description: String
 
-"""
-Card brand.
+  """
+  A date in the future at which the subscription will automatically get canceled.
+  """
+  cancelAt: DateTime
+
+  """
+  If the subscription has been canceled with the ``at_period_end`` flag set to true, ``cancel_at_period_end`` on the subscription will be true. You can use this attribute to determine whether a subscription that has a status of active is scheduled to be canceled at the end of the current period.
+  """
+  cancelAtPeriodEnd: Boolean!
+
+  """
+  If the subscription has been canceled, the date of that cancellation. If the subscription was canceled with ``cancel_at_period_end``, canceled_at will still reflect the date of the initial cancellation request, not the end of the subscription period when the subscription is automatically moved to a canceled state.
+  """
+  canceledAt: DateTime
+
+  """
+  End of the current period for which the subscription has been invoiced. At the end of this period, a new invoice will be created.
+  """
+  currentPeriodEnd: DateTime!
+
+  """
+  Start of the current period for which the subscription has been invoiced.
+  """
+  currentPeriodStart: DateTime!
+
+  """
+  Number of days a customer has to pay invoices generated by this subscription. This value will be `null` for subscriptions where `billing=charge_automatically`.
+  """
+  daysUntilDue: Int
+
+  """
+  If the subscription has ended (either because it was canceled or because the customer was switched to a subscription to a new plan), the date the subscription ended.
+  """
+  endedAt: DateTime
+
+  """
+  Date when the subscription was first created. The date might differ from the created date due to backdating.
+  """
+  startDate: DateTime
+
+  """The status of this subscription."""
+  status: DjstripeSubscriptionStatusChoices!
+
+  """If the subscription has a trial, the end of that trial."""
+  trialEnd: DateTime
+
+  """If the subscription has a trial, the beginning of that trial."""
+  trialStart: DateTime
+
+  """The ID of the object"""
+  id: ID!
+}
+
+"""An enumeration."""
+enum DjstripeSubscriptionStatusChoices {
+  """Active"""
+  ACTIVE
+
+  """Canceled"""
+  CANCELED
+
+  """Incomplete"""
+  INCOMPLETE
+
+  """Incomplete Expired"""
+  INCOMPLETE_EXPIRED
+
+  """Past due"""
+  PAST_DUE
+
+  """Trialing"""
+  TRIALING
+
+  """Unpaid"""
+  UNPAID
+}
+
+union PaymentMethod = CardPaymentMethod
+
+type CardPaymentMethod implements Node {
+  """The ID of the object"""
+  id: ID!
+  brand: CardBrand!
+  country: String!
+  expMonth: Int!
+  expYear: Int!
+  funding: CardFunding!
+  last4: String!
+  isDefault: Boolean!
+}
 
-Can be amex, diners, discover, jcb, mastercard, unionpay, visa, or unknown.
+"""
+Card brand.
+
+Can be amex, diners, discover, jcb, mastercard, unionpay, visa, or unknown.
 """
 enum CardBrand {
   AMEX
@@ -2337,7 +2877,7 @@ input WorkloadRunnerWasmSourceV1 {
 
 type Query {
   latestTOS: TermsOfService!
-  getAppRegions(offset: Int, before: String, after: String, first: Int, last: Int): AppRegionConnection!
+  getAppRegions(active: Boolean, supportsVolumes: Boolean, supportsDatabases: Boolean, offset: Int, before: String, after: String, first: Int, last: Int): AppRegionConnection!
   getDeployAppVersion(name: String!, owner: String, version: String): DeployAppVersion
   getAllDomains(namespace: String, offset: Int, before: String, after: String, first: Int, last: Int): DNSDomainConnection!
   getAllDNSRecords(sortBy: DNSRecordsSortBy, updatedAfter: DateTime, before: String, after: String, first: Int, last: Int): DNSRecordConnection!
@@ -2353,13 +2893,21 @@ type Query {
   getAppVersions(sortBy: DeployAppVersionsSortBy, updatedAfter: DateTime, offset: Int, before: String, after: String, first: Int, last: Int): DeployAppVersionConnection!
   getTemplateFrameworks(offset: Int, before: String, after: String, first: Int, last: Int): TemplateFrameworkConnection
   getTemplateLanguages(offset: Int, before: String, after: String, first: Int, last: Int): TemplateLanguageConnection
-  getAppTemplates(categorySlug: String, frameworkSlug: String, languageSlug: String, sortBy: AppTemplatesSortBy, offset: Int, before: String, after: String, first: Int, last: Int): AppTemplateConnection
+  getAppTemplates(categorySlug: String, frameworkSlug: String, languageSlug: String, sortBy: AppTemplatesSortBy, highlighted: Boolean, offset: Int, before: String, after: String, first: Int, last: Int): AppTemplateConnection
   getAppSecrets(appId: ID!, names: [String], offset: Int, before: String, after: String, first: Int, last: Int): SecretConnection
   getAppSecret(appId: ID!, secretName: String!): Secret
   getAppSecretLog(appId: ID!, offset: Int, before: String, after: String, first: Int, last: Int): SecretLogConnection
   getSecretValue(id: ID!): String
   getAppTemplate(slug: String!): AppTemplate
   getAppTemplateCategories(offset: Int, before: String, after: String, first: Int, last: Int): AppTemplateCategoryConnection
+  getBuildKinds(offset: Int, before: String, after: String, first: Int, last: Int): BuildKindConnection!
+
+  """Specify if the database name is valid or not."""
+  canDeployDbWithName(
+    """Name of the database"""
+    name: String!
+  ): Boolean!
+  wordpressDeploymentDefaults: WordpressDeploymentDefaults!
   viewer: User
   getUser(username: String!): User
   getPasswordResetToken(token: String!): GetPasswordResetToken
@@ -2406,17 +2954,19 @@ type Query {
   getCommands(names: [String!]!): [Command]
   getCollections(before: String, after: String, first: Int, last: Int): CollectionConnection
   getSignedUrlForPackageUpload(name: String, version: String = "latest", filename: String, expiresAfterSeconds: Int = 60): SignedUrl
+  getSignedUrl(filename: String, expiresAfterSeconds: Int = 60): SignedUrl
   getPackageHash(name: String, hash: String!): PackageWebc
   getPackageRelease(hash: String): PackageWebc
   getPackageInstanceByVersionOrHash(name: String!, version: String, hash: String): PackageInstance
   categories(offset: Int, before: String, after: String, first: Int, last: Int): CategoryConnection!
   viewerCan(action: OwnerAction!, ownerName: String!): Boolean!
-  blogposts(tags: [String!], before: String, after: String, first: Int, last: Int): BlogPostConnection!
+  blogposts(tags: [String!], offset: Int, before: String, after: String, first: Int, last: Int): BlogPostConnection!
   getBlogpost(slug: String, featured: Boolean): BlogPost
   allBlogpostTags(offset: Int, before: String, after: String, first: Int, last: Int): BlogPostTagConnection
   search(query: String!, packages: PackagesFilter, namespaces: NamespacesFilter, users: UsersFilter, apps: AppFilter, blogposts: BlogPostsFilter, appTemplates: AppTemplateFilter, before: String, after: String, first: Int, last: Int): SearchConnection!
   searchAutocomplete(kind: [SearchKind!], query: String!, before: String, after: String, first: Int, last: Int): SearchConnection!
   getGlobalObject(slug: String!): GlobalObject
+  internalTask(id: ID!): InternalTask
   node(
     """The ID of the object"""
     id: ID!
@@ -2457,6 +3007,9 @@ type AppRegion implements Node {
   name: String!
   country: String!
   city: String!
+  supportsVolumes: Boolean!
+  supportsDbs: Boolean!
+  active: Boolean!
 
   """The ID of the object"""
   id: ID!
@@ -2527,6 +3080,7 @@ type TemplateLanguageEdge {
   cursor: String!
 }
 
+"""An enumeration."""
 enum AppTemplatesSortBy {
   NEWEST
   OLDEST
@@ -2562,6 +3116,7 @@ type SecretLog implements Node {
   secretName: String!
 }
 
+"""An enumeration."""
 enum DeploySecretLogActionChoices {
   """Access"""
   ACCESS
@@ -2596,11 +3151,40 @@ type AppTemplateCategoryEdge {
   cursor: String!
 }
 
+type BuildKindConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [BuildKindEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `BuildKind` and its cursor."""
+type BuildKindEdge {
+  """The item at the end of the edge"""
+  node: BuildKind
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type WordpressDeploymentDefaults {
+  siteTitle: String!
+  appName: String!
+  adminUsername: String!
+  adminPassword: String!
+  adminEmail: String!
+}
+
 type GetPasswordResetToken {
   valid: Boolean!
   user: User
 }
 
+"""An enumeration."""
 enum PackageVersionSortBy {
   NEWEST
   OLDEST
@@ -2633,6 +3217,9 @@ type BlogPostConnection {
 
   """Contains the nodes in this connection."""
   edges: [BlogPostEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
 }
 
 """A Relay edge containing a `BlogPost` and its cursor."""
@@ -2670,6 +3257,7 @@ type BlogPost implements Node {
   editUrl: String
 }
 
+"""An enumeration."""
 enum BlogBlogPostThemeChoices {
   """Green"""
   GREEN
@@ -2733,7 +3321,7 @@ union SearchResult = PackageVersion | User | Namespace | DeployApp | BlogPost |
 
 input PackagesFilter {
   count: Int = 1000
-  sortBy: SearchOrderSort = ASC
+  sortBy: SearchOrderSort = DESC
 
   """Filter packages by being curated."""
   curated: Boolean
@@ -2826,7 +3414,7 @@ enum PackageOrderBy {
 
 input NamespacesFilter {
   count: Int = 1000
-  sortBy: SearchOrderSort = ASC
+  sortBy: SearchOrderSort = DESC
 
   """Filter namespaces by package count."""
   packageCount: CountFilter
@@ -2856,7 +3444,7 @@ enum NamespaceOrderBy {
 
 input UsersFilter {
   count: Int = 1000
-  sortBy: SearchOrderSort = ASC
+  sortBy: SearchOrderSort = DESC
 
   """Filter users by package count."""
   packageCount: CountFilter
@@ -2882,7 +3470,7 @@ enum UserOrderBy {
 
 input AppFilter {
   count: Int = 1000
-  sortBy: SearchOrderSort = ASC
+  sortBy: SearchOrderSort = DESC
 
   """Filter apps by deployed by."""
   deployedBy: String
@@ -2910,7 +3498,7 @@ enum AppOrderBy {
 
 input BlogPostsFilter {
   count: Int = 1000
-  sortBy: SearchOrderSort = ASC
+  sortBy: SearchOrderSort = DESC
 
   """Filter blog posts by tag."""
   tags: [String]
@@ -2918,10 +3506,10 @@ input BlogPostsFilter {
 
 input AppTemplateFilter {
   count: Int = 1000
-  sortBy: SearchOrderSort = ASC
+  sortBy: SearchOrderSort = DESC
 
   """Order app templates by field."""
-  orderBy: AppTemplateOrderBy = CREATED_DATE
+  orderBy: AppTemplateOrderBy = HIGHLIGHTED
 
   """Filter by app template framework"""
   framework: String
@@ -2935,6 +3523,7 @@ input AppTemplateFilter {
 
 enum AppTemplateOrderBy {
   CREATED_DATE
+  HIGHLIGHTED
 }
 
 enum SearchKind {
@@ -2945,6 +3534,14 @@ enum SearchKind {
 
 union GlobalObject = User | Namespace
 
+type InternalTask {
+  id: ID!
+  status: String!
+  result: JSONString
+  dateDone: DateTime
+  traceback: String
+}
+
 type RegistryInfo {
   """Base URL for this registry"""
   baseUrl: String!
@@ -2993,6 +3590,33 @@ type SchemaInfo {
 type Mutation {
   """Viewer accepts the latest ToS."""
   acceptTOS(input: AcceptTOSInput!): AcceptTOSPayload
+
+  """Delete domain with given ID"""
+  deleteAppDomain(input: DeleteAppDomainInput!): DeleteAppDomainPayload
+
+  """Enable or disable the SSH server capability on an app."""
+  toggleSshServer(input: ToggleSshServerInput!): ToggleSshServerPayload
+
+  """Reveal the password for an SSH user."""
+  revealSshUserPassword(input: RevealSshUserPasswordInput!): RevealSshUserPasswordPayload
+
+  """Rotate the password for an SSH user."""
+  rotateSshUserPassword(input: RotateSshUserPasswordInput!): RotateSshUserPasswordPayload
+
+  """Add an SSH authorized key to an SSH user."""
+  addSshAuthorizedKey(input: AddSshAuthorizedKeyInput!): AddSshAuthorizedKeyPayload
+
+  """Edit an SSH user."""
+  deleteSshAuthorizedKey(input: DeleteSshAuthorizedKeyInput!): DeleteSshAuthorizedKeyPayload
+
+  """Edit an SSH user."""
+  editSshUser(input: EditSshUserInput!): EditSshUserPayload
+
+  """Detach autobuild from app."""
+  verifyAppDomain(input: VerifyAppDomainInput!): VerifyAppDomainPayload
+
+  """Create or update an app domain on an app with given ID"""
+  upsertAppDomain(input: UpsertAppDomainInput!): UpsertAppDomainPayload
   publishDeployApp(input: PublishDeployAppInput!): PublishDeployAppPayload
   deleteApp(input: DeleteAppInput!): DeleteAppPayload
 
@@ -3017,6 +3641,7 @@ type Mutation {
   """
   detachPaymentMethod(input: DetachPaymentMethodInput!): DetachPaymentMethodPayload
   generateDeployConfigToken(input: GenerateDeployConfigTokenInput!): GenerateDeployConfigTokenPayload
+  generateSshToken(input: GenerateSshTokenInput!): GenerateSshTokenPayload
   renameApp(input: RenameAppInput!): RenameAppPayload
   renameAppAlias(input: RenameAppAliasInput!): RenameAppAliasPayload
 
@@ -3049,6 +3674,64 @@ type Mutation {
 
   """Redeploy the active version of an app."""
   rotateS3SecretsForApp(input: RotateS3SecretsForAppInput!): RotateS3SecretsForAppPayload
+
+  """Delete a database for an app."""
+  rotateCredentialsForAppDb(input: RotateCredentialsForAppDBInput!): RotateCredentialsForAppDBPayload
+
+  """Create a new database for an app."""
+  createAppDb(input: CreateAppDBInput!): CreateAppDBPayload
+
+  """Delete a database for an app."""
+  deleteAppDb(input: DeleteAppDBInput!): DeleteAppDBPayload
+
+  """Get the autobuild config for a given repo"""
+  autobuildConfigForRepo(input: AutobuildConfigForRepoInput!): AutobuildConfigForRepoPayload
+
+  """Get the autobuild config for a given zip upload URL"""
+  autobuildConfigForZipUpload(input: AutobuildConfigForZipUploadInput!): AutobuildConfigForZipUploadPayload
+
+  """Add a new github app installation"""
+  installGithubApp(input: InstallGithubAppInput!): InstallGithubAppPayload
+
+  """Detach autobuild from app."""
+  detachAppFromAutobuild(input: DetachAppFromAutobuildInput!): DetachAppFromAutobuildPayload
+
+  """Update autobuild config for an app."""
+  updateAutobuildConfigForApp(input: UpdateAutobuildConfigForAppInput!): UpdateAutobuildConfigForAppPayload
+
+  """Deploy a wordpress site."""
+  deployWordpress(input: DeployWordpressInput!): DeployWordpressPayload @deprecated(reason: "Use `publishAppFromRepoAutobuild` subscription instead.")
+
+  """Enable app that was previously disabled."""
+  enableApp(input: EnableAppInput!): EnableAppPayload
+
+  """Disable app with a reason."""
+  disableApp(input: DisableAppInput!): DisableAppPayload
+
+  """Ban app with a reason."""
+  banApp(input: BanAppInput!): BanAppPayload
+
+  """Un-ban app with a reason."""
+  unbanApp(input: UnbanAppInput!): UnbanAppPayload
+
+  """Claim a perishable app as their own."""
+  claimPerishableApp(input: ClaimPerishableAppInput!): ClaimPerishableAppPayload
+  deployViaAutobuild(input: DeployViaAutobuildInput!): DeployViaAutobuildPayload
+
+  """
+  Delete a user with some reason. The deletion will be soft, so the
+  underlying data will remain and be anonymized following GDPR.
+  """
+  deleteUser(input: DeleteUserInput!): DeleteUserPayload
+
+  """Create a new vault from yaml config"""
+  upsertVault(input: UpsertVaultInput!): UpsertVaultPayload
+
+  """Attach vault to an app"""
+  attachVault(input: AttachVaultInput!): AttachVaultPayload
+
+  """Migrate an app to a different region."""
+  migrateAppRegion(input: MigrateAppRegionInput!): MigrateAppRegionPayload
   tokenAuth(input: ObtainJSONWebTokenInput!): ObtainJSONWebTokenPayload
   generateDeployToken(input: GenerateDeployTokenInput!): GenerateDeployTokenPayload
   verifyAccessToken(token: String): Verify
@@ -3081,6 +3764,13 @@ type Mutation {
   mfa2RecoveryAuth(input: MFARecoveryAuthInput!): MFAAuthResponse
   mfa2EmailAuth(input: MFAEmailAuthInput!): MFAAuthResponse
   mfa2EmailGetToken(input: MFAGenerateEmailOTPInput!): MFAEmailGenerationResponse
+  generateCheckoutUrl(input: GenerateCheckoutUrlInput!): GenerateCheckoutUrlPayload
+
+  """Add webhook to user"""
+  addWebhook(input: AddWebhookInput!): AddWebhookPayload
+
+  """Add webhook to user"""
+  removeWebhook(input: RemoveWebhookInput!): RemoveWebhookPayload
   publishPublicKey(input: PublishPublicKeyInput!): PublishPublicKeyPayload
   publishPackage(input: PublishPackageInput!): PublishPackagePayload
   pushPackageRelease(input: PushPackageReleaseInput!): PushPackageReleasePayload
@@ -3126,6 +3816,157 @@ input AcceptTOSInput {
   clientMutationId: String
 }
 
+"""Delete domain with given ID"""
+type DeleteAppDomainPayload {
+  success: Boolean!
+
+  """ID of the deleted domain."""
+  id: ID!
+  clientMutationId: String
+}
+
+input DeleteAppDomainInput {
+  """ID of the domain to delete."""
+  id: ID!
+  clientMutationId: String
+}
+
+"""Enable or disable the SSH server capability on an app."""
+type ToggleSshServerPayload {
+  sshServer: AppSshServer!
+  app: DeployApp!
+  clientMutationId: String
+}
+
+input ToggleSshServerInput {
+  """App ID"""
+  appId: ID!
+  enabled: Boolean!
+  clientMutationId: String
+}
+
+"""Reveal the password for an SSH user."""
+type RevealSshUserPasswordPayload {
+  sshUser: SshUser!
+  password: String
+  clientMutationId: String
+}
+
+input RevealSshUserPasswordInput {
+  """SSH User ID"""
+  sshUserId: ID!
+  clientMutationId: String
+}
+
+"""Rotate the password for an SSH user."""
+type RotateSshUserPasswordPayload {
+  sshUser: SshUser!
+  password: String!
+  clientMutationId: String
+}
+
+input RotateSshUserPasswordInput {
+  """SSH User ID"""
+  sshUserId: ID!
+  clientMutationId: String
+}
+
+"""Add an SSH authorized key to an SSH user."""
+type AddSshAuthorizedKeyPayload {
+  authorizedKey: SshAuthorizedKey!
+  clientMutationId: String
+}
+
+input AddSshAuthorizedKeyInput {
+  """SSH User ID"""
+  sshUserId: ID!
+  publicKey: String!
+  name: String
+  clientMutationId: String
+}
+
+"""Edit an SSH user."""
+type DeleteSshAuthorizedKeyPayload {
+  success: Boolean!
+  clientMutationId: String
+}
+
+input DeleteSshAuthorizedKeyInput {
+  """SSH User ID"""
+  sshUserId: ID!
+  name: String
+  clientMutationId: String
+}
+
+"""Edit an SSH user."""
+type EditSshUserPayload {
+  sshUser: SshUser!
+  clientMutationId: String
+}
+
+input EditSshUserInput {
+  """SSH User ID"""
+  id: ID!
+  username: String
+  authenticationMethods: [SshAuthenticationMethod] = null
+  sftpRootFolder: String
+  clientMutationId: String
+}
+
+"""Detach autobuild from app."""
+type VerifyAppDomainPayload {
+  verified: Boolean!
+  clientMutationId: String
+}
+
+input VerifyAppDomainInput {
+  """The ID of the domain to verify"""
+  domainId: ID!
+
+  """Specify how to verify the domain"""
+  kind: VerificationKind = QUICK
+  clientMutationId: String
+}
+
+enum VerificationKind {
+  QUICK
+  DEEP
+}
+
+"""Create or update an app domain on an app with given ID"""
+type UpsertAppDomainPayload {
+  """List of domains generated by the mutation"""
+  domains: [AppAlias]
+  success: Boolean!
+  clientMutationId: String
+}
+
+input UpsertAppDomainInput {
+  """ID of the app onto which to add secrets."""
+  appId: ID!
+
+  """ID of the domain to upsert."""
+  id: ID
+
+  """Name of the secret."""
+  name: String!
+
+  """Redirection rules for this domain"""
+  redirection: AppDomainRedirectRules = null
+
+  """Wait for the domain to become available before returning."""
+  wait: Boolean = true
+  clientMutationId: String
+}
+
+input AppDomainRedirectRules {
+  """Domain to redirect to."""
+  to: String!
+
+  """Type of redirection; sets the http code appropriately."""
+  httpCode: HTTPRedirectType!
+}
+
 type PublishDeployAppPayload {
   deployAppVersion: DeployAppVersion!
   clientMutationId: String
@@ -3151,6 +3992,19 @@ input PublishDeployAppInput {
   If true, Publishing will fail if the source package does not have a valid webc.
   """
   strict: Boolean = false
+
+  """
+  If true, the mutation will wait for all deployment jobs to finish before returning.
+  """
+  waitForJobs: Boolean = false
+
+  """If true, the mutation will trigger a screenshot generation job."""
+  generateScreenshot: Boolean = true
+
+  """
+  Wait for smaller of n seconds or till the published app version is live.
+  """
+  waitTillLive: Int = null
   clientMutationId: String
 }
 
@@ -3252,6 +4106,16 @@ input GenerateDeployConfigTokenInput {
   clientMutationId: String
 }
 
+type GenerateSshTokenPayload {
+  token: String!
+  clientMutationId: String
+}
+
+input GenerateSshTokenInput {
+  appId: ID
+  clientMutationId: String
+}
+
 type RenameAppPayload {
   success: Boolean!
   app: DeployApp!
@@ -3389,6 +4253,7 @@ input UpsertDNSRecordInput {
   clientMutationId: String
 }
 
+"""An enumeration."""
 enum RecordKind {
   A
   AAAA
@@ -3532,6 +4397,382 @@ input RotateS3SecretsForAppInput {
   clientMutationId: String
 }
 
+"""Delete a database for an app."""
+type RotateCredentialsForAppDBPayload {
+  database: AppDatabase!
+  password: String!
+  clientMutationId: String
+}
+
+input RotateCredentialsForAppDBInput {
+  """App Database ID"""
+  id: ID!
+  clientMutationId: String
+}
+
+"""Create a new database for an app."""
+type CreateAppDBPayload {
+  database: AppDatabase!
+  password: String!
+  clientMutationId: String
+}
+
+input CreateAppDBInput {
+  """App ID"""
+  id: ID!
+
+  """Database name"""
+  name: String
+  clientMutationId: String
+}
+
+"""Delete a database for an app."""
+type DeleteAppDBPayload {
+  success: Boolean!
+  clientMutationId: String
+}
+
+input DeleteAppDBInput {
+  """App Database ID"""
+  id: ID!
+  clientMutationId: String
+}
+
+"""Get the autobuild config for a given repo"""
+type AutobuildConfigForRepoPayload {
+  """The build configuration"""
+  buildConfig: BuildConfig
+
+  """List of apps deployed with this repo."""
+  deployedApps: [DeployApp]
+  clientMutationId: String
+}
+
+"""The Build Configuration for a given repo"""
+type BuildConfig {
+  buildCmd: String!
+  installCmd: String!
+  setupDb: Boolean!
+  presetName: String!
+  appName: String!
+  canDeployWithoutRepo: Boolean!
+  completionTimeInSeconds: Int!
+  branch: String
+}
+
+input AutobuildConfigForRepoInput {
+  """The repo URL"""
+  repoUrl: String!
+  clientMutationId: String
+}
+
+"""Get the autobuild config for a given zip upload URL"""
+type AutobuildConfigForZipUploadPayload {
+  """The build configuration"""
+  buildConfig: BuildConfig
+
+  """List of apps deployed with this repo."""
+  deployedApps: [DeployApp]
+  clientMutationId: String
+}
+
+input AutobuildConfigForZipUploadInput {
+  """The Zip upload URL"""
+  uploadUrl: String!
+  clientMutationId: String
+}
+
+"""Add a new github app installation"""
+type InstallGithubAppPayload {
+  success: Boolean!
+  user: User!
+  clientMutationId: String
+}
+
+input InstallGithubAppInput {
+  """Github app Installation ID"""
+  installationId: ID!
+  clientMutationId: String
+}
+
+"""Detach autobuild from app."""
+type DetachAppFromAutobuildPayload {
+  app: DeployApp!
+  clientMutationId: String
+}
+
+input DetachAppFromAutobuildInput {
+  """The ID of the App"""
+  appId: ID!
+  clientMutationId: String
+}
+
+"""Update autobuild config for an app."""
+type UpdateAutobuildConfigForAppPayload {
+  app: DeployApp!
+  clientMutationId: String
+}
+
+input UpdateAutobuildConfigForAppInput {
+  """The ID of the App"""
+  appId: ID!
+
+  """Build command for the app"""
+  buildCmd: String
+
+  """Install command for the app"""
+  installCmd: String
+  clientMutationId: String
+}
+
+"""Deploy a wordpress site."""
+type DeployWordpressPayload {
+  appVersion: DeployAppVersion!
+  clientMutationId: String
+}
+
+input DeployWordpressInput {
+  """Wordpress site name."""
+  siteName: String!
+
+  """Name of app to create."""
+  appName: String!
+
+  """Owner of this app."""
+  appOwner: String!
+
+  """Region for this app."""
+  region: String!
+
+  """Username of admin for the wordpress site."""
+  adminUsername: String!
+
+  """Admin password for the wordpress site."""
+  adminPassword: String!
+
+  """Email of admin of the wordpress site."""
+  adminEmail: String!
+
+  """Email of admin of the wordpress site."""
+  language: String
+
+  """If set, the app is managed by wasmer."""
+  managed: Boolean
+  clientMutationId: String
+}
+
+"""Enable app that was previously disabled."""
+type EnableAppPayload {
+  app: DeployApp!
+  clientMutationId: String
+}
+
+input EnableAppInput {
+  """ID of app to disable"""
+  appId: ID!
+  clientMutationId: String
+}
+
+"""Disable app with a reason."""
+type DisableAppPayload {
+  app: DeployApp!
+  clientMutationId: String
+}
+
+input DisableAppInput {
+  """ID of app to disable"""
+  appId: ID!
+
+  """Disable with this reason"""
+  reason: String!
+  clientMutationId: String
+}
+
+"""Ban app with a reason."""
+type BanAppPayload {
+  app: DeployApp!
+  clientMutationId: String
+}
+
+input BanAppInput {
+  """ID of app to disable"""
+  appId: ID!
+
+  """Disable with this reason"""
+  reason: String!
+
+  """Blackhole the app (no network access)"""
+  blackholed: Boolean = false
+  clientMutationId: String
+}
+
+"""Un-ban app with a reason."""
+type UnbanAppPayload {
+  app: DeployApp!
+  clientMutationId: String
+}
+
+input UnbanAppInput {
+  """ID of app to disable"""
+  appId: ID!
+  clientMutationId: String
+}
+
+"""Claim a perishable app as their own."""
+type ClaimPerishableAppPayload {
+  app: DeployApp!
+  clientMutationId: String
+}
+
+input ClaimPerishableAppInput {
+  """ID of app to disable"""
+  appId: ID!
+  clientMutationId: String
+}
+
+type DeployViaAutobuildPayload {
+  success: Boolean!
+  buildId: UUID!
+  clientMutationId: String
+}
+
+input DeployViaAutobuildInput {
+  repoUrl: String
+  uploadUrl: String
+  appName: String
+  appId: ID
+  owner: String
+  buildCmd: String
+  installCmd: String
+  enableDatabase: Boolean
+  secrets: [SecretInput]
+  extraData: AutobuildDeploymentExtraData
+  params: AutobuildDeploymentExtraData
+
+  """If set, the app is managed by wasmer."""
+  managed: Boolean = false
+  kind: String
+
+  """If set, the screenshot is waited for."""
+  waitForScreenshotGeneration: Boolean = false
+
+  """Region to deploy the app"""
+  region: String
+
+  """
+  Branch to deploy from. If no branch is specified, the default branch is used.
+  """
+  branch: String
+
+  """If set, allows deploying a new version of an existing app."""
+  allowExistingApp: Boolean = false
+
+  """Additional jobs to run in the deployment."""
+  jobs: [JobDefinitionInput]
+
+  """Domains for this app"""
+  domains: [String]
+  clientMutationId: String
+}
+
+input AutobuildDeploymentExtraData {
+  wordpress: WordpressDeploymentExtraData = null
+}
+
+input WordpressDeploymentExtraData {
+  siteName: String!
+  adminUsername: String!
+  adminPassword: String!
+  adminEmail: String!
+  language: String = "en_US"
+}
+
+input JobDefinitionInput {
+  name: String
+  package: String
+
+  """Command to run the job"""
+  command: String!
+  cliArgs: [String]
+  env: [String]
+
+  """Humanfriendly timeout definition. e.g. 10m, 1h"""
+  timeout: String = "10m"
+}
+
+"""
+Delete a user with some reason. The deletion will be soft, so the
+underlying data will remain and be anonymized following GDPR.
+"""
+type DeleteUserPayload {
+  deleted: Boolean!
+
+  """ID of user to delete"""
+  userId: ID!
+  clientMutationId: String
+}
+
+input DeleteUserInput {
+  """ID of user to delete"""
+  userId: ID!
+  clientMutationId: String
+}
+
+"""Create a new vault from yaml config"""
+type UpsertVaultPayload {
+  vault: Vault!
+  clientMutationId: String
+}
+
+type Vault implements Node {
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  name: String!
+  app: DeployApp
+
+  """The ID of the object"""
+  id: ID!
+}
+
+input UpsertVaultInput {
+  """YAML Configuration for vault"""
+  config: String!
+  clientMutationId: String
+}
+
+"""Attach vault to an app"""
+type AttachVaultPayload {
+  app: DeployApp!
+  clientMutationId: String
+}
+
+input AttachVaultInput {
+  """ID of app to which the vault will be attached."""
+  appId: ID!
+
+  """ID of vault to attach."""
+  vaultId: ID!
+  clientMutationId: String
+}
+
+"""Migrate an app to a different region."""
+type MigrateAppRegionPayload {
+  app: DeployApp!
+
+  """ID of the internal task for app migration"""
+  taskId: ID!
+  clientMutationId: String
+}
+
+input MigrateAppRegionInput {
+  """ID of the app to migrate"""
+  appId: ID!
+
+  """Target region name"""
+  regionName: String!
+  clientMutationId: String
+}
+
 type ObtainJSONWebTokenPayload {
   payload: GenericScalar!
   refreshExpiresIn: Int!
@@ -3593,12 +4834,13 @@ type RegisterUserPayload {
 }
 
 input RegisterUserInput {
-  fullName: String!
+  fullName: String
   email: String!
   username: CaseInsensitiveString!
   password: String!
   acceptedTos: Boolean
   intent: String
+  fingerprintVisitorId: String
   clientMutationId: String
 }
 
@@ -3613,6 +4855,7 @@ input SocialAuthJWTInput {
   accessToken: String!
   register: Boolean = false
   registerIntent: String
+  fingerprintVisitorId: String
   clientMutationId: String
 }
 
@@ -3652,7 +4895,7 @@ type RequestValidationEmailPayload {
 
 input RequestValidationEmailInput {
   """The user id"""
-  userId: ID
+  userId: ID @deprecated(reason: "This field is deprecated. The user can only request a validation email for themselves.")
   clientMutationId: String
 }
 
@@ -3709,7 +4952,10 @@ input UpdateUserInfoInput {
   bio: String
 
   """The user avatar"""
-  avatar: String
+  avatar: String @deprecated(reason: "Use `avatarUpload` instead")
+
+  """The user avatar"""
+  avatarUpload: Upload
 
   """
   The user Twitter (it can be the url, or the handle with or without the @)
@@ -3729,6 +4975,12 @@ input UpdateUserInfoInput {
   clientMutationId: String
 }
 
+"""
+Create scalar that ignores normal serialization/deserialization, since
+that will be handled by the multipart request spec
+"""
+scalar Upload
+
 type ValidateUserPasswordPayload {
   success: Boolean
   clientMutationId: String
@@ -3901,6 +5153,56 @@ input MFAGenerateEmailOTPInput {
   clientMutationId: String
 }
 
+type GenerateCheckoutUrlPayload {
+  checkout: StripeCheckout!
+  clientMutationId: String
+}
+
+type StripeCheckout {
+  url: String!
+  expiresAt: DateTime!
+}
+
+input GenerateCheckoutUrlInput {
+  """URL to redirect to on success."""
+  successUrl: String!
+
+  """URL to redirect to on cancellation."""
+  cancelUrl: String!
+
+  """ID of price (product) to charge the user."""
+  priceId: ID!
+
+  """Locale of the customer."""
+  locale: String!
+
+  """ID of owner to create subscription on. Defaults to current user."""
+  forOwnerId: ID
+  clientMutationId: String
+}
+
+"""Add webhook to user"""
+type AddWebhookPayload {
+  webhook: Webhook!
+  clientMutationId: String
+}
+
+input AddWebhookInput {
+  url: String!
+  clientMutationId: String
+}
+
+"""Add webhook to user"""
+type RemoveWebhookPayload {
+  success: Boolean!
+  clientMutationId: String
+}
+
+input RemoveWebhookInput {
+  id: ID!
+  clientMutationId: String
+}
+
 type PublishPublicKeyPayload {
   success: Boolean!
   publicKey: PublicKey!
@@ -3932,12 +5234,20 @@ input PublishPackageInput {
   readme: String
   repository: String
   homepage: String
-  file: String
+
+  """The package file"""
+  file: String @deprecated(reason: "Use `fileUpload` instead")
+
+  """The package file"""
+  fileUpload: Upload
   signedUrl: String
   signature: InputSignature
 
   """The package icon"""
-  icon: String
+  icon: String @deprecated(reason: "Use `iconUpload` instead")
+
+  """The package icon"""
+  iconUpload: Upload
 
   """Whether the package is private"""
   private: Boolean = false
@@ -3955,6 +5265,7 @@ input InputSignature {
   data: String!
 }
 
+"""An enumeration."""
 enum UploadFormat {
   targz
   webcv2
@@ -4012,7 +5323,10 @@ input UpdatePackageInput {
   packageId: ID!
 
   """The package icon"""
-  icon: String
+  icon: String @deprecated(reason: "Use `iconUpload` instead")
+
+  """The package icon"""
+  iconUpload: Upload
   clientMutationId: String
 }
 
@@ -4104,7 +5418,10 @@ input CreateNamespaceInput {
   description: String
 
   """The namespace avatar"""
-  avatar: String
+  avatar: String @deprecated(reason: "Use `avatarUpload` instead")
+
+  """The namespace avatar"""
+  avatarUpload: Upload
   clientMutationId: String
 }
 
@@ -4126,7 +5443,10 @@ input UpdateNamespaceInput {
   description: String
 
   """The namespace avatar"""
-  avatar: String
+  avatar: String @deprecated(reason: "Use `avatarUpload` instead")
+
+  """The namespace avatar"""
+  avatarUpload: Upload
 
   """
   The user Twitter (it can be the url, or the handle with or without the @)
@@ -4355,9 +5675,23 @@ input GenerateUploadUrlInput {
 }
 
 type Subscription {
-  streamLogs(
+  autobuildDeployment(buildId: UUID!): AutobuildLog
+  generateScreenshot(
+    """App version ID"""
     appVersionId: ID!
 
+    """Force generation"""
+    forceGeneration: Boolean = false
+  ): DeployAppVersion!
+  streamLogs(
+    """
+    Specify the app to show logs for. Alternatively, you can also just specify the app version if you want. If both app and app-version are specified, then the app-version must be associated with specified app.
+    """
+    appId: ID
+
+    """Filter logs for app to a certain app version."""
+    appVersionId: ID
+
     """
     Get logs starting from this timestamp. Takes ISO timestamp in UTC timezone.
     """
@@ -4382,6 +5716,9 @@ type Subscription {
   ): Log!
   waitOnRepoCreation(repoId: ID!): Boolean!
   appIsPublishedFromRepo(repoId: ID!): DeployAppVersion!
+  runEdgeJob(command: String!, appVersionId: ID!, envVars: [SecretInput], source: String, cliArgs: [String]): Boolean
+  fetchBuildLogs(buildId: String!): String
+  timeout: Int
   packageVersionCreated(publishedBy: ID, ownerId: ID): PackageVersion!
 
   """Subscribe to package version ready"""
@@ -4389,6 +5726,35 @@ type Subscription {
   userNotificationCreated(userId: ID!): UserNotificationCreated!
 }
 
+"""Log entry for Deploying app from github repo"""
+type AutobuildLog {
+  """Kind of log message."""
+  kind: AutoBuildDeployAppLogKind!
+
+  """Log message"""
+  message: String
+  appVersion: DeployAppVersion
+
+  """Timestamp in nanoseconds"""
+  timestamp: String!
+
+  """ISO 8601 string in UTC"""
+  datetime: DateTime!
+
+  """Log stream"""
+  stream: LogStream
+}
+
+enum AutoBuildDeployAppLogKind {
+  LOG
+  PREPARING_TO_DEPLOY_STATUS
+  FETCHING_PLAN_STATUS
+  BUILD_STATUS
+  DEPLOY_STATUS
+  COMPLETE
+  FAILED
+}
+
 type PackageVersionReadyResponse {
   state: PackageVersionState!
   packageVersion: PackageVersion!
diff --git a/lib/backend-api/src/client.rs b/lib/backend-api/src/client.rs
index 6407ab0edd..f56e9553b8 100644
--- a/lib/backend-api/src/client.rs
+++ b/lib/backend-api/src/client.rs
@@ -4,8 +4,13 @@ use std::time::Duration;
 use crate::GraphQLApiFailure;
 use anyhow::{bail, Context as _};
 use cynic::{http::CynicReqwestError, GraphQlResponse, Operation};
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+use reqwest::Proxy;
 use url::Url;
 
+#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+pub struct Proxy;
+
 /// API client for the Wasmer API.
 ///
 /// Use the queries in [`crate::queries`] to interact with the API.
@@ -41,7 +46,7 @@ impl WasmerClient {
         }
         user_agent
             .parse()
-            .with_context(|| format!("invalid user agent: '{}'", user_agent))
+            .with_context(|| format!("invalid user agent: '{user_agent}'"))
     }
 
     pub fn new_with_client(
@@ -75,21 +80,33 @@ impl WasmerClient {
         })
     }
 
+    pub fn new(graphql_endpoint: Url, user_agent: &str) -> Result<Self, anyhow::Error> {
+        Self::new_with_proxy(graphql_endpoint, user_agent, None)
+    }
+
+    #[cfg_attr(all(target_arch = "wasm32", target_os = "unknown"), allow(unused))]
     pub fn new_with_proxy(
         graphql_endpoint: Url,
         user_agent: &str,
-        proxy: reqwest::Proxy,
+        proxy: Option<Proxy>,
     ) -> Result<Self, anyhow::Error> {
         let builder = {
             #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
-            let mut builder = reqwest::ClientBuilder::new();
+            let builder = reqwest::ClientBuilder::new();
 
             #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
             let builder = reqwest::ClientBuilder::new()
                 .connect_timeout(Duration::from_secs(10))
                 .timeout(Duration::from_secs(90));
 
-            builder.proxy(proxy)
+            #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+            if let Some(proxy) = proxy {
+                builder.proxy(proxy)
+            } else {
+                builder
+            }
+            #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+            builder
         };
 
         let client = builder.build().context("failed to create reqwest client")?;
@@ -97,22 +114,6 @@ impl WasmerClient {
         Self::new_with_client(client, graphql_endpoint, user_agent)
     }
 
-    pub fn new(graphql_endpoint: Url, user_agent: &str) -> Result<Self, anyhow::Error> {
-        #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
-        let client = reqwest::Client::builder()
-            .build()
-            .context("could not construct http client")?;
-
-        #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
-        let client = reqwest::Client::builder()
-            .connect_timeout(Duration::from_secs(10))
-            .timeout(Duration::from_secs(90))
-            .build()
-            .context("could not construct http client")?;
-
-        Self::new_with_client(client, graphql_endpoint, user_agent)
-    }
-
     pub fn with_auth_token(mut self, auth_token: String) -> Self {
         self.auth_token = Some(auth_token);
         self
diff --git a/lib/backend-api/src/error.rs b/lib/backend-api/src/error.rs
index 76f5fa90c1..3b45e08c8c 100644
--- a/lib/backend-api/src/error.rs
+++ b/lib/backend-api/src/error.rs
@@ -29,7 +29,7 @@ impl std::fmt::Display for GraphQLApiFailure {
             .map(|err| err.to_string())
             .collect::<Vec<_>>()
             .join(", ");
-        write!(f, "GraphQL API failure: {}", errs)
+        write!(f, "GraphQL API failure: {errs}")
     }
 }
 
diff --git a/lib/backend-api/src/global_id.rs b/lib/backend-api/src/global_id.rs
index e7481cd0bd..0e4f3e82bf 100644
--- a/lib/backend-api/src/global_id.rs
+++ b/lib/backend-api/src/global_id.rs
@@ -371,25 +371,25 @@ impl std::fmt::Display for GlobalIdParseError {
 
         match &self.kind {
             ErrorKind::UnknownPrefix(p) => {
-                write!(f, "unknown type prefix '{}'", p)
+                write!(f, "unknown type prefix '{p}'")
             }
             ErrorKind::Decode(s) => {
-                write!(f, "decode error: {}", s)
+                write!(f, "decode error: {s}")
             }
             ErrorKind::MissingScope => {
                 write!(f, "missing scope value")
             }
             ErrorKind::UnknownScope(x) => {
-                write!(f, "unknown scope value {}", x)
+                write!(f, "unknown scope value {x}")
             }
             ErrorKind::MissingVersion => {
                 write!(f, "missing version value")
             }
             ErrorKind::UnknownVersion(v) => {
-                write!(f, "unknown version value {}", v)
+                write!(f, "unknown version value {v}")
             }
             ErrorKind::UnknownNodeType(t) => {
-                write!(f, "unknown node type '{}'", t)
+                write!(f, "unknown node type '{t}'")
             }
             ErrorKind::MissingPrefix => write!(f, "missing prefix"),
             ErrorKind::PrefixTypeMismatch => write!(f, "prefix type mismatch"),
@@ -412,7 +412,7 @@ mod tests {
             kind: NodeKind::DeployApp,
             database_id: 123,
         };
-        assert_eq!(Ok(x1), GlobalId::parse_prefixed(&x1.encode_prefixed()),);
+        assert_eq!(Ok(x1), GlobalId::parse_prefixed(&x1.encode_prefixed()));
         assert_eq!(Ok(x1), GlobalId::parse_url(&x1.encode_url()));
 
         assert_eq!(
@@ -450,12 +450,12 @@ mod tests {
 
     #[test]
     fn test_global_id_parse_values() {
-        assert_eq!(GlobalId::parse_values(&[]), Err(ErrorKind::MissingScope),);
+        assert_eq!(GlobalId::parse_values(&[]), Err(ErrorKind::MissingScope));
         assert_eq!(
             GlobalId::parse_values(&[2]),
             Err(ErrorKind::UnknownScope(2)),
         );
-        assert_eq!(GlobalId::parse_values(&[1]), Err(ErrorKind::MissingVersion),);
+        assert_eq!(GlobalId::parse_values(&[1]), Err(ErrorKind::MissingVersion));
         assert_eq!(
             GlobalId::parse_values(&[1, 999]),
             Err(ErrorKind::UnknownVersion(999)),
diff --git a/lib/backend-api/src/gql.rs b/lib/backend-api/src/gql.rs
deleted file mode 100644
index d9657ffbba..0000000000
--- a/lib/backend-api/src/gql.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-
-types
diff --git a/lib/backend-api/src/lib.rs b/lib/backend-api/src/lib.rs
index ff6c2d1faf..6b9ee8b5d0 100644
--- a/lib/backend-api/src/lib.rs
+++ b/lib/backend-api/src/lib.rs
@@ -7,6 +7,8 @@ mod error;
 pub mod global_id;
 pub mod query;
 pub mod stream;
+#[cfg(feature = "sys")]
+pub mod subscription;
 pub mod types;
 
 use url::Url;
diff --git a/lib/backend-api/src/query.rs b/lib/backend-api/src/query.rs
index 479cd7568b..ba72361111 100644
--- a/lib/backend-api/src/query.rs
+++ b/lib/backend-api/src/query.rs
@@ -2,13 +2,14 @@ use std::{collections::HashSet, time::Duration};
 
 use anyhow::{bail, Context};
 use cynic::{MutationBuilder, QueryBuilder};
-use edge_schema::schema::NetworkTokenV1;
 use futures::StreamExt;
 use merge_streams::MergeStreams;
 use time::OffsetDateTime;
 use tracing::Instrument;
 use url::Url;
 use wasmer_config::package::PackageIdent;
+use wasmer_package::utils::from_bytes;
+use webc::Container;
 
 use crate::{
     types::{self, *},
@@ -56,6 +57,42 @@ pub async fn redeploy_app_by_id(
         .map(|v| v.redeploy_active_version.map(|v| v.app))
 }
 
+/// List all bindings associated with a particular package.
+///
+/// If a version number isn't provided, this will default to the most recently
+/// published version.
+pub async fn list_bindings(
+    client: &WasmerClient,
+    name: &str,
+    version: Option<&str>,
+) -> Result<Vec<Bindings>, anyhow::Error> {
+    client
+        .run_graphql_strict(types::GetBindingsQuery::build(GetBindingsQueryVariables {
+            name,
+            version,
+        }))
+        .await
+        .and_then(|b| {
+            b.package_version
+                .ok_or(anyhow::anyhow!("No bindings found!"))
+        })
+        .map(|v| {
+            let mut bindings_packages = Vec::new();
+
+            for b in v.bindings.into_iter().flatten() {
+                let pkg = Bindings {
+                    id: b.id.into_inner(),
+                    url: b.url,
+                    language: b.language,
+                    generator: b.generator,
+                };
+                bindings_packages.push(pkg);
+            }
+
+            bindings_packages
+        })
+}
+
 /// Revoke an existing token
 pub async fn revoke_token(
     client: &WasmerClient,
@@ -215,7 +252,7 @@ pub async fn get_app_volumes(
         .get_deploy_app
         .context("app not found")?
         .active_version
-        .volumes
+        .and_then(|v| v.volumes)
         .unwrap_or_default()
         .into_iter()
         .flatten()
@@ -223,6 +260,34 @@ pub async fn get_app_volumes(
     Ok(volumes)
 }
 
+/// Retrieve volumes for an app.
+pub async fn get_app_databases(
+    client: &WasmerClient,
+    owner: impl Into<String>,
+    name: impl Into<String>,
+) -> Result<Vec<types::AppDatabase>, anyhow::Error> {
+    let vars = types::GetAppDatabasesVars {
+        owner: owner.into(),
+        name: name.into(),
+        after: None,
+    };
+    let res = client
+        .run_graphql_strict(types::GetAppDatabases::build(vars))
+        .await?;
+
+    let app = res.get_deploy_app.context("app not found")?;
+    let dbs = app.databases;
+    let _ = dbs.page_info;
+
+    let dbs = dbs
+        .edges
+        .into_iter()
+        .flatten()
+        .flat_map(|edge| edge.node)
+        .collect::<Vec<_>>();
+    Ok(dbs)
+}
+
 /// Load the S3 credentials.
 ///
 /// S3 can be used to get access to an apps volumes.
@@ -375,7 +440,7 @@ pub async fn fetch_webc_package(
     client: &WasmerClient,
     ident: &PackageIdent,
     default_registry: &Url,
-) -> Result<webc::compat::Container, anyhow::Error> {
+) -> Result<Container, anyhow::Error> {
     let url = match ident {
         PackageIdent::Named(n) => Url::parse(&format!(
             "{default_registry}/{}:{}",
@@ -399,7 +464,7 @@ pub async fn fetch_webc_package(
         .bytes()
         .await?;
 
-    webc::compat::Container::from_bytes(data).context("failed to parse webc package")
+    from_bytes(data).context("failed to parse webc package")
 }
 
 /// Fetch app templates.
@@ -796,6 +861,56 @@ pub async fn get_signed_url_for_package_upload(
         .await
         .map(|r| r.get_signed_url_for_package_upload)
 }
+
+/// Request a signed URL for uploading an app archive via the autobuild flow.
+pub async fn generate_upload_url(
+    client: &WasmerClient,
+    filename: &str,
+    name: Option<&str>,
+    version: Option<&str>,
+    expires_after_seconds: Option<i32>,
+) -> Result<SignedUrl, anyhow::Error> {
+    let payload = client
+        .run_graphql_strict(types::GenerateUploadUrl::build(
+            GenerateUploadUrlVariables {
+                expires_after_seconds,
+                filename,
+                name,
+                version,
+            },
+        ))
+        .await
+        .and_then(|res| {
+            res.generate_upload_url
+                .context("generateUploadUrl mutation did not return data")
+        })?;
+
+    Ok(payload.signed_url)
+}
+
+/// Retrieve autobuild metadata derived from a previously uploaded archive.
+pub async fn autobuild_config_for_zip_upload(
+    client: &WasmerClient,
+    upload_url: &str,
+) -> Result<Option<types::AutobuildConfigForZipUploadPayload>, anyhow::Error> {
+    client
+        .run_graphql_strict(types::AutobuildConfigForZipUpload::build(
+            AutobuildConfigForZipUploadVariables { upload_url },
+        ))
+        .await
+        .map(|res| res.autobuild_config_for_zip_upload)
+}
+
+/// Trigger an autobuild deployment for an uploaded archive or repository.
+pub async fn deploy_via_autobuild(
+    client: &WasmerClient,
+    vars: DeployViaAutobuildVars,
+) -> Result<Option<types::DeployViaAutobuildPayload>, anyhow::Error> {
+    client
+        .run_graphql_strict(types::DeployViaAutobuild::build(vars))
+        .await
+        .map(|res| res.deploy_via_autobuild)
+}
 /// Push a package to the registry.
 pub async fn push_package_release(
     client: &WasmerClient,
@@ -1010,6 +1125,41 @@ pub async fn get_deploy_app_versions(
     Ok(versions)
 }
 
+/// Get app deployments for an app.
+pub async fn app_deployments(
+    client: &WasmerClient,
+    vars: types::GetAppDeploymentsVariables,
+) -> Result<Vec<types::Deployment>, anyhow::Error> {
+    let res = client
+        .run_graphql_strict(types::GetAppDeployments::build(vars))
+        .await?;
+    let builds = res
+        .get_deploy_app
+        .and_then(|x| x.deployments)
+        .context("no data returned")?
+        .edges
+        .into_iter()
+        .flatten()
+        .filter_map(|x| x.node)
+        .collect();
+
+    Ok(builds)
+}
+
+/// Get an app deployment by ID.
+pub async fn app_deployment(
+    client: &WasmerClient,
+    id: String,
+) -> Result<types::AutobuildRepository, anyhow::Error> {
+    let node = get_node(client, id.clone())
+        .await?
+        .with_context(|| format!("app deployment with id '{id}' not found"))?;
+    match node {
+        types::Node::AutobuildRepository(x) => Ok(*x),
+        _ => anyhow::bail!("invalid node type returned"),
+    }
+}
+
 /// Load all versions of an app.
 ///
 /// Will paginate through all versions and return them in a single list.
@@ -1262,6 +1412,39 @@ pub async fn get_app_version_by_id_with_app(
     Ok((app, version))
 }
 
+pub async fn user_apps_page(
+    client: &WasmerClient,
+    sort: types::DeployAppsSortBy,
+    cursor: Option<String>,
+) -> Result<Paginated<types::DeployApp>, anyhow::Error> {
+    let user = client
+        .run_graphql(types::GetCurrentUserWithApps::build(
+            GetCurrentUserWithAppsVars {
+                after: cursor,
+                first: Some(10),
+                sort: Some(sort),
+            },
+        ))
+        .await?
+        .viewer
+        .context("not logged in")?;
+
+    let apps: Vec<_> = user
+        .apps
+        .edges
+        .into_iter()
+        .flatten()
+        .filter_map(|x| x.node)
+        .collect();
+
+    let out = Paginated {
+        items: apps,
+        next_cursor: user.apps.page_info.end_cursor,
+    };
+
+    Ok(out)
+}
+
 /// List all apps that are accessible by the current user.
 ///
 /// NOTE: this will only include the first pages and does not provide pagination.
@@ -1273,6 +1456,7 @@ pub async fn user_apps(
         let user = client
             .run_graphql(types::GetCurrentUserWithApps::build(
                 GetCurrentUserWithAppsVars {
+                    first: Some(10),
                     after: cursor,
                     sort: Some(sort),
                 },
@@ -1336,6 +1520,43 @@ pub async fn user_accessible_apps(
     Ok((user_apps, ns_apps.merge()).merge())
 }
 
+/// Get apps for a specific namespace.
+///
+/// NOTE: only retrieves the first page and does not do pagination.
+pub async fn namespace_apps_page(
+    client: &WasmerClient,
+    namespace: String,
+    sort: types::DeployAppsSortBy,
+    cursor: Option<String>,
+) -> Result<Paginated<types::DeployApp>, anyhow::Error> {
+    let namespace = namespace.clone();
+
+    let res = client
+        .run_graphql(types::GetNamespaceApps::build(GetNamespaceAppsVars {
+            name: namespace.to_string(),
+            after: cursor,
+            sort: Some(sort),
+        }))
+        .await?
+        .get_namespace
+        .context("namespace not found")?
+        .apps;
+
+    let apps: Vec<_> = res
+        .edges
+        .into_iter()
+        .flatten()
+        .filter_map(|x| x.node)
+        .collect();
+
+    let out = Paginated {
+        items: apps,
+        next_cursor: res.page_info.end_cursor,
+    };
+
+    Ok(out)
+}
+
 /// Get apps for a specific namespace.
 ///
 /// NOTE: only retrieves the first page and does not do pagination.
@@ -1357,7 +1578,7 @@ pub async fn namespace_apps(
 
         let ns = res
             .get_namespace
-            .with_context(|| format!("failed to get namespace '{}'", namespace))?;
+            .with_context(|| format!("failed to get namespace '{namespace}'"))?;
 
         let apps: Vec<_> = ns
             .apps
@@ -1596,31 +1817,9 @@ pub fn get_package_releases_stream(
     )
 }
 
-/// Generate a new Edge token.
-pub async fn generate_deploy_token_raw(
-    client: &WasmerClient,
-    app_version_id: String,
-) -> Result<String, anyhow::Error> {
-    let res = client
-        .run_graphql(types::GenerateDeployToken::build(
-            types::GenerateDeployTokenVars { app_version_id },
-        ))
-        .await?;
-
-    res.generate_deploy_token
-        .map(|x| x.token)
-        .context("no token returned")
-}
-
-#[derive(Debug, PartialEq)]
-pub enum GenerateTokenBy {
-    Id(NetworkTokenV1),
-}
-
 #[derive(Debug, PartialEq)]
 pub enum TokenKind {
     SSH,
-    Network(GenerateTokenBy),
 }
 
 pub async fn generate_deploy_config_token_raw(
@@ -1632,9 +1831,6 @@ pub async fn generate_deploy_config_token_raw(
             types::GenerateDeployConfigTokenVars {
                 input: match token_kind {
                     TokenKind::SSH => "{}".to_string(),
-                    TokenKind::Network(by) => match by {
-                        GenerateTokenBy::Id(token) => serde_json::to_string(&token)?,
-                    },
                 },
             },
         ))
@@ -1645,6 +1841,27 @@ pub async fn generate_deploy_config_token_raw(
         .context("no token returned")
 }
 
+/// Generate an SSH token for accesing Edge over SSH or SFTP.
+///
+/// If an app id is provided, the token will be scoped to that app,
+/// and using the token will open an ssh context for that app.
+pub async fn generate_ssh_token(
+    client: &WasmerClient,
+    app_id: Option<String>,
+) -> Result<String, anyhow::Error> {
+    let res = client
+        .run_graphql_strict(types::GenerateSshToken::build(
+            types::GenerateSshTokenVariables {
+                app_id: app_id.map(cynic::Id::new),
+            },
+        ))
+        .await?;
+
+    res.generate_ssh_token
+        .map(|x| x.token)
+        .context("no token returned")
+}
+
 /// Get pages of logs associated with an application that lie within the
 /// specified date range.
 // NOTE: this is not public due to severe usability issues.
diff --git a/lib/backend-api/src/subscription.rs b/lib/backend-api/src/subscription.rs
new file mode 100644
index 0000000000..2935546e58
--- /dev/null
+++ b/lib/backend-api/src/subscription.rs
@@ -0,0 +1,121 @@
+use crate::{
+    types::{
+        AutobuildDeploymentSubscription, AutobuildDeploymentSubscriptionVariables,
+        PackageVersionReadySubscription, PackageVersionReadySubscriptionVariables, Uuid,
+    },
+    WasmerClient,
+};
+use anyhow::Context;
+use async_tungstenite::tungstenite::client::IntoClientRequest;
+use cynic::SubscriptionBuilder;
+use graphql_ws_client::Subscription;
+use reqwest::header::HeaderValue;
+use std::future::IntoFuture;
+
+pub async fn package_version_ready(
+    client: &WasmerClient,
+    package_version_id: &str,
+) -> anyhow::Result<
+    Subscription<
+        cynic::StreamingOperation<
+            PackageVersionReadySubscription,
+            PackageVersionReadySubscriptionVariables,
+        >,
+    >,
+> {
+    let mut url = client.graphql_endpoint().clone();
+    if url.scheme() == "http" {
+        url.set_scheme("ws").unwrap();
+    } else if url.scheme() == "https" {
+        url.set_scheme("wss").unwrap();
+    }
+
+    let url = url.to_string();
+    let mut req = url.into_client_request()?;
+
+    req.headers_mut().insert(
+        "Sec-WebSocket-Protocol",
+        HeaderValue::from_str("graphql-transport-ws").unwrap(),
+    );
+
+    if let Some(token) = client.auth_token() {
+        req.headers_mut().insert(
+            reqwest::header::AUTHORIZATION,
+            HeaderValue::from_str(&format!("Bearer {token}"))?,
+        );
+    }
+
+    req.headers_mut()
+        .insert(reqwest::header::USER_AGENT, client.user_agent.clone());
+
+    let (connection, _resp) = async_tungstenite::tokio::connect_async(req)
+        .await
+        .context("could not connect")?;
+
+    let (client, actor) = graphql_ws_client::Client::build(connection).await?;
+    tokio::spawn(actor.into_future());
+
+    let stream = client
+        .subscribe(PackageVersionReadySubscription::build(
+            PackageVersionReadySubscriptionVariables {
+                package_version_id: cynic::Id::new(package_version_id),
+            },
+        ))
+        .await?;
+
+    Ok(stream)
+}
+
+pub async fn autobuild_deployment(
+    client: &WasmerClient,
+    build_id: &str,
+) -> anyhow::Result<
+    Subscription<
+        cynic::StreamingOperation<
+            AutobuildDeploymentSubscription,
+            AutobuildDeploymentSubscriptionVariables,
+        >,
+    >,
+> {
+    let mut url = client.graphql_endpoint().clone();
+    if url.scheme() == "http" {
+        url.set_scheme("ws").unwrap();
+    } else if url.scheme() == "https" {
+        url.set_scheme("wss").unwrap();
+    }
+
+    let url = url.to_string();
+    let mut req = url.into_client_request()?;
+
+    req.headers_mut().insert(
+        "Sec-WebSocket-Protocol",
+        HeaderValue::from_str("graphql-transport-ws").unwrap(),
+    );
+
+    if let Some(token) = client.auth_token() {
+        req.headers_mut().insert(
+            reqwest::header::AUTHORIZATION,
+            HeaderValue::from_str(&format!("Bearer {token}"))?,
+        );
+    }
+
+    req.headers_mut()
+        .insert(reqwest::header::USER_AGENT, client.user_agent.clone());
+
+    let (connection, _resp) = async_tungstenite::tokio::connect_async(req)
+        .await
+        .context("could not connect")?;
+
+    let (client, actor) = graphql_ws_client::Client::build(connection).await?;
+    tokio::spawn(actor.into_future());
+
+    let stream = client
+        .subscribe(AutobuildDeploymentSubscription::build(
+            AutobuildDeploymentSubscriptionVariables {
+                build_id: Uuid(build_id.to_string()),
+            },
+        ))
+        .await?;
+
+    Ok(stream)
+}
diff --git a/lib/backend-api/src/types.rs b/lib/backend-api/src/types.rs
index 14bbf5f6ed..e8741eb189 100644
--- a/lib/backend-api/src/types.rs
+++ b/lib/backend-api/src/types.rs
@@ -2,6 +2,12 @@ pub use queries::*;
 
 pub use cynic::Id;
 
+#[derive(serde::Serialize, serde::Deserialize, Clone, Debug)]
+pub struct Paginated<T> {
+    pub items: Vec<T>,
+    pub next_cursor: Option<String>,
+}
+
 #[cynic::schema_for_derives(file = r#"schema.graphql"#, module = "schema")]
 mod queries {
     use serde::Serialize;
@@ -591,6 +597,27 @@ mod queries {
         pub url: String,
     }
 
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct GenerateUploadUrlVariables<'a> {
+        pub expires_after_seconds: Option<i32>,
+        pub filename: &'a str,
+        pub name: Option<&'a str>,
+        pub version: Option<&'a str>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Mutation", variables = "GenerateUploadUrlVariables")]
+    pub struct GenerateUploadUrl {
+        #[arguments(input: { expiresAfterSeconds: $expires_after_seconds, filename: $filename, name: $name, version: $version })]
+        pub generate_upload_url: Option<GenerateUploadUrlPayload>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct GenerateUploadUrlPayload {
+        #[cynic(rename = "signedUrl")]
+        pub signed_url: SignedUrl,
+    }
+
     #[derive(cynic::QueryFragment, Debug)]
     pub struct PackageWebcConnection {
         pub page_info: PageInfo,
@@ -632,6 +659,7 @@ mod queries {
 
     #[derive(cynic::QueryVariables, Debug)]
     pub struct GetCurrentUserWithAppsVars {
+        pub first: Option<i32>,
         pub after: Option<String>,
         pub sort: Option<DeployAppsSortBy>,
     }
@@ -648,7 +676,7 @@ mod queries {
     pub struct UserWithApps {
         pub id: cynic::Id,
         pub username: String,
-        #[arguments(after: $after, sortBy: $sort)]
+        #[arguments(after: $after, sortBy: $sort, first: $first)]
         pub apps: DeployAppConnection,
     }
 
@@ -832,7 +860,7 @@ mod queries {
     #[derive(cynic::QueryFragment, Debug)]
     #[cynic(graphql_type = "DeployApp")]
     pub(crate) struct AppVolumes {
-        pub active_version: AppVersionVolumes,
+        pub active_version: Option<AppVersionVolumes>,
     }
 
     #[derive(cynic::QueryFragment, Debug)]
@@ -844,10 +872,55 @@ mod queries {
     #[derive(serde::Serialize, cynic::QueryFragment, Debug)]
     pub struct AppVersionVolume {
         pub name: String,
-        pub size: Option<i32>,
+        pub size: Option<BigInt>,
         pub used_size: Option<BigInt>,
     }
 
+    #[derive(cynic::QueryVariables, Debug)]
+    pub(crate) struct GetAppDatabasesVars {
+        pub name: String,
+        pub owner: String,
+        pub after: Option<String>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetAppDatabasesVars")]
+    pub(crate) struct GetAppDatabases {
+        #[arguments(owner: $owner, name: $name)]
+        pub get_deploy_app: Option<AppDatabases>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub(crate) struct AppDatabaseConnection {
+        pub page_info: PageInfo,
+        pub edges: Vec<Option<AppDatabaseEdge>>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "DeployApp")]
+    pub(crate) struct AppDatabases {
+        pub databases: AppDatabaseConnection,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub(crate) struct AppDatabaseEdge {
+        pub node: Option<AppDatabase>,
+    }
+
+    #[derive(serde::Serialize, cynic::QueryFragment, Debug)]
+    pub struct AppDatabase {
+        pub id: cynic::Id,
+        pub name: String,
+        pub created_at: DateTime,
+        pub updated_at: DateTime,
+        pub deleted_at: Option<DateTime>,
+        pub username: String,
+        pub db_explorer_url: Option<String>,
+        pub host: String,
+        pub port: String,
+        pub password: Option<String>,
+    }
+
     #[derive(cynic::QueryFragment, Debug)]
     pub struct RegisterDomainPayload {
         pub success: bool,
@@ -938,7 +1011,7 @@ mod queries {
         pub created_at: DateTime,
         pub updated_at: DateTime,
         pub description: Option<String>,
-        pub active_version: DeployAppVersion,
+        pub active_version: Option<DeployAppVersion>,
         pub admin_url: String,
         pub owner: Owner,
         pub url: String,
@@ -1184,6 +1257,194 @@ mod queries {
         pub app: DeployApp,
     }
 
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct GetAppDeploymentsVariables {
+        pub after: Option<String>,
+        pub first: Option<i32>,
+        pub name: String,
+        pub offset: Option<i32>,
+        pub owner: String,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetAppDeploymentsVariables")]
+    pub struct GetAppDeployments {
+        #[arguments(owner: $owner, name: $name)]
+        pub get_deploy_app: Option<DeployAppDeployments>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "DeployApp", variables = "GetAppDeploymentsVariables")]
+    pub struct DeployAppDeployments {
+        // FIXME: add $offset, $after, currently causes an error from the backend
+        // #[arguments(first: $first, after: $after, offset: $offset)]
+        pub deployments: Option<DeploymentConnection>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct DeploymentConnection {
+        pub page_info: PageInfo,
+        pub edges: Vec<Option<DeploymentEdge>>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct DeploymentEdge {
+        pub node: Option<Deployment>,
+    }
+
+    #[allow(clippy::large_enum_variant)]
+    #[derive(cynic::InlineFragments, Debug, Clone, Serialize)]
+    pub enum Deployment {
+        AutobuildRepository(AutobuildRepository),
+        NakedDeployment(NakedDeployment),
+        #[cynic(fallback)]
+        Other,
+    }
+
+    #[derive(cynic::QueryFragment, serde::Serialize, Debug, Clone)]
+    pub struct NakedDeployment {
+        pub id: cynic::Id,
+        pub created_at: DateTime,
+        pub updated_at: DateTime,
+        pub app_version: Option<DeployAppVersion>,
+    }
+
+    #[derive(cynic::QueryFragment, serde::Serialize, Debug, Clone)]
+    pub struct AutobuildRepository {
+        pub id: cynic::Id,
+        pub build_id: Uuid,
+        pub created_at: DateTime,
+        pub updated_at: DateTime,
+        pub status: StatusEnum,
+        pub log_url: Option<String>,
+        pub repo_url: String,
+    }
+
+    #[derive(cynic::Enum, Clone, Copy, Debug)]
+    pub enum StatusEnum {
+        Success,
+        Working,
+        Failure,
+        Queued,
+        Timeout,
+        InternalError,
+        Cancelled,
+        Running,
+    }
+
+    impl StatusEnum {
+        pub fn as_str(&self) -> &'static str {
+            match self {
+                Self::Success => "success",
+                Self::Working => "working",
+                Self::Failure => "failure",
+                Self::Queued => "queued",
+                Self::Timeout => "timeout",
+                Self::InternalError => "internal_error",
+                Self::Cancelled => "cancelled",
+                Self::Running => "running",
+            }
+        }
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct AutobuildConfigForZipUploadVariables<'a> {
+        pub upload_url: &'a str,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(
+        graphql_type = "Mutation",
+        variables = "AutobuildConfigForZipUploadVariables"
+    )]
+    pub struct AutobuildConfigForZipUpload {
+        #[arguments(input: { uploadUrl: $upload_url })]
+        pub autobuild_config_for_zip_upload: Option<AutobuildConfigForZipUploadPayload>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    pub struct AutobuildConfigForZipUploadPayload {
+        pub build_config: Option<BuildConfig>,
+        pub deployed_apps: Option<Vec<Option<DeployApp>>>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    pub struct BuildConfig {
+        pub build_cmd: String,
+        pub install_cmd: String,
+        pub setup_db: bool,
+        pub preset_name: String,
+        pub app_name: String,
+        pub can_deploy_without_repo: bool,
+        pub completion_time_in_seconds: i32,
+        pub branch: Option<String>,
+    }
+
+    #[derive(cynic::InputObject, Debug, Clone)]
+    pub struct WordpressDeploymentExtraData {
+        pub site_name: String,
+        pub admin_username: String,
+        pub admin_password: String,
+        pub admin_email: String,
+        pub language: Option<String>,
+    }
+
+    #[derive(cynic::InputObject, Debug, Clone)]
+    pub struct AutobuildDeploymentExtraData {
+        pub wordpress: Option<WordpressDeploymentExtraData>,
+    }
+
+    #[derive(cynic::InputObject, Debug, Clone)]
+    pub struct JobDefinitionInput {
+        pub name: Option<String>,
+        pub package: Option<String>,
+        pub command: String,
+        pub cli_args: Option<Vec<Option<String>>>,
+        pub env: Option<Vec<Option<String>>>,
+        pub timeout: Option<String>,
+    }
+
+    #[derive(cynic::QueryVariables, Debug, Clone)]
+    pub struct DeployViaAutobuildVars {
+        pub repo_url: Option<String>,
+        pub upload_url: Option<String>,
+        pub app_name: Option<String>,
+        pub app_id: Option<cynic::Id>,
+        pub owner: Option<String>,
+        pub build_cmd: Option<String>,
+        pub install_cmd: Option<String>,
+        pub enable_database: Option<bool>,
+        pub secrets: Option<Vec<SecretInput>>,
+        pub extra_data: Option<AutobuildDeploymentExtraData>,
+        pub params: Option<AutobuildDeploymentExtraData>,
+        pub managed: Option<bool>,
+        pub kind: Option<String>,
+        pub wait_for_screenshot_generation: Option<bool>,
+        pub region: Option<String>,
+        pub branch: Option<String>,
+        pub allow_existing_app: Option<bool>,
+        pub jobs: Option<Vec<JobDefinitionInput>>,
+        pub domains: Option<Vec<Option<String>>>,
+        pub client_mutation_id: Option<String>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Mutation", variables = "DeployViaAutobuildVars")]
+    pub struct DeployViaAutobuild {
+        #[arguments(input: { repoUrl: $repo_url, uploadUrl: $upload_url, appName: $app_name, appId: $app_id, owner: $owner, buildCmd: $build_cmd, installCmd: $install_cmd, enableDatabase: $enable_database, secrets: $secrets, extraData: $extra_data, params: $params, managed: $managed, kind: $kind, waitForScreenshotGeneration: $wait_for_screenshot_generation, region: $region, branch: $branch, allowExistingApp: $allow_existing_app, jobs: $jobs, domains: $domains, clientMutationId: $client_mutation_id })]
+        pub deploy_via_autobuild: Option<DeployViaAutobuildPayload>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct DeployViaAutobuildPayload {
+        pub success: bool,
+        pub build_id: Uuid,
+    }
+
+    #[derive(cynic::Scalar, Debug, Clone)]
+    #[cynic(graphql_type = "UUID")]
+    pub struct Uuid(pub String);
+
     #[derive(cynic::QueryVariables, Debug)]
     pub struct PublishDeployAppVars {
         pub config: String,
@@ -1283,6 +1544,42 @@ mod queries {
         pub instance_id: String,
     }
 
+    #[derive(cynic::Enum, Clone, Copy, Debug, PartialEq, Eq)]
+    pub enum AutoBuildDeployAppLogKind {
+        Log,
+        PreparingToDeployStatus,
+        FetchingPlanStatus,
+        BuildStatus,
+        DeployStatus,
+        Complete,
+        Failed,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct AutobuildDeploymentSubscriptionVariables {
+        pub build_id: Uuid,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    #[cynic(
+        graphql_type = "Subscription",
+        variables = "AutobuildDeploymentSubscriptionVariables"
+    )]
+    pub struct AutobuildDeploymentSubscription {
+        #[arguments(buildId: $build_id)]
+        pub autobuild_deployment: Option<AutobuildLog>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    pub struct AutobuildLog {
+        pub kind: AutoBuildDeployAppLogKind,
+        pub message: Option<String>,
+        pub app_version: Option<DeployAppVersion>,
+        pub timestamp: String,
+        pub datetime: DateTime,
+        pub stream: Option<LogStream>,
+    }
+
     #[derive(cynic::QueryVariables, Debug)]
     pub struct GenerateDeployConfigTokenVars {
         pub input: String,
@@ -1299,6 +1596,23 @@ mod queries {
         pub token: String,
     }
 
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct GenerateSshTokenVariables {
+        pub app_id: Option<cynic::Id>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Mutation", variables = "GenerateSshTokenVariables")]
+    pub struct GenerateSshToken {
+        #[arguments(input: { appId: $app_id })]
+        pub generate_ssh_token: Option<GenerateSshTokenPayload>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct GenerateSshTokenPayload {
+        pub token: String,
+    }
+
     #[derive(cynic::QueryVariables, Debug)]
     pub struct GetNodeVars {
         pub id: cynic::Id,
@@ -1465,7 +1779,7 @@ mod queries {
         pub success: bool,
     }
 
-    #[derive(cynic::InputObject, Debug)]
+    #[derive(cynic::InputObject, Debug, Clone)]
     pub struct SecretInput {
         pub name: String,
         pub value: String,
@@ -2077,6 +2391,89 @@ mod queries {
     #[derive(cynic::Scalar, Debug, Clone)]
     pub struct BigInt(pub i64);
 
+    #[derive(cynic::Enum, Clone, Copy, Debug, PartialEq, Eq)]
+    pub enum ProgrammingLanguage {
+        Python,
+        Javascript,
+    }
+
+    /// A library that exposes bindings to a Wasmer package.
+    #[derive(Debug, Clone)]
+    pub struct Bindings {
+        /// A unique ID specifying this set of bindings.
+        pub id: String,
+        /// The URL which can be used to download the files that were generated
+        /// (typically as a `*.tar.gz` file).
+        pub url: String,
+        /// The programming language these bindings are written in.
+        pub language: ProgrammingLanguage,
+        /// The generator used to generate these bindings.
+        pub generator: BindingsGenerator,
+    }
+
+    #[derive(cynic::QueryVariables, Debug, Clone)]
+    pub struct GetBindingsQueryVariables<'a> {
+        pub name: &'a str,
+        pub version: Option<&'a str>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone)]
+    #[cynic(graphql_type = "Query", variables = "GetBindingsQueryVariables")]
+    pub struct GetBindingsQuery {
+        #[arguments(name: $name, version: $version)]
+        #[cynic(rename = "getPackageVersion")]
+        pub package_version: Option<PackageBindingsVersion>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone)]
+    #[cynic(graphql_type = "PackageVersion")]
+    pub struct PackageBindingsVersion {
+        pub bindings: Vec<Option<PackageVersionLanguageBinding>>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone)]
+    pub struct BindingsGenerator {
+        pub package_version: PackageVersion,
+        pub command_name: String,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone)]
+    pub struct PackageVersionLanguageBinding {
+        pub id: cynic::Id,
+        pub language: ProgrammingLanguage,
+        pub url: String,
+        pub generator: BindingsGenerator,
+        pub __typename: String,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct PackageVersionReadySubscriptionVariables {
+        pub package_version_id: cynic::Id,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(
+        graphql_type = "Subscription",
+        variables = "PackageVersionReadySubscriptionVariables"
+    )]
+    pub struct PackageVersionReadySubscription {
+        #[arguments(packageVersionId: $package_version_id)]
+        pub package_version_ready: PackageVersionReadyResponse,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct PackageVersionReadyResponse {
+        pub state: PackageVersionState,
+        pub success: bool,
+    }
+
+    #[derive(cynic::Enum, Clone, Copy, Debug)]
+    pub enum PackageVersionState {
+        WebcGenerated,
+        BindingsGenerated,
+        NativeExesGenerated,
+    }
+
     #[derive(cynic::InlineFragments, Debug, Clone)]
     #[cynic(graphql_type = "Node", variables = "GetDeployAppVersionsByIdVars")]
     pub enum NodeDeployAppVersions {
@@ -2098,6 +2495,7 @@ mod queries {
     pub enum Node {
         DeployApp(Box<DeployApp>),
         DeployAppVersion(Box<DeployAppVersion>),
+        AutobuildRepository(Box<AutobuildRepository>),
         #[cynic(fallback)]
         Unknown,
     }
diff --git a/lib/c-api/Cargo.toml b/lib/c-api/Cargo.toml
index f57ff794dd..c8628fdb76 100644
--- a/lib/c-api/Cargo.toml
+++ b/lib/c-api/Cargo.toml
@@ -18,36 +18,43 @@ version.workspace = true
 # `libwasmer.so`, `libwasmer.dylib`, `wasmer.dll` etc. But it creates
 # a conflict with the existing `wasmer` crate, see below.
 name = "wasmer" # ##lib.name##
-                # ^ DO NOT REMOVE, it's used the `Makefile`, see `build-docs-capi`.
+# ^ DO NOT REMOVE, it's used the `Makefile`, see `build-docs-capi`.
 crate-type = ["staticlib", "cdylib"] #"cdylib", "rlib", "staticlib"]
 
 [dependencies]
 # We rename `wasmer` to `wasmer-api` to avoid the conflict with this
 # library name (see `[lib]`).
-wasmer-api = { version = "=4.3.7", path = "../api", default-features = false, package = "wasmer" }
-wasmer-compiler = { version = "=4.3.7", path = "../compiler", optional = true }
-wasmer-compiler-cranelift = { version = "=4.3.7", path = "../compiler-cranelift", optional = true }
-wasmer-compiler-llvm = { version = "=4.3.7", path = "../compiler-llvm", optional = true }
-wasmer-compiler-singlepass = { version = "=4.3.7", path = "../compiler-singlepass", optional = true }
-wasmer-emscripten = { version = "=4.3.7", path = "../emscripten", optional = true }
-wasmer-middlewares = { version = "=4.3.7", path = "../middlewares", optional = true }
-wasmer-types = { version = "=4.3.7", path = "../types" }
-wasmer-wasix = { path = "../wasix", version="=0.27.0", features = ["host-fs", "host-vnet"], optional = true }
+wasmer-api = { version = "=6.1.0", path = "../api", default-features = false, package = "wasmer" }
+wasmer-compiler = { version = "=6.1.0", path = "../compiler", optional = true }
+wasmer-compiler-cranelift = { version = "=6.1.0", path = "../compiler-cranelift", optional = true }
+wasmer-compiler-llvm = { version = "=6.1.0", path = "../compiler-llvm", optional = true }
+wasmer-compiler-singlepass = { version = "=6.1.0", path = "../compiler-singlepass", optional = true }
+wasmer-middlewares = { version = "=6.1.0", path = "../middlewares", optional = true }
+wasmer-types = { version = "=6.1.0", path = "../types" }
+wasmer-wasix = { path = "../wasix", version = "=0.601.0", features = [
+	"host-fs",
+	"host-vnet",
+	"sys",
+], default-features = false, optional = true }
 webc = { workspace = true, optional = true }
-virtual-fs = { version = "0.16.0", path = "../virtual-fs", optional = true, default-features = false, features = ["static-fs"] }
+virtual-fs = { version = "0.601.0", path = "../virtual-fs", optional = true, default-features = false, features = [
+	"static-fs",
+] }
 enumset.workspace = true
-cfg-if = "1.0"
-lazy_static = "1.4"
+cfg-if.workspace = true
 libc.workspace = true
-thiserror = "1"
+thiserror.workspace = true
 typetag = { version = "0.1", optional = true }
 paste = "1.0"
-tokio = { version = "1", features = [ "rt", "rt-multi-thread", "io-util", "sync", "macros"], default-features = false }
-tracing = { version = "0.1" }
-tracing-subscriber = { version = "0.3", features = [
-	"env-filter",
-	"fmt",
-] }
+tokio = { workspace = true, features = [
+	"rt",
+	"rt-multi-thread",
+	"io-util",
+	"sync",
+	"macros",
+], default-features = false }
+tracing.workspace = true
+tracing-subscriber = { workspace = true, features = ["env-filter", "fmt"] }
 
 [dev-dependencies]
 field-offset = "0.3.3"
@@ -59,46 +66,77 @@ wasmer-inline-c = "0.1.1"
 inline-c = "0.1.7"
 
 [features]
-default = [
-    "wat",
-    "cranelift",
-    "compiler",
-    "wasi",
-    "middlewares",
-]
-sys = []
-jsc = ["wasmer-api/jsc", "wasmer-api/std"]
+default = ["wat", "sys-default", "cranelift", "compiler", "wasi", "middlewares"]
 wat = ["wasmer-api/wat"]
 wasi = ["wasmer-wasix"]
-middlewares = [
-    "compiler",
-    "wasmer-middlewares",
-]
-compiler = [
-    "wasmer-compiler",
-    "wasmer-api/compiler",
-    "wasmer-compiler/translator",
-    "wasmer-compiler/compiler",
-]
-compiler-headless = [
-    "wasmer-artifact-load",
-    "static-artifact-load",
-    "wasmer-api/compiler",
-    "wasmer-compiler/translator",
-    "wasmer-compiler/compiler",
-]
+middlewares = ["compiler", "wasmer-middlewares"]
+
+# Enable the `sys` backend.
+sys = ["wasmer-api/sys", "wasmer-compiler"]
+
+# Enable the `singlepass` compiler.
 singlepass = [
-    "wasmer-compiler-singlepass",
-    "compiler",
+	"dep:wasmer-compiler-singlepass",
+	"wasmer-api/singlepass",
+	"compiler",
 ]
+# Enable the `cranelift` compiler. 
 cranelift = [
-    "wasmer-compiler-cranelift",
-    "compiler",
+	"dep:wasmer-compiler-cranelift",
+	"wasmer-api/cranelift",
+	"compiler",
+]
+# Enable the `llvm` compiler.
+llvm = ["dep:wasmer-compiler-llvm", "wasmer-api/llvm", "compiler"]
+
+# Enable the use of compiler. Implies enabling the `sys` feature.
+compiler = [
+	"sys",
+	"wasmer-compiler",
+	"wasmer-api/compiler",
+	"wasmer-compiler/translator",
+	"wasmer-compiler/compiler",
 ]
-llvm = [
-    "wasmer-compiler-llvm",
-    "compiler",
+
+# Enable the use of the headless compiler. Implies enabling the `sys` feature.
+compiler-headless = [
+	"sys",
+	"wasmer-artifact-load",
+	"static-artifact-load",
+	"wasmer-api/compiler",
+	"wasmer-compiler/translator",
+	"wasmer-compiler/compiler",
 ]
+
+# Enable the `jsc` backend.
+jsc = ["wasmer-api/jsc", "wasmer-api/std"]
+
+# Enable the `v8` backend.
+v8 = ["wasmer-api/v8"]
+
+# Enable the `wasmi` backend.
+wasmi = ["wasmer-api/wasmi"]
+
+# Enable the `wamr` backend.
+wamr = ["wasmer-api/wamr"]
+
+# Enable the `sys` backend and use it as default. Notice that this does not
+# enable a default compiler, and users should therefore add one (or more) of
+# the `singlepass`, `cranelift` and `llvm` features.
+sys-default = ["sys", "wasmer-api/sys-default"]
+
+# Enable the `jsc` backend and use it as default.
+jsc-default = ["jsc", "wasmer-api/jsc-default"]
+
+# Enable the `v8` backend and use it as default.
+v8-default = ["v8", "wasmer-api/v8-default"]
+
+# Enable the `wamr` backend and use it as default.
+wamr-default = ["wamr", "wasmer-api/wamr-default"]
+
+# Enable the `wasmi` backend and use it as default.
+wasmi-default = ["wasmi", "wasmer-api/wasmi-default"]
+
 wasmer-artifact-load = ["wasmer-compiler/wasmer-artifact-load"]
 wasmer-artifact-create = ["wasmer-compiler/wasmer-artifact-create"]
 static-artifact-load = ["wasmer-compiler/static-artifact-load"]
@@ -107,8 +145,5 @@ webc_runner = ["virtual-fs", "webc"]
 # Deprecated features.
 jit = ["compiler"]
 
-# TODO: Port this feature.
-#emscripten = ["wasmer-emscripten"]
-
 [build-dependencies]
-cbindgen = { version = "0.24", default-features = false }
+cbindgen = { version = "0.27", default-features = false }
diff --git a/lib/c-api/README.md b/lib/c-api/README.md
index 80488d3969..62897ac348 100644
--- a/lib/c-api/README.md
+++ b/lib/c-api/README.md
@@ -1,4 +1,4 @@
-# `wasmer-c-api` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE)
+# `wasmer-c-api` [![Build Status](https://github.com/wasmerio/wasmer/actions/workflows/build.yml/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE)
 
 This crate exposes a C and a C++ API for the Wasmer runtime. It also fully supports the [wasm-c-api common API](https://github.com/WebAssembly/wasm-c-api).
 
@@ -14,7 +14,6 @@ $WASMER_DIR/
     wasm.h
     wasmer.h
     wasmer.hh
-    wasmer.h
 ```
 
 Wasmer binary also ships with [`wasmer-config`](#wasmer-config)
@@ -128,7 +127,7 @@ If you want to generate the library and headers in a friendly format as shown in
 make package-capi
 ```
 
-This command will generate a `package` directory, that you can then use easily in the [Wasmer C API examples](https://docs.wasmer.io/integrations/examples).
+This command will generate a `package` directory, that you can then use easily in the [Wasmer C API examples](https://wasmerio.github.io/wasmer/crates/doc/wasmer_c_api/).
 
 
 ## Testing
diff --git a/lib/c-api/build.rs b/lib/c-api/build.rs
index 6d3d8c25a5..ee0ca5b001 100644
--- a/lib/c-api/build.rs
+++ b/lib/c-api/build.rs
@@ -49,9 +49,6 @@ const WASI_FEATURE_AS_C_DEFINE: &str = "WASMER_WASI_ENABLED";
 #[allow(unused)]
 const MIDDLEWARES_FEATURE_AS_C_DEFINE: &str = "WASMER_MIDDLEWARES_ENABLED";
 
-#[allow(unused)]
-const EMSCRIPTEN_FEATURE_AS_C_DEFINE: &str = "WASMER_EMSCRIPTEN_ENABLED";
-
 #[allow(unused)]
 const JSC_FEATURE_AS_C_DEFINE: &str = "WASMER_JSC_BACKEND";
 
@@ -74,6 +71,9 @@ macro_rules! map_feature_as_c_define {
 }
 
 fn main() {
+    // TODO: perhaps the "yes" value is not needed here?
+    println!(r#"cargo::rustc-check-cfg=cfg(__cbindgen_hack__, values("yes"))"#);
+
     if !running_self() {
         return;
     }
@@ -141,8 +141,7 @@ fn build_wasm_c_api_headers(crate_dir: &str, out_dir: &str) {
 #if !defined(WASMER_H_PRELUDE)
 
 #define WASMER_H_PRELUDE
-{pre_header}"#,
-        pre_header = PRE_HEADER
+{PRE_HEADER}"#,
     );
 
     map_feature_as_c_define!("jsc", JSC_FEATURE_AS_C_DEFINE, pre_header);
@@ -150,7 +149,6 @@ fn build_wasm_c_api_headers(crate_dir: &str, out_dir: &str) {
     map_feature_as_c_define!("compiler", COMPILER_FEATURE_AS_C_DEFINE, pre_header);
     map_feature_as_c_define!("wasi", WASI_FEATURE_AS_C_DEFINE, pre_header);
     map_feature_as_c_define!("middlewares", MIDDLEWARES_FEATURE_AS_C_DEFINE, pre_header);
-    map_feature_as_c_define!("emscripten", EMSCRIPTEN_FEATURE_AS_C_DEFINE, pre_header);
 
     add_wasmer_version(&mut pre_header);
 
@@ -227,7 +225,6 @@ fn new_builder(language: Language, crate_dir: &str, include_guard: &str, header:
         .with_define("feature", "universal", UNIVERSAL_FEATURE_AS_C_DEFINE)
         .with_define("feature", "compiler", COMPILER_FEATURE_AS_C_DEFINE)
         .with_define("feature", "wasi", WASI_FEATURE_AS_C_DEFINE)
-        .with_define("feature", "emscripten", EMSCRIPTEN_FEATURE_AS_C_DEFINE)
 }
 
 fn build_inline_c_env_vars() {
@@ -250,10 +247,7 @@ fn build_inline_c_env_vars() {
     );
 
     if let Ok(compiler_engine) = env::var("TEST") {
-        println!(
-            "cargo:rustc-env=INLINE_C_RS_TEST={test}",
-            test = compiler_engine
-        );
+        println!("cargo:rustc-env=INLINE_C_RS_TEST={compiler_engine}");
     }
 
     println!(
@@ -299,6 +293,7 @@ fn build_cdylib_link_arg() {
         }
 
         ("macos", _) | ("ios", _) => {
+            #[allow(clippy::uninlined_format_args)]
             lines.push(format!(
                 "-Wl,-install_name,@rpath/libwasmer.dylib,-current_version,{x}.{y}.{z},-compatibility_version,{x}",
                 x = version_major,
@@ -323,7 +318,7 @@ fn build_cdylib_link_arg() {
     }
 
     for line in lines {
-        println!("cargo:rustc-cdylib-link-arg={}", line);
+        println!("cargo:rustc-cdylib-link-arg={line}");
     }
 }
 
diff --git a/lib/c-api/examples/wasmer-capi-examples-runner/Cargo.toml b/lib/c-api/examples/wasmer-capi-examples-runner/Cargo.toml
index eaec6cb708..48c7342727 100644
--- a/lib/c-api/examples/wasmer-capi-examples-runner/Cargo.toml
+++ b/lib/c-api/examples/wasmer-capi-examples-runner/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "wasmer-capi-examples-runner"
-version = "4.3.7"
+version = "6.1.0"
 edition = "2021"
 license = "MIT"
 description = "wasmer-capi-examples-runner"
diff --git a/lib/c-api/examples/wasmer-capi-examples-runner/src/lib.rs b/lib/c-api/examples/wasmer-capi-examples-runner/src/lib.rs
index ace57150b1..74863db3c7 100644
--- a/lib/c-api/examples/wasmer-capi-examples-runner/src/lib.rs
+++ b/lib/c-api/examples/wasmer-capi-examples-runner/src/lib.rs
@@ -172,7 +172,7 @@ pub const TESTS: &[&str] = &[
 fn test_run() {
     let _drop = RemoveTestsOnDrop::default();
     let config = Config::get();
-    println!("config: {:#?}", config);
+    println!("config: {config:#?}");
 
     let manifest_dir = env!("CARGO_MANIFEST_DIR");
     let host = target_lexicon::HOST.to_string();
@@ -190,7 +190,7 @@ fn test_run() {
     for test in TESTS.iter() {
         let manifest_dir_parent = std::path::Path::new(&manifest_dir);
         let manifest_dir_parent = manifest_dir_parent.parent().unwrap();
-        let c_file_path = manifest_dir_parent.join(&format!("{test}.c"));
+        let c_file_path = manifest_dir_parent.join(format!("{test}.c"));
 
         if target.contains("msvc") {
             let mut build = cc::Build::new();
@@ -208,10 +208,10 @@ fn test_run() {
             let compiler = build.try_get_compiler().unwrap();
             let mut command = compiler.to_command();
 
-            command.arg(&format!("{}", c_file_path.display()));
+            command.arg(format!("{}", c_file_path.display()));
             if !config.wasmer_dir.is_empty() {
                 command.arg("/I");
-                command.arg(&format!("{}/include/", config.wasmer_dir));
+                command.arg(format!("{}/include/", config.wasmer_dir));
                 let mut log = String::new();
                 fixup_symlinks(
                     &[
@@ -225,17 +225,17 @@ fn test_run() {
                 println!("{log}");
             }
 
-            let exe_outpath = manifest_dir_parent.join(&format!("{test}.exe"));
+            let exe_outpath = manifest_dir_parent.join(format!("{test}.exe"));
             let exe_outpath = format!("{}", exe_outpath.display());
             println!("compiling exe to {exe_outpath}");
 
-            command.arg(&format!("/Fo:{}/", manifest_dir_parent.display()));
+            command.arg(format!("/Fo:{}/", manifest_dir_parent.display()));
             command.arg("/link");
             if !config.wasmer_dir.is_empty() {
-                command.arg(&format!("/LIBPATH:{}/lib", config.wasmer_dir));
-                command.arg(&format!("{}/lib/wasmer.dll.lib", config.wasmer_dir));
+                command.arg(format!("/LIBPATH:{}/lib", config.wasmer_dir));
+                command.arg(format!("{}/lib/wasmer.dll.lib", config.wasmer_dir));
             }
-            command.arg(&format!("/OUT:{exe_outpath}"));
+            command.arg(format!("/OUT:{exe_outpath}"));
 
             // read vcvars into file, append command, then execute the bat
 
@@ -309,7 +309,7 @@ fn test_run() {
 
             if !config.wasmer_dir.is_empty() {
                 command.arg("-I");
-                command.arg(&format!("{}/include", config.wasmer_dir));
+                command.arg(format!("{}/include", config.wasmer_dir));
                 let mut log = String::new();
                 fixup_symlinks(
                     &[
@@ -324,12 +324,12 @@ fn test_run() {
             command.arg(&c_file_path);
             if !config.wasmer_dir.is_empty() {
                 command.arg("-L");
-                command.arg(&format!("{}/lib/", config.wasmer_dir));
+                command.arg(format!("{}/lib/", config.wasmer_dir));
                 command.arg("-lwasmer");
-                command.arg(&format!("-Wl,-rpath,{}/lib/", config.wasmer_dir));
+                command.arg(format!("-Wl,-rpath,{}/lib/", config.wasmer_dir));
             }
             command.arg("-o");
-            command.arg(&format!("{manifest_dir}/../{test}"));
+            command.arg(format!("{manifest_dir}/../{test}"));
 
             // cc -g -IC:/Users/felix/Development/wasmer/lib/c-api/examples/../tests
             //       -IC:/Users/felix/Development/wasmer/package/include
@@ -358,7 +358,7 @@ fn test_run() {
             }
 
             // execute
-            let mut command = std::process::Command::new(&format!("{manifest_dir}/../{test}"));
+            let mut command = std::process::Command::new(format!("{manifest_dir}/../{test}"));
             command.env("LD_PRELOAD", &libwasmer_so_path);
             command.current_dir(&exe_dir);
             println!("execute: {command:#?}");
@@ -453,7 +453,7 @@ fn fixup_symlinks_inner(include_paths: &[String], log: &mut String) -> Result<()
             _ => continue,
         };
         let lines_3 = file.lines().take(3).collect::<Vec<_>>();
-        log.push_str(&format!("first 3 lines of {path:?}: {:#?}\n", lines_3));
+        log.push_str(&format!("first 3 lines of {path:?}: {lines_3:#?}\n"));
 
         let parent = std::path::Path::new(&path).parent().unwrap();
         if let Ok(symlink) = std::fs::read_to_string(parent.join(&file)) {
@@ -466,7 +466,7 @@ fn fixup_symlinks_inner(include_paths: &[String], log: &mut String) -> Result<()
             .captures_iter(&file)
             .map(|c| c[1].to_string())
             .collect::<Vec<_>>();
-        log.push_str(&format!("regex captures: ({path:?}): {:#?}\n", filepaths));
+        log.push_str(&format!("regex captures: ({path:?}): {filepaths:#?}\n"));
         let joined_filepaths = filepaths
             .iter()
             .map(|s| {
diff --git a/lib/c-api/src/error.rs b/lib/c-api/src/error.rs
index adb988440e..5925f78f53 100644
--- a/lib/c-api/src/error.rs
+++ b/lib/c-api/src/error.rs
@@ -54,7 +54,7 @@ use std::ptr::{self, NonNull};
 use std::slice;
 
 thread_local! {
-    static LAST_ERROR: RefCell<Option<String>> = RefCell::new(None);
+    static LAST_ERROR: RefCell<Option<String>> = const { RefCell::new(None) };
 }
 
 /// Rust function to register a new error.
diff --git a/lib/c-api/src/lib.rs b/lib/c-api/src/lib.rs
index 82a3fa12c2..1b11792368 100644
--- a/lib/c-api/src/lib.rs
+++ b/lib/c-api/src/lib.rs
@@ -25,7 +25,10 @@
 )]
 // Because this crate exposes a lot of C APIs which are unsafe by definition,
 // we allow unsafe without explicit safety documentation for each of them.
+//
+// For the same reason, we also turn off the warning for camel_case types.
 #![allow(clippy::missing_safety_doc)]
+#![allow(non_camel_case_types)]
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
 
 pub mod error;
diff --git a/lib/c-api/src/wasm_c_api/engine.rs b/lib/c-api/src/wasm_c_api/engine.rs
deleted file mode 100644
index f5705d8bf5..0000000000
--- a/lib/c-api/src/wasm_c_api/engine.rs
+++ /dev/null
@@ -1,486 +0,0 @@
-#[cfg(feature = "compiler")]
-pub use super::unstable::engine::wasmer_is_compiler_available;
-pub use super::unstable::engine::{wasm_config_set_features, wasm_config_set_target};
-use super::unstable::features::wasmer_features_t;
-#[cfg(feature = "middlewares")]
-pub use super::unstable::middlewares::wasm_config_push_middleware;
-#[cfg(feature = "middlewares")]
-use super::unstable::middlewares::wasmer_middleware_t;
-use super::unstable::target_lexicon::wasmer_target_t;
-use crate::error::update_last_error;
-use cfg_if::cfg_if;
-#[cfg(not(any(feature = "compiler", feature = "compiler-headless")))]
-use wasmer_api::Engine;
-#[cfg(any(feature = "compiler", feature = "compiler-headless"))]
-use wasmer_compiler::{Engine, EngineBuilder};
-
-/// Kind of compilers that can be used by the engines.
-///
-/// This is a Wasmer-specific type with Wasmer-specific functions for
-/// manipulating it.
-#[cfg(feature = "compiler")]
-#[derive(Debug, Copy, Clone)]
-#[repr(C)]
-pub enum wasmer_compiler_t {
-    /// Variant to represent the Cranelift compiler. See the
-    /// [`wasmer_compiler_cranelift`] Rust crate.
-    CRANELIFT = 0,
-
-    /// Variant to represent the LLVM compiler. See the
-    /// [`wasmer_compiler_llvm`] Rust crate.
-    LLVM = 1,
-
-    /// Variant to represent the Singlepass compiler. See the
-    /// [`wasmer_compiler_singlepass`] Rust crate.
-    SINGLEPASS = 2,
-}
-
-#[cfg(feature = "compiler")]
-impl Default for wasmer_compiler_t {
-    fn default() -> Self {
-        cfg_if! {
-            if #[cfg(feature = "cranelift")] {
-                Self::CRANELIFT
-            } else if #[cfg(feature = "llvm")] {
-                Self::LLVM
-            } else if #[cfg(feature = "singlepass")] {
-                Self::SINGLEPASS
-            } else {
-                compile_error!("Please enable one of the compiler backends")
-            }
-        }
-    }
-}
-
-/// Kind of engines that can be used by the store.
-///
-/// This is a Wasmer-specific type with Wasmer-specific functions for
-/// manipulating it.
-#[derive(Debug, Copy, Clone)]
-#[repr(C)]
-#[allow(non_camel_case_types)]
-pub enum wasmer_engine_t {
-    /// Variant to represent the Universal engine. See the
-    /// [`wasmer_engine_universal`] Rust crate.
-    UNIVERSAL = 0,
-}
-
-impl Default for wasmer_engine_t {
-    fn default() -> Self {
-        Self::UNIVERSAL
-    }
-}
-
-/// A configuration holds the compiler and the engine used by the store.
-///
-/// cbindgen:ignore
-#[derive(Debug, Default)]
-#[repr(C)]
-pub struct wasm_config_t {
-    engine: wasmer_engine_t,
-    #[cfg(feature = "compiler")]
-    compiler: wasmer_compiler_t,
-    #[cfg(feature = "middlewares")]
-    pub(super) middlewares: Vec<wasmer_middleware_t>,
-    pub(super) nan_canonicalization: bool,
-    pub(super) features: Option<Box<wasmer_features_t>>,
-    pub(super) target: Option<Box<wasmer_target_t>>,
-}
-
-/// Create a new default Wasmer configuration.
-///
-/// # Example
-///
-/// ```rust
-/// # use wasmer_inline_c::assert_c;
-/// # fn main() {
-/// #    (assert_c! {
-/// # #include "tests/wasmer.h"
-/// #
-/// int main() {
-///     // Create the configuration.
-///     wasm_config_t* config = wasm_config_new();
-///
-///     // Create the engine.
-///     wasm_engine_t* engine = wasm_engine_new_with_config(config);
-///
-///     // Check we have an engine!
-///     assert(engine);
-///
-///     // Free everything.
-///     wasm_engine_delete(engine);
-///
-///     return 0;
-/// }
-/// #    })
-/// #    .success();
-/// # }
-/// ```
-///
-/// cbindgen:ignore
-#[no_mangle]
-pub extern "C" fn wasm_config_new() -> Box<wasm_config_t> {
-    Box::<wasm_config_t>::default()
-}
-
-/// Delete a Wasmer config object.
-///
-/// This function does not need to be called if `wasm_engine_new_with_config` or
-/// another function that takes ownership of the `wasm_config_t` is called.
-///
-/// # Example
-///
-/// ```rust
-/// # use wasmer_inline_c::assert_c;
-/// # fn main() {
-/// #    (assert_c! {
-/// # #include "tests/wasmer.h"
-/// #
-/// int main() {
-///     // Create the configuration.
-///     wasm_config_t* config = wasm_config_new();
-///
-///     // Delete the configuration
-///     wasm_config_delete(config);
-///
-///     return 0;
-/// }
-/// #    })
-/// #    .success();
-/// # }
-/// ```
-/// cbindgen:ignore
-#[no_mangle]
-pub extern "C" fn wasm_config_delete(_config: Option<Box<wasm_config_t>>) {}
-
-/// Updates the configuration to specify a particular compiler to use.
-///
-/// This is a Wasmer-specific function.
-///
-/// # Example
-///
-/// ```rust
-/// # use wasmer_inline_c::assert_c;
-/// # fn main() {
-/// #    (assert_c! {
-/// # #include "tests/wasmer.h"
-/// #
-/// int main() {
-///     // Create the configuration.
-///     wasm_config_t* config = wasm_config_new();
-///
-///     // Use the Cranelift compiler, if available.
-///     if (wasmer_is_compiler_available(CRANELIFT)) {
-///         wasm_config_set_compiler(config, CRANELIFT);
-///     }
-///     // Or maybe LLVM?
-///     else if (wasmer_is_compiler_available(LLVM)) {
-///         wasm_config_set_compiler(config, LLVM);
-///     }
-///     // Or maybe Singlepass?
-///     else if (wasmer_is_compiler_available(SINGLEPASS)) {
-///         wasm_config_set_compiler(config, SINGLEPASS);
-///     }
-///     // OK, let's run with no particular compiler.
-///
-///     // Create the engine.
-///     wasm_engine_t* engine = wasm_engine_new_with_config(config);
-///
-///     // Check we have an engine!
-///     assert(engine);
-///
-///     // Free everything.
-///     wasm_engine_delete(engine);
-///
-///     return 0;
-/// }
-/// #    })
-/// #    .success();
-/// # }
-/// ```
-#[cfg(feature = "compiler")]
-#[no_mangle]
-pub extern "C" fn wasm_config_set_compiler(
-    config: &mut wasm_config_t,
-    compiler: wasmer_compiler_t,
-) {
-    config.compiler = compiler;
-}
-
-/// Updates the configuration to specify a particular engine to use.
-///
-/// This is a Wasmer-specific function.
-///
-/// # Example
-///
-/// ```rust
-/// # use wasmer_inline_c::assert_c;
-/// # fn main() {
-/// #    (assert_c! {
-/// # #include "tests/wasmer.h"
-/// #
-/// int main() {
-///     // Create the configuration.
-///     wasm_config_t* config = wasm_config_new();
-///
-///     // Create the engine.
-///     wasm_engine_t* engine = wasm_engine_new_with_config(config);
-///
-///     // Check we have an engine!
-///     assert(engine);
-///
-///     // Free everything.
-///     wasm_engine_delete(engine);
-///
-///     return 0;
-/// }
-/// #    })
-/// #    .success();
-/// # }
-/// ```
-#[no_mangle]
-pub extern "C" fn wasm_config_set_engine(config: &mut wasm_config_t, engine: wasmer_engine_t) {
-    config.engine = engine;
-}
-
-/// An engine is used by the store to drive the compilation and the
-/// execution of a WebAssembly module.
-///
-/// cbindgen:ignore
-#[repr(C)]
-pub struct wasm_engine_t {
-    pub(crate) inner: Engine,
-}
-
-#[cfg(feature = "compiler")]
-use wasmer_api::CompilerConfig;
-
-#[cfg(all(feature = "compiler", any(feature = "compiler", feature = "dylib")))]
-fn get_default_compiler_config() -> Box<dyn CompilerConfig> {
-    cfg_if! {
-        if #[cfg(feature = "cranelift")] {
-            Box::<wasmer_compiler_cranelift::Cranelift>::default()
-        } else if #[cfg(feature = "llvm")] {
-            Box::<wasmer_compiler_llvm::LLVM>::default()
-        } else if #[cfg(feature = "singlepass")] {
-            Box::<wasmer_compiler_singlepass::Singlepass>::default()
-        } else {
-            compile_error!("Please enable one of the compiler backends")
-        }
-    }
-}
-
-cfg_if! {
-    if #[cfg(feature = "compiler")] {
-        /// Creates a new Universal engine with the default compiler.
-        ///
-        /// # Example
-        ///
-        /// See [`wasm_engine_delete`].
-        ///
-        /// cbindgen:ignore
-        #[no_mangle]
-        pub extern "C" fn wasm_engine_new() -> Box<wasm_engine_t> {
-            let compiler_config: Box<dyn CompilerConfig> = get_default_compiler_config();
-            let engine: Engine = EngineBuilder::new(compiler_config).engine();
-            Box::new(wasm_engine_t { inner: engine })
-        }
-    } else if #[cfg(feature = "compiler-headless")] {
-        /// Creates a new headless Universal engine.
-        ///
-        /// # Example
-        ///
-        /// See [`wasm_engine_delete`].
-        ///
-        /// cbindgen:ignore
-        #[no_mangle]
-        pub extern "C" fn wasm_engine_new() -> Box<wasm_engine_t> {
-            let engine: Engine = EngineBuilder::headless().engine();
-            Box::new(wasm_engine_t { inner: engine })
-        }
-    } else if #[cfg(feature = "jsc")] {
-        /// Creates the JavascriptCore Engine.
-        ///
-        /// # Example
-        ///
-        /// See [`wasm_engine_delete`].
-        ///
-        /// cbindgen:ignore
-        #[no_mangle]
-        pub extern "C" fn wasm_engine_new() -> Box<wasm_engine_t> {
-            let engine: Engine = Engine::default();
-            Box::new(wasm_engine_t { inner: engine })
-        }
-    } else {
-        /// Creates a new unknown engine, i.e. it will panic with an error message.
-        ///
-        /// # Example
-        ///
-        /// See [`wasm_engine_delete`].
-        ///
-        /// cbindgen:ignore
-        #[no_mangle]
-        pub extern "C" fn wasm_engine_new() -> Box<wasm_engine_t> {
-            unimplemented!("No engine attached; You might want to recompile `wasmer_c_api` with for example `--feature compiler`");
-        }
-    }
-}
-
-/// Deletes an engine.
-///
-/// # Example
-///
-/// ```rust
-/// # use wasmer_inline_c::assert_c;
-/// # fn main() {
-/// #    (assert_c! {
-/// # #include "tests/wasmer.h"
-/// #
-/// int main() {
-///     // Create a default engine.
-///     wasm_engine_t* engine = wasm_engine_new();
-///
-///     // Check we have an engine!
-///     assert(engine);
-///
-///     // Free everything.
-///     wasm_engine_delete(engine);
-///
-///     return 0;
-/// }
-/// #    })
-/// #    .success();
-/// # }
-/// ```
-///
-/// cbindgen:ignore
-#[no_mangle]
-pub unsafe extern "C" fn wasm_engine_delete(_engine: Option<Box<wasm_engine_t>>) {}
-
-/// Creates an engine with a particular configuration.
-///
-/// # Example
-///
-/// See [`wasm_config_new`].
-///
-/// cbindgen:ignore
-#[no_mangle]
-pub extern "C" fn wasm_engine_new_with_config(
-    config: Option<Box<wasm_config_t>>,
-) -> Option<Box<wasm_engine_t>> {
-    #[allow(dead_code)]
-    fn return_with_error(msg: &str) -> Option<Box<wasm_engine_t>> {
-        update_last_error(msg);
-        None
-    }
-
-    #[allow(unused)]
-    let config = config?;
-    #[cfg(not(any(feature = "compiler", feature = "compiler-headless")))]
-    return return_with_error("Wasmer has not been compiled with the `compiler` feature.");
-    cfg_if! {
-        if #[cfg(feature = "compiler")] {
-            #[allow(unused_mut)]
-            let mut compiler_config: Box<dyn CompilerConfig> = match config.compiler {
-                wasmer_compiler_t::CRANELIFT => {
-                    cfg_if! {
-                        if #[cfg(feature = "cranelift")] {
-                            Box::<wasmer_compiler_cranelift::Cranelift>::default()
-                        } else {
-                            return return_with_error("Wasmer has not been compiled with the `cranelift` feature.");
-                        }
-                    }
-                },
-                wasmer_compiler_t::LLVM => {
-                    cfg_if! {
-                        if #[cfg(feature = "llvm")] {
-                            Box::<wasmer_compiler_llvm::LLVM>::default()
-                        } else {
-                            return return_with_error("Wasmer has not been compiled with the `llvm` feature.");
-                        }
-                    }
-                },
-                wasmer_compiler_t::SINGLEPASS => {
-                    cfg_if! {
-                        if #[cfg(feature = "singlepass")] {
-                            Box::<wasmer_compiler_singlepass::Singlepass>::default()
-                        } else {
-                            return return_with_error("Wasmer has not been compiled with the `singlepass` feature.");
-                        }
-                    }
-                },
-            };
-
-            #[cfg(feature = "middlewares")]
-            for middleware in config.middlewares {
-                compiler_config.push_middleware(middleware.inner);
-            }
-
-            if config.nan_canonicalization {
-                compiler_config.canonicalize_nans(true);
-            }
-
-            let inner: Engine =
-                         {
-                            let mut builder = EngineBuilder::new(compiler_config);
-
-                            if let Some(target) = config.target {
-                                builder = builder.set_target(Some(target.inner));
-                            }
-
-                            if let Some(features) = config.features {
-                                builder = builder.set_features(Some(features.inner));
-                            }
-
-                            builder.engine()
-                        };
-            Some(Box::new(wasm_engine_t { inner }))
-        } else {
-            #[cfg(feature = "compiler-headless")]
-            let inner: Engine =
-                     {
-                            let mut builder = EngineBuilder::headless();
-
-                            if let Some(target) = config.target {
-                                builder = builder.set_target(Some(target.inner));
-                            }
-
-                            if let Some(features) = config.features {
-                                builder = builder.set_features(Some(features.inner));
-                            }
-
-                            builder.engine()
-                    };
-            #[cfg(not(any(feature = "compiler-headless", feature="compiler")))]
-            let inner: Engine = Engine::default();
-
-            Some(Box::new(wasm_engine_t { inner }))
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    #[cfg(not(target_os = "windows"))]
-    use inline_c::assert_c;
-    #[cfg(target_os = "windows")]
-    use wasmer_inline_c::assert_c;
-
-    #[cfg_attr(coverage, ignore)]
-    #[test]
-    fn test_engine_new() {
-        (assert_c! {
-            #include "tests/wasmer.h"
-
-            int main() {
-                wasm_engine_t* engine = wasm_engine_new();
-                assert(engine);
-
-                wasm_engine_delete(engine);
-
-                return 0;
-            }
-        })
-        .success();
-    }
-}
diff --git a/lib/c-api/src/wasm_c_api/engine/config/jsc.rs b/lib/c-api/src/wasm_c_api/engine/config/jsc.rs
new file mode 100644
index 0000000000..88d957e565
--- /dev/null
+++ b/lib/c-api/src/wasm_c_api/engine/config/jsc.rs
@@ -0,0 +1,38 @@
+use crate::{
+    error::update_last_error,
+    wasm_c_api::engine::{wasm_config_t, wasm_engine_t, wasmer_backend_t},
+};
+
+use super::wasmer_backend_config_kind_t;
+
+/// Configuration specific for the `jsc` engine.
+///
+/// This is a Wasmer-specific type with Wasmer-specific functions for
+/// manipulating it.
+///
+/// cbindgen:ignore
+#[repr(C)]
+#[derive(Debug, Default)]
+pub(crate) struct wasmer_jsc_engine_config_t;
+
+/// Create a new  [`wasm_engine_t`] backed by a `jsc` engine.
+pub(crate) fn wasm_jsc_engine_new_with_config(config: wasm_config_t) -> Option<Box<wasm_engine_t>> {
+    if !matches!(config.backend, wasmer_backend_t::JSC) || !config.backend_config.inner.is_jsc() {
+        update_last_error("Cannot create a new `jsc` engine with a non-jsc-specific config!");
+        return None;
+    }
+
+    Some(Box::new(wasm_engine_t {
+        inner: wasmer_api::jsc::JSC::default().into(),
+    }))
+}
+
+impl wasmer_backend_config_kind_t {
+    /// Returns `true` if the wasmer_engine_config_t is [`Jsc`].
+    ///
+    /// [`Jsc`]: wasmer_engine_config_t::Jsc
+    #[must_use]
+    pub(super) fn is_jsc(&self) -> bool {
+        matches!(self, Self::Jsc(..))
+    }
+}
diff --git a/lib/c-api/src/wasm_c_api/engine/config/mod.rs b/lib/c-api/src/wasm_c_api/engine/config/mod.rs
new file mode 100644
index 0000000000..33fc3dc49d
--- /dev/null
+++ b/lib/c-api/src/wasm_c_api/engine/config/mod.rs
@@ -0,0 +1,145 @@
+#[cfg(feature = "sys")]
+pub(crate) mod sys;
+#[cfg(feature = "sys")]
+pub use sys::*;
+
+use crate::wasm_c_api::unstable::target_lexicon::wasmer_target_t;
+
+use super::{wasm_config_t, wasmer_backend_t};
+
+#[cfg(feature = "jsc")]
+pub(crate) mod jsc;
+
+#[cfg(feature = "v8")]
+pub(crate) mod v8;
+
+#[cfg(feature = "wasmi")]
+pub(crate) mod wasmi;
+
+#[cfg(feature = "wamr")]
+pub(crate) mod wamr;
+
+#[repr(C)]
+#[derive(Debug)]
+pub(crate) enum wasmer_backend_config_kind_t {
+    #[cfg(feature = "sys")]
+    Sys(sys::wasmer_sys_engine_config_t),
+
+    #[cfg(feature = "jsc")]
+    Jsc(jsc::wasmer_jsc_engine_config_t),
+
+    #[cfg(feature = "v8")]
+    V8(v8::wasmer_v8_engine_config_t),
+
+    #[cfg(feature = "wasmi")]
+    Wasmi(wasmi::wasmer_wasmi_engine_config_t),
+
+    #[cfg(feature = "wamr")]
+    Wamr(wamr::wasmer_wamr_engine_config_t),
+}
+
+impl Default for wasmer_backend_config_kind_t {
+    fn default() -> Self {
+        match wasmer_backend_t::default() {
+            #[cfg(feature = "llvm")]
+            super::wasmer_backend_t::LLVM => Self::Sys(sys::wasmer_sys_engine_config_t::default()),
+            #[cfg(feature = "cranelift")]
+            super::wasmer_backend_t::CRANELIFT => {
+                Self::Sys(sys::wasmer_sys_engine_config_t::default())
+            }
+            #[cfg(feature = "singlepass")]
+            super::wasmer_backend_t::SINGLEPASS => {
+                Self::Sys(sys::wasmer_sys_engine_config_t::default())
+            }
+            #[cfg(feature = "sys")]
+            super::wasmer_backend_t::HEADLESS => {
+                Self::Sys(sys::wasmer_sys_engine_config_t::default())
+            }
+            #[cfg(feature = "v8")]
+            super::wasmer_backend_t::V8 => Self::V8(v8::wasmer_v8_engine_config_t::default()),
+            #[cfg(feature = "wasmi")]
+            super::wasmer_backend_t::WASMI => {
+                Self::Wasmi(wasmi::wasmer_wasmi_engine_config_t::default())
+            }
+            #[cfg(feature = "wamr")]
+            super::wasmer_backend_t::WAMR => {
+                Self::Wamr(wamr::wasmer_wamr_engine_config_t::default())
+            }
+            #[cfg(feature = "jsc")]
+            super::wasmer_backend_t::JSC => Self::Jsc(jsc::wasmer_jsc_engine_config_t::default()),
+
+            _ => unreachable!(),
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Debug, Default)]
+pub(crate) struct wasmer_backend_config_t {
+    pub inner: wasmer_backend_config_kind_t,
+    pub target: Option<Box<wasmer_target_t>>,
+    #[cfg(feature = "middlewares")]
+    pub middlewares: Vec<wasmer_middleware_t>,
+}
+
+/// Unstable non-standard Wasmer-specific API to update the
+/// configuration to specify a particular target for the engine.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the configuration.
+///     wasm_config_t* config = wasm_config_new();
+///
+///     // Set the target.
+///     {
+///         wasmer_triple_t* triple = wasmer_triple_new_from_host();
+///         wasmer_cpu_features_t* cpu_features = wasmer_cpu_features_new();
+///         wasmer_target_t* target = wasmer_target_new(triple, cpu_features);
+///
+///         wasm_config_sys_set_target(config, target);
+///     }
+///
+///     // Create the engine.
+///     wasm_engine_t* engine = wasm_engine_new_with_config(config);
+///
+///     // Check we have an engine!
+///     assert(engine);
+///
+///     // Free everything.
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+#[no_mangle]
+pub extern "C" fn wasm_config_set_target(config: &mut wasm_config_t, target: Box<wasmer_target_t>) {
+    config.backend_config.target = Some(target);
+}
+
+/// Updates the configuration to add a module middleware.
+///
+/// This function takes ownership of `middleware`.
+///
+/// This is a Wasmer-specific function.
+///
+/// # Example
+///
+/// See the documentation of the [`metering`] module.
+#[no_mangle]
+#[cfg(feature = "middlewares")]
+pub extern "C" fn wasm_config_push_middleware(
+    config: &mut wasm_config_t,
+    middleware: Box<wasmer_middleware_t>,
+) {
+    config.backend_config.middlewares.push(*middleware)
+}
diff --git a/lib/c-api/src/wasm_c_api/engine/config/sys.rs b/lib/c-api/src/wasm_c_api/engine/config/sys.rs
new file mode 100644
index 0000000000..9faa61717f
--- /dev/null
+++ b/lib/c-api/src/wasm_c_api/engine/config/sys.rs
@@ -0,0 +1,207 @@
+// Necessary when a single backend is enabled.
+#![allow(irrefutable_let_patterns)]
+
+use crate::{
+    error::update_last_error,
+    wasm_c_api::engine::{
+        wasm_config_t, wasm_engine_t, wasmer_backend_config_kind_t, wasmer_backend_t,
+    },
+};
+
+#[cfg(feature = "middlewares")]
+pub use crate::wasm_c_api::unstable::middlewares::wasmer_middleware_t;
+
+use cfg_if::cfg_if;
+#[cfg(any(feature = "compiler", feature = "compiler-headless"))]
+use wasmer_api::Engine;
+#[cfg(any(feature = "compiler", feature = "compiler-headless"))]
+use wasmer_compiler::EngineBuilder;
+
+#[cfg(feature = "compiler")]
+use wasmer_api::sys::CompilerConfig;
+
+/// Configuration specific for `sys` (Cranelift, LLVM, Singlepass) engines.
+///
+/// This is a Wasmer-specific type with Wasmer-specific functions for manipulating it.
+///
+/// cbindgen:ignore
+#[repr(C)]
+#[derive(Debug, Default)]
+pub(crate) struct wasmer_sys_engine_config_t {
+    pub nan_canonicalization: bool,
+}
+
+/// Updates the configuration to enable NaN canonicalization.
+///
+/// This is a Wasmer-specific function.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the configuration.
+///     wasm_config_t* config = wasm_config_new();
+///
+///     // Enable NaN canonicalization.
+///     wasm_config_sys_canonicalize_nans(config, true);
+///
+///     // Create the engine.
+///     wasm_engine_t* engine = wasm_engine_new_with_config(config);
+///
+///     // Check we have an engine!
+///     assert(engine);
+///
+///     // Free everything.
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+#[no_mangle]
+pub extern "C" fn wasm_config_sys_canonicalize_nans(config: &mut wasm_config_t, enable: bool) {
+    if let wasmer_backend_config_kind_t::Sys(ref mut c) = config.backend_config.inner {
+        c.nan_canonicalization = enable;
+    } else {
+        let sys_config = wasmer_sys_engine_config_t {
+            nan_canonicalization: enable,
+        };
+        config.backend_config.inner = wasmer_backend_config_kind_t::Sys(sys_config);
+    }
+}
+
+/// Create a new  [`wasm_engine_t`] backed by a `sys` engine.
+pub fn wasm_sys_engine_new_with_config(config: wasm_config_t) -> Option<Box<wasm_engine_t>> {
+    if !matches!(config.backend, wasmer_backend_t::LLVM)
+        && !matches!(config.backend, wasmer_backend_t::SINGLEPASS)
+        && !matches!(config.backend, wasmer_backend_t::CRANELIFT)
+        && !matches!(config.backend, wasmer_backend_t::HEADLESS)
+        && !config.backend_config.inner.is_sys()
+    {
+        update_last_error(format!(
+            "Cannot create a new `sys` engine with a non-sys-specific config! {config:?}"
+        ));
+        return None;
+    }
+
+    let backend = config.backend;
+    #[allow(unused)]
+    let sys_config = match config.backend_config.inner.try_into_sys() {
+        Err(_) => {
+            update_last_error(format!(
+                "Could not create new `sys` engine with the selected {backend:?} backend."
+            ));
+            return None;
+        }
+        Ok(s) => s,
+    };
+
+    cfg_if! {
+    if #[cfg(feature = "compiler")] {
+                #[allow(unused_mut)]
+                let mut compiler_config: Box<dyn CompilerConfig> = match &backend {
+                    wasmer_backend_t::CRANELIFT => {
+                        cfg_if! {
+                            if #[cfg(feature = "cranelift")] {
+                                Box::<wasmer_compiler_cranelift::Cranelift>::default()
+                            } else {
+                                update_last_error("Wasmer has not been compiled with the `cranelift` feature.");
+                                return None;
+                            }
+                        }
+                    },
+                    wasmer_backend_t::LLVM => {
+                        cfg_if! {
+                            if #[cfg(feature = "llvm")] {
+                                Box::<wasmer_compiler_llvm::LLVM>::default()
+                            } else {
+                                update_last_error("Wasmer has not been compiled with the `llvm` feature.");
+                                return None;
+                            }
+                        }
+                    },
+                    wasmer_backend_t::SINGLEPASS => {
+                        cfg_if! {
+                            if #[cfg(feature = "singlepass")] {
+                                Box::<wasmer_compiler_singlepass::Singlepass>::default()
+                            } else {
+                                update_last_error("Wasmer has not been compiled with the `singlepass` feature.");
+                                return None;
+                            }
+                        }
+                    },
+                    _ => panic!("not a `sys` backend!")
+                };
+
+                #[cfg(feature = "middlewares")]
+                for middleware in config.backend_config.middlewares {
+                    compiler_config.push_middleware(middleware.inner.clone());
+                }
+
+                if sys_config.nan_canonicalization {
+                    compiler_config.canonicalize_nans(true);
+                }
+
+                let inner: Engine =
+                             {
+                                let mut builder = EngineBuilder::new(compiler_config);
+
+                                if let Some(target) = config.backend_config.target {
+                                    builder = builder.set_target(Some(target.inner));
+                                }
+
+                                if let Some(features) = config.features {
+                                    builder = builder.set_features(Some(features.inner));
+                                }
+
+                                builder.engine().into()
+                            };
+                Some(Box::new(wasm_engine_t { inner }))
+            } else if #[cfg(feature = "compiler-headless")] {
+                let inner: Engine =
+                         {
+                                let mut builder = EngineBuilder::headless();
+
+                                if let Some(target) = config.backend_config.target {
+                                    builder = builder.set_target(Some(target.inner));
+                                }
+
+                                if let Some(features) = config.features {
+                                    builder = builder.set_features(Some(features.inner));
+                                }
+
+                                builder.engine().into()
+                        };
+
+                Some(Box::new(wasm_engine_t { inner }))
+            } else {
+                update_last_error("No backend enabled for the `sys` engine: enable one of `compiler` or `compiler-headless`!");
+                return None;
+            }
+        }
+}
+
+impl wasmer_backend_config_kind_t {
+    /// Returns `true` if the wasmer_engine_config_t is [`Sys`].
+    ///
+    /// [`Sys`]: wasmer_engine_config_t::Sys
+    #[must_use]
+    pub(super) fn is_sys(&self) -> bool {
+        matches!(self, Self::Sys(..))
+    }
+
+    pub(super) fn try_into_sys(self) -> Result<wasmer_sys_engine_config_t, Self> {
+        if let Self::Sys(v) = self {
+            Ok(v)
+        } else {
+            Err(self)
+        }
+    }
+}
diff --git a/lib/c-api/src/wasm_c_api/engine/config/v8.rs b/lib/c-api/src/wasm_c_api/engine/config/v8.rs
new file mode 100644
index 0000000000..8be52c994b
--- /dev/null
+++ b/lib/c-api/src/wasm_c_api/engine/config/v8.rs
@@ -0,0 +1,38 @@
+use crate::{
+    error::update_last_error,
+    wasm_c_api::engine::{wasm_config_t, wasm_engine_t, wasmer_backend_t},
+};
+
+use super::wasmer_backend_config_kind_t;
+
+/// Configuration specific for the `v8` engine.
+///
+/// This is a Wasmer-specific type with Wasmer-specific functions for
+/// manipulating it.
+///
+/// cbindgen:ignore
+#[repr(C)]
+#[derive(Debug, Default)]
+pub(crate) struct wasmer_v8_engine_config_t;
+
+/// Create a new  [`wasm_engine_t`] backed by a `v8` engine.
+pub(crate) fn wasm_v8_engine_new_with_config(config: wasm_config_t) -> Option<Box<wasm_engine_t>> {
+    if !matches!(config.backend, wasmer_backend_t::V8) || !config.backend_config.inner.is_v8() {
+        update_last_error("Cannot create a new `v8` engine with a non-v8-specific config!");
+        return None;
+    }
+
+    Some(Box::new(wasm_engine_t {
+        inner: wasmer_api::v8::V8::default().into(),
+    }))
+}
+
+impl wasmer_backend_config_kind_t {
+    /// Returns `true` if the wasmer_engine_config_t is [`V8`].
+    ///
+    /// [`V8`]: wasmer_engine_config_t::V8
+    #[must_use]
+    pub(super) fn is_v8(&self) -> bool {
+        matches!(self, Self::V8(..))
+    }
+}
diff --git a/lib/c-api/src/wasm_c_api/engine/config/wamr.rs b/lib/c-api/src/wasm_c_api/engine/config/wamr.rs
new file mode 100644
index 0000000000..d4c14d8681
--- /dev/null
+++ b/lib/c-api/src/wasm_c_api/engine/config/wamr.rs
@@ -0,0 +1,40 @@
+use crate::{
+    error::update_last_error,
+    wasm_c_api::engine::{wasm_config_t, wasm_engine_t, wasmer_backend_t},
+};
+
+use super::wasmer_backend_config_kind_t;
+
+/// Configuration specific for the `wamr` engine.
+///
+/// This is a Wasmer-specific type with Wasmer-specific functions for
+/// manipulating it.
+///
+/// cbindgen:ignore
+#[repr(C)]
+#[derive(Debug, Default)]
+pub(crate) struct wasmer_wamr_engine_config_t;
+
+/// Create a new  [`wasm_engine_t`] backed by a `wamr` engine.
+pub(crate) fn wasm_wamr_engine_new_with_config(
+    config: wasm_config_t,
+) -> Option<Box<wasm_engine_t>> {
+    if !matches!(config.backend, wasmer_backend_t::WAMR) || !config.backend_config.inner.is_wamr() {
+        update_last_error("Cannot create a new `wamr` engine with a non-wamr-specific config!");
+        return None;
+    }
+
+    Some(Box::new(wasm_engine_t {
+        inner: wasmer_api::wamr::Wamr::default().into(),
+    }))
+}
+
+impl wasmer_backend_config_kind_t {
+    /// Returns `true` if the wasmer_engine_config_t is [`WAMR`].
+    ///
+    /// [`WAMR`]: wasmer_engine_config_t::WAMR
+    #[must_use]
+    pub(super) fn is_wamr(&self) -> bool {
+        matches!(self, Self::Wamr(..))
+    }
+}
diff --git a/lib/c-api/src/wasm_c_api/engine/config/wasmi.rs b/lib/c-api/src/wasm_c_api/engine/config/wasmi.rs
new file mode 100644
index 0000000000..c0b8da824f
--- /dev/null
+++ b/lib/c-api/src/wasm_c_api/engine/config/wasmi.rs
@@ -0,0 +1,41 @@
+use crate::{
+    error::update_last_error,
+    wasm_c_api::engine::{wasm_config_t, wasm_engine_t, wasmer_backend_t},
+};
+
+use super::wasmer_backend_config_kind_t;
+
+/// Configuration specific for the `wasmi` engine.
+///
+/// This is a Wasmer-specific type with Wasmer-specific functions for
+/// manipulating it.
+///
+/// cbindgen:ignore
+#[repr(C)]
+#[derive(Debug, Default)]
+pub(crate) struct wasmer_wasmi_engine_config_t;
+
+/// Create a new  [`wasm_engine_t`] backed by a `wasmi` engine.
+pub(crate) fn wasm_wasmi_engine_new_with_config(
+    config: wasm_config_t,
+) -> Option<Box<wasm_engine_t>> {
+    if !matches!(config.backend, wasmer_backend_t::WASMI) || !config.backend_config.inner.is_wasmi()
+    {
+        update_last_error("Cannot create a new `wasmi` engine with a non-wasmi-specific config!");
+        return None;
+    }
+
+    Some(Box::new(wasm_engine_t {
+        inner: wasmer_api::wasmi::Wasmi::default().into(),
+    }))
+}
+
+impl wasmer_backend_config_kind_t {
+    /// Returns `true` if the wasmer_engine_config_t is [`WASMI`].
+    ///
+    /// [`WASMI`]: wasmer_engine_config_t::WASMI
+    #[must_use]
+    pub(super) fn is_wasmi(&self) -> bool {
+        matches!(self, Self::Wasmi(..))
+    }
+}
diff --git a/lib/c-api/src/wasm_c_api/engine/mod.rs b/lib/c-api/src/wasm_c_api/engine/mod.rs
new file mode 100644
index 0000000000..d616381002
--- /dev/null
+++ b/lib/c-api/src/wasm_c_api/engine/mod.rs
@@ -0,0 +1,306 @@
+pub use super::unstable::engine::wasm_config_set_features;
+use super::unstable::features::wasmer_features_t;
+
+use wasmer_api::{BackendKind, Engine};
+
+mod config;
+#[allow(unused_imports)]
+pub use config::*;
+
+/// Kind of engines that can be used by the store.
+///
+/// This is a Wasmer-specific type with Wasmer-specific functions for
+/// manipulating it.
+#[derive(Debug, Copy, Clone)]
+#[repr(C)]
+#[allow(non_camel_case_types)]
+pub enum wasmer_backend_t {
+    /// The cranelift backend.
+    CRANELIFT = 0,
+
+    /// The LLVM backend.
+    LLVM,
+
+    /// The singlepass backend.
+    SINGLEPASS,
+
+    /// The headless backend.
+    HEADLESS,
+
+    /// The V8 backend.
+    V8,
+
+    /// The WASMI backend.
+    WASMI,
+
+    /// The WAMR backend.
+    WAMR,
+
+    /// The JSC backend.
+    JSC,
+}
+
+impl From<BackendKind> for wasmer_backend_t {
+    fn from(value: BackendKind) -> Self {
+        match value {
+            #[cfg(feature = "cranelift")]
+            BackendKind::Cranelift => Self::CRANELIFT,
+            #[cfg(feature = "llvm")]
+            BackendKind::LLVM => Self::LLVM,
+            #[cfg(feature = "singlepass")]
+            BackendKind::Singlepass => Self::SINGLEPASS,
+            #[cfg(feature = "sys")]
+            BackendKind::Headless => Self::HEADLESS,
+            #[cfg(feature = "wamr")]
+            BackendKind::Wamr => Self::WAMR,
+            #[cfg(feature = "wasmi")]
+            BackendKind::Wasmi => Self::WASMI,
+            #[cfg(feature = "v8")]
+            BackendKind::V8 => Self::V8,
+            #[cfg(feature = "jsc")]
+            BackendKind::Jsc => Self::JSC,
+            v => panic!("Unsupported backend kind {v:?}"),
+        }
+    }
+}
+
+impl Default for wasmer_backend_t {
+    fn default() -> Self {
+        // Let the `wasmer_api` crate decide which is the default engine, given the enabled
+        // features.
+        wasmer_api::BackendKind::default().into()
+    }
+}
+
+/// An engine is used by the store to drive the compilation and the
+/// execution of a WebAssembly module.
+///
+/// cbindgen:ignore
+#[repr(C)]
+// We can let the API decide which engine is default with the given set of
+// features.
+//
+// See the impl of `Default` for `BackendEngine` in the `wasmer` (API) crate.
+#[derive(Default)]
+pub struct wasm_engine_t {
+    pub(crate) inner: Engine,
+}
+
+#[no_mangle]
+#[allow(unreachable_code)]
+pub extern "C" fn wasm_engine_new() -> Box<wasm_engine_t> {
+    Box::new(wasm_engine_t::default())
+}
+
+/// Deletes an engine.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create a default engine.
+///     wasm_engine_t* engine = wasm_engine_new();
+///     int error_length = wasmer_last_error_length();
+///     if (error_length > 0) {
+///         char *error_message = malloc(error_length);
+///         wasmer_last_error_message(error_message, error_length);
+///
+///         printf("Attempted to set an immutable global: `%s`\n", error_message);
+///         free(error_message);
+///     }
+///
+///     // Check we have an engine!
+///     assert(engine);
+///
+///     // Free everything.
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+///
+/// cbindgen:ignore
+#[no_mangle]
+pub unsafe extern "C" fn wasm_engine_delete(_engine: Option<Box<wasm_engine_t>>) {}
+
+/// Creates an engine with a particular configuration.
+///
+/// # Example
+///
+/// See [`wasm_config_new`].
+///
+/// cbindgen:ignore
+#[no_mangle]
+pub extern "C" fn wasm_engine_new_with_config(
+    config: Option<Box<wasm_config_t>>,
+) -> Option<Box<wasm_engine_t>> {
+    #[allow(unused)]
+    let config = *(config?);
+
+    match config.backend {
+        #[cfg(feature = "llvm")]
+        wasmer_backend_t::LLVM => config::sys::wasm_sys_engine_new_with_config(config),
+        #[cfg(feature = "cranelift")]
+        wasmer_backend_t::CRANELIFT => config::sys::wasm_sys_engine_new_with_config(config),
+        #[cfg(feature = "singlepass")]
+        wasmer_backend_t::SINGLEPASS => config::sys::wasm_sys_engine_new_with_config(config),
+        #[cfg(feature = "sys")]
+        wasmer_backend_t::HEADLESS => config::sys::wasm_sys_engine_new_with_config(config),
+        #[cfg(feature = "v8")]
+        wasmer_backend_t::V8 => config::v8::wasm_v8_engine_new_with_config(config),
+        #[cfg(feature = "wasmi")]
+        wasmer_backend_t::WASMI => config::wasmi::wasm_wasmi_engine_new_with_config(config),
+        #[cfg(feature = "wamr")]
+        wasmer_backend_t::WAMR => config::wamr::wasm_wamr_engine_new_with_config(config),
+        #[cfg(feature = "jsc")]
+        wasmer_backend_t::JSC => config::jsc::wasm_jsc_engine_new_with_config(config),
+        _ => unreachable!(),
+    }
+}
+
+/// A configuration holds the compiler and the engine used by the store.
+///
+/// cbindgen:ignore
+#[derive(Debug, Default)]
+#[repr(C)]
+pub struct wasm_config_t {
+    pub(super) backend: wasmer_backend_t,
+    pub(super) backend_config: wasmer_backend_config_t,
+    pub(super) features: Option<Box<wasmer_features_t>>,
+}
+
+/// Create a new default Wasmer configuration.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the configuration.
+///     wasm_config_t* config = wasm_config_new();
+///
+///     // Create the engine.
+///     wasm_engine_t* engine = wasm_engine_new_with_config(config);
+///
+///     // Check we have an engine!
+///     assert(engine);
+///
+///     // Free everything.
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+///
+/// cbindgen:ignore
+#[no_mangle]
+pub extern "C" fn wasm_config_new() -> Box<wasm_config_t> {
+    Box::<wasm_config_t>::default()
+}
+
+/// Delete a Wasmer config object.
+///
+/// This function does not need to be called if `wasm_engine_new_with_config` or
+/// another function that takes ownership of the `wasm_config_t` is called.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the configuration.
+///     wasm_config_t* config = wasm_config_new();
+///
+///     // Delete the configuration
+///     wasm_config_delete(config);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+/// cbindgen:ignore
+#[no_mangle]
+pub extern "C" fn wasm_config_delete(_config: Option<Box<wasm_config_t>>) {}
+
+/// Updates the configuration to specify a particular engine to use.
+///
+/// This is a Wasmer-specific function.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the configuration.
+///     wasm_config_t* config = wasm_config_new();
+///
+///     // Create the engine.
+///     wasm_engine_t* engine = wasm_engine_new_with_config(config);
+///
+///     // Check we have an engine!
+///     assert(engine);
+///
+///     // Free everything.
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+#[no_mangle]
+pub extern "C" fn wasm_config_set_backend(config: &mut wasm_config_t, engine: wasmer_backend_t) {
+    config.backend = engine;
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(not(target_os = "windows"))]
+    use inline_c::assert_c;
+    #[cfg(target_os = "windows")]
+    use wasmer_inline_c::assert_c;
+
+    #[cfg_attr(coverage, ignore)]
+    #[test]
+    fn test_engine_new() {
+        (assert_c! {
+            #include "tests/wasmer.h"
+
+            int main() {
+                wasm_engine_t* engine = wasm_engine_new();
+                assert(engine);
+
+                wasm_engine_delete(engine);
+
+                return 0;
+            }
+        })
+        .success();
+    }
+}
diff --git a/lib/c-api/src/wasm_c_api/module.rs b/lib/c-api/src/wasm_c_api/module.rs
index 2bc7b1ff3b..971c2c765e 100644
--- a/lib/c-api/src/wasm_c_api/module.rs
+++ b/lib/c-api/src/wasm_c_api/module.rs
@@ -253,7 +253,7 @@ pub unsafe extern "C" fn wasm_module_exports(
 ///         "(module\n"
 ///         "  (import \"ns\" \"function\" (func))\n"
 ///         "  (import \"ns\" \"global\" (global f32))\n"
-///         "  (import \"ns\" \"table\" (table 1 2 anyfunc))\n"
+///         "  (import \"ns\" \"table\" (table 1 2 funcref))\n"
 ///         "  (import \"ns\" \"memory\" (memory 3 4)))"
 ///     );
 ///     wasm_byte_vec_t wasm;
@@ -668,7 +668,7 @@ mod tests {
                     "(module\n"
                     "  (import \"ns\" \"function\" (func))\n"
                     "  (import \"ns\" \"global\" (global f32))\n"
-                    "  (import \"ns\" \"table\" (table 1 2 anyfunc))\n"
+                    "  (import \"ns\" \"table\" (table 1 2 funcref))\n"
                     "  (import \"ns\" \"memory\" (memory 3 4)))"
                 );
                 wasm_byte_vec_t wasm;
diff --git a/lib/c-api/src/wasm_c_api/store.rs b/lib/c-api/src/wasm_c_api/store.rs
index 24c6b0627a..da5b083bf5 100644
--- a/lib/c-api/src/wasm_c_api/store.rs
+++ b/lib/c-api/src/wasm_c_api/store.rs
@@ -34,7 +34,7 @@ pub unsafe extern "C" fn wasm_store_new(
     engine: Option<&wasm_engine_t>,
 ) -> Option<Box<wasm_store_t>> {
     let engine = engine?;
-    let store = Store::new(&engine.inner);
+    let store = Store::new(engine.inner.clone());
 
     Some(Box::new(wasm_store_t {
         inner: StoreRef {
diff --git a/lib/c-api/src/wasm_c_api/types/extern_.rs b/lib/c-api/src/wasm_c_api/types/extern_.rs
index 4218c2a70d..459d5fdcf9 100644
--- a/lib/c-api/src/wasm_c_api/types/extern_.rs
+++ b/lib/c-api/src/wasm_c_api/types/extern_.rs
@@ -1,7 +1,7 @@
 use super::super::externals::wasm_extern_t;
 use super::{
     wasm_functype_t, wasm_globaltype_t, wasm_memorytype_t, wasm_tabletype_t, WasmFunctionType,
-    WasmGlobalType, WasmMemoryType, WasmTableType,
+    WasmGlobalType, WasmMemoryType, WasmTableType, WasmTagType,
 };
 use std::convert::{TryFrom, TryInto};
 use std::mem;
@@ -18,6 +18,7 @@ pub enum wasm_externkind_enum {
     WASM_EXTERN_GLOBAL = 1,
     WASM_EXTERN_TABLE = 2,
     WASM_EXTERN_MEMORY = 3,
+    WASM_EXTERN_TAG = 4,
 }
 
 impl From<ExternType> for wasm_externkind_enum {
@@ -32,6 +33,7 @@ impl From<&ExternType> for wasm_externkind_enum {
             ExternType::Global(_) => Self::WASM_EXTERN_GLOBAL,
             ExternType::Table(_) => Self::WASM_EXTERN_TABLE,
             ExternType::Memory(_) => Self::WASM_EXTERN_MEMORY,
+            ExternType::Tag(_) => Self::WASM_EXTERN_TAG,
         }
     }
 }
@@ -42,6 +44,9 @@ pub(crate) enum WasmExternType {
     Global(WasmGlobalType),
     Table(WasmTableType),
     Memory(WasmMemoryType),
+    // No support for eh in the C-API yet.
+    #[allow(unused)]
+    Tag(WasmTagType),
 }
 
 #[allow(non_camel_case_types)]
@@ -66,6 +71,7 @@ impl wasm_externtype_t {
                 ExternType::Memory(memory_type) => {
                     WasmExternType::Memory(WasmMemoryType::new(memory_type))
                 }
+                ExternType::Tag(tag_type) => WasmExternType::Tag(WasmTagType::new(tag_type)),
             },
         }
     }
@@ -110,6 +116,7 @@ pub unsafe extern "C" fn wasm_externtype_kind(
         WasmExternType::Global(_) => wasm_externkind_enum::WASM_EXTERN_GLOBAL,
         WasmExternType::Table(_) => wasm_externkind_enum::WASM_EXTERN_TABLE,
         WasmExternType::Memory(_) => wasm_externkind_enum::WASM_EXTERN_MEMORY,
+        WasmExternType::Tag(_) => wasm_externkind_enum::WASM_EXTERN_TAG,
     }) as wasm_externkind_t
 }
 
diff --git a/lib/c-api/src/wasm_c_api/types/frame.rs b/lib/c-api/src/wasm_c_api/types/frame.rs
index 9cccd95805..4619f1c632 100644
--- a/lib/c-api/src/wasm_c_api/types/frame.rs
+++ b/lib/c-api/src/wasm_c_api/types/frame.rs
@@ -123,5 +123,5 @@ fn test_frame_name() {
         wasm_name_delete(Some(&mut wasm_frame_module_name));
     }
 
-    println!("{:#?}", info);
+    println!("{info:#?}");
 }
diff --git a/lib/c-api/src/wasm_c_api/types/memory.rs b/lib/c-api/src/wasm_c_api/types/memory.rs
index 0cbbba7ce9..a3506925d8 100644
--- a/lib/c-api/src/wasm_c_api/types/memory.rs
+++ b/lib/c-api/src/wasm_c_api/types/memory.rs
@@ -75,7 +75,7 @@ pub struct wasm_limits_t {
     pub max: u32,
 }
 
-const LIMITS_MAX_SENTINEL: u32 = u32::max_value();
+const LIMITS_MAX_SENTINEL: u32 = u32::MAX;
 
 #[no_mangle]
 pub unsafe extern "C" fn wasm_memorytype_limits(memory_type: &wasm_memorytype_t) -> &wasm_limits_t {
diff --git a/lib/c-api/src/wasm_c_api/types/mod.rs b/lib/c-api/src/wasm_c_api/types/mod.rs
index c5b7ed03f6..c6e7c18ef7 100644
--- a/lib/c-api/src/wasm_c_api/types/mod.rs
+++ b/lib/c-api/src/wasm_c_api/types/mod.rs
@@ -7,6 +7,7 @@ mod import;
 mod memory;
 mod mutability;
 mod table;
+mod tag;
 mod value;
 
 pub use export::*;
@@ -18,6 +19,7 @@ pub use import::*;
 pub use memory::*;
 pub use mutability::*;
 pub use table::*;
+use tag::*;
 pub use value::*;
 
 #[allow(non_camel_case_types)]
diff --git a/lib/c-api/src/wasm_c_api/types/table.rs b/lib/c-api/src/wasm_c_api/types/table.rs
index 3affb52296..108f11c0de 100644
--- a/lib/c-api/src/wasm_c_api/types/table.rs
+++ b/lib/c-api/src/wasm_c_api/types/table.rs
@@ -6,7 +6,7 @@ use wasmer_api::{ExternType, TableType};
 #[allow(non_camel_case_types)]
 pub type wasm_table_size_t = u32;
 
-const LIMITS_MAX_SENTINEL: u32 = u32::max_value();
+const LIMITS_MAX_SENTINEL: u32 = u32::MAX;
 
 #[derive(Debug, Clone)]
 pub(crate) struct WasmTableType {
diff --git a/lib/c-api/src/wasm_c_api/types/tag.rs b/lib/c-api/src/wasm_c_api/types/tag.rs
new file mode 100644
index 0000000000..70092047a7
--- /dev/null
+++ b/lib/c-api/src/wasm_c_api/types/tag.rs
@@ -0,0 +1,35 @@
+use wasmer_types::TagType;
+
+use super::wasm_valtype_vec_t;
+
+#[allow(unused)]
+pub(crate) struct WasmTagType {
+    pub(crate) tag_type: TagType,
+    params: wasm_valtype_vec_t,
+}
+
+impl WasmTagType {
+    pub(crate) fn new(tag_type: TagType) -> Self {
+        Self {
+            params: tag_type
+                .params()
+                .iter()
+                .map(|&valtype| Some(Box::new(valtype.into())))
+                .collect::<Vec<_>>()
+                .into(),
+            tag_type,
+        }
+    }
+}
+
+impl Clone for WasmTagType {
+    fn clone(&self) -> Self {
+        Self::new(self.tag_type.clone())
+    }
+}
+
+impl std::fmt::Debug for WasmTagType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.tag_type.fmt(f)
+    }
+}
diff --git a/lib/c-api/src/wasm_c_api/types/value.rs b/lib/c-api/src/wasm_c_api/types/value.rs
index ae2189c311..fc00f9fec3 100644
--- a/lib/c-api/src/wasm_c_api/types/value.rs
+++ b/lib/c-api/src/wasm_c_api/types/value.rs
@@ -10,8 +10,9 @@ pub enum wasm_valkind_enum {
     WASM_I64 = 1,
     WASM_F32 = 2,
     WASM_F64 = 3,
-    WASM_ANYREF = 128,
+    WASM_EXTERNREF = 128,
     WASM_FUNCREF = 129,
+    WASM_EXNREF = 130,
 }
 
 impl From<Type> for wasm_valkind_enum {
@@ -22,8 +23,9 @@ impl From<Type> for wasm_valkind_enum {
             Type::F32 => Self::WASM_F32,
             Type::F64 => Self::WASM_F64,
             Type::V128 => todo!("no v128 type in Wasm C API yet!"),
-            Type::ExternRef => Self::WASM_ANYREF,
+            Type::ExternRef => Self::WASM_EXTERNREF,
             Type::FuncRef => Self::WASM_FUNCREF,
+            Type::ExceptionRef => Self::WASM_EXNREF,
         }
     }
 }
@@ -36,8 +38,9 @@ impl From<wasm_valkind_enum> for Type {
             WASM_I64 => Type::I64,
             WASM_F32 => Type::F32,
             WASM_F64 => Type::F64,
-            WASM_ANYREF => Type::ExternRef,
+            WASM_EXTERNREF => Type::ExternRef,
             WASM_FUNCREF => Type::FuncRef,
+            WASM_EXNREF => Type::ExternRef,
         }
     }
 }
diff --git a/lib/c-api/src/wasm_c_api/unstable/engine.rs b/lib/c-api/src/wasm_c_api/unstable/engine.rs
index fe3d53cb14..6366e39782 100644
--- a/lib/c-api/src/wasm_c_api/unstable/engine.rs
+++ b/lib/c-api/src/wasm_c_api/unstable/engine.rs
@@ -1,56 +1,10 @@
 //! Unstable non-standard Wasmer-specific types for the
 //! `wasm_engine_t` and siblings.
 
-#[cfg(feature = "compiler")]
-use super::super::engine::wasmer_compiler_t;
-use super::super::engine::{wasm_config_t, wasmer_engine_t};
-
-use super::features::wasmer_features_t;
-use super::target_lexicon::wasmer_target_t;
-
-/// Unstable non-standard Wasmer-specific API to update the
-/// configuration to specify a particular target for the engine.
-///
-/// # Example
-///
-/// ```rust
-/// # use wasmer_inline_c::assert_c;
-/// # fn main() {
-/// #    (assert_c! {
-/// # #include "tests/wasmer.h"
-/// #
-/// int main() {
-///     // Create the configuration.
-///     wasm_config_t* config = wasm_config_new();
-///
-///     // Set the target.
-///     {
-///         wasmer_triple_t* triple = wasmer_triple_new_from_host();
-///         wasmer_cpu_features_t* cpu_features = wasmer_cpu_features_new();
-///         wasmer_target_t* target = wasmer_target_new(triple, cpu_features);
-///
-///         wasm_config_set_target(config, target);
-///     }
-///
-///     // Create the engine.
-///     wasm_engine_t* engine = wasm_engine_new_with_config(config);
-///
-///     // Check we have an engine!
-///     assert(engine);
-///
-///     // Free everything.
-///     wasm_engine_delete(engine);
-///
-///     return 0;
-/// }
-/// #    })
-/// #    .success();
-/// # }
-/// ```
-#[no_mangle]
-pub extern "C" fn wasm_config_set_target(config: &mut wasm_config_t, target: Box<wasmer_target_t>) {
-    config.target = Some(target);
-}
+use super::{
+    super::engine::{wasm_config_t, wasmer_backend_t},
+    features::wasmer_features_t,
+};
 
 /// Unstable non-standard Wasmer-specific API to update the
 /// configuration to specify particular features for the engine.
@@ -98,58 +52,6 @@ pub extern "C" fn wasm_config_set_features(
     config.features = Some(features);
 }
 
-/// Updates the configuration to enable NaN canonicalization.
-///
-/// This is a Wasmer-specific function.
-///
-/// # Example
-///
-/// ```rust
-/// # use wasmer_inline_c::assert_c;
-/// # fn main() {
-/// #    (assert_c! {
-/// # #include "tests/wasmer.h"
-/// #
-/// int main() {
-///     // Create the configuration.
-///     wasm_config_t* config = wasm_config_new();
-///
-///     // Enable NaN canonicalization.
-///     wasm_config_canonicalize_nans(config, true);
-///
-///     // Create the engine.
-///     wasm_engine_t* engine = wasm_engine_new_with_config(config);
-///
-///     // Check we have an engine!
-///     assert(engine);
-///
-///     // Free everything.
-///     wasm_engine_delete(engine);
-///
-///     return 0;
-/// }
-/// #    })
-/// #    .success();
-/// # }
-/// ```
-#[no_mangle]
-pub extern "C" fn wasm_config_canonicalize_nans(config: &mut wasm_config_t, enable: bool) {
-    config.nan_canonicalization = enable;
-}
-
-/// Check whether the given compiler is available, i.e. part of this
-/// compiled library.
-#[no_mangle]
-#[cfg(feature = "compiler")]
-pub extern "C" fn wasmer_is_compiler_available(compiler: wasmer_compiler_t) -> bool {
-    match compiler {
-        wasmer_compiler_t::CRANELIFT if cfg!(feature = "cranelift") => true,
-        wasmer_compiler_t::LLVM if cfg!(feature = "llvm") => true,
-        wasmer_compiler_t::SINGLEPASS if cfg!(feature = "singlepass") => true,
-        _ => false,
-    }
-}
-
 /// Check whether there is no compiler available in this compiled
 /// library.
 #[no_mangle]
@@ -157,11 +59,20 @@ pub extern "C" fn wasmer_is_headless() -> bool {
     !cfg!(feature = "compiler")
 }
 
-/// Check whether the given engine is available, i.e. part of this
+/// Check whether the given backend is available, i.e. part of this
 /// compiled library.
 #[no_mangle]
-pub extern "C" fn wasmer_is_engine_available(engine: wasmer_engine_t) -> bool {
-    matches!(engine, wasmer_engine_t::UNIVERSAL if cfg!(feature = "compiler"))
+pub extern "C" fn wasmer_is_backend_available(backend: wasmer_backend_t) -> bool {
+    match backend {
+        wasmer_backend_t::LLVM => cfg!(feature = "llvm"),
+        wasmer_backend_t::CRANELIFT => cfg!(feature = "cranelift"),
+        wasmer_backend_t::SINGLEPASS => cfg!(feature = "singlepass"),
+        wasmer_backend_t::HEADLESS => cfg!(feature = "sys"),
+        wasmer_backend_t::V8 => cfg!(feature = "v8"),
+        wasmer_backend_t::WASMI => cfg!(feature = "wasmi"),
+        wasmer_backend_t::WAMR => cfg!(feature = "wamr"),
+        wasmer_backend_t::JSC => cfg!(feature = "jsc"),
+    }
 }
 
 #[cfg(test)]
@@ -195,7 +106,7 @@ mod tests {
     }
 
     #[test]
-    fn test_wasmer_is_compiler_available() {
+    fn test_wasmer_is_backend_available() {
         set_var(
             "CRANELIFT",
             if cfg!(feature = "cranelift") {
@@ -219,9 +130,9 @@ mod tests {
             #include <stdlib.h>
 
             int main() {
-                assert(wasmer_is_compiler_available(CRANELIFT) == (getenv("CRANELIFT")[0] == '1'));
-                assert(wasmer_is_compiler_available(LLVM) == (getenv("LLVM")[0] == '1'));
-                assert(wasmer_is_compiler_available(SINGLEPASS) == (getenv("SINGLEPASS")[0] == '1'));
+                assert(wasmer_is_backend_available(CRANELIFT) == (getenv("CRANELIFT")[0] == '1'));
+                assert(wasmer_is_backend_available(LLVM) == (getenv("LLVM")[0] == '1'));
+                assert(wasmer_is_backend_available(SINGLEPASS) == (getenv("SINGLEPASS")[0] == '1'));
 
                 return 0;
             }
@@ -232,26 +143,4 @@ mod tests {
         remove_var("LLVM");
         remove_var("SINGLEPASS");
     }
-
-    #[test]
-    fn test_wasmer_is_engine_available() {
-        set_var(
-            "UNIVERSAL",
-            if cfg!(feature = "compiler") { "1" } else { "0" },
-        );
-
-        (assert_c! {
-            #include "tests/wasmer.h"
-            #include <stdlib.h>
-
-            int main() {
-                assert(wasmer_is_engine_available(UNIVERSAL) == (getenv("UNIVERSAL")[0] == '1'));
-
-                return 0;
-            }
-        })
-        .success();
-
-        remove_var("UNIVERSAL");
-    }
 }
diff --git a/lib/c-api/src/wasm_c_api/unstable/middlewares/metering.rs b/lib/c-api/src/wasm_c_api/unstable/middlewares/metering.rs
index 41958eafd5..ba61250e9f 100644
--- a/lib/c-api/src/wasm_c_api/unstable/middlewares/metering.rs
+++ b/lib/c-api/src/wasm_c_api/unstable/middlewares/metering.rs
@@ -206,7 +206,7 @@ pub unsafe extern "C" fn wasmer_metering_get_remaining_points(
 ) -> u64 {
     match get_remaining_points(&mut instance.store.store_mut(), &instance.inner) {
         MeteringPoints::Remaining(value) => value,
-        MeteringPoints::Exhausted => std::u64::MAX,
+        MeteringPoints::Exhausted => u64::MAX,
     }
 }
 
diff --git a/lib/c-api/src/wasm_c_api/unstable/middlewares/mod.rs b/lib/c-api/src/wasm_c_api/unstable/middlewares/mod.rs
index 238154beed..f75b9a27de 100644
--- a/lib/c-api/src/wasm_c_api/unstable/middlewares/mod.rs
+++ b/lib/c-api/src/wasm_c_api/unstable/middlewares/mod.rs
@@ -3,9 +3,8 @@
 
 pub mod metering;
 
-use super::super::engine::wasm_config_t;
 use std::sync::Arc;
-use wasmer_api::ModuleMiddleware;
+use wasmer_api::sys::ModuleMiddleware;
 
 #[cfg(all(feature = "middlewares", not(feature = "compiler")))]
 compile_error!("The `middlewares` feature requires the `compiler` feature to be turned on");
@@ -21,20 +20,3 @@ compile_error!("The `middlewares` feature requires the `compiler` feature to be
 pub struct wasmer_middleware_t {
     pub(in crate::wasm_c_api) inner: Arc<dyn ModuleMiddleware>,
 }
-
-/// Updates the configuration to add a module middleware.
-///
-/// This function takes ownership of `middleware`.
-///
-/// This is a Wasmer-specific function.
-///
-/// # Example
-///
-/// See the documentation of the [`metering`] module.
-#[no_mangle]
-pub extern "C" fn wasm_config_push_middleware(
-    config: &mut wasm_config_t,
-    middleware: Box<wasmer_middleware_t>,
-) {
-    config.middlewares.push(*middleware);
-}
diff --git a/lib/c-api/src/wasm_c_api/unstable/module.rs b/lib/c-api/src/wasm_c_api/unstable/module.rs
index 7fdbf88114..c5b3ddc6d0 100644
--- a/lib/c-api/src/wasm_c_api/unstable/module.rs
+++ b/lib/c-api/src/wasm_c_api/unstable/module.rs
@@ -172,7 +172,7 @@ pub unsafe extern "C" fn wasmer_module_new(
     engine: Option<&mut wasm_engine_t>,
     bytes: Option<&wasm_byte_vec_t>,
 ) -> Option<Box<wasm_module_t>> {
-    let engine: wasmer_api::Engine = engine?.inner.clone().into();
+    let engine: wasmer_api::Engine = engine?.inner.clone();
     let bytes = bytes?;
 
     let module = c_try!(Module::from_binary(&engine, bytes.as_slice()));
diff --git a/lib/c-api/src/wasm_c_api/unstable/target_lexicon.rs b/lib/c-api/src/wasm_c_api/unstable/target_lexicon.rs
index b24c3da647..183e27499e 100644
--- a/lib/c-api/src/wasm_c_api/unstable/target_lexicon.rs
+++ b/lib/c-api/src/wasm_c_api/unstable/target_lexicon.rs
@@ -57,7 +57,7 @@ use super::super::types::wasm_name_t;
 use enumset::EnumSet;
 use std::slice;
 use std::str::{self, FromStr};
-use wasmer_api::{CpuFeature, Target, Triple};
+use wasmer_types::target::{CpuFeature, Target, Triple};
 
 /// Unstable non-standard Wasmer-specific API to represent a triple +
 /// CPU features pair.
diff --git a/lib/c-api/src/wasm_c_api/value.rs b/lib/c-api/src/wasm_c_api/value.rs
index 737975fa88..a678751ba4 100644
--- a/lib/c-api/src/wasm_c_api/value.rs
+++ b/lib/c-api/src/wasm_c_api/value.rs
@@ -9,7 +9,7 @@ use wasmer_api::Value;
 /// * `WASM_I64`, a 64-bit integer,
 /// * `WASM_F32`, a 32-bit float,
 /// * `WASM_F64`, a 64-bit float,
-/// * `WASM_ANYREF`, a WebAssembly reference,
+/// * `WASM_EXTERNREF`, a WebAssembly reference,
 /// * `WASM_FUNCREF`, a WebAssembly reference.
 #[allow(non_camel_case_types)]
 pub type wasm_valkind_t = u8;
@@ -94,13 +94,15 @@ impl std::fmt::Debug for wasm_val_t {
             Ok(wasm_valkind_enum::WASM_F64) => {
                 ds.field("f64", &unsafe { self.of.float64_t });
             }
-            Ok(wasm_valkind_enum::WASM_ANYREF) => {
+            Ok(wasm_valkind_enum::WASM_EXTERNREF) => {
                 ds.field("anyref", &unsafe { self.of.wref });
             }
-
             Ok(wasm_valkind_enum::WASM_FUNCREF) => {
                 ds.field("funcref", &unsafe { self.of.wref });
             }
+            Ok(wasm_valkind_enum::WASM_EXNREF) => {
+                ds.field("exnref", &unsafe { self.of.wref });
+            }
             Err(_) => {
                 ds.field("value", &"Invalid value type");
             }
@@ -150,17 +152,31 @@ pub unsafe extern "C" fn wasm_val_copy(
             wasm_valkind_enum::WASM_F64 => wasm_val_inner {
                 float64_t: val.of.float64_t,
             },
-            wasm_valkind_enum::WASM_ANYREF => wasm_val_inner { wref: val.of.wref },
+            wasm_valkind_enum::WASM_EXTERNREF => wasm_val_inner { wref: val.of.wref },
             wasm_valkind_enum::WASM_FUNCREF => wasm_val_inner { wref: val.of.wref },
+            wasm_valkind_enum::WASM_EXNREF => wasm_val_inner { wref: val.of.wref },
         }
     }); otherwise ());
 }
 
+impl Drop for wasm_val_t {
+    fn drop(&mut self) {
+        let kind: Result<wasm_valkind_enum, _> = self.kind.try_into();
+        match kind {
+            Ok(wasm_valkind_enum::WASM_EXTERNREF) | Ok(wasm_valkind_enum::WASM_FUNCREF) => unsafe {
+                if !self.of.wref.is_null() {
+                    drop(Box::from_raw(self.of.wref));
+                }
+            },
+            _ => {}
+        }
+    }
+}
+
 #[no_mangle]
-pub unsafe extern "C" fn wasm_val_delete(val: Option<Box<wasm_val_t>>) {
-    if let Some(val) = val {
-        // TODO: figure out where wasm_val is allocated first...
-        let _ = val;
+pub unsafe extern "C" fn wasm_val_delete(val: *mut wasm_val_t) {
+    if !val.is_null() {
+        std::ptr::drop_in_place(val);
     }
 }
 
@@ -173,8 +189,9 @@ impl TryFrom<wasm_valkind_t> for wasm_valkind_enum {
             1 => wasm_valkind_enum::WASM_I64,
             2 => wasm_valkind_enum::WASM_F32,
             3 => wasm_valkind_enum::WASM_F64,
-            128 => wasm_valkind_enum::WASM_ANYREF,
+            128 => wasm_valkind_enum::WASM_EXTERNREF,
             129 => wasm_valkind_enum::WASM_FUNCREF,
+            130 => wasm_valkind_enum::WASM_EXNREF,
             _ => return Err("valkind value out of bounds"),
         })
     }
@@ -197,8 +214,11 @@ impl TryFrom<&wasm_val_t> for Value {
             wasm_valkind_enum::WASM_I64 => Value::I64(unsafe { item.of.int64_t }),
             wasm_valkind_enum::WASM_F32 => Value::F32(unsafe { item.of.float32_t }),
             wasm_valkind_enum::WASM_F64 => Value::F64(unsafe { item.of.float64_t }),
-            wasm_valkind_enum::WASM_ANYREF => return Err("ANYREF not supported at this time"),
+            wasm_valkind_enum::WASM_EXTERNREF => {
+                return Err("EXTERNREF not supported at this time")
+            }
             wasm_valkind_enum::WASM_FUNCREF => return Err("FUNCREF not supported at this time"),
+            wasm_valkind_enum::WASM_EXNREF => return Err("EXNREF not supported at this time"),
         })
     }
 }
diff --git a/lib/c-api/src/wasm_c_api/version.rs b/lib/c-api/src/wasm_c_api/version.rs
index 337ad738b5..6f1dd0b85b 100644
--- a/lib/c-api/src/wasm_c_api/version.rs
+++ b/lib/c-api/src/wasm_c_api/version.rs
@@ -1,20 +1,24 @@
-use lazy_static::lazy_static;
 use std::os::raw::c_char;
+use std::sync::LazyLock;
 
 const VERSION: &str = concat!(env!("CARGO_PKG_VERSION"), "\0");
 const VERSION_PRE: &str = concat!(env!("CARGO_PKG_VERSION_PRE"), "\0");
 
-lazy_static! {
-    static ref VERSION_MAJOR: u8 = env!("CARGO_PKG_VERSION_MAJOR")
+static VERSION_MAJOR: LazyLock<u8> = LazyLock::new(|| {
+    env!("CARGO_PKG_VERSION_MAJOR")
         .parse()
-        .expect("Failed to parse value for `VERSION_MAJOR` from `CARGO_PKG_VERSION_MAJOR`");
-    static ref VERSION_MINOR: u8 = env!("CARGO_PKG_VERSION_MINOR")
+        .expect("Failed to parse value for `VERSION_MAJOR` from `CARGO_PKG_VERSION_MAJOR`")
+});
+static VERSION_MINOR: LazyLock<u8> = LazyLock::new(|| {
+    env!("CARGO_PKG_VERSION_MINOR")
         .parse()
-        .expect("Failed to parse value for `VERSION_MINOR` from `CARGO_PKG_VERSION_MINOR`");
-    static ref VERSION_PATCH: u8 = env!("CARGO_PKG_VERSION_PATCH")
+        .expect("Failed to parse value for `VERSION_MINOR` from `CARGO_PKG_VERSION_MINOR`")
+});
+static VERSION_PATCH: LazyLock<u8> = LazyLock::new(|| {
+    env!("CARGO_PKG_VERSION_PATCH")
         .parse()
-        .expect("Failed to parse value for `VERSION_PATCH` from `CARGO_PKG_VERSION_PATCH`");
-}
+        .expect("Failed to parse value for `VERSION_PATCH` from `CARGO_PKG_VERSION_PATCH`")
+});
 
 /// Get the version of the Wasmer C API.
 ///
diff --git a/lib/c-api/src/wasm_c_api/wasi/mod.rs b/lib/c-api/src/wasm_c_api/wasi/mod.rs
index d504d22f05..72243b7d2a 100644
--- a/lib/c-api/src/wasm_c_api/wasi/mod.rs
+++ b/lib/c-api/src/wasm_c_api/wasi/mod.rs
@@ -275,7 +275,7 @@ fn prepare_webc_env(
     let handle = runtime.handle().clone();
     let _guard = handle.enter();
     let mut rt = PluggableRuntime::new(Arc::new(TokioTaskManager::new(runtime)));
-    rt.set_engine(Some(store_mut.engine().clone()));
+    rt.set_engine(store_mut.engine().clone());
 
     let slice = unsafe { std::slice::from_raw_parts(bytes, len) };
     let volumes = WebC::parse_volumes_from_fileblock(slice).ok()?;
@@ -348,7 +348,7 @@ pub unsafe extern "C" fn wasi_env_new(
     let handle = runtime.handle().clone();
     let _guard = handle.enter();
     let mut rt = PluggableRuntime::new(Arc::new(TokioTaskManager::new(runtime)));
-    rt.set_engine(Some(store_mut.engine().clone()));
+    rt.set_engine(store_mut.engine().clone());
 
     if !config.inherit_stdout {
         config.builder.set_stdout(Box::new(Pipe::channel().0));
@@ -450,7 +450,7 @@ fn read_inner(
         match wasi_file.read(inner_buffer).await {
             Ok(a) => a as isize,
             Err(err) => {
-                update_last_error(format!("failed to read wasi_file: {}", err));
+                update_last_error(format!("failed to read wasi_file: {err}"));
                 -1
             }
         }
@@ -553,8 +553,8 @@ unsafe fn wasi_get_imports_inner(
     let shared_memory = module.inner.imports().memories().next().map(|a| *a.ty());
 
     let spawn_type = match shared_memory {
-        Some(ty) => wasmer_wasix::runtime::SpawnMemoryType::CreateMemoryOfType(ty),
-        None => wasmer_wasix::runtime::SpawnMemoryType::CreateMemory,
+        Some(ty) => wasmer_wasix::runtime::SpawnType::CreateMemoryOfType(ty),
+        None => wasmer_wasix::runtime::SpawnType::CreateMemory,
     };
 
     let tasks = wasi_env
@@ -564,7 +564,7 @@ unsafe fn wasi_get_imports_inner(
         .task_manager()
         .clone();
     let memory = tasks
-        .build_memory(&mut store.store_mut(), spawn_type)
+        .build_memory(&mut store.store_mut(), &spawn_type)
         .unwrap();
 
     if let Some(memory) = memory {
diff --git a/lib/c-api/tests/wasm-c-api/example/callback.c b/lib/c-api/tests/wasm-c-api/example/callback.c
index 2fddb1634f..a575397463 100644
--- a/lib/c-api/tests/wasm-c-api/example/callback.c
+++ b/lib/c-api/tests/wasm-c-api/example/callback.c
@@ -22,7 +22,7 @@ void wasm_val_print(wasm_val_t val) {
     case WASM_F64: {
       printf("%g", val.of.f64);
     } break;
-    case WASM_ANYREF:
+    case WASM_EXTERNREF:
     case WASM_FUNCREF: {
       if (val.of.ref == NULL) {
         printf("null");
diff --git a/lib/c-api/tests/wasm-c-api/example/hostref.c b/lib/c-api/tests/wasm-c-api/example/hostref.c
index 1e787ab190..ae23584033 100644
--- a/lib/c-api/tests/wasm-c-api/example/hostref.c
+++ b/lib/c-api/tests/wasm-c-api/example/hostref.c
@@ -159,7 +159,7 @@ int main(int argc, const char* argv[]) {
   // Create external callback function.
   printf("Creating callback...\n");
   own wasm_functype_t* callback_type = wasm_functype_new_1_1(
-    wasm_valtype_new(WASM_ANYREF), wasm_valtype_new(WASM_ANYREF));
+    wasm_valtype_new(WASM_EXTERNREF), wasm_valtype_new(WASM_EXTERNREF));
   own wasm_func_t* callback_func =
     wasm_func_new(store, callback_type, callback);
 
@@ -207,7 +207,7 @@ int main(int argc, const char* argv[]) {
   check(wasm_ref_copy(host2), host2);
 
   own wasm_val_t val;
-  val.kind = WASM_ANYREF;
+  val.kind = WASM_EXTERNREF;
   val.of.ref = wasm_ref_copy(host1);
   check(wasm_ref_copy(val.of.ref), host1);
   own wasm_ref_t* ref = val.of.ref;
@@ -225,13 +225,13 @@ int main(int argc, const char* argv[]) {
   check(call_v_r(global_get), NULL);
 
   wasm_global_get(global, &val);
-  assert(val.kind == WASM_ANYREF);
+  assert(val.kind == WASM_EXTERNREF);
   check(val.of.ref, NULL);
   val.of.ref = host2;
   wasm_global_set(global, &val);
   check(call_v_r(global_get), host2);
   wasm_global_get(global, &val);
-  assert(val.kind == WASM_ANYREF);
+  assert(val.kind == WASM_EXTERNREF);
   check(val.of.ref, host2);
 
   printf("Accessing table...\n");
diff --git a/lib/c-api/tests/wasm-c-api/example/reflect.c b/lib/c-api/tests/wasm-c-api/example/reflect.c
index d4383185ff..0a7099fe07 100644
--- a/lib/c-api/tests/wasm-c-api/example/reflect.c
+++ b/lib/c-api/tests/wasm-c-api/example/reflect.c
@@ -25,7 +25,7 @@ void print_valtype(const wasm_valtype_t* type) {
     case WASM_I64: printf("i64"); break;
     case WASM_F32: printf("f32"); break;
     case WASM_F64: printf("f64"); break;
-    case WASM_ANYREF: printf("anyref"); break;
+    case WASM_EXTERNREF: printf("externref"); break;
     case WASM_FUNCREF: printf("funcref"); break;
   }
 }
diff --git a/lib/c-api/tests/wasm-c-api/example/reflect.wat b/lib/c-api/tests/wasm-c-api/example/reflect.wat
index 261dfd3c33..7a80e86dde 100644
--- a/lib/c-api/tests/wasm-c-api/example/reflect.wat
+++ b/lib/c-api/tests/wasm-c-api/example/reflect.wat
@@ -1,6 +1,6 @@
 (module
   (func (export "func") (param i32 f64 f32) (result i32) (unreachable))
   (global (export "global") f64 (f64.const 0))
-  (table (export "table") 0 50 anyfunc)
+  (table (export "table") 0 50 funcref)
   (memory (export "memory") 1)
 )
diff --git a/lib/c-api/tests/wasm-c-api/include/wasm.h b/lib/c-api/tests/wasm-c-api/include/wasm.h
index 7b38fe33e1..58115fa386 100644
--- a/lib/c-api/tests/wasm-c-api/include/wasm.h
+++ b/lib/c-api/tests/wasm-c-api/include/wasm.h
@@ -186,7 +186,7 @@ enum wasm_valkind_enum {
   WASM_I64,
   WASM_F32,
   WASM_F64,
-  WASM_ANYREF = 128,
+  WASM_EXTERNREF = 128,
   WASM_FUNCREF,
 };
 
@@ -195,10 +195,10 @@ WASM_API_EXTERN own wasm_valtype_t* wasm_valtype_new(wasm_valkind_t);
 WASM_API_EXTERN wasm_valkind_t wasm_valtype_kind(const wasm_valtype_t*);
 
 static inline bool wasm_valkind_is_num(wasm_valkind_t k) {
-  return k < WASM_ANYREF;
+  return k < WASM_EXTERNREF ;
 }
 static inline bool wasm_valkind_is_ref(wasm_valkind_t k) {
-  return k >= WASM_ANYREF;
+  return k >= WASM_EXTERNREF ;
 }
 
 static inline bool wasm_valtype_is_num(const wasm_valtype_t* t) {
@@ -551,8 +551,8 @@ static inline own wasm_valtype_t* wasm_valtype_new_f64() {
   return wasm_valtype_new(WASM_F64);
 }
 
-static inline own wasm_valtype_t* wasm_valtype_new_anyref() {
-  return wasm_valtype_new(WASM_ANYREF);
+static inline own wasm_valtype_t* wasm_valtype_new_externref() {
+  return wasm_valtype_new(WASM_EXTERNREF);
 }
 static inline own wasm_valtype_t* wasm_valtype_new_funcref() {
   return wasm_valtype_new(WASM_FUNCREF);
@@ -712,8 +712,8 @@ static inline void* wasm_val_ptr(const wasm_val_t* val) {
 #define WASM_I64_VAL(i) {.kind = WASM_I64, .of = {.i64 = i}}
 #define WASM_F32_VAL(z) {.kind = WASM_F32, .of = {.f32 = z}}
 #define WASM_F64_VAL(z) {.kind = WASM_F64, .of = {.f64 = z}}
-#define WASM_REF_VAL(r) {.kind = WASM_ANYREF, .of = {.ref = r}}
-#define WASM_INIT_VAL {.kind = WASM_ANYREF, .of = {.ref = NULL}}
+#define WASM_REF_VAL(r) {.kind = WASM_EXTERNREF, .of = {.ref = r}}
+#define WASM_INIT_VAL {.kind = WASM_EXTERNREF, .of = {.ref = NULL}}
 
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/lib/c-api/tests/wasm.h b/lib/c-api/tests/wasm.h
index 1582dd0ec5..cdc463873f 100644
--- a/lib/c-api/tests/wasm.h
+++ b/lib/c-api/tests/wasm.h
@@ -16,30 +16,36 @@
 wasm_engine_t *wasm_engine_new() {
   wasm_config_t *config = wasm_config_new();
 
-  char *wasmer_test_compiler = getenv("WASMER_CAPI_CONFIG");
+  char *wasmer_test_backend = getenv("WASMER_CAPI_CONFIG");
   char *wasmer_test_engine;
 
-  strtok_r(wasmer_test_compiler, "-", &wasmer_test_engine);
-  printf("Using compiler: %s, engine: %s\n", wasmer_test_compiler,
-         wasmer_test_engine);
-  if (strcmp(wasmer_test_compiler, "cranelift") == 0) {
-    assert(wasmer_is_compiler_available(CRANELIFT));
-    wasm_config_set_compiler(config, CRANELIFT);
-  } else if (strcmp(wasmer_test_compiler, "llvm") == 0) {
-    assert(wasmer_is_compiler_available(LLVM));
-    wasm_config_set_compiler(config, LLVM);
-  } else if (strcmp(wasmer_test_compiler, "singlepass") == 0) {
-    assert(wasmer_is_compiler_available(SINGLEPASS));
-    wasm_config_set_compiler(config, SINGLEPASS);
-  } else if (wasmer_test_compiler) {
-    printf("Compiler %s not recognized\n", wasmer_test_compiler);
-    abort();
-  }
-  if (strcmp(wasmer_test_engine, "universal") == 0) {
-    assert(wasmer_is_engine_available(UNIVERSAL));
-    wasm_config_set_engine(config, UNIVERSAL);
-  } else if (wasmer_test_engine) {
-    printf("Engine %s not recognized\n", wasmer_test_engine);
+  printf("Using backend: %s\n", wasmer_test_backend);
+
+  strtok_r(wasmer_test_backend, "-", &wasmer_test_engine);
+
+  if (strcmp(wasmer_test_backend, "cranelift") == 0) {
+    assert(wasmer_is_backend_available(CRANELIFT));
+    wasm_config_set_backend(config, CRANELIFT);
+  } else if (strcmp(wasmer_test_backend, "llvm") == 0) {
+    assert(wasmer_is_backend_available(LLVM));
+    wasm_config_set_backend(config, LLVM);
+  } else if (strcmp(wasmer_test_backend, "singlepass") == 0) {
+    assert(wasmer_is_backend_available(SINGLEPASS));
+    wasm_config_set_backend(config, SINGLEPASS);
+  } else if (strcmp(wasmer_test_backend, "headless") == 0) {
+    assert(wasmer_is_backend_available(HEADLESS));
+    wasm_config_set_backend(config, HEADLESS);
+  } else if (strcmp(wasmer_test_backend, "v8") == 0) {
+    assert(wasmer_is_backend_available(V8));
+    wasm_config_set_backend(config, V8);
+  } else if (strcmp(wasmer_test_backend, "wamr") == 0) {
+    assert(wasmer_is_backend_available(WAMR));
+    wasm_config_set_backend(config, WAMR);
+  } else if (strcmp(wasmer_test_backend, "wasmi") == 0) {
+    assert(wasmer_is_backend_available(WASMI));
+    wasm_config_set_backend(config, WASMI);
+  } else if (wasmer_test_backend) {
+    printf("Compiler %s not recognized\n", wasmer_test_backend);
     abort();
   }
 
diff --git a/lib/c-api/tests/wasmer-c-api-test-runner/Cargo.toml b/lib/c-api/tests/wasmer-c-api-test-runner/Cargo.toml
index 0c445a2096..e4e7259427 100644
--- a/lib/c-api/tests/wasmer-c-api-test-runner/Cargo.toml
+++ b/lib/c-api/tests/wasmer-c-api-test-runner/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "wasmer-c-api-test-runner"
-version = "4.3.7"
+version = "6.1.0"
 edition = "2021"
 license = "MIT"
 description = "wasmer-c-api-test-runner"
diff --git a/lib/c-api/tests/wasmer-c-api-test-runner/src/lib.rs b/lib/c-api/tests/wasmer-c-api-test-runner/src/lib.rs
index 5abe14c39e..4ac8ca8e3c 100644
--- a/lib/c-api/tests/wasmer-c-api-test-runner/src/lib.rs
+++ b/lib/c-api/tests/wasmer-c-api-test-runner/src/lib.rs
@@ -115,7 +115,7 @@ pub const CAPI_BASE_TESTS_NOT_WORKING: &[&str] = &[
 fn test_ok() {
     let _drop = RemoveTestsOnDrop::default();
     let config = Config::get();
-    println!("config: {:#?}", config);
+    println!("config: {config:#?}");
 
     let manifest_dir = env!("CARGO_MANIFEST_DIR");
     let host = target_lexicon::HOST.to_string();
@@ -143,7 +143,7 @@ fn test_ok() {
 
             let compiler = build.try_get_compiler().unwrap();
 
-            println!("compiler {:#?}", compiler);
+            println!("compiler {compiler:#?}");
 
             // run vcvars
             let vcvars_bat_path = find_vcvars64(&compiler).expect("no vcvars64.bat");
@@ -167,12 +167,12 @@ fn test_ok() {
 
             let mut command = compiler.to_command();
 
-            command.arg(&format!("{manifest_dir}/../{test}.c"));
+            command.arg(format!("{manifest_dir}/../{test}.c"));
             if !config.wasmer_dir.is_empty() {
                 command.arg("/I");
-                command.arg(&format!("{}/wasm-c-api/include/", config.root_dir));
+                command.arg(format!("{}/wasm-c-api/include/", config.root_dir));
                 command.arg("/I");
-                command.arg(&format!("{}/include/", config.wasmer_dir));
+                command.arg(format!("{}/include/", config.wasmer_dir));
                 let mut log = String::new();
                 fixup_symlinks(
                     &[
@@ -188,10 +188,10 @@ fn test_ok() {
             }
             command.arg("/link");
             if !config.wasmer_dir.is_empty() {
-                command.arg(&format!("/LIBPATH:{}/lib", config.wasmer_dir));
-                command.arg(&format!("{}/lib/wasmer.dll.lib", config.wasmer_dir));
+                command.arg(format!("/LIBPATH:{}/lib", config.wasmer_dir));
+                command.arg(format!("{}/lib/wasmer.dll.lib", config.wasmer_dir));
             }
-            command.arg(&format!("/OUT:{manifest_dir}/../{test}.exe"));
+            command.arg(format!("/OUT:{manifest_dir}/../{test}.exe"));
 
             println!("compiling {test}: {command:?}");
 
@@ -202,7 +202,7 @@ fn test_ok() {
             if !output.status.success() {
                 println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
                 println!("stderr: {}", String::from_utf8_lossy(&output.stderr));
-                println!("output: {:#?}", output);
+                println!("output: {output:#?}");
                 // print_wasmer_root_to_stdout(&config);
                 panic!("failed to compile {test}");
             }
@@ -212,7 +212,7 @@ fn test_ok() {
             }
 
             // execute
-            let mut command = std::process::Command::new(&format!("{manifest_dir}/../{test}.exe"));
+            let mut command = std::process::Command::new(format!("{manifest_dir}/../{test}.exe"));
             println!("newpath: {}", newpath.clone());
             command.env("PATH", newpath.clone());
             command.current_dir(exe_dir.clone());
@@ -224,7 +224,7 @@ fn test_ok() {
             if !output.status.success() {
                 println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
                 println!("stderr: {}", String::from_utf8_lossy(&output.stderr));
-                println!("output: {:#?}", output);
+                println!("output: {output:#?}");
                 // print_wasmer_root_to_stdout(&config);
                 panic!("failed to execute {test}");
             }
@@ -250,9 +250,9 @@ fn test_ok() {
 
             if !config.wasmer_dir.is_empty() {
                 command.arg("-I");
-                command.arg(&format!("{}/wasm-c-api/include/", config.root_dir));
+                command.arg(format!("{}/wasm-c-api/include/", config.root_dir));
                 command.arg("-I");
-                command.arg(&format!("{}/include/", config.wasmer_dir));
+                command.arg(format!("{}/include/", config.wasmer_dir));
                 let mut log = String::new();
                 fixup_symlinks(
                     &[
@@ -265,15 +265,15 @@ fn test_ok() {
                 )
                 .unwrap_or_else(|_| panic!("failed to fix symlinks: {log}"));
             }
-            command.arg(&format!("{manifest_dir}/../{test}.c"));
+            command.arg(format!("{manifest_dir}/../{test}.c"));
             if !config.wasmer_dir.is_empty() {
                 command.arg("-L");
-                command.arg(&format!("{}/lib/", config.wasmer_dir));
+                command.arg(format!("{}/lib/", config.wasmer_dir));
                 command.arg("-lwasmer");
-                command.arg(&format!("-Wl,-rpath,{}/lib/", config.wasmer_dir));
+                command.arg(format!("-Wl,-rpath,{}/lib/", config.wasmer_dir));
             }
             command.arg("-o");
-            command.arg(&format!("{manifest_dir}/../{test}"));
+            command.arg(format!("{manifest_dir}/../{test}"));
 
             // print_wasmer_root_to_stdout(&config);
 
@@ -293,7 +293,7 @@ fn test_ok() {
             }
 
             // execute
-            let mut command = std::process::Command::new(&format!("{manifest_dir}/../{test}"));
+            let mut command = std::process::Command::new(format!("{manifest_dir}/../{test}"));
             command.env("LD_PRELOAD", libwasmer_so_path.clone());
             command.current_dir(exe_dir.clone());
             println!("execute: {command:#?}");
@@ -310,9 +310,9 @@ fn test_ok() {
     }
 
     for test in CAPI_BASE_TESTS.iter() {
-        let _ = std::fs::remove_file(&format!("{manifest_dir}/{test}.obj"));
-        let _ = std::fs::remove_file(&format!("{manifest_dir}/../{test}.exe"));
-        let _ = std::fs::remove_file(&format!("{manifest_dir}/../{test}"));
+        let _ = std::fs::remove_file(format!("{manifest_dir}/{test}.obj"));
+        let _ = std::fs::remove_file(format!("{manifest_dir}/../{test}.exe"));
+        let _ = std::fs::remove_file(format!("{manifest_dir}/../{test}"));
     }
 }
 
@@ -411,7 +411,7 @@ fn fixup_symlinks_inner(include_paths: &[String], log: &mut String) -> Result<()
             _ => continue,
         };
         let lines_3 = file.lines().take(3).collect::<Vec<_>>();
-        log.push_str(&format!("first 3 lines of {path:?}: {:#?}\n", lines_3));
+        log.push_str(&format!("first 3 lines of {path:?}: {lines_3:#?}\n"));
 
         let parent = std::path::Path::new(&path).parent().unwrap();
         if let Ok(symlink) = std::fs::read_to_string(parent.join(&file)) {
@@ -424,7 +424,7 @@ fn fixup_symlinks_inner(include_paths: &[String], log: &mut String) -> Result<()
             .captures_iter(&file)
             .map(|c| c[1].to_string())
             .collect::<Vec<_>>();
-        log.push_str(&format!("regex captures: ({path:?}): {:#?}\n", filepaths));
+        log.push_str(&format!("regex captures: ({path:?}): {filepaths:#?}\n"));
         let joined_filepaths = filepaths
             .iter()
             .map(|s| {
diff --git a/lib/cache/Cargo.toml b/lib/cache/Cargo.toml
index 447e697a37..2dc69b3b80 100644
--- a/lib/cache/Cargo.toml
+++ b/lib/cache/Cargo.toml
@@ -13,10 +13,10 @@ rust-version.workspace = true
 version.workspace = true
 
 [dependencies]
-wasmer = { path = "../api", version = "=4.3.7", default-features = false }
-hex = "0.4"
-thiserror = "1"
-blake3 = "1.0"
+wasmer = { path = "../api", version = "=6.1.0", default-features = false }
+hex.workspace = true
+thiserror.workspace = true
+blake3.workspace = true
 
 [dev-dependencies]
 criterion = { version = "0.5", default-features = false }
@@ -24,10 +24,10 @@ clap = { version = "=4.4.11" }
 clap_builder = { version = "=4.4.11" }
 clap_derive = { version = "=4.4.7" }
 clap_lex = { version = "=0.6.0" }
-tempfile = "3.6.0"
+tempfile.workspace = true
 rand = "0.8.3"
-wasmer = { path = "../api", version = "=4.3.7", default-features = false, features = ["sys", "cranelift"] }
-wasmer-compiler-singlepass = { path = "../compiler-singlepass", version = "=4.3.7" }
+wasmer = { path = "../api", version = "=6.1.0", default-features = false, features = ["sys", "cranelift"] }
+wasmer-compiler-singlepass = { path = "../compiler-singlepass", version = "=6.1.0" }
 
 [features]
 default = ["filesystem"]
@@ -35,5 +35,5 @@ filesystem = []
 blake3-pure = ["blake3/pure"]
 
 [package.metadata.docs.rs]
-features = ["wasmer/sys"]
+features = ["wasmer/sys", "wasmer/compiler"]
 rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/cache/src/filesystem.rs b/lib/cache/src/filesystem.rs
index 2efd11301f..dabec09f28 100644
--- a/lib/cache/src/filesystem.rs
+++ b/lib/cache/src/filesystem.rs
@@ -98,7 +98,7 @@ impl Cache for FileSystemCache {
         key: Hash,
     ) -> Result<Module, Self::DeserializeError> {
         let filename = if let Some(ref ext) = self.ext {
-            format!("{}.{}", key, ext)
+            format!("{key}.{ext}")
         } else {
             key.to_string()
         };
@@ -114,7 +114,7 @@ impl Cache for FileSystemCache {
 
     fn store(&mut self, key: Hash, module: &Module) -> Result<(), Self::SerializeError> {
         let filename = if let Some(ref ext) = self.ext {
-            format!("{}.{}", key, ext)
+            format!("{key}.{ext}")
         } else {
             key.to_string()
         };
diff --git a/lib/cache/src/hash.rs b/lib/cache/src/hash.rs
index e29fb7cfa3..2c1b8a070b 100644
--- a/lib/cache/src/hash.rs
+++ b/lib/cache/src/hash.rs
@@ -46,8 +46,7 @@ impl FromStr for Hash {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let bytes = hex::decode(s).map_err(|e| {
             DeserializeError::Generic(format!(
-                "Could not decode prehashed key as hexadecimal: {}",
-                e
+                "Could not decode prehashed key as hexadecimal: {e}",
             ))
         })?;
         if bytes.len() != 32 {
@@ -56,7 +55,7 @@ impl FromStr for Hash {
             ));
         }
         Ok(Self(bytes[0..32].try_into().map_err(|e| {
-            DeserializeError::Generic(format!("Could not get first 32 bytes: {}", e))
+            DeserializeError::Generic(format!("Could not get first 32 bytes: {e}"))
         })?))
     }
 }
diff --git a/lib/cli-compiler/Cargo.toml b/lib/cli-compiler/Cargo.toml
index 0065dc0703..dfc5c3de3d 100644
--- a/lib/cli-compiler/Cargo.toml
+++ b/lib/cli-compiler/Cargo.toml
@@ -20,40 +20,48 @@ path = "src/bin/wasmer_compiler.rs"
 doc = false
 
 [dependencies]
-wasmer-compiler = { version = "=4.3.7", path = "../compiler", features = ["compiler"] }
-wasmer-types = { version = "=4.3.7", path = "../types" }
+wasmer-compiler = { version = "=6.1.0", path = "../compiler", features = [
+	"compiler",
+] }
+wasmer-types = { version = "=6.1.0", path = "../types", features = ["detect-wasm-features"] }
 is-terminal = "0.4.7"
 colored = "2.0"
-anyhow = "1.0"
+anyhow.workspace = true
 # For the function names autosuggestion
 distance = "0.4"
 # For the inspect subcommand
 bytesize = "1.0"
-cfg-if = "1.0"
+cfg-if.workspace = true
 # For debug feature
 fern = { version = "0.6", features = ["colored"], optional = true }
-log = { version = "0.4", optional = true }
-target-lexicon = { version = "0.12", features = ["std"] }
+log = { workspace = true, optional = true }
+target-lexicon = { workspace = true, features = ["std"] }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-wasmer-compiler-singlepass = { version = "=4.3.7", path = "../compiler-singlepass", optional = true }
-wasmer-compiler-cranelift = { version = "=4.3.7", path = "../compiler-cranelift", optional = true }
-clap = { version = "4.3.7", features = ["derive", "env"] }
+wasmer-compiler-singlepass = { version = "=6.1.0", path = "../compiler-singlepass", optional = true }
+wasmer-compiler-cranelift = { version = "=6.1.0", path = "../compiler-cranelift", optional = true }
+wasmer-compiler-llvm = { version = "=6.1.0", path = "../compiler-llvm", optional = true }
+clap = { version = "4.4.0", features = ["derive", "env"] }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
-wasmer-compiler-singlepass = { version = "=4.3.7", path = "../compiler-singlepass", optional = true, default-features = false, features = ["wasm"] }
-wasmer-compiler-cranelift = { version = "=4.3.7", path = "../compiler-cranelift", optional = true, default-features = false, features = ["wasm"] }
+wasmer-compiler-singlepass = { version = "=6.1.0", path = "../compiler-singlepass", optional = true, default-features = false, features = [
+	"wasm",
+] }
+wasmer-compiler-cranelift = { version = "=6.1.0", path = "../compiler-cranelift", optional = true, default-features = false, features = [
+	"wasm",
+] }
+wasmer-compiler-llvm = { version = "=6.1.0", path = "../compiler-llvm",  optional = true, default-features = false, features = [] }
 # NOTE: Must use different features for clap because the "color" feature does not
 # work on wasi, due to the anstream dependency not compiling.
-clap = { version = "4.3.7", default-features = false, features = [
-  "std",
-  "help",
-  "usage",
-  "error-context",
-  "suggestions",
-  "derive",
-  "env",
-]}
+clap = { version = "4.4.0", default-features = false, features = [
+	"std",
+	"help",
+	"usage",
+	"error-context",
+	"suggestions",
+	"derive",
+	"env",
+] }
 
 [target.'cfg(target_os = "linux")'.dependencies]
 unix_mode = "0.1.3"
@@ -63,21 +71,13 @@ unix_mode = "0.1.3"
 # since we might want to autoconfigure them depending on the availability on the host.
 default = []
 engine = []
-compiler = [
-    "wasmer-compiler/translator",
-    "wasmer-compiler/compiler",
-]
-singlepass = [
-    "wasmer-compiler-singlepass",
-    "compiler",
-]
-cranelift = [
-    "wasmer-compiler-cranelift",
-    "compiler",
-]
+compiler = ["wasmer-compiler/translator", "wasmer-compiler/compiler"]
+singlepass = ["wasmer-compiler-singlepass", "compiler"]
+cranelift = ["wasmer-compiler-cranelift", "compiler"]
 debug = ["fern", "log"]
 disable-all-logging = []
 jit = []
+llvm = ["wasmer-compiler-llvm"]
 
 [package.metadata.docs.rs]
 rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/cli-compiler/README.md b/lib/cli-compiler/README.md
index 5fb713d090..a4cba6cee9 100644
--- a/lib/cli-compiler/README.md
+++ b/lib/cli-compiler/README.md
@@ -1,4 +1,5 @@
-# `wasmer-cli-compiler` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE)
+# `wasmer-cli-compiler` 
+[![Build Status](https://github.com/wasmerio/wasmer/actions/workflows/build.yml/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE)
 
 This crate is the Wasmer Compiler only CLI.
 
@@ -7,11 +8,9 @@ This crate is the Wasmer Compiler only CLI.
 
 The Compiler only Wasmer supports the following features:
 * `wasi` (default): support for [WASI].
-* `emscripten` (default): support for [Emscripten].
 * `singlepass`: support for the [Singlepass compiler].
 
 [WASI]: https://github.com/wasmerio/wasmer/tree/main/lib/wasi/
-[Emscripten]: https://github.com/wasmerio/wasmer/tree/main/lib/emscripten/
 [Singlepass compiler]: https://github.com/wasmerio/wasmer/tree/main/lib/compiler-singlepass/
 
 ## CLI commands
diff --git a/lib/cli-compiler/src/bin/wasmer_compiler.rs b/lib/cli-compiler/src/bin/wasmer_compiler.rs
index ba0f2e10f5..c61d074130 100644
--- a/lib/cli-compiler/src/bin/wasmer_compiler.rs
+++ b/lib/cli-compiler/src/bin/wasmer_compiler.rs
@@ -1,8 +1,5 @@
 use wasmer_compiler_cli::cli::wasmer_main;
 
-#[cfg(feature = "run")]
-compile_error!("Cannot enable run with the compile-only build");
-
 fn main() {
     wasmer_main();
 }
diff --git a/lib/cli-compiler/src/commands/compile.rs b/lib/cli-compiler/src/commands/compile.rs
index 7a5147066b..50c69649c5 100644
--- a/lib/cli-compiler/src/commands/compile.rs
+++ b/lib/cli-compiler/src/commands/compile.rs
@@ -6,10 +6,8 @@ use std::fs;
 use std::path::{Path, PathBuf};
 use wasmer_compiler::{ArtifactBuild, ArtifactCreate, ModuleEnvironment};
 use wasmer_types::entity::PrimaryMap;
-use wasmer_types::{
-    Architecture, CompileError, CpuFeature, MemoryIndex, MemoryStyle, TableIndex, TableStyle,
-    Target, Triple,
-};
+use wasmer_types::target::{Architecture, CpuFeature, Target, Triple};
+use wasmer_types::{CompileError, MemoryIndex, MemoryStyle, TableIndex, TableStyle};
 
 #[derive(Debug, Parser)]
 /// The options for the `wasmer compile` subcommand
@@ -82,7 +80,7 @@ impl Compile {
         }
         let tunables = self.store.get_tunables_for_target(&target)?;
 
-        println!("Compiler: {}", compiler_type.to_string());
+        println!("Compiler: {compiler_type}");
         println!("Target: {}", target.triple());
 
         // compile and save the artifact (without using module from api)
diff --git a/lib/cli-compiler/src/commands/config.rs b/lib/cli-compiler/src/commands/config.rs
index 155fb0c1dd..81d562f027 100644
--- a/lib/cli-compiler/src/commands/config.rs
+++ b/lib/cli-compiler/src/commands/config.rs
@@ -57,8 +57,7 @@ impl Config {
                 Some(dir)
             })
             .context(format!(
-                "failed to retrieve the {} environment variables",
-                key
+                "failed to retrieve the {key} environment variables",
             ))?;
 
         let prefix = PathBuf::from(wasmer_dir);
@@ -67,40 +66,40 @@ impl Config {
         let bindir = prefix.join("bin").display().to_string();
         let includedir = prefix.join("include").display().to_string();
         let libdir = prefix.join("lib").display().to_string();
-        let cflags = format!("-I{}", includedir);
-        let libs = format!("-L{} -lwasmer", libdir);
+        let cflags = format!("-I{includedir}");
+        let libs = format!("-L{libdir} -lwasmer");
 
         if self.pkg_config {
-            println!("prefix={}", prefixdir);
-            println!("exec_prefix={}", bindir);
-            println!("includedir={}", includedir);
-            println!("libdir={}", libdir);
+            println!("prefix={prefixdir}");
+            println!("exec_prefix={bindir}");
+            println!("includedir={includedir}");
+            println!("libdir={libdir}");
             println!();
             println!("Name: wasmer");
             println!("Description: The Wasmer library for running WebAssembly");
-            println!("Version: {}", VERSION);
-            println!("Cflags: {}", cflags);
-            println!("Libs: {}", libs);
+            println!("Version: {VERSION}");
+            println!("Cflags: {cflags}");
+            println!("Libs: {libs}");
             return Ok(());
         }
 
         if self.prefix {
-            println!("{}", prefixdir);
+            println!("{prefixdir}");
         }
         if self.bindir {
-            println!("{}", bindir);
+            println!("{bindir}");
         }
         if self.includedir {
-            println!("{}", includedir);
+            println!("{includedir}");
         }
         if self.libdir {
-            println!("{}", libdir);
+            println!("{libdir}");
         }
         if self.libs {
-            println!("{}", libs);
+            println!("{libs}");
         }
         if self.cflags {
-            println!("{}", cflags);
+            println!("{cflags}");
         }
         Ok(())
     }
diff --git a/lib/cli-compiler/src/commands/validate.rs b/lib/cli-compiler/src/commands/validate.rs
index c3c421f466..024d3791c2 100644
--- a/lib/cli-compiler/src/commands/validate.rs
+++ b/lib/cli-compiler/src/commands/validate.rs
@@ -3,7 +3,8 @@ use anyhow::{bail, Context, Result};
 use clap::Parser;
 use std::path::PathBuf;
 use std::str::FromStr;
-use wasmer_types::{is_wasm, CpuFeature, Target, Triple};
+use wasmer_types::is_wasm;
+use wasmer_types::target::{CpuFeature, Target, Triple};
 
 #[derive(Debug, Parser)]
 /// The options for the `wasmer validate` subcommand
diff --git a/lib/cli-compiler/src/error.rs b/lib/cli-compiler/src/error.rs
index f23b50339c..d1aa39a526 100644
--- a/lib/cli-compiler/src/error.rs
+++ b/lib/cli-compiler/src/error.rs
@@ -55,7 +55,7 @@ impl Debug for PrettyError {
                     is_last: n == total_errors - 1,
                     started: false,
                 };
-                write!(indented, "{}", error)?;
+                write!(indented, "{error}")?;
             }
         }
         Ok(())
@@ -84,14 +84,14 @@ where
                                 self.inner,
                                 "{} {: >4} ",
                                 "│".bold().blue(),
-                                format!("{}:", number).dimmed()
+                                format!("{number}:").dimmed()
                             )?
                         } else {
                             write!(
                                 self.inner,
                                 "{}{: >2}: ",
                                 "╰─▶".bold().blue(),
-                                format!("{}", number).bold().blue()
+                                format!("{number}").bold().blue()
                             )?
                         }
                     }
diff --git a/lib/cli-compiler/src/store.rs b/lib/cli-compiler/src/store.rs
index 370d59b535..9d2c0bb372 100644
--- a/lib/cli-compiler/src/store.rs
+++ b/lib/cli-compiler/src/store.rs
@@ -4,12 +4,16 @@
 use crate::common::WasmFeatures;
 use anyhow::Result;
 use clap::Parser;
+#[cfg(doc)]
+use std::path::PathBuf;
 use std::string::ToString;
 #[allow(unused_imports)]
 use std::sync::Arc;
-use wasmer_compiler::EngineBuilder;
-use wasmer_compiler::{CompilerConfig, Features};
-use wasmer_types::{MemoryStyle, MemoryType, Pages, PointerWidth, TableStyle, TableType, Target};
+use wasmer_compiler::{CompilerConfig, EngineBuilder, Features};
+use wasmer_types::target::{PointerWidth, Target};
+#[cfg(doc)]
+use wasmer_types::Type;
+use wasmer_types::{MemoryStyle, MemoryType, Pages, TableStyle, TableType};
 
 /// Minimul Subset of Tunable parameters for WebAssembly compilation.
 #[derive(Clone)]
@@ -209,7 +213,7 @@ impl CompilerOptions {
                 use std::fs::File;
                 use std::io::Write;
                 use wasmer_compiler_llvm::{
-                    CompiledKind, InkwellMemoryBuffer, InkwellModule, LLVMCallbacks, LLVM,
+                    CompiledKind, InkwellMemoryBuffer, InkwellModule, LLVMCallbacks,
                 };
                 use wasmer_types::entity::EntityRef;
                 let mut config = LLVM::new();
@@ -290,6 +294,22 @@ impl CompilerOptions {
                             pos += file.write(&mem_buf_slice[pos..]).unwrap();
                         }
                     }
+
+                    fn asm_memory_buffer(
+                        &self,
+                        kind: &CompiledKind,
+                        asm_memory_buffer: &InkwellMemoryBuffer,
+                    ) {
+                        let mut path = self.debug_dir.clone();
+                        path.push(format!("{}.s", function_kind_to_filename(kind)));
+                        let mem_buf_slice = asm_memory_buffer.as_slice();
+                        let mut file = File::create(path)
+                            .expect("Error while creating debug object file from LLVM IR");
+                        let mut pos = 0;
+                        while pos < mem_buf_slice.len() {
+                            pos += file.write(&mem_buf_slice[pos..]).unwrap();
+                        }
+                    }
                 }
 
                 impl fmt::Debug for Callbacks {
@@ -306,7 +326,7 @@ impl CompilerOptions {
                 }
                 Box::new(config)
             }
-            #[cfg(not(all(feature = "singlepass", feature = "cranelift", feature = "llvm",)))]
+            #[cfg(not(all(feature = "singlepass", feature = "cranelift", feature = "llvm")))]
             compiler => {
                 bail!(
                     "The `{}` compiler is not included in this binary.",
@@ -348,14 +368,18 @@ impl CompilerType {
     }
 }
 
-impl ToString for CompilerType {
-    fn to_string(&self) -> String {
-        match self {
-            Self::Singlepass => "singlepass".to_string(),
-            Self::Cranelift => "cranelift".to_string(),
-            Self::LLVM => "llvm".to_string(),
-            Self::Headless => "headless".to_string(),
-        }
+impl std::fmt::Display for CompilerType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Self::Singlepass => "singlepass",
+                Self::Cranelift => "cranelift",
+                Self::LLVM => "llvm",
+                Self::Headless => "headless",
+            }
+        )
     }
 }
 
diff --git a/lib/cli/Cargo.toml b/lib/cli/Cargo.toml
index fbac043c74..6bcd2e89c9 100644
--- a/lib/cli/Cargo.toml
+++ b/lib/cli/Cargo.toml
@@ -32,26 +32,28 @@ default = [
 	"sys",
 	"wat",
 	"wast",
-	"compiler",
 	"journal",
 	"wasmer-artifact-create",
 	"static-artifact-create",
 ]
 
-# Tun-tap client for connecting to Wasmer Edge VPNs
-tun-tap = [
-	"dep:tun-tap",
-	"virtual-net/tokio-tungstenite",
-	"tokio-tungstenite",
-	"mio",
-	"mac_address",
-	"dep:interfaces",
-]
+# # Tun-tap client for connecting to Wasmer Edge VPNs
+# tun-tap = [
+# 	"dep:tun-tap",
+# 	"virtual-net/tokio-tungstenite",
+# 	"tokio-tungstenite",
+# 	"mio",
+# 	"mac_address",
+# 	"dep:interfaces",
+# ]
 journal = ["wasmer-wasix/journal"]
-fuse = ["dep:fuse", "dep:time01", "dep:shared-buffer", "dep:rkyv"]
+fuse = ["dep:fuser", "dep:time01", "dep:shared-buffer", "dep:rkyv"]
 backend = []
 coredump = ["wasm-coredump-builder"]
-sys = ["compiler", "wasmer-vm"]
+sys = ["compiler", "dep:wasmer-vm"]
+v8 = ["backend", "wasmer/v8"]
+wamr = ["backend", "wasmer/wamr"]
+wasmi = ["backend", "wasmer/wasmi"]
 jsc = ["backend", "wasmer/jsc", "wasmer/std"]
 wast = ["wasmer-wast"]
 host-net = ["virtual-net/host-net"]
@@ -61,6 +63,7 @@ compiler = [
 	"wasmer/compiler",
 	"wasmer-compiler/translator",
 	"wasmer-compiler/compiler",
+	"sys",
 ]
 wasmer-artifact-create = [
 	"compiler",
@@ -68,7 +71,6 @@ wasmer-artifact-create = [
 	"wasmer/wasmer-artifact-create",
 	"wasmer-compiler/wasmer-artifact-load",
 	"wasmer-compiler/wasmer-artifact-create",
-	"wasmer-object",
 ]
 static-artifact-create = [
 	"compiler",
@@ -76,7 +78,6 @@ static-artifact-create = [
 	"wasmer/static-artifact-create",
 	"wasmer-compiler/static-artifact-load",
 	"wasmer-compiler/static-artifact-create",
-	"wasmer-object",
 ]
 wasmer-artifact-load = [
 	"compiler",
@@ -88,15 +89,16 @@ static-artifact-load = [
 	"wasmer/static-artifact-load",
 	"wasmer-compiler/static-artifact-load",
 ]
-singlepass = ["wasmer-compiler-singlepass", "compiler"]
-cranelift = ["wasmer-compiler-cranelift", "compiler"]
-llvm = ["wasmer-compiler-llvm", "compiler"]
+singlepass = ["wasmer-compiler-singlepass", "compiler", "wasmer/singlepass"]
+cranelift = ["wasmer-compiler-cranelift", "compiler", "wasmer/cranelift"]
+llvm = ["wasmer-compiler-llvm", "compiler", "wasmer/llvm"]
 disable-all-logging = [
 	"wasmer-wasix/disable-all-logging",
 	"log/release_max_level_off",
 ]
-headless = []
+headless = ["dep:wasmer-vm", "wasmer/sys"]
 headless-minimal = ["headless", "disable-all-logging"]
+telemetry = []
 
 # Optional
 enable-serde = [
@@ -109,52 +111,48 @@ enable-serde = [
 [dependencies]
 # Repo-local dependencies.
 
-wasmer = { version = "=4.3.7", path = "../api", default-features = false }
-wasmer-compiler = { version = "=4.3.7", path = "../compiler", features = [
+wasmer = { version = "=6.1.0", path = "../api", default-features = false }
+wasmer-compiler = { version = "=6.1.0", path = "../compiler", features = [
 	"compiler",
 ], optional = true }
-wasmer-compiler-cranelift = { version = "=4.3.7", path = "../compiler-cranelift", optional = true }
-wasmer-compiler-singlepass = { version = "=4.3.7", path = "../compiler-singlepass", optional = true }
-wasmer-compiler-llvm = { version = "=4.3.7", path = "../compiler-llvm", optional = true }
-wasmer-emscripten = { version = "=4.3.7", path = "../emscripten" }
-wasmer-vm = { version = "=4.3.7", path = "../vm", optional = true }
-wasmer-wasix = { path = "../wasix", version = "=0.27.0", features = [
+wasmer-compiler-cranelift = { version = "=6.1.0", path = "../compiler-cranelift", optional = true }
+wasmer-compiler-singlepass = { version = "=6.1.0", path = "../compiler-singlepass", optional = true }
+wasmer-compiler-llvm = { version = "=6.1.0", path = "../compiler-llvm", optional = true }
+wasmer-package.workspace = true
+
+wasmer-vm = { version = "=6.1.0", path = "../vm", optional = true }
+wasmer-wasix = { path = "../wasix", version = "=0.601.0", features = [
 	"logging",
 	"webc_runner_rt_wcgi",
 	"webc_runner_rt_dcgi",
 	"webc_runner_rt_dproxy",
-	"webc_runner_rt_emscripten",
 	"host-fs",
 	"ctrlc",
-] }
-wasmer-wast = { version = "=4.3.7", path = "../../tests/lib/wast", optional = true }
-wasmer-types = { version = "=4.3.7", path = "../types", features = [
+	"sys",
+], default-features = false }
+wasmer-wast = { version = "=6.1.0", path = "../../tests/lib/wast", optional = true }
+wasmer-types = { version = "=6.1.0", path = "../types", features = [
 	"enable-serde",
+	"detect-wasm-features",
 ] }
-wasmer-registry = { version = "=5.19.0", path = "../registry", features = [
-	"build-package",
-	"clap",
-] }
-wasmer-object = { version = "=4.3.7", path = "../object", optional = true }
-virtual-fs = { version = "0.16.0", path = "../virtual-fs", default-features = false, features = [
+virtual-fs = { version = "0.601.0", path = "../virtual-fs", default-features = false, features = [
 	"host-fs",
 ] }
-virtual-net = { version = "0.8.0", path = "../virtual-net" }
-virtual-mio = { version = "0.3.1", path = "../virtual-io" }
+virtual-net = { version = "0.601.0", path = "../virtual-net" }
+virtual-mio = { version = "0.601.0", path = "../virtual-io" }
 
 # Wasmer-owned dependencies.
 
-webc = { workspace = true }
-wasmer-api = { version = "=0.0.34", path = "../backend-api" }
-edge-schema.workspace = true
-edge-util = { version = "=0.1.0" }
-lazy_static = "1.4.0"
+webc.workspace = true
+wasmer-backend-api = { version = "=0.601.0", path = "../backend-api" }
+wasmer-sdk = { path = "../sdk" }
+wasmer-config = { version = "0.601.0", path = "../config" }
 
 # Used by the mount command
 
 shared-buffer = { workspace = true, optional = true }
 rkyv = { workspace = true, optional = true }
-fuse = { version = "0.3", optional = true }
+fuser = { version = "0.14.0", optional = true }
 time01 = { package = "time", version = "0.1.45", optional = true }
 
 
@@ -163,83 +161,84 @@ time01 = { package = "time", version = "0.1.45", optional = true }
 http.workspace = true
 is-terminal = "0.4.7"
 colored = "2.0"
-anyhow = "1.0"
-bytesize = "1.0"
-cfg-if = "1.0"
-tempfile = "3.6.0"
-serde = { version = "1.0.147", features = ["derive"] }
+anyhow.workspace = true
+bytesize.workspace = true
+cfg-if.workspace = true
+tempfile.workspace = true
+serde.workspace = true
+serde_json.workspace = true
 dirs = "4.0"
-serde_json = { version = "1.0" }
-target-lexicon = { version = "0.12", features = ["std"] }
-wasmer-config = { version = "0.8.0", path = "../config" }
-indexmap = "1.9.2"
+target-lexicon = { workspace = true, features = ["std"] }
+indexmap.workspace = true
 walkdir = "2.3.2"
 regex = "1.6.0"
 toml.workspace = true
-url = "2.3.1"
+url.workspace = true
 libc.workspace = true
 parking_lot = "0.12"
 dialoguer = "0.11.0"
-tldextract = "0.6.0"
-hex = "0.4.3"
-flate2 = "1.0.25"
+hex.workspace = true
+flate2.workspace = true
 cargo_metadata = "0.15.2"
-tar = "0.4.40"
-bytes = "1"
-thiserror = "1.0.37"
-log = "0.4.17"
-semver = "1.0.14"
+tar.workspace = true
+bytes.workspace = true
+thiserror.workspace = true
+log.workspace = true
+semver.workspace = true
 pathdiff = "0.2.1"
-sha2 = "0.10.6"
-object = "0.32.0"
+sha2.workspace = true
+object.workspace = true
 wasm-coredump-builder = { version = "0.1.11", optional = true }
-tracing = { version = "0.1" }
-tracing-subscriber = { version = "0.3", features = [
+tracing.workspace = true
+tracing-subscriber = { workspace = true, features = [
 	"env-filter",
 	"fmt",
 	"json",
 ] }
-async-trait = "0.1.68"
-tokio = { version = "1.28.1", features = ["macros", "rt-multi-thread"] }
-once_cell = "1.17.1"
+async-trait = { workspace = true }
+tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
+once_cell.workspace = true
 indicatif = "0.17.5"
 opener = "0.6.1"
 normpath = "=1.1.1"
 hyper = { workspace = true, features = ["server"] }
-hyper-util = { version = "0.1.5", features = ["tokio"] }
-http-body-util = "0.1.1"
+hyper-util = { workspace = true, features = ["tokio"] }
+http-body-util.workspace = true
 futures = "0.3.29"
 humantime = "2.1.0"
 interfaces = { version = "0.0.9", optional = true }
 
 uuid = { version = "1.3.0", features = ["v4"] }
-time = { version = "0.3.17", features = ["macros"] }
-serde_yaml = { workspace = true }
-comfy-table = "7.0.1"
+time = { workspace = true, features = ["macros"] }
+serde_yaml.workspace = true
+base64.workspace = true
+# FIXME: 7.2 is not compatible with Rust 1.84
+comfy-table = "=7.1.4"
 
 
 # Used by tuntap and connect
-futures-util = "0.3"
-mio = { version = "0.8", optional = true }
-tokio-tungstenite = { version = "0.21.0", features = [
+futures-util.workspace = true
+mio = { workspace = true, optional = true }
+tokio-tungstenite = { workspace = true, features = [
 	"rustls-tls-webpki-roots",
 	"stream",
 ], optional = true }
 mac_address = { version = "1.1.5", optional = true }
-tun-tap = { version = "0.1.4", features = ["tokio"], optional = true }
+#tun-tap = { version = "0.1.4", features = ["tokio"], optional = true }
 
 clap_complete = "4.5.2"
 clap_mangen = "0.2.20"
-zip = { version = "2.1.3", default-features = false, features = ["deflate"] }
+zip = { version = "2.4", default-features = false, features = ["deflate"] }
 console = "0.15.8"
 dotenvy = "0.15.7"
+lzma-rs = "0.3.0"
 
 # NOTE: Must use different features for clap because the "color" feature does not
 # work on wasi due to the anstream dependency not compiling.
 [target.'cfg(not(target_family = "wasm"))'.dependencies]
-clap = { version = "4.3.7", features = ["derive", "env"] }
+clap = { version = "4.4.0", features = ["derive", "env"] }
 [target.'cfg(target_family = "wasm")'.dependencies]
-clap = { version = "4.3.7", default-features = false, features = [
+clap = { version = "4.4.0", default-features = false, features = [
 	"std",
 	"help",
 	"usage",
@@ -249,7 +248,7 @@ clap = { version = "4.3.7", default-features = false, features = [
 	"env",
 ] }
 
-[target.'cfg(not(target_arch = "riscv64"))'.dependencies]
+[target.'cfg(not(any(target_arch = "riscv64", target_arch = "loongarch64")))'.dependencies]
 reqwest = { workspace = true, default-features = false, features = [
 	"rustls-tls",
 	"json",
@@ -257,15 +256,16 @@ reqwest = { workspace = true, default-features = false, features = [
 	"gzip",
 ] }
 
-[target.'cfg(target_arch = "riscv64")'.dependencies]
+[target.'cfg(any(target_arch = "riscv64", target_arch = "loongarch64"))'.dependencies]
 reqwest = { workspace = true, default-features = false, features = [
 	"native-tls",
 	"json",
 	"multipart",
 ] }
 
+
 [build-dependencies]
-chrono = { version = "^0.4", default-features = false, features = [
+chrono = { version = "0.4.38", default-features = false, features = [
 	"std",
 	"clock",
 ] }
@@ -277,7 +277,7 @@ unix_mode = "0.1.3"
 [dev-dependencies]
 assert_cmd = "2.0.11"
 predicates = "3.0.3"
-pretty_assertions = "1.3.0"
+pretty_assertions.workspace = true
 
 [target.'cfg(target_os = "windows")'.dependencies]
 colored = "2.0.0"
diff --git a/lib/cli/README.md b/lib/cli/README.md
index 3b5e0e3498..c7a28dca36 100644
--- a/lib/cli/README.md
+++ b/lib/cli/README.md
@@ -1,4 +1,4 @@
-# `wasmer-cli` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE)
+# `wasmer-cli` [![Build Status](https://github.com/wasmerio/wasmer/actions/workflows/build.yml/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE)
 
 This crate is the Wasmer CLI.
 
@@ -23,13 +23,11 @@ The Wasmer supports the following features:
 * `wast`(default): support for running wast test files.
 * `cache` (default): support or automatically caching compiled artifacts.
 * `wasi` (default): support for [WASI].
-* `emscripten` (default): support for [Emscripten].
 * `singlepass`: support for the [Singlepass compiler].
 * `cranelift`: support for the [Cranelift compiler].
 * `llvm`: support for the [LLVM compiler].
 
 [WASI]: https://github.com/wasmerio/wasmer/tree/main/lib/wasi/
-[Emscripten]: https://github.com/wasmerio/wasmer/tree/main/lib/emscripten/
 [Singlepass compiler]: https://github.com/wasmerio/wasmer/tree/main/lib/compiler-singlepass/
 [Cranelift compiler]: https://github.com/wasmerio/wasmer/tree/main/lib/compiler-cranelift/
 [LLVM compiler]: https://github.com/wasmerio/wasmer/tree/main/lib/compiler-llvm/
diff --git a/lib/cli/build.rs b/lib/cli/build.rs
index be9c01645f..b8e6525d56 100644
--- a/lib/cli/build.rs
+++ b/lib/cli/build.rs
@@ -10,7 +10,7 @@ pub fn main() {
         .ok()
         .and_then(|output| String::from_utf8(output.stdout).ok())
         .unwrap_or_default();
-    println!("cargo:rustc-env=WASMER_BUILD_GIT_HASH={}", git_hash);
+    println!("cargo:rustc-env=WASMER_BUILD_GIT_HASH={git_hash}");
 
     if git_hash.len() > 5 {
         println!(
@@ -23,5 +23,5 @@ pub fn main() {
 
     let utc: DateTime<Utc> = Utc::now();
     let date = utc.format("%Y-%m-%d").to_string();
-    println!("cargo:rustc-env=WASMER_BUILD_DATE={}", date);
+    println!("cargo:rustc-env=WASMER_BUILD_DATE={date}");
 }
diff --git a/lib/cli/src/backend.rs b/lib/cli/src/backend.rs
new file mode 100644
index 0000000000..ce3f449eca
--- /dev/null
+++ b/lib/cli/src/backend.rs
@@ -0,0 +1,944 @@
+//! Common module with common used structures across different
+//! commands.
+
+// NOTE: A lot of this code depends on feature flags.
+// To not go crazy with annotations, some lints are disabled for the whole
+// module.
+#![allow(dead_code, unused_imports, unused_variables)]
+
+use std::num::NonZero;
+use std::string::ToString;
+use std::sync::Arc;
+use std::{path::PathBuf, str::FromStr};
+
+use anyhow::{bail, Result};
+#[cfg(feature = "sys")]
+use wasmer::sys::*;
+use wasmer::*;
+use wasmer_types::{target::Target, Features};
+
+#[cfg(feature = "compiler")]
+use wasmer_compiler::CompilerConfig;
+
+use wasmer::Engine;
+
+#[derive(Debug, clap::Parser, Clone, Default)]
+/// The WebAssembly features that can be passed through the
+/// Command Line args.
+pub struct WasmFeatures {
+    /// Enable support for the SIMD proposal.
+    #[clap(long = "enable-simd")]
+    pub simd: bool,
+
+    /// Disable support for the threads proposal.
+    #[clap(long = "disable-threads")]
+    pub disable_threads: bool,
+
+    /// Deprecated, threads are enabled by default.
+    #[clap(long = "enable-threads")]
+    pub _threads: bool,
+
+    /// Enable support for the reference types proposal.
+    #[clap(long = "enable-reference-types")]
+    pub reference_types: bool,
+
+    /// Enable support for the multi value proposal.
+    #[clap(long = "enable-multi-value")]
+    pub multi_value: bool,
+
+    /// Enable support for the bulk memory proposal.
+    #[clap(long = "enable-bulk-memory")]
+    pub bulk_memory: bool,
+
+    /// Enable support for the tail call proposal.
+    #[clap(long = "enable-tail-call")]
+    pub tail_call: bool,
+
+    /// Enable support for the module linking proposal.
+    #[clap(long = "enable-module-linking")]
+    pub module_linking: bool,
+
+    /// Enable support for the multi memory proposal.
+    #[clap(long = "enable-multi-memory")]
+    pub multi_memory: bool,
+
+    /// Enable support for the memory64 proposal.
+    #[clap(long = "enable-memory64")]
+    pub memory64: bool,
+
+    /// Enable support for the exceptions proposal.
+    #[clap(long = "enable-exceptions")]
+    pub exceptions: bool,
+
+    /// Enable support for the relaxed SIMD proposal.
+    #[clap(long = "enable-relaxed-simd")]
+    pub relaxed_simd: bool,
+
+    /// Enable support for the extended constant expressions proposal.
+    #[clap(long = "enable-extended-const")]
+    pub extended_const: bool,
+
+    /// Enable support for all pre-standard proposals.
+    #[clap(long = "enable-all")]
+    pub all: bool,
+}
+
+#[derive(Debug, Clone, clap::Parser, Default)]
+/// The compiler options
+pub struct RuntimeOptions {
+    /// Use Singlepass compiler.
+    #[cfg(feature = "singlepass")]
+    #[clap(long, conflicts_with_all = &Vec::<&str>::from_iter([
+        #[cfg(feature = "llvm")]
+        "llvm", 
+        #[cfg(feature = "v8")]
+        "v8", 
+        #[cfg(feature = "cranelift")]
+        "cranelift", 
+        #[cfg(feature = "wamr")]
+        "wamr", 
+        #[cfg(feature = "wasmi")]
+        "wasmi"
+    ]))]
+    singlepass: bool,
+
+    /// Use Cranelift compiler.
+    #[cfg(feature = "cranelift")]
+    #[clap(long, conflicts_with_all = &Vec::<&str>::from_iter([
+        #[cfg(feature = "llvm")]
+        "llvm", 
+        #[cfg(feature = "v8")]
+        "v8", 
+        #[cfg(feature = "singlepass")]
+        "singlepass", 
+        #[cfg(feature = "wamr")]
+        "wamr", 
+        #[cfg(feature = "wasmi")]
+        "wasmi"
+    ]))]
+    cranelift: bool,
+
+    /// Use LLVM compiler.
+    #[cfg(feature = "llvm")]
+    #[clap(long, conflicts_with_all = &Vec::<&str>::from_iter([
+        #[cfg(feature = "cranelift")]
+        "cranelift", 
+        #[cfg(feature = "v8")]
+        "v8", 
+        #[cfg(feature = "singlepass")]
+        "singlepass", 
+        #[cfg(feature = "wamr")]
+        "wamr", 
+        #[cfg(feature = "wasmi")]
+        "wasmi"
+    ]))]
+    llvm: bool,
+
+    /// Use the V8 runtime.
+    #[cfg(feature = "v8")]
+    #[clap(long, conflicts_with_all = &Vec::<&str>::from_iter([
+        #[cfg(feature = "cranelift")]
+        "cranelift", 
+        #[cfg(feature = "llvm")]
+        "llvm", 
+        #[cfg(feature = "singlepass")]
+        "singlepass", 
+        #[cfg(feature = "wamr")]
+        "wamr", 
+        #[cfg(feature = "wasmi")]
+        "wasmi"
+    ]))]
+    v8: bool,
+
+    /// Use WAMR.
+    #[cfg(feature = "wamr")]
+    #[clap(long, conflicts_with_all = &Vec::<&str>::from_iter([
+        #[cfg(feature = "cranelift")]
+        "cranelift", 
+        #[cfg(feature = "llvm")]
+        "llvm", 
+        #[cfg(feature = "singlepass")]
+        "singlepass", 
+        #[cfg(feature = "v8")]
+        "v8", 
+        #[cfg(feature = "wasmi")]
+        "wasmi"
+    ]))]
+    wamr: bool,
+
+    /// Use the wasmi runtime.
+    #[cfg(feature = "wasmi")]
+    #[clap(long, conflicts_with_all = &Vec::<&str>::from_iter([
+        #[cfg(feature = "cranelift")]
+        "cranelift", 
+        #[cfg(feature = "llvm")]
+        "llvm", 
+        #[cfg(feature = "singlepass")]
+        "singlepass", 
+        #[cfg(feature = "v8")]
+        "v8", 
+        #[cfg(feature = "wamr")]
+        "wamr"
+    ]))]
+    wasmi: bool,
+
+    /// Enable compiler internal verification.
+    ///
+    /// Available for cranelift, LLVM and singlepass.
+    #[clap(long)]
+    enable_verifier: bool,
+
+    /// Enable a profiler.
+    ///
+    /// Available for cranelift, LLVM and singlepass.
+    #[clap(long, value_enum)]
+    profiler: Option<Profiler>,
+
+    /// LLVM debug directory, where IR and object files will be written to.
+    ///
+    /// Only available for the LLVM compiler.
+    #[clap(long)]
+    llvm_debug_dir: Option<PathBuf>,
+
+    /// Only available for the LLVM compiler. Enable the "pass-params" optimization, where the first (#0)
+    /// global and the first (#0) memory passed between guest functions as explicit parameters.
+    #[clap(long)]
+    enable_pass_params_opt: bool,
+
+    /// Only available for the LLVM compiler. Sets the number of threads used to compile the
+    /// input module(s).
+    #[clap(long)]
+    llvm_num_threads: Option<NonZero<usize>>,
+
+    #[clap(flatten)]
+    features: WasmFeatures,
+}
+
+#[derive(Clone, Debug)]
+pub enum Profiler {
+    /// Perfmap-based profilers.
+    Perfmap,
+}
+
+impl FromStr for Profiler {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "perfmap" => Ok(Self::Perfmap),
+            _ => Err(anyhow::anyhow!("Unrecognized profiler: {s}")),
+        }
+    }
+}
+
+impl RuntimeOptions {
+    pub fn get_available_backends(&self) -> Result<Vec<BackendType>> {
+        // If a specific backend is explicitly requested, use it
+        #[cfg(feature = "cranelift")]
+        {
+            if self.cranelift {
+                return Ok(vec![BackendType::Cranelift]);
+            }
+        }
+
+        #[cfg(feature = "llvm")]
+        {
+            if self.llvm {
+                return Ok(vec![BackendType::LLVM]);
+            }
+        }
+
+        #[cfg(feature = "singlepass")]
+        {
+            if self.singlepass {
+                return Ok(vec![BackendType::Singlepass]);
+            }
+        }
+
+        #[cfg(feature = "wamr")]
+        {
+            if self.wamr {
+                return Ok(vec![BackendType::Wamr]);
+            }
+        }
+
+        #[cfg(feature = "v8")]
+        {
+            if self.v8 {
+                return Ok(vec![BackendType::V8]);
+            }
+        }
+
+        #[cfg(feature = "wasmi")]
+        {
+            if self.wasmi {
+                return Ok(vec![BackendType::Wasmi]);
+            }
+        }
+
+        Ok(BackendType::enabled())
+    }
+
+    /// Filter enabled backends based on required WebAssembly features
+    pub fn filter_backends_by_features(
+        backends: Vec<BackendType>,
+        required_features: &Features,
+        target: &Target,
+    ) -> Vec<BackendType> {
+        backends
+            .into_iter()
+            .filter(|backend| backend.supports_features(required_features, target))
+            .collect()
+    }
+
+    pub fn get_store(&self) -> Result<Store> {
+        let engine = self.get_engine(&Target::default())?;
+        Ok(Store::new(engine))
+    }
+
+    pub fn get_engine(&self, target: &Target) -> Result<Engine> {
+        let backends = self.get_available_backends()?;
+        let backend = backends.first().unwrap();
+        let backend_kind = wasmer::BackendKind::from(backend);
+        let required_features = wasmer::Engine::default_features_for_backend(&backend_kind, target);
+        backend.get_engine(target, &required_features, self)
+    }
+
+    pub fn get_engine_for_module(&self, module_contents: &[u8], target: &Target) -> Result<Engine> {
+        let required_features = self
+            .detect_features_from_wasm(module_contents)
+            .unwrap_or_default();
+
+        self.get_engine_for_features(&required_features, target)
+    }
+
+    pub fn get_engine_for_features(
+        &self,
+        required_features: &Features,
+        target: &Target,
+    ) -> Result<Engine> {
+        let backends = self.get_available_backends()?;
+        let filtered_backends =
+            Self::filter_backends_by_features(backends.clone(), required_features, target);
+
+        if filtered_backends.is_empty() {
+            let enabled_backends = BackendType::enabled();
+            if backends.len() == 1 && enabled_backends.len() > 1 {
+                // If the user has chosen an specific backend, we can suggest to use another one
+                let filtered_backends =
+                    Self::filter_backends_by_features(enabled_backends, required_features, target);
+                let extra_text: String = if !filtered_backends.is_empty() {
+                    format!(". You can use --{} instead", filtered_backends[0])
+                } else {
+                    "".to_string()
+                };
+                bail!(
+                    "The {} backend does not support the required features for the Wasm module{}",
+                    backends[0],
+                    extra_text
+                );
+            } else {
+                bail!("No backends support the required features for the Wasm module. Feel free to open an issue at https://github.com/wasmerio/wasmer/issues");
+            }
+        }
+        filtered_backends
+            .first()
+            .unwrap()
+            .get_engine(target, required_features, self)
+    }
+
+    #[cfg(feature = "compiler")]
+    /// Get the enaled Wasm features.
+    pub fn get_features(&self, features: &Features) -> Result<Features> {
+        let mut result = features.clone();
+        if !self.features.disable_threads || self.features.all {
+            result.threads(true);
+        }
+        if self.features.disable_threads && !self.features.all {
+            result.threads(false);
+        }
+        if self.features.multi_value || self.features.all {
+            result.multi_value(true);
+        }
+        if self.features.simd || self.features.all {
+            result.simd(true);
+        }
+        if self.features.bulk_memory || self.features.all {
+            result.bulk_memory(true);
+        }
+        if self.features.reference_types || self.features.all {
+            result.reference_types(true);
+        }
+        Ok(result)
+    }
+
+    #[cfg(feature = "compiler")]
+    /// Get a copy of the default features with user-configured options
+    pub fn get_configured_features(&self) -> Result<Features> {
+        let features = Features::default();
+        self.get_features(&features)
+    }
+
+    /// Detect features from a WebAssembly module binary.
+    pub fn detect_features_from_wasm(
+        &self,
+        wasm_bytes: &[u8],
+    ) -> Result<Features, wasmparser::BinaryReaderError> {
+        let mut features = Features::detect_from_wasm(wasm_bytes)?;
+
+        // Merge with user-configured features
+        if !self.features.disable_threads || self.features.all {
+            features.threads(true);
+        }
+        if self.features.reference_types || self.features.all {
+            features.reference_types(true);
+        }
+        if self.features.simd || self.features.all {
+            features.simd(true);
+        }
+        if self.features.bulk_memory || self.features.all {
+            features.bulk_memory(true);
+        }
+        if self.features.multi_value || self.features.all {
+            features.multi_value(true);
+        }
+        if self.features.tail_call || self.features.all {
+            features.tail_call(true);
+        }
+        if self.features.module_linking || self.features.all {
+            features.module_linking(true);
+        }
+        if self.features.multi_memory || self.features.all {
+            features.multi_memory(true);
+        }
+        if self.features.memory64 || self.features.all {
+            features.memory64(true);
+        }
+        if self.features.exceptions || self.features.all {
+            features.exceptions(true);
+        }
+
+        Ok(features)
+    }
+
+    #[cfg(feature = "compiler")]
+    pub fn get_sys_compiler_engine_for_target(
+        &self,
+        target: Target,
+    ) -> std::result::Result<Engine, anyhow::Error> {
+        let backends = self.get_available_backends()?;
+        let compiler_config = self.get_sys_compiler_config(backends.first().unwrap())?;
+        let default_features = compiler_config.default_features_for_target(&target);
+        let features = self.get_features(&default_features)?;
+        Ok(wasmer_compiler::EngineBuilder::new(compiler_config)
+            .set_features(Some(features))
+            .set_target(Some(target))
+            .engine()
+            .into())
+    }
+
+    #[allow(unused_variables)]
+    #[cfg(feature = "compiler")]
+    pub(crate) fn get_sys_compiler_config(
+        &self,
+        rt: &BackendType,
+    ) -> Result<Box<dyn CompilerConfig>> {
+        let compiler_config: Box<dyn CompilerConfig> = match rt {
+            BackendType::Headless => bail!("The headless engine can't be chosen"),
+            #[cfg(feature = "singlepass")]
+            BackendType::Singlepass => {
+                let mut config = wasmer_compiler_singlepass::Singlepass::new();
+                if self.enable_verifier {
+                    config.enable_verifier();
+                }
+                if let Some(p) = &self.profiler {
+                    match p {
+                        Profiler::Perfmap => config.enable_perfmap(),
+                    }
+                }
+
+                Box::new(config)
+            }
+            #[cfg(feature = "cranelift")]
+            BackendType::Cranelift => {
+                let mut config = wasmer_compiler_cranelift::Cranelift::new();
+                if self.enable_verifier {
+                    config.enable_verifier();
+                }
+                if let Some(p) = &self.profiler {
+                    match p {
+                        Profiler::Perfmap => config.enable_perfmap(),
+                    }
+                }
+                Box::new(config)
+            }
+            #[cfg(feature = "llvm")]
+            BackendType::LLVM => {
+                use std::{fmt, fs::File, io::Write};
+
+                use wasmer_compiler_llvm::{
+                    CompiledKind, InkwellMemoryBuffer, InkwellModule, LLVMCallbacks, LLVM,
+                };
+                use wasmer_types::entity::EntityRef;
+                let mut config = LLVM::new();
+
+                if self.enable_pass_params_opt {
+                    config.enable_pass_params_opt();
+                }
+
+                if let Some(num_threads) = self.llvm_num_threads {
+                    config.num_threads(num_threads);
+                }
+
+                struct Callbacks {
+                    debug_dir: PathBuf,
+                }
+                impl Callbacks {
+                    fn new(debug_dir: PathBuf) -> Result<Self> {
+                        // Create the debug dir in case it doesn't exist
+                        std::fs::create_dir_all(&debug_dir)?;
+                        Ok(Self { debug_dir })
+                    }
+                }
+                // Converts a kind into a filename, that we will use to dump
+                // the contents of the IR object file to.
+                fn types_to_signature(types: &[Type]) -> String {
+                    types
+                        .iter()
+                        .map(|ty| match ty {
+                            Type::I32 => "i".to_string(),
+                            Type::I64 => "I".to_string(),
+                            Type::F32 => "f".to_string(),
+                            Type::F64 => "F".to_string(),
+                            Type::V128 => "v".to_string(),
+                            Type::ExternRef => "e".to_string(),
+                            Type::FuncRef => "r".to_string(),
+                            Type::ExceptionRef => "x".to_string(),
+                        })
+                        .collect::<Vec<_>>()
+                        .join("")
+                }
+                // Converts a kind into a filename, that we will use to dump
+                // the contents of the IR object file to.
+                fn function_kind_to_filename(kind: &CompiledKind) -> String {
+                    match kind {
+                        CompiledKind::Local(local_index) => {
+                            format!("function_{}", local_index.index())
+                        }
+                        CompiledKind::FunctionCallTrampoline(func_type) => format!(
+                            "trampoline_call_{}_{}",
+                            types_to_signature(func_type.params()),
+                            types_to_signature(func_type.results())
+                        ),
+                        CompiledKind::DynamicFunctionTrampoline(func_type) => format!(
+                            "trampoline_dynamic_{}_{}",
+                            types_to_signature(func_type.params()),
+                            types_to_signature(func_type.results())
+                        ),
+                        CompiledKind::Module => "module".into(),
+                    }
+                }
+                impl LLVMCallbacks for Callbacks {
+                    fn preopt_ir(&self, kind: &CompiledKind, module: &InkwellModule) {
+                        let mut path = self.debug_dir.clone();
+                        path.push(format!("{}.preopt.ll", function_kind_to_filename(kind)));
+                        module
+                            .print_to_file(&path)
+                            .expect("Error while dumping pre optimized LLVM IR");
+                    }
+                    fn postopt_ir(&self, kind: &CompiledKind, module: &InkwellModule) {
+                        let mut path = self.debug_dir.clone();
+                        path.push(format!("{}.postopt.ll", function_kind_to_filename(kind)));
+                        module
+                            .print_to_file(&path)
+                            .expect("Error while dumping post optimized LLVM IR");
+                    }
+                    fn obj_memory_buffer(
+                        &self,
+                        kind: &CompiledKind,
+                        memory_buffer: &InkwellMemoryBuffer,
+                    ) {
+                        let mut path = self.debug_dir.clone();
+                        path.push(format!("{}.o", function_kind_to_filename(kind)));
+                        let mem_buf_slice = memory_buffer.as_slice();
+                        let mut file = File::create(path)
+                            .expect("Error while creating debug object file from LLVM IR");
+                        let mut pos = 0;
+                        while pos < mem_buf_slice.len() {
+                            pos += file.write(&mem_buf_slice[pos..]).unwrap();
+                        }
+                    }
+                    fn asm_memory_buffer(
+                        &self,
+                        kind: &CompiledKind,
+                        asm_memory_buffer: &InkwellMemoryBuffer,
+                    ) {
+                        let mut path = self.debug_dir.clone();
+                        path.push(format!("{}.s", function_kind_to_filename(kind)));
+                        let mem_buf_slice = asm_memory_buffer.as_slice();
+                        let mut file = File::create(path)
+                            .expect("Error while creating debug object file from LLVM IR");
+                        let mut pos = 0;
+                        while pos < mem_buf_slice.len() {
+                            pos += file.write(&mem_buf_slice[pos..]).unwrap();
+                        }
+                    }
+                }
+
+                impl fmt::Debug for Callbacks {
+                    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                        write!(f, "LLVMCallbacks")
+                    }
+                }
+
+                if let Some(ref llvm_debug_dir) = self.llvm_debug_dir {
+                    config.callbacks(Some(Arc::new(Callbacks::new(llvm_debug_dir.clone())?)));
+                }
+                if self.enable_verifier {
+                    config.enable_verifier();
+                }
+                if let Some(p) = &self.profiler {
+                    match p {
+                        Profiler::Perfmap => config.enable_perfmap(),
+                    }
+                }
+
+                Box::new(config)
+            }
+            BackendType::V8 | BackendType::Wamr | BackendType::Wasmi => unreachable!(),
+            #[cfg(not(all(feature = "singlepass", feature = "cranelift", feature = "llvm")))]
+            compiler => {
+                bail!(
+                    "The `{}` compiler is not included in this binary.",
+                    compiler.to_string()
+                )
+            }
+        };
+
+        #[allow(unreachable_code)]
+        Ok(compiler_config)
+    }
+}
+
+/// The compiler used for the store
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[allow(clippy::upper_case_acronyms, dead_code)]
+pub enum BackendType {
+    /// Singlepass compiler
+    Singlepass,
+
+    /// Cranelift compiler
+    Cranelift,
+
+    /// LLVM compiler
+    LLVM,
+
+    /// V8 runtime
+    V8,
+
+    /// Wamr runtime
+    Wamr,
+
+    /// Wasmi runtime
+    Wasmi,
+
+    /// Headless compiler
+    #[allow(dead_code)]
+    Headless,
+}
+
+impl BackendType {
+    /// Return all enabled compilers
+    pub fn enabled() -> Vec<Self> {
+        vec![
+            #[cfg(feature = "cranelift")]
+            Self::Cranelift,
+            #[cfg(feature = "llvm")]
+            Self::LLVM,
+            #[cfg(feature = "singlepass")]
+            Self::Singlepass,
+            #[cfg(feature = "v8")]
+            Self::V8,
+            #[cfg(feature = "wamr")]
+            Self::Wamr,
+            #[cfg(feature = "wasmi")]
+            Self::Wasmi,
+        ]
+    }
+
+    /// Get an engine for this backend type
+    pub fn get_engine(
+        &self,
+        target: &Target,
+        features: &Features,
+        runtime_opts: &RuntimeOptions,
+    ) -> Result<Engine> {
+        match self {
+            #[cfg(feature = "singlepass")]
+            Self::Singlepass => {
+                let mut config = wasmer_compiler_singlepass::Singlepass::new();
+                if runtime_opts.enable_verifier {
+                    config.enable_verifier();
+                }
+                if let Some(p) = &runtime_opts.profiler {
+                    match p {
+                        Profiler::Perfmap => config.enable_perfmap(),
+                    }
+                }
+                let engine = wasmer_compiler::EngineBuilder::new(config)
+                    .set_features(Some(features.clone()))
+                    .set_target(Some(target.clone()))
+                    .engine()
+                    .into();
+                Ok(engine)
+            }
+            #[cfg(feature = "cranelift")]
+            Self::Cranelift => {
+                let mut config = wasmer_compiler_cranelift::Cranelift::new();
+                if runtime_opts.enable_verifier {
+                    config.enable_verifier();
+                }
+                if let Some(p) = &runtime_opts.profiler {
+                    match p {
+                        Profiler::Perfmap => config.enable_perfmap(),
+                    }
+                }
+                let engine = wasmer_compiler::EngineBuilder::new(config)
+                    .set_features(Some(features.clone()))
+                    .set_target(Some(target.clone()))
+                    .engine()
+                    .into();
+                Ok(engine)
+            }
+            #[cfg(feature = "llvm")]
+            Self::LLVM => {
+                use std::{fmt, fs::File, io::Write};
+
+                use wasmer_compiler_llvm::{
+                    CompiledKind, InkwellMemoryBuffer, InkwellModule, LLVMCallbacks, LLVM,
+                };
+                use wasmer_types::entity::EntityRef;
+
+                let mut config = wasmer_compiler_llvm::LLVM::new();
+
+                struct Callbacks {
+                    debug_dir: PathBuf,
+                }
+                impl Callbacks {
+                    fn new(debug_dir: PathBuf) -> Result<Self> {
+                        // Create the debug dir in case it doesn't exist
+                        std::fs::create_dir_all(&debug_dir)?;
+                        Ok(Self { debug_dir })
+                    }
+                }
+                // Converts a kind into a filename, that we will use to dump
+                // the contents of the IR object file to.
+                fn types_to_signature(types: &[Type]) -> String {
+                    types
+                        .iter()
+                        .map(|ty| match ty {
+                            Type::I32 => "i".to_string(),
+                            Type::I64 => "I".to_string(),
+                            Type::F32 => "f".to_string(),
+                            Type::F64 => "F".to_string(),
+                            Type::V128 => "v".to_string(),
+                            Type::ExternRef => "e".to_string(),
+                            Type::FuncRef => "r".to_string(),
+                            Type::ExceptionRef => "x".to_string(),
+                        })
+                        .collect::<Vec<_>>()
+                        .join("")
+                }
+                // Converts a kind into a filename, that we will use to dump
+                // the contents of the IR object file to.
+                fn function_kind_to_filename(kind: &CompiledKind) -> String {
+                    match kind {
+                        CompiledKind::Local(local_index) => {
+                            format!("function_{}", local_index.index())
+                        }
+                        CompiledKind::FunctionCallTrampoline(func_type) => format!(
+                            "trampoline_call_{}_{}",
+                            types_to_signature(func_type.params()),
+                            types_to_signature(func_type.results())
+                        ),
+                        CompiledKind::DynamicFunctionTrampoline(func_type) => format!(
+                            "trampoline_dynamic_{}_{}",
+                            types_to_signature(func_type.params()),
+                            types_to_signature(func_type.results())
+                        ),
+                        CompiledKind::Module => "module".into(),
+                    }
+                }
+                impl LLVMCallbacks for Callbacks {
+                    fn preopt_ir(&self, kind: &CompiledKind, module: &InkwellModule) {
+                        let mut path = self.debug_dir.clone();
+                        path.push(format!("{}.preopt.ll", function_kind_to_filename(kind)));
+                        module
+                            .print_to_file(&path)
+                            .expect("Error while dumping pre optimized LLVM IR");
+                    }
+                    fn postopt_ir(&self, kind: &CompiledKind, module: &InkwellModule) {
+                        let mut path = self.debug_dir.clone();
+                        path.push(format!("{}.postopt.ll", function_kind_to_filename(kind)));
+                        module
+                            .print_to_file(&path)
+                            .expect("Error while dumping post optimized LLVM IR");
+                    }
+                    fn obj_memory_buffer(
+                        &self,
+                        kind: &CompiledKind,
+                        memory_buffer: &InkwellMemoryBuffer,
+                    ) {
+                        let mut path = self.debug_dir.clone();
+                        path.push(format!("{}.o", function_kind_to_filename(kind)));
+                        let mem_buf_slice = memory_buffer.as_slice();
+                        let mut file = File::create(path)
+                            .expect("Error while creating debug object file from LLVM IR");
+                        let mut pos = 0;
+                        while pos < mem_buf_slice.len() {
+                            pos += file.write(&mem_buf_slice[pos..]).unwrap();
+                        }
+                    }
+                    fn asm_memory_buffer(
+                        &self,
+                        kind: &CompiledKind,
+                        asm_memory_buffer: &InkwellMemoryBuffer,
+                    ) {
+                        let mut path = self.debug_dir.clone();
+                        path.push(format!("{}.s", function_kind_to_filename(kind)));
+                        let mem_buf_slice = asm_memory_buffer.as_slice();
+                        let mut file = File::create(path)
+                            .expect("Error while creating debug object file from LLVM IR");
+                        let mut pos = 0;
+                        while pos < mem_buf_slice.len() {
+                            pos += file.write(&mem_buf_slice[pos..]).unwrap();
+                        }
+                    }
+                }
+
+                impl fmt::Debug for Callbacks {
+                    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                        write!(f, "LLVMCallbacks")
+                    }
+                }
+
+                if let Some(ref llvm_debug_dir) = runtime_opts.llvm_debug_dir {
+                    config.callbacks(Some(Arc::new(Callbacks::new(llvm_debug_dir.clone())?)));
+                }
+                if runtime_opts.enable_verifier {
+                    config.enable_verifier();
+                }
+
+                if runtime_opts.enable_pass_params_opt {
+                    config.enable_pass_params_opt();
+                }
+
+                if let Some(num_threads) = runtime_opts.llvm_num_threads {
+                    config.num_threads(num_threads);
+                }
+
+                if let Some(p) = &runtime_opts.profiler {
+                    match p {
+                        Profiler::Perfmap => config.enable_perfmap(),
+                    }
+                }
+
+                let engine = wasmer_compiler::EngineBuilder::new(config)
+                    .set_features(Some(features.clone()))
+                    .set_target(Some(target.clone()))
+                    .engine()
+                    .into();
+                Ok(engine)
+            }
+            #[cfg(feature = "v8")]
+            Self::V8 => Ok(wasmer::v8::V8::new().into()),
+            #[cfg(feature = "wamr")]
+            Self::Wamr => Ok(wasmer::wamr::Wamr::new().into()),
+            #[cfg(feature = "wasmi")]
+            Self::Wasmi => Ok(wasmer::wasmi::Wasmi::new().into()),
+            Self::Headless => bail!("Headless is not a valid runtime to instantiate directly"),
+            #[allow(unreachable_patterns)]
+            _ => bail!("Unsupported backend type"),
+        }
+    }
+
+    /// Check if this backend supports all the required WebAssembly features
+    #[allow(unreachable_code)]
+    pub fn supports_features(&self, required_features: &Features, target: &Target) -> bool {
+        // Map BackendType to the corresponding wasmer::BackendKind
+        let backend_kind = match self {
+            #[cfg(feature = "singlepass")]
+            Self::Singlepass => wasmer::BackendKind::Singlepass,
+            #[cfg(feature = "cranelift")]
+            Self::Cranelift => wasmer::BackendKind::Cranelift,
+            #[cfg(feature = "llvm")]
+            Self::LLVM => wasmer::BackendKind::LLVM,
+            #[cfg(feature = "v8")]
+            Self::V8 => wasmer::BackendKind::V8,
+            #[cfg(feature = "wamr")]
+            Self::Wamr => wasmer::BackendKind::Wamr,
+            #[cfg(feature = "wasmi")]
+            Self::Wasmi => wasmer::BackendKind::Wasmi,
+            Self::Headless => return false, // Headless can't compile
+            #[allow(unreachable_patterns)]
+            _ => return false,
+        };
+
+        // Get the supported features from the backend
+        let supported = wasmer::Engine::supported_features_for_backend(&backend_kind, target);
+
+        // Check if the backend supports all required features
+        if !supported.contains_features(required_features) {
+            return false;
+        }
+
+        true
+    }
+}
+
+impl From<&BackendType> for wasmer::BackendKind {
+    fn from(backend_type: &BackendType) -> Self {
+        match backend_type {
+            #[cfg(feature = "singlepass")]
+            BackendType::Singlepass => wasmer::BackendKind::Singlepass,
+            #[cfg(feature = "cranelift")]
+            BackendType::Cranelift => wasmer::BackendKind::Cranelift,
+            #[cfg(feature = "llvm")]
+            BackendType::LLVM => wasmer::BackendKind::LLVM,
+            #[cfg(feature = "v8")]
+            BackendType::V8 => wasmer::BackendKind::V8,
+            #[cfg(feature = "wamr")]
+            BackendType::Wamr => wasmer::BackendKind::Wamr,
+            #[cfg(feature = "wasmi")]
+            BackendType::Wasmi => wasmer::BackendKind::Wasmi,
+            _ => {
+                #[cfg(feature = "sys")]
+                {
+                    wasmer::BackendKind::Headless
+                }
+                #[cfg(not(feature = "sys"))]
+                {
+                    unreachable!("No backend enabled!")
+                }
+            }
+        }
+    }
+}
+
+impl std::fmt::Display for BackendType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Self::Singlepass => "singlepass",
+                Self::Cranelift => "cranelift",
+                Self::LLVM => "llvm",
+                Self::V8 => "v8",
+                Self::Wamr => "wamr",
+                Self::Wasmi => "wasmi",
+                Self::Headless => "headless",
+            }
+        )
+    }
+}
diff --git a/lib/cli/src/bin/wasmer.rs b/lib/cli/src/bin/wasmer.rs
index 482342ed73..d08b773645 100644
--- a/lib/cli/src/bin/wasmer.rs
+++ b/lib/cli/src/bin/wasmer.rs
@@ -1,6 +1,6 @@
 #[cfg(not(feature = "backend"))]
 compile_error!(
-    "Either enable at least one backend, or compile the wasmer-headless binary instead.\nWith cargo, you can provide a compiler option with the --features flag.\n\nExample values:\n\n\t\t--features cranelift,singlepass\n\t\t--features jsc\n\n\n"
+    "Either enable at least one backend, or compile the wasmer-headless binary instead.\nWith cargo, you can provide a compiler option with the --features flag.\n\nExample values:\n\n\t\t--features cranelift,singlepass\n\t\t--features jsc\n\t\t--features wamr\n\t\t--features wamr\n\t\t--features v8\n\n\n"
 );
 
 fn main() {
diff --git a/lib/cli/src/c_gen/mod.rs b/lib/cli/src/c_gen/mod.rs
index 9ae88bb2d4..c7df5c007a 100644
--- a/lib/cli/src/c_gen/mod.rs
+++ b/lib/cli/src/c_gen/mod.rs
@@ -326,7 +326,7 @@ impl CStatement {
                 w.push_str("typedef ");
                 // leaky abstraction / hack, doesn't fully solve the problem
                 if let CType::Function { .. } = source_type {
-                    source_type.generate_c_with_name(&format!("(*{})", new_name), w);
+                    source_type.generate_c_with_name(&format!("(*{new_name})"), w);
                 } else {
                     source_type.generate_c(w);
                     w.push(' ');
diff --git a/lib/cli/src/c_gen/staticlib_header.rs b/lib/cli/src/c_gen/staticlib_header.rs
index 27c10c6a1b..3767c6b6c1 100644
--- a/lib/cli/src/c_gen/staticlib_header.rs
+++ b/lib/cli/src/c_gen/staticlib_header.rs
@@ -1,69 +1,20 @@
 //! Generate a header file for the static object file produced.
 
-use wasmer_types::{ModuleInfo, Symbol, SymbolRegistry};
+use wasmer_compiler::types::symbols::{Symbol, SymbolRegistry};
+use wasmer_types::ModuleInfo;
 
 use super::{generate_c, CStatement, CType};
 
 /// Helper functions to simplify the usage of the static artifact.
 fn gen_helper_functions(atom_name: &str, module_name: &str) -> String {
     format!("
-    wasm_byte_vec_t generate_serialized_data_{atom_name}() {{
-        // We need to pass all the bytes as one big buffer so we have to do all this logic to memcpy
-        // the various pieces together from the generated header file.
-        //
-        // We should provide a `deseralize_vectored` function to avoid requiring this extra work.
-
-        char* byte_ptr = (char*)&{module_name}[0];
-
-        size_t num_function_pointers
-                = sizeof(function_pointers_{atom_name}) / sizeof(void*);
-        size_t num_function_trampolines
-                = sizeof(function_trampolines_{atom_name}) / sizeof(void*);
-        size_t num_dynamic_function_trampoline_pointers
-                = sizeof(dynamic_function_trampoline_pointers_{atom_name}) / sizeof(void*);
-
-
-        size_t buffer_size = module_bytes_len_{atom_name}
-                + sizeof(size_t) + sizeof(function_pointers_{atom_name})
-                + sizeof(size_t) + sizeof(function_trampolines_{atom_name})
-                + sizeof(size_t) + sizeof(dynamic_function_trampoline_pointers_{atom_name});
-
-        char* memory_buffer = (char*) malloc(buffer_size);
-        size_t current_offset = 0;
-
-        memcpy(memory_buffer + current_offset, byte_ptr, module_bytes_len_{atom_name});
-        current_offset += module_bytes_len_{atom_name};
-
-        memcpy(memory_buffer + current_offset, (void*)&num_function_pointers, sizeof(size_t));
-        current_offset += sizeof(size_t);
-
-        memcpy(memory_buffer + current_offset, (void*)&function_pointers_{atom_name}[0], sizeof(function_pointers_{atom_name}));
-        current_offset += sizeof(function_pointers_{atom_name});
-
-        memcpy(memory_buffer + current_offset, (void*)&num_function_trampolines, sizeof(size_t));
-        current_offset += sizeof(size_t);
-
-        memcpy(memory_buffer + current_offset, (void*)&function_trampolines_{atom_name}[0], sizeof(function_trampolines_{atom_name}));
-        current_offset += sizeof(function_trampolines_{atom_name});
-
-        memcpy(memory_buffer + current_offset, (void*)&num_dynamic_function_trampoline_pointers, sizeof(size_t));
-        current_offset += sizeof(size_t);
-
-        memcpy(memory_buffer + current_offset, (void*)&dynamic_function_trampoline_pointers_{atom_name}[0], sizeof(dynamic_function_trampoline_pointers_{atom_name}));
-        current_offset += sizeof(dynamic_function_trampoline_pointers_{atom_name});
-
-        wasm_byte_vec_t module_byte_vec = {{
-                .size = buffer_size,
-                .data = memory_buffer,
-        }};
-        return module_byte_vec;
-    }}
-
     wasm_module_t* wasmer_object_module_new_{atom_name}(wasm_store_t* store, const char* wasm_name) {{
             // wasm_name intentionally unused for now: will be used in the future.
-            wasm_byte_vec_t module_byte_vec = generate_serialized_data_{atom_name}();
+            wasm_byte_vec_t module_byte_vec = {{
+                .size = module_bytes_len_{atom_name},
+                .data = (char*)&{module_name}[0],
+            }};
             wasm_module_t* module = wasm_module_deserialize(store, &module_byte_vec);
-            free(module_byte_vec.data);
 
             return module;
     }}
@@ -134,41 +85,6 @@ pub fn generate_header_file(
     });
     c_statements.extend(function_declarations);
 
-    // function pointer array
-    {
-        let function_pointer_array_statements = module_info
-            .functions
-            .iter()
-            .filter_map(|(f_index, sig_index)| {
-                Some((module_info.local_func_index(f_index)?, sig_index))
-            })
-            .map(|(function_local_index, _sig_index)| {
-                let function_name =
-                    symbol_registry.symbol_to_name(Symbol::LocalFunction(function_local_index));
-                // TODO: figure out the signature here too
-
-                CStatement::Cast {
-                    target_type: CType::void_ptr(),
-                    expression: Box::new(CStatement::LiteralConstant {
-                        value: function_name,
-                    }),
-                }
-            })
-            .collect::<Vec<_>>();
-
-        c_statements.push(CStatement::Declaration {
-            name: format!("function_pointers_{atom_name}"),
-            is_extern: false,
-            is_const: true,
-            ctype: CType::Array {
-                inner: Box::new(CType::void_ptr()),
-            },
-            definition: Some(Box::new(CStatement::LiteralArray {
-                items: function_pointer_array_statements,
-            })),
-        });
-    }
-
     let func_trampoline_declarations =
         module_info
             .signatures
@@ -198,33 +114,6 @@ pub fn generate_header_file(
     });
     c_statements.extend(func_trampoline_declarations);
 
-    // function trampolines
-    {
-        let function_trampoline_statements = module_info
-            .signatures
-            .iter()
-            .map(|(sig_index, _vm_shared_index)| {
-                let function_name =
-                    symbol_registry.symbol_to_name(Symbol::FunctionCallTrampoline(sig_index));
-                CStatement::LiteralConstant {
-                    value: function_name,
-                }
-            })
-            .collect::<Vec<_>>();
-
-        c_statements.push(CStatement::Declaration {
-            name: format!("function_trampolines_{atom_name}"),
-            is_extern: false,
-            is_const: true,
-            ctype: CType::Array {
-                inner: Box::new(CType::void_ptr()),
-            },
-            definition: Some(Box::new(CStatement::LiteralArray {
-                items: function_trampoline_statements,
-            })),
-        });
-    }
-
     let dyn_func_declarations = module_info
         .functions
         .keys()
@@ -262,33 +151,6 @@ pub fn generate_header_file(
         new_name: "dyn_func_trampoline_t".to_string(),
     });
 
-    // dynamic function trampoline pointer array
-    {
-        let dynamic_function_trampoline_statements = module_info
-            .functions
-            .keys()
-            .take(module_info.num_imported_functions)
-            .map(|func_index| {
-                let function_name =
-                    symbol_registry.symbol_to_name(Symbol::DynamicFunctionTrampoline(func_index));
-                CStatement::LiteralConstant {
-                    value: function_name,
-                }
-            })
-            .collect::<Vec<_>>();
-        c_statements.push(CStatement::Declaration {
-            name: format!("dynamic_function_trampoline_pointers_{atom_name}"),
-            is_extern: false,
-            is_const: true,
-            ctype: CType::Array {
-                inner: Box::new(CType::TypeDef("dyn_func_trampoline_t".to_string())),
-            },
-            definition: Some(Box::new(CStatement::LiteralArray {
-                items: dynamic_function_trampoline_statements,
-            })),
-        });
-    }
-
     c_statements.push(CStatement::LiteralConstant {
         value: gen_helper_functions(atom_name, &symbol_registry.symbol_to_name(Symbol::Metadata)),
     });
diff --git a/lib/cli/src/commands/add.rs b/lib/cli/src/commands/add.rs
index 44cba7ae88..83b232143b 100644
--- a/lib/cli/src/commands/add.rs
+++ b/lib/cli/src/commands/add.rs
@@ -1,12 +1,17 @@
-use std::process::{Command, Stdio};
-
+use super::AsyncCliCommand;
+use crate::config::WasmerEnv;
 use anyhow::{Context, Error};
 use clap::Parser;
-use wasmer_registry::{wasmer_env::WasmerEnv, Bindings, ProgrammingLanguage};
+use std::process::{Command, Stdio};
+use wasmer_backend_api::{
+    types::{Bindings, ProgrammingLanguage},
+    WasmerClient,
+};
+use wasmer_config::package::NamedPackageIdent;
 
 /// Add a Wasmer package's bindings to your application.
 #[derive(Debug, Parser)]
-pub struct Add {
+pub struct CmdAdd {
     #[clap(flatten)]
     env: WasmerEnv,
     /// Add the JavaScript bindings using "npm install".
@@ -25,20 +30,19 @@ pub struct Add {
     #[clap(long, groups = &["bindings", "py"])]
     pip: bool,
     /// The packages to add (e.g. "wasmer/wasmer-pack@0.5.0" or "python/python")
-    packages: Vec<wasmer_registry::Package>,
+    packages: Vec<NamedPackageIdent>,
 }
 
-impl Add {
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdAdd {
+    type Output = ();
+
     /// Execute [`Add`].
-    pub fn execute(&self) -> Result<(), Error> {
+    async fn run_async(self) -> Result<Self::Output, anyhow::Error> {
         anyhow::ensure!(!self.packages.is_empty(), "No packages specified");
 
-        let registry = self
-            .env
-            .registry_endpoint()
-            .context("Unable to determine which registry to use")?;
-
-        let bindings = self.lookup_bindings(registry.as_str())?;
+        let client = self.env.client_unauthennticated()?;
+        let bindings = self.lookup_bindings(&client).await?;
 
         let mut cmd = self.target()?.command(&bindings)?;
         cmd.stdin(Stdio::null())
@@ -58,15 +62,18 @@ impl Add {
 
         Ok(())
     }
+}
 
-    fn lookup_bindings(&self, registry: &str) -> Result<Vec<Bindings>, Error> {
+impl CmdAdd {
+    async fn lookup_bindings(&self, client: &WasmerClient) -> Result<Vec<Bindings>, Error> {
         println!("Querying Wasmer for package bindings");
 
         let mut bindings_to_add = Vec::new();
         let language = self.target()?.language();
 
         for pkg in &self.packages {
-            let bindings = lookup_bindings_for_package(registry, pkg, &language)
+            let bindings = lookup_bindings_for_package(client, pkg, &language)
+                .await
                 .with_context(|| format!("Unable to find bindings for {pkg}"))?;
             bindings_to_add.push(bindings);
         }
@@ -90,18 +97,22 @@ impl Add {
     }
 }
 
-fn lookup_bindings_for_package(
-    registry: &str,
-    pkg: &wasmer_registry::Package,
+async fn lookup_bindings_for_package(
+    client: &WasmerClient,
+    pkg: &NamedPackageIdent,
     language: &ProgrammingLanguage,
 ) -> Result<Bindings, Error> {
-    let all_bindings =
-        wasmer_registry::list_bindings(registry, &pkg.package(), pkg.version.as_deref())?;
+    let all_bindings = wasmer_backend_api::query::list_bindings(
+        client,
+        &pkg.name,
+        pkg.version_opt().map(|v| v.to_string()).as_deref(),
+    )
+    .await?;
 
     match all_bindings.iter().find(|b| b.language == *language) {
         Some(b) => {
             let Bindings { url, generator, .. } = b;
-            log::debug!("Found {pkg} bindings generated by {generator} at {url}");
+            log::debug!("Found {pkg} bindings generated by {generator:?} at {url}");
 
             Ok(b.clone())
         }
@@ -126,9 +137,9 @@ enum Target {
 impl Target {
     fn language(self) -> ProgrammingLanguage {
         match self {
-            Target::Pip => ProgrammingLanguage::PYTHON,
+            Target::Pip => ProgrammingLanguage::Python,
             Target::Pnpm { .. } | Target::Yarn { .. } | Target::Npm { .. } => {
-                ProgrammingLanguage::JAVASCRIPT
+                ProgrammingLanguage::Javascript
             }
         }
     }
diff --git a/lib/cli/src/commands/app/create.rs b/lib/cli/src/commands/app/create.rs
index b98ec43da0..701fd3a516 100644
--- a/lib/cli/src/commands/app/create.rs
+++ b/lib/cli/src/commands/app/create.rs
@@ -1,7 +1,6 @@
 //! Create a new Edge app.
 
 use std::{
-    collections::HashMap,
     env,
     io::Cursor,
     path::{Path, PathBuf},
@@ -13,8 +12,9 @@ use anyhow::Context;
 use colored::Colorize;
 use dialoguer::{theme::ColorfulTheme, Confirm, Select};
 use futures::stream::TryStreamExt;
+use indexmap::IndexMap;
 use is_terminal::IsTerminal;
-use wasmer_api::{
+use wasmer_backend_api::{
     types::{AppTemplate, TemplateLanguage},
     WasmerClient,
 };
@@ -28,7 +28,10 @@ use crate::{
     utils::{load_package_manifest, prompts::PackageCheckMode},
 };
 
-async fn write_app_config(app_config: &AppConfigV1, dir: Option<PathBuf>) -> anyhow::Result<()> {
+pub(crate) async fn write_app_config(
+    app_config: &AppConfigV1,
+    dir: Option<PathBuf>,
+) -> anyhow::Result<()> {
     let raw_app_config = app_config.clone().to_yaml()?;
 
     let app_dir = match dir {
@@ -49,6 +52,28 @@ async fn write_app_config(app_config: &AppConfigV1, dir: Option<PathBuf>) -> any
         })
 }
 
+pub(crate) fn minimal_app_config(owner: &str, name: &str) -> AppConfigV1 {
+    AppConfigV1 {
+        name: Some(String::from(name)),
+        owner: Some(String::from(owner)),
+        package: PackageSource::Path(String::from(".")),
+        app_id: None,
+        domains: None,
+        env: IndexMap::new(),
+        cli_args: None,
+        capabilities: None,
+        scheduled_tasks: None,
+        volumes: None,
+        health_checks: None,
+        debug: None,
+        scaling: None,
+        locality: None,
+        redirect: None,
+        extra: IndexMap::new(),
+        jobs: None,
+    }
+}
+
 /// Create a new Edge app.
 #[derive(clap::Parser, Debug)]
 pub struct CmdAppCreate {
@@ -132,12 +157,12 @@ impl CmdAppCreate {
     #[inline]
     fn get_app_config(&self, owner: &str, name: &str, package: &str) -> AppConfigV1 {
         AppConfigV1 {
-            name: String::from(name),
+            name: Some(String::from(name)),
             owner: Some(String::from(owner)),
             package: PackageSource::from_str(package).unwrap(),
             app_id: None,
             domains: None,
-            env: HashMap::new(),
+            env: IndexMap::new(),
             cli_args: None,
             capabilities: None,
             scheduled_tasks: None,
@@ -147,7 +172,8 @@ impl CmdAppCreate {
             scaling: None,
             locality: None,
             redirect: None,
-            extra: HashMap::new(),
+            extra: IndexMap::new(),
+            jobs: None,
         }
     }
 
@@ -173,7 +199,7 @@ impl CmdAppCreate {
             }),
         };
 
-        crate::utils::prompts::prompt_for_ident(
+        crate::utils::prompts::prompt_for_app_ident(
             "What should be the name of the app?",
             default_name.as_deref(),
         )
@@ -190,7 +216,7 @@ impl CmdAppCreate {
         }
 
         let user = if let Some(client) = client {
-            Some(wasmer_api::query::current_user_with_namespaces(client, None).await?)
+            Some(wasmer_backend_api::query::current_user_with_namespaces(client, None).await?)
         } else {
             None
         };
@@ -264,7 +290,7 @@ impl CmdAppCreate {
         if self.use_local_manifest || ask_confirmation()? {
             let app_config = self.get_app_config(owner, app_name, ".");
             write_app_config(&app_config, self.app_dir_path.clone()).await?;
-            self.try_deploy(owner, app_name, None).await?;
+            self.try_deploy(owner, app_name, None, false, false).await?;
             return Ok(true);
         }
 
@@ -286,7 +312,8 @@ impl CmdAppCreate {
         if let Some(pkg) = &self.package {
             let app_config = self.get_app_config(owner, app_name, pkg);
             write_app_config(&app_config, Some(output_path.clone())).await?;
-            self.try_deploy(owner, app_name, Some(&output_path)).await?;
+            self.try_deploy(owner, app_name, Some(&output_path), false, false)
+                .await?;
             return Ok(true);
         } else if !self.non_interactive {
             let (package_id, _) = crate::utils::prompts::prompt_for_package(
@@ -303,7 +330,8 @@ impl CmdAppCreate {
 
             let app_config = self.get_app_config(owner, app_name, &package_id.to_string());
             write_app_config(&app_config, Some(output_path.clone())).await?;
-            self.try_deploy(owner, app_name, Some(&output_path)).await?;
+            self.try_deploy(owner, app_name, Some(&output_path), false, false)
+                .await?;
             return Ok(true);
         } else {
             eprintln!(
@@ -359,10 +387,10 @@ impl CmdAppCreate {
         // Fetch the first page.
         // If first item matches, then no need to re-fetch.
         //
-        let stream = wasmer_api::query::fetch_all_app_templates_from_language(
+        let stream = wasmer_backend_api::query::fetch_all_app_templates_from_language(
             client,
             10,
-            Some(wasmer_api::types::AppTemplatesSortBy::Newest),
+            Some(wasmer_backend_api::types::AppTemplatesSortBy::Newest),
             language.to_string(),
         );
 
@@ -446,7 +474,7 @@ impl CmdAppCreate {
         // Either no cache present, or cache has exceeded max age.
         // Fetch the first page.
         // If first item matches, then no need to re-fetch.
-        let mut stream = Box::pin(wasmer_api::query::fetch_all_app_template_languages(
+        let mut stream = Box::pin(wasmer_backend_api::query::fetch_all_app_template_languages(
             client, None,
         ));
 
@@ -489,7 +517,8 @@ impl CmdAppCreate {
             if let Ok(url) = url::Url::parse(template) {
                 url
             } else if let Some(template) =
-                wasmer_api::query::fetch_app_template_from_slug(client, template.clone()).await?
+                wasmer_backend_api::query::fetch_app_template_from_slug(client, template.clone())
+                    .await?
             {
                 url::Url::parse(&template.repo_url)?
             } else {
@@ -685,6 +714,9 @@ impl CmdAppCreate {
             AppConfigV1::parse_yaml(&raw_app)?;
 
             tokio::fs::write(&app_yaml_path, raw_app).await?;
+        } else {
+            let app_config = minimal_app_config(owner, app_name);
+            write_app_config(&app_config, Some(output_path.clone())).await?;
         }
 
         let build_md_path = output_path.join("BUILD.md");
@@ -710,7 +742,8 @@ the app:\n"
                 format!("{bin_name} deploy").bold()
             )
         } else {
-            self.try_deploy(owner, app_name, Some(&output_path)).await?;
+            self.try_deploy(owner, app_name, Some(&output_path), false, false)
+                .await?;
         }
 
         Ok(true)
@@ -721,16 +754,23 @@ the app:\n"
         owner: &str,
         app_name: &str,
         path: Option<&Path>,
+        build_remote: bool,
+        skip_prompt: bool,
     ) -> anyhow::Result<()> {
         let interactive = !self.non_interactive;
         let theme = dialoguer::theme::ColorfulTheme::default();
 
-        if self.deploy_app
-            || (interactive
-                && Confirm::with_theme(&theme)
-                    .with_prompt("Do you want to deploy the app now?")
-                    .interact()?)
-        {
+        let mut should_deploy = self.deploy_app;
+
+        if skip_prompt {
+            should_deploy = true;
+        } else if !should_deploy && interactive {
+            should_deploy = Confirm::with_theme(&theme)
+                .with_prompt("Do you want to deploy the app now?")
+                .interact()?;
+        }
+
+        if should_deploy {
             let cmd_deploy = CmdAppDeploy {
                 quiet: false,
                 env: self.env.clone(),
@@ -739,7 +779,7 @@ the app:\n"
                 },
                 no_validate: false,
                 non_interactive: self.non_interactive,
-                publish_package: true,
+                publish_package: !build_remote,
                 dir: self.app_dir_path.clone(),
                 path: path.map(|v| v.to_path_buf()),
                 no_wait: self.no_wait,
@@ -748,9 +788,11 @@ the app:\n"
                 owner: Some(String::from(owner)),
                 app_name: Some(app_name.into()),
                 bump: false,
+                build_remote,
                 template: None,
                 package: None,
                 use_local_manifest: self.use_local_manifest,
+                ensure_app_config: true,
             };
             cmd_deploy.run_async().await?;
         }
@@ -797,21 +839,56 @@ impl AsyncCliCommand for CmdAppCreate {
                         .await?;
                 } else {
                     let theme = ColorfulTheme::default();
+                    let working_dir = if let Some(dir) = &self.app_dir_path {
+                        dir.clone()
+                    } else {
+                        std::env::current_dir()?
+                    };
+
+                    let remote_option_available = working_dir.is_dir()
+                        && std::fs::read_dir(&working_dir)?.next().is_some()
+                        && !working_dir.join(AppConfigV1::CANONICAL_FILE_NAME).exists()
+                        && load_package_manifest(&working_dir)?.is_none();
+
+                    let mut items = Vec::new();
+                    let mut remote_idx = None;
+                    if remote_option_available {
+                        remote_idx = Some(items.len());
+                        items.push(String::from(
+                            "Deploy the current directory with a remote build",
+                        ));
+                    }
+                    let template_idx = items.len();
+                    items.push(String::from("Start with a template"));
+                    let package_idx = items.len();
+                    items.push(String::from("Choose an existing package"));
+
                     let choice = Select::with_theme(&theme)
                         .with_prompt("What would you like to deploy?")
-                        .items(&["Start with a template", "Choose an existing package"])
+                        .items(&items)
                         .default(0)
                         .interact()?;
-                    match choice {
-                        0 => {
-                            self.create_from_template(client.as_ref(), &owner, &app_name)
-                                .await?
-                        }
-                        1 => {
-                            self.create_from_package(client.as_ref(), &owner, &app_name)
-                                .await?
-                        }
-                        x => panic!("unhandled selection {x}"),
+
+                    if remote_idx.is_some() && Some(choice) == remote_idx {
+                        let app_config = minimal_app_config(owner.as_str(), app_name.as_str());
+                        write_app_config(&app_config, Some(working_dir.clone())).await?;
+                        self.try_deploy(
+                            owner.as_str(),
+                            app_name.as_str(),
+                            Some(&working_dir),
+                            true,
+                            true,
+                        )
+                        .await?;
+                        return Ok(());
+                    } else if choice == template_idx {
+                        self.create_from_template(client.as_ref(), &owner, &app_name)
+                            .await?
+                    } else if choice == package_idx {
+                        self.create_from_package(client.as_ref(), &owner, &app_name)
+                            .await?
+                    } else {
+                        panic!("unhandled selection {choice}");
                     };
                 }
             } else {
diff --git a/lib/cli/src/commands/app/database/list.rs b/lib/cli/src/commands/app/database/list.rs
new file mode 100644
index 0000000000..161c6bc1a8
--- /dev/null
+++ b/lib/cli/src/commands/app/database/list.rs
@@ -0,0 +1,51 @@
+//! List volumes tied to an edge app.
+
+use super::super::util::AppIdentOpts;
+use crate::{commands::AsyncCliCommand, config::WasmerEnv, opts::ListFormatOpts};
+
+/// List the volumes of an app.
+#[derive(clap::Parser, Debug)]
+pub struct CmdAppDatabaseList {
+    #[clap(flatten)]
+    fmt: ListFormatOpts,
+
+    #[clap(flatten)]
+    env: WasmerEnv,
+
+    #[clap(flatten)]
+    ident: AppIdentOpts,
+
+    #[clap(long, help = "Include password in the output")]
+    pub with_password: bool,
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdAppDatabaseList {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        let client = self.env.client()?;
+
+        let (_ident, app) = self.ident.load_app(&client).await?;
+        let mut dbs = wasmer_backend_api::query::get_app_databases(
+            &client,
+            &app.owner.global_name,
+            &app.name,
+        )
+        .await?;
+
+        if !self.with_password {
+            dbs.iter_mut().for_each(|db| {
+                db.password = None;
+            });
+        }
+
+        if dbs.is_empty() {
+            eprintln!("App {} has no databases!", app.name);
+        } else {
+            println!("{}", self.fmt.format.render(dbs.as_slice()));
+        }
+
+        Ok(())
+    }
+}
diff --git a/lib/cli/src/commands/app/database/mod.rs b/lib/cli/src/commands/app/database/mod.rs
new file mode 100644
index 0000000000..b7ed9fe42f
--- /dev/null
+++ b/lib/cli/src/commands/app/database/mod.rs
@@ -0,0 +1,24 @@
+use crate::commands::AsyncCliCommand;
+
+pub mod list;
+
+/// App volume management.
+#[derive(Debug, clap::Parser)]
+pub enum CmdAppDatabase {
+    //  Credentials(credentials::CmdAppDatabaseCredentials),
+    List(list::CmdAppDatabaseList),
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdAppDatabase {
+    type Output = ();
+
+    async fn run_async(self) -> Result<Self::Output, anyhow::Error> {
+        match self {
+            Self::List(c) => {
+                c.run_async().await?;
+                Ok(())
+            }
+        }
+    }
+}
diff --git a/lib/cli/src/commands/app/delete.rs b/lib/cli/src/commands/app/delete.rs
index fb5b23e6e4..6ae4ca19db 100644
--- a/lib/cli/src/commands/app/delete.rs
+++ b/lib/cli/src/commands/app/delete.rs
@@ -33,7 +33,7 @@ impl AsyncCliCommand for CmdAppDelete {
         if interactive {
             let theme = dialoguer::theme::ColorfulTheme::default();
             let should_use = Confirm::with_theme(&theme)
-                .with_prompt(&format!(
+                .with_prompt(format!(
                     "Really delete the app '{}/{}'? (id: {})",
                     app.owner.global_name,
                     app.name,
@@ -53,7 +53,7 @@ impl AsyncCliCommand for CmdAppDelete {
             app.name,
             app.id.inner(),
         );
-        wasmer_api::query::delete_app(&client, app.id.into_inner()).await?;
+        wasmer_backend_api::query::delete_app(&client, app.id.into_inner()).await?;
 
         eprintln!("App '{}/{}' was deleted!", app.owner.global_name, app.name);
 
diff --git a/lib/cli/src/commands/app/deploy.rs b/lib/cli/src/commands/app/deploy.rs
index fda80cb800..7e5095a46c 100644
--- a/lib/cli/src/commands/app/deploy.rs
+++ b/lib/cli/src/commands/app/deploy.rs
@@ -1,27 +1,34 @@
 use super::{util::login_user, AsyncCliCommand};
 use crate::{
-    commands::{app::create::CmdAppCreate, package::publish::PackagePublish, PublishWait},
+    commands::{
+        app::create::{minimal_app_config, write_app_config, CmdAppCreate},
+        package::publish::PackagePublish,
+        PublishWait,
+    },
     config::WasmerEnv,
     opts::ItemFormatOpts,
-    utils::load_package_manifest,
+    utils::{load_package_manifest, DEFAULT_PACKAGE_MANIFEST_FILE},
 };
 use anyhow::Context;
+use bytesize::ByteSize;
 use colored::Colorize;
-use dialoguer::Confirm;
+use dialoguer::{theme::ColorfulTheme, Confirm};
+use indexmap::IndexMap;
 use is_terminal::IsTerminal;
 use std::io::Write;
-use std::{path::PathBuf, str::FromStr, time::Duration};
-use wasmer_api::{
-    types::{DeployApp, DeployAppVersion},
+use std::{path::Path, path::PathBuf, str::FromStr, time::Duration};
+use wasmer_backend_api::{
+    types::{AutoBuildDeployAppLogKind, DeployApp, DeployAppVersion},
     WasmerClient,
 };
 use wasmer_config::{
     app::AppConfigV1,
     package::{PackageIdent, PackageSource},
 };
+use wasmer_sdk::app::deploy_remote_build::{
+    deploy_app_remote, DeployRemoteEvent, DeployRemoteOpts,
+};
 
-// TODO: apparently edge-util uses a different version of the http crate, which makes the
-// HEADER_APP_VERSION_ID field incompatible with our use here, so it needs to be redeclared.
 static EDGE_HEADER_APP_VERSION_ID: http::HeaderName =
     http::HeaderName::from_static("x-edge-app-version-id");
 
@@ -65,7 +72,7 @@ pub struct CmdAppDeploy {
     #[clap(long)]
     pub no_default: bool,
 
-    /// Do not persist the app version ID in the app.yaml.
+    /// Do not persist the app ID under `app_id` field in app.yaml.
     #[clap(long)]
     pub no_persist_id: bool,
 
@@ -97,6 +104,10 @@ pub struct CmdAppDeploy {
     #[clap(long)]
     pub quiet: bool,
 
+    /// Use Wasmer's remote autobuild pipeline instead of building locally.
+    #[clap(long)]
+    pub build_remote: bool,
+
     // - App creation -
     /// A reference to the template to use when creating an app to deploy.
     ///
@@ -121,6 +132,16 @@ pub struct CmdAppDeploy {
     /// Whether or not to search (and use) a local manifest when creating an app to deploy.
     #[clap(long, conflicts_with = "template", conflicts_with = "package")]
     pub use_local_manifest: bool,
+
+    #[clap(skip)]
+    pub ensure_app_config: bool,
+}
+
+struct RemoteBuildInput {
+    app_config: AppConfigV1,
+    owner: String,
+    original_config: Option<serde_yaml::Value>,
+    config_path: Option<PathBuf>,
 }
 
 impl CmdAppDeploy {
@@ -133,7 +154,7 @@ impl CmdAppDeploy {
         let (manifest_path, manifest) = match load_package_manifest(&manifest_dir_path)? {
             Some(r) => r,
             None => anyhow::bail!(
-                "Could not read or find manifest in path '{}'!",
+                "Could not read or find wasmer.toml manifest in path '{}'!",
                 manifest_dir_path.display()
             ),
         };
@@ -187,7 +208,7 @@ impl CmdAppDeploy {
             anyhow::bail!("No owner specified: use --owner XXX");
         }
 
-        let user = wasmer_api::query::current_user_with_namespaces(client, None).await?;
+        let user = wasmer_backend_api::query::current_user_with_namespaces(client, None).await?;
         let owner = crate::utils::prompts::prompt_for_namespace(
             "Who should own this app?",
             None,
@@ -225,6 +246,297 @@ impl CmdAppDeploy {
 
         create_cmd.run_async().await
     }
+
+    fn resolve_app_paths(&self) -> anyhow::Result<(PathBuf, PathBuf)> {
+        let base = if let Some(dir) = &self.dir {
+            dir.clone()
+        } else if let Some(path) = &self.path {
+            path.clone()
+        } else {
+            std::env::current_dir()
+                .context("could not determine current directory for deployment")?
+        };
+
+        if base.is_file() {
+            let base_dir = base
+                .parent()
+                .map(PathBuf::from)
+                .context("could not determine parent directory for app config")?;
+            Ok((base, base_dir))
+        } else if base.is_dir() {
+            let config = base.join(AppConfigV1::CANONICAL_FILE_NAME);
+            Ok((config, base))
+        } else {
+            anyhow::bail!("No such file or directory '{}'", base.display());
+        }
+    }
+
+    async fn handle_remote_build(&self, client: &WasmerClient) -> anyhow::Result<()> {
+        let (app_config_path, base_dir_path) = self.resolve_app_paths()?;
+        let wait = if self.no_wait {
+            WaitMode::Deployed
+        } else {
+            WaitMode::Reachable
+        };
+
+        let prep = if app_config_path.is_file() {
+            self.prepare_remote_build_from_file(client, &app_config_path, &base_dir_path)
+                .await?
+        } else {
+            self.prepare_remote_build_without_config(client, &base_dir_path)
+                .await?
+        };
+
+        let RemoteBuildInput {
+            app_config,
+            owner,
+            original_config,
+            config_path,
+        } = prep;
+
+        let opts = DeployAppOpts {
+            app: &app_config,
+            original_config: original_config.clone(),
+            allow_create: true,
+            make_default: !self.no_default,
+            owner: Some(owner.clone()),
+            wait,
+        };
+
+        let app_version = deploy_app_remote(
+            client,
+            DeployRemoteOpts {
+                app: app_config.clone(),
+                owner: Some(owner.clone()),
+            },
+            &base_dir_path,
+            remote_progress_handler(self.quiet),
+        )
+        .await?;
+
+        if let Some(path) = config_path {
+            let mut new_app_config = app_config_from_api(&app_version)?;
+
+            if self.no_persist_id {
+                new_app_config.app_id = None;
+            }
+
+            new_app_config.package = app_config.package.clone();
+
+            if new_app_config != app_config {
+                let new_merged = crate::utils::merge_yaml_values(
+                    &app_config.clone().to_yaml_value()?,
+                    &new_app_config.to_yaml_value()?,
+                );
+                let new_config_raw = serde_yaml::to_string(&new_merged)?;
+                std::fs::write(&path, new_config_raw)
+                    .with_context(|| format!("Could not write file: '{}'", path.display()))?;
+            }
+        }
+
+        wait_app(client, opts.clone(), app_version.clone(), self.quiet).await?;
+
+        if self.fmt.format == Some(crate::utils::render::ItemFormat::Json) {
+            println!("{}", serde_json::to_string_pretty(&app_version)?);
+        }
+
+        Ok(())
+    }
+
+    async fn prepare_remote_build_from_file(
+        &self,
+        client: &WasmerClient,
+        app_config_path: &Path,
+        base_dir_path: &Path,
+    ) -> anyhow::Result<RemoteBuildInput> {
+        let config_str = std::fs::read_to_string(app_config_path)
+            .with_context(|| format!("Could not read file '{}'", app_config_path.display()))?;
+
+        let mut app_yaml: serde_yaml::Value = serde_yaml::from_str(&config_str)?;
+        let maybe_edge_app = if let Some(app_id) = app_yaml.get("app_id").and_then(|s| s.as_str()) {
+            wasmer_backend_api::query::get_app_by_id(client, app_id.to_owned())
+                .await
+                .ok()
+        } else {
+            None
+        };
+
+        let mut owner = self
+            .get_owner(client, &mut app_yaml, maybe_edge_app.as_ref())
+            .await?;
+        let previous_owner = owner.clone();
+        owner = self.ensure_owner_access(client, owner).await?;
+
+        let mapping = app_yaml
+            .as_mapping_mut()
+            .context("app config must be a mapping")?;
+        mapping.insert("owner".into(), owner.clone().into());
+        if owner != previous_owner {
+            mapping.remove("app_id");
+            mapping.remove("name");
+        }
+
+        if mapping.get("name").is_none() && self.app_name.is_some() {
+            mapping.insert(
+                "name".into(),
+                self.app_name.as_ref().unwrap().to_string().into(),
+            );
+        } else if mapping.get("name").is_none() && maybe_edge_app.is_some() {
+            mapping.insert(
+                "name".into(),
+                maybe_edge_app.as_ref().unwrap().name.to_string().into(),
+            );
+        } else if mapping.get("name").is_none() {
+            if !self.non_interactive {
+                let default_name = base_dir_path
+                    .file_name()
+                    .and_then(|f| f.to_str())
+                    .map(|s| s.to_owned());
+                let app_name = crate::utils::prompts::prompt_new_app_name(
+                    "Enter the name of the app",
+                    default_name.as_deref(),
+                    &owner,
+                    Some(client),
+                )
+                .await?;
+
+                mapping.insert("name".into(), app_name.into());
+            } else {
+                if !self.quiet {
+                    eprintln!("The app.yaml does not specify any app name.");
+                    eprintln!(
+                        "Please, use the --app_name <app_name> to specify the name of the app."
+                    );
+                }
+
+                anyhow::bail!(
+                    "Cannot proceed with the deployment as the app spec in path {} does not have\n                        a 'name' field.",
+                    app_config_path.display()
+                );
+            }
+        }
+
+        let current_config: AppConfigV1 = serde_yaml::from_value(app_yaml.clone())?;
+        std::fs::write(app_config_path, serde_yaml::to_string(&current_config)?)
+            .with_context(|| format!("Could not write file: '{}'", app_config_path.display()))?;
+
+        let mut app_config = current_config.clone();
+        app_config.owner = Some(owner.clone());
+
+        match &app_config.package {
+            PackageSource::Path(_) => {}
+            other => {
+                anyhow::bail!(
+                    "remote deployments require the app's package to reference a local path (found `{other}`)"
+                );
+            }
+        }
+
+        let original_config = Some(app_config.clone().to_yaml_value()?);
+
+        Ok(RemoteBuildInput {
+            app_config,
+            owner,
+            original_config,
+            config_path: Some(app_config_path.to_path_buf()),
+        })
+    }
+
+    async fn prepare_remote_build_without_config(
+        &self,
+        client: &WasmerClient,
+        base_dir_path: &Path,
+    ) -> anyhow::Result<RemoteBuildInput> {
+        let initial_owner = if let Some(owner) = &self.owner {
+            owner.clone()
+        } else if self.non_interactive {
+            anyhow::bail!("No owner specified: use --owner XXX");
+        } else {
+            let user =
+                wasmer_backend_api::query::current_user_with_namespaces(client, None).await?;
+            crate::utils::prompts::prompt_for_namespace(
+                "Who should own this app?",
+                None,
+                Some(&user),
+            )?
+        };
+
+        let owner = self.ensure_owner_access(client, initial_owner).await?;
+
+        let app_name = if let Some(name) = &self.app_name {
+            name.clone()
+        } else if self.non_interactive {
+            anyhow::bail!("Cannot determine app name: use --app_name <app_name>");
+        } else {
+            let default_name = base_dir_path
+                .file_name()
+                .and_then(|f| f.to_str())
+                .map(|s| s.to_owned());
+            crate::utils::prompts::prompt_new_app_name(
+                "Enter the name of the app",
+                default_name.as_deref(),
+                &owner,
+                Some(client),
+            )
+            .await?
+        };
+
+        let app_config = AppConfigV1 {
+            name: Some(app_name.clone()),
+            app_id: None,
+            owner: Some(owner.clone()),
+            package: PackageSource::Path(String::from(".")),
+            domains: None,
+            locality: None,
+            env: IndexMap::new(),
+            cli_args: None,
+            capabilities: None,
+            scheduled_tasks: None,
+            volumes: None,
+            health_checks: None,
+            debug: None,
+            scaling: None,
+            redirect: None,
+            jobs: None,
+            extra: IndexMap::new(),
+        };
+
+        let original_config = Some(app_config.clone().to_yaml_value()?);
+
+        Ok(RemoteBuildInput {
+            app_config,
+            owner,
+            original_config,
+            config_path: None,
+        })
+    }
+
+    async fn ensure_owner_access(
+        &self,
+        client: &WasmerClient,
+        owner: String,
+    ) -> anyhow::Result<String> {
+        if wasmer_backend_api::query::viewer_can_deploy_to_namespace(client, &owner).await? {
+            return Ok(owner);
+        }
+
+        eprintln!("It seems you don't have access to {}", owner.bold());
+        if self.non_interactive {
+            anyhow::bail!(
+                "Please, change the owner before deploying or check your current user with `{} whoami`.",
+                std::env::args().next().unwrap_or("wasmer".into())
+            );
+        }
+
+        let user = wasmer_backend_api::query::current_user_with_namespaces(client, None).await?;
+        let owner = crate::utils::prompts::prompt_for_namespace(
+            "Who should own this app?",
+            None,
+            Some(&user),
+        )?;
+
+        Ok(owner)
+    }
 }
 
 #[async_trait::async_trait]
@@ -234,26 +546,53 @@ impl AsyncCliCommand for CmdAppDeploy {
     async fn run_async(self) -> Result<Self::Output, anyhow::Error> {
         let client = login_user(&self.env, !self.non_interactive, "deploy an app").await?;
 
-        let base_dir_path = self.dir.clone().unwrap_or_else(|| {
-            self.path
-                .clone()
-                .unwrap_or_else(|| std::env::current_dir().unwrap())
-        });
-
-        let (app_config_path, base_dir_path) = {
-            if base_dir_path.is_file() {
-                (
-                    base_dir_path.clone(),
-                    base_dir_path.clone().parent().unwrap().to_path_buf(),
-                )
-            } else if base_dir_path.is_dir() {
-                let f = base_dir_path.join(AppConfigV1::CANONICAL_FILE_NAME);
+        if self.build_remote && self.publish_package {
+            anyhow::bail!("--build-remote cannot be combined with --publish-package");
+        }
+
+        if self.build_remote {
+            self.handle_remote_build(&client).await?;
+            return Ok(());
+        }
+
+        let (app_config_path, base_dir_path) = self.resolve_app_paths()?;
 
-                (f, base_dir_path.clone())
+        if !app_config_path.is_file() && self.ensure_app_config {
+            let owner = if let Some(owner) = &self.owner {
+                owner.clone()
+            } else if self.non_interactive {
+                anyhow::bail!("No owner specified: use --owner <owner>");
             } else {
-                anyhow::bail!("No such file or directory '{}'", base_dir_path.display());
-            }
-        };
+                let user =
+                    wasmer_backend_api::query::current_user_with_namespaces(&client, None).await?;
+                crate::utils::prompts::prompt_for_namespace(
+                    "Who should own this app?",
+                    None,
+                    Some(&user),
+                )?
+            };
+
+            let app_name = if let Some(name) = &self.app_name {
+                name.clone()
+            } else if self.non_interactive {
+                anyhow::bail!("No app name specified: use --name <app_name>");
+            } else {
+                let default_name = base_dir_path
+                    .file_name()
+                    .and_then(|f| f.to_str())
+                    .map(|s| s.to_owned());
+                crate::utils::prompts::prompt_new_app_name(
+                    "Enter the name of the app",
+                    default_name.as_deref(),
+                    &owner,
+                    Some(&client),
+                )
+                .await?
+            };
+
+            let app_config = minimal_app_config(&owner, &app_name);
+            write_app_config(&app_config, Some(base_dir_path.clone())).await?;
+        }
 
         if !app_config_path.is_file()
             || self.template.is_some()
@@ -276,7 +615,7 @@ impl AsyncCliCommand for CmdAppDeploy {
         // We want to allow the user to specify the app name interactively.
         let mut app_yaml: serde_yaml::Value = serde_yaml::from_str(&config_str)?;
         let maybe_edge_app = if let Some(app_id) = app_yaml.get("app_id").and_then(|s| s.as_str()) {
-            wasmer_api::query::get_app_by_id(&client, app_id.to_owned())
+            wasmer_backend_api::query::get_app_by_id(&client, app_id.to_owned())
                 .await
                 .ok()
         } else {
@@ -287,12 +626,13 @@ impl AsyncCliCommand for CmdAppDeploy {
             .get_owner(&client, &mut app_yaml, maybe_edge_app.as_ref())
             .await?;
 
-        if !wasmer_api::query::viewer_can_deploy_to_namespace(&client, &owner).await? {
+        if !wasmer_backend_api::query::viewer_can_deploy_to_namespace(&client, &owner).await? {
             eprintln!("It seems you don't have access to {}", owner.bold());
             if self.non_interactive {
                 anyhow::bail!("Please, change the owner before deploying or check your current user with `{} whoami`.", std::env::args().next().unwrap_or("wasmer".into()));
             } else {
-                let user = wasmer_api::query::current_user_with_namespaces(&client, None).await?;
+                let user =
+                    wasmer_backend_api::query::current_user_with_namespaces(&client, None).await?;
                 owner = crate::utils::prompts::prompt_for_namespace(
                     "Who should own this app?",
                     None,
@@ -381,6 +721,43 @@ impl AsyncCliCommand for CmdAppDeploy {
         };
 
         let mut app_cfg_new = app_config.clone();
+
+        // If the directory has an app.yaml, but no wasmer.toml manifest,
+        // ask the user to deploy with a remote build instead.
+        if !self.build_remote {
+            let is_local_pkg = app_cfg_new.package.to_string() == ".";
+            let manifest_path = base_dir_path.join(DEFAULT_PACKAGE_MANIFEST_FILE);
+            let manifest_exists = manifest_path.is_file();
+
+            if is_local_pkg && !manifest_exists {
+                if self.non_interactive {
+                    anyhow::bail!(
+                        "The app.yaml references a local package, but no wasmer.toml manifest was found in {} - use --build-remote to deploy with a remote build.",
+                        base_dir_path.display()
+                    );
+                }
+
+                let theme = ColorfulTheme::default();
+                let should_use_remote = Confirm::with_theme(&theme)
+                    .with_prompt(format!(
+                        "No wasmer.toml manifest found in {}. Deploy with a remote build instead?",
+                        base_dir_path.display()
+                    ))
+                    .default(true)
+                    .interact()?;
+
+                if should_use_remote {
+                    self.handle_remote_build(&client).await?;
+                    return Ok(());
+                } else {
+                    anyhow::bail!(
+                        "The app.yaml references a local package, but no wasmer.toml manifest was found in {}",
+                        base_dir_path.display()
+                    );
+                }
+            }
+        }
+
         let opts = match &app_cfg_new.package {
             PackageSource::Path(ref path) => {
                 let path = PathBuf::from(path);
@@ -424,14 +801,18 @@ impl AsyncCliCommand for CmdAppDeploy {
                                         "Found local package (manifest path: {}).",
                                         manifest_path.display()
                                     );
-                                    eprintln!("The `package` field in `app.yaml` specified the same named package ({}).", name);
+                                    eprintln!(
+                                        "The `package` field in `app.yaml` specified the same named package ({name})."
+                                    );
                                     eprintln!("This behaviour is deprecated.");
                                 }
 
                                 let theme = dialoguer::theme::ColorfulTheme::default();
                                 if self.non_interactive {
                                     if !self.quiet {
-                                        eprintln!("Hint: replace `package: {}` with `package: .` to replicate the intended behaviour.", n);
+                                        eprintln!(
+                                            "Hint: replace `package: {n}` with `package: .` to replicate the intended behaviour."
+                                        );
                                     }
                                     anyhow::bail!("deprecated deploy behaviour")
                                 } else if Confirm::with_theme(&theme)
@@ -474,8 +855,9 @@ impl AsyncCliCommand for CmdAppDeploy {
                                 } else {
                                     if !self.quiet {
                                         eprintln!(
-                                        "{}: the package will not be published and the deployment will fail if the package does not already exist.",
-                                        "Warning".yellow().bold());
+                                            "{}: the package will not be published and the deployment will fail if the package does not already exist.",
+                                            "Warning".yellow().bold()
+                                        );
                                     }
                                     DeployAppOpts {
                                         app: &app_config,
@@ -549,13 +931,24 @@ impl AsyncCliCommand for CmdAppDeploy {
         let app = &opts.app;
 
         let pretty_name = if let Some(owner) = &owner {
-            format!("{} ({})", app.name.bold(), owner.bold())
+            format!(
+                "{} ({})",
+                app.name
+                    .as_ref()
+                    .context("App name has to be specified")?
+                    .bold(),
+                owner.bold()
+            )
         } else {
-            app.name.bold().to_string()
+            app.name
+                .as_ref()
+                .context("App name has to be specified")?
+                .bold()
+                .to_string()
         };
 
         if !self.quiet {
-            eprintln!("\nDeploying app {} to Wasmer Edge...\n", pretty_name);
+            eprintln!("\nDeploying app {pretty_name} to Wasmer Edge...\n");
         }
 
         let app_version = deploy_app(&client, opts.clone()).await?;
@@ -587,7 +980,7 @@ impl AsyncCliCommand for CmdAppDeploy {
 
         wait_app(&client, opts.clone(), app_version.clone(), self.quiet).await?;
 
-        if self.fmt.format == crate::utils::render::ItemFormat::Json {
+        if self.fmt.format == Some(crate::utils::render::ItemFormat::Json) {
             println!("{}", serde_json::to_string_pretty(&app_version)?);
         }
 
@@ -602,12 +995,89 @@ pub struct DeployAppOpts<'a> {
     // Present here to enable forwarding unknown fields to the backend, which
     // preserves forwards-compatibility for schema changes.
     pub original_config: Option<serde_yaml::value::Value>,
+    #[allow(dead_code)]
     pub allow_create: bool,
     pub make_default: bool,
     pub owner: Option<String>,
     pub wait: WaitMode,
 }
 
+fn format_autobuild_kind(kind: AutoBuildDeployAppLogKind) -> &'static str {
+    match kind {
+        AutoBuildDeployAppLogKind::Log => "log",
+        AutoBuildDeployAppLogKind::PreparingToDeployStatus => "prepare",
+        AutoBuildDeployAppLogKind::FetchingPlanStatus => "plan",
+        AutoBuildDeployAppLogKind::BuildStatus => "build",
+        AutoBuildDeployAppLogKind::DeployStatus => "deploy",
+        AutoBuildDeployAppLogKind::Complete => "complete",
+        AutoBuildDeployAppLogKind::Failed => "failed",
+    }
+}
+
+fn remote_progress_handler(quiet: bool) -> impl FnMut(DeployRemoteEvent) {
+    move |event| {
+        if quiet {
+            return;
+        }
+
+        match event {
+            DeployRemoteEvent::CreatingArchive { path } => {
+                eprintln!("Creating deployment archive from {}...", path.display());
+            }
+            DeployRemoteEvent::ArchiveCreated {
+                file_count,
+                archive_size,
+            } => {
+                eprintln!(
+                    "Packaging project directory ({} files, {})",
+                    file_count,
+                    ByteSize(archive_size)
+                );
+            }
+            DeployRemoteEvent::GeneratingUploadUrl => {
+                eprintln!("Requesting upload target...");
+            }
+            DeployRemoteEvent::UploadArchiveStart { archive_size } => {
+                eprintln!(
+                    "Uploading archive ({} bytes) to Wasmer...",
+                    ByteSize(archive_size)
+                );
+            }
+            DeployRemoteEvent::DeterminingBuildConfiguration => {
+                eprintln!("Determining build configuration...");
+            }
+            DeployRemoteEvent::BuildConfigDetermined { config } => {
+                eprintln!(
+                    "Build configuration determined (preset: {})",
+                    config.preset_name
+                );
+            }
+            DeployRemoteEvent::InitiatingBuild { .. } => {
+                eprintln!("Requesting remote build...");
+            }
+            DeployRemoteEvent::StreamingAutobuildLogs { build_id } => {
+                eprintln!("Streaming autobuild logs (build id {build_id})");
+            }
+            DeployRemoteEvent::AutobuildLog { log } => {
+                let kind = log.kind;
+                let message = log.message;
+
+                if let Some(msg) = message {
+                    eprintln!("[{}] {}", format_autobuild_kind(kind), msg);
+                } else if matches!(kind, AutoBuildDeployAppLogKind::Complete) {
+                    eprintln!("[{}] complete", format_autobuild_kind(kind));
+                }
+            }
+            DeployRemoteEvent::Finished => {
+                eprintln!("Remote autobuild finished successfully.\n");
+            }
+            _ => {
+                eprintln!("Unknown event: {event:?}");
+            }
+        }
+    }
+}
+
 pub async fn deploy_app(
     client: &WasmerClient,
     opts: DeployAppOpts<'_>,
@@ -625,11 +1095,11 @@ pub async fn deploy_app(
 
     // TODO: respect allow_create flag
 
-    let version = wasmer_api::query::publish_deploy_app(
+    let version = wasmer_backend_api::query::publish_deploy_app(
         client,
-        wasmer_api::types::PublishDeployAppVars {
+        wasmer_backend_api::types::PublishDeployAppVars {
             config: raw_config,
-            name: app.name.clone().into(),
+            name: app.name.clone().context("Expected an app name")?.into(),
             owner: opts.owner.map(|o| o.into()),
             make_default: Some(opts.make_default),
         },
@@ -666,7 +1136,7 @@ pub async fn wait_app(
         .inner()
         .to_string();
 
-    let app = wasmer_api::query::get_app_by_id(client, app_id.clone())
+    let app = wasmer_backend_api::query::get_app_by_id(client, app_id.clone())
         .await
         .context("could not fetch app from backend")?;
 
@@ -763,7 +1233,7 @@ pub async fn wait_app(
 
                         tracing::debug!(
                             current=%header,
-                            expected=%app.active_version.id.inner(),
+                            expected=%version.id.inner(),
                             "app is not at the right version yet",
                         );
                     }
diff --git a/lib/cli/src/commands/app/deployments/get.rs b/lib/cli/src/commands/app/deployments/get.rs
new file mode 100644
index 0000000000..30a3e5656b
--- /dev/null
+++ b/lib/cli/src/commands/app/deployments/get.rs
@@ -0,0 +1,29 @@
+//! Get deployments for an app.
+
+use crate::{commands::AsyncCliCommand, config::WasmerEnv, opts::ItemFormatOpts};
+
+/// Get the volumes of an app.
+#[derive(clap::Parser, Debug)]
+pub struct CmdAppDeploymentGet {
+    #[clap(flatten)]
+    fmt: ItemFormatOpts,
+
+    #[clap(flatten)]
+    env: WasmerEnv,
+
+    /// ID of the deployment.
+    id: String,
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdAppDeploymentGet {
+    type Output = ();
+
+    async fn run_async(mut self) -> Result<(), anyhow::Error> {
+        let client = self.env.client()?;
+        let item = wasmer_backend_api::query::app_deployment(&client, self.id).await?;
+
+        println!("{}", self.fmt.get().render(&item));
+        Ok(())
+    }
+}
diff --git a/lib/cli/src/commands/app/deployments/list.rs b/lib/cli/src/commands/app/deployments/list.rs
new file mode 100644
index 0000000000..f1beea5b11
--- /dev/null
+++ b/lib/cli/src/commands/app/deployments/list.rs
@@ -0,0 +1,50 @@
+//! List volumes tied to an edge app.
+
+use super::super::util::AppIdentOpts;
+use crate::{commands::AsyncCliCommand, config::WasmerEnv, opts::ListFormatOpts};
+
+/// List the volumes of an app.
+#[derive(clap::Parser, Debug)]
+pub struct CmdAppDeploymentList {
+    #[clap(flatten)]
+    fmt: ListFormatOpts,
+
+    #[clap(flatten)]
+    env: WasmerEnv,
+
+    #[clap(flatten)]
+    ident: AppIdentOpts,
+
+    #[clap(long)]
+    offset: Option<u32>,
+
+    #[clap(long)]
+    limit: Option<u32>,
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdAppDeploymentList {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        let client = self.env.client()?;
+
+        let (_ident, app) = self.ident.load_app(&client).await?;
+        let vars = wasmer_backend_api::types::GetAppDeploymentsVariables {
+            after: None,
+            first: self.limit.map(|x| x as i32),
+            name: app.name.clone(),
+            offset: self.offset.map(|x| x as i32),
+            owner: app.owner.global_name,
+        };
+        let items = wasmer_backend_api::query::app_deployments(&client, vars).await?;
+
+        if items.is_empty() {
+            eprintln!("App {} has no deployments!", app.name);
+        } else {
+            println!("{}", self.fmt.format.render(&items));
+        }
+
+        Ok(())
+    }
+}
diff --git a/lib/cli/src/commands/app/deployments/logs.rs b/lib/cli/src/commands/app/deployments/logs.rs
new file mode 100644
index 0000000000..f9165608aa
--- /dev/null
+++ b/lib/cli/src/commands/app/deployments/logs.rs
@@ -0,0 +1,51 @@
+//! Get logs for an app deployment.
+
+use std::io::Write;
+
+use anyhow::Context;
+use futures::stream::TryStreamExt;
+
+use crate::{commands::AsyncCliCommand, config::WasmerEnv, opts::ItemFormatOpts};
+
+/// Get logs for an app deployment.
+#[derive(clap::Parser, Debug)]
+pub struct CmdAppDeploymentLogs {
+    #[clap(flatten)]
+    fmt: ItemFormatOpts,
+
+    #[clap(flatten)]
+    env: WasmerEnv,
+
+    /// ID of the deployment.
+    id: String,
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdAppDeploymentLogs {
+    type Output = ();
+
+    async fn run_async(mut self) -> Result<(), anyhow::Error> {
+        let client = self.env.client()?;
+        let item = wasmer_backend_api::query::app_deployment(&client, self.id).await?;
+
+        let url = item
+            .log_url
+            .context("This deployment does not have logs available")?;
+
+        let mut writer = std::io::BufWriter::new(std::io::stdout());
+
+        let mut stream = reqwest::Client::new()
+            .get(url)
+            .send()
+            .await?
+            .error_for_status()?
+            .bytes_stream();
+
+        while let Some(chunk) = stream.try_next().await? {
+            writer.write_all(&chunk)?;
+            writer.flush()?;
+        }
+
+        Ok(())
+    }
+}
diff --git a/lib/cli/src/commands/app/deployments/mod.rs b/lib/cli/src/commands/app/deployments/mod.rs
new file mode 100644
index 0000000000..eeb8b7f651
--- /dev/null
+++ b/lib/cli/src/commands/app/deployments/mod.rs
@@ -0,0 +1,26 @@
+use crate::commands::AsyncCliCommand;
+
+pub mod get;
+pub mod list;
+pub mod logs;
+
+/// App volume management.
+#[derive(Debug, clap::Parser)]
+pub enum CmdAppDeployment {
+    List(list::CmdAppDeploymentList),
+    Get(get::CmdAppDeploymentGet),
+    Logs(logs::CmdAppDeploymentLogs),
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdAppDeployment {
+    type Output = ();
+
+    async fn run_async(self) -> Result<Self::Output, anyhow::Error> {
+        match self {
+            Self::List(c) => c.run_async().await,
+            Self::Get(c) => c.run_async().await,
+            Self::Logs(c) => c.run_async().await,
+        }
+    }
+}
diff --git a/lib/cli/src/commands/app/get.rs b/lib/cli/src/commands/app/get.rs
index 73b4d9de94..0961163d60 100644
--- a/lib/cli/src/commands/app/get.rs
+++ b/lib/cli/src/commands/app/get.rs
@@ -1,10 +1,12 @@
 //! Get information about an edge app.
 
-use wasmer_api::types::DeployApp;
+use wasmer_backend_api::types::DeployApp;
 
 use super::util::AppIdentOpts;
 
-use crate::{commands::AsyncCliCommand, config::WasmerEnv, opts::ItemFormatOpts};
+use crate::{
+    commands::AsyncCliCommand, config::WasmerEnv, opts::ItemFormatOpts, utils::render::ItemFormat,
+};
 
 /// Retrieve detailed informations about an app
 #[derive(clap::Parser, Debug)]
@@ -27,7 +29,10 @@ impl AsyncCliCommand for CmdAppGet {
         let client = self.env.client()?;
         let (_ident, app) = self.ident.load_app(&client).await?;
 
-        println!("{}", self.fmt.format.render(&app));
+        println!(
+            "{}",
+            self.fmt.get_with_default(ItemFormat::Yaml).render(&app)
+        );
 
         Ok(app)
     }
diff --git a/lib/cli/src/commands/app/info.rs b/lib/cli/src/commands/app/info.rs
index 36a3d458b1..96a644c10c 100644
--- a/lib/cli/src/commands/app/info.rs
+++ b/lib/cli/src/commands/app/info.rs
@@ -23,15 +23,18 @@ impl AsyncCliCommand for CmdAppInfo {
         let (_ident, app) = self.ident.load_app(&client).await?;
 
         let app_url = app.url;
-        let versioned_url = app.active_version.url;
+        let versioned_url = app
+            .active_version
+            .as_ref()
+            .map_or("n/a", |version| &version.url);
         let dashboard_url = app.admin_url;
 
         println!("  App Info  ");
         println!("→ Name: {}", app.name);
         println!("→ Owner: {}", app.owner.global_name);
-        println!("→ URL: {}", app_url);
-        println!("→ Unique URL: {}", versioned_url);
-        println!("→ Dashboard: {}", dashboard_url);
+        println!("→ URL: {app_url}");
+        println!("→ Unique URL: {versioned_url}");
+        println!("→ Dashboard: {dashboard_url}");
 
         Ok(())
     }
diff --git a/lib/cli/src/commands/app/list.rs b/lib/cli/src/commands/app/list.rs
index 94bb6221ad..23e955d187 100644
--- a/lib/cli/src/commands/app/list.rs
+++ b/lib/cli/src/commands/app/list.rs
@@ -3,7 +3,7 @@
 use std::pin::Pin;
 
 use futures::{Stream, StreamExt};
-use wasmer_api::types::{DeployApp, DeployAppsSortBy};
+use wasmer_backend_api::types::{DeployApp, DeployAppsSortBy};
 
 use crate::{commands::AsyncCliCommand, config::WasmerEnv, opts::ListFormatOpts};
 
@@ -65,11 +65,11 @@ impl AsyncCliCommand for CmdAppList {
         let apps_stream: Pin<
             Box<dyn Stream<Item = Result<Vec<DeployApp>, anyhow::Error>> + Send + Sync>,
         > = if let Some(ns) = self.namespace.clone() {
-            Box::pin(wasmer_api::query::namespace_apps(&client, ns, sort).await)
+            Box::pin(wasmer_backend_api::query::namespace_apps(&client, ns, sort).await)
         } else if self.all {
-            Box::pin(wasmer_api::query::user_accessible_apps(&client, sort).await?)
+            Box::pin(wasmer_backend_api::query::user_accessible_apps(&client, sort).await?)
         } else {
-            Box::pin(wasmer_api::query::user_apps(&client, sort).await)
+            Box::pin(wasmer_backend_api::query::user_apps(&client, sort).await)
         };
 
         let mut apps_stream = std::pin::pin!(apps_stream);
diff --git a/lib/cli/src/commands/app/logs.rs b/lib/cli/src/commands/app/logs.rs
index 1d297da73c..4ecd47275d 100644
--- a/lib/cli/src/commands/app/logs.rs
+++ b/lib/cli/src/commands/app/logs.rs
@@ -1,11 +1,11 @@
 //! Show logs for an Edge app.
 
+use crate::utils::timestamp::parse_timestamp_or_relative_time_negative_offset;
 use colored::Colorize;
 use comfy_table::{Cell, Table};
-use edge_schema::pretty_duration::parse_timestamp_or_relative_time;
 use futures::StreamExt;
 use time::{format_description::well_known::Rfc3339, OffsetDateTime};
-use wasmer_api::types::{Log, LogStream};
+use wasmer_backend_api::types::{Log, LogStream};
 
 use crate::{config::WasmerEnv, opts::ListFormatOpts, utils::render::CliRender};
 
@@ -37,7 +37,7 @@ pub struct CmdAppLogs {
     /// * Unix timestamp (`1136196245`)
     /// * Relative time (`10m` / `-1h`, `1d1h30s`)
     // TODO: should default to trailing logs once trailing is implemented.
-    #[clap(long, value_parser = parse_timestamp_or_relative_time, conflicts_with = "request_id")]
+    #[clap(long, value_parser = parse_timestamp_or_relative_time_negative_offset, conflicts_with = "request_id")]
     from: Option<OffsetDateTime>,
 
     /// The date of the latest log entry.
@@ -48,7 +48,7 @@ pub struct CmdAppLogs {
     /// * Simple date (`2022-11-11`)
     /// * Unix timestamp (`1136196245`)
     /// * Relative time (`10m` / `1h`, `1d1h30s`)
-    #[clap(long, value_parser = parse_timestamp_or_relative_time, conflicts_with = "request_id")]
+    #[clap(long, value_parser = parse_timestamp_or_relative_time_negative_offset, conflicts_with = "request_id")]
     until: Option<OffsetDateTime>,
 
     /// Maximum log lines to fetch.
@@ -90,10 +90,12 @@ impl crate::commands::AsyncCliCommand for CmdAppLogs {
             .from
             .unwrap_or_else(|| OffsetDateTime::now_utc() - time::Duration::minutes(10));
 
+        let version = app.active_version.as_ref().map_or("n/a", |v| &v.version);
+
         tracing::info!(
             app.name=%app.name,
             app.owner=%app.owner.global_name,
-            app.version=app.active_version.version,
+            app.version=version,
             range.start=%from,
             range.end=self.until.map(|ts| ts.to_string()),
             "Fetching logs",
@@ -125,7 +127,7 @@ impl crate::commands::AsyncCliCommand for CmdAppLogs {
 
         // Code duplication to avoid a dependency to `OR` streams.
         if let Some(instance_id) = &self.instance_id {
-            let logs_stream = wasmer_api::query::get_app_logs_paginated_filter_instance(
+            let logs_stream = wasmer_backend_api::query::get_app_logs_paginated_filter_instance(
                 &client,
                 app.name.clone(),
                 app.owner.global_name.to_string(),
@@ -160,7 +162,7 @@ impl crate::commands::AsyncCliCommand for CmdAppLogs {
                 }
             }
         } else if let Some(request_id) = &self.request_id {
-            let logs_stream = wasmer_api::query::get_app_logs_paginated_filter_request(
+            let logs_stream = wasmer_backend_api::query::get_app_logs_paginated_filter_request(
                 &client,
                 app.name.clone(),
                 app.owner.global_name.to_string(),
@@ -195,7 +197,7 @@ impl crate::commands::AsyncCliCommand for CmdAppLogs {
                 }
             }
         } else {
-            let logs_stream = wasmer_api::query::get_app_logs_paginated(
+            let logs_stream = wasmer_backend_api::query::get_app_logs_paginated(
                 &client,
                 app.name.clone(),
                 app.owner.global_name.to_string(),
diff --git a/lib/cli/src/commands/app/mod.rs b/lib/cli/src/commands/app/mod.rs
index 7a461a06c8..187cc67a63 100644
--- a/lib/cli/src/commands/app/mod.rs
+++ b/lib/cli/src/commands/app/mod.rs
@@ -1,8 +1,10 @@
 //! Edge app commands.
 
 pub mod create;
+pub mod database;
 pub mod delete;
 pub mod deploy;
+mod deployments;
 pub mod get;
 pub mod info;
 pub mod list;
@@ -14,6 +16,7 @@ pub mod version;
 pub mod volumes;
 
 mod util;
+pub use util::AppIdentArgOpts;
 
 use crate::commands::AsyncCliCommand;
 
@@ -36,6 +39,10 @@ pub enum CmdApp {
     Region(regions::CmdAppRegions),
     #[clap(subcommand, alias = "volumes")]
     Volume(volumes::CmdAppVolumes),
+    #[clap(subcommand, alias = "databases")]
+    Database(database::CmdAppDatabase),
+    #[clap(subcommand, alias = "deployments")]
+    Deployment(deployments::CmdAppDeployment),
 }
 
 #[async_trait::async_trait]
@@ -65,6 +72,8 @@ impl AsyncCliCommand for CmdApp {
             Self::Secret(cmd) => cmd.run_async().await,
             Self::Region(cmd) => cmd.run_async().await,
             Self::Volume(cmd) => cmd.run_async().await,
+            Self::Database(cmd) => cmd.run_async().await,
+            Self::Deployment(cmd) => cmd.run_async().await,
         }
     }
 }
diff --git a/lib/cli/src/commands/app/purge_cache.rs b/lib/cli/src/commands/app/purge_cache.rs
index 8f08b41e8c..0069f79b52 100644
--- a/lib/cli/src/commands/app/purge_cache.rs
+++ b/lib/cli/src/commands/app/purge_cache.rs
@@ -1,5 +1,7 @@
 //! Get information about an edge app.
 
+use anyhow::Context;
+
 use super::util::AppIdentOpts;
 use crate::{commands::AsyncCliCommand, config::WasmerEnv, opts::ItemFormatOpts};
 
@@ -29,7 +31,12 @@ impl AsyncCliCommand for CmdAppPurgeCache {
         let client = self.env.client()?;
         let (_ident, app) = self.ident.load_app(&client).await?;
 
-        let version_id = app.active_version.id;
+        let version_id = app
+            .active_version
+            .as_ref()
+            .context("Could not purge cache: app has no active version!")?
+            .id
+            .clone();
 
         let name = format!("{} ({})", app.name, app.owner.global_name);
 
@@ -39,8 +46,8 @@ impl AsyncCliCommand for CmdAppPurgeCache {
             version_id.inner()
         );
 
-        let vars = wasmer_api::types::PurgeCacheForAppVersionVars { id: version_id };
-        wasmer_api::query::purge_cache_for_app_version(&client, vars).await?;
+        let vars = wasmer_backend_api::types::PurgeCacheForAppVersionVars { id: version_id };
+        wasmer_backend_api::query::purge_cache_for_app_version(&client, vars).await?;
 
         println!("🚽 swirl! All caches have been purged!");
 
diff --git a/lib/cli/src/commands/app/regions/list.rs b/lib/cli/src/commands/app/regions/list.rs
index 88b5e39830..9828d24abb 100644
--- a/lib/cli/src/commands/app/regions/list.rs
+++ b/lib/cli/src/commands/app/regions/list.rs
@@ -26,7 +26,7 @@ impl AsyncCliCommand for CmdAppRegionsList {
 
     async fn run_async(self) -> Result<Self::Output, anyhow::Error> {
         let client = self.env.client()?;
-        let regions = wasmer_api::query::get_all_app_regions(&client).await?;
+        let regions = wasmer_backend_api::query::get_all_app_regions(&client).await?;
 
         println!("{}", self.fmt.format.render(regions.as_slice()));
 
diff --git a/lib/cli/src/commands/app/regions/utils/render.rs b/lib/cli/src/commands/app/regions/utils/render.rs
index bb03497fc4..14f0a57bc9 100644
--- a/lib/cli/src/commands/app/regions/utils/render.rs
+++ b/lib/cli/src/commands/app/regions/utils/render.rs
@@ -1,6 +1,6 @@
 use crate::utils::render::CliRender;
 use comfy_table::{Cell, Table};
-use wasmer_api::types::AppRegion;
+use wasmer_backend_api::types::AppRegion;
 
 impl CliRender for AppRegion {
     fn render_item_table(&self) -> String {
diff --git a/lib/cli/src/commands/app/secrets/create.rs b/lib/cli/src/commands/app/secrets/create.rs
index 77301e752c..f0570562aa 100644
--- a/lib/cli/src/commands/app/secrets/create.rs
+++ b/lib/cli/src/commands/app/secrets/create.rs
@@ -11,7 +11,7 @@ use std::{
     collections::{HashMap, HashSet},
     path::{Path, PathBuf},
 };
-use wasmer_api::WasmerClient;
+use wasmer_backend_api::WasmerClient;
 
 /// Create a new app secret.
 #[derive(clap::Parser, Debug)]
@@ -95,7 +95,7 @@ impl CmdAppSecretsCreate {
     ) -> anyhow::Result<Vec<Secret>> {
         let names = secrets.iter().map(|s| &s.name);
         let app_secrets =
-            wasmer_api::query::get_all_app_secrets_filtered(client, app_id, names).await?;
+            wasmer_backend_api::query::get_all_app_secrets_filtered(client, app_id, names).await?;
         let mut sset = HashSet::<String>::from_iter(app_secrets.iter().map(|s| s.name.clone()));
         let mut ret = HashMap::new();
 
@@ -142,7 +142,7 @@ impl CmdAppSecretsCreate {
         app_id: &str,
         secrets: Vec<Secret>,
     ) -> Result<(), anyhow::Error> {
-        let res = wasmer_api::query::upsert_app_secrets(
+        let res = wasmer_backend_api::query::upsert_app_secrets(
             client,
             app_id,
             secrets.iter().map(|s| (s.name.as_str(), s.value.as_str())),
@@ -173,7 +173,7 @@ impl CmdAppSecretsCreate {
                 };
 
                 if should_redeploy {
-                    wasmer_api::query::redeploy_app_by_id(client, app_id).await?;
+                    wasmer_backend_api::query::redeploy_app_by_id(client, app_id).await?;
                     eprintln!("{} Deployment complete", "𖥔".yellow().bold());
                 } else {
                     eprintln!(
diff --git a/lib/cli/src/commands/app/secrets/delete.rs b/lib/cli/src/commands/app/secrets/delete.rs
index eba87c7eae..093b243905 100644
--- a/lib/cli/src/commands/app/secrets/delete.rs
+++ b/lib/cli/src/commands/app/secrets/delete.rs
@@ -6,7 +6,7 @@ use colored::Colorize;
 use dialoguer::theme::ColorfulTheme;
 use is_terminal::IsTerminal;
 use std::path::{Path, PathBuf};
-use wasmer_api::WasmerClient;
+use wasmer_backend_api::WasmerClient;
 
 use super::utils::{self, get_secrets};
 
@@ -91,7 +91,8 @@ impl CmdAppSecretsDelete {
                 }
             }
 
-            let res = wasmer_api::query::delete_app_secret(client, secret.id.into_inner()).await?;
+            let res = wasmer_backend_api::query::delete_app_secret(client, secret.id.into_inner())
+                .await?;
 
             match res {
                 Some(res) if !res.success => {
diff --git a/lib/cli/src/commands/app/secrets/update.rs b/lib/cli/src/commands/app/secrets/update.rs
index 32c20bd586..ba14eb6148 100644
--- a/lib/cli/src/commands/app/secrets/update.rs
+++ b/lib/cli/src/commands/app/secrets/update.rs
@@ -11,7 +11,7 @@ use std::{
     collections::HashSet,
     path::{Path, PathBuf},
 };
-use wasmer_api::WasmerClient;
+use wasmer_backend_api::WasmerClient;
 
 /// Update an existing app secret.
 #[derive(clap::Parser, Debug)]
@@ -100,7 +100,7 @@ impl CmdAppSecretsUpdate {
     ) -> anyhow::Result<Vec<Secret>> {
         let names = secrets.iter().map(|s| &s.name);
         let app_secrets =
-            wasmer_api::query::get_all_app_secrets_filtered(client, app_id, names).await?;
+            wasmer_backend_api::query::get_all_app_secrets_filtered(client, app_id, names).await?;
         let sset = HashSet::<&str>::from_iter(app_secrets.iter().map(|s| s.name.as_str()));
 
         let mut ret = vec![];
@@ -136,7 +136,7 @@ impl CmdAppSecretsUpdate {
         app_id: &str,
         secrets: Vec<Secret>,
     ) -> Result<(), anyhow::Error> {
-        let res = wasmer_api::query::upsert_app_secrets(
+        let res = wasmer_backend_api::query::upsert_app_secrets(
             client,
             app_id,
             secrets.iter().map(|s| (s.name.as_str(), s.value.as_str())),
@@ -167,7 +167,7 @@ impl CmdAppSecretsUpdate {
                 };
 
                 if should_redeploy {
-                    wasmer_api::query::redeploy_app_by_id(client, app_id).await?;
+                    wasmer_backend_api::query::redeploy_app_by_id(client, app_id).await?;
                     eprintln!("{} Deployment complete", "𖥔".yellow().bold());
                 } else {
                     eprintln!(
diff --git a/lib/cli/src/commands/app/secrets/utils/mod.rs b/lib/cli/src/commands/app/secrets/utils/mod.rs
index 745a716dd9..e6e329851a 100644
--- a/lib/cli/src/commands/app/secrets/utils/mod.rs
+++ b/lib/cli/src/commands/app/secrets/utils/mod.rs
@@ -1,12 +1,12 @@
 pub(crate) mod render;
-
+use anyhow::Context;
 use colored::Colorize;
 use std::{
     env::current_dir,
     path::{Path, PathBuf},
     str::FromStr,
 };
-use wasmer_api::{types::Secret as BackendSecret, WasmerClient};
+use wasmer_backend_api::{types::Secret as BackendSecret, WasmerClient};
 
 use crate::commands::app::util::{get_app_config_from_dir, prompt_app_ident, AppIdent};
 
@@ -30,20 +30,20 @@ pub(super) async fn get_secret_by_name(
     app_id: &str,
     secret_name: &str,
 ) -> anyhow::Result<Option<BackendSecret>> {
-    wasmer_api::query::get_app_secret_by_name(client, app_id, secret_name).await
+    wasmer_backend_api::query::get_app_secret_by_name(client, app_id, secret_name).await
 }
 pub(crate) async fn get_secrets(
     client: &WasmerClient,
     app_id: &str,
-) -> anyhow::Result<Vec<wasmer_api::types::Secret>> {
-    wasmer_api::query::get_all_app_secrets(client, app_id).await
+) -> anyhow::Result<Vec<wasmer_backend_api::types::Secret>> {
+    wasmer_backend_api::query::get_all_app_secrets(client, app_id).await
 }
 
 pub(crate) async fn get_secret_value(
     client: &WasmerClient,
-    secret: &wasmer_api::types::Secret,
+    secret: &wasmer_backend_api::types::Secret,
 ) -> anyhow::Result<String> {
-    wasmer_api::query::get_app_secret_value_by_id(client, secret.id.clone().into_inner())
+    wasmer_backend_api::query::get_app_secret_value_by_id(client, secret.id.clone().into_inner())
         .await?
         .ok_or_else(|| {
             anyhow::anyhow!(
@@ -68,7 +68,7 @@ pub(crate) async fn reveal_secrets(
     client: &WasmerClient,
     app_id: &str,
 ) -> anyhow::Result<Vec<Secret>> {
-    let secrets = wasmer_api::query::get_all_app_secrets(client, app_id).await?;
+    let secrets = wasmer_backend_api::query::get_all_app_secrets(client, app_id).await?;
     let mut ret = vec![];
     for secret in secrets {
         let name = secret.name.clone();
@@ -112,9 +112,15 @@ pub(super) async fn get_app_id(
         let (app, _) = r;
 
         let app_name = if let Some(owner) = &app.owner {
-            format!("{owner}/{}", app.name)
+            format!(
+                "{owner}/{}",
+                &app.name.clone().context("App name has to be specified")?
+            )
         } else {
-            app.name.to_string()
+            app.name
+                .clone()
+                .context("App name has to be specified")?
+                .to_string()
         };
 
         let id = if let Some(id) = &app.app_id {
@@ -140,10 +146,13 @@ pub(super) async fn get_app_id(
                 if let Some(owner) = &app.owner {
                     eprintln!(
                         "Managing secrets related to app {} ({owner}).",
-                        app.name.bold()
+                        app.name.context("App name has to be specified")?.bold()
                     );
                 } else {
-                    eprintln!("Managing secrets related to app {}.", app.name.bold());
+                    eprintln!(
+                        "Managing secrets related to app {}.",
+                        app.name.context("App name has to be specified")?.bold()
+                    );
                 }
             }
             return Ok(id);
diff --git a/lib/cli/src/commands/app/secrets/utils/render.rs b/lib/cli/src/commands/app/secrets/utils/render.rs
index 0b679e10b5..103796a454 100644
--- a/lib/cli/src/commands/app/secrets/utils/render.rs
+++ b/lib/cli/src/commands/app/secrets/utils/render.rs
@@ -3,7 +3,7 @@ use crate::utils::render::CliRender;
 use colored::Colorize;
 use comfy_table::{Cell, Table};
 use time::OffsetDateTime;
-use wasmer_api::types::{DateTime, Secret as BackendSecret};
+use wasmer_backend_api::types::{DateTime, Secret as BackendSecret};
 
 impl CliRender for Secret {
     fn render_item_table(&self) -> String {
diff --git a/lib/cli/src/commands/app/util.rs b/lib/cli/src/commands/app/util.rs
index df1265a387..dfc22e6a0b 100644
--- a/lib/cli/src/commands/app/util.rs
+++ b/lib/cli/src/commands/app/util.rs
@@ -3,7 +3,7 @@ use std::{path::Path, str::FromStr};
 use anyhow::{bail, Context};
 use colored::Colorize;
 use dialoguer::{theme::ColorfulTheme, Confirm};
-use wasmer_api::{
+use wasmer_backend_api::{
     global_id::{GlobalId, NodeKind},
     types::DeployApp,
     WasmerClient,
@@ -32,30 +32,32 @@ impl AppIdent {
     /// Resolve an app identifier through the API.
     pub async fn resolve(&self, client: &WasmerClient) -> Result<DeployApp, anyhow::Error> {
         match self {
-            AppIdent::AppId(app_id) => wasmer_api::query::get_app_by_id(client, app_id.clone())
-                .await
-                .with_context(|| format!("Could not find app with id '{}'", app_id)),
+            AppIdent::AppId(app_id) => {
+                wasmer_backend_api::query::get_app_by_id(client, app_id.clone())
+                    .await
+                    .with_context(|| format!("Could not find app with id '{app_id}'"))
+            }
             AppIdent::AppVersionId(id) => {
                 let (app, _version) =
-                    wasmer_api::query::get_app_version_by_id_with_app(client, id.clone())
+                    wasmer_backend_api::query::get_app_version_by_id_with_app(client, id.clone())
                         .await
-                        .with_context(|| format!("Could not query for app version id '{}'", id))?;
+                        .with_context(|| format!("Could not query for app version id '{id}'"))?;
                 Ok(app)
             }
             AppIdent::Name(name) => {
                 // The API only allows to query by owner + name,
                 // so default to the current user as the owner.
                 // To to so the username must first be retrieved.
-                let user = wasmer_api::query::current_user(client)
+                let user = wasmer_backend_api::query::current_user(client)
                     .await?
                     .context("not logged in")?;
 
-                wasmer_api::query::get_app(client, user.username, name.clone())
+                wasmer_backend_api::query::get_app(client, user.username, name.clone())
                     .await?
                     .with_context(|| format!("Could not find app with name '{name}'"))
             }
             AppIdent::NamespacedName(owner, name) => {
-                wasmer_api::query::get_app(client, owner.clone(), name.clone())
+                wasmer_backend_api::query::get_app(client, owner.clone(), name.clone())
                     .await?
                     .with_context(|| format!("Could not find app '{owner}/{name}'"))
             }
@@ -63,6 +65,17 @@ impl AppIdent {
     }
 }
 
+impl std::fmt::Display for AppIdent {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            AppIdent::AppId(id) => write!(f, "{id}"),
+            AppIdent::AppVersionId(id) => write!(f, "{id}"),
+            AppIdent::NamespacedName(namespace, name) => write!(f, "{namespace}/{name}"),
+            AppIdent::Name(name) => write!(f, "{name}"),
+        }
+    }
+}
+
 impl std::str::FromStr for AppIdent {
     type Err = anyhow::Error;
 
@@ -121,6 +134,7 @@ pub struct AppIdentOpts {
 #[allow(clippy::large_enum_variant)]
 pub enum ResolvedAppIdent {
     Ident(AppIdent),
+    #[allow(dead_code)]
     Config {
         ident: AppIdent,
         config: AppConfigV1,
@@ -138,6 +152,34 @@ impl ResolvedAppIdent {
 }
 
 impl AppIdentOpts {
+    pub fn resolve_static_opt(&self) -> Result<Option<ResolvedAppIdent>, anyhow::Error> {
+        if let Some(id) = &self.app {
+            return Ok(Some(ResolvedAppIdent::Ident(id.clone())));
+        }
+
+        // Try to load from local.
+        let Some((config, path)) = get_app_config_from_current_dir_opt()? else {
+            return Ok(None);
+        };
+
+        let ident = if let Some(id) = &config.app_id {
+            AppIdent::AppId(id.clone())
+        } else if let Some(owner) = &config.owner {
+            AppIdent::NamespacedName(
+                owner.clone(),
+                config.name.clone().context("App name was not specified")?,
+            )
+        } else {
+            AppIdent::Name(config.name.clone().context("App name was not specified")?)
+        };
+
+        Ok(Some(ResolvedAppIdent::Config {
+            ident,
+            config,
+            path,
+        }))
+    }
+
     pub fn resolve_static(&self) -> Result<ResolvedAppIdent, anyhow::Error> {
         if let Some(id) = &self.app {
             return Ok(ResolvedAppIdent::Ident(id.clone()));
@@ -149,9 +191,12 @@ impl AppIdentOpts {
         let ident = if let Some(id) = &config.app_id {
             AppIdent::AppId(id.clone())
         } else if let Some(owner) = &config.owner {
-            AppIdent::NamespacedName(owner.clone(), config.name.clone())
+            AppIdent::NamespacedName(
+                owner.clone(),
+                config.name.clone().context("App name was not specified")?,
+            )
         } else {
-            AppIdent::Name(config.name.clone())
+            AppIdent::Name(config.name.clone().context("App name was not specified")?)
         };
 
         Ok(ResolvedAppIdent::Config {
@@ -171,6 +216,48 @@ impl AppIdentOpts {
 
         Ok((id, app))
     }
+
+    pub async fn load_app_opt(
+        &self,
+        client: &WasmerClient,
+    ) -> Result<Option<(ResolvedAppIdent, DeployApp)>, anyhow::Error> {
+        let id = match self.resolve_static_opt()? {
+            Some(id) => id,
+            None => return Ok(None),
+        };
+        let app = id.ident().resolve(client).await?;
+
+        Ok(Some((id, app)))
+    }
+}
+
+/// Options for identifying an app.
+///
+/// Same as [`AppIdentOpts`], but with the app being a --app flag instead of
+/// a positional argument.
+#[derive(clap::Parser, Debug, Clone)]
+pub struct AppIdentArgOpts {
+    /// Identifier of the application.
+    ///
+    /// NOTE: If not specified, the command will look for an app config file in
+    /// the current directory.
+    ///
+    /// Valid input:
+    /// - namespace/app-name
+    /// - app-alias
+    /// - App ID
+    #[clap(long, short)]
+    pub app: Option<AppIdent>,
+}
+
+impl AppIdentArgOpts {
+    /// Convert to `AppIdentOpts`.
+    /// Useful for accessing the methods on that type.
+    pub fn to_opts(&self) -> AppIdentOpts {
+        AppIdentOpts {
+            app: self.app.clone(),
+        }
+    }
 }
 
 #[cfg(test)]
@@ -262,16 +349,13 @@ pub(super) async fn login_user(
     env.client()
 }
 
-pub fn get_app_config_from_dir(
+pub fn get_app_config_from_dir_opt(
     path: &Path,
-) -> Result<(AppConfigV1, std::path::PathBuf), anyhow::Error> {
+) -> Result<Option<(AppConfigV1, std::path::PathBuf)>, anyhow::Error> {
     let app_config_path = path.join(AppConfigV1::CANONICAL_FILE_NAME);
 
     if !app_config_path.exists() || !app_config_path.is_file() {
-        bail!(
-            "Could not find app.yaml at path: '{}'.\nPlease specify an app like 'wasmer app get <namespace>/<name>' or 'wasmer app get <name>`'",
-            app_config_path.display()
-        );
+        return Ok(None);
     }
     // read the app.yaml
     let raw_app_config = std::fs::read_to_string(&app_config_path)
@@ -281,7 +365,25 @@ pub fn get_app_config_from_dir(
     let config = AppConfigV1::parse_yaml(&raw_app_config)
         .map_err(|err| anyhow::anyhow!("Could not parse app.yaml: {err:?}"))?;
 
-    Ok((config, app_config_path))
+    Ok(Some((config, app_config_path)))
+}
+
+pub fn get_app_config_from_current_dir_opt(
+) -> Result<Option<(AppConfigV1, std::path::PathBuf)>, anyhow::Error> {
+    let current_dir = std::env::current_dir()?;
+    get_app_config_from_dir_opt(&current_dir)
+}
+
+pub fn get_app_config_from_dir(
+    path: &Path,
+) -> Result<(AppConfigV1, std::path::PathBuf), anyhow::Error> {
+    get_app_config_from_dir_opt(path)?
+        .with_context(|| {
+            format!(
+                "Could not find app.yaml in directory: '{}'.\nPlease specify an app like 'wasmer app get <namespace>/<name>' or 'wasmer app get <name>`'",
+                path.display()
+            )
+        })
 }
 
 pub fn get_app_config_from_current_dir() -> Result<(AppConfigV1, std::path::PathBuf), anyhow::Error>
diff --git a/lib/cli/src/commands/app/version/activate.rs b/lib/cli/src/commands/app/version/activate.rs
index 222a45de19..f4afea5f67 100644
--- a/lib/cli/src/commands/app/version/activate.rs
+++ b/lib/cli/src/commands/app/version/activate.rs
@@ -23,15 +23,19 @@ impl AsyncCliCommand for CmdAppVersionActivate {
     async fn run_async(self) -> Result<(), anyhow::Error> {
         let client = self.env.client()?;
 
-        let app = wasmer_api::query::app_version_activate(&client, self.version).await?;
+        let app = wasmer_backend_api::query::app_version_activate(&client, self.version).await?;
+
+        let Some(version) = &app.active_version else {
+            anyhow::bail!("Failed to activate version: backend did not update version!");
+        };
 
         eprintln!(
             "Changed active version of app '{}/{}' from '{}' to '{}' (id: {})",
             app.owner.global_name,
             app.name,
-            app.active_version.version,
-            app.active_version.version,
-            app.active_version.id.inner()
+            version.version,
+            version.version,
+            version.id.inner(),
         );
 
         Ok(())
diff --git a/lib/cli/src/commands/app/version/get.rs b/lib/cli/src/commands/app/version/get.rs
index 83d80edffa..66494724e9 100644
--- a/lib/cli/src/commands/app/version/get.rs
+++ b/lib/cli/src/commands/app/version/get.rs
@@ -4,6 +4,7 @@ use crate::{
     commands::{app::util::AppIdentOpts, AsyncCliCommand},
     config::WasmerEnv,
     opts::ItemFormatOpts,
+    utils::render::ItemFormat,
 };
 
 /// Show information for a specific app version.
@@ -32,7 +33,7 @@ impl AsyncCliCommand for CmdAppVersionGet {
         let client = self.env.client()?;
         let (_ident, app) = self.ident.load_app(&client).await?;
 
-        let version = wasmer_api::query::get_app_version(
+        let version = wasmer_backend_api::query::get_app_version(
             &client,
             app.owner.global_name,
             app.name,
@@ -41,7 +42,10 @@ impl AsyncCliCommand for CmdAppVersionGet {
         .await?
         .with_context(|| format!("Could not find app version '{}'", self.name))?;
 
-        println!("{}", self.fmt.format.render(&version));
+        println!(
+            "{}",
+            self.fmt.get_with_default(ItemFormat::Yaml).render(&version)
+        );
 
         Ok(())
     }
diff --git a/lib/cli/src/commands/app/version/list.rs b/lib/cli/src/commands/app/version/list.rs
index 895a096c7d..491a79540f 100644
--- a/lib/cli/src/commands/app/version/list.rs
+++ b/lib/cli/src/commands/app/version/list.rs
@@ -1,4 +1,4 @@
-use wasmer_api::types::{DeployAppVersionsSortBy, GetDeployAppVersionsVars};
+use wasmer_backend_api::types::{DeployAppVersionsSortBy, GetDeployAppVersionsVars};
 
 use crate::{
     commands::{app::util::AppIdentOpts, AsyncCliCommand},
@@ -77,7 +77,8 @@ impl AsyncCliCommand for CmdAppVersionList {
         let (_ident, app) = self.ident.load_app(&client).await?;
 
         let versions = if self.all {
-            wasmer_api::query::all_app_versions(&client, app.owner.global_name, app.name).await?
+            wasmer_backend_api::query::all_app_versions(&client, app.owner.global_name, app.name)
+                .await?
         } else {
             let vars = GetDeployAppVersionsVars {
                 owner: app.owner.global_name,
@@ -91,7 +92,7 @@ impl AsyncCliCommand for CmdAppVersionList {
             };
 
             let versions =
-                wasmer_api::query::get_deploy_app_versions(&client, vars.clone()).await?;
+                wasmer_backend_api::query::get_deploy_app_versions(&client, vars.clone()).await?;
 
             versions
                 .edges
diff --git a/lib/cli/src/commands/app/volumes/credentials/mod.rs b/lib/cli/src/commands/app/volumes/credentials/mod.rs
index db0f8906b2..38d70515f5 100644
--- a/lib/cli/src/commands/app/volumes/credentials/mod.rs
+++ b/lib/cli/src/commands/app/volumes/credentials/mod.rs
@@ -30,7 +30,8 @@ impl AsyncCliCommand for CmdAppVolumesCredentials {
         let (_ident, app) = self.ident.load_app(&client).await?;
 
         let creds =
-            wasmer_api::query::get_app_s3_credentials(&client, app.id.clone().into_inner()).await?;
+            wasmer_backend_api::query::get_app_s3_credentials(&client, app.id.clone().into_inner())
+                .await?;
 
         match self.fmt.format {
             CredsItemFormat::Rclone => {
diff --git a/lib/cli/src/commands/app/volumes/credentials/rotate_secrets.rs b/lib/cli/src/commands/app/volumes/credentials/rotate_secrets.rs
index 41cf77eb13..e2d041c64f 100644
--- a/lib/cli/src/commands/app/volumes/credentials/rotate_secrets.rs
+++ b/lib/cli/src/commands/app/volumes/credentials/rotate_secrets.rs
@@ -28,7 +28,7 @@ impl AsyncCliCommand for CmdAppVolumesRotateSecrets {
         let client = self.env.client()?;
         let (_ident, app) = self.ident.load_app(&client).await?;
 
-        wasmer_api::query::rotate_s3_secrets(&client, app.id).await?;
+        wasmer_backend_api::query::rotate_s3_secrets(&client, app.id).await?;
 
         // Don't print it here and leave it implied, so users can append the output
         // of `wasmer app volumes credentials` without worrying about this message.
diff --git a/lib/cli/src/commands/app/volumes/list.rs b/lib/cli/src/commands/app/volumes/list.rs
index b3601209e0..6258b729e4 100644
--- a/lib/cli/src/commands/app/volumes/list.rs
+++ b/lib/cli/src/commands/app/volumes/list.rs
@@ -25,7 +25,8 @@ impl AsyncCliCommand for CmdAppVolumesList {
 
         let (_ident, app) = self.ident.load_app(&client).await?;
         let volumes =
-            wasmer_api::query::get_app_volumes(&client, &app.owner.global_name, &app.name).await?;
+            wasmer_backend_api::query::get_app_volumes(&client, &app.owner.global_name, &app.name)
+                .await?;
 
         if volumes.is_empty() {
             eprintln!("App {} has no volumes!", app.name);
diff --git a/lib/cli/src/commands/auth/login/auth_server.rs b/lib/cli/src/commands/auth/login/auth_server.rs
index 3942111fec..4b2060ac68 100644
--- a/lib/cli/src/commands/auth/login/auth_server.rs
+++ b/lib/cli/src/commands/auth/login/auth_server.rs
@@ -27,7 +27,7 @@ pub(super) async fn setup_listener() -> Result<(TcpListener, String), anyhow::Er
     let addr = listener.local_addr()?;
     let port = addr.port();
 
-    let server_url = format!("http://localhost:{}", port);
+    let server_url = format!("http://localhost:{port}");
 
     Ok((listener, server_url))
 }
diff --git a/lib/cli/src/commands/auth/login/mod.rs b/lib/cli/src/commands/auth/login/mod.rs
index a8795c132d..5388964947 100644
--- a/lib/cli/src/commands/auth/login/mod.rs
+++ b/lib/cli/src/commands/auth/login/mod.rs
@@ -10,7 +10,7 @@ use crate::{
 };
 use futures_util::{stream::FuturesUnordered, StreamExt};
 use std::{path::PathBuf, time::Duration};
-use wasmer_api::{types::Nonce, WasmerClient};
+use wasmer_backend_api::{types::Nonce, WasmerClient};
 
 #[derive(Debug, Clone)]
 enum AuthorizationState {
@@ -20,7 +20,7 @@ enum AuthorizationState {
     UnknownMethod,
 }
 
-/// Subcommand for log in a user into Wasmer (using a browser or provided a token)
+/// Login into Wasmer (using a browser or by providing a token created in https://wasmer.io/settings/access-tokens)
 #[derive(Debug, Clone, clap::Parser)]
 pub struct Login {
     /// Variable to login without opening a browser
@@ -55,25 +55,15 @@ impl Login {
             return Ok(AuthorizationState::TokenSuccess(token.clone()));
         }
 
-        let registry_host = env.registry_endpoint()?;
-        let registry_tld = tldextract::TldExtractor::new(tldextract::TldOption::default())
-            .extract(registry_host.as_str())
-            .map_err(|e| {
-                std::io::Error::new(
-                    std::io::ErrorKind::Other,
-                    format!("Invalid registry for login {}: {e}", registry_host),
-                )
-            })?;
-
-        let login_prompt = match (
-            registry_tld.domain.as_deref(),
-            registry_tld.suffix.as_deref(),
-        ) {
-            (Some(d), Some(s)) => {
-                format!("Please paste the login token from https://{d}.{s}/settings/access-tokens")
+        let public_url = env.registry_public_url()?;
+
+        let login_prompt = match public_url.domain() {
+            Some(d) => {
+                format!("Please paste the login token from https://{d}/settings/access-tokens")
             }
             _ => "Please paste the login token".to_string(),
         };
+
         #[cfg(test)]
         {
             Ok(AuthorizationState::TokenSuccess(login_prompt))
@@ -103,7 +93,7 @@ impl Login {
         };
 
         let Nonce { auth_url, .. } =
-            wasmer_api::query::create_nonce(client, "wasmer-cli".to_string(), server_url)
+            wasmer_backend_api::query::create_nonce(client, "wasmer-cli".to_string(), server_url)
                 .await?
                 .ok_or_else(|| {
                     anyhow::anyhow!("The backend did not return any nonce to auth the login!")
@@ -111,6 +101,10 @@ impl Login {
 
         // if failed to open the browser, then don't error out just print the auth_url with a message
         println!("Opening auth link in your default browser: {}", &auth_url);
+        println!(
+            "{}: If browser driven login does not work, manually create a token at https://wasmer.io/settings/access-tokens and log in with `wasmer login <TOKEN>`",
+            "NOTE".yellow().bold()
+        );
         opener::open_browser(&auth_url).unwrap_or_else(|_| {
             println!(
                 "⚠️ Failed to open the browser.\n
@@ -140,7 +134,7 @@ impl Login {
                     let fut = graceful.watch(conn);
                     futs.push(async move {
                         if let Err(e) = fut.await {
-                            eprintln!("Error serving connection: {:?}", e);
+                            eprintln!("Error serving connection: {e:?}");
                         }
                     });
                 },
@@ -166,29 +160,30 @@ impl Login {
     async fn do_login(&self, env: &WasmerEnv) -> anyhow::Result<AuthorizationState> {
         let client = env.client_unauthennticated()?;
 
-        let should_login = if let Some(user) = wasmer_api::query::current_user(&client).await? {
-            #[cfg(not(test))]
-            {
-                println!(
-                    "You are already logged in as {} in registry {}.",
-                    user.username.bold(),
-                    env.registry_public_url()?.host_str().unwrap().bold()
-                );
-                let theme = dialoguer::theme::ColorfulTheme::default();
-                let dialog = dialoguer::Confirm::with_theme(&theme).with_prompt("Login again?");
-
-                dialog.interact()?
-            }
-            #[cfg(test)]
-            {
-                // prevent unused binding warning
-                _ = user;
+        let should_login =
+            if let Some(user) = wasmer_backend_api::query::current_user(&client).await? {
+                #[cfg(not(test))]
+                {
+                    println!(
+                        "You are already logged in as {} in registry {}.",
+                        user.username.bold(),
+                        env.registry_public_url()?.host_str().unwrap().bold()
+                    );
+                    let theme = dialoguer::theme::ColorfulTheme::default();
+                    let dialog = dialoguer::Confirm::with_theme(&theme).with_prompt("Login again?");
+
+                    dialog.interact()?
+                }
+                #[cfg(test)]
+                {
+                    // prevent unused binding warning
+                    _ = user;
 
-                false
-            }
-        } else {
-            true
-        };
+                    false
+                }
+            } else {
+                true
+            };
 
         if !should_login {
             Ok(AuthorizationState::Cancelled)
@@ -228,7 +223,7 @@ impl Login {
         // This will automatically read the config again, picking up the new edits.
         let client = env.client()?;
 
-        wasmer_api::query::current_user(&client)
+        wasmer_backend_api::query::current_user(&client)
             .await?
             .map(|v| v.username)
             .ok_or_else(|| anyhow::anyhow!("Not logged in!"))
diff --git a/lib/cli/src/commands/auth/logout.rs b/lib/cli/src/commands/auth/logout.rs
index 5e6b9f76d7..ffbb79789a 100644
--- a/lib/cli/src/commands/auth/logout.rs
+++ b/lib/cli/src/commands/auth/logout.rs
@@ -5,7 +5,7 @@ use crate::{
 use colored::Colorize;
 use is_terminal::IsTerminal;
 
-/// Subcommand for log in a user into Wasmer (using a browser or provided a token)
+/// Log out from Wasmer
 #[derive(Debug, Clone, clap::Parser)]
 pub struct Logout {
     #[clap(flatten)]
@@ -39,7 +39,7 @@ impl AsyncCliCommand for Logout {
             .client()
             .map_err(|_| anyhow::anyhow!("Not logged into registry {host_str}"))?;
 
-        let user = wasmer_api::query::current_user(&client)
+        let user = wasmer_backend_api::query::current_user(&client)
             .await
             .map_err(|e| anyhow::anyhow!("Not logged into registry {host_str}: {e}"))?
             .ok_or_else(|| anyhow::anyhow!("Not logged into registry {host_str}"))?;
@@ -92,7 +92,7 @@ impl AsyncCliCommand for Logout {
                 };
 
                 if should_revoke {
-                    wasmer_api::query::revoke_token(&client, token).await?;
+                    wasmer_backend_api::query::revoke_token(&client, token).await?;
                     println!(
                         "Token for user {} in registry {host_str} correctly revoked",
                         user.username.bold()
diff --git a/lib/cli/src/commands/auth/mod.rs b/lib/cli/src/commands/auth/mod.rs
index b893753518..f95f20db8e 100644
--- a/lib/cli/src/commands/auth/mod.rs
+++ b/lib/cli/src/commands/auth/mod.rs
@@ -3,12 +3,11 @@ mod logout;
 mod whoami;
 
 pub use login::*;
-pub use logout::*;
 pub use whoami::*;
 
 use super::AsyncCliCommand;
 
-/// Manage your .
+/// Manage authentication in Wasmer
 #[derive(clap::Subcommand, Debug)]
 pub enum CmdAuth {
     Login(login::Login),
diff --git a/lib/cli/src/commands/auth/whoami.rs b/lib/cli/src/commands/auth/whoami.rs
index d7c10e0f04..269ab41f28 100644
--- a/lib/cli/src/commands/auth/whoami.rs
+++ b/lib/cli/src/commands/auth/whoami.rs
@@ -6,7 +6,7 @@ use crate::config::WasmerEnv;
 use super::AsyncCliCommand;
 
 #[derive(Debug, Parser)]
-/// The options for the `wasmer whoami` subcommand
+/// Print the current user and where is logged into
 pub struct Whoami {
     #[clap(flatten)]
     env: WasmerEnv,
@@ -20,7 +20,7 @@ impl AsyncCliCommand for Whoami {
     async fn run_async(self) -> Result<Self::Output, anyhow::Error> {
         let client = self.env.client_unauthennticated()?;
         let host_str = self.env.registry_public_url()?.host_str().unwrap().bold();
-        let user = wasmer_api::query::current_user(&client)
+        let user = wasmer_backend_api::query::current_user(&client)
             .await?
             .ok_or_else(|| anyhow::anyhow!("Not logged in registry {host_str}"))?;
         println!(
diff --git a/lib/cli/src/commands/cache.rs b/lib/cli/src/commands/cache.rs
index bd6ff0f695..c68cf606d6 100644
--- a/lib/cli/src/commands/cache.rs
+++ b/lib/cli/src/commands/cache.rs
@@ -1,8 +1,7 @@
-use std::{fs, path::Path};
-
+use crate::config::WasmerEnv;
 use anyhow::Result;
 use clap::Parser;
-use wasmer_registry::wasmer_env::WasmerEnv;
+use std::{fs, path::Path};
 
 #[derive(Debug, Parser)]
 /// The options for the `wasmer cache` subcommand
@@ -21,7 +20,7 @@ impl Cache {
 
         match self.cmd {
             Cmd::Clean => {
-                clean(&cache_dir)?;
+                clean(cache_dir)?;
             }
             Cmd::Dir => {
                 println!("{}", self.env.cache_dir().display());
diff --git a/lib/cli/src/commands/compile.rs b/lib/cli/src/commands/compile.rs
index a01cacae71..4c2cc45389 100644
--- a/lib/cli/src/commands/compile.rs
+++ b/lib/cli/src/commands/compile.rs
@@ -1,10 +1,13 @@
 use std::path::PathBuf;
 
-use anyhow::{Context, Result};
+use anyhow::{bail, Context, Result};
 use clap::Parser;
-use wasmer::*;
+use wasmer::{
+    sys::{engine::NativeEngineExt, *},
+    *,
+};
 
-use crate::{common::HashAlgorithm, store::StoreOptions, warning};
+use crate::{backend::RuntimeOptions, common::HashAlgorithm, warning};
 
 #[derive(Debug, Parser)]
 /// The options for the `wasmer compile` subcommand
@@ -22,7 +25,7 @@ pub struct Compile {
     target_triple: Option<Triple>,
 
     #[clap(flatten)]
-    store: StoreOptions,
+    rt: RuntimeOptions,
 
     #[clap(short = 'm')]
     cpu_features: Vec<CpuFeature>,
@@ -57,9 +60,14 @@ impl Compile {
                 Target::new(target_triple.clone(), features)
             })
             .unwrap_or_default();
-        let (mut store, compiler_type) = self.store.get_store_for_target(target.clone())?;
 
-        let engine = store.engine_mut();
+        let module_contents = std::fs::read(&self.path)?;
+        if !is_wasm(&module_contents) {
+            bail!("`wasmer compile` only compiles WebAssembly files");
+        }
+
+        let mut engine = self.rt.get_engine_for_module(&module_contents, &target)?;
+
         let hash_algorithm = self.hash_algorithm.unwrap_or_default().into();
         engine.set_hash_algorithm(Some(hash_algorithm));
 
@@ -80,10 +88,10 @@ impl Compile {
                 warning!("the output file has no extension. We recommend using `{}.{}` for the chosen target", &output_filename, &recommended_extension)
             }
         }
-        println!("Compiler: {}", compiler_type.to_string());
+        println!("Compiler: {}", engine.deterministic_id());
         println!("Target: {}", target.triple());
 
-        let module = Module::from_file(&store, &self.path)?;
+        let module = Module::new(&engine, &module_contents)?;
         module.serialize_to_file(&self.output)?;
         eprintln!(
             "✔ File compiled successfully to `{}`.",
diff --git a/lib/cli/src/commands/config.rs b/lib/cli/src/commands/config.rs
index 261a189673..035d6bf887 100644
--- a/lib/cli/src/commands/config.rs
+++ b/lib/cli/src/commands/config.rs
@@ -1,10 +1,12 @@
-use std::str::ParseBoolError;
-
+use crate::{
+    config::{UpdateRegistry, WasmerConfig, WasmerEnv},
+    VERSION,
+};
 use anyhow::{Context, Result};
 use clap::Parser;
-use wasmer_registry::{wasmer_env::WasmerEnv, WasmerConfig};
+use std::str::ParseBoolError;
 
-use crate::VERSION;
+use super::AsyncCliCommand;
 
 #[derive(Debug, Parser)]
 /// The options for the `wasmer config` subcommand: `wasmer config get --OPTION` or `wasmer config set [FLAG]`
@@ -162,16 +164,22 @@ pub struct SetProxyUrl {
     pub url: String,
 }
 
-impl Config {
+#[async_trait::async_trait]
+impl AsyncCliCommand for Config {
+    type Output = ();
+
     /// Runs logic for the `config` subcommand
-    pub fn execute(&self) -> Result<()> {
+    async fn run_async(self) -> Result<Self::Output, anyhow::Error> {
         self.inner_execute()
+            .await
             .context("failed to retrieve the wasmer config".to_string())
     }
+}
 
-    fn inner_execute(&self) -> Result<()> {
+impl Config {
+    async fn inner_execute(&self) -> Result<()> {
         if let Some(s) = self.set.as_ref() {
-            return s.execute(&self.env);
+            return s.execute(&self.env).await;
         }
 
         let flags = &self.flags;
@@ -182,40 +190,40 @@ impl Config {
         let bindir = prefix.join("bin").display().to_string();
         let includedir = prefix.join("include").display().to_string();
         let libdir = prefix.join("lib").display().to_string();
-        let cflags = format!("-I{}", includedir);
-        let libs = format!("-L{} -lwasmer", libdir);
+        let cflags = format!("-I{includedir}");
+        let libs = format!("-L{libdir} -lwasmer");
 
         if flags.pkg_config {
-            println!("prefix={}", prefixdir);
-            println!("exec_prefix={}", bindir);
-            println!("includedir={}", includedir);
-            println!("libdir={}", libdir);
+            println!("prefix={prefixdir}");
+            println!("exec_prefix={bindir}");
+            println!("includedir={includedir}");
+            println!("libdir={libdir}");
             println!();
             println!("Name: wasmer");
             println!("Description: The Wasmer library for running WebAssembly");
-            println!("Version: {}", VERSION);
-            println!("Cflags: {}", cflags);
-            println!("Libs: {}", libs);
+            println!("Version: {VERSION}");
+            println!("Cflags: {cflags}");
+            println!("Libs: {libs}");
             return Ok(());
         }
 
         if flags.prefix {
-            println!("{}", prefixdir);
+            println!("{prefixdir}");
         }
         if flags.bindir {
-            println!("{}", bindir);
+            println!("{bindir}");
         }
         if flags.includedir {
-            println!("{}", includedir);
+            println!("{includedir}");
         }
         if flags.libdir {
-            println!("{}", libdir);
+            println!("{libdir}");
         }
         if flags.libs {
-            println!("{}", libs);
+            println!("{libs}");
         }
         if flags.cflags {
-            println!("{}", cflags);
+            println!("{cflags}");
         }
 
         if flags.config_path {
@@ -228,7 +236,7 @@ impl Config {
 }
 
 impl GetOrSet {
-    fn execute(&self, env: &WasmerEnv) -> Result<()> {
+    async fn execute(&self, env: &WasmerEnv) -> Result<()> {
         let config_file = WasmerConfig::get_file_location(env.dir());
         let mut config = env.config()?;
 
@@ -262,22 +270,23 @@ impl GetOrSet {
             GetOrSet::Set(s) => {
                 match s {
                     StorableConfigField::RegistryUrl(s) => {
-                        config.registry.set_current_registry(&s.url);
+                        config.registry.set_current_registry(&s.url).await;
                         let current_registry = config.registry.get_current_registry();
-                        if let Some(u) = wasmer_registry::utils::get_username(&current_registry)
-                            .ok()
-                            .and_then(|o| o)
-                        {
-                            println!(
+                        if let Ok(client) = env.client() {
+                            if let Some(u) =
+                                wasmer_backend_api::query::current_user(&client).await?
+                            {
+                                println!(
                                 "Successfully logged into registry {current_registry:?} as user {u:?}"
                             );
+                            }
                         }
                     }
                     StorableConfigField::RegistryToken(t) => {
                         config.registry.set_login_token_for_registry(
                             &config.registry.get_current_registry(),
                             &t.token,
-                            wasmer_registry::config::UpdateRegistry::LeaveAsIs,
+                            UpdateRegistry::LeaveAsIs,
                         );
                     }
                     StorableConfigField::TelemetryEnabled(t) => {
diff --git a/lib/cli/src/commands/connect.rs b/lib/cli/src/commands/connect.rs
index dee96296ca..419e052936 100644
--- a/lib/cli/src/commands/connect.rs
+++ b/lib/cli/src/commands/connect.rs
@@ -1,3 +1,5 @@
+// NOTE: not currently in use - but kept here to allow easy re-implementation.
+
 use std::net::IpAddr;
 
 use crate::config::WasmerEnv;
@@ -34,65 +36,71 @@ pub struct CmdConnect {
 impl AsyncCliCommand for CmdConnect {
     type Output = ();
 
-    #[cfg(all(target_os = "linux", feature = "tun-tap"))]
-    async fn run_async(mut self) -> Result<(), anyhow::Error> {
-        use edge_schema::{AppId, NetworkIdEncodingMethod, WELL_KNOWN_VPN};
-        use virtual_mio::Selector;
+    // Note (xdoardo, 28 Oct 2024):
+    // This part of the code is commented out as we did not manage
+    // to implement tun-tap yet.
+    //
+    //
+    //
+    //#[cfg(all(target_os = "linux", feature = "tun-tap"))]
+    //async fn run_async(mut self) -> Result<(), anyhow::Error> {
+    //    use edge_schema::{AppId, NetworkIdEncodingMethod, WELL_KNOWN_VPN};
+    //    use virtual_mio::Selector;
 
-        use crate::net::TunTapSocket;
+    //    use crate::net::TunTapSocket;
 
-        // If the URL does not include the well known postfix then add it
-        if !self.leave_postfix {
-            self.url.set_path(WELL_KNOWN_VPN);
-        }
+    //    // If the URL does not include the well known postfix then add it
+    //    if !self.leave_postfix {
+    //        self.url.set_path(WELL_KNOWN_VPN);
+    //    }
 
-        if self.print {
-            println!("websocket-url: {}", self.url.as_str());
-            return Ok(());
-        }
+    //    if self.print {
+    //        println!("websocket-url: {}", self.url.as_str());
+    //        return Ok(());
+    //    }
 
-        print!("Connecting...");
-        let socket = TunTapSocket::create(
-            Selector::new(),
-            self.url.clone(),
-            self.leave_down == false,
-            self.ip,
-        )
-        .await
-        .map_err(|err| {
-            println!("failed");
-            err
-        })?;
-        println!("\rConnected to {}    ", self.url.as_str());
+    //    print!("Connecting...");
+    //    let socket = TunTapSocket::create(
+    //        Selector::new(),
+    //        self.url.clone(),
+    //        self.leave_down == false,
+    //        self.ip,
+    //    )
+    //    .await
+    //    .map_err(|err| {
+    //        println!("failed");
+    //        err
+    //    })?;
+    //    println!("\rConnected to {}    ", self.url.as_str());
 
-        for cidr in socket.ips().iter() {
-            println!("Your IP:  {}/{}", cidr.ip, cidr.prefix);
-        }
-        for route in socket.routes().iter() {
-            println!(
-                "Gateway: {}/{} -> {}",
-                route.cidr.ip, route.cidr.prefix, route.via_router
-            );
-        }
-        for cidr in socket.ips().iter() {
-            if let Some((app_id, _)) =
-                AppId::from_ip(&cidr.ip, NetworkIdEncodingMethod::PrivateProjection)
-            {
-                let ip = app_id.into_ip(
-                    cidr.ip,
-                    0x00_1001,
-                    NetworkIdEncodingMethod::PrivateProjection,
-                );
-                println!("Instance: {}/{}", ip, cidr.prefix);
-            }
-        }
-        println!("Press ctrl-c to terminate");
-        socket.await?;
+    //    for cidr in socket.ips().iter() {
+    //        println!("Your IP:  {}/{}", cidr.ip, cidr.prefix);
+    //    }
+    //    for route in socket.routes().iter() {
+    //        println!(
+    //            "Gateway: {}/{} -> {}",
+    //            route.cidr.ip, route.cidr.prefix, route.via_router
+    //        );
+    //    }
+    //    for cidr in socket.ips().iter() {
+    //        if let Some((app_id, _)) =
+    //            AppId::from_ip(&cidr.ip, NetworkIdEncodingMethod::PrivateProjection)
+    //        {
+    //            let ip = app_id.into_ip(
+    //                cidr.ip,
+    //                0x00_1001,
+    //                NetworkIdEncodingMethod::PrivateProjection,
+    //            );
+    //            println!("Instance: {}/{}", ip, cidr.prefix);
+    //        }
+    //    }
+    //    println!("Press ctrl-c to terminate");
+    //    socket.await?;
 
-        Ok(())
-    }
+    //    Ok(())
+    //}
 
-    #[cfg(not(all(target_os = "linux", feature = "tun-tap")))]
+    //#[cfg(not(all(target_os = "linux", feature = "tun-tap")))]
     async fn run_async(self) -> Result<(), anyhow::Error> {
         Err(anyhow::anyhow!(
             "This CLI does not support the 'connect' command: only available on Linux (feature: tun-tap)"
diff --git a/lib/cli/src/commands/create_exe.rs b/lib/cli/src/commands/create_exe.rs
index add738ee75..d4fba44fe1 100644
--- a/lib/cli/src/commands/create_exe.rs
+++ b/lib/cli/src/commands/create_exe.rs
@@ -1,30 +1,35 @@
 //! Create a standalone native executable for a given Wasm file.
 
+use self::utils::normalize_atom_name;
+use super::CliCommand;
+use crate::{
+    backend::RuntimeOptions,
+    common::{normalize_path, HashAlgorithm},
+    config::WasmerEnv,
+};
+use anyhow::{anyhow, bail, Context, Result};
+use clap::Parser;
+use object::ObjectSection;
+use serde::{Deserialize, Serialize};
 use std::{
     collections::BTreeMap,
     env,
     path::{Path, PathBuf},
     process::{Command, Stdio},
 };
-
-use anyhow::{anyhow, bail, Context, Result};
-use clap::Parser;
-use serde::{Deserialize, Serialize};
 use tar::Archive;
-use wasmer::sys::Artifact;
-use wasmer::*;
-use wasmer_object::{emit_serialized, get_object_for_target};
-use wasmer_types::{compilation::symbols::ModuleMetadataSymbolRegistry, ModuleInfo};
-use webc::{
-    compat::{Container, Volume as WebcVolume},
-    PathSegments,
+use target_lexicon::BinaryFormat;
+use wasmer::{
+    sys::{engine::NativeEngineExt, *},
+    *,
 };
-
-use self::utils::normalize_atom_name;
-use crate::{
-    common::{normalize_path, HashAlgorithm},
-    store::CompilerOptions,
+use wasmer_compiler::{
+    object::{emit_serialized, get_object_for_target},
+    types::symbols::{ModuleMetadataSymbolRegistry, Symbol, SymbolRegistry},
 };
+use wasmer_package::utils::from_disk;
+use wasmer_types::ModuleInfo;
+use webc::{Container, Metadata, PathSegments, Volume as WebcVolume};
 
 const LINK_SYSTEM_LIBRARIES_WINDOWS: &[&str] = &["userenv", "Ws2_32", "advapi32", "bcrypt"];
 
@@ -33,6 +38,9 @@ const LINK_SYSTEM_LIBRARIES_UNIX: &[&str] = &["dl", "m", "pthread"];
 #[derive(Debug, Parser)]
 /// The options for the `wasmer create-exe` subcommand
 pub struct CreateExe {
+    #[clap(flatten)]
+    env: WasmerEnv,
+
     /// Input file
     #[clap(name = "FILE")]
     path: PathBuf,
@@ -93,7 +101,7 @@ pub struct CreateExe {
     cross_compile: CrossCompile,
 
     #[clap(flatten)]
-    compiler: CompilerOptions,
+    compiler: RuntimeOptions,
 
     /// Hashing algorithm to be used for module hash
     #[clap(long, value_enum)]
@@ -192,9 +200,11 @@ pub struct Volume {
     pub obj_file: PathBuf,
 }
 
-impl CreateExe {
+impl CliCommand for CreateExe {
+    type Output = ();
+
     /// Runs logic for the `compile` subcommand
-    pub fn execute(&self) -> Result<()> {
+    fn run(self) -> Result<Self::Output, anyhow::Error> {
         let path = normalize_path(&format!("{}", self.path.display()));
         let target_triple = self.target_triple.clone().unwrap_or_else(Triple::host);
         let mut cc = self.cross_compile.clone();
@@ -214,20 +224,25 @@ impl CreateExe {
             None => None,
         };
 
-        let cross_compilation =
-            utils::get_cross_compile_setup(&mut cc, &target_triple, &starting_cd, url_or_version)?;
+        let cross_compilation = utils::get_cross_compile_setup(
+            &self.env,
+            &mut cc,
+            &target_triple,
+            &starting_cd,
+            url_or_version,
+        )?;
 
         if input_path.is_dir() {
             return Err(anyhow::anyhow!("input path cannot be a directory"));
         }
 
-        let (store, compiler_type) = self.compiler.get_store_for_target(target.clone())?;
+        let _backends = self.compiler.get_available_backends()?;
+        let mut engine = self.compiler.get_engine(&target)?;
 
-        let mut engine = store.engine().clone();
         let hash_algorithm = self.hash_algorithm.unwrap_or_default().into();
         engine.set_hash_algorithm(Some(hash_algorithm));
 
-        println!("Compiler: {}", compiler_type.to_string());
+        println!("Compiler: {}", engine.deterministic_id());
         println!("Target: {}", target.triple());
         println!(
             "Using path `{}` as libwasmer path.",
@@ -245,7 +260,7 @@ impl CreateExe {
         };
         std::fs::create_dir_all(&tempdir)?;
 
-        let atoms = if let Ok(pirita) = Container::from_disk(&input_path) {
+        let atoms = if let Ok(pirita) = from_disk(&input_path) {
             // pirita file
             compile_pirita_into_directory(
                 &pirita,
@@ -270,10 +285,17 @@ impl CreateExe {
             )
         }?;
 
-        get_module_infos(&store, &tempdir, &atoms)?;
+        get_module_infos(&engine, &tempdir, &atoms)?;
         let mut entrypoint = get_entrypoint(&tempdir)?;
-        create_header_files_in_dir(&tempdir, &mut entrypoint, &atoms, &self.precompiled_atom)?;
+        create_header_files_in_dir(
+            &tempdir,
+            &mut entrypoint,
+            &atoms,
+            &self.precompiled_atom,
+            &target_triple.binary_format,
+        )?;
         link_exe_from_dir(
+            &self.env,
             &tempdir,
             output_path,
             &cross_compilation,
@@ -351,7 +373,7 @@ pub enum AllowMultiWasm {
 pub(super) fn compile_pirita_into_directory(
     pirita: &Container,
     target_dir: &Path,
-    compiler: &CompilerOptions,
+    compiler: &RuntimeOptions,
     cpu_features: &[CpuFeature],
     triple: &Triple,
     prefixes: &[String],
@@ -365,7 +387,7 @@ pub(super) fn compile_pirita_into_directory(
         AllowMultiWasm::Reject(Some(s)) => {
             let atom = pirita
                 .get_atom(s)
-                .with_context(|| format!("could not find atom \"{s}\"",))?;
+                .with_context(|| format!("could not find atom \"{s}\""))?;
             vec![(s.to_string(), atom)]
         }
     };
@@ -516,14 +538,14 @@ fn serialize_volume_to_webc_v1(volume: &WebcVolume) -> Vec<u8> {
             path.push(segment);
 
             match meta {
-                webc::compat::Metadata::Dir { .. } => {
+                Metadata::Dir { .. } => {
                     files.insert(
                         webc::v1::DirOrFile::Dir(path.to_string().into()),
                         Vec::new(),
                     );
                     read_dir(volume, path, files);
                 }
-                webc::compat::Metadata::File { .. } => {
+                Metadata::File { .. } => {
                     if let Some((contents, _)) = volume.read_file(&*path) {
                         files.insert(
                             webc::v1::DirOrFile::File(path.to_string().into()),
@@ -548,7 +570,7 @@ fn serialize_volume_to_webc_v1(volume: &WebcVolume) -> Vec<u8> {
 impl AllowMultiWasm {
     fn validate(
         &self,
-        all_atoms: &Vec<(String, webc::compat::SharedBytes)>,
+        all_atoms: &[(String, webc::compat::SharedBytes)],
     ) -> Result<(), anyhow::Error> {
         if matches!(self, AllowMultiWasm::Reject(None)) && all_atoms.len() > 1 {
             let keys = all_atoms
@@ -793,7 +815,7 @@ fn test_split_prefix() {
 fn compile_atoms(
     atoms: &[(String, Vec<u8>)],
     output_dir: &Path,
-    compiler: &CompilerOptions,
+    compiler: &RuntimeOptions,
     target: &Target,
     prefixes: &PrefixMapCompilation,
     debug: bool,
@@ -818,8 +840,8 @@ fn compile_atoms(
             }
             continue;
         }
-        let (engine, _) = compiler.get_engine_for_target(target.clone())?;
-        let engine_inner = engine.inner();
+        let engine = compiler.get_sys_compiler_engine_for_target(target.clone())?;
+        let engine_inner = engine.as_sys().inner();
         let compiler = engine_inner.compiler()?;
         let features = engine_inner.features();
         let tunables = engine.tunables();
@@ -844,6 +866,7 @@ fn compile_atoms(
 
 /// Compile the C code.
 fn run_c_compile(
+    env: &WasmerEnv,
     path_to_c_src: &Path,
     output_name: &Path,
     target: &Triple,
@@ -864,7 +887,7 @@ fn run_c_compile(
         .arg("-c")
         .arg(path_to_c_src)
         .arg("-I")
-        .arg(utils::get_wasmer_include_directory()?);
+        .arg(utils::get_wasmer_include_directory(env)?);
 
     for i in include_dirs {
         command = command.arg("-I");
@@ -873,7 +896,7 @@ fn run_c_compile(
 
     // On some compiler -target isn't implemented
     if *target != Triple::host() {
-        command = command.arg("-target").arg(format!("{}", target));
+        command = command.arg("-target").arg(format!("{target}"));
     }
 
     let command = command.arg("-o").arg(output_name);
@@ -936,7 +959,7 @@ fn write_volume_obj(
 pub(super) fn prepare_directory_from_single_wasm_file(
     wasm_file: &Path,
     target_dir: &Path,
-    compiler: &CompilerOptions,
+    compiler: &RuntimeOptions,
     triple: &Triple,
     cpu_features: &[CpuFeature],
     prefix: &[String],
@@ -1010,7 +1033,7 @@ pub(super) fn prepare_directory_from_single_wasm_file(
 // reads the module info from the wasm module and writes the ModuleInfo for each file
 // into the entrypoint.json file
 fn get_module_infos(
-    store: &Store,
+    engine: &Engine,
     directory: &Path,
     atoms: &[(String, Vec<u8>)],
 ) -> Result<BTreeMap<String, ModuleInfo>, anyhow::Error> {
@@ -1019,7 +1042,7 @@ fn get_module_infos(
 
     let mut module_infos = BTreeMap::new();
     for (atom_name, atom_bytes) in atoms {
-        let module = Module::new(&store, atom_bytes.as_slice())?;
+        let module = Module::new(engine, atom_bytes.as_slice())?;
         let module_info = module.info();
         if let Some(s) = entrypoint
             .atoms
@@ -1042,8 +1065,9 @@ pub(crate) fn create_header_files_in_dir(
     entrypoint: &mut Entrypoint,
     atoms: &[(String, Vec<u8>)],
     prefixes: &[String],
+    binary_fmt: &BinaryFormat,
 ) -> anyhow::Result<()> {
-    use object::{Object, ObjectSection};
+    use object::{Object, ObjectSymbol};
 
     std::fs::create_dir_all(directory.join("include")).map_err(|e| {
         anyhow::anyhow!("cannot create /include dir in {}: {e}", directory.display())
@@ -1057,27 +1081,44 @@ pub(crate) fn create_header_files_in_dir(
         let prefix = prefixes
             .get_prefix_for_atom(atom_name)
             .ok_or_else(|| anyhow::anyhow!("cannot get prefix for atom {atom_name}"))?;
+        let symbol_registry = ModuleMetadataSymbolRegistry {
+            prefix: prefix.clone(),
+        };
 
         let object_file_src = directory.join(&atom.path);
         let object_file = std::fs::read(&object_file_src)
             .map_err(|e| anyhow::anyhow!("could not read {}: {e}", object_file_src.display()))?;
         let obj_file = object::File::parse(&*object_file)?;
-        let sections = obj_file
-            .sections()
-            .filter_map(|s| s.name().ok().map(|s| s.to_string()))
-            .collect::<Vec<_>>();
-        let section = obj_file
-            .section_by_name(".data")
-            .unwrap()
-            .data()
-            .map_err(|_| {
-                anyhow::anyhow!(
-                    "missing section .data in object file {} (sections = {:#?}",
-                    object_file_src.display(),
-                    sections
-                )
-            })?;
-        let metadata_length = section.len();
+        let mut symbol_name = symbol_registry.symbol_to_name(Symbol::Metadata);
+        if matches!(binary_fmt, BinaryFormat::Macho) {
+            symbol_name = format!("_{symbol_name}");
+        }
+
+        let mut metadata_length = obj_file.symbol_by_name(&symbol_name).unwrap().size() as usize;
+        if metadata_length == 0 {
+            let metadata_obj = obj_file.symbol_by_name(&symbol_name).unwrap();
+            let sec = obj_file
+                .section_by_index(metadata_obj.section().index().unwrap())
+                .unwrap();
+            let mut syms_in_data_sec = obj_file
+                .symbols()
+                .filter(|v| v.section_index().is_some_and(|i| i == sec.index()))
+                .collect::<Vec<_>>();
+
+            syms_in_data_sec.sort_by_key(|v| v.address());
+
+            let metadata_obj_idx = syms_in_data_sec
+                .iter()
+                .position(|v| v.name().is_ok_and(|v| v == symbol_name))
+                .unwrap();
+
+            metadata_length = if metadata_obj_idx == syms_in_data_sec.len() - 1 {
+                (sec.address() + sec.size()) - syms_in_data_sec[metadata_obj_idx].address()
+            } else {
+                syms_in_data_sec[metadata_obj_idx + 1].address()
+                    - syms_in_data_sec[metadata_obj_idx].address()
+            } as usize;
+        }
 
         let module_info = atom
             .module_info
@@ -1090,9 +1131,7 @@ pub(crate) fn create_header_files_in_dir(
         let header_file_src = crate::c_gen::staticlib_header::generate_header_file(
             &prefix,
             module_info,
-            &ModuleMetadataSymbolRegistry {
-                prefix: prefix.clone(),
-            },
+            &symbol_registry,
             metadata_length,
         );
 
@@ -1111,7 +1150,9 @@ pub(crate) fn create_header_files_in_dir(
 }
 
 /// Given a directory, links all the objects from the directory appropriately
+#[allow(clippy::too_many_arguments)]
 fn link_exe_from_dir(
+    env: &WasmerEnv,
     directory: &Path,
     output_path: PathBuf,
     cross_compilation: &CrossCompileSetup,
@@ -1182,6 +1223,7 @@ fn link_exe_from_dir(
         && cross_compilation.target.operating_system == OperatingSystem::Windows
     {
         run_c_compile(
+            env,
             &directory.join("wasmer_main.c"),
             &directory.join("wasmer_main.o"),
             &cross_compilation.target,
@@ -1284,14 +1326,15 @@ fn link_exe_from_dir(
     let out_path = directory.join("wasmer_main.exe");
     #[cfg(not(target_os = "windows"))]
     let out_path = directory.join("wasmer_main");
-    cmd.arg(&format!("-femit-bin={}", out_path.display()));
+    cmd.arg(format!("-femit-bin={}", out_path.display()));
+
     cmd.args(
-        &object_paths
+        object_paths
             .iter()
             .map(|o| normalize_path(&format!("{}", o.display())))
             .collect::<Vec<_>>(),
     );
-    cmd.arg(&normalize_path(&format!("{}", library_path.display())));
+    cmd.arg(normalize_path(&format!("{}", library_path.display())));
     cmd.arg(normalize_path(&format!(
         "{}",
         directory
@@ -1394,7 +1437,7 @@ fn link_objects_system_linker(
 
     if *target != Triple::host() {
         command = command.arg("-target");
-        command = command.arg(format!("{}", target));
+        command = command.arg(format!("{target}"));
     }
 
     for include_dir in include_dirs {
@@ -1420,11 +1463,11 @@ fn link_objects_system_linker(
     } else {
         additional_libraries.extend(LINK_SYSTEM_LIBRARIES_UNIX.iter().map(|s| s.to_string()));
     }
-    let link_against_extra_libs = additional_libraries.iter().map(|lib| format!("-l{}", lib));
+    let link_against_extra_libs = additional_libraries.iter().map(|lib| format!("-l{lib}"));
     let command = command.args(link_against_extra_libs);
     let command = command.arg("-o").arg(output_path);
     if debug {
-        println!("{:#?}", command);
+        println!("{command:#?}");
     }
     let output = command.output()?;
 
@@ -1540,8 +1583,7 @@ fn generate_wasmer_main_c(
                 })?;
             writeln!(
                 c_code_to_instantiate,
-                "if (strcmp(selected_atom, \"{a}\") == 0) {{ module = atom_{}; }}",
-                prefix
+                "if (strcmp(selected_atom, \"{a}\") == 0) {{ module = atom_{prefix}; }}",
             )?;
         }
     }
@@ -1577,7 +1619,9 @@ pub(super) mod utils {
 
     use anyhow::{anyhow, Context};
     use target_lexicon::{Architecture, Environment, OperatingSystem, Triple};
-    use wasmer_types::{CpuFeature, Target};
+    use wasmer_types::target::{CpuFeature, Target};
+
+    use crate::config::WasmerEnv;
 
     use super::{CrossCompile, CrossCompileSetup, UrlOrVersion};
 
@@ -1595,6 +1639,7 @@ pub(super) mod utils {
     }
 
     pub(in crate::commands) fn get_cross_compile_setup(
+        env: &WasmerEnv,
         cross_subc: &mut CrossCompile,
         target_triple: &Triple,
         starting_cd: &Path,
@@ -1640,13 +1685,10 @@ pub(super) mod utils {
         } else {
             let wasmer_cache_dir =
                 if *target_triple == Triple::host() && std::env::var("WASMER_DIR").is_ok() {
-                    wasmer_registry::WasmerConfig::get_wasmer_dir()
-                        .map_err(|e| anyhow!("{e}"))
-                        .map(|o| o.join("cache"))
+                    Some(env.cache_dir().to_path_buf())
                 } else {
-                    get_libwasmer_cache_path()
-                }
-                .ok();
+                    get_libwasmer_cache_path(env).ok()
+                };
 
             // check if the tarball for the target already exists locally
             let local_tarball = wasmer_cache_dir.as_ref().and_then(|wc| {
@@ -1665,12 +1707,12 @@ pub(super) mod utils {
             });
 
             if let Some(UrlOrVersion::Url(wasmer_release)) = specific_release.as_ref() {
-                let tarball = super::http_fetch::download_url(wasmer_release.as_ref())?;
+                let tarball = super::http_fetch::download_url(env, wasmer_release.as_ref())?;
                 let (filename, tarball_dir) = find_filename(&tarball, target)?;
                 Some(tarball_dir.join(filename))
             } else if let Some(UrlOrVersion::Version(wasmer_release)) = specific_release.as_ref() {
                 let release = super::http_fetch::get_release(Some(wasmer_release.clone()))?;
-                let tarball = super::http_fetch::download_release(release, target.clone())?;
+                let tarball = super::http_fetch::download_release(env, release, target.clone())?;
                 let (filename, tarball_dir) = find_filename(&tarball, target)?;
                 Some(tarball_dir.join(filename))
             } else if let Some(local_tarball) = local_tarball.as_ref() {
@@ -1678,7 +1720,7 @@ pub(super) mod utils {
                 Some(tarball_dir.join(filename))
             } else {
                 let release = super::http_fetch::get_release(None)?;
-                let tarball = super::http_fetch::download_release(release, target.clone())?;
+                let tarball = super::http_fetch::download_release(env, release, target.clone())?;
                 let (filename, tarball_dir) = find_filename(&tarball, target)?;
                 Some(tarball_dir.join(filename))
             }
@@ -1699,52 +1741,62 @@ pub(super) mod utils {
     }
 
     fn filter_tarball_internal(p: &Path, target: &Triple) -> Option<bool> {
-        if !p.file_name()?.to_str()?.ends_with(".tar.gz") {
+        // [todo]: Move this description to a better suited place.
+        //
+        // The filename scheme:
+        // FILENAME := "wasmer-" [ FEATURE ] OS  PLATFORM  .
+        // FEATURE  := "wamr-" | "v8-" | "wasmi-" .
+        // OS       := "darwin" | "linux" | "linux-musl" | "windows" .
+        // PLATFORM := "aarch64" | "amd64" | "gnu64" .
+        //
+        // In this function we want to select only those version where features don't appear.
+
+        let filename = p.file_name()?.to_str()?;
+
+        if !filename.ends_with(".tar.gz") {
+            return None;
+        }
+
+        if filename.contains("wamr") || filename.contains("v8") || filename.contains("wasmi") {
             return None;
         }
 
-        if target.environment == Environment::Musl && !p.file_name()?.to_str()?.contains("musl")
-            || p.file_name()?.to_str()?.contains("musl") && target.environment != Environment::Musl
+        if target.environment == Environment::Musl && !filename.contains("musl")
+            || filename.contains("musl") && target.environment != Environment::Musl
         {
             return None;
         }
 
         if let Architecture::Aarch64(_) = target.architecture {
-            if !(p.file_name()?.to_str()?.contains("aarch64")
-                || p.file_name()?.to_str()?.contains("arm64"))
-            {
+            if !(filename.contains("aarch64") || filename.contains("arm64")) {
                 return None;
             }
         }
 
         if let Architecture::X86_64 = target.architecture {
             if target.operating_system == OperatingSystem::Windows {
-                if !p.file_name()?.to_str()?.contains("gnu64") {
+                if !filename.contains("gnu64") {
                     return None;
                 }
-            } else if !(p.file_name()?.to_str()?.contains("x86_64")
-                || p.file_name()?.to_str()?.contains("amd64"))
-            {
+            } else if !(filename.contains("x86_64") || filename.contains("amd64")) {
                 return None;
             }
         }
 
         if let OperatingSystem::Windows = target.operating_system {
-            if !p.file_name()?.to_str()?.contains("windows") {
+            if !filename.contains("windows") {
                 return None;
             }
         }
 
         if let OperatingSystem::Darwin = target.operating_system {
-            if !(p.file_name()?.to_str()?.contains("apple")
-                || p.file_name()?.to_str()?.contains("darwin"))
-            {
+            if !(filename.contains("apple") || filename.contains("darwin")) {
                 return None;
             }
         }
 
         if let OperatingSystem::Linux = target.operating_system {
-            if !p.file_name()?.to_str()?.contains("linux") {
+            if !filename.contains("linux") {
                 return None;
             }
         }
@@ -1819,33 +1871,29 @@ pub(super) mod utils {
 
     pub(super) fn triple_to_zig_triple(target_triple: &Triple) -> String {
         let arch = match target_triple.architecture {
-            wasmer_types::Architecture::X86_64 => "x86_64".into(),
-            wasmer_types::Architecture::Aarch64(wasmer_types::Aarch64Architecture::Aarch64) => {
+            Architecture::X86_64 => "x86_64".into(),
+            Architecture::Aarch64(wasmer_types::target::Aarch64Architecture::Aarch64) => {
                 "aarch64".into()
             }
             v => v.to_string(),
         };
         let os = match target_triple.operating_system {
-            wasmer_types::OperatingSystem::Linux => "linux".into(),
-            wasmer_types::OperatingSystem::Darwin => "macos".into(),
-            wasmer_types::OperatingSystem::Windows => "windows".into(),
+            OperatingSystem::Linux => "linux".into(),
+            OperatingSystem::Darwin => "macos".into(),
+            OperatingSystem::Windows => "windows".into(),
             v => v.to_string(),
         };
         let env = match target_triple.environment {
-            wasmer_types::Environment::Musl => "musl",
-            wasmer_types::Environment::Gnu => "gnu",
-            wasmer_types::Environment::Msvc => "msvc",
+            Environment::Musl => "musl",
+            Environment::Gnu => "gnu",
+            Environment::Msvc => "msvc",
             _ => "none",
         };
-        format!("{}-{}-{}", arch, os, env)
-    }
-
-    pub(super) fn get_wasmer_dir() -> anyhow::Result<PathBuf> {
-        wasmer_registry::WasmerConfig::get_wasmer_dir().map_err(|e| anyhow!("{e}"))
+        format!("{arch}-{os}-{env}")
     }
 
-    pub(super) fn get_wasmer_include_directory() -> anyhow::Result<PathBuf> {
-        let mut path = get_wasmer_dir()?;
+    pub(super) fn get_wasmer_include_directory(env: &WasmerEnv) -> anyhow::Result<PathBuf> {
+        let mut path = env.dir().to_path_buf();
         if path.clone().join("wasmer.h").exists() {
             return Ok(path);
         }
@@ -1863,8 +1911,8 @@ pub(super) mod utils {
     }
 
     /// path to the static libwasmer
-    pub(super) fn get_libwasmer_path() -> anyhow::Result<PathBuf> {
-        let path = get_wasmer_dir()?;
+    pub(super) fn get_libwasmer_path(env: &WasmerEnv) -> anyhow::Result<PathBuf> {
+        let path = env.dir().to_path_buf();
 
         // TODO: prefer headless Wasmer if/when it's a separate library.
         #[cfg(not(windows))]
@@ -1880,8 +1928,8 @@ pub(super) mod utils {
     }
 
     /// path to library tarball cache dir
-    pub(super) fn get_libwasmer_cache_path() -> anyhow::Result<PathBuf> {
-        let mut path = get_wasmer_dir()?;
+    pub(super) fn get_libwasmer_cache_path(env: &WasmerEnv) -> anyhow::Result<PathBuf> {
+        let mut path = env.dir().to_path_buf();
         path.push("cache");
         std::fs::create_dir_all(&path)?;
         Ok(path)
@@ -2120,6 +2168,8 @@ mod http_fetch {
 
         let status = response.status();
 
+        log::info!("GitHub api response status: {status}");
+
         let body = response
             .bytes()
             .map_err(anyhow::Error::new)
@@ -2173,11 +2223,12 @@ mod http_fetch {
     }
 
     pub(super) fn download_release(
+        env: &WasmerEnv,
         mut release: serde_json::Value,
-        target_triple: wasmer::Triple,
+        target_triple: wasmer::sys::Triple,
     ) -> Result<std::path::PathBuf> {
         // Test if file has been already downloaded
-        if let Ok(mut cache_path) = super::utils::get_libwasmer_cache_path() {
+        if let Ok(mut cache_path) = super::utils::get_libwasmer_cache_path(env) {
             let paths = std::fs::read_dir(&cache_path).and_then(|r| {
                 r.map(|res| res.map(|e| e.path()))
                     .collect::<Result<Vec<_>, std::io::Error>>()
@@ -2218,7 +2269,7 @@ mod http_fetch {
 
         if assets.len() != 1 {
             return Err(anyhow!(
-                "GitHub API: more that one release selected for target {target_triple}: {assets:?}"
+                "GitHub API: more than one release selected for target {target_triple}: {assets:#?}"
             ));
         }
 
@@ -2230,10 +2281,11 @@ mod http_fetch {
             ));
         };
 
-        download_url(&browser_download_url)
+        download_url(env, &browser_download_url)
     }
 
     pub(crate) fn download_url(
+        env: &WasmerEnv,
         browser_download_url: &str,
     ) -> Result<std::path::PathBuf, anyhow::Error> {
         let filename = browser_download_url
@@ -2267,7 +2319,7 @@ mod http_fetch {
             .copy_to(&mut file)
             .map_err(|e| anyhow::anyhow!("{e}"))?;
 
-        match super::utils::get_libwasmer_cache_path() {
+        match super::utils::get_libwasmer_cache_path(env) {
             Ok(mut cache_path) => {
                 cache_path.push(&filename);
                 if let Err(err) = std::fs::copy(&download_path, &cache_path) {
@@ -2287,10 +2339,7 @@ mod http_fetch {
                 }
             }
             Err(err) => {
-                eprintln!(
-                    "Could not determine cache path for downloaded binaries.: {}",
-                    err
-                );
+                eprintln!("Could not determine cache path for downloaded binaries.: {err}");
                 Err(anyhow!("Could not determine libwasmer cache path"))
             }
         }
@@ -2298,6 +2347,8 @@ mod http_fetch {
 
     use std::path::PathBuf;
 
+    use crate::{config::WasmerEnv, utils::unpack::try_unpack_targz};
+
     pub(crate) fn list_dir(target: &Path) -> Vec<PathBuf> {
         use walkdir::WalkDir;
         WalkDir::new(target)
@@ -2309,7 +2360,7 @@ mod http_fetch {
 
     pub(super) fn untar(tarball: &Path, target: &Path) -> Result<Vec<PathBuf>> {
         let _ = std::fs::remove_dir(target);
-        wasmer_registry::try_unpack_targz(tarball, target, false)?;
+        try_unpack_targz(tarball, target, false)?;
         Ok(list_dir(target))
     }
 }
diff --git a/lib/cli/src/commands/create_obj.rs b/lib/cli/src/commands/create_obj.rs
index 22a2f112a4..a50d823d9e 100644
--- a/lib/cli/src/commands/create_obj.rs
+++ b/lib/cli/src/commands/create_obj.rs
@@ -5,9 +5,10 @@ use std::{env, path::PathBuf};
 
 use anyhow::{Context, Result};
 use clap::Parser;
-use wasmer::*;
+use wasmer::sys::*;
+use wasmer_package::utils::from_disk;
 
-use crate::store::CompilerOptions;
+use crate::backend::RuntimeOptions;
 
 #[derive(Debug, Parser)]
 /// The options for the `wasmer create-exe` subcommand
@@ -54,7 +55,7 @@ pub struct CreateObj {
     cpu_features: Vec<CpuFeature>,
 
     #[clap(flatten)]
-    compiler: CompilerOptions,
+    rt: RuntimeOptions,
 }
 
 impl CreateObj {
@@ -79,15 +80,25 @@ impl CreateObj {
             &target_triple,
             &self.cpu_features,
         );
-        let (_, compiler_type) = self.compiler.get_store_for_target(target.clone())?;
-        println!("Compiler: {}", compiler_type.to_string());
+        // let compiler_type = self.rt.get_available_backends()?.get(0).unwrap();
+        // match compiler_type {
+        //     crate::backend::BackendType::Cranelift
+        //     | crate::backend::BackendType::LLVM
+        //     | crate::backend::BackendType::Singlepass=> {
+        //     },
+        //     _ => {
+        //         anyhow::bail!("Cannot produce objects with {compiler_type}!")
+        //     }
+        // }
+        // println!("Compiler: {compiler_type}");
+
         println!("Target: {}", target.triple());
 
-        let atoms = if let Ok(webc) = webc::compat::Container::from_disk(&input_path) {
+        let atoms = if let Ok(webc) = from_disk(&input_path) {
             crate::commands::create_exe::compile_pirita_into_directory(
                 &webc,
                 &output_directory_path,
-                &self.compiler,
+                &self.rt,
                 &self.cpu_features,
                 &target_triple,
                 &prefix,
@@ -98,7 +109,7 @@ impl CreateObj {
             crate::commands::create_exe::prepare_directory_from_single_wasm_file(
                 &input_path,
                 &output_directory_path,
-                &self.compiler,
+                &self.rt,
                 &target_triple,
                 &self.cpu_features,
                 &prefix,
diff --git a/lib/cli/src/commands/domain/get.rs b/lib/cli/src/commands/domain/get.rs
index ace53e8d32..1fd6deaab5 100644
--- a/lib/cli/src/commands/domain/get.rs
+++ b/lib/cli/src/commands/domain/get.rs
@@ -19,7 +19,8 @@ impl AsyncCliCommand for CmdDomainGet {
 
     async fn run_async(self) -> Result<(), anyhow::Error> {
         let client = self.env.client()?;
-        if let Some(domain) = wasmer_api::query::get_domain_with_records(&client, self.name).await?
+        if let Some(domain) =
+            wasmer_backend_api::query::get_domain_with_records(&client, self.name).await?
         {
             println!("{}", self.fmt.format.render(&domain));
         } else {
diff --git a/lib/cli/src/commands/domain/list.rs b/lib/cli/src/commands/domain/list.rs
index d2858bbd7d..89fd218854 100644
--- a/lib/cli/src/commands/domain/list.rs
+++ b/lib/cli/src/commands/domain/list.rs
@@ -1,4 +1,4 @@
-use wasmer_api::types::GetAllDomainsVariables;
+use wasmer_backend_api::types::GetAllDomainsVariables;
 
 use crate::{commands::AsyncCliCommand, config::WasmerEnv, opts::ListFormatOpts};
 
@@ -21,7 +21,7 @@ impl AsyncCliCommand for CmdDomainList {
 
     async fn run_async(self) -> Result<(), anyhow::Error> {
         let client = self.env.client()?;
-        let domains = wasmer_api::query::get_all_domains(
+        let domains = wasmer_backend_api::query::get_all_domains(
             &client,
             GetAllDomainsVariables {
                 first: None,
diff --git a/lib/cli/src/commands/domain/register.rs b/lib/cli/src/commands/domain/register.rs
index 97c954ca72..0cc04d5d6a 100644
--- a/lib/cli/src/commands/domain/register.rs
+++ b/lib/cli/src/commands/domain/register.rs
@@ -27,7 +27,7 @@ impl AsyncCliCommand for CmdDomainRegister {
 
     async fn run_async(self) -> Result<(), anyhow::Error> {
         let client = self.env.client()?;
-        let domain = wasmer_api::query::register_domain(
+        let domain = wasmer_backend_api::query::register_domain(
             &client,
             self.name,
             self.namespace,
diff --git a/lib/cli/src/commands/domain/zonefile.rs b/lib/cli/src/commands/domain/zonefile.rs
index 830c9f820d..cc2fcacf65 100644
--- a/lib/cli/src/commands/domain/zonefile.rs
+++ b/lib/cli/src/commands/domain/zonefile.rs
@@ -39,14 +39,14 @@ impl AsyncCliCommand for CmdZoneFileGet {
     async fn run_async(self) -> Result<(), anyhow::Error> {
         let client = self.env.client()?;
         if let Some(domain) =
-            wasmer_api::query::get_domain_zone_file(&client, self.domain_name).await?
+            wasmer_backend_api::query::get_domain_zone_file(&client, self.domain_name).await?
         {
             let zone_file_contents = domain.zone_file;
             if let Some(zone_file_path) = self.zone_file_path {
                 std::fs::write(zone_file_path, zone_file_contents)
                     .context("Unable to write file")?;
             } else {
-                println!("{}", zone_file_contents);
+                println!("{zone_file_contents}");
             }
         } else {
             anyhow::bail!("Domain not found");
@@ -62,7 +62,7 @@ impl AsyncCliCommand for CmdZoneFileSync {
     async fn run_async(self) -> Result<(), anyhow::Error> {
         let data = std::fs::read(&self.zone_file_path).context("Unable to read file")?;
         let zone_file_contents = String::from_utf8(data).context("Not a valid UTF-8 sequence")?;
-        let domain = wasmer_api::query::upsert_domain_from_zone_file(
+        let domain = wasmer_backend_api::query::upsert_domain_from_zone_file(
             &self.env.client()?,
             zone_file_contents,
             !self.no_delete_missing_records,
diff --git a/lib/cli/src/commands/gen_c_header.rs b/lib/cli/src/commands/gen_c_header.rs
index 142c41a111..2a6bcec2ce 100644
--- a/lib/cli/src/commands/gen_c_header.rs
+++ b/lib/cli/src/commands/gen_c_header.rs
@@ -3,13 +3,14 @@ use std::path::PathBuf;
 use anyhow::{Context, Error};
 use bytes::Bytes;
 use clap::Parser;
-use wasmer_compiler::Artifact;
-use wasmer_types::{
-    compilation::symbols::ModuleMetadataSymbolRegistry, CpuFeature, MetadataHeader, Triple,
+use wasmer_compiler::{
+    object::ObjectMetadataBuilder, types::symbols::ModuleMetadataSymbolRegistry, Artifact,
 };
-use webc::{compat::SharedBytes, Container, DetectError};
+use wasmer_package::{package::WasmerPackageError, utils::from_bytes};
+use wasmer_types::target::{CpuFeature, Triple};
+use webc::{compat::SharedBytes, Container, ContainerError, DetectError};
 
-use crate::store::CompilerOptions;
+use crate::backend::RuntimeOptions;
 
 #[derive(Debug, Parser)]
 /// The options for the `wasmer gen-c-header` subcommand
@@ -60,9 +61,11 @@ impl GenCHeader {
             None => crate::commands::PrefixMapCompilation::hash_for_bytes(&file),
         };
 
-        let atom = match Container::from_bytes(file.clone()) {
+        let atom = match from_bytes(file.clone()) {
             Ok(webc) => self.get_atom(&webc)?,
-            Err(webc::compat::ContainerError::Detect(DetectError::InvalidMagic { .. })) => {
+            Err(WasmerPackageError::ContainerError(ContainerError::Detect(
+                DetectError::InvalidMagic { .. },
+            ))) => {
                 // we've probably got a WebAssembly file
                 file.into()
             }
@@ -76,7 +79,13 @@ impl GenCHeader {
             &target_triple,
             &self.cpu_features,
         );
-        let (engine, _) = CompilerOptions::default().get_engine_for_target(target.clone())?;
+        let engine =
+            RuntimeOptions::default().get_sys_compiler_engine_for_target(target.clone())?;
+        if !engine.is_sys() {
+            anyhow::bail!("Cannot use this engine to generate c-headers! Please, use one of `cranelift`, `llvm` or `singlepass`.");
+        }
+        let engine = engine.into_sys();
+
         let engine_inner = engine.inner();
         let compiler = engine_inner.compiler()?;
         let features = engine_inner.features();
@@ -91,13 +100,9 @@ impl GenCHeader {
         )
         .map_err(|e| anyhow::anyhow!("could not generate metadata: {e}"))?;
 
-        let serialized_data = metadata
-            .serialize()
-            .map_err(|e| anyhow::anyhow!("failed to serialize: {e}"))?;
-        let mut metadata_binary = vec![];
-        metadata_binary.extend(MetadataHeader::new(serialized_data.len()).into_bytes());
-        metadata_binary.extend(serialized_data);
-        let metadata_length = metadata_binary.len();
+        let metadata_builder = ObjectMetadataBuilder::new(&metadata, &target_triple)
+            .map_err(|e| anyhow::anyhow!("failed to create relocs builder: {e}"))?;
+        let metadata_length = metadata_builder.placeholder_data().len();
 
         let header_file_src = crate::c_gen::staticlib_header::generate_header_file(
             &prefix,
diff --git a/lib/cli/src/commands/gen_completions.rs b/lib/cli/src/commands/gen_completions.rs
index 271c704a79..e3b64794d7 100644
--- a/lib/cli/src/commands/gen_completions.rs
+++ b/lib/cli/src/commands/gen_completions.rs
@@ -17,7 +17,7 @@ impl CmdGenCompletions {
     pub fn execute(&self) -> anyhow::Result<()> {
         let mut cmd = WasmerCmd::command();
 
-        let name = cmd.get_name().to_string();
+        let name = std::env::args().next().unwrap();
         if let Some(out) = &self.out {
             let mut f = OpenOptions::new()
                 .truncate(true)
diff --git a/lib/cli/src/commands/gen_manpage.rs b/lib/cli/src/commands/gen_manpage.rs
index e2c396232c..411121c077 100644
--- a/lib/cli/src/commands/gen_manpage.rs
+++ b/lib/cli/src/commands/gen_manpage.rs
@@ -3,10 +3,14 @@ use anyhow::Context;
 use clap::CommandFactory;
 use clap_mangen::generate_to;
 use std::path::PathBuf;
+use std::sync::LazyLock;
 
-lazy_static::lazy_static! {
-    static ref DEFAULT_MAN_DIR_PATH: PathBuf = dirs::data_dir().unwrap_or_default().join("man").join("man1");
-}
+static DEFAULT_MAN_DIR_PATH: LazyLock<PathBuf> = LazyLock::new(|| {
+    dirs::data_dir()
+        .unwrap_or_default()
+        .join("man")
+        .join("man1")
+});
 
 #[derive(Debug, Clone, clap::Parser)]
 pub struct CmdGenManPage {
diff --git a/lib/cli/src/commands/init.rs b/lib/cli/src/commands/init.rs
index 0e127a30b6..26b416bb3a 100644
--- a/lib/cli/src/commands/init.rs
+++ b/lib/cli/src/commands/init.rs
@@ -1,13 +1,12 @@
-use std::{
-    collections::HashMap,
-    path::{Path, PathBuf},
-};
-
+use crate::config::WasmerEnv;
 use anyhow::Context;
 use cargo_metadata::{CargoOpt, MetadataCommand};
 use clap::Parser;
+use indexmap::IndexMap;
 use semver::VersionReq;
-use wasmer_registry::wasmer_env::WasmerEnv;
+use std::path::{Path, PathBuf};
+
+use super::AsyncCliCommand;
 
 static NOTE: &str = "# See more keys and definitions at https://docs.wasmer.io/registry/manifest";
 
@@ -94,9 +93,11 @@ struct MiniCargoTomlPackage {
 
 static WASMER_TOML_NAME: &str = "wasmer.toml";
 
-impl Init {
-    /// `wasmer init` execution
-    pub fn execute(&self) -> Result<(), anyhow::Error> {
+#[async_trait::async_trait]
+impl AsyncCliCommand for Init {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
         let bin_or_lib = self.get_bin_or_lib()?;
 
         // See if the directory has a Cargo.toml file, if yes, copy the license / readme, etc.
@@ -130,6 +131,7 @@ impl Init {
         }
 
         let constructed_manifest = construct_manifest(
+            &self.env,
             cargo_toml.as_ref(),
             &fallback_package_name,
             self.package_name.as_deref(),
@@ -141,8 +143,8 @@ impl Init {
             self.template.as_ref(),
             self.include.as_slice(),
             self.quiet,
-            self.env.dir(),
-        )?;
+        )
+        .await?;
 
         if let Some(parent) = target_file.parent() {
             let _ = std::fs::create_dir_all(parent);
@@ -151,7 +153,9 @@ impl Init {
         // generate the wasmer.toml and exit
         Self::write_wasmer_toml(&target_file, &constructed_manifest)
     }
+}
 
+impl Init {
     /// Writes the metadata to a wasmer.toml file, making sure we include the
     /// [`NOTE`] so people get a link to the registry docs.
     fn write_wasmer_toml(
@@ -265,8 +269,8 @@ impl Init {
     }
 
     /// Returns the dependencies based on the `--template` flag
-    fn get_dependencies(template: Option<&Template>) -> HashMap<String, VersionReq> {
-        let mut map = HashMap::default();
+    fn get_dependencies(template: Option<&Template>) -> IndexMap<String, VersionReq> {
+        let mut map = IndexMap::default();
 
         match template {
             Some(Template::Js) => {
@@ -349,13 +353,14 @@ impl GetBindingsResult {
     fn first_binding(&self) -> Option<wasmer_config::package::Bindings> {
         match self {
             Self::OneBinding(s) => Some(s.clone()),
-            Self::MultiBindings(s) => s.get(0).cloned(),
+            Self::MultiBindings(s) => s.first().cloned(),
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn construct_manifest(
+async fn construct_manifest(
+    env: &WasmerEnv,
     cargo_toml: Option<&MiniCargoTomlPackage>,
     fallback_package_name: &String,
     package_name: Option<&str>,
@@ -367,7 +372,6 @@ fn construct_manifest(
     template: Option<&Template>,
     include_fs: &[String],
     quiet: bool,
-    wasmer_dir: &Path,
 ) -> Result<wasmer_config::package::Manifest, anyhow::Error> {
     if let Some(ct) = cargo_toml.as_ref() {
         let msg = format!(
@@ -386,11 +390,20 @@ fn construct_manifest(
             .map(|p| &p.name)
             .unwrap_or(fallback_package_name)
     });
-    let namespace = namespace.or_else(|| {
-        wasmer_registry::whoami(wasmer_dir, None, None)
-            .ok()
-            .map(|o| o.1)
-    });
+    let namespace = match namespace {
+        Some(n) => Some(n),
+        None => {
+            if let Ok(client) = env.client() {
+                if let Ok(Some(u)) = wasmer_backend_api::query::current_user(&client).await {
+                    Some(u.username)
+                } else {
+                    None
+                }
+            } else {
+                None
+            }
+        }
+    };
     let version = version.unwrap_or_else(|| {
         cargo_toml
             .as_ref()
@@ -424,7 +437,7 @@ fn construct_manifest(
             .collect::<Vec<_>>()
             .join("\r\n");
 
-        let msg = vec![
+        let msg = [
             String::new(),
             "    It looks like your project contains multiple *.wai files.".to_string(),
             "    Make sure you update the [[module.bindings]] appropriately".to_string(),
@@ -474,10 +487,11 @@ fn construct_manifest(
         abi: default_abi,
         bindings: bindings.as_ref().and_then(|b| b.first_binding()),
         interfaces: Some({
-            let mut map = HashMap::new();
+            let mut map = IndexMap::new();
             map.insert("wasi".to_string(), "0.1.0-unstable".to_string());
             map
         }),
+        annotations: None,
     }];
 
     let mut pkg = wasmer_config::package::Package::builder(
@@ -554,6 +568,6 @@ fn parse_cargo_toml(manifest_path: &PathBuf) -> Result<MiniCargoTomlPackage, any
         build_dir: metadata
             .target_directory
             .into_std_path_buf()
-            .join("wasm32-wasi"),
+            .join("wasm32-wasip1"),
     })
 }
diff --git a/lib/cli/src/commands/inspect.rs b/lib/cli/src/commands/inspect.rs
index 80b4d05abd..cd999277ba 100644
--- a/lib/cli/src/commands/inspect.rs
+++ b/lib/cli/src/commands/inspect.rs
@@ -1,11 +1,11 @@
 use std::path::PathBuf;
 
+use crate::backend::RuntimeOptions;
 use anyhow::{Context, Result};
 use bytesize::ByteSize;
 use clap::Parser;
 use wasmer::*;
-
-use crate::store::StoreOptions;
+use wasmer_types::target::Target;
 
 #[derive(Debug, Parser)]
 /// The options for the `wasmer validate` subcommand
@@ -15,7 +15,7 @@ pub struct Inspect {
     path: PathBuf,
 
     #[clap(flatten)]
-    store: StoreOptions,
+    rt: RuntimeOptions,
 }
 
 impl Inspect {
@@ -26,12 +26,19 @@ impl Inspect {
     }
 
     fn inner_execute(&self) -> Result<()> {
-        let (store, _compiler_type) = self.store.get_store()?;
-
         let module_contents = std::fs::read(&self.path)?;
+        let engine = self
+            .rt
+            .get_engine_for_module(&module_contents, &Target::default())?;
+
         let iswasm = is_wasm(&module_contents);
         let module_len = module_contents.len();
-        let module = Module::new(&store, module_contents)?;
+        let module = Module::new(&engine, module_contents)?;
+        println!(
+            "Backend used to parse the module: {}",
+            engine.deterministic_id()
+        );
+
         println!("Type: {}", if !iswasm { "wat" } else { "wasm" });
         println!("Size: {}", ByteSize(module_len as _));
         println!("Imports:");
diff --git a/lib/cli/src/commands/journal/filter.rs b/lib/cli/src/commands/journal/filter.rs
index 4052067efd..31225350be 100644
--- a/lib/cli/src/commands/journal/filter.rs
+++ b/lib/cli/src/commands/journal/filter.rs
@@ -35,7 +35,7 @@ impl FromStr for FilterOut {
             "core" => Self::Core,
             "snap" | "snapshot" | "snapshots" => Self::Snapshots,
             "net" | "network" | "networking" => Self::Networking,
-            t => return Err(format!("unknown filter type - {}", t)),
+            t => return Err(format!("unknown filter type - {t}")),
         })
     }
 }
diff --git a/lib/cli/src/commands/journal/import.rs b/lib/cli/src/commands/journal/import.rs
index 00bf0e50fe..668cb364dc 100644
--- a/lib/cli/src/commands/journal/import.rs
+++ b/lib/cli/src/commands/journal/import.rs
@@ -46,7 +46,7 @@ impl CliCommand for CmdJournalImport {
             }
 
             let record = serde_json::from_str::<JournalEntry<'static>>(&lines)?;
-            println!("{}", record);
+            println!("{record}");
             journal.write(record)?;
             lines.clear();
         }
diff --git a/lib/cli/src/commands/journal/mount/cmd.rs b/lib/cli/src/commands/journal/mount/cmd.rs
index 66d03f0e27..92dd4afb07 100644
--- a/lib/cli/src/commands/journal/mount/cmd.rs
+++ b/lib/cli/src/commands/journal/mount/cmd.rs
@@ -36,7 +36,7 @@ impl CliCommand for CmdJournalMount {
             .build()?;
 
         // Mounts the journal file system at a path
-        fuse::mount(fs, &self.mount_path, &[])?;
+        fuser::mount(fs, &self.mount_path, &[])?;
         Ok(())
     }
 }
diff --git a/lib/cli/src/commands/journal/mount/fs.rs b/lib/cli/src/commands/journal/mount/fs.rs
index 5544eed0f5..556797965a 100644
--- a/lib/cli/src/commands/journal/mount/fs.rs
+++ b/lib/cli/src/commands/journal/mount/fs.rs
@@ -11,7 +11,7 @@ use std::{
     time::Duration,
 };
 
-use fuse::{
+use fuser::{
     FileAttr, Filesystem, ReplyAttr, ReplyBmap, ReplyCreate, ReplyData, ReplyDirectory, ReplyEmpty,
     ReplyEntry, ReplyLock, ReplyOpen, ReplyStatfs, ReplyWrite, ReplyXattr, Request,
 };
@@ -460,7 +460,7 @@ impl Filesystem for JournalFileSystem {
                         mtime: time01::Timespec::new(file.last_modified() as i64, 0),
                         ctime: time01::Timespec::new(file.created_time() as i64, 0),
                         crtime: time01::Timespec::new(file.created_time() as i64, 0),
-                        kind: fuse::FileType::RegularFile,
+                        kind: fuser::FileType::RegularFile,
                         perm: 0o644,
                         nlink: 1,
                         uid: 0,
@@ -534,7 +534,7 @@ impl Filesystem for JournalFileSystem {
                             mtime: time01::Timespec::new(file.last_modified() as i64, 0),
                             ctime: time01::Timespec::new(file.created_time() as i64, 0),
                             crtime: time01::Timespec::new(file.created_time() as i64, 0),
-                            kind: fuse::FileType::RegularFile,
+                            kind: fuser::FileType::RegularFile,
                             perm: 0o644,
                             nlink: 1,
                             uid: 0,
@@ -746,7 +746,7 @@ impl Filesystem for JournalFileSystem {
                 mtime: now,
                 ctime: now,
                 crtime: now,
-                kind: fuse::FileType::RegularFile,
+                kind: fuser::FileType::RegularFile,
                 perm: 0o644,
                 nlink: 1,
                 uid: 0,
@@ -956,7 +956,7 @@ impl Filesystem for JournalFileSystem {
             // Compute the directory kind
             let kind = match entry.file_type() {
                 Ok(ft) => file_type_to_kind(ft),
-                _ => fuse::FileType::RegularFile,
+                _ => fuser::FileType::RegularFile,
             };
 
             // i + 1 means the index of the next entry
@@ -1203,18 +1203,18 @@ impl Filesystem for JournalFileSystem {
     }
 }
 
-fn file_type_to_kind(ft: virtual_fs::FileType) -> fuse::FileType {
+fn file_type_to_kind(ft: virtual_fs::FileType) -> fuser::FileType {
     if ft.dir {
-        fuse::FileType::Directory
+        fuser::FileType::Directory
     } else if ft.symlink {
-        fuse::FileType::Symlink
+        fuser::FileType::Symlink
     } else if ft.block_device {
-        fuse::FileType::BlockDevice
+        fuser::FileType::BlockDevice
     } else if ft.char_device {
-        fuse::FileType::CharDevice
+        fuser::FileType::CharDevice
     } else if ft.socket {
-        fuse::FileType::Socket
+        fuser::FileType::Socket
     } else {
-        fuse::FileType::RegularFile
+        fuser::FileType::RegularFile
     }
 }
diff --git a/lib/cli/src/commands/mod.rs b/lib/cli/src/commands/mod.rs
index 5b56d25b08..c77840f5c2 100644
--- a/lib/cli/src/commands/mod.rs
+++ b/lib/cli/src/commands/mod.rs
@@ -178,12 +178,12 @@ impl WasmerCmd {
             #[cfg(feature = "compiler")]
             Some(Cmd::Compile(compile)) => compile.execute(),
             #[cfg(any(feature = "static-artifact-create", feature = "wasmer-artifact-create"))]
-            Some(Cmd::CreateExe(create_exe)) => create_exe.execute(),
+            Some(Cmd::CreateExe(create_exe)) => create_exe.run(),
             #[cfg(feature = "static-artifact-create")]
             Some(Cmd::CreateObj(create_obj)) => create_obj.execute(),
-            Some(Cmd::Config(config)) => config.execute(),
+            Some(Cmd::Config(config)) => config.run(),
             Some(Cmd::Inspect(inspect)) => inspect.execute(),
-            Some(Cmd::Init(init)) => init.execute(),
+            Some(Cmd::Init(init)) => init.run(),
             Some(Cmd::Login(login)) => login.run(),
             Some(Cmd::Auth(auth)) => auth.run(),
             Some(Cmd::Publish(publish)) => publish.run().map(|_| ()),
@@ -198,9 +198,6 @@ impl WasmerCmd {
             Some(Cmd::Container(cmd)) => match cmd {
                 crate::commands::Container::Unpack(cmd) => cmd.execute(),
             },
-            /*
-            Some(Cmd::Connect(connect)) => connect.execute(),
-            */
             #[cfg(feature = "static-artifact-create")]
             Some(Cmd::GenCHeader(gen_heder)) => gen_heder.execute(),
             #[cfg(feature = "wast")]
@@ -208,7 +205,7 @@ impl WasmerCmd {
             #[cfg(target_os = "linux")]
             Some(Cmd::Binfmt(binfmt)) => binfmt.execute(),
             Some(Cmd::Whoami(whoami)) => whoami.run(),
-            Some(Cmd::Add(install)) => install.execute(),
+            Some(Cmd::Add(add)) => add.run(),
 
             // Deploy commands.
             Some(Cmd::Deploy(c)) => c.run(),
@@ -287,7 +284,7 @@ impl WasmerCmd {
 #[allow(clippy::large_enum_variant)]
 /// The options for the wasmer Command Line Interface
 enum Cmd {
-    /// Login into a wasmer.io-like registry
+    /// Login into Wasmer
     Login(Login),
 
     #[clap(subcommand)]
@@ -295,7 +292,7 @@ enum Cmd {
 
     /// Publish a package to a registry [alias: package publish]
     #[clap(name = "publish")]
-    Publish(crate::commands::package::publish::PackagePublish),
+    Publish(PackagePublish),
 
     /// Manage the local Wasmer cache
     Cache(Cache),
@@ -405,7 +402,7 @@ enum Cmd {
     Whoami(Whoami),
 
     /// Add a Wasmer package's bindings to your application
-    Add(Add),
+    Add(CmdAdd),
 
     /// Run a WebAssembly file or Wasmer container
     #[clap(alias = "run-unstable")]
@@ -482,17 +479,29 @@ fn print_version(verbose: bool) -> Result<(), anyhow::Error> {
     println!("commit-date: {}", env!("WASMER_BUILD_DATE"));
     println!("host: {}", target_lexicon::HOST);
 
-    let mut compilers = Vec::<&'static str>::new();
+    let mut runtimes = Vec::<&'static str>::new();
     if cfg!(feature = "singlepass") {
-        compilers.push("singlepass");
+        runtimes.push("singlepass");
     }
     if cfg!(feature = "cranelift") {
-        compilers.push("cranelift");
+        runtimes.push("cranelift");
     }
     if cfg!(feature = "llvm") {
-        compilers.push("llvm");
+        runtimes.push("llvm");
     }
-    println!("compiler: {}", compilers.join(","));
 
+    if cfg!(feature = "wamr") {
+        runtimes.push("wamr");
+    }
+
+    if cfg!(feature = "wasmi") {
+        runtimes.push("wasmi");
+    }
+
+    if cfg!(feature = "v8") {
+        runtimes.push("v8");
+    }
+
+    println!("runtimes: {}", runtimes.join(", "));
     Ok(())
 }
diff --git a/lib/cli/src/commands/namespace/create.rs b/lib/cli/src/commands/namespace/create.rs
index adc6b3017f..dbe528233e 100644
--- a/lib/cli/src/commands/namespace/create.rs
+++ b/lib/cli/src/commands/namespace/create.rs
@@ -24,13 +24,13 @@ impl AsyncCliCommand for CmdNamespaceCreate {
     async fn run_async(self) -> Result<(), anyhow::Error> {
         let client = self.env.client()?;
 
-        let vars = wasmer_api::types::CreateNamespaceVars {
+        let vars = wasmer_backend_api::types::CreateNamespaceVars {
             name: self.name.clone(),
             description: self.description.clone(),
         };
-        let namespace = wasmer_api::query::create_namespace(&client, vars).await?;
+        let namespace = wasmer_backend_api::query::create_namespace(&client, vars).await?;
 
-        println!("{}", self.fmt.format.render(&namespace));
+        println!("{}", self.fmt.get().render(&namespace));
 
         Ok(())
     }
diff --git a/lib/cli/src/commands/namespace/get.rs b/lib/cli/src/commands/namespace/get.rs
index 48138de830..48406d3bb2 100644
--- a/lib/cli/src/commands/namespace/get.rs
+++ b/lib/cli/src/commands/namespace/get.rs
@@ -22,11 +22,11 @@ impl AsyncCliCommand for CmdNamespaceGet {
     async fn run_async(self) -> Result<(), anyhow::Error> {
         let client = self.env.client()?;
 
-        let namespace = wasmer_api::query::get_namespace(&client, self.name)
+        let namespace = wasmer_backend_api::query::get_namespace(&client, self.name)
             .await?
             .context("namespace not found")?;
 
-        println!("{}", self.fmt.format.render(&namespace));
+        println!("{}", self.fmt.get().render(&namespace));
 
         Ok(())
     }
diff --git a/lib/cli/src/commands/namespace/list.rs b/lib/cli/src/commands/namespace/list.rs
index a5e61fb368..333ce037e1 100644
--- a/lib/cli/src/commands/namespace/list.rs
+++ b/lib/cli/src/commands/namespace/list.rs
@@ -16,7 +16,7 @@ impl AsyncCliCommand for CmdNamespaceList {
     async fn run_async(self) -> Result<(), anyhow::Error> {
         let client = self.env.client()?;
 
-        let namespaces = wasmer_api::query::user_namespaces(&client).await?;
+        let namespaces = wasmer_backend_api::query::user_namespaces(&client).await?;
 
         println!("{}", self.fmt.format.render(&namespaces));
 
diff --git a/lib/cli/src/commands/package/build.rs b/lib/cli/src/commands/package/build.rs
index 28860967e0..16590d208d 100644
--- a/lib/cli/src/commands/package/build.rs
+++ b/lib/cli/src/commands/package/build.rs
@@ -5,7 +5,7 @@ use dialoguer::console::{style, Emoji};
 use indicatif::ProgressBar;
 use sha2::Digest;
 use wasmer_config::package::PackageHash;
-use webc::wasmer_package::Package;
+use wasmer_package::package::Package;
 
 use crate::utils::load_package_manifest;
 
@@ -54,12 +54,10 @@ impl PackageBuild {
                 manifest_path.display()
             )
         };
-        let pkg = webc::wasmer_package::Package::from_manifest(manifest_path.clone()).context(
-            format!(
-                "While parsing the manifest (loaded from {})",
-                manifest_path.canonicalize()?.display()
-            ),
-        )?;
+        let pkg = Package::from_manifest(manifest_path.clone()).context(format!(
+            "While parsing the manifest (loaded from {})",
+            manifest_path.canonicalize()?.display()
+        ))?;
         let data = pkg.serialize().context("While validating the package")?;
         let hash = sha2::Sha256::digest(&data).into();
         let pkg_hash = PackageHash::from_sha256_bytes(hash);
@@ -72,10 +70,10 @@ impl PackageBuild {
                     format!("{}-{}.webc", name.replace('/', "-"), pkg_hash)
                 }
             } else {
-                format!("{}.webc", pkg_hash)
+                format!("{pkg_hash}.webc")
             }
         } else {
-            format!("{}.webc", pkg_hash)
+            format!("{pkg_hash}.webc")
         };
 
         // Setup the progress bar
@@ -181,6 +179,8 @@ impl PackageBuild {
 
 #[cfg(test)]
 mod tests {
+    use wasmer_package::utils::from_disk;
+
     use super::*;
 
     /// Download a package from the dev registry.
@@ -215,6 +215,6 @@ description = "hello"
 
         cmd.execute().unwrap();
 
-        webc::Container::from_disk(path.join("wasmer-hello-0.1.0.webc")).unwrap();
+        from_disk(path.join("wasmer-hello-0.1.0.webc")).unwrap();
     }
 }
diff --git a/lib/cli/src/commands/package/common/mod.rs b/lib/cli/src/commands/package/common/mod.rs
index 5641f96bfd..ef5a32e302 100644
--- a/lib/cli/src/commands/package/common/mod.rs
+++ b/lib/cli/src/commands/package/common/mod.rs
@@ -11,9 +11,9 @@ use std::{
     collections::BTreeMap,
     path::{Path, PathBuf},
 };
-use wasmer_api::WasmerClient;
+use wasmer_backend_api::WasmerClient;
 use wasmer_config::package::{Manifest, NamedPackageIdent, PackageHash};
-use webc::wasmer_package::Package;
+use wasmer_package::package::Package;
 
 pub mod macros;
 pub mod wait;
@@ -44,13 +44,14 @@ pub(super) async fn upload(
     timeout: humantime::Duration,
     package: &Package,
     pb: ProgressBar,
+    proxy: Option<reqwest::Proxy>,
 ) -> anyhow::Result<String> {
     let hash_str = hash.to_string();
     let hash_str = hash_str.trim_start_matches("sha256:");
 
     let session_uri = {
         let default_timeout_secs = Some(60 * 30);
-        let q = wasmer_api::query::get_signed_url_for_package_upload(
+        let q = wasmer_backend_api::query::get_signed_url_for_package_upload(
             client,
             default_timeout_secs,
             Some(hash_str),
@@ -68,11 +69,19 @@ pub(super) async fn upload(
 
     tracing::info!("signed url is: {session_uri}");
 
-    let client = reqwest::Client::builder()
-        .default_headers(reqwest::header::HeaderMap::default())
-        .timeout(timeout.into())
-        .build()
-        .unwrap();
+    let client = {
+        let builder = reqwest::Client::builder()
+            .default_headers(reqwest::header::HeaderMap::default())
+            .timeout(timeout.into());
+
+        let builder = if let Some(proxy) = proxy {
+            builder.proxy(proxy)
+        } else {
+            builder
+        };
+
+        builder.build().unwrap()
+    };
 
     let res = client
         .post(&session_uri)
@@ -153,13 +162,13 @@ pub(super) async fn upload(
     let res = client
         .put(&session_uri)
         .header(reqwest::header::CONTENT_TYPE, "application/octet-stream")
-        .header(reqwest::header::CONTENT_LENGTH, format!("{}", total_bytes))
+        .header(reqwest::header::CONTENT_LENGTH, format!("{total_bytes}"))
         .body(Body::wrap_stream(stream));
 
     res.send()
         .await
         .map(|response| response.error_for_status())
-        .map_err(|e| anyhow::anyhow!("error uploading package to {session_uri}: {e}",))??;
+        .map_err(|e| anyhow::anyhow!("error uploading package to {session_uri}: {e}"))??;
 
     Ok(session_uri)
 }
diff --git a/lib/cli/src/commands/package/common/wait.rs b/lib/cli/src/commands/package/common/wait.rs
index 8fcba61e20..0aef557cfa 100644
--- a/lib/cli/src/commands/package/common/wait.rs
+++ b/lib/cli/src/commands/package/common/wait.rs
@@ -1,5 +1,5 @@
-use futures_util::StreamExt;
-use wasmer_api::WasmerClient;
+use futures::StreamExt;
+use wasmer_backend_api::{types::PackageVersionState, WasmerClient};
 
 /// Different conditions that can be "awaited" when publishing a package.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, clap::ValueEnum)]
@@ -79,23 +79,18 @@ impl From<PublishWait> for WaitPackageState {
 pub async fn wait_package(
     client: &WasmerClient,
     to_wait: PublishWait,
-    package_version_id: wasmer_api::types::Id,
+    package_version_id: wasmer_backend_api::types::Id,
     timeout: humantime::Duration,
 ) -> anyhow::Result<()> {
     if let PublishWait::None = to_wait {
         return Ok(());
     }
 
-    let registry_url = client.graphql_endpoint().to_string();
-    let login_token = client.auth_token().unwrap_or_default().to_string();
     let package_version_id = package_version_id.into_inner();
 
-    let (mut stream, _) = wasmer_registry::subscriptions::subscribe_package_version_ready(
-        &registry_url,
-        &login_token,
-        &package_version_id,
-    )
-    .await?;
+    let mut stream =
+        wasmer_backend_api::subscription::package_version_ready(client, &package_version_id)
+            .await?;
 
     let mut state: WaitPackageState = to_wait.into();
 
@@ -127,16 +122,9 @@ pub async fn wait_package(
 
         if let Some(data) = data.unwrap().data {
             match data.package_version_ready.state {
-                wasmer_registry::subscriptions::PackageVersionState::WEBC_GENERATED => {
-                    state.container = false
-                }
-                wasmer_registry::subscriptions::PackageVersionState::BINDINGS_GENERATED => {
-                    state.bindings = false
-                }
-                wasmer_registry::subscriptions::PackageVersionState::NATIVE_EXES_GENERATED => {
-                    state.native_executables = false
-                }
-                wasmer_registry::subscriptions::PackageVersionState::Other(_) => {}
+                PackageVersionState::WebcGenerated => state.container = false,
+                PackageVersionState::BindingsGenerated => state.bindings = false,
+                PackageVersionState::NativeExesGenerated => state.native_executables = false,
             }
         }
     }
diff --git a/lib/cli/src/commands/package/download.rs b/lib/cli/src/commands/package/download.rs
index bc168fae95..54888fa407 100644
--- a/lib/cli/src/commands/package/download.rs
+++ b/lib/cli/src/commands/package/download.rs
@@ -5,11 +5,19 @@ use dialoguer::console::{style, Emoji};
 use indicatif::{ProgressBar, ProgressStyle};
 use tempfile::NamedTempFile;
 use wasmer_config::package::{PackageIdent, PackageSource};
-use wasmer_wasix::http::reqwest::get_proxy;
+use wasmer_package::utils::from_disk;
 
 use crate::config::WasmerEnv;
 
 /// Download a package from the registry.
+///
+/// Examples:
+/// * `wasmer package download wasmer/hello`
+///   Download the `wasmer/hello` package, writing to `./hello@<version>.webc`.
+///
+/// * `wasmer package download --unpack wasmer/hello@0.1.0 -o hello.webc`
+///    Download the `wasmer/hello` package version `0.1.0`, writing to `./hello.webc`,
+///    and unpacking it to `./hello.webc.unpacked/`.
 #[derive(clap::Parser, Debug)]
 pub struct PackageDownload {
     #[clap(flatten)]
@@ -26,11 +34,15 @@ pub struct PackageDownload {
 
     /// Run the download command without any output
     #[clap(long)]
-    pub quiet: bool,
+    quiet: bool,
 
-    /// proxy to use for downloading
-    #[clap(long)]
-    pub proxy: Option<String>,
+    /// Unpack the downloaded package.
+    ///
+    /// The unpacked directory will be next to the downloaded file, with a `.unpacked` suffix.
+    ///
+    /// Note: unpacking can also be done manually with the `wasmer package unpack` command.
+    #[clap(short, long)]
+    unpack: bool,
 
     /// The package to download.
     package: PackageSource,
@@ -60,14 +72,34 @@ impl PackageDownload {
 
         pb.println(format!(
             "{} {}Creating output directory...",
-            style(format!("[{}/{}]", step_num, total_steps))
-                .bold()
-                .dim(),
+            style(format!("[{step_num}/{total_steps}]")).bold().dim(),
             CREATING_OUTPUT_DIRECTORY_EMOJI,
         ));
 
         step_num += 1;
 
+        let out_dir = if let Some(parent) = self.out_path.as_ref().and_then(|p| p.parent()) {
+            match parent.metadata() {
+                Ok(m) => {
+                    if !m.is_dir() {
+                        bail!(
+                            "parent of output file is not a directory: '{}'",
+                            parent.display()
+                        );
+                    }
+                    parent.to_owned()
+                }
+                Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
+                    std::fs::create_dir_all(parent)
+                        .context("could not create parent directory of output file")?;
+                    parent.to_owned()
+                }
+                Err(err) => return Err(err.into()),
+            }
+        } else {
+            current_dir()?
+        };
+
         if let Some(parent) = self.out_path.as_ref().and_then(|p| p.parent()) {
             match parent.metadata() {
                 Ok(m) => {
@@ -88,9 +120,7 @@ impl PackageDownload {
 
         pb.println(format!(
             "{} {}Retrieving package information...",
-            style(format!("[{}/{}]", step_num, total_steps))
-                .bold()
-                .dim(),
+            style(format!("[{step_num}/{total_steps}]")).bold().dim(),
             RETRIEVING_PACKAGE_INFORMATION_EMOJI
         ));
 
@@ -101,13 +131,7 @@ impl PackageDownload {
                 // caveat: client_unauthennticated will use a token if provided, it
                 // just won't fail if none is present. So, _unauthenticated() can actually
                 // produce an authenticated client.
-                let client = if let Some(proxy) = &self.proxy {
-                    let proxy = reqwest::Proxy::all(proxy)?;
-
-                    self.env.client_unauthennticated_with_proxy(proxy)?
-                } else {
-                    self.env.client_unauthennticated()?
-                };
+                let client = self.env.client_unauthennticated()?;
 
                 let version = id.version_or_default().to_string();
                 let version = if version == "*" {
@@ -119,7 +143,7 @@ impl PackageDownload {
 
                 let rt = tokio::runtime::Runtime::new()?;
                 let package = rt
-                    .block_on(wasmer_api::query::get_package_version(
+                    .block_on(wasmer_backend_api::query::get_package_version(
                         &client,
                         full_name.clone(),
                         version.clone(),
@@ -157,11 +181,11 @@ impl PackageDownload {
                 let client = self.env.client_unauthennticated()?;
 
                 let rt = tokio::runtime::Runtime::new()?;
-                let pkg = rt.block_on(wasmer_api::query::get_package_release(&client, &hash.to_string()))?
+                let pkg = rt.block_on(wasmer_backend_api::query::get_package_release(&client, &hash.to_string()))?
                     .with_context(|| format!("Package with {hash} does not exist in the registry, or is not accessible"))?;
 
                 let ident = hash.to_string();
-                let filename = format!("{}.webc", hash);
+                let filename = format!("{hash}.webc");
 
                 (pkg.webc_url, ident, filename)
             }
@@ -171,7 +195,7 @@ impl PackageDownload {
 
         let builder = {
             let mut builder = reqwest::blocking::ClientBuilder::new();
-            if let Some(proxy) = get_proxy()? {
+            if let Some(proxy) = self.env.proxy()? {
                 builder = builder.proxy(proxy);
             }
             builder
@@ -183,12 +207,8 @@ impl PackageDownload {
             .header(http::header::ACCEPT, "application/webc");
 
         pb.println(format!(
-            "{} {}Downloading package {} ...",
-            style(format!("[{}/{}]", step_num, total_steps))
-                .bold()
-                .dim(),
-            DOWNLOADING_PACKAGE_EMOJI,
-            ident,
+            "{} {DOWNLOADING_PACKAGE_EMOJI}Downloading package {ident} ...",
+            style(format!("[{step_num}/{total_steps}]")).bold().dim(),
         ));
 
         step_num += 1;
@@ -213,11 +233,7 @@ impl PackageDownload {
         // Set the length of the progress bar
         pb.set_length(webc_total_size);
 
-        let mut tmpfile = if let Some(parent) = self.out_path.as_ref().and_then(|p| p.parent()) {
-            NamedTempFile::new_in(parent)?
-        } else {
-            NamedTempFile::new()?
-        };
+        let mut tmpfile = NamedTempFile::new_in(&out_dir)?;
         let accepted_contenttypes = vec![
             "application/webc",
             "application/octet-stream",
@@ -231,8 +247,7 @@ impl PackageDownload {
         if !(accepted_contenttypes.contains(&ty)) {
             eprintln!(
                 "Warning: response has invalid content type - expected \
-                 one of {:?}, got {ty}",
-                accepted_contenttypes
+                 one of {accepted_contenttypes:?}, got {ty}",
             );
         }
 
@@ -244,24 +259,21 @@ impl PackageDownload {
         if self.validate {
             if !self.quiet {
                 println!(
-                    "{} {}Validating package...",
-                    style(format!("[{}/{}]", step_num, total_steps))
-                        .bold()
-                        .dim(),
-                    VALIDATING_PACKAGE_EMOJI
+                    "{} {VALIDATING_PACKAGE_EMOJI}Validating package...",
+                    style(format!("[{step_num}/{total_steps}]")).bold().dim(),
                 );
             }
 
             step_num += 1;
 
-            webc::compat::Container::from_disk(tmpfile.path())
+            from_disk(tmpfile.path())
                 .context("could not parse downloaded file as a package - invalid download?")?;
         }
 
         let out_path = if let Some(out_path) = &self.out_path {
             out_path.clone()
         } else {
-            current_dir()?.join(filename)
+            out_dir.join(filename)
         };
 
         tmpfile.persist(&out_path).with_context(|| {
@@ -272,17 +284,31 @@ impl PackageDownload {
         })?;
 
         pb.println(format!(
-            "{} {}Package downloaded to '{}'",
-            style(format!("[{}/{}]", step_num, total_steps))
-                .bold()
-                .dim(),
-            WRITING_PACKAGE_EMOJI,
+            "{} {WRITING_PACKAGE_EMOJI}Package downloaded to '{}'",
+            style(format!("[{step_num}/{total_steps}]")).bold().dim(),
             out_path.display()
         ));
 
         // We're done, so finish the progress bar
         pb.finish();
 
+        if self.unpack {
+            let out_dir = if out_path.extension().is_some() {
+                out_path.with_extension("")
+            } else {
+                out_path.with_extension("unpacked")
+            };
+
+            let unpack_cmd = super::unpack::PackageUnpack {
+                out_dir,
+                overwrite: false,
+                quiet: self.quiet,
+                package_path: out_path,
+                format: super::unpack::Format::Package,
+            };
+            unpack_cmd.execute()?;
+        }
+
         Ok(())
     }
 }
@@ -308,12 +334,14 @@ mod tests {
             validate: true,
             out_path: Some(out_path.clone()),
             package: "wasmer/hello@0.1.0".parse().unwrap(),
+            unpack: true,
             quiet: true,
-            proxy: None,
         };
 
         cmd.execute().unwrap();
 
-        webc::compat::Container::from_disk(out_path).unwrap();
+        from_disk(out_path).unwrap();
+
+        assert!(dir.path().join("hello/wasmer.toml").is_file());
     }
 }
diff --git a/lib/cli/src/commands/package/publish.rs b/lib/cli/src/commands/package/publish.rs
index 4b3fbdaebe..df34b4751d 100644
--- a/lib/cli/src/commands/package/publish.rs
+++ b/lib/cli/src/commands/package/publish.rs
@@ -12,7 +12,7 @@ use crate::{
 use colored::Colorize;
 use is_terminal::IsTerminal;
 use std::path::{Path, PathBuf};
-use wasmer_api::WasmerClient;
+use wasmer_backend_api::WasmerClient;
 use wasmer_config::package::{Manifest, PackageIdent};
 
 /// Publish (push and tag) a package to the registry.
diff --git a/lib/cli/src/commands/package/push.rs b/lib/cli/src/commands/package/push.rs
index 03de8e9aad..af4318af59 100644
--- a/lib/cli/src/commands/package/push.rs
+++ b/lib/cli/src/commands/package/push.rs
@@ -7,9 +7,9 @@ use anyhow::Context;
 use colored::Colorize;
 use is_terminal::IsTerminal;
 use std::path::{Path, PathBuf};
-use wasmer_api::WasmerClient;
+use wasmer_backend_api::WasmerClient;
 use wasmer_config::package::{Manifest, PackageHash};
-use webc::wasmer_package::Package;
+use wasmer_package::package::Package;
 
 /// Push a package to the registry.
 ///
@@ -78,7 +78,7 @@ impl PackagePush {
             anyhow::bail!("No package namespace specified: use --namespace XXX");
         }
 
-        let user = wasmer_api::query::current_user_with_namespaces(client, None).await?;
+        let user = wasmer_backend_api::query::current_user_with_namespaces(client, None).await?;
         let owner = crate::utils::prompts::prompt_for_namespace(
             "Choose a namespace to push the package to",
             None,
@@ -112,7 +112,7 @@ impl PackagePush {
     }
 
     async fn should_push(&self, client: &WasmerClient, hash: &PackageHash) -> anyhow::Result<bool> {
-        let res = wasmer_api::query::get_package_release(client, &hash.to_string()).await;
+        let res = wasmer_backend_api::query::get_package_release(client, &hash.to_string()).await;
         tracing::info!("{:?}", res);
         res.map(|p| p.is_none())
     }
@@ -128,11 +128,19 @@ impl PackagePush {
     ) -> anyhow::Result<()> {
         let pb = make_spinner!(self.quiet, "Uploading the package..");
 
-        let signed_url = upload(client, package_hash, self.timeout, package, pb.clone()).await?;
+        let signed_url = upload(
+            client,
+            package_hash,
+            self.timeout,
+            package,
+            pb.clone(),
+            self.env.proxy()?,
+        )
+        .await?;
         spinner_ok!(pb, "Package correctly uploaded");
 
         let pb = make_spinner!(self.quiet, "Waiting for package to become available...");
-        match wasmer_api::query::push_package_release(
+        match wasmer_backend_api::query::push_package_release(
             client,
             name.as_deref(),
             namespace,
diff --git a/lib/cli/src/commands/package/tag.rs b/lib/cli/src/commands/package/tag.rs
index d936134956..ce4ad0d81f 100644
--- a/lib/cli/src/commands/package/tag.rs
+++ b/lib/cli/src/commands/package/tag.rs
@@ -13,7 +13,7 @@ use std::{
     path::{Path, PathBuf},
     str::FromStr,
 };
-use wasmer_api::WasmerClient;
+use wasmer_backend_api::WasmerClient;
 use wasmer_config::package::{
     Manifest, NamedPackageId, NamedPackageIdent, PackageBuilder, PackageHash, PackageIdent,
 };
@@ -154,7 +154,7 @@ impl PackageTag {
         client: &WasmerClient,
         id: &NamedPackageId,
         manifest: Option<&Manifest>,
-        package_release_id: &wasmer_api::types::Id,
+        package_release_id: &wasmer_backend_api::types::Id,
     ) -> anyhow::Result<()> {
         tracing::info!(
             "Tagging package with registry id {:?} and specifier {:?}",
@@ -200,7 +200,19 @@ impl PackageTag {
             None
         };
 
-        let r = wasmer_api::query::tag_package_release(
+        let maybe_readme_content = match maybe_readme {
+            Some(readme) => {
+                let readme_path = self.package_path.join(&readme);
+                if readme_path.exists() {
+                    Some(tokio::fs::read_to_string(readme_path).await?)
+                } else {
+                    None
+                }
+            }
+            None => None,
+        };
+
+        let r = wasmer_backend_api::query::tag_package_release(
             client,
             maybe_description.as_deref(),
             maybe_homepage.as_deref(),
@@ -211,7 +223,7 @@ impl PackageTag {
             None,
             package_release_id,
             private,
-            maybe_readme.as_deref(),
+            maybe_readme_content.as_deref(),
             maybe_repository.as_deref(),
             &version,
         );
@@ -219,7 +231,7 @@ impl PackageTag {
         match r.await? {
             Some(r) => {
                 if r.success {
-                    spinner_ok!(pb, format!("Successfully tagged package {id}",));
+                    spinner_ok!(pb, format!("Successfully tagged package {id}"));
                     if let Some(package_version) = r.package_version {
                         wait_package(client, self.wait, package_version.id, self.timeout).await?;
                     }
@@ -241,7 +253,7 @@ impl PackageTag {
         client: &WasmerClient,
         hash: &PackageHash,
         check_package_exists: bool,
-    ) -> anyhow::Result<wasmer_api::types::Id> {
+    ) -> anyhow::Result<wasmer_backend_api::types::Id> {
         let pb = make_spinner!(
             self.quiet || check_package_exists,
             "Checking if the package exists.."
@@ -249,7 +261,9 @@ impl PackageTag {
 
         tracing::debug!("Searching for package with hash: {hash}");
 
-        let pkg = match wasmer_api::query::get_package_release(client, &hash.to_string()).await? {
+        let pkg = match wasmer_backend_api::query::get_package_release(client, &hash.to_string())
+            .await?
+        {
             Some(p) => p,
             None => {
                 spinner_err!(pb, "The package is not in the registry!");
@@ -366,7 +380,7 @@ impl PackageTag {
             anyhow::bail!("No package namespace specified: use --namespace <package_namespace>");
         }
 
-        let user = wasmer_api::query::current_user_with_namespaces(client, None).await?;
+        let user = wasmer_backend_api::query::current_user_with_namespaces(client, None).await?;
         crate::utils::prompts::prompt_for_namespace("Choose a namespace", None, Some(&user))
     }
 
@@ -403,7 +417,7 @@ impl PackageTag {
             format!("Checking if a version of {full_pkg_name} already exists..")
         );
 
-        if let Some(registry_version) = wasmer_api::query::get_package_version(
+        if let Some(registry_version) = wasmer_backend_api::query::get_package_version(
             client,
             full_pkg_name.to_string(),
             String::from("latest"),
@@ -425,7 +439,7 @@ impl PackageTag {
 
             // Must necessarily bump if there's a package with the chosen version with a different hash.
             let must_bump = {
-                let maybe_pkg = wasmer_api::query::get_package_version(
+                let maybe_pkg = wasmer_backend_api::query::get_package_version(
                     client,
                     full_pkg_name.to_string(),
                     user_version.to_string(),
@@ -590,7 +604,7 @@ impl PackageTag {
             return Ok(false);
         }
 
-        let pkg = wasmer_api::query::get_package_version(
+        let pkg = wasmer_backend_api::query::get_package_version(
             client,
             id.full_name.clone(),
             id.version.to_string(),
diff --git a/lib/cli/src/commands/package/unpack.rs b/lib/cli/src/commands/package/unpack.rs
index 0f4784886e..08e579d4bb 100644
--- a/lib/cli/src/commands/package/unpack.rs
+++ b/lib/cli/src/commands/package/unpack.rs
@@ -3,29 +3,56 @@ use std::path::PathBuf;
 use anyhow::Context;
 use dialoguer::console::{style, Emoji};
 use indicatif::ProgressBar;
+use wasmer_package::utils::from_disk;
 
 /// Extract contents of a webc image to a directory.
+///
+/// See --format flag for available output formats.
 #[derive(clap::Parser, Debug)]
 pub struct PackageUnpack {
     /// The output directory.
     #[clap(short = 'o', long)]
-    out_dir: PathBuf,
+    pub out_dir: PathBuf,
 
     /// Overwrite existing directories/files.
     #[clap(long)]
-    overwrite: bool,
+    pub overwrite: bool,
 
     /// Run the unpack command without any output
     #[clap(long)]
     pub quiet: bool,
 
     /// Path to the package.
-    package_path: PathBuf,
+    pub package_path: PathBuf,
+
+    /// Output format.
+    ///
+    /// * package
+    ///   Restore a package directory with a wasmer.toml
+    ///   NOTE: this conversion is lossy, because webcs don't store the original
+    ///   wasmer.toml and the full contents can not be restored.
+    ///
+    /// * webc
+    ///   Directly unpack the webc contents.
+    ///   - Volumes will be placed in subdirectories.
+    ///   - atoms will be placed in the root directory
+    ///   - the full webc manifest will be placed in a manifest.json file
+    #[clap(short, long, default_value = "package")]
+    pub format: Format,
 }
 
 static PACKAGE_EMOJI: Emoji<'_, '_> = Emoji("📦 ", "");
 static EXTRACTED_TO_EMOJI: Emoji<'_, '_> = Emoji("📂 ", "");
 
+/// Webc unpack format.
+#[derive(clap::ValueEnum, Clone, Debug)]
+pub enum Format {
+    /// See [`PackageUnpack::format`] for details.
+    Package,
+    /// See [`PackageUnpack::format`] for details.
+    Webc,
+}
+
 impl PackageUnpack {
     pub(crate) fn execute(&self) -> Result<(), anyhow::Error> {
         // Setup the progress bar
@@ -41,7 +68,7 @@ impl PackageUnpack {
             PACKAGE_EMOJI
         ));
 
-        let pkg = webc::compat::Container::from_disk(&self.package_path).with_context(|| {
+        let pkg = from_disk(&self.package_path).with_context(|| {
             format!(
                 "could not open package at '{}'",
                 self.package_path.display()
@@ -52,8 +79,16 @@ impl PackageUnpack {
         std::fs::create_dir_all(outdir)
             .with_context(|| format!("could not create output directory '{}'", outdir.display()))?;
 
-        pkg.unpack(outdir, self.overwrite)
-            .with_context(|| "could not extract package".to_string())?;
+        match self.format {
+            Format::Package => {
+                wasmer_package::convert::webc_to_package_dir(&pkg, outdir)
+                    .with_context(|| "could not extract package")?;
+            }
+            Format::Webc => {
+                pkg.unpack(outdir, self.overwrite)
+                    .with_context(|| "could not extract package".to_string())?;
+            }
+        }
 
         pb.println(format!(
             "{} {}Extracted package contents to '{}'",
@@ -89,6 +124,7 @@ mod tests {
             overwrite: false,
             package_path,
             quiet: true,
+            format: Format::Webc,
         };
 
         cmd.execute().unwrap();
diff --git a/lib/cli/src/commands/run/capabilities/mod.rs b/lib/cli/src/commands/run/capabilities/mod.rs
index d6f95d0833..ada750bd57 100644
--- a/lib/cli/src/commands/run/capabilities/mod.rs
+++ b/lib/cli/src/commands/run/capabilities/mod.rs
@@ -1,3 +1,5 @@
+use crate::config::WasmerEnv;
+
 use super::PackageSource;
 use anyhow::anyhow;
 use sha2::{Digest, Sha256};
@@ -5,8 +7,8 @@ use std::{
     path::{Path, PathBuf},
     time::UNIX_EPOCH,
 };
+
 use wasmer_config::package::PackageSource as PackageSpecifier;
-use wasmer_registry::wasmer_env::WasmerEnv;
 
 /// A custom implementation of the [`virtual_net::VirtualNetwork`] that asks users if they want to
 /// use networking features at runtime.
@@ -88,7 +90,7 @@ pub(crate) fn get_capability_cache_path(
                     n.name
                 ),
                 wasmer_config::package::PackageIdent::Hash(h) => {
-                    format!("hash_{}", h)
+                    format!("hash_{h}")
                 }
             },
             PackageSpecifier::Path(f) => {
diff --git a/lib/cli/src/commands/run/mod.rs b/lib/cli/src/commands/run/mod.rs
index eefc629f72..e92a857731 100644
--- a/lib/cli/src/commands/run/mod.rs
+++ b/lib/cli/src/commands/run/mod.rs
@@ -18,46 +18,53 @@ use std::{
 
 use anyhow::{anyhow, bail, Context, Error};
 use clap::{Parser, ValueEnum};
+use futures::future::BoxFuture;
 use indicatif::{MultiProgress, ProgressBar};
+use is_terminal::IsTerminal as _;
 use once_cell::sync::Lazy;
 use tempfile::NamedTempFile;
 use url::Url;
 #[cfg(feature = "sys")]
-use wasmer::NativeEngineExt;
+use wasmer::sys::NativeEngineExt;
 use wasmer::{
-    DeserializeError, Engine, Function, Imports, Instance, Module, Store, Type, TypedFunction,
-    Value,
+    AsStoreMut, DeserializeError, Engine, Function, Imports, Instance, Module, Store, Type,
+    TypedFunction, Value,
 };
 
+use wasmer_types::{target::Target, Features};
+
 #[cfg(feature = "compiler")]
 use wasmer_compiler::ArtifactBuild;
 use wasmer_config::package::PackageSource as PackageSpecifier;
-use wasmer_registry::{wasmer_env::WasmerEnv, Package};
+use wasmer_package::utils::from_disk;
 use wasmer_types::ModuleHash;
+
 #[cfg(feature = "journal")]
 use wasmer_wasix::journal::{LogFileJournal, SnapshotTrigger};
 use wasmer_wasix::{
-    bin_factory::BinaryPackage,
+    bin_factory::{BinaryPackage, BinaryPackageCommand},
     journal::CompactingLogFileJournal,
     runners::{
         dcgi::{DcgiInstanceFactory, DcgiRunner},
         dproxy::DProxyRunner,
-        emscripten::EmscriptenRunner,
-        wasi::WasiRunner,
+        wasi::{RuntimeOrEngine, WasiRunner},
         wcgi::{self, AbortHandle, NoOpWcgiCallbacks, WcgiRunner},
         MappedCommand, MappedDirectory, Runner,
     },
     runtime::{
-        module_cache::CacheError, package_loader::PackageLoader, resolver::QueryError,
+        module_cache::{CacheError, HashedModuleData},
+        package_loader::PackageLoader,
+        resolver::QueryError,
         task_manager::VirtualTaskManagerExt,
     },
-    Runtime, WasiError,
+    Runtime, SpawnError, WasiError,
 };
-use webc::{metadata::Manifest, Container};
+use webc::metadata::Manifest;
+use webc::Container;
 
 use crate::{
-    commands::run::wasi::Wasi, common::HashAlgorithm, error::PrettyError, logging::Output,
-    store::StoreOptions,
+    backend::RuntimeOptions, commands::run::wasi::Wasi, common::HashAlgorithm, config::WasmerEnv,
+    error::PrettyError, logging::Output,
 };
 
 const TICK: Duration = Duration::from_millis(250);
@@ -68,7 +75,7 @@ pub struct Run {
     #[clap(flatten)]
     env: WasmerEnv,
     #[clap(flatten)]
-    store: StoreOptions,
+    rt: RuntimeOptions,
     #[clap(flatten)]
     wasi: crate::commands::run::Wasi,
     #[clap(flatten)]
@@ -76,9 +83,12 @@ pub struct Run {
     /// Set the default stack size (default is 1048576)
     #[clap(long = "stack-size")]
     stack_size: Option<usize>,
-    /// The function or command to invoke.
-    #[clap(short, long, aliases = &["command", "invoke", "command-name"])]
+    /// The entrypoint module for webc packages.
+    #[clap(short, long, aliases = &["command", "command-name"])]
     entrypoint: Option<String>,
+    /// The function to invoke.
+    #[clap(short, long)]
+    invoke: Option<String>,
     /// Generate a coredump at this path if a WebAssembly trap occurs
     #[clap(name = "COREDUMP_PATH", long)]
     coredump_on_trap: Option<PathBuf>,
@@ -111,11 +121,6 @@ impl Run {
             .build()?;
         let handle = runtime.handle().clone();
 
-        #[cfg(feature = "sys")]
-        if self.stack_size.is_some() {
-            wasmer_vm::set_stack_size(self.stack_size.unwrap());
-        }
-
         // Check for the preferred webc version.
         // Default to v3.
         let webc_version_var = std::env::var("WASMER_WEBC_VERSION");
@@ -128,18 +133,80 @@ impl Run {
         };
 
         let _guard = handle.enter();
-        let (store, _) = self.store.get_store()?;
+
+        // Get the input file path
+        let mut wasm_bytes: Option<Vec<u8>> = None;
+
+        // Try to detect WebAssembly features before selecting a backend
+        tracing::info!("Input source: {:?}", self.input);
+        if let PackageSource::File(path) = &self.input {
+            tracing::info!("Input file path: {}", path.display());
+
+            // Try to read and detect any file that exists, regardless of extension
+            if path.exists() {
+                tracing::info!("Found file: {}", path.display());
+                match std::fs::read(path) {
+                    Ok(bytes) => {
+                        tracing::info!("Read {} bytes from file", bytes.len());
+
+                        // Check if it's a WebAssembly module by looking for magic bytes
+                        let magic = [0x00, 0x61, 0x73, 0x6D]; // "\0asm"
+                        if bytes.len() >= 4 && bytes[0..4] == magic {
+                            // Looks like a valid WebAssembly module, save the bytes for feature detection
+                            tracing::info!(
+                                "Valid WebAssembly module detected, magic header verified"
+                            );
+                            wasm_bytes = Some(bytes);
+                        } else {
+                            tracing::info!("File does not have valid WebAssembly magic number, will try to run it anyway");
+                            // Still provide the bytes so the engine can attempt to run it
+                            wasm_bytes = Some(bytes);
+                        }
+                    }
+                    Err(e) => {
+                        tracing::info!("Failed to read file for feature detection: {}", e);
+                    }
+                }
+            } else {
+                tracing::info!("File does not exist: {}", path.display());
+            }
+        } else {
+            tracing::info!("Input is not a file, skipping WebAssembly feature detection");
+        }
+
+        // Get engine with feature-based backend selection if possible
+        let mut engine = match &wasm_bytes {
+            Some(wasm_bytes) => {
+                tracing::info!("Attempting to detect WebAssembly features from binary");
+
+                self.rt
+                    .get_engine_for_module(wasm_bytes, &Target::default())?
+            }
+            None => {
+                // No WebAssembly file available for analysis, check if we have a webc package
+                if let PackageSource::Package(ref pkg_source) = &self.input {
+                    tracing::info!("Checking package for WebAssembly features: {}", pkg_source);
+                    self.rt.get_engine(&Target::default())?
+                } else {
+                    tracing::info!("No feature detection possible, using default engine");
+                    self.rt.get_engine(&Target::default())?
+                }
+            }
+        };
+
+        let engine_kind = engine.deterministic_id();
+        tracing::info!("Executing on backend {engine_kind:?}");
 
         #[cfg(feature = "sys")]
-        let engine = {
-            let mut engine = store.engine().clone();
+        if engine.is_sys() {
+            if self.stack_size.is_some() {
+                wasmer_vm::set_stack_size(self.stack_size.unwrap());
+            }
             let hash_algorithm = self.hash_algorithm.unwrap_or_default().into();
             engine.set_hash_algorithm(Some(hash_algorithm));
+        }
 
-            engine
-        };
-        #[cfg(not(feature = "sys"))]
-        let engine = store.engine().clone();
+        let engine = engine.clone();
 
         let runtime = self.wasi.prepare_runtime(
             engine,
@@ -174,8 +241,64 @@ impl Run {
                     module,
                     module_hash,
                     path,
-                } => self.execute_wasm(&path, &module, module_hash, store, runtime.clone()),
-                ExecutableTarget::Package(pkg) => self.execute_webc(&pkg, runtime.clone()),
+                } => self.execute_wasm(&path, module, module_hash, runtime.clone()),
+                ExecutableTarget::Package(pkg) => {
+                    // Check if we should update the engine based on the WebC package features
+                    if let Some(cmd) = pkg.get_entrypoint_command() {
+                        if let Some(features) = cmd.wasm_features() {
+                            // Get the right engine for these features
+                            let backends = self.rt.get_available_backends()?;
+                            let available_engines = backends
+                                .iter()
+                                .map(|b| b.to_string())
+                                .collect::<Vec<_>>()
+                                .join(", ");
+
+                            let filtered_backends = RuntimeOptions::filter_backends_by_features(
+                                backends.clone(),
+                                &features,
+                                &Target::default(),
+                            );
+
+                            if !filtered_backends.is_empty() {
+                                let engine_id = filtered_backends[0].to_string();
+
+                                // Get a new engine that's compatible with the required features
+                                if let Ok(new_engine) = filtered_backends[0].get_engine(
+                                    &Target::default(),
+                                    &features,
+                                    &self.rt,
+                                ) {
+                                    tracing::info!(
+                                        "The command '{}' requires to run the Wasm module with the features {:?}. The backends available are {}. Choosing {}.",
+                                        cmd.name(),
+                                        features,
+                                        available_engines,
+                                        engine_id
+                                    );
+                                    // Create a new runtime with the updated engine
+                                    let new_runtime = self.wasi.prepare_runtime(
+                                        new_engine,
+                                        &self.env,
+                                        &capabilities::get_capability_cache_path(
+                                            &self.env,
+                                            &self.input,
+                                        )?,
+                                        tokio::runtime::Builder::new_multi_thread()
+                                            .enable_all()
+                                            .build()?,
+                                        preferred_webc_version,
+                                    )?;
+
+                                    let new_runtime =
+                                        Arc::new(MonitoringRuntime::new(new_runtime, pb.clone()));
+                                    return self.execute_webc(&pkg, new_runtime);
+                                }
+                            }
+                        }
+                    }
+                    self.execute_webc(&pkg, runtime.clone())
+                }
             }
         };
 
@@ -197,17 +320,14 @@ impl Run {
     fn execute_wasm(
         &self,
         path: &Path,
-        module: &Module,
+        module: Module,
         module_hash: ModuleHash,
-        mut store: Store,
         runtime: Arc<dyn Runtime + Send + Sync>,
     ) -> Result<(), Error> {
-        if wasmer_emscripten::is_emscripten_module(module) {
-            self.execute_emscripten_module()
-        } else if wasmer_wasix::is_wasi_module(module) || wasmer_wasix::is_wasix_module(module) {
-            self.execute_wasi_module(path, module, module_hash, runtime, store)
+        if wasmer_wasix::is_wasi_module(&module) || wasmer_wasix::is_wasix_module(&module) {
+            self.execute_wasi_module(path, module, module_hash, runtime)
         } else {
-            self.execute_pure_wasm_module(module, &mut store)
+            self.execute_pure_wasm_module(&module)
         }
     }
 
@@ -219,7 +339,7 @@ impl Run {
     ) -> Result<(), Error> {
         let id = match self.entrypoint.as_deref() {
             Some(cmd) => cmd,
-            None => infer_webc_entrypoint(pkg)?,
+            None => pkg.infer_entrypoint()?,
         };
         let cmd = pkg
             .get_command(id)
@@ -235,8 +355,6 @@ impl Run {
             self.run_wcgi(id, pkg, uses, runtime)
         } else if WasiRunner::can_run_command(cmd.metadata())? {
             self.run_wasi(id, pkg, uses, runtime)
-        } else if EmscriptenRunner::can_run_command(cmd.metadata())? {
-            self.run_emscripten(id, pkg, runtime)
         } else {
             bail!(
                 "Unable to find a runner that supports \"{}\"",
@@ -279,7 +397,7 @@ impl Run {
         runtime: Arc<dyn Runtime + Send + Sync>,
     ) -> Result<(), Error> {
         let mut runner = self.build_wasi_runner(&runtime)?;
-        runner.run_command(command_name, pkg, runtime)
+        Runner::run_command(&mut runner, command_name, pkg, runtime)
     }
 
     fn run_wcgi(
@@ -316,19 +434,26 @@ impl Run {
             for trigger in self.wasi.snapshot_on.iter().cloned() {
                 config.add_snapshot_trigger(trigger);
             }
-            if self.wasi.snapshot_on.is_empty() && !self.wasi.journals.is_empty() {
+            if self.wasi.snapshot_on.is_empty() && !self.wasi.writable_journals.is_empty() {
                 config.add_default_snapshot_triggers();
             }
             if let Some(period) = self.wasi.snapshot_interval {
-                if self.wasi.journals.is_empty() {
+                if self.wasi.writable_journals.is_empty() {
                     return Err(anyhow::format_err!(
-                        "If you specify a snapshot interval then you must also specify a journal file"
+                        "If you specify a snapshot interval then you must also specify a writable journal file"
                     ));
                 }
                 config.with_snapshot_interval(Duration::from_millis(period));
             }
-            for journal in self.wasi.build_journals()? {
-                config.add_journal(journal);
+            if self.wasi.stop_after_snapshot {
+                config.with_stop_running_after_snapshot(true);
+            }
+            let (r, w) = self.wasi.build_journals()?;
+            for journal in r {
+                config.add_read_only_journal(journal);
+            }
+            for journal in w {
+                config.add_writable_journal(journal);
             }
         }
 
@@ -359,37 +484,28 @@ impl Run {
         runner.run_command(command_name, pkg, runtime)
     }
 
-    fn run_emscripten(
-        &self,
-        command_name: &str,
-        pkg: &BinaryPackage,
-        runtime: Arc<dyn Runtime + Send + Sync>,
-    ) -> Result<(), Error> {
-        let mut runner = wasmer_wasix::runners::emscripten::EmscriptenRunner::new();
-        runner.set_args(self.args.clone());
-
-        runner.run_command(command_name, pkg, runtime)
-    }
-
     #[tracing::instrument(skip_all)]
-    fn execute_pure_wasm_module(&self, module: &Module, store: &mut Store) -> Result<(), Error> {
+    fn execute_pure_wasm_module(&self, module: &Module) -> Result<(), Error> {
+        /// The rest of the execution happens in the main thread, so we can create the
+        /// store here.
+        let mut store = self.rt.get_store()?;
         let imports = Imports::default();
-        let instance = Instance::new(store, module, &imports)
+        let instance = Instance::new(&mut store, module, &imports)
             .context("Unable to instantiate the WebAssembly module")?;
 
-        let entrypoint  = match &self.entrypoint {
+        let entry_function  = match &self.invoke {
             Some(entry) => {
                 instance.exports
                     .get_function(entry)
-                    .with_context(|| format!("The module doesn't contain a \"{entry}\" function"))?
+                    .with_context(|| format!("The module doesn't export a function named \"{entry}\""))?
             },
             None => {
                 instance.exports.get_function("_start")
-                    .context("The module doesn't contain a \"_start\" function. Either implement it or specify an entrypoint function.")?
+                    .context("The module doesn't export a \"_start\" function. Either implement it or specify an entry function with --invoke")?
             }
         };
 
-        let return_values = invoke_function(&instance, store, entrypoint, &self.args)?;
+        let return_values = invoke_function(&instance, &mut store, entry_function, &self.args)?;
 
         println!(
             "{}",
@@ -425,25 +541,37 @@ impl Run {
             .with_forward_host_env(self.wasi.forward_host_env)
             .with_capabilities(self.wasi.capabilities());
 
+        if let Some(ref entry_function) = self.invoke {
+            runner.with_entry_function(entry_function);
+        }
+
         #[cfg(feature = "journal")]
         {
             for trigger in self.wasi.snapshot_on.iter().cloned() {
                 runner.with_snapshot_trigger(trigger);
             }
-            if self.wasi.snapshot_on.is_empty() && !self.wasi.journals.is_empty() {
+            if self.wasi.snapshot_on.is_empty() && !self.wasi.writable_journals.is_empty() {
                 runner.with_default_snapshot_triggers();
             }
             if let Some(period) = self.wasi.snapshot_interval {
-                if self.wasi.journals.is_empty() {
+                if self.wasi.writable_journals.is_empty() {
                     return Err(anyhow::format_err!(
-                        "If you specify a snapshot interval then you must also specify a journal file"
+                        "If you specify a snapshot interval then you must also specify a writable journal file"
                     ));
                 }
                 runner.with_snapshot_interval(Duration::from_millis(period));
             }
-            for journal in self.wasi.build_journals()? {
-                runner.with_journal(journal);
+            if self.wasi.stop_after_snapshot {
+                runner.with_stop_running_after_snapshot(true);
             }
+            let (r, w) = self.wasi.build_journals()?;
+            for journal in r {
+                runner.with_read_only_journal(journal);
+            }
+            for journal in w {
+                runner.with_writable_journal(journal);
+            }
+            runner.with_skip_stdio_during_bootstrap(self.wasi.skip_stdio_during_bootstrap);
         }
 
         Ok(runner)
@@ -453,28 +581,21 @@ impl Run {
     fn execute_wasi_module(
         &self,
         wasm_path: &Path,
-        module: &Module,
+        module: Module,
         module_hash: ModuleHash,
         runtime: Arc<dyn Runtime + Send + Sync>,
-        mut store: Store,
     ) -> Result<(), Error> {
         let program_name = wasm_path.display().to_string();
 
         let runner = self.build_wasi_runner(&runtime)?;
         runner.run_wasm(
-            runtime,
+            RuntimeOrEngine::Runtime(runtime),
             &program_name,
             module,
             module_hash,
-            self.wasi.enable_async_threads,
         )
     }
 
-    #[tracing::instrument(skip_all)]
-    fn execute_emscripten_module(&self) -> Result<(), Error> {
-        bail!("Emscripten packages are not currently supported")
-    }
-
     #[allow(unused_variables)]
     fn maybe_save_coredump(&self, e: &Error) {
         #[cfg(feature = "coredump")]
@@ -500,7 +621,7 @@ impl Run {
     }
 
     fn from_binfmt_args_fallible() -> Result<Self, Error> {
-        if !cfg!(linux) {
+        if cfg!(not(target_os = "linux")) {
             bail!("binfmt_misc is only available on linux.");
         }
 
@@ -511,14 +632,15 @@ impl Run {
                 bail!("Wasmer binfmt interpreter needs at least three arguments (including $0) - must be registered as binfmt interpreter with the CFP flags. (Got arguments: {:?})", argv);
             }
         };
-        let store = StoreOptions::default();
+        let rt = RuntimeOptions::default();
         Ok(Run {
             env: WasmerEnv::default(),
-            store,
+            rt,
             wasi: Wasi::for_binfmt_interpreter()?,
             wcgi: WcgiOptions::default(),
             stack_size: None,
             entrypoint: Some(original_executable.to_string()),
+            invoke: None,
             coredump_on_trap: None,
             input: PackageSource::infer(executable)?,
             args: args.to_vec(),
@@ -570,25 +692,6 @@ fn parse_value(s: &str, ty: wasmer_types::Type) -> Result<Value, Error> {
     Ok(value)
 }
 
-fn infer_webc_entrypoint(pkg: &BinaryPackage) -> Result<&str, Error> {
-    if let Some(entrypoint) = pkg.entrypoint_cmd.as_deref() {
-        return Ok(entrypoint);
-    }
-
-    match pkg.commands.as_slice() {
-        [] => bail!("The WEBC file doesn't contain any executable commands"),
-        [one] => Ok(one.name()),
-        [..] => {
-            let mut commands: Vec<_> = pkg.commands.iter().map(|cmd| cmd.name()).collect();
-            commands.sort();
-            bail!(
-                "Unable to determine the WEBC file's entrypoint. Please choose one of {:?}",
-                commands,
-            );
-        }
-    }
-}
-
 /// The input that was passed in via the command-line.
 #[derive(Debug, Clone, PartialEq)]
 enum PackageSource {
@@ -670,7 +773,7 @@ impl TargetOnDisk {
         let mut buffer = [0_u8; 512];
 
         let mut f = File::open(path)
-            .with_context(|| format!("Unable to open \"{}\" for reading", path.display(),))?;
+            .with_context(|| format!("Unable to open \"{}\" for reading", path.display()))?;
         let bytes_read = f.read(&mut buffer)?;
 
         let leading_bytes = &buffer[..bytes_read];
@@ -744,15 +847,17 @@ impl ExecutableTarget {
         match TargetOnDisk::from_file(path)? {
             TargetOnDisk::WebAssemblyBinary | TargetOnDisk::Wat => {
                 let wasm = std::fs::read(path)?;
+                let module_data = HashedModuleData::new(wasm);
+                let module_hash = *module_data.hash();
 
                 pb.set_message("Compiling to WebAssembly");
                 let module = runtime
-                    .load_module_sync(&wasm)
+                    .load_hashed_module_sync(module_data, None)
                     .with_context(|| format!("Unable to compile \"{}\"", path.display()))?;
 
                 Ok(ExecutableTarget::WebAssembly {
                     module,
-                    module_hash: ModuleHash::xxhash(&wasm),
+                    module_hash,
                     path: path.to_path_buf(),
                 })
             }
@@ -772,7 +877,7 @@ impl ExecutableTarget {
                 })
             }
             TargetOnDisk::LocalWebc => {
-                let container = Container::from_disk(path)?;
+                let container = from_disk(path)?;
                 pb.set_message("Resolving dependencies");
 
                 let inner_runtime = runtime.clone();
@@ -970,6 +1075,109 @@ impl<R: wasmer_wasix::Runtime + Send + Sync> wasmer_wasix::Runtime for Monitorin
     fn tty(&self) -> Option<&(dyn wasmer_wasix::os::TtyBridge + Send + Sync)> {
         self.runtime.tty()
     }
+
+    #[cfg(feature = "journal")]
+    fn read_only_journals<'a>(
+        &'a self,
+    ) -> Box<dyn Iterator<Item = Arc<wasmer_wasix::journal::DynReadableJournal>> + 'a> {
+        self.runtime.read_only_journals()
+    }
+
+    #[cfg(feature = "journal")]
+    fn writable_journals<'a>(
+        &'a self,
+    ) -> Box<dyn Iterator<Item = Arc<wasmer_wasix::journal::DynJournal>> + 'a> {
+        self.runtime.writable_journals()
+    }
+
+    #[cfg(feature = "journal")]
+    fn active_journal(&self) -> Option<&'_ wasmer_wasix::journal::DynJournal> {
+        self.runtime.active_journal()
+    }
+
+    fn load_hashed_module(
+        &self,
+        module: HashedModuleData,
+        engine: Option<&Engine>,
+    ) -> BoxFuture<'_, Result<Module, SpawnError>> {
+        let hash = *module.hash();
+        let fut = self.runtime.load_hashed_module(module, engine);
+        Box::pin(compile_with_progress(fut, hash, None))
+    }
+
+    fn load_hashed_module_sync(
+        &self,
+        wasm: HashedModuleData,
+        engine: Option<&Engine>,
+    ) -> Result<Module, wasmer_wasix::SpawnError> {
+        let hash = *wasm.hash();
+        compile_with_progress_sync(
+            || self.runtime.load_hashed_module_sync(wasm, engine),
+            &hash,
+            None,
+        )
+    }
+
+    fn load_command_module(
+        &self,
+        cmd: &BinaryPackageCommand,
+    ) -> BoxFuture<'_, Result<Module, SpawnError>> {
+        let fut = self.runtime.load_command_module(cmd);
+
+        Box::pin(compile_with_progress(
+            fut,
+            *cmd.hash(),
+            Some(cmd.name().to_owned()),
+        ))
+    }
+
+    fn load_command_module_sync(
+        &self,
+        cmd: &wasmer_wasix::bin_factory::BinaryPackageCommand,
+    ) -> Result<Module, wasmer_wasix::SpawnError> {
+        compile_with_progress_sync(
+            || self.runtime.load_command_module_sync(cmd),
+            cmd.hash(),
+            Some(cmd.name()),
+        )
+    }
+}
+
+async fn compile_with_progress<'a, F, T>(fut: F, hash: ModuleHash, name: Option<String>) -> T
+where
+    F: std::future::Future<Output = T> + Send + 'a,
+    T: Send + 'static,
+{
+    let mut pb = new_progressbar_compile(&hash, name.as_deref());
+    let res = fut.await;
+    pb.finish_and_clear();
+    res
+}
+
+fn compile_with_progress_sync<F, T>(f: F, hash: &ModuleHash, name: Option<&str>) -> T
+where
+    F: FnOnce() -> T,
+{
+    let mut pb = new_progressbar_compile(hash, name);
+    let res = f();
+    pb.finish_and_clear();
+    res
+}
+
+fn new_progressbar_compile(hash: &ModuleHash, name: Option<&str>) -> ProgressBar {
+    // Only show a spinner if we're running in a TTY
+    if std::io::stderr().is_terminal() {
+        let msg = if let Some(name) = name {
+            format!("Compiling WebAssembly module for command '{name}' ({hash})...")
+        } else {
+            format!("Compiling WebAssembly module {hash}...")
+        };
+        let pb = ProgressBar::new_spinner().with_message(msg);
+        pb.enable_steady_tick(Duration::from_millis(100));
+        pb
+    } else {
+        ProgressBar::hidden()
+    }
 }
 
 #[derive(Debug)]
diff --git a/lib/cli/src/commands/run/wasi.rs b/lib/cli/src/commands/run/wasi.rs
index b48ce6585a..f5a8b7604a 100644
--- a/lib/cli/src/commands/run/wasi.rs
+++ b/lib/cli/src/commands/run/wasi.rs
@@ -12,9 +12,9 @@ use clap::Parser;
 use tokio::runtime::Handle;
 use url::Url;
 use virtual_fs::{DeviceFile, FileSystem, PassthruFileSystem, RootFileSystemBuilder};
+use virtual_net::ruleset::Ruleset;
 use wasmer::{Engine, Function, Instance, Memory32, Memory64, Module, RuntimeError, Store, Value};
 use wasmer_config::package::PackageSource as PackageSpecifier;
-use wasmer_registry::wasmer_env::WasmerEnv;
 use wasmer_types::ModuleHash;
 #[cfg(feature = "journal")]
 use wasmer_wasix::journal::{LogFileJournal, SnapshotTrigger};
@@ -23,7 +23,7 @@ use wasmer_wasix::{
     capabilities::Capabilities,
     default_fs_backing, get_wasi_versions,
     http::HttpClient,
-    journal::{CompactingLogFileJournal, DynJournal},
+    journal::{CompactingLogFileJournal, DynJournal, DynReadableJournal},
     os::{tty_sys::SysTty, TtyBridge},
     rewind_ext,
     runners::MAPPED_CURRENT_DIR_DEFAULT_PATH,
@@ -45,7 +45,10 @@ use wasmer_wasix::{
     WasiVersion,
 };
 
-use crate::utils::{parse_envvar, parse_mapdir};
+use crate::{
+    config::{UserRegistry, WasmerEnv},
+    utils::{parse_envvar, parse_mapdir},
+};
 
 use super::{
     capabilities::{self, PkgCapabilityCache},
@@ -97,8 +100,25 @@ pub struct Wasi {
     /// Enable networking with the host network.
     ///
     /// Allows WASI modules to open TCP and UDP connections, create sockets, ...
-    #[clap(long = "net")]
-    pub networking: bool,
+    ///
+    /// Optionally, a set of network filters could be defined which allows fine-grained
+    /// control over the network sandbox.
+    ///
+    /// Rule Syntax:
+    ///
+    /// <rule-type>:<allow|deny>=<rule-expression>
+    ///
+    /// Examples:
+    ///
+    ///  - Allow a specific domain and port: dns:allow=example.com:80
+    ///
+    ///  - Deny a domain and all its subdomains on all ports: dns:deny=*danger.xyz:*
+    ///
+    ///  - Allow opening ipv4 sockets only on a specific IP and port: ipv4:allow=127.0.0.1:80/in.
+    #[clap(long = "net", require_equals = true)]
+    // Note that when --net is passed to the cli, the first Option will be initialized: Some(None)
+    // and when --net=<ruleset> is specified, the inner Option will be initialized: Some(Some(ruleset))
+    pub networking: Option<Option<String>>,
 
     /// Disables the TTY bridge
     #[clap(long = "no-tty")]
@@ -115,6 +135,15 @@ pub struct Wasi {
     #[clap(long = "enable-cpu-backoff")]
     pub enable_cpu_backoff: Option<u64>,
 
+    /// Specifies one or more journal files that Wasmer will use to restore
+    /// the state of the WASM process as it executes.
+    ///
+    /// The state of the WASM process and its sandbox will be reapplied using
+    /// the journals in the order that you specify here.
+    #[cfg(feature = "journal")]
+    #[clap(long = "journal")]
+    pub read_only_journals: Vec<PathBuf>,
+
     /// Specifies one or more journal files that Wasmer will use to restore
     /// and save the state of the WASM process as it executes.
     ///
@@ -125,8 +154,8 @@ pub struct Wasi {
     /// and opened for read and write. New journal events will be written to this
     /// file
     #[cfg(feature = "journal")]
-    #[clap(long = "journal")]
-    pub journals: Vec<PathBuf>,
+    #[clap(long = "journal-writable")]
+    pub writable_journals: Vec<PathBuf>,
 
     /// Flag that indicates if the journal will be automatically compacted
     /// as it fills up and when the process exits
@@ -152,7 +181,8 @@ pub struct Wasi {
     /// and written to the journal file.
     ///
     /// If not specified, the default is to snapshot when the process idles, when
-    /// the process exits or periodically if an interval argument is also supplied.
+    /// the process exits or periodically if an interval argument is also supplied,
+    /// as well as when the process requests a snapshot explicitly.
     ///
     /// Additionally if the snapshot-on is not specified it will also take a snapshot
     /// on the first stdin, environ or socket listen - this can be used to accelerate
@@ -168,6 +198,17 @@ pub struct Wasi {
     #[clap(long = "snapshot-period")]
     pub snapshot_interval: Option<u64>,
 
+    /// If specified, the runtime will stop executing the WASM module after the first snapshot
+    /// is taken.
+    #[cfg(feature = "journal")]
+    #[clap(long = "stop-after-snapshot")]
+    pub stop_after_snapshot: bool,
+
+    /// Skip writes to stdout and stderr when replying journal events to bootstrap a module.
+    #[cfg(feature = "journal")]
+    #[clap(long = "skip-journal-stdio")]
+    pub skip_stdio_during_bootstrap: bool,
+
     /// Allow instances to send http requests.
     ///
     /// Access to domains is granted by default.
@@ -177,6 +218,13 @@ pub struct Wasi {
     /// Require WASI modules to only import 1 version of WASI.
     #[clap(long = "deny-multiple-wasi-versions")]
     pub deny_multiple_wasi_versions: bool,
+
+    /// Disable the cache for the compiled modules.
+    ///
+    /// Cache is used to speed up the loading of modules, as the
+    /// generated artifacts are cached.
+    #[clap(long = "disable-cache")]
+    disable_cache: bool,
 }
 
 pub struct RunProperties {
@@ -376,18 +424,40 @@ impl Wasi {
             if let Some(interval) = self.snapshot_interval {
                 builder.with_snapshot_interval(std::time::Duration::from_millis(interval));
             }
-            for journal in self.build_journals()? {
-                builder.add_journal(journal);
+            if self.stop_after_snapshot {
+                builder.with_stop_running_after_snapshot(true);
+            }
+            let (r, w) = self.build_journals()?;
+            for journal in r {
+                builder.add_read_only_journal(journal);
+            }
+            for journal in w {
+                builder.add_writable_journal(journal);
             }
+            builder.with_skip_stdio_during_bootstrap(self.skip_stdio_during_bootstrap);
         }
 
         Ok(builder)
     }
 
     #[cfg(feature = "journal")]
-    pub fn build_journals(&self) -> anyhow::Result<Vec<Arc<DynJournal>>> {
-        let mut ret = Vec::new();
-        for journal in self.journals.clone() {
+    #[allow(clippy::type_complexity)]
+    pub fn build_journals(
+        &self,
+    ) -> anyhow::Result<(Vec<Arc<DynReadableJournal>>, Vec<Arc<DynJournal>>)> {
+        let mut readable = Vec::new();
+        for journal in self.read_only_journals.clone() {
+            if matches!(std::fs::metadata(&journal), Err(e) if e.kind() == std::io::ErrorKind::NotFound)
+            {
+                bail!("Read-only journal file does not exist: {journal:?}");
+            }
+
+            readable
+                .push(Arc::new(LogFileJournal::new_readonly(journal)?) as Arc<DynReadableJournal>);
+        }
+
+        let mut writable = Vec::new();
+        for journal in self.writable_journals.clone() {
             if self.enable_compaction {
                 let mut journal = CompactingLogFileJournal::new(journal)?;
                 if !self.without_compact_on_drop {
@@ -396,12 +466,12 @@ impl Wasi {
                 if self.with_compact_on_growth.is_normal() && self.with_compact_on_growth != 0f32 {
                     journal = journal.with_compact_on_factor_size(self.with_compact_on_growth);
                 }
-                ret.push(Arc::new(journal) as Arc<DynJournal>);
+                writable.push(Arc::new(journal) as Arc<DynJournal>);
             } else {
-                ret.push(Arc::new(LogFileJournal::new(journal)?));
+                writable.push(Arc::new(LogFileJournal::new(journal)?));
             }
         }
-        Ok(ret)
+        Ok((readable, writable))
     }
 
     #[cfg(not(feature = "journal"))]
@@ -554,25 +624,44 @@ impl Wasi {
         let tokio_task_manager = Arc::new(TokioTaskManager::new(rt_or_handle.into()));
         let mut rt = PluggableRuntime::new(tokio_task_manager.clone());
 
-        let has_networking = self.networking
+        let has_networking = self.networking.is_some()
             || capabilities::get_cached_capability(pkg_cache_path)
                 .ok()
                 .is_some_and(|v| v.enable_networking);
 
+        let ruleset = self
+            .networking
+            .clone()
+            .flatten()
+            .map(|ruleset| Ruleset::from_str(&ruleset))
+            .transpose()?;
+
+        let network = if let Some(ruleset) = ruleset {
+            virtual_net::host::LocalNetworking::with_ruleset(ruleset)
+        } else {
+            virtual_net::host::LocalNetworking::default()
+        };
+
         if has_networking {
-            rt.set_networking_implementation(virtual_net::host::LocalNetworking::default());
+            rt.set_networking_implementation(network);
         } else {
             let net = super::capabilities::net::AskingNetworking::new(
                 pkg_cache_path.to_path_buf(),
-                Arc::new(virtual_net::host::LocalNetworking::default()),
+                Arc::new(network),
             );
 
             rt.set_networking_implementation(net);
         }
 
         #[cfg(feature = "journal")]
-        for journal in self.build_journals()? {
-            rt.add_journal(journal);
+        {
+            let (r, w) = self.build_journals()?;
+            for journal in r {
+                rt.add_read_only_journal(journal);
+            }
+            for journal in w {
+                rt.add_writable_journal(journal);
+            }
         }
 
         if !self.no_tty {
@@ -591,14 +680,16 @@ impl Wasi {
 
         let registry = self.prepare_source(env, client, preferred_webc_version)?;
 
-        let cache_dir = env.cache_dir().join("compiled");
-        let module_cache = wasmer_wasix::runtime::module_cache::in_memory()
-            .with_fallback(FileSystemCache::new(cache_dir, tokio_task_manager));
+        if !self.disable_cache {
+            let cache_dir = env.cache_dir().join("compiled");
+            let module_cache = wasmer_wasix::runtime::module_cache::in_memory()
+                .with_fallback(FileSystemCache::new(cache_dir, tokio_task_manager));
+            rt.set_module_cache(module_cache);
+        }
 
         rt.set_package_loader(package_loader)
-            .set_module_cache(module_cache)
             .set_source(registry)
-            .set_engine(Some(engine));
+            .set_engine(engine);
 
         Ok(rt)
     }
@@ -635,7 +726,7 @@ impl Wasi {
         &self,
         env: &WasmerEnv,
         client: Arc<dyn HttpClient + Send + Sync>,
-    ) -> Result<impl PackageLoader + Send + Sync> {
+    ) -> Result<impl PackageLoader> {
         let checkout_dir = env.cache_dir().join("checkouts");
         let tokens = tokens_by_authority(env)?;
 
@@ -652,8 +743,8 @@ impl Wasi {
         env: &WasmerEnv,
         client: Arc<dyn HttpClient + Send + Sync>,
         preferred_webc_version: webc::Version,
-    ) -> Result<impl Source + Send + Sync> {
-        let mut source = MultiSource::new();
+    ) -> Result<impl Source + Send> {
+        let mut source = MultiSource::default();
 
         // Note: This should be first so our "preloaded" sources get a chance to
         // override the main registry.
@@ -703,8 +794,7 @@ impl Wasi {
 }
 
 fn parse_registry(r: &str) -> Result<Url> {
-    let url = wasmer_registry::format_graphql(r).parse()?;
-    Ok(url)
+    UserRegistry::from(r).graphql_endpoint()
 }
 
 fn tokens_by_authority(env: &WasmerEnv) -> Result<HashMap<String, String>> {
diff --git a/lib/cli/src/commands/ssh.rs b/lib/cli/src/commands/ssh.rs
index 046838d1fb..d128b950ba 100644
--- a/lib/cli/src/commands/ssh.rs
+++ b/lib/cli/src/commands/ssh.rs
@@ -1,36 +1,43 @@
 //! Edge SSH command.
 
 use anyhow::Context;
-use wasmer_api::WasmerClient;
+use wasmer_backend_api::{types::DeployApp, WasmerClient};
 
-use super::AsyncCliCommand;
-use crate::{config::WasmerEnv, edge_config::EdgeConfig};
+use super::{app::AppIdentArgOpts, AsyncCliCommand};
+use crate::{config::WasmerEnv, edge_config::LoadedEdgeConfig};
 
 /// Start a remote SSH session.
 #[derive(clap::Parser, Debug)]
 pub struct CmdSsh {
+    #[clap(flatten)]
+    pub app: AppIdentArgOpts,
+
     #[clap(flatten)]
     env: WasmerEnv,
+
     /// SSH port to use.
     #[clap(long, default_value = "22")]
     pub ssh_port: u16,
-    /// SSH Host
-    #[clap(long, default_value = "root.wasmer.network")]
-    pub host: String,
+
     /// Local port mapping to the package that's running, this allows
     /// for instance a HTTP server to be tested remotely while giving
     /// instant logs over stderr channelled via SSH.
     #[clap(long)]
     pub map_port: Vec<u16>,
-    /// Package to run on the Deploy servers
-    #[clap(index = 1, default_value = "sharrattj/bash")]
-    pub run: String,
-    /// Arguments to pass the package running on Deploy
-    #[clap(index = 2, trailing_var_arg = true)]
-    pub run_args: Vec<String>,
-    /// Prints the SSH command rather than executing it
+
+    /// The Edge SSH server host to connect to.
+    ///
+    /// You can usually ignore this flag, it mainly exists for debugging purposes.
+    #[clap(long)]
+    pub host: Option<String>,
+
+    /// Prints the SSH command rather than executing it.
     #[clap(short, long)]
     pub print: bool,
+
+    // All extra arguments.
+    #[clap(trailing_var_arg = true)]
+    pub extra: Vec<String>,
 }
 
 #[async_trait::async_trait]
@@ -41,19 +48,43 @@ impl AsyncCliCommand for CmdSsh {
         let mut config = crate::edge_config::load_config(None)?;
         let client = self.env.client()?;
 
-        let (token, is_new) = acquire_ssh_token(&client, &config.config).await?;
-
-        let host = self.host;
+        let token = acquire_ssh_token(&client, &config, &self.app).await?;
+        let app_id = token.app.as_ref().map(|a| a.id.inner().to_owned());
+
+        let host = if let Some(host) = self.host {
+            host
+        } else if let Some(app) = &token.app {
+            // For apps, use the app domain to ensure proper routing.
+            let url = app.url.clone();
+            if url.starts_with("http://") || url.starts_with("https://") {
+                let url = url.parse::<url::Url>().context("Could not parse app url")?;
+                url.host_str()
+                    .context("Could not determine host from app url")?
+                    .to_string()
+            } else {
+                url
+            }
+        } else {
+            // No custom host specified, use an appropriate one based on the
+            // environment.
+            self.env
+                .app_domain()
+                .context("Could not determine SSH host based on the backend url")?
+        };
         let port = self.ssh_port;
 
-        if is_new {
+        if token.is_new {
             eprintln!("Acquired new SSH token");
-            config.set_ssh_token(token.clone())?;
+            config.config.add_ssh_token(app_id, token.token.clone());
             if let Err(err) = config.save() {
-                eprintln!("Warning: failed to save config: {err}");
+                eprintln!("WARNING: failed to save config: {err}");
             }
         }
 
+        if let Some(app) = &token.app {
+            eprintln!("Connecting to app '{}' at {}", app.name, host);
+        }
+
         let mut cmd = std::process::Command::new("ssh");
         let mut cmd = cmd
             .args([
@@ -75,16 +106,12 @@ impl AsyncCliCommand for CmdSsh {
             ])
             .args(["-p", format!("{port}").as_str()]);
         for map_port in self.map_port {
-            cmd = cmd.args([
-                "-L",
-                format!("{}:localhost:{}", map_port, map_port).as_str(),
-            ]);
+            cmd = cmd.args(["-L", format!("{map_port}:localhost:{map_port}").as_str()]);
         }
 
-        cmd = cmd.arg(format!("{token}@{host}")).arg(self.run.as_str());
-        for run_arg in self.run_args {
-            cmd = cmd.arg(&run_arg);
-        }
+        cmd = cmd
+            .arg(format!("{}@{}", token.token, host))
+            .args(&self.extra);
 
         if self.print {
             print!("ssh");
@@ -104,25 +131,53 @@ impl AsyncCliCommand for CmdSsh {
     }
 }
 
-type IsNew = bool;
 type RawToken = String;
 
+struct AcquiredToken {
+    token: RawToken,
+    app: Option<DeployApp>,
+    is_new: bool,
+}
+
 async fn acquire_ssh_token(
     client: &WasmerClient,
-    config: &EdgeConfig,
-) -> Result<(RawToken, IsNew), anyhow::Error> {
-    if let Some(token) = &config.ssh_token {
-        // TODO: validate that token is still valid.
-        return Ok((token.clone(), false));
+    config: &LoadedEdgeConfig,
+    app_opts: &AppIdentArgOpts,
+) -> Result<AcquiredToken, anyhow::Error> {
+    let app_opts = app_opts.clone().to_opts();
+
+    let app = if let Some((_, app)) = app_opts.load_app_opt(client).await? {
+        Some(app)
+    } else {
+        None
+    };
+
+    // Check cached.
+    let app_id = app.as_ref().map(|a| a.id.inner());
+    if let Some(token) = config.config.get_valid_ssh_token(app_id) {
+        return Ok(AcquiredToken {
+            token: token.to_string(),
+            app,
+            is_new: false,
+        });
     }
 
-    let token = create_ssh_token(client).await?;
-    Ok((token, true))
+    // Create new.
+    let token = create_ssh_token(client, app_id.map(|x| x.to_owned())).await?;
+
+    Ok(AcquiredToken {
+        token,
+        app,
+        is_new: true,
+    })
 }
 
 /// Create a new token for SSH access through the backend API.
-async fn create_ssh_token(client: &WasmerClient) -> Result<RawToken, anyhow::Error> {
-    wasmer_api::query::generate_deploy_config_token_raw(client, wasmer_api::query::TokenKind::SSH)
+async fn create_ssh_token(
+    client: &WasmerClient,
+    app: Option<String>,
+) -> Result<RawToken, anyhow::Error> {
+    wasmer_backend_api::query::generate_ssh_token(client, app)
         .await
         .context("Could not create token for ssh access")
 }
diff --git a/lib/cli/src/commands/validate.rs b/lib/cli/src/commands/validate.rs
index 8806ca49f1..450ae50bd4 100644
--- a/lib/cli/src/commands/validate.rs
+++ b/lib/cli/src/commands/validate.rs
@@ -2,10 +2,10 @@ use std::path::PathBuf;
 
 use anyhow::{bail, Context, Result};
 use clap::Parser;
-use wasmer::*;
-
-use crate::store::StoreOptions;
+use wasmer::{is_wasm, Module};
+use wasmer_types::target::Target;
 
+use crate::backend::RuntimeOptions;
 #[derive(Debug, Parser)]
 /// The options for the `wasmer validate` subcommand
 pub struct Validate {
@@ -14,7 +14,7 @@ pub struct Validate {
     path: PathBuf,
 
     #[clap(flatten)]
-    store: StoreOptions,
+    rt: RuntimeOptions,
 }
 
 impl Validate {
@@ -24,13 +24,15 @@ impl Validate {
             .context(format!("failed to validate `{}`", self.path.display()))
     }
     fn inner_execute(&self) -> Result<()> {
-        let (store, _compiler_type) = self.store.get_store()?;
-
         let module_contents = std::fs::read(&self.path)?;
         if !is_wasm(&module_contents) {
             bail!("`wasmer validate` only validates WebAssembly files");
         }
-        Module::validate(&store, &module_contents)?;
+
+        let engine = self
+            .rt
+            .get_engine_for_module(&module_contents, &Target::default())?;
+        Module::validate(&engine, &module_contents)?;
         eprintln!("Validation passed for `{}`.", self.path.display());
         Ok(())
     }
diff --git a/lib/cli/src/commands/wasmer_create_exe_main.c b/lib/cli/src/commands/wasmer_create_exe_main.c
index 2840dbc3f6..c4c60fcea6 100644
--- a/lib/cli/src/commands/wasmer_create_exe_main.c
+++ b/lib/cli/src/commands/wasmer_create_exe_main.c
@@ -14,7 +14,7 @@
 
 static void print_wasmer_error() {
   int error_len = wasmer_last_error_length();
-  printf("Error len: `%d`\n", error_len);
+  //printf("Error len: `%d`\n", error_len);
   char *error_str = (char *)malloc(error_len);
   wasmer_last_error_message(error_str, error_len);
   printf("%s\n", error_str);
diff --git a/lib/cli/src/commands/wast.rs b/lib/cli/src/commands/wast.rs
index a2ce63b789..52c97cab3c 100644
--- a/lib/cli/src/commands/wast.rs
+++ b/lib/cli/src/commands/wast.rs
@@ -3,10 +3,13 @@ use std::path::PathBuf;
 
 use anyhow::{Context, Result};
 use clap::Parser;
-use wasmer::NativeEngineExt;
+use wasmer::{
+    sys::{engine::NativeEngineExt, Target},
+    Store,
+};
 use wasmer_wast::Wast as WastSpectest;
 
-use crate::{common::HashAlgorithm, store::StoreOptions};
+use crate::{backend::RuntimeOptions, common::HashAlgorithm};
 
 #[derive(Debug, Parser)]
 /// The options for the `wasmer wast` subcommand
@@ -16,7 +19,7 @@ pub struct Wast {
     path: PathBuf,
 
     #[clap(flatten)]
-    store: StoreOptions,
+    rt: RuntimeOptions,
 
     #[clap(short, long)]
     /// A flag to indicate wast stop at the first error or continue.
@@ -34,12 +37,12 @@ impl Wast {
             .context(format!("failed to test the wast `{}`", self.path.display()))
     }
     fn inner_execute(&self) -> Result<()> {
-        let (store, _compiler_name) = self.store.get_store()?;
+        let mut engine = self.rt.get_engine(&Target::default())?;
 
-        let mut engine = store.engine().clone();
         let hash_algorithm = self.hash_algorithm.unwrap_or_default().into();
         engine.set_hash_algorithm(Some(hash_algorithm));
 
+        let store: Store = Store::new(engine);
         let mut wast = WastSpectest::new_with_spectest(store);
         wast.fail_fast = self.fail_fast;
         wast.run_file(&self.path).with_context(|| "tests failed")?;
diff --git a/lib/cli/src/common.rs b/lib/cli/src/common.rs
index 99fc28b4b6..f65d4eaeca 100644
--- a/lib/cli/src/common.rs
+++ b/lib/cli/src/common.rs
@@ -37,7 +37,7 @@ pub struct WasmFeatures {
 }
 
 pub(crate) fn normalize_path(s: &str) -> String {
-    wasmer_registry::utils::normalize_path(s)
+    s.strip_prefix(r"\\?\").unwrap_or(s).to_string()
 }
 
 /// Hashing algorithm to be used for the module info
diff --git a/lib/cli/src/config/env.rs b/lib/cli/src/config/env.rs
index 496962c14f..6a4fe4c6be 100644
--- a/lib/cli/src/config/env.rs
+++ b/lib/cli/src/config/env.rs
@@ -1,14 +1,12 @@
 use super::WasmerConfig;
 use anyhow::{Context, Error};
-use lazy_static::lazy_static;
 use std::path::{Path, PathBuf};
+use std::sync::LazyLock;
 use url::Url;
-use wasmer_api::WasmerClient;
+use wasmer_backend_api::WasmerClient;
 
-lazy_static! {
-    pub static ref DEFAULT_WASMER_CLI_USER_AGENT: String =
-        format!("WasmerCLI-v{}", env!("CARGO_PKG_VERSION"));
-}
+pub static DEFAULT_WASMER_CLI_USER_AGENT: LazyLock<String> =
+    LazyLock::new(|| format!("WasmerCLI-v{}", env!("CARGO_PKG_VERSION")));
 
 /// Command-line flags for determining the local "Wasmer Environment".
 ///
@@ -36,6 +34,9 @@ pub struct WasmerEnv {
 }
 
 impl WasmerEnv {
+    const APP_DOMAIN_PROD: &'static str = "wasmer.app";
+    const APP_DOMAIN_DEV: &'static str = "wasmer.dev";
+
     pub fn new(
         wasmer_dir: PathBuf,
         cache_dir: PathBuf,
@@ -91,6 +92,17 @@ impl WasmerEnv {
             })
     }
 
+    /// Returns the proxy specified in wasmer config if present
+    pub fn proxy(&self) -> Result<Option<reqwest::Proxy>, Error> {
+        self.config()?
+            .proxy
+            .url
+            .as_ref()
+            .map(reqwest::Proxy::all)
+            .transpose()
+            .map_err(Into::into)
+    }
+
     /// The directory all Wasmer artifacts are stored in.
     pub fn dir(&self) -> &Path {
         &self.wasmer_dir
@@ -125,25 +137,31 @@ impl WasmerEnv {
             .get_login_token_for_registry(registry_endpoint.as_str())
     }
 
-    pub fn client_unauthennticated(&self) -> Result<WasmerClient, anyhow::Error> {
-        let registry_url = self.registry_endpoint()?;
-        let client = wasmer_api::WasmerClient::new(registry_url, &DEFAULT_WASMER_CLI_USER_AGENT)?;
-
-        let client = if let Some(token) = self.token() {
-            client.with_auth_token(token)
+    pub fn app_domain(&self) -> Result<String, Error> {
+        let registry_url = self.registry_public_url()?;
+        let domain = registry_url
+            .host_str()
+            .context("url has no host")?
+            .trim_end_matches('.');
+
+        if domain.ends_with("wasmer.io") {
+            Ok(Self::APP_DOMAIN_PROD.to_string())
+        } else if domain.ends_with("wasmer.wtf") {
+            Ok(Self::APP_DOMAIN_DEV.to_string())
         } else {
-            client
-        };
-
-        Ok(client)
+            anyhow::bail!(
+                "could not determine app domain for backend url '{}': unknown backend",
+                domain
+            );
+        }
     }
 
-    pub fn client_unauthennticated_with_proxy(
-        &self,
-        proxy: reqwest::Proxy,
-    ) -> Result<WasmerClient, anyhow::Error> {
+    pub fn client_unauthennticated(&self) -> Result<WasmerClient, anyhow::Error> {
         let registry_url = self.registry_endpoint()?;
-        let client = wasmer_api::WasmerClient::new_with_proxy(
+
+        let proxy = self.proxy()?;
+
+        let client = wasmer_backend_api::WasmerClient::new_with_proxy(
             registry_url,
             &DEFAULT_WASMER_CLI_USER_AGENT,
             proxy,
@@ -254,6 +272,33 @@ mod tests {
         assert_eq!(env.cache_dir(), temp.path().join("cache"));
     }
 
+    #[test]
+    fn env_app_domain() {
+        // Prod
+        {
+            let env = WasmerEnv {
+                wasmer_dir: PathBuf::from("/tmp"),
+                registry: Some(UserRegistry::from("https://registry.wasmer.io/graphql")),
+                cache_dir: PathBuf::from("/tmp/cache"),
+                token: None,
+            };
+
+            assert_eq!(env.app_domain().unwrap(), "wasmer.app");
+        }
+
+        // Dev
+        {
+            let env = WasmerEnv {
+                wasmer_dir: PathBuf::from("/tmp"),
+                registry: Some(UserRegistry::from("https://registry.wasmer.wtf/graphql")),
+                cache_dir: PathBuf::from("/tmp/cache"),
+                token: None,
+            };
+
+            assert_eq!(env.app_domain().unwrap(), "wasmer.dev");
+        }
+    }
+
     #[test]
     fn override_token() {
         let temp = TempDir::new().unwrap();
diff --git a/lib/cli/src/config/mod.rs b/lib/cli/src/config/mod.rs
index 23c95f21f3..0a9822e183 100644
--- a/lib/cli/src/config/mod.rs
+++ b/lib/cli/src/config/mod.rs
@@ -3,15 +3,16 @@ pub use env::*;
 
 use serde::{Deserialize, Serialize};
 use std::path::{Path, PathBuf};
+use std::sync::LazyLock;
 use url::Url;
-use wasmer_api::WasmerClient;
+use wasmer_backend_api::WasmerClient;
 
 pub static GLOBAL_CONFIG_FILE_NAME: &str = "wasmer.toml";
 pub static DEFAULT_PROD_REGISTRY: &str = "https://registry.wasmer.io/graphql";
 
-lazy_static::lazy_static! {
-    /// The default value for `$WASMER_DIR`.
-    pub static ref DEFAULT_WASMER_DIR: PathBuf = match WasmerConfig::get_wasmer_dir() {
+/// The default value for `$WASMER_DIR`.
+pub static DEFAULT_WASMER_DIR: LazyLock<PathBuf> =
+    LazyLock::new(|| match WasmerConfig::get_wasmer_dir() {
         Ok(path) => path,
         Err(e) => {
             if let Some(install_prefix) = option_env!("WASMER_INSTALL_PREFIX") {
@@ -20,13 +21,13 @@ lazy_static::lazy_static! {
 
             panic!("Unable to determine the wasmer dir: {e}");
         }
-    };
+    });
 
-    /// The default value for `$WASMER_DIR`.
-    pub static ref DEFAULT_WASMER_CACHE_DIR: PathBuf = DEFAULT_WASMER_DIR.join("cache");
-}
+/// The default value for `$WASMER_DIR`.
+pub static DEFAULT_WASMER_CACHE_DIR: LazyLock<PathBuf> =
+    LazyLock::new(|| DEFAULT_WASMER_DIR.join("cache"));
 
-#[derive(Deserialize, Default, Serialize, Debug, PartialEq, Eq)]
+#[derive(Deserialize, Serialize, Debug, PartialEq, Eq)]
 pub struct WasmerConfig {
     /// Whether or not telemetry is enabled.
     #[serde(default)]
@@ -44,6 +45,17 @@ pub struct WasmerConfig {
     pub proxy: Proxy,
 }
 
+impl Default for WasmerConfig {
+    fn default() -> Self {
+        Self {
+            telemetry_enabled: true,
+            update_notifications_enabled: true,
+            registry: Default::default(),
+            proxy: Default::default(),
+        }
+    }
+}
+
 #[derive(Deserialize, Serialize, Debug, PartialEq, Eq, Default)]
 pub struct Proxy {
     pub url: Option<String>,
@@ -112,7 +124,9 @@ fn endpoint_from_domain_name(domain_name: &str) -> String {
 async fn test_if_registry_present(registry: &str) -> anyhow::Result<()> {
     let client = WasmerClient::new(url::Url::parse(registry)?, &DEFAULT_WASMER_CLI_USER_AGENT)?;
 
-    wasmer_api::query::current_user(&client).await.map(|_| ())
+    wasmer_backend_api::query::current_user(&client)
+        .await
+        .map(|_| ())
 }
 
 #[derive(PartialEq, Eq, Copy, Clone)]
diff --git a/lib/cli/src/edge_config.rs b/lib/cli/src/edge_config.rs
index b9176e3f12..7d5aa5f903 100644
--- a/lib/cli/src/edge_config.rs
+++ b/lib/cli/src/edge_config.rs
@@ -1,13 +1,23 @@
-use std::path::{Path, PathBuf};
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+    time::Duration,
+};
 
 use anyhow::{bail, Context};
 use serde::{Deserialize, Serialize};
+use time::OffsetDateTime;
 
 #[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
 pub struct EdgeConfig {
     pub version: u32,
     /// Token used for ssh access.
     pub ssh_token: Option<String>,
+
+    /// Map from unique app ID (da_...) to SSH token.
+    #[serde(default)]
+    pub ssh_app_tokens: HashMap<String, String>,
+
     /// Token used for network access.
     pub network_token: Option<String>,
 }
@@ -34,12 +44,44 @@ impl EdgeConfig {
         let config = toml::from_str(data_str)?;
         Ok(config)
     }
+
+    /// Get a valid SSH token.
+    ///
+    /// Will filter out the stored token if it has expired.
+    pub fn get_valid_ssh_token(&self, app_id: Option<&str>) -> Option<&str> {
+        #[allow(clippy::manual_filter)]
+        if let Some(app_id) = app_id {
+            let token = self.ssh_app_tokens.get(app_id)?;
+            if jwt_token_valid(token) {
+                Some(token)
+            } else {
+                None
+            }
+        } else if let Some(token) = &self.ssh_token {
+            if jwt_token_valid(token) {
+                Some(token)
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    }
+
+    pub fn add_ssh_token(&mut self, app_id: Option<String>, token: String) {
+        if let Some(app_id) = app_id {
+            self.ssh_app_tokens.insert(app_id, token);
+        } else {
+            self.ssh_token = Some(token);
+        }
+    }
 }
 
 impl Default for EdgeConfig {
     fn default() -> Self {
         Self {
             ssh_token: None,
+            ssh_app_tokens: HashMap::new(),
             network_token: None,
             version: 1,
         }
@@ -55,12 +97,6 @@ pub struct LoadedEdgeConfig {
 }
 
 impl LoadedEdgeConfig {
-    pub fn set_ssh_token(&mut self, token: String) -> Result<(), anyhow::Error> {
-        self.config.ssh_token = Some(token);
-        self.save()?;
-        Ok(())
-    }
-
     #[allow(dead_code)]
     pub fn set_network_token(&mut self, token: String) -> Result<(), anyhow::Error> {
         self.config.network_token = Some(token);
@@ -131,3 +167,50 @@ fn try_load_config(path: &Path) -> Result<EdgeConfig, anyhow::Error> {
         .with_context(|| format!("failed to parse config file at '{}'", path.display()))?;
     Ok(config)
 }
+
+fn jwt_token_valid(jwt_token: &str) -> bool {
+    if let Ok(expiration) = jwt_token_expiration_time(jwt_token) {
+        expiration > (OffsetDateTime::now_utc() + Duration::from_secs(30))
+    } else {
+        false
+    }
+}
+
+fn jwt_token_expiration_time(jwt_token: &str) -> Result<OffsetDateTime, anyhow::Error> {
+    use base64::Engine;
+
+    // JWT tokens have three parts separated by dots: Header.Payload.Signature
+    let parts: Vec<&str> = jwt_token.split('.').collect();
+
+    if parts.len() != 3 {
+        bail!("Invalid JWT token format: expected 3 parts.");
+    }
+
+    let payload_base64 = parts[1];
+
+    // Decode the Base64 URL-encoded payload
+    let decoded_payload_bytes = base64::prelude::BASE64_URL_SAFE_NO_PAD
+        .decode(payload_base64)
+        .with_context(|| "Failed to base64 decode payload")?;
+
+    let decoded_payload_str = String::from_utf8(decoded_payload_bytes)
+        .with_context(|| "Failed to convert decoded bytes to UTF-8")?;
+
+    // Parse the JSON payload
+    let payload_json: serde_json::Value = serde_json::from_str(&decoded_payload_str)
+        .with_context(|| "Failed to parse JSON payload")?;
+
+    // Extract the 'exp' (expiration time) claim
+    // It should be a Unix timestamp (seconds since epoch)
+    let exp_timestamp = payload_json
+        .get("exp")
+        .context("no 'exp' field in token payload")?
+        .as_i64()
+        .context("exp field is not an integer")?;
+
+    // Convert the Unix timestamp to an OffsetDateTime
+    let expiration_time = OffsetDateTime::from_unix_timestamp(exp_timestamp)
+        .context("Failed to convert Unix timestamp to OffsetDateTime")?;
+
+    Ok(expiration_time)
+}
diff --git a/lib/cli/src/error.rs b/lib/cli/src/error.rs
index 57bc0f3ee5..810f31e38d 100644
--- a/lib/cli/src/error.rs
+++ b/lib/cli/src/error.rs
@@ -1,9 +1,9 @@
 //! Implements `PretyError` to print pretty errors in the CLI (when they happen)
 
-use std::fmt::{self, Debug, Write};
-
 use anyhow::{Chain, Error};
 use colored::*;
+use std::fmt::{self, Debug, Write};
+#[cfg(not(any(feature = "jsc", feature = "wamr", feature = "wasmi", feature = "v8")))]
 use wasmer::RuntimeError;
 
 /// A `PrettyError` for printing `anyhow::Error` nicely.
@@ -27,7 +27,7 @@ macro_rules! warning {
     })
 }
 
-#[cfg(not(feature = "jsc"))]
+#[cfg(not(any(feature = "jsc", feature = "wamr", feature = "wasmi", feature = "v8")))]
 impl PrettyError {
     /// Process a `Result` printing any errors and exiting
     /// the process after
@@ -53,7 +53,7 @@ impl PrettyError {
     }
 }
 
-#[cfg(feature = "jsc")]
+#[cfg(any(feature = "jsc", feature = "wamr", feature = "wasmi", feature = "v8"))]
 impl PrettyError {
     /// Process a `Result` printing any errors and exiting
     /// the process after
@@ -94,7 +94,7 @@ impl Debug for PrettyError {
                     is_last: n == total_errors - 1,
                     started: false,
                 };
-                write!(indented, "{}", error)?;
+                write!(indented, "{error}")?;
             }
         }
         Ok(())
@@ -123,14 +123,14 @@ where
                                 self.inner,
                                 "{} {: >4} ",
                                 "│".bold().blue(),
-                                format!("{}:", number).dimmed()
+                                format!("{number}:").dimmed()
                             )?
                         } else {
                             write!(
                                 self.inner,
                                 "{}{: >2}: ",
                                 "╰─▶".bold().blue(),
-                                format!("{}", number).bold().blue()
+                                format!("{number}").bold().blue()
                             )?
                         }
                     }
diff --git a/lib/cli/src/lib.rs b/lib/cli/src/lib.rs
index 3769d75e11..1b2961e6c0 100644
--- a/lib/cli/src/lib.rs
+++ b/lib/cli/src/lib.rs
@@ -15,19 +15,19 @@
 #![allow(clippy::bool_comparison, clippy::match_like_matches_macro)]
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
 
-#[cfg(all(target_os = "linux", feature = "tun-tap"))]
-mod net;
+//#[cfg(all(target_os = "linux", feature = "tun-tap"))]
+//mod net;
 
 mod commands;
 mod common;
 mod config;
 #[macro_use]
 mod error;
+mod backend;
+#[cfg(feature = "static-artifact-create")]
 mod c_gen;
 mod logging;
 mod opts;
-mod package_source;
-mod store;
 mod types;
 mod utils;
 
diff --git a/lib/cli/src/logging.rs b/lib/cli/src/logging.rs
index 64fb9c744e..1f4c7a0097 100644
--- a/lib/cli/src/logging.rs
+++ b/lib/cli/src/logging.rs
@@ -18,6 +18,9 @@ pub struct Output {
     /// The format to use when generating logs.
     #[clap(long, global = true, env, default_value = "text")]
     pub log_format: LogFormat,
+    /// Which span events to log.
+    #[clap(long, global = true, env, default_value = "close")]
+    pub log_events: LogEvents,
     /// When to display colored output.
     #[clap(long, default_value_t = clap::ColorChoice::Auto, global = true)]
     pub color: clap::ColorChoice,
@@ -34,11 +37,18 @@ impl Output {
     pub fn initialize_logging(&self) {
         let fmt_layer = fmt::layer()
             .with_target(true)
-            .with_span_events(fmt::format::FmtSpan::CLOSE)
             .with_ansi(self.should_emit_colors())
             .with_thread_ids(true)
             .with_writer(std::io::stderr);
 
+        let fmt_layer = match self.log_events {
+            LogEvents::New => fmt_layer.with_span_events(fmt::format::FmtSpan::NEW),
+            LogEvents::Close => fmt_layer.with_span_events(fmt::format::FmtSpan::CLOSE),
+            LogEvents::All => {
+                fmt_layer.with_span_events(fmt::format::FmtSpan::NEW | fmt::format::FmtSpan::CLOSE)
+            }
+        };
+
         let filter_layer = self.log_filter();
 
         match self.log_format {
@@ -125,3 +135,15 @@ pub enum LogFormat {
     /// Machine-readable logs.
     Json,
 }
+
+/// Which span events to log.
+#[derive(Debug, Default, Copy, Clone, PartialEq, clap::ValueEnum)]
+pub enum LogEvents {
+    // Only log at the start of a new span.
+    New,
+    // Only log at the end of a span.
+    #[default]
+    Close,
+    // Log at the start and end of a span.
+    All,
+}
diff --git a/lib/cli/src/opts.rs b/lib/cli/src/opts.rs
index cc9844a219..8b0a983c08 100644
--- a/lib/cli/src/opts.rs
+++ b/lib/cli/src/opts.rs
@@ -1,9 +1,30 @@
+use crate::utils::render::ItemFormat;
+
 /// Formatting options for a single item.
 #[derive(clap::Parser, Debug, Default)]
 pub struct ItemFormatOpts {
     /// Output format. (yaml, json, table)
-    #[clap(short = 'f', long, default_value = "yaml")]
-    pub format: crate::utils::render::ItemFormat,
+    ///
+    /// This value is optional instead of using a default value to allow code
+    /// to distinguish between the user not specifying a value and a generic
+    /// default.
+    ///
+    /// Code should usually use [`Self::get`] to use the same default format.
+    #[clap(short = 'f', long)]
+    pub format: Option<ItemFormat>,
+}
+
+impl ItemFormatOpts {
+    /// Get the output format, defaulting to `ItemFormat::Yaml`.
+    pub fn get(&self) -> crate::utils::render::ItemFormat {
+        self.format
+            .unwrap_or(crate::utils::render::ItemFormat::Table)
+    }
+
+    /// Get the output format, defaulting to the given value if not specified.
+    pub fn get_with_default(&self, default: ItemFormat) -> crate::utils::render::ItemFormat {
+        self.format.unwrap_or(default)
+    }
 }
 
 /// Formatting options for a single item.
diff --git a/lib/cli/src/package_source.rs b/lib/cli/src/package_source.rs
index 4c54b1ab7e..e69de29bb2 100644
--- a/lib/cli/src/package_source.rs
+++ b/lib/cli/src/package_source.rs
@@ -1,121 +0,0 @@
-//! Module for parsing and installing packages
-
-use std::str::FromStr;
-
-use url::Url;
-
-/// Source of a package
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub enum PackageSource {
-    /// Download from a URL
-    Url(Url),
-    /// Run a local file
-    File(String),
-    /// Download from a package
-    Package(wasmer_registry::Package),
-}
-
-impl Default for PackageSource {
-    fn default() -> Self {
-        PackageSource::File(String::new())
-    }
-}
-
-impl FromStr for PackageSource {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Self::parse(s)
-    }
-}
-
-impl PackageSource {
-    /// Parses a package source and transforms it to a URL or a File
-    pub fn parse(s: &str) -> Result<Self, String> {
-        // If the file is a http:// URL, run the URL
-        if let Ok(url) = url::Url::parse(s) {
-            if url.scheme() == "http" || url.scheme() == "https" {
-                return Ok(Self::Url(url));
-            }
-        }
-
-        Ok(match wasmer_registry::Package::from_str(s) {
-            Ok(o) => Self::Package(o),
-            Err(_) => Self::File(s.to_string()),
-        })
-    }
-}
-
-#[test]
-fn test_package_source() {
-    assert_eq!(
-        PackageSource::parse("registry.wasmer.io/graphql/python/python").unwrap(),
-        PackageSource::File("registry.wasmer.io/graphql/python/python".to_string()),
-    );
-
-    assert_eq!(
-        PackageSource::parse("/absolute/path/test.wasm").unwrap(),
-        PackageSource::File("/absolute/path/test.wasm".to_string()),
-    );
-
-    assert_eq!(
-        PackageSource::parse("C://absolute/path/test.wasm").unwrap(),
-        PackageSource::File("C://absolute/path/test.wasm".to_string()),
-    );
-
-    assert_eq!(
-        PackageSource::parse("namespace/name@latest").unwrap(),
-        PackageSource::Package(wasmer_registry::Package {
-            namespace: "namespace".to_string(),
-            name: "name".to_string(),
-            version: Some("latest".to_string()),
-        })
-    );
-
-    assert_eq!(
-        PackageSource::parse("namespace/name@latest:command").unwrap(),
-        PackageSource::File("namespace/name@latest:command".to_string()),
-    );
-
-    assert_eq!(
-        PackageSource::parse("namespace/name@1.0.2").unwrap(),
-        PackageSource::Package(wasmer_registry::Package {
-            namespace: "namespace".to_string(),
-            name: "name".to_string(),
-            version: Some("1.0.2".to_string()),
-        })
-    );
-
-    assert_eq!(
-        PackageSource::parse("namespace/name@1.0.2-rc.2").unwrap(),
-        PackageSource::Package(wasmer_registry::Package {
-            namespace: "namespace".to_string(),
-            name: "name".to_string(),
-            version: Some("1.0.2-rc.2".to_string()),
-        })
-    );
-
-    assert_eq!(
-        PackageSource::parse("namespace/name").unwrap(),
-        PackageSource::Package(wasmer_registry::Package {
-            namespace: "namespace".to_string(),
-            name: "name".to_string(),
-            version: None,
-        })
-    );
-
-    assert_eq!(
-        PackageSource::parse("https://wasmer.io/syrusakbary/python").unwrap(),
-        PackageSource::Url(url::Url::parse("https://wasmer.io/syrusakbary/python").unwrap()),
-    );
-
-    assert_eq!(
-        PackageSource::parse("command").unwrap(),
-        PackageSource::File("command".to_string()),
-    );
-
-    assert_eq!(
-        PackageSource::parse("python@latest").unwrap(),
-        PackageSource::File("python@latest".to_string()),
-    );
-}
diff --git a/lib/cli/src/store.rs b/lib/cli/src/store.rs
deleted file mode 100644
index d7587901f2..0000000000
--- a/lib/cli/src/store.rs
+++ /dev/null
@@ -1,404 +0,0 @@
-//! Common module with common used structures across different
-//! commands.
-
-// NOTE: A lot of this code depends on feature flags.
-// To not go crazy with annotations, some lints are disablefor the whole
-// module.
-#![allow(dead_code, unused_imports, unused_variables)]
-
-use std::path::PathBuf;
-use std::string::ToString;
-use std::sync::Arc;
-
-use anyhow::{bail, Result};
-#[cfg(feature = "sys")]
-use wasmer::sys::Features;
-use wasmer::*;
-#[cfg(feature = "compiler")]
-use wasmer_compiler::CompilerConfig;
-#[cfg(feature = "compiler")]
-use wasmer_compiler::Engine;
-
-#[derive(Debug, Clone, clap::Parser, Default)]
-/// The compiler options
-pub struct StoreOptions {
-    #[cfg(feature = "compiler")]
-    #[clap(flatten)]
-    compiler: CompilerOptions,
-}
-
-#[derive(Debug, clap::Parser, Clone, Default)]
-/// The WebAssembly features that can be passed through the
-/// Command Line args.
-pub struct WasmFeatures {
-    /// Enable support for the SIMD proposal.
-    #[clap(long = "enable-simd")]
-    pub simd: bool,
-
-    /// Disable support for the threads proposal.
-    #[clap(long = "disable-threads")]
-    pub disable_threads: bool,
-
-    /// Deprecated, threads are enabled by default.
-    #[clap(long = "enable-threads")]
-    pub _threads: bool,
-
-    /// Enable support for the reference types proposal.
-    #[clap(long = "enable-reference-types")]
-    pub reference_types: bool,
-
-    /// Enable support for the multi value proposal.
-    #[clap(long = "enable-multi-value")]
-    pub multi_value: bool,
-
-    /// Enable support for the bulk memory proposal.
-    #[clap(long = "enable-bulk-memory")]
-    pub bulk_memory: bool,
-
-    /// Enable support for all pre-standard proposals.
-    #[clap(long = "enable-all")]
-    pub all: bool,
-}
-
-#[cfg(feature = "compiler")]
-#[derive(Debug, Clone, clap::Parser, Default)]
-/// The compiler options
-pub struct CompilerOptions {
-    /// Use Singlepass compiler.
-    #[clap(long, conflicts_with_all = &["cranelift", "llvm"])]
-    singlepass: bool,
-
-    /// Use Cranelift compiler.
-    #[clap(long, conflicts_with_all = &["singlepass", "llvm"])]
-    cranelift: bool,
-
-    /// Use LLVM compiler.
-    #[clap(long, conflicts_with_all = &["singlepass", "cranelift"])]
-    llvm: bool,
-
-    /// Enable compiler internal verification.
-    ///
-    /// Available for cranelift, LLVM and singlepass.
-    #[clap(long)]
-    enable_verifier: bool,
-
-    /// LLVM debug directory, where IR and object files will be written to.
-    ///
-    /// Only available for the LLVM compiler.
-    #[clap(long)]
-    llvm_debug_dir: Option<PathBuf>,
-
-    #[clap(flatten)]
-    features: WasmFeatures,
-}
-
-#[cfg(feature = "compiler")]
-impl CompilerOptions {
-    fn get_compiler(&self) -> Result<CompilerType> {
-        if self.cranelift {
-            Ok(CompilerType::Cranelift)
-        } else if self.llvm {
-            Ok(CompilerType::LLVM)
-        } else if self.singlepass {
-            Ok(CompilerType::Singlepass)
-        } else {
-            // Auto mode, we choose the best compiler for that platform
-            cfg_if::cfg_if! {
-                if #[cfg(all(feature = "cranelift", any(target_arch = "x86_64", target_arch = "aarch64")))] {
-                    Ok(CompilerType::Cranelift)
-                }
-                else if #[cfg(all(feature = "singlepass", any(target_arch = "x86_64", target_arch = "aarch64")))] {
-                    Ok(CompilerType::Singlepass)
-                }
-                else if #[cfg(feature = "llvm")] {
-                    Ok(CompilerType::LLVM)
-                } else {
-                    bail!("There are no available compilers for your architecture");
-                }
-            }
-        }
-    }
-
-    /// Get the enaled Wasm features.
-    pub fn get_features(&self, mut features: Features) -> Result<Features> {
-        if !self.features.disable_threads || self.features.all {
-            features.threads(true);
-        }
-        if self.features.disable_threads && !self.features.all {
-            features.threads(false);
-        }
-        if self.features.multi_value || self.features.all {
-            features.multi_value(true);
-        }
-        if self.features.simd || self.features.all {
-            features.simd(true);
-        }
-        if self.features.bulk_memory || self.features.all {
-            features.bulk_memory(true);
-        }
-        if self.features.reference_types || self.features.all {
-            features.reference_types(true);
-        }
-        Ok(features)
-    }
-
-    /// Gets the Store for a given target.
-    pub fn get_store_for_target(&self, target: Target) -> Result<(Store, CompilerType)> {
-        let (compiler_config, compiler_type) = self.get_compiler_config()?;
-        let engine = self.get_engine(target, compiler_config)?;
-        let store = Store::new(engine);
-        Ok((store, compiler_type))
-    }
-
-    /// Gets the Engine for a given target.
-    pub fn get_engine_for_target(&self, target: Target) -> Result<(Engine, CompilerType)> {
-        let (compiler_config, compiler_type) = self.get_compiler_config()?;
-        let engine = self.get_engine(target, compiler_config)?;
-        Ok((engine, compiler_type))
-    }
-
-    #[cfg(feature = "compiler")]
-    fn get_engine(
-        &self,
-        target: Target,
-        compiler_config: Box<dyn CompilerConfig>,
-    ) -> Result<Engine> {
-        let features = self.get_features(compiler_config.default_features_for_target(&target))?;
-        let engine: Engine = wasmer_compiler::EngineBuilder::new(compiler_config)
-            .set_features(Some(features))
-            .set_target(Some(target))
-            .engine();
-
-        Ok(engine)
-    }
-
-    /// Get the Compiler Config for the current options
-    #[allow(unused_variables)]
-    pub(crate) fn get_compiler_config(&self) -> Result<(Box<dyn CompilerConfig>, CompilerType)> {
-        let compiler = self.get_compiler()?;
-        let compiler_config: Box<dyn CompilerConfig> = match compiler {
-            CompilerType::Headless => bail!("The headless engine can't be chosen"),
-            #[cfg(feature = "singlepass")]
-            CompilerType::Singlepass => {
-                let mut config = wasmer_compiler_singlepass::Singlepass::new();
-                if self.enable_verifier {
-                    config.enable_verifier();
-                }
-                Box::new(config)
-            }
-            #[cfg(feature = "cranelift")]
-            CompilerType::Cranelift => {
-                let mut config = wasmer_compiler_cranelift::Cranelift::new();
-                if self.enable_verifier {
-                    config.enable_verifier();
-                }
-                Box::new(config)
-            }
-            #[cfg(feature = "llvm")]
-            CompilerType::LLVM => {
-                use std::{fmt, fs::File, io::Write};
-
-                use wasmer_compiler_llvm::{
-                    CompiledKind, InkwellMemoryBuffer, InkwellModule, LLVMCallbacks, LLVM,
-                };
-                use wasmer_types::entity::EntityRef;
-                let mut config = LLVM::new();
-                struct Callbacks {
-                    debug_dir: PathBuf,
-                }
-                impl Callbacks {
-                    fn new(debug_dir: PathBuf) -> Result<Self> {
-                        // Create the debug dir in case it doesn't exist
-                        std::fs::create_dir_all(&debug_dir)?;
-                        Ok(Self { debug_dir })
-                    }
-                }
-                // Converts a kind into a filename, that we will use to dump
-                // the contents of the IR object file to.
-                fn types_to_signature(types: &[Type]) -> String {
-                    types
-                        .iter()
-                        .map(|ty| match ty {
-                            Type::I32 => "i".to_string(),
-                            Type::I64 => "I".to_string(),
-                            Type::F32 => "f".to_string(),
-                            Type::F64 => "F".to_string(),
-                            Type::V128 => "v".to_string(),
-                            Type::ExternRef => "e".to_string(),
-                            Type::FuncRef => "r".to_string(),
-                        })
-                        .collect::<Vec<_>>()
-                        .join("")
-                }
-                // Converts a kind into a filename, that we will use to dump
-                // the contents of the IR object file to.
-                fn function_kind_to_filename(kind: &CompiledKind) -> String {
-                    match kind {
-                        CompiledKind::Local(local_index) => {
-                            format!("function_{}", local_index.index())
-                        }
-                        CompiledKind::FunctionCallTrampoline(func_type) => format!(
-                            "trampoline_call_{}_{}",
-                            types_to_signature(func_type.params()),
-                            types_to_signature(func_type.results())
-                        ),
-                        CompiledKind::DynamicFunctionTrampoline(func_type) => format!(
-                            "trampoline_dynamic_{}_{}",
-                            types_to_signature(func_type.params()),
-                            types_to_signature(func_type.results())
-                        ),
-                        CompiledKind::Module => "module".into(),
-                    }
-                }
-                impl LLVMCallbacks for Callbacks {
-                    fn preopt_ir(&self, kind: &CompiledKind, module: &InkwellModule) {
-                        let mut path = self.debug_dir.clone();
-                        path.push(format!("{}.preopt.ll", function_kind_to_filename(kind)));
-                        module
-                            .print_to_file(&path)
-                            .expect("Error while dumping pre optimized LLVM IR");
-                    }
-                    fn postopt_ir(&self, kind: &CompiledKind, module: &InkwellModule) {
-                        let mut path = self.debug_dir.clone();
-                        path.push(format!("{}.postopt.ll", function_kind_to_filename(kind)));
-                        module
-                            .print_to_file(&path)
-                            .expect("Error while dumping post optimized LLVM IR");
-                    }
-                    fn obj_memory_buffer(
-                        &self,
-                        kind: &CompiledKind,
-                        memory_buffer: &InkwellMemoryBuffer,
-                    ) {
-                        let mut path = self.debug_dir.clone();
-                        path.push(format!("{}.o", function_kind_to_filename(kind)));
-                        let mem_buf_slice = memory_buffer.as_slice();
-                        let mut file = File::create(path)
-                            .expect("Error while creating debug object file from LLVM IR");
-                        let mut pos = 0;
-                        while pos < mem_buf_slice.len() {
-                            pos += file.write(&mem_buf_slice[pos..]).unwrap();
-                        }
-                    }
-                }
-
-                impl fmt::Debug for Callbacks {
-                    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                        write!(f, "LLVMCallbacks")
-                    }
-                }
-
-                if let Some(ref llvm_debug_dir) = self.llvm_debug_dir {
-                    config.callbacks(Some(Arc::new(Callbacks::new(llvm_debug_dir.clone())?)));
-                }
-                if self.enable_verifier {
-                    config.enable_verifier();
-                }
-                Box::new(config)
-            }
-            #[cfg(not(all(feature = "singlepass", feature = "cranelift", feature = "llvm",)))]
-            compiler => {
-                bail!(
-                    "The `{}` compiler is not included in this binary.",
-                    compiler.to_string()
-                )
-            }
-        };
-
-        #[allow(unreachable_code)]
-        Ok((compiler_config, compiler))
-    }
-}
-
-/// The compiler used for the store
-#[derive(Debug, PartialEq, Eq)]
-#[allow(clippy::upper_case_acronyms, dead_code)]
-pub enum CompilerType {
-    /// Singlepass compiler
-    Singlepass,
-    /// Cranelift compiler
-    Cranelift,
-    /// LLVM compiler
-    LLVM,
-    /// Headless compiler
-    #[allow(dead_code)]
-    Headless,
-}
-
-impl CompilerType {
-    /// Return all enabled compilers
-    #[allow(dead_code)]
-    pub fn enabled() -> Vec<CompilerType> {
-        vec![
-            #[cfg(feature = "singlepass")]
-            Self::Singlepass,
-            #[cfg(feature = "cranelift")]
-            Self::Cranelift,
-            #[cfg(feature = "llvm")]
-            Self::LLVM,
-        ]
-    }
-}
-
-impl ToString for CompilerType {
-    fn to_string(&self) -> String {
-        match self {
-            Self::Singlepass => "singlepass".to_string(),
-            Self::Cranelift => "cranelift".to_string(),
-            Self::LLVM => "llvm".to_string(),
-            Self::Headless => "headless".to_string(),
-        }
-    }
-}
-
-#[cfg(feature = "compiler")]
-impl StoreOptions {
-    /// Gets the store for the host target, with the compiler name selected
-    pub fn get_store(&self) -> Result<(Store, CompilerType)> {
-        let target = Target::default();
-        self.get_store_for_target(target)
-    }
-
-    /// Gets the store for a given target, with the compiler name selected.
-    pub fn get_store_for_target(&self, target: Target) -> Result<(Store, CompilerType)> {
-        let (compiler_config, compiler_type) = self.compiler.get_compiler_config()?;
-        let engine = self.get_engine_with_compiler(target, compiler_config)?;
-        let store = Store::new(engine);
-        Ok((store, compiler_type))
-    }
-
-    #[cfg(feature = "compiler")]
-    fn get_engine_with_compiler(
-        &self,
-        target: Target,
-        compiler_config: Box<dyn CompilerConfig>,
-    ) -> Result<Engine> {
-        let engine = self.compiler.get_engine(target, compiler_config)?;
-        Ok(engine)
-    }
-}
-
-// If we don't have a compiler, but we have an engine
-#[cfg(not(any(feature = "compiler", feature = "jsc")))]
-impl StoreOptions {
-    fn get_engine_headless(&self) -> Result<wasmer_compiler::Engine> {
-        let engine: wasmer_compiler::Engine = wasmer_compiler::EngineBuilder::headless().engine();
-        Ok(engine)
-    }
-
-    /// Get the store (headless engine)
-    pub fn get_store(&self) -> Result<(Store, CompilerType)> {
-        let engine = self.get_engine_headless()?;
-        let store = Store::new(engine);
-        Ok((store, CompilerType::Headless))
-    }
-}
-
-#[cfg(all(not(feature = "compiler"), feature = "jsc"))]
-impl StoreOptions {
-    /// Get the store (headless engine)
-    pub fn get_store(&self) -> Result<(Store, CompilerType)> {
-        let store = Store::default();
-        Ok((store, CompilerType::Headless))
-    }
-}
diff --git a/lib/cli/src/types.rs b/lib/cli/src/types.rs
index 0b391d036d..bab1ee1150 100644
--- a/lib/cli/src/types.rs
+++ b/lib/cli/src/types.rs
@@ -1,5 +1,7 @@
 use comfy_table::Table;
-use wasmer_api::types::{DeployApp, DeployAppVersion, DnsDomain, DnsDomainWithRecords, Namespace};
+use wasmer_backend_api::types::{
+    DeployApp, DeployAppVersion, Deployment, DnsDomain, DnsDomainWithRecords, Namespace,
+};
 
 use crate::utils::render::CliRender;
 
@@ -98,11 +100,13 @@ impl CliRender for DeployApp {
                 "App".to_string(),
                 format!("{}/{}", self.owner.global_name, self.name),
             ],
-            vec!["Version".to_string(), self.active_version.version.clone()],
             vec![
-                "Created".to_string(),
-                self.active_version.created_at.0.clone(),
+                "Version".to_string(),
+                self.active_version
+                    .as_ref()
+                    .map_or_else(|| "n/a".to_string(), |v| v.version.clone()),
             ],
+            vec!["Created".to_string(), self.created_at.0.clone()],
             vec!["Id".to_string(), self.id.inner().to_string()],
         ]);
         table.to_string()
@@ -119,8 +123,10 @@ impl CliRender for DeployApp {
         table.add_rows(items.iter().map(|app| {
             vec![
                 format!("{}/{}", app.owner.global_name, app.name),
-                app.active_version.version.clone(),
-                app.active_version.created_at.0.clone(),
+                app.active_version
+                    .as_ref()
+                    .map_or_else(|| "n/a".to_string(), |v| v.version.clone()),
+                app.created_at.0.clone(),
                 app.id.inner().to_string(),
             ]
         }));
@@ -157,7 +163,7 @@ impl CliRender for DeployAppVersion {
     }
 }
 
-impl CliRender for wasmer_api::types::AppVersionVolume {
+impl CliRender for wasmer_backend_api::types::AppVersionVolume {
     fn render_item_table(&self) -> String {
         let mut table = Table::new();
         table.add_rows([
@@ -183,7 +189,53 @@ impl CliRender for wasmer_api::types::AppVersionVolume {
     }
 }
 
-fn format_disk_size_opt(value: Option<wasmer_api::types::BigInt>) -> String {
+impl CliRender for wasmer_backend_api::types::AppDatabase {
+    fn render_item_table(&self) -> String {
+        let mut table = Table::new();
+        table.add_rows([
+            vec!["Name".to_string(), self.name.clone()],
+            vec!["Host".to_string(), self.host.clone()],
+            vec!["Port".to_string(), self.port.clone()],
+            vec!["Username".to_string(), self.username.clone()],
+            vec![
+                "Password".to_string(),
+                self.password.clone().unwrap_or_else(|| "n/a".to_string()),
+            ],
+            vec![
+                "UI".to_string(),
+                self.db_explorer_url
+                    .clone()
+                    .unwrap_or_else(|| "n/a".to_string()),
+            ],
+        ]);
+        table.to_string()
+    }
+
+    fn render_list_table(items: &[Self]) -> String {
+        let mut table = Table::new();
+        table.set_header(vec![
+            "Name".to_string(),
+            "Host".to_string(),
+            "Port".to_string(),
+            "UI".to_string(),
+            "Password".to_string(),
+        ]);
+        table.add_rows(items.iter().map(|vol| {
+            vec![
+                vol.name.clone(),
+                vol.host.clone(),
+                vol.port.clone(),
+                vol.db_explorer_url
+                    .clone()
+                    .unwrap_or_else(|| "n/a".to_string()),
+                vol.password.clone().unwrap_or_else(|| "n/a".to_string()),
+            ]
+        }));
+        table.to_string()
+    }
+}
+
+fn format_disk_size_opt(value: Option<wasmer_backend_api::types::BigInt>) -> String {
     let value = value.and_then(|x| {
         let y: Option<u64> = x.0.try_into().ok();
         y
@@ -196,3 +248,124 @@ fn format_disk_size_opt(value: Option<wasmer_api::types::BigInt>) -> String {
         "n/a".to_string()
     }
 }
+
+impl CliRender for Deployment {
+    fn render_item_table(&self) -> String {
+        match self {
+            Deployment::NakedDeployment(naked) => naked.render_item_table(),
+            Deployment::AutobuildRepository(build) => build.render_item_table(),
+            Deployment::Other => "unknown deployment type".to_string(),
+        }
+    }
+
+    fn render_list_table(items: &[Self]) -> String {
+        let mut table = Table::new();
+        table.set_header(vec![
+            "Id".to_string(),
+            "Type".to_string(),
+            "Created at".to_string(),
+            "Status".to_string(),
+            "App version".to_string(),
+        ]);
+
+        let rows = items
+            .iter()
+            .map(|item| match item {
+                Deployment::NakedDeployment(naked) => {
+                    vec![
+                        naked.id.inner().to_string(),
+                        "Manual".to_string(),
+                        naked.created_at.0.clone(),
+                        String::new(),
+                        naked
+                            .app_version
+                            .as_ref()
+                            .map_or_else(|| "n/a".to_string(), |x| x.version.clone()),
+                    ]
+                }
+                Deployment::AutobuildRepository(build) => {
+                    vec![
+                        build.id.inner().to_string(),
+                        "Autobuild".to_string(),
+                        build.status.as_str().to_string(),
+                        build.created_at.0.clone(),
+                    ]
+                }
+                Deployment::Other => vec![
+                    String::new(),
+                    "Unknown".to_string(),
+                    String::new(),
+                    String::new(),
+                ],
+            })
+            .collect::<Vec<_>>();
+        table.add_rows(rows);
+
+        table.to_string()
+    }
+}
+
+impl CliRender for wasmer_backend_api::types::NakedDeployment {
+    fn render_item_table(&self) -> String {
+        let mut table = Table::new();
+        table.add_rows([
+            vec!["Id".to_string(), self.id.clone().into_inner()],
+            vec!["Created at".to_string(), self.created_at.0.clone()],
+            vec![
+                "App version".to_string(),
+                self.app_version
+                    .as_ref()
+                    .map_or_else(|| "n/a".to_string(), |x| x.version.clone()),
+            ],
+        ]);
+        table.to_string()
+    }
+
+    fn render_list_table(items: &[Self]) -> String {
+        let mut table = Table::new();
+        table.set_header(vec![
+            "Id".to_string(),
+            "Created at".to_string(),
+            "App version".to_string(),
+        ]);
+        table.add_rows(items.iter().map(|item| {
+            vec![
+                item.id.clone().into_inner(),
+                item.created_at.0.clone(),
+                item.app_version
+                    .as_ref()
+                    .map_or_else(|| "n/a".to_string(), |x| x.version.clone()),
+            ]
+        }));
+        table.to_string()
+    }
+}
+
+impl CliRender for wasmer_backend_api::types::AutobuildRepository {
+    fn render_item_table(&self) -> String {
+        let mut table = Table::new();
+        table.add_rows([
+            vec!["Id".to_string(), self.id.clone().into_inner()],
+            vec!["Status".to_string(), self.status.as_str().to_string()],
+            vec!["Created at".to_string(), self.created_at.0.clone()],
+        ]);
+        table.to_string()
+    }
+
+    fn render_list_table(items: &[Self]) -> String {
+        let mut table = Table::new();
+        table.set_header(vec![
+            "Id".to_string(),
+            "Status".to_string(),
+            "Created at".to_string(),
+        ]);
+        table.add_rows(items.iter().map(|item| {
+            vec![
+                item.id.clone().into_inner(),
+                item.status.as_str().to_string(),
+                item.created_at.0.clone(),
+            ]
+        }));
+        table.to_string()
+    }
+}
diff --git a/lib/cli/src/utils/mod.rs b/lib/cli/src/utils/mod.rs
index 7cd7550963..c418b8e179 100644
--- a/lib/cli/src/utils/mod.rs
+++ b/lib/cli/src/utils/mod.rs
@@ -3,6 +3,8 @@
 pub(crate) mod package_wizard;
 pub(crate) mod prompts;
 pub(crate) mod render;
+pub(crate) mod timestamp;
+pub(crate) mod unpack;
 
 use std::{
     path::{Path, PathBuf},
diff --git a/lib/cli/src/utils/package_wizard/mod.rs b/lib/cli/src/utils/package_wizard/mod.rs
index 08383cf458..d13fee9b43 100644
--- a/lib/cli/src/utils/package_wizard/mod.rs
+++ b/lib/cli/src/utils/package_wizard/mod.rs
@@ -2,7 +2,7 @@
 //
 // use anyhow::Context;
 // use dialoguer::{theme::ColorfulTheme, Select};
-// use wasmer_api::{types::UserWithNamespaces, WasmerClient};
+// use wasmer_backend_api::{types::UserWithNamespaces, WasmerClient};
 //
 // use super::prompts::PackageCheckMode;
 //
@@ -77,7 +77,7 @@
 // }
 //
 // pub struct PackageWizardOutput {
-//     pub api: Option<wasmer_api::types::Package>,
+//     pub api: Option<wasmer_backend_api::types::Package>,
 //     pub local_path: Option<PathBuf>,
 //     pub local_manifest: Option<wasmer_config::package::Manifest>,
 // }
diff --git a/lib/cli/src/utils/prompts.rs b/lib/cli/src/utils/prompts.rs
index c5ab5da302..2e2209f2ad 100644
--- a/lib/cli/src/utils/prompts.rs
+++ b/lib/cli/src/utils/prompts.rs
@@ -1,7 +1,7 @@
 use anyhow::Context;
 use colored::Colorize;
 use dialoguer::{theme::ColorfulTheme, Select};
-use wasmer_api::WasmerClient;
+use wasmer_backend_api::WasmerClient;
 use wasmer_config::package::NamedPackageIdent;
 
 pub fn prompt_for_ident(message: &str, default: Option<&str>) -> Result<String, anyhow::Error> {
@@ -23,6 +23,31 @@ pub fn prompt_for_ident(message: &str, default: Option<&str>) -> Result<String,
     }
 }
 
+/// Ask a user for an application name.
+///
+/// Will continue looping until the user provides a valid name that contains
+/// neither dots nor spaces. Returns an error if there are issues with
+/// the input interaction.
+pub fn prompt_for_app_ident(message: &str, default: Option<&str>) -> Result<String, anyhow::Error> {
+    loop {
+        let theme = ColorfulTheme::default();
+        let diag = dialoguer::Input::with_theme(&theme)
+            .with_prompt(message)
+            .with_initial_text(default.unwrap_or_default());
+
+        let raw: String = diag.interact_text()?;
+        let val = raw.trim();
+        if val.is_empty() {
+            continue;
+        }
+        if val.contains('.') || val.contains(' ') {
+            eprintln!("The name must not contain dots or spaces. Please try again.");
+            continue;
+        }
+        return Ok(val.to_string());
+    }
+}
+
 /// Ask a user for a package name.
 ///
 /// Will continue looping until the user provides a valid name.
@@ -90,7 +115,13 @@ pub async fn prompt_for_package(
     default: Option<&str>,
     check: Option<PackageCheckMode>,
     client: Option<&WasmerClient>,
-) -> Result<(NamedPackageIdent, Option<wasmer_api::types::Package>), anyhow::Error> {
+) -> Result<
+    (
+        NamedPackageIdent,
+        Option<wasmer_backend_api::types::Package>,
+    ),
+    anyhow::Error,
+> {
     loop {
         let ident = prompt_for_package_ident(message, default)?;
 
@@ -98,12 +129,16 @@ pub async fn prompt_for_package(
             let api = client.expect("Check mode specified, but no API provided");
 
             let pkg = if let Some(v) = ident.version_opt() {
-                wasmer_api::query::get_package_version(api, ident.full_name(), v.to_string())
-                    .await
-                    .context("could not query backend for package")?
-                    .map(|p| p.package)
+                wasmer_backend_api::query::get_package_version(
+                    api,
+                    ident.full_name(),
+                    v.to_string(),
+                )
+                .await
+                .context("could not query backend for package")?
+                .map(|p| p.package)
             } else {
-                wasmer_api::query::get_package(api, ident.to_string())
+                wasmer_backend_api::query::get_package(api, ident.to_string())
                     .await
                     .context("could not query backend for package")?
             };
@@ -144,7 +179,7 @@ pub async fn prompt_for_package(
 pub fn prompt_for_namespace(
     message: &str,
     default: Option<&str>,
-    user: Option<&wasmer_api::types::UserWithNamespaces>,
+    user: Option<&wasmer_backend_api::types::UserWithNamespaces>,
 ) -> Result<String, anyhow::Error> {
     if let Some(user) = user {
         let namespaces = user
@@ -205,7 +240,8 @@ pub async fn prompt_new_app_name(
                 "WARN".bold().yellow()
             )
         } else if let Some(api) = &api {
-            let app = wasmer_api::query::get_app(api, namespace.to_string(), ident.clone()).await?;
+            let app = wasmer_backend_api::query::get_app(api, namespace.to_string(), ident.clone())
+                .await?;
             eprint!("Checking name availability... ");
             if app.is_some() {
                 eprintln!(
@@ -237,7 +273,7 @@ pub async fn prompt_new_app_alias(
         let ident = prompt_for_ident(message, default)?;
 
         if let Some(api) = &api {
-            let app = wasmer_api::query::get_app_by_alias(api, ident.clone()).await?;
+            let app = wasmer_backend_api::query::get_app_by_alias(api, ident.clone()).await?;
             eprintln!("Checking name availability...");
             if app.is_some() {
                 eprintln!(
diff --git a/lib/cli/src/utils/timestamp.rs b/lib/cli/src/utils/timestamp.rs
new file mode 100644
index 0000000000..61b61f187f
--- /dev/null
+++ b/lib/cli/src/utils/timestamp.rs
@@ -0,0 +1,68 @@
+use time::{
+    format_description::well_known::{Rfc2822, Rfc3339},
+    Date, OffsetDateTime, PrimitiveDateTime, Time,
+};
+
+/// Try to parse the string as a timestamp in a number of well-known formats.
+///
+/// Supported formats,
+///
+/// - RFC 3339 (`2006-01-02T03:04:05-07:00`)
+/// - RFC 2822 (`Mon, 02 Jan 2006 03:04:05 MST`)
+/// - Date (`2006-01-02`)
+/// - Unix timestamp (`1136196245`)
+/// - Relative time (`10m` / `-1h`, `1d`)
+pub fn parse_timestamp_or_relative_time(
+    s: &str,
+    assume_negative_offset: bool,
+) -> Result<OffsetDateTime, anyhow::Error> {
+    parse_timestamp_or_relative_time_based(s, OffsetDateTime::now_utc(), assume_negative_offset)
+}
+
+/// See [`parse_timestamp_or_relative_time`].
+///
+/// NOTE: assumes a negative offset if time is specified in a format like "1h".
+pub fn parse_timestamp_or_relative_time_negative_offset(
+    s: &str,
+) -> Result<OffsetDateTime, anyhow::Error> {
+    parse_timestamp_or_relative_time(s, true)
+}
+
+/// See [`parse_timestamp_or_relative_time`].
+pub fn parse_timestamp_or_relative_time_based(
+    s: &str,
+    base: OffsetDateTime,
+    assume_negative_offset: bool,
+) -> Result<OffsetDateTime, anyhow::Error> {
+    if let Ok(t) = OffsetDateTime::parse(s, &Rfc3339) {
+        return Ok(t);
+    }
+    if let Ok(t) = OffsetDateTime::parse(s, &Rfc2822) {
+        return Ok(t);
+    }
+    if let Ok(t) = Date::parse(s, time::macros::format_description!("[year]-[month]-[day]")) {
+        return Ok(PrimitiveDateTime::new(t, Time::MIDNIGHT).assume_utc());
+    }
+    if let Ok(t) = OffsetDateTime::parse(s, time::macros::format_description!("[unix_timestamp]")) {
+        return Ok(t);
+    }
+
+    // Relative time.
+    let (is_negative, v) = match s.strip_prefix('-') {
+        Some(rest) => (true, rest),
+        // Note: `assume_negative_offset` forces offsets to be negative.
+        None => (assume_negative_offset, s.trim_start_matches('+')),
+    };
+
+    if let Ok(duration) = humantime::parse_duration(v) {
+        let time = if is_negative {
+            base - duration
+        } else {
+            base + duration
+        };
+
+        return Ok(time);
+    }
+
+    anyhow::bail!("Unable to parse the timestamp - no known format matched")
+}
diff --git a/lib/cli/src/utils/unpack.rs b/lib/cli/src/utils/unpack.rs
new file mode 100644
index 0000000000..7ec4964203
--- /dev/null
+++ b/lib/cli/src/utils/unpack.rs
@@ -0,0 +1,129 @@
+#![allow(unused)]
+
+use crate::common::normalize_path;
+use std::path::{Path, PathBuf};
+
+/// Convenience function that will unpack .tar.gz files and .tar.bz
+/// files to a target directory (does NOT remove the original .tar.gz)
+pub fn try_unpack_targz<P: AsRef<Path>>(
+    target_targz_path: P,
+    target_path: P,
+    strip_toplevel: bool,
+) -> Result<PathBuf, anyhow::Error> {
+    let target_targz_path = target_targz_path.as_ref().to_string_lossy().to_string();
+    let target_targz_path = normalize_path(&target_targz_path);
+    let target_targz_path = Path::new(&target_targz_path);
+
+    let target_path = target_path.as_ref().to_string_lossy().to_string();
+    let target_path = normalize_path(&target_path);
+    let target_path = Path::new(&target_path);
+
+    let open_file = || {
+        std::fs::File::open(target_targz_path)
+            .map_err(|e| anyhow::anyhow!("failed to open {}: {e}", target_targz_path.display()))
+    };
+
+    let try_decode_gz = || {
+        let file = open_file()?;
+        let gz_decoded = flate2::read::GzDecoder::new(&file);
+        let ar = tar::Archive::new(gz_decoded);
+        if strip_toplevel {
+            unpack_sans_parent(ar, target_path).map_err(|e| {
+                anyhow::anyhow!(
+                    "failed to unpack (gz_ar_unpack_sans_parent) {}: {e}",
+                    target_targz_path.display()
+                )
+            })
+        } else {
+            unpack_with_parent(ar, target_path).map_err(|e| {
+                anyhow::anyhow!(
+                    "failed to unpack (gz_ar_unpack) {}: {e}",
+                    target_targz_path.display()
+                )
+            })
+        }
+    };
+
+    let try_decode_xz = || {
+        let file = open_file()?;
+        let mut decomp: Vec<u8> = Vec::new();
+        let mut bufread = std::io::BufReader::new(&file);
+        lzma_rs::xz_decompress(&mut bufread, &mut decomp).map_err(|e| {
+            anyhow::anyhow!(
+                "failed to unpack (try_decode_xz) {}: {e}",
+                target_targz_path.display()
+            )
+        })?;
+
+        let cursor = std::io::Cursor::new(decomp);
+        let mut ar = tar::Archive::new(cursor);
+        if strip_toplevel {
+            unpack_sans_parent(ar, target_path).map_err(|e| {
+                anyhow::anyhow!(
+                    "failed to unpack (sans parent) {}: {e}",
+                    target_targz_path.display()
+                )
+            })
+        } else {
+            ar.unpack(target_path).map_err(|e| {
+                anyhow::anyhow!(
+                    "failed to unpack (with parent) {}: {e}",
+                    target_targz_path.display()
+                )
+            })
+        }
+    };
+
+    try_decode_gz().or_else(|e1| {
+        try_decode_xz()
+            .map_err(|e2| anyhow::anyhow!("could not decode gz: {e1}, could not decode xz: {e2}"))
+    })?;
+
+    Ok(Path::new(&target_targz_path).to_path_buf())
+}
+
+pub fn unpack_with_parent<R>(mut archive: tar::Archive<R>, dst: &Path) -> Result<(), anyhow::Error>
+where
+    R: std::io::Read,
+{
+    use std::path::Component::Normal;
+
+    let dst_normalized = normalize_path(dst.to_string_lossy().as_ref());
+
+    for entry in archive.entries()? {
+        let mut entry = entry?;
+        let path: PathBuf = entry
+            .path()?
+            .components()
+            .skip(1) // strip top-level directory
+            .filter(|c| matches!(c, Normal(_))) // prevent traversal attacks
+            .collect();
+        if entry.header().entry_type().is_file() {
+            entry.unpack_in(&dst_normalized)?;
+        } else if entry.header().entry_type() == tar::EntryType::Directory {
+            std::fs::create_dir_all(Path::new(&dst_normalized).join(&path))?;
+        }
+    }
+    Ok(())
+}
+
+pub fn unpack_sans_parent<R>(mut archive: tar::Archive<R>, dst: &Path) -> std::io::Result<()>
+where
+    R: std::io::Read,
+{
+    use std::path::Component::Normal;
+
+    let dst_normalized = normalize_path(dst.to_string_lossy().as_ref());
+
+    for entry in archive.entries()? {
+        let mut entry = entry?;
+        let path: PathBuf = entry
+            .path()?
+            .components()
+            .skip(1) // strip top-level directory
+            .filter(|c| matches!(c, Normal(_))) // prevent traversal attacks
+            .collect();
+        entry.unpack(Path::new(&dst_normalized).join(path))?;
+    }
+    Ok(())
+}
diff --git a/lib/compiler-cranelift/Cargo.toml b/lib/compiler-cranelift/Cargo.toml
index 805f53319c..44ab1886ed 100644
--- a/lib/compiler-cranelift/Cargo.toml
+++ b/lib/compiler-cranelift/Cargo.toml
@@ -14,22 +14,31 @@ rust-version.workspace = true
 version.workspace = true
 
 [dependencies]
-wasmer-compiler = { path = "../compiler", version = "=4.3.7", features = ["translator", "compiler"], default-features = false }
-wasmer-types = { path = "../types", version = "=4.3.7", default-features = false, features = ["std"] }
-cranelift-entity = { version = "0.91.1", default-features = false }
-cranelift-codegen = { version = "0.91.1", default-features = false, features = ["x86", "arm64", "riscv64"] }
-cranelift-frontend = { version = "0.91.1", default-features = false }
-tracing = "0.1"
-hashbrown = { version = "0.11", optional = true }
-rayon = { version = "1.5", optional = true }
-more-asserts = "0.2"
-gimli = { version = "0.26", optional = true }
-smallvec = "1.6"
-target-lexicon = { version = "0.12.2", default-features = false }
+wasmer-compiler = { path = "../compiler", version = "=6.1.0", features = [
+	"translator",
+	"compiler",
+], default-features = false }
+wasmer-types = { path = "../types", version = "=6.1.0", default-features = false, features = [
+	"std",
+] }
+cranelift-entity = { version = "=0.110.2", default-features = false }
+cranelift-codegen = { version = "=0.110.2", default-features = false, features = [
+	"x86",
+	"arm64",
+	"riscv64",
+] }
+cranelift-frontend = { version = "=0.110.2", default-features = false }
+itertools.workspace = true
+tracing.workspace = true
+hashbrown = { workspace = true, optional = true }
+rayon = { workspace = true, optional = true }
+more-asserts.workspace = true
+gimli = { workspace = true, optional = true }
+smallvec.workspace = true
+target-lexicon = { workspace = true, default-features = false }
 
 [dev-dependencies]
-cranelift-codegen = { version = "0.91.1", features = ["all-arch"] }
-lazy_static = "1.4"
+cranelift-codegen = { version = "=0.110.2", features = ["all-arch"] }
 
 [badges]
 maintenance = { status = "actively-developed" }
@@ -38,8 +47,14 @@ maintenance = { status = "actively-developed" }
 default = ["std", "unwind", "rayon"]
 wasm = ["std", "unwind"]
 unwind = ["cranelift-codegen/unwind", "gimli"]
-std = ["cranelift-codegen/std", "cranelift-frontend/std", "wasmer-compiler/std", "wasmer-types/std"]
+std = [
+	"cranelift-codegen/std",
+	"cranelift-frontend/std",
+	"wasmer-compiler/std",
+	"wasmer-types/std",
+]
 core = ["hashbrown", "cranelift-codegen/core", "cranelift-frontend/core"]
+enable-serde = []
 
 [package.metadata.docs.rs]
 rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/compiler-cranelift/README.md b/lib/compiler-cranelift/README.md
index 625b51e744..6dbb86a56f 100644
--- a/lib/compiler-cranelift/README.md
+++ b/lib/compiler-cranelift/README.md
@@ -1,11 +1,11 @@
-# `wasmer-compiler-cranelift` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE) [![crates.io](https://img.shields.io/crates/v/wasmer-compiler-cranelift.svg)](https://crates.io/crates/wasmer-compiler-cranelift)
+# `wasmer-compiler-cranelift` [![Build Status](https://github.com/wasmerio/wasmer/actions/workflows/build.yml/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE) [![crates.io](https://img.shields.io/crates/v/wasmer-compiler-cranelift.svg)](https://crates.io/crates/wasmer-compiler-cranelift)
 
 This crate contains a compiler implementation based on Cranelift.
 
 ## Usage
 
 ```rust
-use wasmer::{Store, EngineBuilder};
+use wasmer::{Store, sys::EngineBuilder};
 use wasmer_compiler_cranelift::Cranelift;
 
 let compiler = Cranelift::new();
diff --git a/lib/compiler-cranelift/build.rs b/lib/compiler-cranelift/build.rs
index 0be0760c07..69eb555dbe 100644
--- a/lib/compiler-cranelift/build.rs
+++ b/lib/compiler-cranelift/build.rs
@@ -11,5 +11,5 @@ fn main() {
         Ok(output) => str::from_utf8(&output.stdout).unwrap().trim().to_string(),
         Err(_) => env!("CARGO_PKG_VERSION").to_string(),
     };
-    println!("cargo:rustc-env=GIT_REV={}", git_rev);
+    println!("cargo:rustc-env=GIT_REV={git_rev}");
 }
diff --git a/lib/compiler-cranelift/src/address_map.rs b/lib/compiler-cranelift/src/address_map.rs
index 41c7d80f87..cdef0523a1 100644
--- a/lib/compiler-cranelift/src/address_map.rs
+++ b/lib/compiler-cranelift/src/address_map.rs
@@ -1,10 +1,10 @@
 // This file contains code from external sources.
 // Attributions: https://github.com/wasmerio/wasmer/blob/main/docs/ATTRIBUTIONS.md
 
-use cranelift_codegen::Context;
-use cranelift_codegen::MachSrcLoc;
+use cranelift_codegen::{Context, MachSrcLoc};
 use std::ops::Range;
-use wasmer_types::{FunctionAddressMap, InstructionAddressMap, SourceLoc};
+use wasmer_compiler::types::address_map::{FunctionAddressMap, InstructionAddressMap};
+use wasmer_types::SourceLoc;
 
 pub fn get_function_address_map(
     context: &Context,
diff --git a/lib/compiler-cranelift/src/compiler.rs b/lib/compiler-cranelift/src/compiler.rs
index b2a880f695..6acb6efec4 100644
--- a/lib/compiler-cranelift/src/compiler.rs
+++ b/lib/compiler-cranelift/src/compiler.rs
@@ -1,39 +1,55 @@
 //! Support for compiling with Cranelift.
 
-use crate::address_map::get_function_address_map;
-use crate::config::Cranelift;
 #[cfg(feature = "unwind")]
 use crate::dwarf::WriterRelocate;
-use crate::func_environ::{get_function_name, FuncEnvironment};
-use crate::trampoline::{
-    make_trampoline_dynamic_function, make_trampoline_function_call, FunctionBuilderContext,
+
+use crate::{
+    address_map::get_function_address_map,
+    config::Cranelift,
+    func_environ::{get_function_name, FuncEnvironment},
+    trampoline::{
+        make_trampoline_dynamic_function, make_trampoline_function_call, FunctionBuilderContext,
+    },
+    translator::{
+        compiled_function_unwind_info, irlibcall_to_libcall, irreloc_to_relocationkind,
+        signature_to_cranelift_ir, CraneliftUnwindInfo, FuncTranslator,
+    },
 };
-use crate::translator::{
-    compiled_function_unwind_info, irlibcall_to_libcall, irreloc_to_relocationkind,
-    signature_to_cranelift_ir, CraneliftUnwindInfo, FuncTranslator,
+use cranelift_codegen::{
+    ir::{self, ExternalName, UserFuncName},
+    Context, FinalizedMachReloc, FinalizedRelocTarget, MachTrap,
 };
-use cranelift_codegen::ir::{ExternalName, UserFuncName};
-use cranelift_codegen::{ir, MachReloc};
-use cranelift_codegen::{Context, MachTrap};
+
 #[cfg(feature = "unwind")]
-use gimli::write::{Address, EhFrame, FrameTable};
+use gimli::write::{Address, EhFrame, FrameTable, Writer};
+
 #[cfg(feature = "rayon")]
 use rayon::prelude::{IntoParallelRefIterator, ParallelIterator};
 use std::sync::Arc;
+
 use wasmer_compiler::{
+    types::{
+        function::{
+            Compilation, CompiledFunction, CompiledFunctionFrameInfo, FunctionBody, UnwindInfo,
+        },
+        module::CompileModuleInfo,
+        relocation::{Relocation, RelocationTarget},
+        section::SectionIndex,
+        unwind::CompiledFunctionUnwindInfo,
+    },
     Compiler, FunctionBinaryReader, FunctionBodyData, MiddlewareBinaryReader, ModuleMiddleware,
     ModuleMiddlewareChain, ModuleTranslationState,
 };
 use wasmer_types::entity::{EntityRef, PrimaryMap};
+use wasmer_types::target::{CallingConvention, Target};
 use wasmer_types::{
-    CallingConvention, Compilation, CompileError, CompileModuleInfo, CompiledFunction,
-    CompiledFunctionFrameInfo, CompiledFunctionUnwindInfo, Dwarf, FunctionBody, FunctionIndex,
-    LocalFunctionIndex, ModuleInfo, Relocation, RelocationTarget, SectionIndex, SignatureIndex,
-    Target, TrapCode, TrapInformation,
+    CompileError, FunctionIndex, LocalFunctionIndex, ModuleInfo, SignatureIndex, TrapCode,
+    TrapInformation,
 };
 
 /// A compiler that compiles a WebAssembly module with Cranelift, translating the Wasm to Cranelift IR,
 /// optimizing it and then translating to assembly.
+#[derive(Debug)]
 pub struct CraneliftCompiler {
     config: Cranelift,
 }
@@ -48,21 +64,10 @@ impl CraneliftCompiler {
     pub fn config(&self) -> &Cranelift {
         &self.config
     }
-}
-
-impl Compiler for CraneliftCompiler {
-    fn name(&self) -> &str {
-        "cranelift"
-    }
-
-    /// Get the middlewares for this compiler
-    fn get_middlewares(&self) -> &[Arc<dyn ModuleMiddleware>] {
-        &self.config.middlewares
-    }
 
-    /// Compile the module using Cranelift, producing a compilation result with
-    /// associated relocations.
-    fn compile_module(
+    // Helper function to create an easy scope boundary for the thread pool used
+    // in [`Self::compile_module`].
+    fn compile_module_internal(
         &self,
         target: &Target,
         compile_info: &CompileModuleInfo,
@@ -124,7 +129,7 @@ impl Compiler for CraneliftCompiler {
                     module,
                     &signatures,
                     &memory_styles,
-                    &table_styles,
+                    table_styles,
                 );
                 context.func.name = match get_function_name(func_index) {
                     ExternalName::User(nameref) => {
@@ -160,7 +165,7 @@ impl Compiler for CraneliftCompiler {
 
                 let mut code_buf: Vec<u8> = Vec::new();
                 context
-                    .compile_and_emit(&*isa, &mut code_buf)
+                    .compile_and_emit(&*isa, &mut code_buf, &mut Default::default())
                     .map_err(|error| CompileError::Codegen(error.inner.to_string()))?;
 
                 let result = context.compiled_code().unwrap();
@@ -254,6 +259,7 @@ impl Compiler for CraneliftCompiler {
                 // if generate_debug_info {
                 //     context.func.collect_debug_info();
                 // }
+
                 let mut reader =
                     MiddlewareBinaryReader::new_with_offset(input.data, input.module_offset);
                 reader.set_middleware_chain(
@@ -272,8 +278,8 @@ impl Compiler for CraneliftCompiler {
 
                 let mut code_buf: Vec<u8> = Vec::new();
                 context
-                    .compile_and_emit(&*isa, &mut code_buf)
-                    .map_err(|error| CompileError::Codegen(error.inner.to_string()))?;
+                    .compile_and_emit(&*isa, &mut code_buf, &mut Default::default())
+                    .map_err(|error| CompileError::Codegen(format!("{error:#?}")))?;
 
                 let result = context.compiled_code().unwrap();
                 let func_relocs = result
@@ -336,22 +342,21 @@ impl Compiler for CraneliftCompiler {
             .into_iter()
             .unzip();
 
+        let mut unwind_info = UnwindInfo::default();
+
         #[cfg(feature = "unwind")]
-        let dwarf = if let Some((mut dwarf_frametable, cie_id)) = dwarf_frametable {
+        if let Some((mut dwarf_frametable, cie_id)) = dwarf_frametable {
             for fde in fdes.into_iter().flatten() {
                 dwarf_frametable.add_fde(cie_id, fde);
             }
             let mut eh_frame = EhFrame(WriterRelocate::new(target.triple().endianness().ok()));
             dwarf_frametable.write_eh_frame(&mut eh_frame).unwrap();
+            eh_frame.write(&[0, 0, 0, 0]).unwrap(); // Write a 0 length at the end of the table.
 
             let eh_frame_section = eh_frame.0.into_section();
             custom_sections.push(eh_frame_section);
-            Some(Dwarf::new(SectionIndex::new(custom_sections.len() - 1)))
-        } else {
-            None
+            unwind_info.eh_frame = Some(SectionIndex::new(custom_sections.len() - 1));
         };
-        #[cfg(not(feature = "unwind"))]
-        let dwarf = None;
 
         // function call trampolines (only for local functions, by signature)
         #[cfg(not(feature = "rayon"))]
@@ -405,40 +410,106 @@ impl Compiler for CraneliftCompiler {
             .into_iter()
             .collect::<PrimaryMap<FunctionIndex, FunctionBody>>();
 
+        let got = wasmer_compiler::types::function::GOT::empty();
+
         Ok(Compilation {
             functions: functions.into_iter().collect(),
             custom_sections,
             function_call_trampolines,
             dynamic_function_trampolines,
-            debug: dwarf,
+            unwind_info,
+            got,
         })
     }
 }
 
-fn mach_reloc_to_reloc(module: &ModuleInfo, reloc: &MachReloc) -> Relocation {
-    let &MachReloc {
+impl Compiler for CraneliftCompiler {
+    fn name(&self) -> &str {
+        "cranelift"
+    }
+
+    fn get_perfmap_enabled(&self) -> bool {
+        self.config.enable_perfmap
+    }
+
+    fn deterministic_id(&self) -> String {
+        String::from("cranelift")
+    }
+
+    /// Get the middlewares for this compiler
+    fn get_middlewares(&self) -> &[Arc<dyn ModuleMiddleware>] {
+        &self.config.middlewares
+    }
+
+    /// Compile the module using Cranelift, producing a compilation result with
+    /// associated relocations.
+    fn compile_module(
+        &self,
+        target: &Target,
+        compile_info: &CompileModuleInfo,
+        module_translation_state: &ModuleTranslationState,
+        function_body_inputs: PrimaryMap<LocalFunctionIndex, FunctionBodyData<'_>>,
+    ) -> Result<Compilation, CompileError> {
+        #[cfg(feature = "rayon")]
+        {
+            let num_threads = self.config.num_threads.get();
+            let pool = rayon::ThreadPoolBuilder::new()
+                .num_threads(num_threads)
+                .build()
+                .unwrap();
+
+            pool.install(|| {
+                self.compile_module_internal(
+                    target,
+                    compile_info,
+                    module_translation_state,
+                    function_body_inputs,
+                )
+            })
+        }
+
+        #[cfg(not(feature = "rayon"))]
+        {
+            self.compile_module_internal(
+                target,
+                compile_info,
+                module_translation_state,
+                function_body_inputs,
+            )
+        }
+    }
+}
+
+fn mach_reloc_to_reloc(module: &ModuleInfo, reloc: &FinalizedMachReloc) -> Relocation {
+    let FinalizedMachReloc {
         offset,
         kind,
-        ref name,
         addend,
-    } = reloc;
-    let reloc_target = if let ExternalName::User(extname_ref) = *name {
+        target,
+    } = &reloc;
+    let name = match target {
+        FinalizedRelocTarget::ExternalName(external_name) => external_name,
+        FinalizedRelocTarget::Func(_) => {
+            unimplemented!("relocations to offset in the same function are not yet supported")
+        }
+    };
+    let reloc_target: RelocationTarget = if let ExternalName::User(extname_ref) = name {
         //debug_assert_eq!(namespace, 0);
         RelocationTarget::LocalFunc(
             module
                 .local_func_index(FunctionIndex::from_u32(extname_ref.as_u32()))
                 .expect("The provided function should be local"),
         )
-    } else if let ExternalName::LibCall(libcall) = *name {
-        RelocationTarget::LibCall(irlibcall_to_libcall(libcall))
+    } else if let ExternalName::LibCall(libcall) = name {
+        RelocationTarget::LibCall(irlibcall_to_libcall(*libcall))
     } else {
-        panic!("unrecognized external name")
+        panic!("unrecognized external target")
     };
     Relocation {
-        kind: irreloc_to_relocationkind(kind),
+        kind: irreloc_to_relocationkind(*kind),
         reloc_target,
-        offset,
-        addend,
+        offset: *offset,
+        addend: *addend,
     }
 }
 
@@ -464,6 +535,9 @@ fn translate_ir_trapcode(trap: ir::TrapCode) -> TrapCode {
         ir::TrapCode::BadConversionToInteger => TrapCode::BadConversionToInteger,
         ir::TrapCode::UnreachableCodeReached => TrapCode::UnreachableCodeReached,
         ir::TrapCode::Interrupt => unimplemented!("Interrupts not supported"),
+        ir::TrapCode::NullReference | ir::TrapCode::NullI31Ref => {
+            unimplemented!("Null reference not supported")
+        }
         ir::TrapCode::User(_user_code) => unimplemented!("User trap code not supported"),
         // ir::TrapCode::Interrupt => TrapCode::Interrupt,
         // ir::TrapCode::User(user_code) => TrapCode::User(user_code),
diff --git a/lib/compiler-cranelift/src/config.rs b/lib/compiler-cranelift/src/config.rs
index 0ce14a4ceb..d983cdda6f 100644
--- a/lib/compiler-cranelift/src/config.rs
+++ b/lib/compiler-cranelift/src/config.rs
@@ -1,10 +1,13 @@
 use crate::compiler::CraneliftCompiler;
-use cranelift_codegen::isa::{lookup, TargetIsa};
-use cranelift_codegen::settings::{self, Configurable};
-use cranelift_codegen::CodegenResult;
+use cranelift_codegen::{
+    isa::{lookup, TargetIsa},
+    settings::{self, Configurable},
+    CodegenResult,
+};
+use std::num::NonZero;
 use std::sync::Arc;
 use wasmer_compiler::{Compiler, CompilerConfig, Engine, EngineBuilder, ModuleMiddleware};
-use wasmer_types::{Architecture, CpuFeature, Target};
+use wasmer_types::target::{Architecture, CpuFeature, Target};
 
 // Runtime Environment
 
@@ -31,8 +34,11 @@ pub enum CraneliftOptLevel {
 pub struct Cranelift {
     enable_nan_canonicalization: bool,
     enable_verifier: bool,
+    pub(crate) enable_perfmap: bool,
     enable_pic: bool,
     opt_level: CraneliftOptLevel,
+    /// The number of threads to use for compilation.
+    pub num_threads: NonZero<usize>,
     /// The middleware chain.
     pub(crate) middlewares: Vec<Arc<dyn ModuleMiddleware>>,
 }
@@ -46,7 +52,9 @@ impl Cranelift {
             enable_verifier: false,
             opt_level: CraneliftOptLevel::Speed,
             enable_pic: false,
+            num_threads: std::thread::available_parallelism().unwrap_or(NonZero::new(1).unwrap()),
             middlewares: vec![],
+            enable_perfmap: false,
         }
     }
 
@@ -59,6 +67,12 @@ impl Cranelift {
         self
     }
 
+    /// Set the number of threads to use for compilation.
+    pub fn num_threads(&mut self, num_threads: NonZero<usize>) -> &mut Self {
+        self.num_threads = num_threads;
+        self
+    }
+
     /// The optimization levels when optimizing the IR.
     pub fn opt_level(&mut self, opt_level: CraneliftOptLevel) -> &mut Self {
         self.opt_level = opt_level;
@@ -66,7 +80,7 @@ impl Cranelift {
     }
 
     /// Generates the ISA for the provided target
-    pub fn isa(&self, target: &Target) -> CodegenResult<Box<dyn TargetIsa>> {
+    pub fn isa(&self, target: &Target) -> CodegenResult<Arc<dyn TargetIsa>> {
         let mut builder =
             lookup(target.triple().clone()).expect("construct Cranelift ISA for triple");
         // Cpu Features
@@ -122,7 +136,6 @@ impl Cranelift {
 
     /// Generates the flags for the compiler
     pub fn flags(&self, target: &Target) -> settings::Flags {
-        let is_riscv = matches!(target.triple().architecture, Architecture::Riscv64(_));
         let mut flags = settings::builder();
 
         // Enable probestack
@@ -137,12 +150,6 @@ impl Cranelift {
                 .expect("should be valid flag");
         }
 
-        // There are two possible traps for division, and this way
-        // we get the proper one if code traps.
-        flags
-            .enable("avoid_div_traps")
-            .expect("should be valid flag");
-
         if self.enable_pic {
             flags.enable("is_pic").expect("should be a valid flag");
         }
@@ -177,16 +184,6 @@ impl Cranelift {
             )
             .expect("should be valid flag");
 
-        if is_riscv {
-            flags
-                .set("enable_simd", "false")
-                .expect("should be valid flag");
-        } else {
-            flags
-                .set("enable_simd", "true")
-                .expect("should be valid flag");
-        }
-
         let enable_nan_canonicalization = if self.enable_nan_canonicalization {
             "true"
         } else {
@@ -209,6 +206,10 @@ impl CompilerConfig for Cranelift {
         self.enable_verifier = true;
     }
 
+    fn enable_perfmap(&mut self) {
+        self.enable_perfmap = true;
+    }
+
     fn canonicalize_nans(&mut self, enable: bool) {
         self.enable_nan_canonicalization = enable;
     }
diff --git a/lib/compiler-cranelift/src/dwarf.rs b/lib/compiler-cranelift/src/dwarf.rs
index 8ab9b0b4b2..68e7582318 100644
--- a/lib/compiler-cranelift/src/dwarf.rs
+++ b/lib/compiler-cranelift/src/dwarf.rs
@@ -1,11 +1,10 @@
 use gimli::write::{Address, EndianVec, Result, Writer};
 use gimli::{RunTimeEndian, SectionId};
-use wasmer_types::entity::EntityRef;
-use wasmer_types::LocalFunctionIndex;
-use wasmer_types::{
-    CustomSection, CustomSectionProtection, Endianness, Relocation, RelocationKind,
-    RelocationTarget, SectionBody,
+use wasmer_compiler::types::{
+    relocation::{Relocation, RelocationKind, RelocationTarget},
+    section::{CustomSection, CustomSectionProtection, SectionBody},
 };
+use wasmer_types::{entity::EntityRef, target::Endianness, LocalFunctionIndex};
 
 #[derive(Clone, Debug)]
 pub struct WriterRelocate {
@@ -34,6 +33,7 @@ impl WriterRelocate {
         let data = self.writer.into_vec();
         CustomSection {
             protection: CustomSectionProtection::Read,
+            alignment: None,
             bytes: SectionBody::new_with_vec(data),
             relocations: self.relocs,
         }
diff --git a/lib/compiler-cranelift/src/func_environ.rs b/lib/compiler-cranelift/src/func_environ.rs
index 1160e00f96..3f01707f40 100644
--- a/lib/compiler-cranelift/src/func_environ.rs
+++ b/lib/compiler-cranelift/src/func_environ.rs
@@ -1,29 +1,31 @@
 // This file contains code from external sources.
 // Attributions: https://github.com/wasmerio/wasmer/blob/main/docs/ATTRIBUTIONS.md
 
-use crate::translator::{
-    type_to_irtype, FuncEnvironment as BaseFuncEnvironment, GlobalVariable, TargetEnvironment,
+use crate::{
+    heap::{Heap, HeapData, HeapStyle},
+    table::{TableData, TableSize},
+    translator::{FuncEnvironment as BaseFuncEnvironment, GlobalVariable, TargetEnvironment},
+};
+use cranelift_codegen::{
+    cursor::FuncCursor,
+    ir::{
+        self,
+        condcodes::IntCC,
+        immediates::{Offset32, Uimm64},
+        types::*,
+        AbiParam, ArgumentPurpose, Function, InstBuilder, MemFlags, Signature,
+    },
+    isa::TargetFrontendConfig,
 };
-use cranelift_codegen::cursor::FuncCursor;
-use cranelift_codegen::ir;
-use cranelift_codegen::ir::condcodes::*;
-use cranelift_codegen::ir::immediates::{Offset32, Uimm64};
-use cranelift_codegen::ir::types::*;
-use cranelift_codegen::ir::{AbiParam, ArgumentPurpose, Function, InstBuilder, Signature};
-use cranelift_codegen::isa::TargetFrontendConfig;
 use cranelift_frontend::FunctionBuilder;
 use std::convert::TryFrom;
 use wasmer_compiler::wasmparser::HeapType;
-use wasmer_types::entity::EntityRef;
-use wasmer_types::entity::PrimaryMap;
-use wasmer_types::VMBuiltinFunctionIndex;
-use wasmer_types::VMOffsets;
 use wasmer_types::{
-    FunctionIndex, FunctionType, GlobalIndex, LocalFunctionIndex, MemoryIndex, ModuleInfo,
-    SignatureIndex, TableIndex, Type as WasmerType,
+    entity::{EntityRef, PrimaryMap, SecondaryMap},
+    FunctionIndex, FunctionType, GlobalIndex, LocalFunctionIndex, MemoryIndex, MemoryStyle,
+    ModuleInfo, SignatureIndex, TableIndex, TableStyle, Type as WasmerType, VMBuiltinFunctionIndex,
+    VMOffsets, WasmError, WasmResult,
 };
-use wasmer_types::{MemoryStyle, TableStyle};
-use wasmer_types::{WasmError, WasmResult};
 
 /// Compute an `ir::ExternalName` for a given wasm function index.
 pub fn get_function_name(func_index: FunctionIndex) -> ir::ExternalName {
@@ -31,6 +33,7 @@ pub fn get_function_name(func_index: FunctionIndex) -> ir::ExternalName {
 }
 
 /// The type of the `current_elements` field.
+#[allow(unused)]
 pub fn type_of_vmtable_definition_current_elements(vmoffsets: &VMOffsets) -> ir::Type {
     ir::Type::int(u16::from(vmoffsets.size_of_vmtable_definition_current_elements()) * 8).unwrap()
 }
@@ -49,6 +52,9 @@ pub struct FuncEnvironment<'module_environment> {
     /// The module function signatures
     signatures: &'module_environment PrimaryMap<SignatureIndex, ir::Signature>,
 
+    /// Heaps implementing WebAssembly linear memories.
+    heaps: PrimaryMap<Heap, HeapData>,
+
     /// The Cranelift global holding the vmctx address.
     vmctx: Option<ir::GlobalValue>,
 
@@ -119,7 +125,9 @@ pub struct FuncEnvironment<'module_environment> {
     /// The memory styles
     memory_styles: &'module_environment PrimaryMap<MemoryIndex, MemoryStyle>,
 
-    /// The table styles
+    /// Cranelift tables we have created to implement Wasm tables.
+    tables: SecondaryMap<TableIndex, Option<TableData>>,
+
     table_styles: &'module_environment PrimaryMap<TableIndex, TableStyle>,
 }
 
@@ -136,6 +144,7 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
             module,
             signatures,
             type_stack: vec![],
+            heaps: PrimaryMap::new(),
             vmctx: None,
             memory32_size_sig: None,
             table_size_sig: None,
@@ -157,6 +166,7 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
             memory32_atomic_notify_sig: None,
             offsets: VMOffsets::new(target_config.pointer_bytes(), module),
             memory_styles,
+            tables: Default::default(),
             table_styles,
         }
     }
@@ -165,6 +175,80 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
         self.target_config.pointer_type()
     }
 
+    fn ensure_table_exists(&mut self, func: &mut ir::Function, index: TableIndex) {
+        if self.tables[index].is_some() {
+            return;
+        }
+
+        let pointer_type = self.pointer_type();
+
+        let (ptr, base_offset, current_elements_offset) = {
+            let vmctx = self.vmctx(func);
+            if let Some(def_index) = self.module.local_table_index(index) {
+                let base_offset =
+                    i32::try_from(self.offsets.vmctx_vmtable_definition_base(def_index)).unwrap();
+                let current_elements_offset = i32::try_from(
+                    self.offsets
+                        .vmctx_vmtable_definition_current_elements(def_index),
+                )
+                .unwrap();
+                (vmctx, base_offset, current_elements_offset)
+            } else {
+                let from_offset = self.offsets.vmctx_vmtable_import(index);
+                let table = func.create_global_value(ir::GlobalValueData::Load {
+                    base: vmctx,
+                    offset: Offset32::new(i32::try_from(from_offset).unwrap()),
+                    global_type: pointer_type,
+                    flags: MemFlags::trusted().with_readonly(),
+                });
+                let base_offset = i32::from(self.offsets.vmtable_definition_base());
+                let current_elements_offset =
+                    i32::from(self.offsets.vmtable_definition_current_elements());
+                (table, base_offset, current_elements_offset)
+            }
+        };
+
+        let table = &self.module.tables[index];
+        let element_size = self.reference_type().bytes();
+
+        let base_gv = func.create_global_value(ir::GlobalValueData::Load {
+            base: ptr,
+            offset: Offset32::new(base_offset),
+            global_type: pointer_type,
+            flags: if Some(table.minimum) == table.maximum {
+                // A fixed-size table can't be resized so its base address won't
+                // change.
+                MemFlags::trusted().with_readonly()
+            } else {
+                MemFlags::trusted()
+            },
+        });
+
+        let bound = if Some(table.minimum) == table.maximum {
+            TableSize::Static {
+                bound: table.minimum,
+            }
+        } else {
+            TableSize::Dynamic {
+                bound_gv: func.create_global_value(ir::GlobalValueData::Load {
+                    base: ptr,
+                    offset: Offset32::new(current_elements_offset),
+                    global_type: ir::Type::int(
+                        u16::from(self.offsets.size_of_vmtable_definition_current_elements()) * 8,
+                    )
+                    .unwrap(),
+                    flags: MemFlags::trusted(),
+                }),
+            }
+        };
+
+        self.tables[index] = Some(TableData {
+            base_gv,
+            bound,
+            element_size,
+        });
+    }
+
     fn vmctx(&mut self, func: &mut Function) -> ir::GlobalValue {
         self.vmctx.unwrap_or_else(|| {
             let vmctx = func.create_global_value(ir::GlobalValueData::VMContext);
@@ -851,83 +935,47 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
 
         (base, func_addr)
     }
+
+    fn get_or_init_funcref_table_elem(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        table_index: TableIndex,
+        index: ir::Value,
+    ) -> ir::Value {
+        let pointer_type = self.pointer_type();
+        self.ensure_table_exists(builder.func, table_index);
+        let table_data = self.tables[table_index].as_ref().unwrap();
+
+        // To support lazy initialization of table
+        // contents, we check for a null entry here, and
+        // if null, we take a slow-path that invokes a
+        // libcall.
+        let (table_entry_addr, flags) =
+            table_data.prepare_table_addr(builder, index, pointer_type, false);
+        builder.ins().load(pointer_type, flags, table_entry_addr, 0)
+    }
 }
 
-impl<'module_environment> TargetEnvironment for FuncEnvironment<'module_environment> {
+impl TargetEnvironment for FuncEnvironment<'_> {
     fn target_config(&self) -> TargetFrontendConfig {
         self.target_config
     }
 }
 
-impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_environment> {
+impl BaseFuncEnvironment for FuncEnvironment<'_> {
     fn is_wasm_parameter(&self, _signature: &ir::Signature, index: usize) -> bool {
         // The first parameter is the vmctx. The rest are the wasm parameters.
         index >= 1
     }
 
-    fn make_table(&mut self, func: &mut ir::Function, index: TableIndex) -> WasmResult<ir::Table> {
-        let pointer_type = self.pointer_type();
-
-        let (ptr, base_offset, current_elements_offset) = {
-            let vmctx = self.vmctx(func);
-            if let Some(def_index) = self.module.local_table_index(index) {
-                let base_offset =
-                    i32::try_from(self.offsets.vmctx_vmtable_definition_base(def_index)).unwrap();
-                let current_elements_offset = i32::try_from(
-                    self.offsets
-                        .vmctx_vmtable_definition_current_elements(def_index),
-                )
-                .unwrap();
-                (vmctx, base_offset, current_elements_offset)
-            } else {
-                let from_offset = self.offsets.vmctx_vmtable_import_definition(index);
-                let table = func.create_global_value(ir::GlobalValueData::Load {
-                    base: vmctx,
-                    offset: Offset32::new(i32::try_from(from_offset).unwrap()),
-                    global_type: pointer_type,
-                    readonly: true,
-                });
-                let base_offset = i32::from(self.offsets.vmtable_definition_base());
-                let current_elements_offset =
-                    i32::from(self.offsets.vmtable_definition_current_elements());
-                (table, base_offset, current_elements_offset)
-            }
-        };
-
-        let base_gv = func.create_global_value(ir::GlobalValueData::Load {
-            base: ptr,
-            offset: Offset32::new(base_offset),
-            global_type: pointer_type,
-            readonly: false,
-        });
-        let bound_gv = func.create_global_value(ir::GlobalValueData::Load {
-            base: ptr,
-            offset: Offset32::new(current_elements_offset),
-            global_type: type_of_vmtable_definition_current_elements(&self.offsets),
-            readonly: false,
-        });
-
-        let element_size = match self.table_styles[index] {
-            TableStyle::CallerChecksSignature => u64::from(self.offsets.size_of_vm_funcref()),
-        };
-
-        Ok(func.create_table(ir::TableData {
-            base_gv,
-            min_size: Uimm64::new(0),
-            bound_gv,
-            element_size: Uimm64::new(element_size),
-            index_type: I32,
-        }))
-    }
-
     fn translate_table_grow(
         &mut self,
         mut pos: cranelift_codegen::cursor::FuncCursor<'_>,
         table_index: TableIndex,
-        _table: ir::Table,
         delta: ir::Value,
         init_value: ir::Value,
     ) -> WasmResult<ir::Value> {
+        self.ensure_table_exists(pos.func, table_index);
         let (func_sig, index_arg, func_idx) = self.get_table_grow_func(pos.func, table_index);
         let table_index = pos.ins().iconst(I32, index_arg as i64);
         let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
@@ -943,9 +991,9 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
         &mut self,
         builder: &mut FunctionBuilder,
         table_index: TableIndex,
-        _table: ir::Table,
         index: ir::Value,
     ) -> WasmResult<ir::Value> {
+        self.ensure_table_exists(builder.func, table_index);
         let mut pos = builder.cursor();
 
         let (func_sig, table_index_arg, func_idx) = self.get_table_get_func(pos.func, table_index);
@@ -961,17 +1009,17 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
         &mut self,
         builder: &mut FunctionBuilder,
         table_index: TableIndex,
-        _table: ir::Table,
         value: ir::Value,
         index: ir::Value,
     ) -> WasmResult<()> {
+        self.ensure_table_exists(builder.func, table_index);
         let mut pos = builder.cursor();
 
         let (func_sig, table_index_arg, func_idx) = self.get_table_set_func(pos.func, table_index);
-        let table_index = pos.ins().iconst(I32, table_index_arg as i64);
+        let n_table_index = pos.ins().iconst(I32, table_index_arg as i64);
         let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
         pos.ins()
-            .call_indirect(func_sig, func_addr, &[vmctx, table_index, index, value]);
+            .call_indirect(func_sig, func_addr, &[vmctx, n_table_index, index, value]);
         Ok(())
     }
 
@@ -983,6 +1031,7 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
         val: ir::Value,
         len: ir::Value,
     ) -> WasmResult<()> {
+        self.ensure_table_exists(pos.func, table_index);
         let (func_sig, table_index_arg, func_idx) = self.get_table_fill_func(pos.func, table_index);
         let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
 
@@ -1002,12 +1051,23 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
         ty: HeapType,
     ) -> WasmResult<ir::Value> {
         Ok(match ty {
-            HeapType::Func => pos.ins().null(self.reference_type()),
-            HeapType::Extern => pos.ins().null(self.reference_type()),
-            _ => {
+            HeapType::Abstract { ty, .. } => match ty {
+                wasmer_compiler::wasmparser::AbstractHeapType::Func => {
+                    pos.ins().null(self.reference_type())
+                }
+                wasmer_compiler::wasmparser::AbstractHeapType::Extern => {
+                    pos.ins().null(self.reference_type())
+                }
+                _ => {
+                    return Err(WasmError::Unsupported(
+                        "`ref.null T` that is not a `funcref` or an `externref`".into(),
+                    ))
+                }
+            },
+            HeapType::Concrete(_) => {
                 return Err(WasmError::Unsupported(
                     "`ref.null T` that is not a `funcref` or an `externref`".into(),
-                ));
+                ))
             }
         })
     }
@@ -1036,14 +1096,6 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
         mut pos: cranelift_codegen::cursor::FuncCursor<'_>,
         func_index: FunctionIndex,
     ) -> WasmResult<ir::Value> {
-        // TODO: optimize this by storing a pointer to local func_index funcref metadata
-        // so that local funcref is just (*global + offset) instead of a function call
-        //
-        // Actually we can do the above for both local and imported functions because
-        // all of those are known statically.
-        //
-        // prototyping with a function call though
-
         let (func_sig, func_index_arg, func_idx) = self.get_func_ref_func(pos.func, func_index);
         let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
 
@@ -1072,7 +1124,7 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
         unreachable!("we don't make any custom globals")
     }
 
-    fn make_heap(&mut self, func: &mut ir::Function, index: MemoryIndex) -> WasmResult<ir::Heap> {
+    fn make_heap(&mut self, func: &mut ir::Function, index: MemoryIndex) -> WasmResult<Heap> {
         let pointer_type = self.pointer_type();
 
         let (ptr, base_offset, current_length_offset) = {
@@ -1092,7 +1144,7 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
                     base: vmctx,
                     offset: Offset32::new(i32::try_from(from_offset).unwrap()),
                     global_type: pointer_type,
-                    readonly: true,
+                    flags: ir::MemFlags::trusted().with_readonly(),
                 });
                 let base_offset = i32::from(self.offsets.vmmemory_definition_base());
                 let current_length_offset =
@@ -1109,11 +1161,11 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
                     base: ptr,
                     offset: Offset32::new(current_length_offset),
                     global_type: pointer_type,
-                    readonly: false,
+                    flags: ir::MemFlags::trusted(),
                 });
                 (
                     Uimm64::new(offset_guard_size),
-                    ir::HeapStyle::Dynamic {
+                    HeapStyle::Dynamic {
                         bound_gv: heap_bound,
                     },
                     false,
@@ -1124,8 +1176,8 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
                 offset_guard_size,
             } => (
                 Uimm64::new(offset_guard_size),
-                ir::HeapStyle::Static {
-                    bound: Uimm64::new(bound.bytes().0 as u64),
+                HeapStyle::Static {
+                    bound: bound.bytes().0 as u64,
                 },
                 true,
             ),
@@ -1135,14 +1187,21 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
             base: ptr,
             offset: Offset32::new(base_offset),
             global_type: pointer_type,
-            readonly: readonly_base,
+            flags: if readonly_base {
+                ir::MemFlags::trusted().with_readonly()
+            } else {
+                ir::MemFlags::trusted()
+            },
         });
-        Ok(func.create_heap(ir::HeapData {
+        Ok(self.heaps.push(HeapData {
             base: heap_base,
-            min_size: 0.into(),
-            offset_guard_size,
+            min_size: 0,
+            max_size: None,
+            memory_type: None,
+            offset_guard_size: offset_guard_size.into(),
             style: heap_style,
             index_type: I32,
+            page_size_log2: self.target_config.page_size_align_log2,
         }))
     }
 
@@ -1155,16 +1214,18 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
 
         let (ptr, offset) = {
             let vmctx = self.vmctx(func);
+
             let from_offset = if let Some(def_index) = self.module.local_global_index(index) {
                 self.offsets.vmctx_vmglobal_definition(def_index)
             } else {
                 self.offsets.vmctx_vmglobal_import_definition(index)
             };
+
             let global = func.create_global_value(ir::GlobalValueData::Load {
                 base: vmctx,
                 offset: Offset32::new(i32::try_from(from_offset).unwrap()),
                 global_type: pointer_type,
-                readonly: true,
+                flags: MemFlags::trusted(),
             });
 
             (global, 0)
@@ -1173,7 +1234,16 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
         Ok(GlobalVariable::Memory {
             gv: ptr,
             offset: offset.into(),
-            ty: type_to_irtype(self.module.globals[index].ty, self.target_config())?,
+            ty: match self.module.globals[index].ty {
+                WasmerType::I32 => ir::types::I32,
+                WasmerType::I64 => ir::types::I64,
+                WasmerType::F32 => ir::types::F32,
+                WasmerType::F64 => ir::types::F64,
+                WasmerType::V128 => ir::types::I8X16,
+                WasmerType::FuncRef | WasmerType::ExternRef | WasmerType::ExceptionRef => {
+                    self.reference_type()
+                }
+            },
         })
     }
 
@@ -1202,9 +1272,8 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
 
     fn translate_call_indirect(
         &mut self,
-        mut pos: FuncCursor<'_>,
+        builder: &mut FunctionBuilder,
         table_index: TableIndex,
-        table: ir::Table,
         sig_index: SignatureIndex,
         sig_ref: ir::SigRef,
         callee: ir::Value,
@@ -1212,25 +1281,21 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
     ) -> WasmResult<ir::Inst> {
         let pointer_type = self.pointer_type();
 
-        let table_entry_addr = pos.ins().table_addr(pointer_type, table, callee, 0);
+        // Get the anyfunc pointer (the funcref) from the table.
+        let anyfunc_ptr = self.get_or_init_funcref_table_elem(builder, table_index, callee);
 
         // Dereference table_entry_addr to get the function address.
         let mem_flags = ir::MemFlags::trusted();
-        let table_entry_addr = pos.ins().load(
-            pointer_type,
-            mem_flags,
-            table_entry_addr,
-            i32::from(self.offsets.vm_funcref_anyfunc_ptr()),
-        );
 
         // check if the funcref is null
-        pos.ins()
-            .trapz(table_entry_addr, ir::TrapCode::IndirectCallToNull);
+        builder
+            .ins()
+            .trapz(anyfunc_ptr, ir::TrapCode::IndirectCallToNull);
 
-        let func_addr = pos.ins().load(
+        let func_addr = builder.ins().load(
             pointer_type,
             mem_flags,
-            table_entry_addr,
+            anyfunc_ptr,
             i32::from(self.offsets.vmcaller_checked_anyfunc_func_ptr()),
         );
 
@@ -1239,38 +1304,40 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
             TableStyle::CallerChecksSignature => {
                 let sig_id_size = self.offsets.size_of_vmshared_signature_index();
                 let sig_id_type = ir::Type::int(u16::from(sig_id_size) * 8).unwrap();
-                let vmctx = self.vmctx(pos.func);
-                let base = pos.ins().global_value(pointer_type, vmctx);
+                let vmctx = self.vmctx(builder.func);
+                let base = builder.ins().global_value(pointer_type, vmctx);
                 let offset =
                     i32::try_from(self.offsets.vmctx_vmshared_signature_id(sig_index)).unwrap();
 
                 // Load the caller ID.
                 let mut mem_flags = ir::MemFlags::trusted();
                 mem_flags.set_readonly();
-                let caller_sig_id = pos.ins().load(sig_id_type, mem_flags, base, offset);
+                let caller_sig_id = builder.ins().load(sig_id_type, mem_flags, base, offset);
 
                 // Load the callee ID.
                 let mem_flags = ir::MemFlags::trusted();
-                let callee_sig_id = pos.ins().load(
+                let callee_sig_id = builder.ins().load(
                     sig_id_type,
                     mem_flags,
-                    table_entry_addr,
+                    anyfunc_ptr,
                     i32::from(self.offsets.vmcaller_checked_anyfunc_type_index()),
                 );
 
                 // Check that they match.
-                let cmp = pos.ins().icmp(IntCC::Equal, callee_sig_id, caller_sig_id);
-                pos.ins().trapz(cmp, ir::TrapCode::BadSignature);
+                let cmp = builder
+                    .ins()
+                    .icmp(IntCC::Equal, callee_sig_id, caller_sig_id);
+                builder.ins().trapz(cmp, ir::TrapCode::BadSignature);
             }
         }
 
         let mut real_call_args = Vec::with_capacity(call_args.len() + 2);
 
         // First append the callee vmctx address.
-        let vmctx = pos.ins().load(
+        let vmctx = builder.ins().load(
             pointer_type,
             mem_flags,
-            table_entry_addr,
+            anyfunc_ptr,
             i32::from(self.offsets.vmcaller_checked_anyfunc_vmctx()),
         );
         real_call_args.push(vmctx);
@@ -1278,12 +1345,14 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
         // Then append the regular call arguments.
         real_call_args.extend_from_slice(call_args);
 
-        Ok(pos.ins().call_indirect(sig_ref, func_addr, &real_call_args))
+        Ok(builder
+            .ins()
+            .call_indirect(sig_ref, func_addr, &real_call_args))
     }
 
     fn translate_call(
         &mut self,
-        mut pos: FuncCursor<'_>,
+        builder: &mut FunctionBuilder,
         callee_index: FunctionIndex,
         callee: ir::FuncRef,
         call_args: &[ir::Value],
@@ -1293,7 +1362,10 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
         // Handle direct calls to locally-defined functions.
         if !self.module.is_imported_function(callee_index) {
             // Let's get the caller vmctx
-            let caller_vmctx = pos.func.special_param(ArgumentPurpose::VMContext).unwrap();
+            let caller_vmctx = builder
+                .func
+                .special_param(ArgumentPurpose::VMContext)
+                .unwrap();
             // First append the callee vmctx address, which is the same as the caller vmctx in
             // this case.
             real_call_args.push(caller_vmctx);
@@ -1301,40 +1373,46 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
             // Then append the regular call arguments.
             real_call_args.extend_from_slice(call_args);
 
-            return Ok(pos.ins().call(callee, &real_call_args));
+            return Ok(builder.ins().call(callee, &real_call_args));
         }
 
         // Handle direct calls to imported functions. We use an indirect call
         // so that we don't have to patch the code at runtime.
         let pointer_type = self.pointer_type();
-        let sig_ref = pos.func.dfg.ext_funcs[callee].signature;
-        let vmctx = self.vmctx(pos.func);
-        let base = pos.ins().global_value(pointer_type, vmctx);
+        let sig_ref = builder.func.dfg.ext_funcs[callee].signature;
+        let vmctx = self.vmctx(builder.func);
+        let base = builder.ins().global_value(pointer_type, vmctx);
 
         let mem_flags = ir::MemFlags::trusted();
 
         // Load the callee address.
         let body_offset =
             i32::try_from(self.offsets.vmctx_vmfunction_import_body(callee_index)).unwrap();
-        let func_addr = pos.ins().load(pointer_type, mem_flags, base, body_offset);
+        let func_addr = builder
+            .ins()
+            .load(pointer_type, mem_flags, base, body_offset);
 
         // First append the callee vmctx address.
         let vmctx_offset =
             i32::try_from(self.offsets.vmctx_vmfunction_import_vmctx(callee_index)).unwrap();
-        let vmctx = pos.ins().load(pointer_type, mem_flags, base, vmctx_offset);
+        let vmctx = builder
+            .ins()
+            .load(pointer_type, mem_flags, base, vmctx_offset);
         real_call_args.push(vmctx);
 
         // Then append the regular call arguments.
         real_call_args.extend_from_slice(call_args);
 
-        Ok(pos.ins().call_indirect(sig_ref, func_addr, &real_call_args))
+        Ok(builder
+            .ins()
+            .call_indirect(sig_ref, func_addr, &real_call_args))
     }
 
     fn translate_memory_grow(
         &mut self,
         mut pos: FuncCursor<'_>,
         index: MemoryIndex,
-        _heap: ir::Heap,
+        _heap: Heap,
         val: ir::Value,
     ) -> WasmResult<ir::Value> {
         let (func_sig, index_arg, func_idx) = self.get_memory_grow_func(pos.func, index);
@@ -1350,7 +1428,7 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
         &mut self,
         mut pos: FuncCursor<'_>,
         index: MemoryIndex,
-        _heap: ir::Heap,
+        _heap: Heap,
     ) -> WasmResult<ir::Value> {
         let (func_sig, index_arg, func_idx) = self.get_memory_size_func(pos.func, index);
         let memory_index = pos.ins().iconst(I32, index_arg as i64);
@@ -1365,9 +1443,9 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
         &mut self,
         mut pos: FuncCursor,
         src_index: MemoryIndex,
-        _src_heap: ir::Heap,
+        _src_heap: Heap,
         _dst_index: MemoryIndex,
-        _dst_heap: ir::Heap,
+        _dst_heap: Heap,
         dst: ir::Value,
         src: ir::Value,
         len: ir::Value,
@@ -1388,7 +1466,7 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
         &mut self,
         mut pos: FuncCursor,
         memory_index: MemoryIndex,
-        _heap: ir::Heap,
+        _heap: Heap,
         dst: ir::Value,
         val: ir::Value,
         len: ir::Value,
@@ -1412,7 +1490,7 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
         &mut self,
         mut pos: FuncCursor,
         memory_index: MemoryIndex,
-        _heap: ir::Heap,
+        _heap: Heap,
         seg_index: u32,
         dst: ir::Value,
         src: ir::Value,
@@ -1447,8 +1525,8 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
         &mut self,
         mut pos: FuncCursor,
         table_index: TableIndex,
-        _table: ir::Table,
     ) -> WasmResult<ir::Value> {
+        self.ensure_table_exists(pos.func, table_index);
         let (func_sig, index_arg, func_idx) = self.get_table_size_func(pos.func, table_index);
         let table_index = pos.ins().iconst(I32, index_arg as i64);
         let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
@@ -1462,13 +1540,13 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
         &mut self,
         mut pos: FuncCursor,
         dst_table_index: TableIndex,
-        _dst_table: ir::Table,
         src_table_index: TableIndex,
-        _src_table: ir::Table,
         dst: ir::Value,
         src: ir::Value,
         len: ir::Value,
     ) -> WasmResult<()> {
+        self.ensure_table_exists(pos.func, src_table_index);
+        self.ensure_table_exists(pos.func, dst_table_index);
         let (func_sig, dst_table_index_arg, src_table_index_arg, func_idx) =
             self.get_table_copy_func(pos.func, dst_table_index, src_table_index);
 
@@ -1498,11 +1576,11 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
         mut pos: FuncCursor,
         seg_index: u32,
         table_index: TableIndex,
-        _table: ir::Table,
         dst: ir::Value,
         src: ir::Value,
         len: ir::Value,
     ) -> WasmResult<()> {
+        self.ensure_table_exists(pos.func, table_index);
         let (func_sig, table_index_arg, func_idx) = self.get_table_init_func(pos.func, table_index);
 
         let table_index_arg = pos.ins().iconst(I32, table_index_arg as i64);
@@ -1536,7 +1614,7 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
         &mut self,
         mut pos: FuncCursor,
         index: MemoryIndex,
-        _heap: ir::Heap,
+        _heap: Heap,
         addr: ir::Value,
         expected: ir::Value,
         timeout: ir::Value,
@@ -1560,7 +1638,7 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
         &mut self,
         mut pos: FuncCursor,
         index: MemoryIndex,
-        _heap: ir::Heap,
+        _heap: Heap,
         addr: ir::Value,
         count: ir::Value,
     ) -> WasmResult<ir::Value> {
@@ -1606,4 +1684,16 @@ impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_enviro
     fn get_function_sig(&self, sig_index: SignatureIndex) -> Option<&FunctionType> {
         self.module.signatures.get(sig_index)
     }
+
+    fn heap_access_spectre_mitigation(&self) -> bool {
+        false
+    }
+
+    fn proof_carrying_code(&self) -> bool {
+        false
+    }
+
+    fn heaps(&self) -> &PrimaryMap<Heap, HeapData> {
+        &self.heaps
+    }
 }
diff --git a/lib/compiler-cranelift/src/heap.rs b/lib/compiler-cranelift/src/heap.rs
new file mode 100644
index 0000000000..0771032527
--- /dev/null
+++ b/lib/compiler-cranelift/src/heap.rs
@@ -0,0 +1,119 @@
+//! Heaps to implement WebAssembly linear memories.
+
+use cranelift_codegen::ir::{GlobalValue, MemoryType, Type};
+use wasmer_types::entity::entity_impl;
+
+/// An opaque reference to a [`HeapData`][crate::HeapData].
+///
+/// While the order is stable, it is arbitrary.
+#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(
+    feature = "enable-serde",
+    derive(serde_derive::Serialize, serde_derive::Deserialize)
+)]
+pub struct Heap(u32);
+entity_impl!(Heap, "heap");
+
+/// A heap implementing a WebAssembly linear memory.
+///
+/// Code compiled from WebAssembly runs in a sandbox where it can't access all
+/// process memory. Instead, it is given a small set of memory areas to work in,
+/// and all accesses are bounds checked. `cranelift-wasm` models this through
+/// the concept of *heaps*.
+///
+/// Heap addresses can be smaller than the native pointer size, for example
+/// unsigned `i32` offsets on a 64-bit architecture.
+///
+/// A heap appears as three consecutive ranges of address space:
+///
+/// 1. The *mapped pages* are the accessible memory range in the heap. A heap
+///    may have a minimum guaranteed size which means that some mapped pages are
+///    always present.
+///
+/// 2. The *unmapped pages* is a possibly empty range of address space that may
+///    be mapped in the future when the heap is grown. They are addressable but
+///    not accessible.
+///
+/// 3. The *offset-guard pages* is a range of address space that is guaranteed
+///    to always cause a trap when accessed. It is used to optimize bounds
+///    checking for heap accesses with a shared base pointer. They are
+///    addressable but not accessible.
+///
+/// The *heap bound* is the total size of the mapped and unmapped pages. This is
+/// the bound that `heap_addr` checks against. Memory accesses inside the heap
+/// bounds can trap if they hit an unmapped page (which is not accessible).
+///
+/// Two styles of heaps are supported, *static* and *dynamic*. They behave
+/// differently when resized.
+///
+/// #### Static heaps
+///
+/// A *static heap* starts out with all the address space it will ever need, so
+/// it never moves to a different address. At the base address is a number of
+/// mapped pages corresponding to the heap's current size. Then follows a number
+/// of unmapped pages where the heap can grow up to its maximum size. After the
+/// unmapped pages follow the offset-guard pages which are also guaranteed to
+/// generate a trap when accessed.
+///
+/// #### Dynamic heaps
+///
+/// A *dynamic heap* can be relocated to a different base address when it is
+/// resized, and its bound can move dynamically. The offset-guard pages move
+/// when the heap is resized. The bound of a dynamic heap is stored in a global
+/// value.
+#[derive(Clone, PartialEq, Hash)]
+#[cfg_attr(
+    feature = "enable-serde",
+    derive(serde_derive::Serialize, serde_derive::Deserialize)
+)]
+pub struct HeapData {
+    /// The address of the start of the heap's storage.
+    pub base: GlobalValue,
+
+    /// Guaranteed minimum heap size in bytes. Heap accesses before `min_size`
+    /// don't need bounds checking.
+    pub min_size: u64,
+
+    /// The maximum heap size in bytes.
+    ///
+    /// Heap accesses larger than this will always trap.
+    pub max_size: Option<u64>,
+
+    /// The memory type for the pointed-to memory, if using proof-carrying code.
+    pub memory_type: Option<MemoryType>,
+
+    /// Size in bytes of the offset-guard pages following the heap.
+    pub offset_guard_size: u64,
+
+    /// Heap style, with additional style-specific info.
+    pub style: HeapStyle,
+
+    /// The index type for the heap.
+    pub index_type: Type,
+
+    /// The log2 of this memory's page size.
+    pub page_size_log2: u8,
+}
+
+/// Style of heap including style-specific information.
+#[derive(Clone, PartialEq, Hash)]
+#[cfg_attr(
+    feature = "enable-serde",
+    derive(serde_derive::Serialize, serde_derive::Deserialize)
+)]
+pub enum HeapStyle {
+    /// A dynamic heap can be relocated to a different base address when it is
+    /// grown.
+    Dynamic {
+        /// Global value providing the current bound of the heap in bytes.
+        bound_gv: GlobalValue,
+    },
+
+    /// A static heap has a fixed base address and a number of not-yet-allocated
+    /// pages before the offset-guard pages.
+    Static {
+        /// Heap bound in bytes. The offset-guard pages are allocated after the
+        /// bound.
+        bound: u64,
+    },
+}
diff --git a/lib/compiler-cranelift/src/lib.rs b/lib/compiler-cranelift/src/lib.rs
index 042537ec10..5d8857f3ed 100644
--- a/lib/compiler-cranelift/src/lib.rs
+++ b/lib/compiler-cranelift/src/lib.rs
@@ -45,6 +45,8 @@ mod debug;
 #[cfg(feature = "unwind")]
 mod dwarf;
 mod func_environ;
+mod heap;
+mod table;
 mod trampoline;
 mod translator;
 
diff --git a/lib/compiler-cranelift/src/table.rs b/lib/compiler-cranelift/src/table.rs
new file mode 100644
index 0000000000..b1dc08787e
--- /dev/null
+++ b/lib/compiler-cranelift/src/table.rs
@@ -0,0 +1,104 @@
+use cranelift_codegen::cursor::FuncCursor;
+use cranelift_codegen::ir::{self, condcodes::IntCC, immediates::Imm64, InstBuilder};
+use cranelift_frontend::FunctionBuilder;
+
+/// Size of a WebAssembly table, in elements.
+#[derive(Clone, Debug)]
+pub enum TableSize {
+    /// Non-resizable table.
+    Static {
+        /// Non-resizable tables have a constant size known at compile time.
+        bound: u32,
+    },
+    /// Resizable table.
+    Dynamic {
+        /// Resizable tables declare a Cranelift global value to load the
+        /// current size from.
+        bound_gv: ir::GlobalValue,
+    },
+}
+
+impl TableSize {
+    /// Get a CLIF value representing the current bounds of this table.
+    pub fn bound(&self, mut pos: FuncCursor, index_ty: ir::Type) -> ir::Value {
+        match *self {
+            Self::Static { bound } => pos.ins().iconst(index_ty, Imm64::new(i64::from(bound))),
+            Self::Dynamic { bound_gv } => pos.ins().global_value(index_ty, bound_gv),
+        }
+    }
+}
+
+/// An implementation of a WebAssembly table.
+#[derive(Clone, Debug)]
+pub struct TableData {
+    /// Global value giving the address of the start of the table.
+    pub base_gv: ir::GlobalValue,
+
+    /// The size of the table, in elements.
+    pub bound: TableSize,
+
+    /// The size of a table element, in bytes.
+    pub element_size: u32,
+}
+
+impl TableData {
+    /// Return a CLIF value containing a native pointer to the beginning of the
+    /// given index within this table.
+    pub fn prepare_table_addr(
+        &self,
+        pos: &mut FunctionBuilder,
+        mut index: ir::Value,
+        addr_ty: ir::Type,
+        enable_table_access_spectre_mitigation: bool,
+    ) -> (ir::Value, ir::MemFlags) {
+        let index_ty = pos.func.dfg.value_type(index);
+
+        // Start with the bounds check. Trap if `index + 1 > bound`.
+        let bound = self.bound.bound(pos.cursor(), index_ty);
+
+        // `index > bound - 1` is the same as `index >= bound`.
+        let oob = pos
+            .ins()
+            .icmp(IntCC::UnsignedGreaterThanOrEqual, index, bound);
+
+        if !enable_table_access_spectre_mitigation {
+            pos.ins().trapnz(oob, ir::TrapCode::TableOutOfBounds);
+        }
+
+        // Convert `index` to `addr_ty`.
+        if index_ty != addr_ty {
+            index = pos.ins().uextend(addr_ty, index);
+        }
+
+        // Add the table base address base
+        let base = pos.ins().global_value(addr_ty, self.base_gv);
+
+        let element_size = self.element_size;
+        let offset = if element_size == 1 {
+            index
+        } else if element_size.is_power_of_two() {
+            pos.ins()
+                .ishl_imm(index, i64::from(element_size.trailing_zeros()))
+        } else {
+            pos.ins().imul_imm(index, element_size as i64)
+        };
+
+        let element_addr = pos.ins().iadd(base, offset);
+
+        let base_flags = ir::MemFlags::new()
+            .with_aligned()
+            .with_alias_region(Some(ir::AliasRegion::Table));
+        if enable_table_access_spectre_mitigation {
+            // Short-circuit the computed table element address to a null pointer
+            // when out-of-bounds. The consumer of this address will trap when
+            // trying to access it.
+            let zero = pos.ins().iconst(addr_ty, 0);
+            (
+                pos.ins().select_spectre_guard(oob, zero, element_addr),
+                base_flags.with_trap_code(Some(ir::TrapCode::TableOutOfBounds)),
+            )
+        } else {
+            (element_addr, base_flags.with_trap_code(None))
+        }
+    }
+}
diff --git a/lib/compiler-cranelift/src/trampoline/dynamic_function.rs b/lib/compiler-cranelift/src/trampoline/dynamic_function.rs
index 7ca710a105..ead1caa3f9 100644
--- a/lib/compiler-cranelift/src/trampoline/dynamic_function.rs
+++ b/lib/compiler-cranelift/src/trampoline/dynamic_function.rs
@@ -4,17 +4,15 @@
 //! A trampoline generator for calling dynamic host functions from Wasm.
 
 use crate::translator::{compiled_function_unwind_info, signature_to_cranelift_ir};
-use cranelift_codegen::ir;
-use cranelift_codegen::ir::{
-    Function, InstBuilder, MemFlags, StackSlotData, StackSlotKind, UserFuncName,
+use cranelift_codegen::{
+    ir::{self, Function, InstBuilder, MemFlags, StackSlotData, StackSlotKind, UserFuncName},
+    isa::TargetIsa,
+    Context,
 };
-use cranelift_codegen::isa::TargetIsa;
-use cranelift_codegen::Context;
-use std::cmp;
-use std::mem;
-
 use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
-use wasmer_types::{CompileError, FunctionBody, FunctionType, VMOffsets};
+use std::{cmp, mem};
+use wasmer_compiler::types::function::FunctionBody;
+use wasmer_types::{CompileError, FunctionType, VMOffsets};
 
 /// Create a trampoline for invoking a WebAssembly function.
 pub fn make_trampoline_dynamic_function(
@@ -47,6 +45,7 @@ pub fn make_trampoline_dynamic_function(
     let ss = context.func.create_sized_stack_slot(StackSlotData::new(
         StackSlotKind::ExplicitSlot,
         values_vec_len,
+        0,
     ));
 
     {
@@ -105,7 +104,7 @@ pub fn make_trampoline_dynamic_function(
 
     let mut code_buf = Vec::new();
     context
-        .compile_and_emit(isa, &mut code_buf)
+        .compile_and_emit(isa, &mut code_buf, &mut Default::default())
         .map_err(|error| CompileError::Codegen(error.inner.to_string()))?;
 
     let unwind_info = compiled_function_unwind_info(isa, &context)?.maybe_into_to_windows_unwind();
diff --git a/lib/compiler-cranelift/src/trampoline/function_call.rs b/lib/compiler-cranelift/src/trampoline/function_call.rs
index b59b5af02f..ebe874f0b3 100644
--- a/lib/compiler-cranelift/src/trampoline/function_call.rs
+++ b/lib/compiler-cranelift/src/trampoline/function_call.rs
@@ -9,13 +9,15 @@
 //! my_func.call([1, 2])
 //! ```
 use crate::translator::{compiled_function_unwind_info, signature_to_cranelift_ir};
-use cranelift_codegen::ir;
-use cranelift_codegen::ir::InstBuilder;
-use cranelift_codegen::isa::TargetIsa;
-use cranelift_codegen::Context;
+use cranelift_codegen::{
+    ir::{self, InstBuilder},
+    isa::TargetIsa,
+    Context,
+};
 use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
 use std::mem;
-use wasmer_types::{CompileError, FunctionBody, FunctionType};
+use wasmer_compiler::types::function::FunctionBody;
+use wasmer_types::{CompileError, FunctionType};
 
 /// Create a trampoline for invoking a WebAssembly function.
 pub fn make_trampoline_function_call(
@@ -103,7 +105,7 @@ pub fn make_trampoline_function_call(
     let mut code_buf = Vec::new();
 
     context
-        .compile_and_emit(isa, &mut code_buf)
+        .compile_and_emit(isa, &mut code_buf, &mut Default::default())
         .map_err(|error| CompileError::Codegen(error.inner.to_string()))?;
 
     let unwind_info = compiled_function_unwind_info(isa, &context)?.maybe_into_to_windows_unwind();
diff --git a/lib/compiler-cranelift/src/translator/code_translator.rs b/lib/compiler-cranelift/src/translator/code_translator.rs
index f994ee3b31..b02d1b613a 100644
--- a/lib/compiler-cranelift/src/translator/code_translator.rs
+++ b/lib/compiler-cranelift/src/translator/code_translator.rs
@@ -74,13 +74,13 @@
 //!   <https://github.com/bytecodealliance/cranelift/pull/1236>
 //!     ("Relax verification to allow I8X16 to act as a default vector type")
 
-use super::func_environ::{FuncEnvironment, GlobalVariable, ReturnMode};
+mod bounds_checks;
+
+use super::func_environ::{FuncEnvironment, GlobalVariable};
 use super::func_state::{ControlStackFrame, ElseData, FuncTranslationState};
 use super::translation_utils::{block_with_params, f32_translation, f64_translation};
 use crate::{hash_map, HashMap};
-use core::cmp;
 use core::convert::TryFrom;
-use core::{i32, u32};
 use cranelift_codegen::ir::condcodes::{FloatCC, IntCC};
 use cranelift_codegen::ir::immediates::Offset32;
 use cranelift_codegen::ir::types::*;
@@ -89,6 +89,7 @@ use cranelift_codegen::ir::{
 };
 use cranelift_codegen::packed_option::ReservedValue;
 use cranelift_frontend::{FunctionBuilder, Variable};
+use itertools::Itertools;
 use smallvec::SmallVec;
 use std::vec::Vec;
 
@@ -98,6 +99,24 @@ use wasmer_types::{
     FunctionIndex, GlobalIndex, MemoryIndex, SignatureIndex, TableIndex, WasmResult,
 };
 
+/// Given a `Reachability<T>`, unwrap the inner `T` or, when unreachable, set
+/// `state.reachable = false` and return.
+///
+/// Used in combination with calling `prepare_addr` and `prepare_atomic_addr`
+/// when we can statically determine that a Wasm access will unconditionally
+/// trap.
+macro_rules! unwrap_or_return_unreachable_state {
+    ($state:ident, $value:expr) => {
+        match $value {
+            Reachability::Reachable(x) => x,
+            Reachability::Unreachable => {
+                $state.reachable = false;
+                return Ok(());
+            }
+        }
+    };
+}
+
 // Clippy warns about "align: _" but its important to document that the align field is ignored
 #[allow(clippy::unneeded_field_pattern, clippy::cognitive_complexity)]
 /// Translates wasm operators into Cranelift IR instructions. Returns `true` if it inserted
@@ -156,29 +175,30 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
          *  `get_global` and `set_global` are handled by the environment.
          ***********************************************************************************/
         Operator::GlobalGet { global_index } => {
-            let global_index = GlobalIndex::from_u32(*global_index);
-            let stack_elem = match state.get_global(builder.func, global_index.as_u32(), environ)? {
+            let val = match state.get_global(builder.func, *global_index, environ)? {
                 GlobalVariable::Const(val) => val,
                 GlobalVariable::Memory { gv, offset, ty } => {
                     let addr = builder.ins().global_value(environ.pointer_type(), gv);
-                    let flags = ir::MemFlags::trusted();
+                    let mut flags = ir::MemFlags::trusted();
+                    // Put globals in the "table" abstract heap category as well.
+                    flags.set_alias_region(Some(ir::AliasRegion::Table));
                     builder.ins().load(ty, flags, addr, offset)
                 }
-                GlobalVariable::Custom => {
-                    environ.translate_custom_global_get(builder.cursor(), global_index)?
-                }
+                GlobalVariable::Custom => environ.translate_custom_global_get(
+                    builder.cursor(),
+                    GlobalIndex::from_u32(*global_index),
+                )?,
             };
-            state.push1(stack_elem);
+            state.push1(val);
         }
         Operator::GlobalSet { global_index } => {
-            let global_index = GlobalIndex::from_u32(*global_index);
-            match state.get_global(builder.func, global_index.as_u32(), environ)? {
-                GlobalVariable::Const(_) => {
-                    panic!("global #{} is a constant", global_index.as_u32())
-                }
+            match state.get_global(builder.func, *global_index, environ)? {
+                GlobalVariable::Const(_) => panic!("global #{} is a constant", *global_index),
                 GlobalVariable::Memory { gv, offset, ty } => {
                     let addr = builder.ins().global_value(environ.pointer_type(), gv);
-                    let flags = ir::MemFlags::trusted();
+                    let mut flags = ir::MemFlags::trusted();
+                    // Put globals in the "table" abstract heap category as well.
+                    flags.set_alias_region(Some(ir::AliasRegion::Table));
                     let mut val = state.pop1();
                     // Ensure SIMD values are cast to their default Cranelift type, I8x16.
                     if ty.is_vector() {
@@ -186,10 +206,15 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
                     }
                     debug_assert_eq!(ty, builder.func.dfg.value_type(val));
                     builder.ins().store(flags, val, addr, offset);
+                    environ.update_global(builder, *global_index, val);
                 }
                 GlobalVariable::Custom => {
                     let val = state.pop1();
-                    environ.translate_custom_global_set(builder.cursor(), global_index, val)?;
+                    environ.translate_custom_global_set(
+                        builder.cursor(),
+                        GlobalIndex::from_u32(*global_index),
+                        val,
+                    )?;
                 }
             }
         }
@@ -211,7 +236,16 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
             state.push1(builder.ins().select(cond, arg1, arg2));
         }
         Operator::TypedSelect { ty: _ } => {
-            let (arg1, arg2, cond) = state.pop3();
+            // We ignore the explicit type parameter as it is only needed for
+            // validation, which we require to have been performed before
+            // translation.
+            let (mut arg1, mut arg2, cond) = state.pop3();
+            if builder.func.dfg.value_type(arg1).is_vector() {
+                arg1 = optionally_bitcast_vector(arg1, I8X16, builder);
+            }
+            if builder.func.dfg.value_type(arg2).is_vector() {
+                arg2 = optionally_bitcast_vector(arg2, I8X16, builder);
+            }
             state.push1(builder.ins().select(cond, arg1, arg2));
         }
         Operator::Nop => {
@@ -257,7 +291,9 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         Operator::If { blockty } => {
             let val = state.pop1();
 
+            let next_block = builder.create_block();
             let (params, results) = module_translation_state.blocktype_params_results(blockty)?;
+            let results: Vec<_> = results.iter().copied().collect();
             let (destination, else_data) = if params == results {
                 // It is possible there is no `else` block, so we will only
                 // allocate a block for it if/when we find the `else`. For now,
@@ -266,21 +302,38 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
                 // up discovering an `else`, then we will allocate a block for it
                 // and go back and patch the jump.
                 let destination = block_with_params(builder, results.iter(), environ)?;
-                let branch_inst =
-                    canonicalise_then_brz(builder, val, destination, state.peekn(params.len()));
-                (destination, ElseData::NoElse { branch_inst })
+                let branch_inst = canonicalise_brif(
+                    builder,
+                    val,
+                    next_block,
+                    &[],
+                    destination,
+                    state.peekn(params.len()),
+                );
+                (
+                    destination,
+                    ElseData::NoElse {
+                        branch_inst,
+                        placeholder: destination,
+                    },
+                )
             } else {
                 // The `if` type signature is not valid without an `else` block,
                 // so we eagerly allocate the `else` block here.
                 let destination = block_with_params(builder, results.iter(), environ)?;
                 let else_block = block_with_params(builder, params.iter(), environ)?;
-                canonicalise_then_brz(builder, val, else_block, state.peekn(params.len()));
+                canonicalise_brif(
+                    builder,
+                    val,
+                    next_block,
+                    &[],
+                    else_block,
+                    state.peekn(params.len()),
+                );
                 builder.seal_block(else_block);
                 (destination, ElseData::WithElse { else_block })
             };
 
-            let next_block = builder.create_block();
-            canonicalise_then_jump(builder, next_block, &[]);
             builder.seal_block(next_block); // Only predecessor is the current block.
             builder.switch_to_block(next_block);
 
@@ -322,7 +375,10 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
                         // Ensure we have a block for the `else` block (it may have
                         // already been pre-allocated, see `ElseData` for details).
                         let else_block = match *else_data {
-                            ElseData::NoElse { branch_inst } => {
+                            ElseData::NoElse {
+                                branch_inst,
+                                placeholder,
+                            } => {
                                 let (params, _results) = module_translation_state
                                     .blocktype_params_results(&blocktype)?;
                                 debug_assert_eq!(params.len(), num_return_values);
@@ -335,7 +391,11 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
                                 );
                                 state.popn(params.len());
 
-                                builder.change_jump_destination(branch_inst, else_block);
+                                builder.change_jump_destination(
+                                    branch_inst,
+                                    placeholder,
+                                    else_block,
+                                );
                                 builder.seal_block(else_block);
                                 else_block
                             }
@@ -372,17 +432,16 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         Operator::End => {
             let frame = state.control_stack.pop().unwrap();
             let next_block = frame.following_code();
-            if !builder.is_unreachable() || builder.func.layout.first_inst(next_block).is_some() {
-                let return_count = frame.num_return_values();
-                let return_args = state.peekn(return_count);
-                canonicalise_then_jump(builder, frame.following_code(), return_args);
-                // You might expect that if we just finished an `if` block that
-                // didn't have a corresponding `else` block, then we would clean
-                // up our duplicate set of parameters that we pushed earlier
-                // right here. However, we don't have to explicitly do that,
-                // since we truncate the stack back to the original height
-                // below.
-            }
+            let return_count = frame.num_return_values();
+            let return_args = state.peekn_mut(return_count);
+
+            canonicalise_then_jump(builder, next_block, return_args);
+            // You might expect that if we just finished an `if` block that
+            // didn't have a corresponding `else` block, then we would clean
+            // up our duplicate set of parameters that we pushed earlier
+            // right here. However, we don't have to explicitly do that,
+            // since we truncate the stack back to the original height
+            // below.
 
             builder.switch_to_block(next_block);
             builder.seal_block(next_block);
@@ -456,7 +515,7 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
                 }
             };
             let val = state.pop1();
-            let mut data = JumpTableData::with_capacity(targets.len() as usize);
+            let mut data = Vec::with_capacity(targets.len() as usize);
             if jump_args_count == 0 {
                 // No jump arguments
                 for depth in targets.targets() {
@@ -467,16 +526,17 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
                         frame.set_branched_to_exit();
                         frame.br_destination()
                     };
-                    data.push_entry(block);
+                    data.push(builder.func.dfg.block_call(block, &[]));
                 }
-                let jt = builder.create_jump_table(data);
                 let block = {
                     let i = state.control_stack.len() - 1 - (default as usize);
                     let frame = &mut state.control_stack[i];
                     frame.set_branched_to_exit();
                     frame.br_destination()
                 };
-                builder.ins().br_table(val, block, jt);
+                let block = builder.func.dfg.block_call(block, &[]);
+                let jt = builder.create_jump_table(JumpTableData::new(block, &data));
+                builder.ins().br_table(val, jt);
             } else {
                 // Here we have jump arguments, but Cranelift's br_table doesn't support them
                 // We then proceed to split the edges going out of the br_table
@@ -493,7 +553,7 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
                             *entry.insert(block)
                         }
                     };
-                    data.push_entry(branch_block);
+                    data.push(builder.func.dfg.block_call(branch_block, &[]));
                 }
                 let default_branch_block = match dest_block_map.entry(default as usize) {
                     hash_map::Entry::Occupied(entry) => *entry.get(),
@@ -503,8 +563,9 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
                         *entry.insert(block)
                     }
                 };
-                let jt = builder.create_jump_table(data);
-                builder.ins().br_table(val, default_branch_block, jt);
+                let default_branch_block = builder.func.dfg.block_call(default_branch_block, &[]);
+                let jt = builder.create_jump_table(JumpTableData::new(default_branch_block, &data));
+                builder.ins().br_table(val, jt);
                 for (depth, dest_block) in dest_block_sequence {
                     builder.switch_to_block(dest_block);
                     builder.seal_block(dest_block);
@@ -514,7 +575,7 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
                         frame.set_branched_to_exit();
                         frame.br_destination()
                     };
-                    let destination_args = state.peekn(return_count);
+                    let destination_args = state.peekn_mut(return_count);
                     canonicalise_then_jump(builder, real_dest_block, destination_args);
                 }
                 state.popn(return_count);
@@ -522,25 +583,20 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
             state.reachable = false;
         }
         Operator::Return => {
-            let (return_count, _br_destination) = {
+            let return_count = {
                 let frame = &mut state.control_stack[0];
-                let return_count = frame.num_return_values();
-                (return_count, frame.br_destination())
+                frame.num_return_values()
             };
             {
                 let return_args = state.peekn_mut(return_count);
-                // TODO(reftypes): maybe ref count here?
-                let return_types = wasm_param_types(&builder.func.signature.returns, |i| {
-                    environ.is_wasm_return(&builder.func.signature, i)
-                });
-                bitcast_arguments(return_args, &return_types, builder);
-                match environ.return_mode() {
-                    ReturnMode::NormalReturns => builder.ins().return_(return_args),
-                };
+                environ.handle_before_return(return_args, builder);
+                bitcast_wasm_returns(environ, return_args, builder);
+                builder.ins().return_(return_args);
             }
             state.popn(return_count);
             state.reachable = false;
         }
+
         /********************************** Exception handing **********************************/
         Operator::Try { .. }
         | Operator::Catch { .. }
@@ -561,18 +617,21 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         Operator::Call { function_index } => {
             let (fref, num_args) = state.get_direct_func(builder.func, *function_index, environ)?;
 
+            // Bitcast any vector arguments to their default type, I8X16, before calling.
             let args = state.peekn_mut(num_args);
+            bitcast_wasm_params(
+                environ,
+                builder.func.dfg.ext_funcs[fref].signature,
+                args,
+                builder,
+            );
 
-            // Bitcast any vector arguments to their default type, I8X16, before calling.
-            let callee_signature =
-                &builder.func.dfg.signatures[builder.func.dfg.ext_funcs[fref].signature];
-            let types = wasm_param_types(&callee_signature.params, |i| {
-                environ.is_wasm_parameter(callee_signature, i)
-            });
-            bitcast_arguments(args, &types, builder);
-            let func_index = FunctionIndex::from_u32(*function_index);
-
-            let call = environ.translate_call(builder.cursor(), func_index, fref, args)?;
+            let call = environ.translate_call(
+                builder,
+                FunctionIndex::from_u32(*function_index),
+                fref,
+                args,
+            )?;
             let inst_results = builder.inst_results(call);
             debug_assert_eq!(
                 inst_results.len(),
@@ -587,33 +646,25 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         Operator::CallIndirect {
             type_index,
             table_index,
-            table_byte: _,
+            ..
         } => {
-            // `index` is the index of the function's signature and `table_index` is the index of
-            // the table to search the function in.
+            // `type_index` is the index of the function's signature and
+            // `table_index` is the index of the table to search the function
+            // in.
             let (sigref, num_args) = state.get_indirect_sig(builder.func, *type_index, environ)?;
-            let table = state.get_or_create_table(builder.func, *table_index, environ)?;
             let callee = state.pop1();
 
             // Bitcast any vector arguments to their default type, I8X16, before calling.
-            let callee_signature = &builder.func.dfg.signatures[sigref];
             let args = state.peekn_mut(num_args);
-            let types = wasm_param_types(&callee_signature.params, |i| {
-                environ.is_wasm_parameter(callee_signature, i)
-            });
-            bitcast_arguments(args, &types, builder);
-
-            let args = state.peekn(num_args);
-            let sig_idx = SignatureIndex::from_u32(*type_index);
+            bitcast_wasm_params(environ, sigref, args, builder);
 
             let call = environ.translate_call_indirect(
-                builder.cursor(),
+                builder,
                 TableIndex::from_u32(*table_index),
-                table,
-                sig_idx,
+                SignatureIndex::from_u32(*type_index),
                 sigref,
                 callee,
-                args,
+                state.peekn(num_args),
             )?;
             let inst_results = builder.inst_results(call);
             debug_assert_eq!(
@@ -628,7 +679,7 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
          * Memory management is handled by environment. It is usually translated into calls to
          * special functions.
          ************************************************************************************/
-        Operator::MemoryGrow { mem, mem_byte: _ } => {
+        Operator::MemoryGrow { mem } => {
             // The WebAssembly MVP only supports one linear memory, but we expect the reserved
             // argument to be a memory index.
             let heap_index = MemoryIndex::from_u32(*mem);
@@ -636,7 +687,7 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
             let val = state.pop1();
             state.push1(environ.translate_memory_grow(builder.cursor(), heap_index, heap, val)?)
         }
-        Operator::MemorySize { mem, mem_byte: _ } => {
+        Operator::MemorySize { mem } => {
             let heap_index = MemoryIndex::from_u32(*mem);
             let heap = state.get_heap(builder.func, *mem, environ)?;
             state.push1(environ.translate_memory_size(builder.cursor(), heap_index, heap)?);
@@ -646,78 +697,142 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
          * The memory base address is provided by the environment.
          ************************************************************************************/
         Operator::I32Load8U { memarg } => {
-            translate_load(memarg, ir::Opcode::Uload8, I32, builder, state, environ)?;
+            unwrap_or_return_unreachable_state!(
+                state,
+                translate_load(memarg, ir::Opcode::Uload8, I32, builder, state, environ)?
+            );
         }
         Operator::I32Load16U { memarg } => {
-            translate_load(memarg, ir::Opcode::Uload16, I32, builder, state, environ)?;
+            unwrap_or_return_unreachable_state!(
+                state,
+                translate_load(memarg, ir::Opcode::Uload16, I32, builder, state, environ)?
+            );
         }
         Operator::I32Load8S { memarg } => {
-            translate_load(memarg, ir::Opcode::Sload8, I32, builder, state, environ)?;
+            unwrap_or_return_unreachable_state!(
+                state,
+                translate_load(memarg, ir::Opcode::Sload8, I32, builder, state, environ)?
+            );
         }
         Operator::I32Load16S { memarg } => {
-            translate_load(memarg, ir::Opcode::Sload16, I32, builder, state, environ)?;
+            unwrap_or_return_unreachable_state!(
+                state,
+                translate_load(memarg, ir::Opcode::Sload16, I32, builder, state, environ)?
+            );
         }
         Operator::I64Load8U { memarg } => {
-            translate_load(memarg, ir::Opcode::Uload8, I64, builder, state, environ)?;
+            unwrap_or_return_unreachable_state!(
+                state,
+                translate_load(memarg, ir::Opcode::Uload8, I64, builder, state, environ)?
+            );
         }
         Operator::I64Load16U { memarg } => {
-            translate_load(memarg, ir::Opcode::Uload16, I64, builder, state, environ)?;
+            unwrap_or_return_unreachable_state!(
+                state,
+                translate_load(memarg, ir::Opcode::Uload16, I64, builder, state, environ)?
+            );
         }
         Operator::I64Load8S { memarg } => {
-            translate_load(memarg, ir::Opcode::Sload8, I64, builder, state, environ)?;
+            unwrap_or_return_unreachable_state!(
+                state,
+                translate_load(memarg, ir::Opcode::Sload8, I64, builder, state, environ)?
+            );
         }
         Operator::I64Load16S { memarg } => {
-            translate_load(memarg, ir::Opcode::Sload16, I64, builder, state, environ)?;
+            unwrap_or_return_unreachable_state!(
+                state,
+                translate_load(memarg, ir::Opcode::Sload16, I64, builder, state, environ)?
+            );
         }
         Operator::I64Load32S { memarg } => {
-            translate_load(memarg, ir::Opcode::Sload32, I64, builder, state, environ)?;
+            unwrap_or_return_unreachable_state!(
+                state,
+                translate_load(memarg, ir::Opcode::Sload32, I64, builder, state, environ)?
+            );
         }
         Operator::I64Load32U { memarg } => {
-            translate_load(memarg, ir::Opcode::Uload32, I64, builder, state, environ)?;
+            unwrap_or_return_unreachable_state!(
+                state,
+                translate_load(memarg, ir::Opcode::Uload32, I64, builder, state, environ)?
+            );
         }
         Operator::I32Load { memarg } => {
-            translate_load(memarg, ir::Opcode::Load, I32, builder, state, environ)?;
+            unwrap_or_return_unreachable_state!(
+                state,
+                translate_load(memarg, ir::Opcode::Load, I32, builder, state, environ)?
+            );
         }
         Operator::F32Load { memarg } => {
-            translate_load(memarg, ir::Opcode::Load, F32, builder, state, environ)?;
+            unwrap_or_return_unreachable_state!(
+                state,
+                translate_load(memarg, ir::Opcode::Load, F32, builder, state, environ)?
+            );
         }
         Operator::I64Load { memarg } => {
-            translate_load(memarg, ir::Opcode::Load, I64, builder, state, environ)?;
+            unwrap_or_return_unreachable_state!(
+                state,
+                translate_load(memarg, ir::Opcode::Load, I64, builder, state, environ)?
+            );
         }
         Operator::F64Load { memarg } => {
-            translate_load(memarg, ir::Opcode::Load, F64, builder, state, environ)?;
+            unwrap_or_return_unreachable_state!(
+                state,
+                translate_load(memarg, ir::Opcode::Load, F64, builder, state, environ)?
+            );
         }
         Operator::V128Load { memarg } => {
-            translate_load(memarg, ir::Opcode::Load, I8X16, builder, state, environ)?;
+            unwrap_or_return_unreachable_state!(
+                state,
+                translate_load(memarg, ir::Opcode::Load, I8X16, builder, state, environ)?
+            );
         }
         Operator::V128Load8x8S { memarg } => {
-            let (flags, base, offset) = prepare_load(memarg, 8, builder, state, environ)?;
-            let loaded = builder.ins().sload8x8(flags, base, offset);
+            //TODO(#6829): add before_load() and before_store() hooks for SIMD loads and stores.
+            let (flags, _, base) = unwrap_or_return_unreachable_state!(
+                state,
+                prepare_addr(memarg, 8, builder, state, environ)?
+            );
+            let loaded = builder.ins().sload8x8(flags, base, 0);
             state.push1(loaded);
         }
         Operator::V128Load8x8U { memarg } => {
-            let (flags, base, offset) = prepare_load(memarg, 8, builder, state, environ)?;
-            let loaded = builder.ins().uload8x8(flags, base, offset);
+            let (flags, _, base) = unwrap_or_return_unreachable_state!(
+                state,
+                prepare_addr(memarg, 8, builder, state, environ)?
+            );
+            let loaded = builder.ins().uload8x8(flags, base, 0);
             state.push1(loaded);
         }
         Operator::V128Load16x4S { memarg } => {
-            let (flags, base, offset) = prepare_load(memarg, 8, builder, state, environ)?;
-            let loaded = builder.ins().sload16x4(flags, base, offset);
+            let (flags, _, base) = unwrap_or_return_unreachable_state!(
+                state,
+                prepare_addr(memarg, 8, builder, state, environ)?
+            );
+            let loaded = builder.ins().sload16x4(flags, base, 0);
             state.push1(loaded);
         }
         Operator::V128Load16x4U { memarg } => {
-            let (flags, base, offset) = prepare_load(memarg, 8, builder, state, environ)?;
-            let loaded = builder.ins().uload16x4(flags, base, offset);
+            let (flags, _, base) = unwrap_or_return_unreachable_state!(
+                state,
+                prepare_addr(memarg, 8, builder, state, environ)?
+            );
+            let loaded = builder.ins().uload16x4(flags, base, 0);
             state.push1(loaded);
         }
         Operator::V128Load32x2S { memarg } => {
-            let (flags, base, offset) = prepare_load(memarg, 8, builder, state, environ)?;
-            let loaded = builder.ins().sload32x2(flags, base, offset);
+            let (flags, _, base) = unwrap_or_return_unreachable_state!(
+                state,
+                prepare_addr(memarg, 8, builder, state, environ)?
+            );
+            let loaded = builder.ins().sload32x2(flags, base, 0);
             state.push1(loaded);
         }
         Operator::V128Load32x2U { memarg } => {
-            let (flags, base, offset) = prepare_load(memarg, 8, builder, state, environ)?;
-            let loaded = builder.ins().uload32x2(flags, base, offset);
+            let (flags, _, base) = unwrap_or_return_unreachable_state!(
+                state,
+                prepare_addr(memarg, 8, builder, state, environ)?
+            );
+            let loaded = builder.ins().uload32x2(flags, base, 0);
             state.push1(loaded);
         }
         /****************************** Store instructions ***********************************
@@ -743,7 +858,9 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
             translate_store(memarg, ir::Opcode::Store, builder, state, environ)?;
         }
         /****************************** Nullary Operators ************************************/
-        Operator::I32Const { value } => state.push1(builder.ins().iconst(I32, i64::from(*value))),
+        Operator::I32Const { value } => {
+            state.push1(builder.ins().iconst(I32, *value as u32 as i64))
+        }
         Operator::I64Const { value } => state.push1(builder.ins().iconst(I64, *value)),
         Operator::F32Const { value } => {
             state.push1(builder.ins().f32const(f32_translation(*value)));
@@ -1356,56 +1473,43 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
             environ.translate_data_drop(builder.cursor(), *data_index)?;
         }
         Operator::TableSize { table: index } => {
-            let table = state.get_or_create_table(builder.func, *index, environ)?;
-            state.push1(environ.translate_table_size(
-                builder.cursor(),
-                TableIndex::from_u32(*index),
-                table,
-            )?);
+            state.push1(
+                environ.translate_table_size(builder.cursor(), TableIndex::from_u32(*index))?,
+            );
         }
         Operator::TableGrow { table: index } => {
             let table_index = TableIndex::from_u32(*index);
-            let table = state.get_or_create_table(builder.func, *index, environ)?;
             let delta = state.pop1();
             let init_value = state.pop1();
             state.push1(environ.translate_table_grow(
                 builder.cursor(),
                 table_index,
-                table,
                 delta,
                 init_value,
             )?);
         }
         Operator::TableGet { table: index } => {
             let table_index = TableIndex::from_u32(*index);
-            let table = state.get_or_create_table(builder.func, *index, environ)?;
             let index = state.pop1();
-            state.push1(environ.translate_table_get(builder, table_index, table, index)?);
+            state.push1(environ.translate_table_get(builder, table_index, index)?);
         }
         Operator::TableSet { table: index } => {
             let table_index = TableIndex::from_u32(*index);
-            let table = state.get_or_create_table(builder.func, *index, environ)?;
-            // We don't touch the ref count here because we're passing it to the host
-            // then dropping it from the stack. Thus 1 + -1 = 0.
             let value = state.pop1();
             let index = state.pop1();
-            environ.translate_table_set(builder, table_index, table, value, index)?;
+            environ.translate_table_set(builder, table_index, value, index)?;
         }
         Operator::TableCopy {
             dst_table: dst_table_index,
             src_table: src_table_index,
         } => {
-            let dst_table = state.get_or_create_table(builder.func, *dst_table_index, environ)?;
-            let src_table = state.get_or_create_table(builder.func, *src_table_index, environ)?;
             let len = state.pop1();
             let src = state.pop1();
             let dest = state.pop1();
             environ.translate_table_copy(
                 builder.cursor(),
                 TableIndex::from_u32(*dst_table_index),
-                dst_table,
                 TableIndex::from_u32(*src_table_index),
-                src_table,
                 dest,
                 src,
                 len,
@@ -1422,7 +1526,6 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
             elem_index,
             table: table_index,
         } => {
-            let table = state.get_or_create_table(builder.func, *table_index, environ)?;
             let len = state.pop1();
             let src = state.pop1();
             let dest = state.pop1();
@@ -1430,7 +1533,6 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
                 builder.cursor(),
                 *elem_index,
                 TableIndex::from_u32(*table_index),
-                table,
                 dest,
                 src,
                 len,
@@ -1463,26 +1565,32 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         | Operator::V128Load16Splat { memarg }
         | Operator::V128Load32Splat { memarg }
         | Operator::V128Load64Splat { memarg } => {
-            translate_load(
-                memarg,
-                ir::Opcode::Load,
-                type_of(op).lane_type(),
-                builder,
+            unwrap_or_return_unreachable_state!(
                 state,
-                environ,
-            )?;
+                translate_load(
+                    memarg,
+                    ir::Opcode::Load,
+                    type_of(op).lane_type(),
+                    builder,
+                    state,
+                    environ,
+                )?
+            );
             let splatted = builder.ins().splat(type_of(op), state.pop1());
             state.push1(splatted)
         }
         Operator::V128Load32Zero { memarg } | Operator::V128Load64Zero { memarg } => {
-            translate_load(
-                memarg,
-                ir::Opcode::Load,
-                type_of(op).lane_type(),
-                builder,
+            unwrap_or_return_unreachable_state!(
                 state,
-                environ,
-            )?;
+                translate_load(
+                    memarg,
+                    ir::Opcode::Load,
+                    type_of(op).lane_type(),
+                    builder,
+                    state,
+                    environ,
+                )?
+            );
             let as_vector = builder.ins().scalar_to_vector(type_of(op), state.pop1());
             state.push1(as_vector)
         }
@@ -1491,14 +1599,17 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         | Operator::V128Load32Lane { memarg, lane }
         | Operator::V128Load64Lane { memarg, lane } => {
             let vector = pop1_with_bitcast(state, type_of(op), builder);
-            translate_load(
-                memarg,
-                ir::Opcode::Load,
-                type_of(op).lane_type(),
-                builder,
+            unwrap_or_return_unreachable_state!(
                 state,
-                environ,
-            )?;
+                translate_load(
+                    memarg,
+                    ir::Opcode::Load,
+                    type_of(op).lane_type(),
+                    builder,
+                    state,
+                    environ,
+                )?
+            );
             let replacement = state.pop1();
             state.push1(builder.ins().insertlane(vector, replacement, *lane))
         }
@@ -1558,7 +1669,7 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         }
         Operator::I8x16Swizzle => {
             let (a, b) = pop2_with_bitcast(state, I8X16, builder);
-            state.push1(builder.ins().swizzle(I8X16, a, b))
+            state.push1(builder.ins().swizzle(a, b))
         }
         Operator::I8x16Add | Operator::I16x8Add | Operator::I32x4Add | Operator::I64x2Add => {
             let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
@@ -1768,12 +1879,29 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
             state.push1(builder.ins().fmin(a, b))
         }
         Operator::F32x4PMax | Operator::F64x2PMax => {
-            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
-            state.push1(builder.ins().fmax_pseudo(a, b))
+            // Note the careful ordering here with respect to `fcmp` and
+            // `bitselect`. This matches the spec definition of:
+            //
+            //  fpmax(z1, z2) =
+            //      * If z1 is less than z2 then return z2.
+            //      * Else return z1.
+            let ty = type_of(op);
+            let (a, b) = pop2_with_bitcast(state, ty, builder);
+            let cmp = builder.ins().fcmp(FloatCC::LessThan, a, b);
+            let cmp = optionally_bitcast_vector(cmp, ty, builder);
+            state.push1(builder.ins().bitselect(cmp, b, a))
         }
         Operator::F32x4PMin | Operator::F64x2PMin => {
-            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
-            state.push1(builder.ins().fmin_pseudo(a, b))
+            // Note the careful ordering here which is similar to `pmax` above:
+            //
+            //  fpmin(z1, z2) =
+            //      * If z2 is less than z1 then return z2.
+            //      * Else return z1.
+            let ty = type_of(op);
+            let (a, b) = pop2_with_bitcast(state, ty, builder);
+            let cmp = builder.ins().fcmp(FloatCC::LessThan, b, a);
+            let cmp = optionally_bitcast_vector(cmp, ty, builder);
+            state.push1(builder.ins().bitselect(cmp, b, a))
         }
         Operator::F32x4Sqrt | Operator::F64x2Sqrt => {
             let a = pop1_with_bitcast(state, type_of(op), builder);
@@ -1797,7 +1925,8 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         }
         Operator::F64x2ConvertLowI32x4S => {
             let a = pop1_with_bitcast(state, I32X4, builder);
-            state.push1(builder.ins().fcvt_low_from_sint(F64X2, a));
+            let widened_a = builder.ins().swiden_low(a);
+            state.push1(builder.ins().fcvt_from_sint(F64X2, widened_a));
         }
         Operator::F64x2ConvertLowI32x4U => {
             let a = pop1_with_bitcast(state, I32X4, builder);
@@ -1946,7 +2075,13 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         }
         Operator::I32x4DotI16x8S => {
             let (a, b) = pop2_with_bitcast(state, I16X8, builder);
-            state.push1(builder.ins().widening_pairwise_dot_product_s(a, b));
+            let alow = builder.ins().swiden_low(a);
+            let blow = builder.ins().swiden_low(b);
+            let low = builder.ins().imul(alow, blow);
+            let ahigh = builder.ins().swiden_high(a);
+            let bhigh = builder.ins().swiden_high(b);
+            let high = builder.ins().imul(ahigh, bhigh);
+            state.push1(builder.ins().iadd_pairwise(low, high));
         }
         Operator::I8x16Popcnt => {
             let arg = pop1_with_bitcast(state, type_of(op), builder);
@@ -2088,7 +2223,8 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         | Operator::AnyConvertExtern
         | Operator::ExternConvertAny
         | Operator::RefI31
-        | Operator::I31GetS
+        | Operator::RefI31Shared => todo!(),
+        Operator::I31GetS
         | Operator::I31GetU
         | Operator::MemoryDiscard { .. }
         | Operator::CallRef { .. }
@@ -2098,6 +2234,60 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         | Operator::BrOnNonNull { .. } => {
             return Err(wasm_unsupported!("GC proposal not (operator: {:?})", op));
         }
+        Operator::GlobalAtomicGet { .. }
+        | Operator::GlobalAtomicSet { .. }
+        | Operator::GlobalAtomicRmwAdd { .. }
+        | Operator::GlobalAtomicRmwSub { .. }
+        | Operator::GlobalAtomicRmwAnd { .. }
+        | Operator::GlobalAtomicRmwOr { .. }
+        | Operator::GlobalAtomicRmwXor { .. }
+        | Operator::GlobalAtomicRmwXchg { .. }
+        | Operator::GlobalAtomicRmwCmpxchg { .. } => {
+            return Err(wasm_unsupported!("Global atomics not supported yet!"))
+        }
+        Operator::TableAtomicGet { .. }
+        | Operator::TableAtomicSet { .. }
+        | Operator::TableAtomicRmwXchg { .. }
+        | Operator::TableAtomicRmwCmpxchg { .. } => {
+            return Err(wasm_unsupported!("Table atomics not supported yet!"))
+        }
+        Operator::StructAtomicGet { .. }
+        | Operator::StructAtomicGetS { .. }
+        | Operator::StructAtomicGetU { .. }
+        | Operator::StructAtomicSet { .. }
+        | Operator::StructAtomicRmwAdd { .. }
+        | Operator::StructAtomicRmwSub { .. }
+        | Operator::StructAtomicRmwAnd { .. }
+        | Operator::StructAtomicRmwOr { .. }
+        | Operator::StructAtomicRmwXor { .. }
+        | Operator::StructAtomicRmwXchg { .. }
+        | Operator::StructAtomicRmwCmpxchg { .. } => {
+            return Err(wasm_unsupported!("Table atomics not supported yet!"))
+        }
+        Operator::ArrayAtomicGet { .. }
+        | Operator::ArrayAtomicGetS { .. }
+        | Operator::ArrayAtomicGetU { .. }
+        | Operator::ArrayAtomicSet { .. }
+        | Operator::ArrayAtomicRmwAdd { .. }
+        | Operator::ArrayAtomicRmwSub { .. }
+        | Operator::ArrayAtomicRmwAnd { .. }
+        | Operator::ArrayAtomicRmwOr { .. }
+        | Operator::ArrayAtomicRmwXor { .. }
+        | Operator::ArrayAtomicRmwXchg { .. }
+        | Operator::ArrayAtomicRmwCmpxchg { .. } => {
+            return Err(wasm_unsupported!("Array atomics not supported yet!"))
+        }
+        Operator::ContNew { .. } => todo!(),
+        Operator::ContBind { .. } => todo!(),
+        Operator::Suspend { .. } => todo!(),
+        Operator::Resume { .. } => todo!(),
+        Operator::ResumeThrow { .. } => todo!(),
+        Operator::Switch { .. } => todo!(),
+        Operator::I64Add128 => todo!(),
+        Operator::I64Sub128 => todo!(),
+        Operator::I64MulWideS => todo!(),
+        Operator::I64MulWideU => todo!(),
+        _ => todo!(),
     };
     Ok(())
 }
@@ -2123,6 +2313,7 @@ fn translate_unreachable_operator<FE: FuncEnvironment + ?Sized>(
                 ir::Block::reserved_value(),
                 ElseData::NoElse {
                     branch_inst: ir::Inst::reserved_value(),
+                    placeholder: ir::Block::reserved_value(),
                 },
                 0,
                 0,
@@ -2150,7 +2341,10 @@ fn translate_unreachable_operator<FE: FuncEnvironment + ?Sized>(
                         state.reachable = true;
 
                         let else_block = match *else_data {
-                            ElseData::NoElse { branch_inst } => {
+                            ElseData::NoElse {
+                                branch_inst,
+                                placeholder,
+                            } => {
                                 let (params, _results) = module_translation_state
                                     .blocktype_params_results(&blocktype)?;
                                 let else_block =
@@ -2159,7 +2353,11 @@ fn translate_unreachable_operator<FE: FuncEnvironment + ?Sized>(
                                 frame.truncate_value_stack_to_else_params(&mut state.stack);
 
                                 // We change the target of the branch instruction.
-                                builder.change_jump_destination(branch_inst, else_block);
+                                builder.change_jump_destination(
+                                    branch_inst,
+                                    placeholder,
+                                    else_block,
+                                );
                                 builder.seal_block(else_block);
                                 else_block
                             }
@@ -2236,29 +2434,49 @@ fn translate_unreachable_operator<FE: FuncEnvironment + ?Sized>(
     Ok(())
 }
 
-/// Get the address+offset to use for a heap access.
-fn get_heap_addr(
-    heap: ir::Heap,
-    addr32: ir::Value,
-    offset: u32,
-    width: u32,
-    addr_ty: Type,
+/// This function is a generalized helper for validating that a wasm-supplied
+/// heap address is in-bounds.
+///
+/// This function takes a litany of parameters and requires that the *Wasm*
+/// address to be verified is at the top of the stack in `state`. This will
+/// generate necessary IR to validate that the heap address is correctly
+/// in-bounds, and various parameters are returned describing the valid *native*
+/// heap address if execution reaches that point.
+///
+/// Returns `None` when the Wasm access will unconditionally trap.
+///
+/// Returns `(flags, wasm_addr, native_addr)`.
+fn prepare_addr<FE>(
+    memarg: &MemArg,
+    access_size: u8,
     builder: &mut FunctionBuilder,
-) -> (ir::Value, i32) {
-    let offset_guard_size: u64 = builder.func.heaps[heap].offset_guard_size.into();
+    state: &mut FuncTranslationState,
+    environ: &mut FE,
+) -> WasmResult<Reachability<(MemFlags, Value, Value)>>
+where
+    FE: FuncEnvironment + ?Sized,
+{
+    let index = state.pop1();
+    let heap = state.get_heap(builder.func, memarg.memory, environ)?;
 
     // How exactly the bounds check is performed here and what it's performed
     // on is a bit tricky. Generally we want to rely on access violations (e.g.
     // segfaults) to generate traps since that means we don't have to bounds
     // check anything explicitly.
     //
-    // If we don't have a guard page of unmapped memory, though, then we can't
-    // rely on this trapping behavior through segfaults. Instead we need to
-    // bounds-check the entire memory access here which is everything from
+    // (1) If we don't have a guard page of unmapped memory, though, then we
+    // can't rely on this trapping behavior through segfaults. Instead we need
+    // to bounds-check the entire memory access here which is everything from
     // `addr32 + offset` to `addr32 + offset + width` (not inclusive). In this
-    // scenario our adjusted offset that we're checking is `offset + width`.
+    // scenario our adjusted offset that we're checking is `memarg.offset +
+    // access_size`. Note that we do saturating arithmetic here to avoid
+    // overflow. The addition here is in the 64-bit space, which means that
+    // we'll never overflow for 32-bit wasm but for 64-bit this is an issue. If
+    // our effective offset is u64::MAX though then it's impossible for for
+    // that to actually be a valid offset because otherwise the wasm linear
+    // memory would take all of the host memory!
     //
-    // If we have a guard page, however, then we can perform a further
+    // (2) If we have a guard page, however, then we can perform a further
     // optimization of the generated code by only checking multiples of the
     // offset-guard size to be more CSE-friendly. Knowing that we have at least
     // 1 page of a guard page we're then able to disregard the `width` since we
@@ -2291,66 +2509,175 @@ fn get_heap_addr(
     // in-bounds or will hit the guard page, meaning we'll get the desired
     // semantics we want.
     //
-    // As one final comment on the bits with the guard size here, another goal
-    // of this is to hit an optimization in `heap_addr` where if the heap size
-    // minus the offset is >= 4GB then bounds checks are 100% eliminated. This
-    // means that with huge guard regions (e.g. our 2GB default) most adjusted
-    // offsets we're checking here are zero. This means that we'll hit the fast
-    // path and emit zero conditional traps for bounds checks
-    let adjusted_offset = if offset_guard_size == 0 {
-        u64::from(offset) + u64::from(width)
-    } else {
-        assert!(width < 1024);
-        cmp::max(u64::from(offset) / offset_guard_size * offset_guard_size, 1)
+    // ---
+    //
+    // With all that in mind remember that the goal is to bounds check as few
+    // things as possible. To facilitate this the "fast path" is expected to be
+    // hit like so:
+    //
+    // * For wasm32, wasmtime defaults to 4gb "static" memories with 2gb guard
+    //   regions. This means that for all offsets <=2gb, we hit the optimized
+    //   case for `heap_addr` on static memories 4gb in size in cranelift's
+    //   legalization of `heap_addr`, eliding the bounds check entirely.
+    //
+    // * For wasm64 offsets <=2gb will generate a single `heap_addr`
+    //   instruction, but at this time all heaps are "dynamic" which means that
+    //   a single bounds check is forced. Ideally we'd do better here, but
+    //   that's the current state of affairs.
+    //
+    // Basically we assume that most configurations have a guard page and most
+    // offsets in `memarg` are <=2gb, which means we get the fast path of one
+    // `heap_addr` instruction plus a hardcoded i32-offset in memory-related
+    // instructions.
+    let heap = environ.heaps()[heap].clone();
+    let addr = match u32::try_from(memarg.offset) {
+        // If our offset fits within a u32, then we can place the it into the
+        // offset immediate of the `heap_addr` instruction.
+        Ok(offset) => bounds_checks::bounds_check_and_compute_addr(
+            builder,
+            environ,
+            &heap,
+            index,
+            offset,
+            access_size,
+        )?,
+
+        // If the offset doesn't fit within a u32, then we can't pass it
+        // directly into `heap_addr`.
+        //
+        // One reasonable question you might ask is "why not?". There's no
+        // fundamental reason why `heap_addr` *must* take a 32-bit offset. The
+        // reason this isn't done, though, is that blindly changing the offset
+        // to a 64-bit offset increases the size of the `InstructionData` enum
+        // in cranelift by 8 bytes (16 to 24). This can have significant
+        // performance implications so the conclusion when this was written was
+        // that we shouldn't do that.
+        //
+        // Without the ability to put the whole offset into the `heap_addr`
+        // instruction we need to fold the offset into the address itself with
+        // an unsigned addition. In doing so though we need to check for
+        // overflow because that would mean the address is out-of-bounds (wasm
+        // bounds checks happen on the effective 33 or 65 bit address once the
+        // offset is factored in).
+        //
+        // Once we have the effective address, offset already folded in, then
+        // `heap_addr` is used to verify that the address is indeed in-bounds.
+        //
+        // Note that this is generating what's likely to be at least two
+        // branches, one for the overflow and one for the bounds check itself.
+        // For now though that should hopefully be ok since 4gb+ offsets are
+        // relatively odd/rare. In the future if needed we can look into
+        // optimizing this more.
+        Err(_) => {
+            let offset = builder.ins().iconst(heap.index_type, memarg.offset as i64);
+            let adjusted_index =
+                builder
+                    .ins()
+                    .uadd_overflow_trap(index, offset, ir::TrapCode::HeapOutOfBounds);
+            bounds_checks::bounds_check_and_compute_addr(
+                builder,
+                environ,
+                &heap,
+                adjusted_index,
+                0,
+                access_size,
+            )?
+        }
     };
-    debug_assert!(adjusted_offset > 0); // want to bounds check at least 1 byte
-    let check_size = u32::try_from(adjusted_offset).unwrap_or(u32::MAX);
-    let base = builder
-        .ins()
-        .heap_addr(addr_ty, heap, addr32, 0u32, check_size as u8);
-
-    // Native load/store instructions take a signed `Offset32` immediate, so adjust the base
-    // pointer if necessary.
-    if offset > i32::MAX as u32 {
-        // Offset doesn't fit in the load/store instruction.
-        let adj = builder.ins().iadd_imm(base, i64::from(i32::MAX) + 1);
-        (adj, (offset - (i32::MAX as u32 + 1)) as i32)
-    } else {
-        (base, offset as i32)
+    let addr = match addr {
+        Reachability::Unreachable => return Ok(Reachability::Unreachable),
+        Reachability::Reachable(a) => a,
+    };
+
+    // Note that we don't set `is_aligned` here, even if the load instruction's
+    // alignment immediate may says it's aligned, because WebAssembly's
+    // immediate field is just a hint, while Cranelift's aligned flag needs a
+    // guarantee. WebAssembly memory accesses are always little-endian.
+    let mut flags = MemFlags::new();
+    flags.set_endianness(ir::Endianness::Little);
+
+    if heap.memory_type.is_some() {
+        // Proof-carrying code is enabled; check this memory access.
+        flags.set_checked();
     }
+
+    // The access occurs to the `heap` disjoint category of abstract
+    // state. This may allow alias analysis to merge redundant loads,
+    // etc. when heap accesses occur interleaved with other (table,
+    // vmctx, stack) accesses.
+    flags.set_alias_region(Some(ir::AliasRegion::Heap));
+
+    Ok(Reachability::Reachable((flags, index, addr)))
 }
 
-/// Prepare for a load; factors out common functionality between load and load_extend operations.
-fn prepare_load<FE: FuncEnvironment + ?Sized>(
+fn align_atomic_addr(
     memarg: &MemArg,
-    loaded_bytes: u32,
+    loaded_bytes: u8,
     builder: &mut FunctionBuilder,
     state: &mut FuncTranslationState,
-    environ: &mut FE,
-) -> WasmResult<(MemFlags, Value, Offset32)> {
-    let addr32 = state.pop1();
-
-    let heap = state.get_heap(builder.func, memarg.memory, environ)?;
-    let (base, offset) = get_heap_addr(
-        heap,
-        addr32,
-        memarg.offset as u32,
-        loaded_bytes,
-        environ.pointer_type(),
-        builder,
-    );
+) {
+    // Atomic addresses must all be aligned correctly, and for now we check
+    // alignment before we check out-of-bounds-ness. The order of this check may
+    // need to be updated depending on the outcome of the official threads
+    // proposal itself.
+    //
+    // Note that with an offset>0 we generate an `iadd_imm` where the result is
+    // thrown away after the offset check. This may truncate the offset and the
+    // result may overflow as well, but those conditions won't affect the
+    // alignment check itself. This can probably be optimized better and we
+    // should do so in the future as well.
+    if loaded_bytes > 1 {
+        let addr = state.pop1(); // "peek" via pop then push
+        state.push1(addr);
+        let effective_addr = if memarg.offset == 0 {
+            addr
+        } else {
+            builder
+                .ins()
+                .iadd_imm(addr, i64::from(memarg.offset as i32))
+        };
+        debug_assert!(loaded_bytes.is_power_of_two());
+        let misalignment = builder
+            .ins()
+            .band_imm(effective_addr, i64::from(loaded_bytes - 1));
+        let f = builder.ins().icmp_imm(IntCC::NotEqual, misalignment, 0);
+        builder.ins().trapnz(f, ir::TrapCode::HeapMisaligned);
+    }
+}
 
-    // Note that we don't set `is_aligned` here, even if the load instruction's
-    // alignment immediate says it's aligned, because WebAssembly's immediate
-    // field is just a hint, while Cranelift's aligned flag needs a guarantee.
-    // WebAssembly memory accesses are always little-endian.
-    let mut flags = MemFlags::new();
-    flags.set_endianness(ir::Endianness::Little);
+/// Like `prepare_addr` but for atomic accesses.
+///
+/// Returns `None` when the Wasm access will unconditionally trap.
+fn prepare_atomic_addr<FE: FuncEnvironment + ?Sized>(
+    memarg: &MemArg,
+    loaded_bytes: u8,
+    builder: &mut FunctionBuilder,
+    state: &mut FuncTranslationState,
+    environ: &mut FE,
+) -> WasmResult<Reachability<(MemFlags, Value, Value)>> {
+    align_atomic_addr(memarg, loaded_bytes, builder, state);
+    prepare_addr(memarg, loaded_bytes, builder, state, environ)
+}
 
-    Ok((flags, base, offset.into()))
+/// Like `Option<T>` but specifically for passing information about transitions
+/// from reachable to unreachable state and the like from callees to callers.
+///
+/// Marked `must_use` to force callers to update
+/// `FuncTranslationState::reachable` as necessary.
+#[derive(PartialEq, Eq)]
+#[must_use]
+pub enum Reachability<T> {
+    /// The Wasm execution state is reachable, here is a `T`.
+    Reachable(T),
+    /// The Wasm execution state has been determined to be statically
+    /// unreachable. It is the receiver of this value's responsibility to update
+    /// `FuncTranslationState::reachable` as necessary.
+    Unreachable,
 }
 
 /// Translate a load instruction.
+///
+/// Returns the execution state's reachability after the load is translated.
 fn translate_load<FE: FuncEnvironment + ?Sized>(
     memarg: &MemArg,
     opcode: ir::Opcode,
@@ -2358,17 +2685,21 @@ fn translate_load<FE: FuncEnvironment + ?Sized>(
     builder: &mut FunctionBuilder,
     state: &mut FuncTranslationState,
     environ: &mut FE,
-) -> WasmResult<()> {
-    let (flags, base, offset) = prepare_load(
-        memarg,
-        mem_op_size(opcode, result_ty),
-        builder,
-        state,
-        environ,
-    )?;
-    let (load, dfg) = builder.ins().Load(opcode, result_ty, flags, offset, base);
+) -> WasmResult<Reachability<()>> {
+    let mem_op_size = mem_op_size(opcode, result_ty);
+    let (flags, wasm_index, base) =
+        match prepare_addr(memarg, mem_op_size, builder, state, environ)? {
+            Reachability::Unreachable => return Ok(Reachability::Unreachable),
+            Reachability::Reachable((f, i, b)) => (f, i, b),
+        };
+
+    environ.before_load(builder, mem_op_size, wasm_index, memarg.offset);
+
+    let (load, dfg) = builder
+        .ins()
+        .Load(opcode, result_ty, flags, Offset32::new(0), base);
     state.push1(dfg.first_result(load));
-    Ok(())
+    Ok(Reachability::Reachable(()))
 }
 
 /// Translate a store instruction.
@@ -2379,34 +2710,30 @@ fn translate_store<FE: FuncEnvironment + ?Sized>(
     state: &mut FuncTranslationState,
     environ: &mut FE,
 ) -> WasmResult<()> {
-    let (addr32, val) = state.pop2();
+    let val = state.pop1();
     let val_ty = builder.func.dfg.value_type(val);
+    let mem_op_size = mem_op_size(opcode, val_ty);
 
-    let heap = state.get_heap(builder.func, memarg.memory, environ)?;
-    let (base, offset) = get_heap_addr(
-        heap,
-        addr32,
-        memarg.offset as u32,
-        mem_op_size(opcode, val_ty),
-        environ.pointer_type(),
-        builder,
+    let (flags, wasm_index, base) = unwrap_or_return_unreachable_state!(
+        state,
+        prepare_addr(memarg, mem_op_size, builder, state, environ)?
     );
-    // See the comments in `prepare_load` about the flags.
-    let mut flags = MemFlags::new();
-    flags.set_endianness(ir::Endianness::Little);
+
+    environ.before_store(builder, mem_op_size, wasm_index, memarg.offset);
+
     builder
         .ins()
-        .Store(opcode, val_ty, flags, offset.into(), val, base);
+        .Store(opcode, val_ty, flags, Offset32::new(0), val, base);
     Ok(())
 }
 
-fn mem_op_size(opcode: ir::Opcode, ty: Type) -> u32 {
+fn mem_op_size(opcode: ir::Opcode, ty: Type) -> u8 {
     match opcode {
         ir::Opcode::Istore8 | ir::Opcode::Sload8 | ir::Opcode::Uload8 => 1,
         ir::Opcode::Istore16 | ir::Opcode::Sload16 | ir::Opcode::Uload16 => 2,
         ir::Opcode::Istore32 | ir::Opcode::Sload32 | ir::Opcode::Uload32 => 4,
-        ir::Opcode::Store | ir::Opcode::Load => ty.bytes(),
-        _ => panic!("unknown size of mem op for {:?}", opcode),
+        ir::Opcode::Store | ir::Opcode::Load => u8::try_from(ty.bytes()).unwrap(),
+        _ => panic!("unknown size of mem op for {opcode:?}"),
     }
 }
 
@@ -2448,58 +2775,6 @@ fn fold_atomic_mem_addr(
     final_lma
 }
 
-// For an atomic memory operation, emit an alignment check for the linear memory address,
-// and then compute the final effective address.
-fn finalise_atomic_mem_addr<FE: FuncEnvironment + ?Sized>(
-    linear_mem_addr: Value,
-    memarg: &MemArg,
-    access_ty: Type,
-    builder: &mut FunctionBuilder,
-    state: &mut FuncTranslationState,
-    environ: &mut FE,
-) -> WasmResult<Value> {
-    let access_ty_bytes = access_ty.bytes();
-    let final_lma = if memarg.offset > 0 {
-        assert!(builder.func.dfg.value_type(linear_mem_addr) == I32);
-        let linear_mem_addr = builder.ins().uextend(I64, linear_mem_addr);
-        let a = builder
-            .ins()
-            .iadd_imm(linear_mem_addr, memarg.offset as i64);
-        let r = builder
-            .ins()
-            .icmp_imm(IntCC::UnsignedGreaterThanOrEqual, a, 0x1_0000_0000i64);
-        builder.ins().trapnz(r, ir::TrapCode::HeapOutOfBounds);
-        builder.ins().ireduce(I32, a)
-    } else {
-        linear_mem_addr
-    };
-    // Check the alignment of `linear_mem_addr`.
-    if access_ty_bytes != 1 {
-        assert!(access_ty_bytes == 2 || access_ty_bytes == 4 || access_ty_bytes == 8);
-        let final_lma_misalignment = builder
-            .ins()
-            .band_imm(final_lma, i64::from(access_ty_bytes - 1));
-        let f = builder
-            .ins()
-            .icmp_imm(IntCC::Equal, final_lma_misalignment, i64::from(0));
-        builder.ins().trapz(f, ir::TrapCode::HeapMisaligned);
-    }
-
-    // Compute the final effective address.
-    let heap = state.get_heap(builder.func, memarg.memory, environ)?;
-    let (base, offset) = get_heap_addr(
-        heap,
-        final_lma,
-        /*offset=*/ 0,
-        access_ty.bytes(),
-        environ.pointer_type(),
-        builder,
-    );
-
-    let final_effective_address = builder.ins().iadd_imm(base, i64::from(offset));
-    Ok(final_effective_address)
-}
-
 fn translate_atomic_rmw<FE: FuncEnvironment + ?Sized>(
     widened_ty: Type,
     access_ty: Type,
@@ -2509,7 +2784,7 @@ fn translate_atomic_rmw<FE: FuncEnvironment + ?Sized>(
     state: &mut FuncTranslationState,
     environ: &mut FE,
 ) -> WasmResult<()> {
-    let (linear_mem_addr, mut arg2) = state.pop2();
+    let mut arg2 = state.pop1();
     let arg2_ty = builder.func.dfg.value_type(arg2);
 
     // The operation is performed at type `access_ty`, and the old value is zero-extended
@@ -2531,22 +2806,24 @@ fn translate_atomic_rmw<FE: FuncEnvironment + ?Sized>(
         arg2 = builder.ins().ireduce(access_ty, arg2);
     }
 
-    let final_effective_address =
-        finalise_atomic_mem_addr(linear_mem_addr, memarg, access_ty, builder, state, environ)?;
+    let (flags, _, addr) = unwrap_or_return_unreachable_state!(
+        state,
+        prepare_atomic_addr(
+            memarg,
+            u8::try_from(access_ty.bytes()).unwrap(),
+            builder,
+            state,
+            environ,
+        )?
+    );
 
-    // See the comments in `prepare_load` about the flags.
-    let mut flags = MemFlags::new();
-    flags.set_endianness(ir::Endianness::Little);
-    let mut res = builder
-        .ins()
-        .atomic_rmw(access_ty, flags, op, final_effective_address, arg2);
+    let mut res = builder.ins().atomic_rmw(access_ty, flags, op, addr, arg2);
     if access_ty != widened_ty {
         res = builder.ins().uextend(widened_ty, res);
     }
     state.push1(res);
     Ok(())
 }
-
 fn translate_atomic_cas<FE: FuncEnvironment + ?Sized>(
     widened_ty: Type,
     access_ty: Type,
@@ -2555,7 +2832,7 @@ fn translate_atomic_cas<FE: FuncEnvironment + ?Sized>(
     state: &mut FuncTranslationState,
     environ: &mut FE,
 ) -> WasmResult<()> {
-    let (linear_mem_addr, mut expected, mut replacement) = state.pop3();
+    let (mut expected, mut replacement) = state.pop2();
     let expected_ty = builder.func.dfg.value_type(expected);
     let replacement_ty = builder.func.dfg.value_type(replacement);
 
@@ -2582,15 +2859,17 @@ fn translate_atomic_cas<FE: FuncEnvironment + ?Sized>(
         replacement = builder.ins().ireduce(access_ty, replacement);
     }
 
-    let final_effective_address =
-        finalise_atomic_mem_addr(linear_mem_addr, memarg, access_ty, builder, state, environ)?;
-
-    // See the comments in `prepare_load` about the flags.
-    let mut flags = MemFlags::new();
-    flags.set_endianness(ir::Endianness::Little);
-    let mut res = builder
-        .ins()
-        .atomic_cas(flags, final_effective_address, expected, replacement);
+    let (flags, _, addr) = unwrap_or_return_unreachable_state!(
+        state,
+        prepare_atomic_addr(
+            memarg,
+            u8::try_from(access_ty.bytes()).unwrap(),
+            builder,
+            state,
+            environ,
+        )?
+    );
+    let mut res = builder.ins().atomic_cas(flags, addr, expected, replacement);
     if access_ty != widened_ty {
         res = builder.ins().uextend(widened_ty, res);
     }
@@ -2606,8 +2885,6 @@ fn translate_atomic_load<FE: FuncEnvironment + ?Sized>(
     state: &mut FuncTranslationState,
     environ: &mut FE,
 ) -> WasmResult<()> {
-    let linear_mem_addr = state.pop1();
-
     // The load is performed at type `access_ty`, and the loaded value is zero extended
     // to `widened_ty`.
     match access_ty {
@@ -2622,15 +2899,17 @@ fn translate_atomic_load<FE: FuncEnvironment + ?Sized>(
     let w_ty_ok = matches!(widened_ty, I32 | I64);
     assert!(w_ty_ok && widened_ty.bytes() >= access_ty.bytes());
 
-    let final_effective_address =
-        finalise_atomic_mem_addr(linear_mem_addr, memarg, access_ty, builder, state, environ)?;
-
-    // See the comments in `prepare_load` about the flags.
-    let mut flags = MemFlags::new();
-    flags.set_endianness(ir::Endianness::Little);
-    let mut res = builder
-        .ins()
-        .atomic_load(access_ty, flags, final_effective_address);
+    let (flags, _, addr) = unwrap_or_return_unreachable_state!(
+        state,
+        prepare_atomic_addr(
+            memarg,
+            u8::try_from(access_ty.bytes()).unwrap(),
+            builder,
+            state,
+            environ,
+        )?
+    );
+    let mut res = builder.ins().atomic_load(access_ty, flags, addr);
     if access_ty != widened_ty {
         res = builder.ins().uextend(widened_ty, res);
     }
@@ -2645,7 +2924,7 @@ fn translate_atomic_store<FE: FuncEnvironment + ?Sized>(
     state: &mut FuncTranslationState,
     environ: &mut FE,
 ) -> WasmResult<()> {
-    let (linear_mem_addr, mut data) = state.pop2();
+    let mut data = state.pop1();
     let data_ty = builder.func.dfg.value_type(data);
 
     // The operation is performed at type `access_ty`, and the data to be stored may first
@@ -2666,15 +2945,17 @@ fn translate_atomic_store<FE: FuncEnvironment + ?Sized>(
         data = builder.ins().ireduce(access_ty, data);
     }
 
-    let final_effective_address =
-        finalise_atomic_mem_addr(linear_mem_addr, memarg, access_ty, builder, state, environ)?;
-
-    // See the comments in `prepare_load` about the flags.
-    let mut flags = MemFlags::new();
-    flags.set_endianness(ir::Endianness::Little);
-    builder
-        .ins()
-        .atomic_store(flags, data, final_effective_address);
+    let (flags, _, addr) = unwrap_or_return_unreachable_state!(
+        state,
+        prepare_atomic_addr(
+            memarg,
+            u8::try_from(access_ty.bytes()).unwrap(),
+            builder,
+            state,
+            environ,
+        )?
+    );
+    builder.ins().atomic_store(flags, data, addr);
     Ok(())
 }
 
@@ -2715,10 +2996,9 @@ fn translate_br_if(
 ) {
     let val = state.pop1();
     let (br_destination, inputs) = translate_br_if_args(relative_depth, state);
-    canonicalise_then_brnz(builder, val, br_destination, inputs);
-
     let next_block = builder.create_block();
-    canonicalise_then_jump(builder, next_block, &[]);
+    canonicalise_brif(builder, val, br_destination, inputs, next_block, &[]);
+
     builder.seal_block(next_block); // The only predecessor is the current block.
     builder.switch_to_block(next_block);
 }
@@ -3020,28 +3300,28 @@ fn canonicalise_then_jump(
     builder.ins().jump(destination, canonicalised)
 }
 
-/// The same but for a `brz` instruction.
-fn canonicalise_then_brz(
-    builder: &mut FunctionBuilder,
-    cond: ir::Value,
-    destination: ir::Block,
-    params: &[ir::Value],
-) -> ir::Inst {
-    let mut tmp_canonicalised = SmallVec::<[ir::Value; 16]>::new();
-    let canonicalised = canonicalise_v128_values(&mut tmp_canonicalised, builder, params);
-    builder.ins().brz(cond, destination, canonicalised)
-}
-
-/// The same but for a `brnz` instruction.
-fn canonicalise_then_brnz(
+/// The same but for a `brif` instruction.
+fn canonicalise_brif(
     builder: &mut FunctionBuilder,
     cond: ir::Value,
-    destination: ir::Block,
-    params: &[ir::Value],
+    block_then: ir::Block,
+    params_then: &[ir::Value],
+    block_else: ir::Block,
+    params_else: &[ir::Value],
 ) -> ir::Inst {
-    let mut tmp_canonicalised = SmallVec::<[ir::Value; 16]>::new();
-    let canonicalised = canonicalise_v128_values(&mut tmp_canonicalised, builder, params);
-    builder.ins().brnz(cond, destination, canonicalised)
+    let mut tmp_canonicalised_then = SmallVec::<[ir::Value; 16]>::new();
+    let canonicalised_then =
+        canonicalise_v128_values(&mut tmp_canonicalised_then, builder, params_then);
+    let mut tmp_canonicalised_else = SmallVec::<[ir::Value; 16]>::new();
+    let canonicalised_else =
+        canonicalise_v128_values(&mut tmp_canonicalised_else, builder, params_else);
+    builder.ins().brif(
+        cond,
+        block_then,
+        canonicalised_then,
+        block_else,
+        canonicalised_else,
+    )
 }
 
 /// A helper for popping and bitcasting a single value; since SIMD values can lose their type by
@@ -3069,40 +3349,79 @@ fn pop2_with_bitcast(
     (bitcast_a, bitcast_b)
 }
 
-/// A helper for bitcasting a sequence of values (e.g. function arguments). If a value is a
-/// vector type that does not match its expected type, this will modify the value in place to point
-/// to the result of a `raw_bitcast`. This conversion is necessary to translate Wasm code that
-/// uses `V128` as function parameters (or implicitly in block parameters) and still use specific
-/// CLIF types (e.g. `I32X4`) in the function body.
-pub fn bitcast_arguments(
-    arguments: &mut [Value],
-    expected_types: &[Type],
-    builder: &mut FunctionBuilder,
-) {
-    assert_eq!(arguments.len(), expected_types.len());
-    for (i, t) in expected_types.iter().enumerate() {
-        if t.is_vector() {
+pub fn bitcast_arguments<'a>(
+    builder: &FunctionBuilder,
+    arguments: &'a mut [Value],
+    params: &[ir::AbiParam],
+    param_predicate: impl Fn(usize) -> bool,
+) -> Vec<(Type, &'a mut Value)> {
+    let filtered_param_types = params
+        .iter()
+        .enumerate()
+        .filter(|(i, _)| param_predicate(*i))
+        .map(|(_, param)| param.value_type);
+
+    // zip_eq, from the itertools::Itertools trait, is like Iterator::zip but panics if one
+    // iterator ends before the other. The `param_predicate` is required to select exactly as many
+    // elements of `params` as there are elements in `arguments`.
+    let pairs = filtered_param_types.zip_eq(arguments.iter_mut());
+
+    // The arguments which need to be bitcasted are those which have some vector type but the type
+    // expected by the parameter is not the same vector type as that of the provided argument.
+    pairs
+        .filter(|(param_type, _)| param_type.is_vector())
+        .filter(|(param_type, arg)| {
+            let arg_type = builder.func.dfg.value_type(**arg);
             assert!(
-                builder.func.dfg.value_type(arguments[i]).is_vector(),
+                arg_type.is_vector(),
                 "unexpected type mismatch: expected {}, argument {} was actually of type {}",
-                t,
-                arguments[i],
-                builder.func.dfg.value_type(arguments[i])
+                param_type,
+                *arg,
+                arg_type
             );
-            arguments[i] = optionally_bitcast_vector(arguments[i], *t, builder)
-        }
+
+            // This is the same check that would be done by `optionally_bitcast_vector`, except we
+            // can't take a mutable borrow of the FunctionBuilder here, so we defer inserting the
+            // bitcast instruction to the caller.
+            arg_type != *param_type
+        })
+        .collect()
+}
+
+/// A helper for bitcasting a sequence of return values for the function currently being built. If
+/// a value is a vector type that does not match its expected type, this will modify the value in
+/// place to point to the result of a `bitcast`. This conversion is necessary to translate Wasm
+/// code that uses `V128` as function parameters (or implicitly in block parameters) and still use
+/// specific CLIF types (e.g. `I32X4`) in the function body.
+pub fn bitcast_wasm_returns<FE: FuncEnvironment + ?Sized>(
+    environ: &mut FE,
+    arguments: &mut [Value],
+    builder: &mut FunctionBuilder,
+) {
+    let changes = bitcast_arguments(builder, arguments, &builder.func.signature.returns, |i| {
+        environ.is_wasm_return(&builder.func.signature, i)
+    });
+    for (t, arg) in changes {
+        let mut flags = MemFlags::new();
+        flags.set_endianness(ir::Endianness::Little);
+        *arg = builder.ins().bitcast(t, flags, *arg);
     }
 }
 
-/// A helper to extract all the `Type` listings of each variable in `params`
-/// for only parameters the return true for `is_wasm`, typically paired with
-/// `is_wasm_return` or `is_wasm_parameter`.
-pub fn wasm_param_types(params: &[ir::AbiParam], is_wasm: impl Fn(usize) -> bool) -> Vec<Type> {
-    let mut ret = Vec::with_capacity(params.len());
-    for (i, param) in params.iter().enumerate() {
-        if is_wasm(i) {
-            ret.push(param.value_type);
-        }
+/// Like `bitcast_wasm_returns`, but for the parameters being passed to a specified callee.
+pub fn bitcast_wasm_params<FE: FuncEnvironment + ?Sized>(
+    environ: &mut FE,
+    callee_signature: ir::SigRef,
+    arguments: &mut [Value],
+    builder: &mut FunctionBuilder,
+) {
+    let callee_signature = &builder.func.dfg.signatures[callee_signature];
+    let changes = bitcast_arguments(builder, arguments, &callee_signature.params, |i| {
+        environ.is_wasm_parameter(callee_signature, i)
+    });
+    for (t, arg) in changes {
+        let mut flags = MemFlags::new();
+        flags.set_endianness(ir::Endianness::Little);
+        *arg = builder.ins().bitcast(t, flags, *arg);
     }
-    ret
 }
diff --git a/lib/compiler-cranelift/src/translator/code_translator/bounds_checks.rs b/lib/compiler-cranelift/src/translator/code_translator/bounds_checks.rs
new file mode 100644
index 0000000000..58b8c13c31
--- /dev/null
+++ b/lib/compiler-cranelift/src/translator/code_translator/bounds_checks.rs
@@ -0,0 +1,731 @@
+//! Implementation of Wasm to CLIF memory access translation.
+//!
+//! Given
+//!
+//! * a dynamic Wasm memory index operand,
+//! * a static offset immediate, and
+//! * a static access size,
+//!
+//! bounds check the memory access and translate it into a native memory access.
+//!
+//! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+//! !!!                                                                      !!!
+//! !!!    THIS CODE IS VERY SUBTLE, HAS MANY SPECIAL CASES, AND IS ALSO     !!!
+//! !!!   ABSOLUTELY CRITICAL FOR MAINTAINING THE SAFETY OF THE WASM HEAP    !!!
+//! !!!                             SANDBOX.                                 !!!
+//! !!!                                                                      !!!
+//! !!!    A good rule of thumb is to get two reviews on any substantive     !!!
+//! !!!                         changes in here.                             !!!
+//! !!!                                                                      !!!
+//! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+use super::Reachability;
+use crate::{
+    heap::{HeapData, HeapStyle},
+    translator::func_environ::FuncEnvironment,
+};
+use cranelift_codegen::{
+    cursor::{Cursor, FuncCursor},
+    ir::{self, condcodes::IntCC, InstBuilder, RelSourceLoc},
+    ir::{Expr, Fact},
+};
+use cranelift_frontend::FunctionBuilder;
+use wasmer_types::WasmResult;
+use Reachability::*;
+
+/// Helper used to emit bounds checks (as necessary) and compute the native
+/// address of a heap access.
+///
+/// Returns the `ir::Value` holding the native address of the heap access, or
+/// `None` if the heap access will unconditionally trap.
+pub fn bounds_check_and_compute_addr<Env>(
+    builder: &mut FunctionBuilder,
+    env: &mut Env,
+    heap: &HeapData,
+    // Dynamic operand indexing into the heap.
+    index: ir::Value,
+    // Static immediate added to the index.
+    offset: u32,
+    // Static size of the heap access.
+    access_size: u8,
+) -> WasmResult<Reachability<ir::Value>>
+where
+    Env: FuncEnvironment + ?Sized,
+{
+    let pointer_bit_width = u16::try_from(env.pointer_type().bits()).unwrap();
+    let orig_index = index;
+    let index = cast_index_to_pointer_ty(
+        index,
+        heap.index_type,
+        env.pointer_type(),
+        heap.memory_type.is_some(),
+        &mut builder.cursor(),
+    );
+    let offset_and_size = offset_plus_size(offset, access_size);
+    let spectre_mitigations_enabled = env.heap_access_spectre_mitigation();
+    let pcc = env.proof_carrying_code();
+
+    let host_page_size_log2 = env.target_config().page_size_align_log2;
+    let can_use_virtual_memory = heap.page_size_log2 >= host_page_size_log2;
+
+    let make_compare = |builder: &mut FunctionBuilder,
+                        compare_kind: IntCC,
+                        lhs: ir::Value,
+                        lhs_off: Option<i64>,
+                        rhs: ir::Value,
+                        rhs_off: Option<i64>| {
+        let result = builder.ins().icmp(compare_kind, lhs, rhs);
+        if pcc {
+            // Name the original value as a def of the SSA value;
+            // if the value was extended, name that as well with a
+            // dynamic range, overwriting the basic full-range
+            // fact that we previously put on the uextend.
+            builder.func.dfg.facts[orig_index] = Some(Fact::Def { value: orig_index });
+            if index != orig_index {
+                builder.func.dfg.facts[index] = Some(Fact::value(pointer_bit_width, orig_index));
+            }
+
+            // Create a fact on the LHS that is a "trivial symbolic
+            // fact": v1 has range v1+LHS_off..=v1+LHS_off
+            builder.func.dfg.facts[lhs] = Some(Fact::value_offset(
+                pointer_bit_width,
+                orig_index,
+                lhs_off.unwrap(),
+            ));
+            // If the RHS is a symbolic value (v1 or gv1), we can
+            // emit a Compare fact.
+            if let Some(rhs) = builder.func.dfg.facts[rhs]
+                .as_ref()
+                .and_then(|f| f.as_symbol())
+            {
+                builder.func.dfg.facts[result] = Some(Fact::Compare {
+                    kind: compare_kind,
+                    lhs: Expr::offset(&Expr::value(orig_index), lhs_off.unwrap()).unwrap(),
+                    rhs: Expr::offset(rhs, rhs_off.unwrap()).unwrap(),
+                });
+            }
+            // Likewise, if the RHS is a constant, we can emit a
+            // Compare fact.
+            if let Some(k) = builder.func.dfg.facts[rhs]
+                .as_ref()
+                .and_then(|f| f.as_const(pointer_bit_width))
+            {
+                builder.func.dfg.facts[result] = Some(Fact::Compare {
+                    kind: compare_kind,
+                    lhs: Expr::offset(&Expr::value(orig_index), lhs_off.unwrap()).unwrap(),
+                    rhs: Expr::constant((k as i64).checked_add(rhs_off.unwrap()).unwrap()),
+                });
+            }
+        }
+        result
+    };
+
+    // We need to emit code that will trap (or compute an address that will trap
+    // when accessed) if
+    //
+    //     index + offset + access_size > bound
+    //
+    // or if the `index + offset + access_size` addition overflows.
+    //
+    // Note that we ultimately want a 64-bit integer (we only target 64-bit
+    // architectures at the moment) and that `offset` is a `u32` and
+    // `access_size` is a `u8`. This means that we can add the latter together
+    // as `u64`s without fear of overflow, and we only have to be concerned with
+    // whether adding in `index` will overflow.
+    //
+    // Finally, the following right-hand sides of the matches do have a little
+    // bit of duplicated code across them, but I think writing it this way is
+    // worth it for readability and seeing very clearly each of our cases for
+    // different bounds checks and optimizations of those bounds checks. It is
+    // intentionally written in a straightforward case-matching style that will
+    // hopefully make it easy to port to ISLE one day.
+    Ok(match heap.style {
+        // ====== Dynamic Memories ======
+        //
+        // 1. First special case for when `offset + access_size == 1`:
+        //
+        //            index + 1 > bound
+        //        ==> index >= bound
+        HeapStyle::Dynamic { bound_gv } if offset_and_size == 1 => {
+            let bound = get_dynamic_heap_bound(builder, env, heap);
+            let oob = make_compare(
+                builder,
+                IntCC::UnsignedGreaterThanOrEqual,
+                index,
+                Some(0),
+                bound,
+                Some(0),
+            );
+            Reachable(explicit_check_oob_condition_and_compute_addr(
+                &mut builder.cursor(),
+                heap,
+                env.pointer_type(),
+                index,
+                offset,
+                access_size,
+                spectre_mitigations_enabled,
+                AddrPcc::dynamic(heap.memory_type, bound_gv),
+                oob,
+            ))
+        }
+
+        // 2. Second special case for when we know that there are enough guard
+        //    pages to cover the offset and access size.
+        //
+        //    The precise should-we-trap condition is
+        //
+        //        index + offset + access_size > bound
+        //
+        //    However, if we instead check only the partial condition
+        //
+        //        index > bound
+        //
+        //    then the most out of bounds that the access can be, while that
+        //    partial check still succeeds, is `offset + access_size`.
+        //
+        //    However, when we have a guard region that is at least as large as
+        //    `offset + access_size`, we can rely on the virtual memory
+        //    subsystem handling these out-of-bounds errors at
+        //    runtime. Therefore, the partial `index > bound` check is
+        //    sufficient for this heap configuration.
+        //
+        //    Additionally, this has the advantage that a series of Wasm loads
+        //    that use the same dynamic index operand but different static
+        //    offset immediates -- which is a common code pattern when accessing
+        //    multiple fields in the same struct that is in linear memory --
+        //    will all emit the same `index > bound` check, which we can GVN.
+        HeapStyle::Dynamic { bound_gv }
+            if can_use_virtual_memory && offset_and_size <= heap.offset_guard_size =>
+        {
+            let bound = get_dynamic_heap_bound(builder, env, heap);
+            let oob = make_compare(
+                builder,
+                IntCC::UnsignedGreaterThan,
+                index,
+                Some(0),
+                bound,
+                Some(0),
+            );
+            Reachable(explicit_check_oob_condition_and_compute_addr(
+                &mut builder.cursor(),
+                heap,
+                env.pointer_type(),
+                index,
+                offset,
+                access_size,
+                spectre_mitigations_enabled,
+                AddrPcc::dynamic(heap.memory_type, bound_gv),
+                oob,
+            ))
+        }
+
+        // 3. Third special case for when `offset + access_size <= min_size`.
+        //
+        //    We know that `bound >= min_size`, so we can do the following
+        //    comparison, without fear of the right-hand side wrapping around:
+        //
+        //            index + offset + access_size > bound
+        //        ==> index > bound - (offset + access_size)
+        HeapStyle::Dynamic { bound_gv } if offset_and_size <= heap.min_size => {
+            let bound = get_dynamic_heap_bound(builder, env, heap);
+            let adjustment = offset_and_size as i64;
+            let adjustment_value = builder.ins().iconst(env.pointer_type(), adjustment);
+            if pcc {
+                builder.func.dfg.facts[adjustment_value] =
+                    Some(Fact::constant(pointer_bit_width, offset_and_size));
+            }
+            let adjusted_bound = builder.ins().isub(bound, adjustment_value);
+            if pcc {
+                builder.func.dfg.facts[adjusted_bound] = Some(Fact::global_value_offset(
+                    pointer_bit_width,
+                    bound_gv,
+                    -adjustment,
+                ));
+            }
+            let oob = make_compare(
+                builder,
+                IntCC::UnsignedGreaterThan,
+                index,
+                Some(0),
+                adjusted_bound,
+                Some(adjustment),
+            );
+            Reachable(explicit_check_oob_condition_and_compute_addr(
+                &mut builder.cursor(),
+                heap,
+                env.pointer_type(),
+                index,
+                offset,
+                access_size,
+                spectre_mitigations_enabled,
+                AddrPcc::dynamic(heap.memory_type, bound_gv),
+                oob,
+            ))
+        }
+
+        // 4. General case for dynamic memories:
+        //
+        //        index + offset + access_size > bound
+        //
+        //    And we have to handle the overflow case in the left-hand side.
+        HeapStyle::Dynamic { bound_gv } => {
+            let access_size_val = builder
+                .ins()
+                // Explicit cast from u64 to i64: we just want the raw
+                // bits, and iconst takes an `Imm64`.
+                .iconst(env.pointer_type(), offset_and_size as i64);
+            if pcc {
+                builder.func.dfg.facts[access_size_val] =
+                    Some(Fact::constant(pointer_bit_width, offset_and_size));
+            }
+            let adjusted_index = builder.ins().uadd_overflow_trap(
+                index,
+                access_size_val,
+                ir::TrapCode::HeapOutOfBounds,
+            );
+            if pcc {
+                builder.func.dfg.facts[adjusted_index] = Some(Fact::value_offset(
+                    pointer_bit_width,
+                    index,
+                    i64::try_from(offset_and_size).unwrap(),
+                ));
+            }
+            let bound = get_dynamic_heap_bound(builder, env, heap);
+            let oob = make_compare(
+                builder,
+                IntCC::UnsignedGreaterThan,
+                adjusted_index,
+                i64::try_from(offset_and_size).ok(),
+                bound,
+                Some(0),
+            );
+            Reachable(explicit_check_oob_condition_and_compute_addr(
+                &mut builder.cursor(),
+                heap,
+                env.pointer_type(),
+                index,
+                offset,
+                access_size,
+                spectre_mitigations_enabled,
+                AddrPcc::dynamic(heap.memory_type, bound_gv),
+                oob,
+            ))
+        }
+
+        // ====== Static Memories ======
+        //
+        // With static memories we know the size of the heap bound at compile
+        // time.
+        //
+        // 1. First special case: trap immediately if `offset + access_size >
+        //    bound`, since we will end up being out-of-bounds regardless of the
+        //    given `index`.
+        HeapStyle::Static { bound } if offset_and_size > bound => {
+            assert!(
+                can_use_virtual_memory,
+                "static memories require the ability to use virtual memory"
+            );
+            env.before_unconditionally_trapping_memory_access(builder)?;
+            builder.ins().trap(ir::TrapCode::HeapOutOfBounds);
+            Unreachable
+        }
+
+        // 2. Second special case for when we can completely omit explicit
+        //    bounds checks for 32-bit static memories.
+        //
+        //    First, let's rewrite our comparison to move all of the constants
+        //    to one side:
+        //
+        //            index + offset + access_size > bound
+        //        ==> index > bound - (offset + access_size)
+        //
+        //    We know the subtraction on the right-hand side won't wrap because
+        //    we didn't hit the first special case.
+        //
+        //    Additionally, we add our guard pages (if any) to the right-hand
+        //    side, since we can rely on the virtual memory subsystem at runtime
+        //    to catch out-of-bound accesses within the range `bound .. bound +
+        //    guard_size`. So now we are dealing with
+        //
+        //        index > bound + guard_size - (offset + access_size)
+        //
+        //    Note that `bound + guard_size` cannot overflow for
+        //    correctly-configured heaps, as otherwise the heap wouldn't fit in
+        //    a 64-bit memory space.
+        //
+        //    The complement of our should-this-trap comparison expression is
+        //    the should-this-not-trap comparison expression:
+        //
+        //        index <= bound + guard_size - (offset + access_size)
+        //
+        //    If we know the right-hand side is greater than or equal to
+        //    `u32::MAX`, then
+        //
+        //        index <= u32::MAX <= bound + guard_size - (offset + access_size)
+        //
+        //    This expression is always true when the heap is indexed with
+        //    32-bit integers because `index` cannot be larger than
+        //    `u32::MAX`. This means that `index` is always either in bounds or
+        //    within the guard page region, neither of which require emitting an
+        //    explicit bounds check.
+        HeapStyle::Static { bound }
+            if can_use_virtual_memory
+                && heap.index_type == ir::types::I32
+                && u64::from(u32::MAX) <= bound + heap.offset_guard_size - offset_and_size =>
+        {
+            assert!(
+                can_use_virtual_memory,
+                "static memories require the ability to use virtual memory"
+            );
+            Reachable(compute_addr(
+                &mut builder.cursor(),
+                heap,
+                env.pointer_type(),
+                index,
+                offset,
+                AddrPcc::static32(heap.memory_type, bound + heap.offset_guard_size),
+            ))
+        }
+
+        // 3. General case for static memories.
+        //
+        //    We have to explicitly test whether
+        //
+        //        index > bound - (offset + access_size)
+        //
+        //    and trap if so.
+        //
+        //    Since we have to emit explicit bounds checks, we might as well be
+        //    precise, not rely on the virtual memory subsystem at all, and not
+        //    factor in the guard pages here.
+        HeapStyle::Static { bound } => {
+            assert!(
+                can_use_virtual_memory,
+                "static memories require the ability to use virtual memory"
+            );
+            // NB: this subtraction cannot wrap because we didn't hit the first
+            // special case.
+            let adjusted_bound = bound - offset_and_size;
+            let adjusted_bound_value = builder
+                .ins()
+                .iconst(env.pointer_type(), adjusted_bound as i64);
+            if pcc {
+                builder.func.dfg.facts[adjusted_bound_value] =
+                    Some(Fact::constant(pointer_bit_width, adjusted_bound));
+            }
+            let oob = make_compare(
+                builder,
+                IntCC::UnsignedGreaterThan,
+                index,
+                Some(0),
+                adjusted_bound_value,
+                Some(0),
+            );
+            Reachable(explicit_check_oob_condition_and_compute_addr(
+                &mut builder.cursor(),
+                heap,
+                env.pointer_type(),
+                index,
+                offset,
+                access_size,
+                spectre_mitigations_enabled,
+                AddrPcc::static32(heap.memory_type, bound),
+                oob,
+            ))
+        }
+    })
+}
+
+/// Get the bound of a dynamic heap as an `ir::Value`.
+fn get_dynamic_heap_bound<Env>(
+    builder: &mut FunctionBuilder,
+    env: &mut Env,
+    heap: &HeapData,
+) -> ir::Value
+where
+    Env: FuncEnvironment + ?Sized,
+{
+    let enable_pcc = heap.memory_type.is_some();
+
+    let (value, gv) = match (heap.max_size, &heap.style) {
+        // The heap has a constant size, no need to actually load the
+        // bound.  TODO: this is currently disabled for PCC because we
+        // can't easily prove that the GV load indeed results in a
+        // constant (that information is lost in the CLIF). We'll want
+        // to create an `iconst` GV expression kind to reify this fact
+        // in the GV, then re-enable this opt. (Or, alternately,
+        // compile such memories with a static-bound memtype and
+        // facts.)
+        (Some(max_size), HeapStyle::Dynamic { bound_gv })
+            if heap.min_size == max_size && !enable_pcc =>
+        {
+            (
+                builder.ins().iconst(env.pointer_type(), max_size as i64),
+                *bound_gv,
+            )
+        }
+
+        // Load the heap bound from its global variable.
+        (_, HeapStyle::Dynamic { bound_gv }) => (
+            builder.ins().global_value(env.pointer_type(), *bound_gv),
+            *bound_gv,
+        ),
+
+        (_, HeapStyle::Static { .. }) => unreachable!("not a dynamic heap"),
+    };
+
+    // If proof-carrying code is enabled, apply a fact to the range to
+    // tie it to the GV.
+    if enable_pcc {
+        builder.func.dfg.facts[value] = Some(Fact::global_value(
+            u16::try_from(env.pointer_type().bits()).unwrap(),
+            gv,
+        ));
+    }
+
+    value
+}
+
+fn cast_index_to_pointer_ty(
+    index: ir::Value,
+    index_ty: ir::Type,
+    pointer_ty: ir::Type,
+    pcc: bool,
+    pos: &mut FuncCursor,
+) -> ir::Value {
+    if index_ty == pointer_ty {
+        return index;
+    }
+    // Note that using 64-bit heaps on a 32-bit host is not currently supported,
+    // would require at least a bounds check here to ensure that the truncation
+    // from 64-to-32 bits doesn't lose any upper bits. For now though we're
+    // mostly interested in the 32-bit-heaps-on-64-bit-hosts cast.
+    assert!(index_ty.bits() < pointer_ty.bits());
+
+    // Convert `index` to `addr_ty`.
+    let extended_index = pos.ins().uextend(pointer_ty, index);
+
+    // Add a range fact on the extended value.
+    if pcc {
+        pos.func.dfg.facts[extended_index] = Some(Fact::max_range_for_width_extended(
+            u16::try_from(index_ty.bits()).unwrap(),
+            u16::try_from(pointer_ty.bits()).unwrap(),
+        ));
+    }
+
+    // Add debug value-label alias so that debuginfo can name the extended
+    // value as the address
+    let loc = pos.srcloc();
+    let loc = RelSourceLoc::from_base_offset(pos.func.params.base_srcloc(), loc);
+    pos.func
+        .stencil
+        .dfg
+        .add_value_label_alias(extended_index, loc, index);
+
+    extended_index
+}
+
+/// Which facts do we want to emit for proof-carrying code, if any, on
+/// address computations?
+#[derive(Clone, Copy, Debug)]
+enum AddrPcc {
+    /// A 32-bit static memory with the given size.
+    Static32(ir::MemoryType, u64),
+    /// Dynamic bounds-check, with actual memory size (the `GlobalValue`)
+    /// expressed symbolically.
+    Dynamic(ir::MemoryType, ir::GlobalValue),
+}
+impl AddrPcc {
+    fn static32(memory_type: Option<ir::MemoryType>, size: u64) -> Option<Self> {
+        memory_type.map(|ty| Self::Static32(ty, size))
+    }
+    fn dynamic(memory_type: Option<ir::MemoryType>, bound: ir::GlobalValue) -> Option<Self> {
+        memory_type.map(|ty| Self::Dynamic(ty, bound))
+    }
+}
+
+/// Emit explicit checks on the given out-of-bounds condition for the Wasm
+/// address and return the native address.
+///
+/// This function deduplicates explicit bounds checks and Spectre mitigations
+/// that inherently also implement bounds checking.
+#[allow(clippy::too_many_arguments)]
+fn explicit_check_oob_condition_and_compute_addr(
+    pos: &mut FuncCursor,
+    heap: &HeapData,
+    addr_ty: ir::Type,
+    index: ir::Value,
+    offset: u32,
+    access_size: u8,
+    // Whether Spectre mitigations are enabled for heap accesses.
+    spectre_mitigations_enabled: bool,
+    // Whether we're emitting PCC facts.
+    pcc: Option<AddrPcc>,
+    // The `i8` boolean value that is non-zero when the heap access is out of
+    // bounds (and therefore we should trap) and is zero when the heap access is
+    // in bounds (and therefore we can proceed).
+    oob_condition: ir::Value,
+) -> ir::Value {
+    if !spectre_mitigations_enabled {
+        pos.ins()
+            .trapnz(oob_condition, ir::TrapCode::HeapOutOfBounds);
+    }
+
+    let mut addr = compute_addr(pos, heap, addr_ty, index, offset, pcc);
+
+    if spectre_mitigations_enabled {
+        let null = pos.ins().iconst(addr_ty, 0);
+        addr = pos.ins().select_spectre_guard(oob_condition, null, addr);
+
+        match pcc {
+            None => {}
+            Some(AddrPcc::Static32(ty, size)) => {
+                pos.func.dfg.facts[null] =
+                    Some(Fact::constant(u16::try_from(addr_ty.bits()).unwrap(), 0));
+                pos.func.dfg.facts[addr] = Some(Fact::Mem {
+                    ty,
+                    min_offset: 0,
+                    max_offset: size.checked_sub(u64::from(access_size)).unwrap(),
+                    nullable: true,
+                });
+            }
+            Some(AddrPcc::Dynamic(ty, gv)) => {
+                pos.func.dfg.facts[null] =
+                    Some(Fact::constant(u16::try_from(addr_ty.bits()).unwrap(), 0));
+                pos.func.dfg.facts[addr] = Some(Fact::DynamicMem {
+                    ty,
+                    min: Expr::constant(0),
+                    max: Expr::offset(
+                        &Expr::global_value(gv),
+                        i64::try_from(heap.offset_guard_size)
+                            .unwrap()
+                            .checked_sub(i64::from(access_size))
+                            .unwrap(),
+                    )
+                    .unwrap(),
+                    nullable: true,
+                });
+            }
+        }
+    }
+
+    addr
+}
+
+/// Emit code for the native address computation of a Wasm address,
+/// without any bounds checks or overflow checks.
+///
+/// It is the caller's responsibility to ensure that any necessary bounds and
+/// overflow checks are emitted, and that the resulting address is never used
+/// unless they succeed.
+fn compute_addr(
+    pos: &mut FuncCursor,
+    heap: &HeapData,
+    addr_ty: ir::Type,
+    index: ir::Value,
+    offset: u32,
+    pcc: Option<AddrPcc>,
+) -> ir::Value {
+    debug_assert_eq!(pos.func.dfg.value_type(index), addr_ty);
+
+    let heap_base = pos.ins().global_value(addr_ty, heap.base);
+
+    match pcc {
+        None => {}
+        Some(AddrPcc::Static32(ty, _size)) => {
+            pos.func.dfg.facts[heap_base] = Some(Fact::Mem {
+                ty,
+                min_offset: 0,
+                max_offset: 0,
+                nullable: false,
+            });
+        }
+        Some(AddrPcc::Dynamic(ty, _limit)) => {
+            pos.func.dfg.facts[heap_base] = Some(Fact::dynamic_base_ptr(ty));
+        }
+    }
+
+    let base_and_index = pos.ins().iadd(heap_base, index);
+
+    match pcc {
+        None => {}
+        Some(AddrPcc::Static32(ty, _) | AddrPcc::Dynamic(ty, _)) => {
+            if let Some(idx) = pos.func.dfg.facts[index]
+                .as_ref()
+                .and_then(|f| f.as_symbol())
+                .cloned()
+            {
+                pos.func.dfg.facts[base_and_index] = Some(Fact::DynamicMem {
+                    ty,
+                    min: idx.clone(),
+                    max: idx,
+                    nullable: false,
+                });
+            } else {
+                pos.func.dfg.facts[base_and_index] = Some(Fact::Mem {
+                    ty,
+                    min_offset: 0,
+                    max_offset: u64::from(u32::MAX),
+                    nullable: false,
+                });
+            }
+        }
+    }
+
+    if offset == 0 {
+        base_and_index
+    } else {
+        // NB: The addition of the offset immediate must happen *before* the
+        // `select_spectre_guard`, if any. If it happens after, then we
+        // potentially are letting speculative execution read the whole first
+        // 4GiB of memory.
+        let offset_val = pos.ins().iconst(addr_ty, i64::from(offset));
+
+        if pcc.is_some() {
+            pos.func.dfg.facts[offset_val] = Some(Fact::constant(
+                u16::try_from(addr_ty.bits()).unwrap(),
+                u64::from(offset),
+            ));
+        }
+
+        let result = pos.ins().iadd(base_and_index, offset_val);
+
+        match pcc {
+            None => {}
+            Some(AddrPcc::Static32(ty, _) | AddrPcc::Dynamic(ty, _)) => {
+                if let Some(idx) = pos.func.dfg.facts[index]
+                    .as_ref()
+                    .and_then(|f| f.as_symbol())
+                {
+                    pos.func.dfg.facts[result] = Some(Fact::DynamicMem {
+                        ty,
+                        min: idx.clone(),
+                        // Safety: adding an offset to an expression with
+                        // zero offset -- add cannot wrap, so `unwrap()`
+                        // cannot fail.
+                        max: Expr::offset(idx, i64::from(offset)).unwrap(),
+                        nullable: false,
+                    });
+                } else {
+                    pos.func.dfg.facts[result] = Some(Fact::Mem {
+                        ty,
+                        min_offset: u64::from(offset),
+                        // Safety: can't overflow -- two u32s summed in a
+                        // 64-bit add. TODO: when memory64 is supported here,
+                        // `u32::MAX` is no longer true, and we'll need to
+                        // handle overflow here.
+                        max_offset: u64::from(u32::MAX) + u64::from(offset),
+                        nullable: false,
+                    });
+                }
+            }
+        }
+        result
+    }
+}
+
+#[inline]
+fn offset_plus_size(offset: u32, size: u8) -> u64 {
+    // Cannot overflow because we are widening to `u64`.
+    offset as u64 + size as u64
+}
diff --git a/lib/compiler-cranelift/src/translator/func_environ.rs b/lib/compiler-cranelift/src/translator/func_environ.rs
index ced49f84a3..a732a39ae0 100644
--- a/lib/compiler-cranelift/src/translator/func_environ.rs
+++ b/lib/compiler-cranelift/src/translator/func_environ.rs
@@ -6,6 +6,7 @@
 
 use super::func_state::FuncTranslationState;
 use super::translation_utils::reference_type;
+use crate::heap::{Heap, HeapData};
 use core::convert::From;
 use cranelift_codegen::cursor::FuncCursor;
 use cranelift_codegen::ir::immediates::Offset32;
@@ -13,6 +14,7 @@ use cranelift_codegen::ir::{self, InstBuilder};
 use cranelift_codegen::isa::TargetFrontendConfig;
 use cranelift_frontend::FunctionBuilder;
 use wasmer_compiler::wasmparser::{HeapType, Operator};
+use wasmer_types::entity::PrimaryMap;
 use wasmer_types::{
     FunctionIndex, FunctionType, GlobalIndex, LocalFunctionIndex, MemoryIndex, SignatureIndex,
     TableIndex, Type as WasmerType, WasmResult,
@@ -80,6 +82,12 @@ pub trait TargetEnvironment {
 /// IR. The function environment provides information about the WebAssembly module as well as the
 /// runtime environment.
 pub trait FuncEnvironment: TargetEnvironment {
+    /// Whether to enable Spectre mitigations for heap accesses.
+    fn heap_access_spectre_mitigation(&self) -> bool;
+
+    /// Whether to add proof-carrying-code facts to verify memory accesses.
+    fn proof_carrying_code(&self) -> bool;
+
     /// Is the given parameter of the given function a wasm-level parameter, as opposed to a hidden
     /// parameter added for use by the implementation?
     fn is_wasm_parameter(&self, signature: &ir::Signature, index: usize) -> bool {
@@ -112,17 +120,29 @@ pub trait FuncEnvironment: TargetEnvironment {
         index: GlobalIndex,
     ) -> WasmResult<GlobalVariable>;
 
-    /// Set up the necessary preamble definitions in `func` to access the linear memory identified
-    /// by `index`.
+    /// Inserts code before updating a global.
+    fn update_global(
+        &mut self,
+        _builder: &mut FunctionBuilder,
+        _global_index: u32,
+        _value: ir::Value,
+    ) {
+    }
+
+    /// Get the heaps for this function environment.
     ///
-    /// The index space covers both imported and locally declared memories.
-    fn make_heap(&mut self, func: &mut ir::Function, index: MemoryIndex) -> WasmResult<ir::Heap>;
+    /// The returned map should provide heap format details (encoded in
+    /// `HeapData`) for each `Heap` that was previously returned by
+    /// `make_heap()`. The translator will first call make_heap for each Wasm
+    /// memory, and then later when translating code, will invoke `heaps()` to
+    /// learn how to access the environment's implementation of each memory.
+    fn heaps(&self) -> &PrimaryMap<Heap, HeapData>;
 
-    /// Set up the necessary preamble definitions in `func` to access the table identified
+    /// Set up the necessary preamble definitions in `func` to access the linear memory identified
     /// by `index`.
     ///
-    /// The index space covers both imported and locally declared tables.
-    fn make_table(&mut self, func: &mut ir::Function, index: TableIndex) -> WasmResult<ir::Table>;
+    /// The index space covers both imported and locally declared memories.
+    fn make_heap(&mut self, func: &mut ir::Function, index: MemoryIndex) -> WasmResult<Heap>;
 
     /// Set up a signature definition in the preamble of `func` that can be used for an indirect
     /// call with signature `index`.
@@ -156,6 +176,23 @@ pub trait FuncEnvironment: TargetEnvironment {
         index: FunctionIndex,
     ) -> WasmResult<ir::FuncRef>;
 
+    /// Translate a `call` WebAssembly instruction at `pos`.
+    ///
+    /// Insert instructions at `pos` for a direct call to the function `callee_index`.
+    ///
+    /// The function reference `callee` was previously created by `make_direct_func()`.
+    ///
+    /// Return the call instruction whose results are the WebAssembly return values.
+    fn translate_call(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        _callee_index: FunctionIndex,
+        callee: ir::FuncRef,
+        call_args: &[ir::Value],
+    ) -> WasmResult<ir::Inst> {
+        Ok(builder.ins().call(callee, call_args))
+    }
+
     /// Translate a `call_indirect` WebAssembly instruction at `pos`.
     ///
     /// Insert instructions at `pos` for an indirect call to the function `callee` in the table
@@ -165,35 +202,18 @@ pub trait FuncEnvironment: TargetEnvironment {
     /// The signature `sig_ref` was previously created by `make_indirect_sig()`.
     ///
     /// Return the call instruction whose results are the WebAssembly return values.
-    #[allow(clippy::too_many_arguments)]
+    /// Returns `None` if this statically traps instead of creating a call
+    /// instruction.
     fn translate_call_indirect(
         &mut self,
-        pos: FuncCursor,
+        builder: &mut FunctionBuilder,
         table_index: TableIndex,
-        table: ir::Table,
         sig_index: SignatureIndex,
         sig_ref: ir::SigRef,
         callee: ir::Value,
         call_args: &[ir::Value],
     ) -> WasmResult<ir::Inst>;
 
-    /// Translate a `call` WebAssembly instruction at `pos`.
-    ///
-    /// Insert instructions at `pos` for a direct call to the function `callee_index`.
-    ///
-    /// The function reference `callee` was previously created by `make_direct_func()`.
-    ///
-    /// Return the call instruction whose results are the WebAssembly return values.
-    fn translate_call(
-        &mut self,
-        mut pos: FuncCursor,
-        _callee_index: FunctionIndex,
-        callee: ir::FuncRef,
-        call_args: &[ir::Value],
-    ) -> WasmResult<ir::Inst> {
-        Ok(pos.ins().call(callee, call_args))
-    }
-
     /// Translate a `memory.grow` WebAssembly instruction.
     ///
     /// The `index` provided identifies the linear memory to grow, and `heap` is the heap reference
@@ -206,7 +226,7 @@ pub trait FuncEnvironment: TargetEnvironment {
         &mut self,
         pos: FuncCursor,
         index: MemoryIndex,
-        heap: ir::Heap,
+        heap: Heap,
         val: ir::Value,
     ) -> WasmResult<ir::Value>;
 
@@ -220,7 +240,7 @@ pub trait FuncEnvironment: TargetEnvironment {
         &mut self,
         pos: FuncCursor,
         index: MemoryIndex,
-        heap: ir::Heap,
+        heap: Heap,
     ) -> WasmResult<ir::Value>;
 
     /// Translate a `memory.copy` WebAssembly instruction.
@@ -232,9 +252,9 @@ pub trait FuncEnvironment: TargetEnvironment {
         &mut self,
         pos: FuncCursor,
         src_index: MemoryIndex,
-        src_heap: ir::Heap,
+        src_heap: Heap,
         dst_index: MemoryIndex,
-        dst_heap: ir::Heap,
+        dst_heap: Heap,
         dst: ir::Value,
         src: ir::Value,
         len: ir::Value,
@@ -248,7 +268,7 @@ pub trait FuncEnvironment: TargetEnvironment {
         &mut self,
         pos: FuncCursor,
         index: MemoryIndex,
-        heap: ir::Heap,
+        heap: Heap,
         dst: ir::Value,
         val: ir::Value,
         len: ir::Value,
@@ -264,7 +284,7 @@ pub trait FuncEnvironment: TargetEnvironment {
         &mut self,
         pos: FuncCursor,
         index: MemoryIndex,
-        heap: ir::Heap,
+        heap: Heap,
         seg_index: u32,
         dst: ir::Value,
         src: ir::Value,
@@ -275,19 +295,14 @@ pub trait FuncEnvironment: TargetEnvironment {
     fn translate_data_drop(&mut self, pos: FuncCursor, seg_index: u32) -> WasmResult<()>;
 
     /// Translate a `table.size` WebAssembly instruction.
-    fn translate_table_size(
-        &mut self,
-        pos: FuncCursor,
-        index: TableIndex,
-        table: ir::Table,
-    ) -> WasmResult<ir::Value>;
+    fn translate_table_size(&mut self, pos: FuncCursor, index: TableIndex)
+        -> WasmResult<ir::Value>;
 
     /// Translate a `table.grow` WebAssembly instruction.
     fn translate_table_grow(
         &mut self,
         pos: FuncCursor,
         table_index: TableIndex,
-        table: ir::Table,
         delta: ir::Value,
         init_value: ir::Value,
     ) -> WasmResult<ir::Value>;
@@ -297,7 +312,6 @@ pub trait FuncEnvironment: TargetEnvironment {
         &mut self,
         builder: &mut FunctionBuilder,
         table_index: TableIndex,
-        table: ir::Table,
         index: ir::Value,
     ) -> WasmResult<ir::Value>;
 
@@ -306,7 +320,6 @@ pub trait FuncEnvironment: TargetEnvironment {
         &mut self,
         builder: &mut FunctionBuilder,
         table_index: TableIndex,
-        table: ir::Table,
         value: ir::Value,
         index: ir::Value,
     ) -> WasmResult<()>;
@@ -317,9 +330,7 @@ pub trait FuncEnvironment: TargetEnvironment {
         &mut self,
         pos: FuncCursor,
         dst_table_index: TableIndex,
-        dst_table: ir::Table,
         src_table_index: TableIndex,
-        src_table: ir::Table,
         dst: ir::Value,
         src: ir::Value,
         len: ir::Value,
@@ -342,7 +353,6 @@ pub trait FuncEnvironment: TargetEnvironment {
         pos: FuncCursor,
         seg_index: u32,
         table_index: TableIndex,
-        table: ir::Table,
         dst: ir::Value,
         src: ir::Value,
         len: ir::Value,
@@ -418,7 +428,7 @@ pub trait FuncEnvironment: TargetEnvironment {
         &mut self,
         pos: FuncCursor,
         index: MemoryIndex,
-        heap: ir::Heap,
+        heap: Heap,
         addr: ir::Value,
         expected: ir::Value,
         timeout: ir::Value,
@@ -434,7 +444,7 @@ pub trait FuncEnvironment: TargetEnvironment {
         &mut self,
         pos: FuncCursor,
         index: MemoryIndex,
-        heap: ir::Heap,
+        heap: Heap,
         addr: ir::Value,
         count: ir::Value,
     ) -> WasmResult<ir::Value>;
@@ -470,6 +480,18 @@ pub trait FuncEnvironment: TargetEnvironment {
         Ok(())
     }
 
+    /// Optional callback for the `FuncEnvironment` performing this translation
+    /// to maintain, prepare, or finalize custom, internal state when we
+    /// statically determine that a Wasm memory access will unconditionally
+    /// trap, rendering the rest of the block unreachable. Called just before
+    /// the unconditional trap is emitted.
+    fn before_unconditionally_trapping_memory_access(
+        &mut self,
+        _builder: &mut FunctionBuilder,
+    ) -> WasmResult<()> {
+        Ok(())
+    }
+
     /// Get the type of the global at the given index.
     #[allow(dead_code)]
     fn get_global_type(&self, global_index: GlobalIndex) -> Option<WasmerType>;
@@ -495,4 +517,27 @@ pub trait FuncEnvironment: TargetEnvironment {
     /// Get the type of a function with the given signature index.
     #[allow(dead_code)]
     fn get_function_sig(&self, sig_index: SignatureIndex) -> Option<&FunctionType>;
+
+    /// Inserts code before a function return.
+    fn handle_before_return(&mut self, _retvals: &[ir::Value], _builder: &mut FunctionBuilder) {}
+
+    /// Inserts code before a load.
+    fn before_load(
+        &mut self,
+        _builder: &mut FunctionBuilder,
+        _val_size: u8,
+        _addr: ir::Value,
+        _offset: u64,
+    ) {
+    }
+
+    /// Inserts code before a store.
+    fn before_store(
+        &mut self,
+        _builder: &mut FunctionBuilder,
+        _val_size: u8,
+        _addr: ir::Value,
+        _offset: u64,
+    ) {
+    }
 }
diff --git a/lib/compiler-cranelift/src/translator/func_state.rs b/lib/compiler-cranelift/src/translator/func_state.rs
index 7891c8be69..e35f56b030 100644
--- a/lib/compiler-cranelift/src/translator/func_state.rs
+++ b/lib/compiler-cranelift/src/translator/func_state.rs
@@ -10,12 +10,11 @@
 //! value and control stacks during the translation of a single function.
 
 use super::func_environ::{FuncEnvironment, GlobalVariable};
+use crate::heap::Heap;
 use crate::{HashMap, Occupied, Vacant};
 use cranelift_codegen::ir::{self, Block, Inst, Value};
 use std::vec::Vec;
-use wasmer_types::{
-    FunctionIndex, GlobalIndex, MemoryIndex, SignatureIndex, TableIndex, WasmResult,
-};
+use wasmer_types::{FunctionIndex, GlobalIndex, MemoryIndex, SignatureIndex, WasmResult};
 
 /// Information about the presence of an associated `else` for an `if`, or the
 /// lack thereof.
@@ -30,6 +29,9 @@ pub enum ElseData {
         /// instruction that needs to be fixed up to point to the new `else`
         /// block rather than the destination block after the `if...end`.
         branch_inst: Inst,
+
+        /// The placeholder block we're replacing.
+        placeholder: Block,
     },
 
     /// We have already allocated an `else` block.
@@ -233,10 +235,7 @@ pub struct FuncTranslationState {
     globals: HashMap<GlobalIndex, GlobalVariable>,
 
     // Map of heaps that have been created by `FuncEnvironment::make_heap`.
-    heaps: HashMap<MemoryIndex, ir::Heap>,
-
-    // Map of tables that have been created by `FuncEnvironment::make_table`.
-    tables: HashMap<TableIndex, ir::Table>,
+    heaps: HashMap<MemoryIndex, Heap>,
 
     // Map of indirect call signatures that have been created by
     // `FuncEnvironment::make_indirect_sig()`.
@@ -270,7 +269,6 @@ impl FuncTranslationState {
             reachable: true,
             globals: HashMap::new(),
             heaps: HashMap::new(),
-            tables: HashMap::new(),
             signatures: HashMap::new(),
             functions: HashMap::new(),
         }
@@ -282,7 +280,6 @@ impl FuncTranslationState {
         self.reachable = true;
         self.globals.clear();
         self.heaps.clear();
-        self.tables.clear();
         self.signatures.clear();
         self.functions.clear();
     }
@@ -473,7 +470,7 @@ impl FuncTranslationState {
         func: &mut ir::Function,
         index: u32,
         environ: &mut FE,
-    ) -> WasmResult<ir::Heap> {
+    ) -> WasmResult<Heap> {
         let index = MemoryIndex::from_u32(index);
         match self.heaps.entry(index) {
             Occupied(entry) => Ok(*entry.get()),
@@ -481,21 +478,6 @@ impl FuncTranslationState {
         }
     }
 
-    /// Get the `Table` reference that should be used to access table `index`.
-    /// Create the reference if necessary.
-    pub(crate) fn get_or_create_table<FE: FuncEnvironment + ?Sized>(
-        &mut self,
-        func: &mut ir::Function,
-        index: u32,
-        environ: &mut FE,
-    ) -> WasmResult<ir::Table> {
-        let index = TableIndex::from_u32(index);
-        match self.tables.entry(index) {
-            Occupied(entry) => Ok(*entry.get()),
-            Vacant(entry) => Ok(*entry.insert(environ.make_table(func, index)?)),
-        }
-    }
-
     /// Get the `SigRef` reference that should be used to make an indirect call with signature
     /// `index`. Also return the number of WebAssembly arguments in the signature.
     ///
diff --git a/lib/compiler-cranelift/src/translator/func_translator.rs b/lib/compiler-cranelift/src/translator/func_translator.rs
index 3fa329b247..6ae1b40903 100644
--- a/lib/compiler-cranelift/src/translator/func_translator.rs
+++ b/lib/compiler-cranelift/src/translator/func_translator.rs
@@ -7,10 +7,11 @@
 //! function to Cranelift IR guided by a `FuncEnvironment` which provides information about the
 //! WebAssembly module and the runtime environment.
 
-use super::code_translator::{bitcast_arguments, translate_operator, wasm_param_types};
+use super::code_translator::translate_operator;
 use super::func_environ::{FuncEnvironment, ReturnMode};
 use super::func_state::FuncTranslationState;
 use super::translation_utils::get_vmctx_value_label;
+use crate::translator::code_translator::bitcast_wasm_returns;
 use cranelift_codegen::entity::EntityRef;
 use cranelift_codegen::ir::{self, Block, InstBuilder, ValueLabel};
 use cranelift_codegen::timing;
@@ -249,10 +250,7 @@ fn parse_function_body<FE: FuncEnvironment + ?Sized>(
         if !builder.is_unreachable() {
             match environ.return_mode() {
                 ReturnMode::NormalReturns => {
-                    let return_types = wasm_param_types(&builder.func.signature.returns, |i| {
-                        environ.is_wasm_return(&builder.func.signature, i)
-                    });
-                    bitcast_arguments(&mut state.stack, &return_types, builder);
+                    bitcast_wasm_returns(environ, &mut state.stack, builder);
                     builder.ins().return_(&state.stack)
                 }
             };
diff --git a/lib/compiler-cranelift/src/translator/mod.rs b/lib/compiler-cranelift/src/translator/mod.rs
index 773ee44666..accc867c46 100644
--- a/lib/compiler-cranelift/src/translator/mod.rs
+++ b/lib/compiler-cranelift/src/translator/mod.rs
@@ -10,6 +10,6 @@ mod unwind;
 pub use self::func_environ::{FuncEnvironment, GlobalVariable, TargetEnvironment};
 pub use self::func_translator::FuncTranslator;
 pub use self::translation_utils::{
-    irlibcall_to_libcall, irreloc_to_relocationkind, signature_to_cranelift_ir, type_to_irtype,
+    irlibcall_to_libcall, irreloc_to_relocationkind, signature_to_cranelift_ir,
 };
 pub(crate) use self::unwind::{compiled_function_unwind_info, CraneliftUnwindInfo};
diff --git a/lib/compiler-cranelift/src/translator/translation_utils.rs b/lib/compiler-cranelift/src/translator/translation_utils.rs
index eb33af5412..81a4d835d8 100644
--- a/lib/compiler-cranelift/src/translator/translation_utils.rs
+++ b/lib/compiler-cranelift/src/translator/translation_utils.rs
@@ -2,13 +2,14 @@
 
 use super::func_environ::TargetEnvironment;
 use crate::std::string::ToString;
-use core::u32;
-use cranelift_codegen::binemit::Reloc;
-use cranelift_codegen::ir::{self, AbiParam};
-use cranelift_codegen::isa::TargetFrontendConfig;
+use cranelift_codegen::{
+    binemit::Reloc,
+    ir::{self, AbiParam},
+    isa::TargetFrontendConfig,
+};
 use cranelift_frontend::FunctionBuilder;
-use wasmer_compiler::wasmparser;
-use wasmer_types::{FunctionType, LibCall, RelocationKind, Type, WasmError, WasmResult};
+use wasmer_compiler::{types::relocation::RelocationKind, wasm_unsupported, wasmparser};
+use wasmer_types::{FunctionType, LibCall, Type, WasmError, WasmResult};
 
 /// Helper function translate a Function signature into Cranelift Ir
 pub fn signature_to_cranelift_ir(
@@ -54,6 +55,9 @@ pub fn type_to_irtype(ty: Type, target_config: TargetFrontendConfig) -> WasmResu
         Type::F64 => Ok(ir::types::F64),
         Type::V128 => Ok(ir::types::I8X16),
         Type::ExternRef | Type::FuncRef => reference_type(target_config),
+        Type::ExceptionRef => Err(wasm_unsupported!(
+            "exnrefs are not supported yet in cranelift"
+        )),
         // ty => Err(wasm_unsupported!("type_to_type: wasm type {:?}", ty)),
     }
 }
@@ -84,8 +88,8 @@ pub fn irreloc_to_relocationkind(reloc: Reloc) -> RelocationKind {
         Reloc::X86CallPLTRel4 => RelocationKind::X86CallPLTRel4,
         Reloc::X86GOTPCRel4 => RelocationKind::X86GOTPCRel4,
         Reloc::Arm64Call => RelocationKind::Arm64Call,
-        Reloc::RiscvCall => RelocationKind::RiscvCall,
-        _ => panic!("The relocation {} is not yet supported.", reloc),
+        Reloc::RiscvCallPlt => RelocationKind::RiscvCall,
+        _ => panic!("The relocation {reloc} is not yet supported."),
     }
 }
 
@@ -115,8 +119,7 @@ pub fn block_with_params<'a, PE: TargetEnvironment + ?Sized>(
                     builder.append_block_param(block, environ.reference_type());
                 } else {
                     return Err(WasmError::Unsupported(format!(
-                        "unsupported reference type: {:?}",
-                        ty
+                        "unsupported reference type: {ty:?}"
                     )));
                 }
             }
diff --git a/lib/compiler-cranelift/src/translator/unwind.rs b/lib/compiler-cranelift/src/translator/unwind.rs
index 4de700b2d8..ceddcbd505 100644
--- a/lib/compiler-cranelift/src/translator/unwind.rs
+++ b/lib/compiler-cranelift/src/translator/unwind.rs
@@ -3,10 +3,9 @@
 
 #[cfg(feature = "unwind")]
 use cranelift_codegen::isa::unwind::{systemv::UnwindInfo as DwarfFDE, UnwindInfo};
-use cranelift_codegen::print_errors::pretty_error;
-use cranelift_codegen::{isa, Context};
+use cranelift_codegen::{isa, print_errors::pretty_error, Context};
+use wasmer_compiler::types::unwind::CompiledFunctionUnwindInfo;
 use wasmer_types::CompileError;
-use wasmer_types::CompiledFunctionUnwindInfo;
 
 /// Cranelift specific unwind info
 pub(crate) enum CraneliftUnwindInfo {
diff --git a/lib/compiler-llvm/Cargo.toml b/lib/compiler-llvm/Cargo.toml
index a0ae6dd9f3..853cdb66e9 100644
--- a/lib/compiler-llvm/Cargo.toml
+++ b/lib/compiler-llvm/Cargo.toml
@@ -8,36 +8,44 @@ readme = "README.md"
 authors.workspace = true
 edition.workspace = true
 homepage.workspace = true
-license.workspace = true
+license-file = "LICENSE"
 repository.workspace = true
 rust-version.workspace = true
 version.workspace = true
 
 [dependencies]
-wasmer-compiler = { path = "../compiler", version = "=4.3.7", features = [
-    "translator", "compiler"
+wasmer-compiler = { path = "../compiler", version = "=6.1.0", features = [
+	"translator",
+	"compiler",
 ] }
-wasmer-vm = { path = "../vm", version = "=4.3.7" }
-wasmer-types = { path = "../types", version = "=4.3.7" }
-target-lexicon = { version = "0.12.2", default-features = false }
-smallvec = "1.6"
-object = { version = "0.28.3", default-features = false, features = ["read"] }
+wasmer-vm = { path = "../vm", version = "=6.1.0" }
+wasmer-types = { path = "../types", version = "=6.1.0" }
+target-lexicon = { workspace = true, default-features = false }
+smallvec.workspace = true
+object = { workspace = true, features = ["read"] }
 libc.workspace = true
-byteorder = "1"
-itertools = "0.10"
-rayon = "1.5"
+byteorder.workspace = true
+itertools.workspace = true
+rayon.workspace = true
+phf = { version = "0.11.2", features = ["macros"] }
+tracing = { workspace = true, features = ["log"] }
 
 [dependencies.inkwell]
 package = "inkwell"
-version = "0.1.1"
+version = "0.5.0"
 default-features = false
-features = ["llvm15-0", "target-x86", "target-aarch64", "target-riscv"]
+features = [
+	"llvm18-0-prefer-static",
+	"target-x86",
+	"target-aarch64",
+	"target-riscv",
+	"target-loongarch",
+]
 
 [build-dependencies]
 cc = "1.0"
-lazy_static = "1.4"
 regex = "1.5"
-semver = "1.0"
+semver.workspace = true
 rustc_version = "0.4"
 
 [features]
diff --git a/lib/compiler-llvm/LICENSE b/lib/compiler-llvm/LICENSE
new file mode 100644
index 0000000000..622ebe383d
--- /dev/null
+++ b/lib/compiler-llvm/LICENSE
@@ -0,0 +1,86 @@
+License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved.
+"Business Source License" is a trademark of MariaDB Corporation Ab.
+
+Parameters
+
+Licensor:             Wasmer, Inc.
+Licensed Work:        Wasmer LLVM Version 6.0.0 or later.  The Licensed Work is
+                      (c) 2025 Wasmer, Inc.
+Additional Use Grant: You may make production use of the Licensed Work provided you are
+                      either a Sponsor under the Wasmer Sponsorhip Program or an entity
+                      within the Sponsorship Network of any current Sponsor designated in
+                      accordance with Wasmer’s criteria.
+                      
+                      For purposes of this Agreement:
+                      A "Sponsor" is an entity actively enrolled in the Wasmer Sponsorship
+                      Program that fulfills all requirements—including the timely payment of
+                      an applicable monthly sponsorship fee determined in a separate,
+                      non-public Sponsorship Agreement with Wasmer—and maintains good
+                      standing with Wasmer.
+
+                      A "Sponsorship Network" means any network of systems or entities
+                      designated by Wasmer under a current Sponsor. The criteria and list of
+                      such elements shall be maintained and updated by Wasmer.
+
+                      "Wasmer Sponsorship Program" means the program established by Wasmer
+                      under which eligible participants, including Sponsor, may obtain access
+                      to and use of the Software, in exchange for the payment of a recurring
+                      Sponsorship Fee.
+
+                      The Additional Use Grant is conditioned on your continued compliance
+                      with the terms of the Wasmer Sponsorship Program, including the timely
+                      payment of the applicable monthly sponsorship fee determined by Wasmer;
+                      if the sponsor fail to meet these conditions or if your Sponsorship or
+                      that of your associated Sponsor is terminated for any reason, the
+                      additional rights granted under this Sponsor Exception shall
+                      immediately revert to the standard limitations of BUSL 1.1.
+Change Date:          Four years from the date the Licensed Work is published
+Change License:       MPL 2.0
+
+For information about alternative licensing arrangements for the Licensed Work,
+please contact licensing@wasmer.io.
+
+Notice
+
+Business Source License 1.1
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under
+the terms of the Change License, and the rights granted in the paragraph
+above terminate.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or authorized
+resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works
+of the Licensed Work, are subject to this License. This License applies
+separately for each version of the Licensed Work and the Change Date may vary
+for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy
+of the Licensed Work. If you receive the Licensed Work in original or
+modified form from a third party, the terms and conditions set forth in this
+License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other
+versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or logo of
+Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+TITLE.
\ No newline at end of file
diff --git a/lib/compiler-llvm/README.md b/lib/compiler-llvm/README.md
index 124f5c48bb..e2d789068c 100644
--- a/lib/compiler-llvm/README.md
+++ b/lib/compiler-llvm/README.md
@@ -1,4 +1,4 @@
-# `wasmer-compiler-llvm` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE) [![crates.io](https://img.shields.io/crates/v/wasmer-compiler-llvm.svg)](https://crates.io/crates/wasmer-compiler-llvm)
+# `wasmer-compiler-llvm` [![Build Status](https://github.com/wasmerio/wasmer/actions/workflows/build.yml/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE) [![crates.io](https://img.shields.io/crates/v/wasmer-compiler-llvm.svg)](https://crates.io/crates/wasmer-compiler-llvm)
 
 This crate contains a compiler implementation based on [the LLVM Compiler Infrastructure][LLVM].
 
@@ -17,26 +17,26 @@ let mut store = Store::new(compiler);
 ## When to use LLVM
 
 We recommend using LLVM as the default compiler when running WebAssembly
-files on any **production** system, as it offers maximum peformance near
+files on any **production** system, as it offers maximum performance near
 to native speeds.
 
 ## Requirements
 
 The LLVM compiler requires a valid installation of LLVM in your system.
-It currently requires **LLVM 15**.
+It currently requires **LLVM 18**.
 
 
 You can install LLVM easily on your Debian-like system via this command:
 
 ```bash
 wget https://apt.llvm.org/llvm.sh -O /tmp/llvm.sh
-sudo bash /tmp/llvm.sh 15
+sudo bash /tmp/llvm.sh 18
 ```
 
 Or in macOS:
 
 ```bash
-brew install llvm@15
+brew install llvm@18
 ```
 
 Or via any of the [pre-built binaries that LLVM offers][llvm-pre-built].
diff --git a/lib/compiler-llvm/src/abi/aarch64_systemv.rs b/lib/compiler-llvm/src/abi/aarch64_systemv.rs
index 7ebf68b840..2076f62962 100644
--- a/lib/compiler-llvm/src/abi/aarch64_systemv.rs
+++ b/lib/compiler-llvm/src/abi/aarch64_systemv.rs
@@ -1,4 +1,5 @@
 use crate::abi::Abi;
+use crate::error::{err, err_nt};
 use crate::translator::intrinsics::{type_to_llvm, Intrinsics};
 use inkwell::{
     attributes::{Attribute, AttributeLoc},
@@ -14,13 +15,15 @@ use wasmer_vm::VMOffsets;
 
 use std::convert::TryInto;
 
+use super::{G0M0FunctionKind, LocalFunctionG0M0params};
+
 /// Implementation of the [`Abi`] trait for the Aarch64 ABI on Linux.
 pub struct Aarch64SystemV {}
 
 impl Abi for Aarch64SystemV {
     // Given a function definition, retrieve the parameter that is the vmctx pointer.
     fn get_vmctx_ptr_param<'ctx>(&self, func_value: &FunctionValue<'ctx>) -> PointerValue<'ctx> {
-        func_value
+        let param = func_value
             .get_nth_param(u32::from(
                 func_value
                     .get_enum_attribute(
@@ -29,8 +32,48 @@ impl Abi for Aarch64SystemV {
                     )
                     .is_some(),
             ))
-            .unwrap()
-            .into_pointer_value()
+            .unwrap();
+        //param.set_name("vmctx");
+
+        param.into_pointer_value()
+    }
+
+    /// Given a function definition, retrieve the parameter that is the pointer to the first --
+    /// number 0 -- local global.
+    fn get_g0_ptr_param<'ctx>(&self, func_value: &FunctionValue<'ctx>) -> IntValue<'ctx> {
+        // g0 is always after the vmctx.
+        let vmctx_idx = u32::from(
+            func_value
+                .get_enum_attribute(
+                    AttributeLoc::Param(0),
+                    Attribute::get_named_enum_kind_id("sret"),
+                )
+                .is_some(),
+        );
+
+        let param = func_value.get_nth_param(vmctx_idx + 1).unwrap();
+        param.set_name("g0");
+
+        param.into_int_value()
+    }
+
+    /// Given a function definition, retrieve the parameter that is the pointer to the first --
+    /// number 0 -- local memory.
+    fn get_m0_ptr_param<'ctx>(&self, func_value: &FunctionValue<'ctx>) -> PointerValue<'ctx> {
+        // m0 is always after g0.
+        let vmctx_idx = u32::from(
+            func_value
+                .get_enum_attribute(
+                    AttributeLoc::Param(0),
+                    Attribute::get_named_enum_kind_id("sret"),
+                )
+                .is_some(),
+        );
+
+        let param = func_value.get_nth_param(vmctx_idx + 2).unwrap();
+        param.set_name("m0_base_ptr");
+
+        param.into_pointer_value()
     }
 
     // Given a wasm function type, produce an llvm function declaration.
@@ -40,11 +83,19 @@ impl Abi for Aarch64SystemV {
         intrinsics: &Intrinsics<'ctx>,
         offsets: Option<&VMOffsets>,
         sig: &FuncSig,
+        function_kind: Option<G0M0FunctionKind>,
     ) -> Result<(FunctionType<'ctx>, Vec<(Attribute, AttributeLoc)>), CompileError> {
         let user_param_types = sig.params().iter().map(|&ty| type_to_llvm(intrinsics, ty));
 
-        let param_types =
-            std::iter::once(Ok(intrinsics.ctx_ptr_ty.as_basic_type_enum())).chain(user_param_types);
+        let mut param_types = vec![Ok(intrinsics.ptr_ty.as_basic_type_enum())];
+        if function_kind.is_some_and(|v| v.is_local()) {
+            // The value of g0
+            param_types.push(Ok(intrinsics.i32_ty.as_basic_type_enum()));
+            // The base pointer to m0
+            param_types.push(Ok(intrinsics.ptr_ty.as_basic_type_enum()));
+        }
+
+        let param_types = param_types.into_iter().chain(user_param_types);
 
         let vmctx_attributes = |i: u32| {
             vec![
@@ -156,6 +207,25 @@ impl Abi for Aarch64SystemV {
                     vmctx_attributes(0),
                 )
             }
+            [t1, t2]
+                if matches!(t1, Type::I32 | Type::I64 | Type::F32 | Type::F64)
+                    && matches!(t2, Type::FuncRef | Type::ExternRef | Type::ExceptionRef) =>
+            {
+                let t1 = type_to_llvm(intrinsics, *t1).unwrap();
+                let t2 = type_to_llvm(intrinsics, *t2).unwrap();
+                (
+                    context
+                        .struct_type(&[t1.as_basic_type_enum(), t2.as_basic_type_enum()], false)
+                        .fn_type(
+                            param_types
+                                .map(|v| v.map(Into::into))
+                                .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                                .as_slice(),
+                            false,
+                        ),
+                    vmctx_attributes(0),
+                )
+            }
             _ => {
                 let sig_returns_bitwidths = sig
                     .results()
@@ -164,7 +234,7 @@ impl Abi for Aarch64SystemV {
                         Type::I32 | Type::F32 => 32,
                         Type::I64 | Type::F64 => 64,
                         Type::V128 => 128,
-                        Type::ExternRef | Type::FuncRef => 64, /* pointer */
+                        Type::ExternRef | Type::FuncRef | Type::ExceptionRef => 64, /* pointer */
                     })
                     .collect::<Vec<i32>>();
                 match sig_returns_bitwidths.as_slice() {
@@ -202,7 +272,7 @@ impl Abi for Aarch64SystemV {
                             .collect::<Result<_, _>>()?;
 
                         let sret = context.struct_type(&basic_types, false);
-                        let sret_ptr = sret.ptr_type(AddressSpace::default());
+                        let sret_ptr = context.ptr_type(AddressSpace::default());
 
                         let param_types =
                             std::iter::once(Ok(sret_ptr.as_basic_type_enum())).chain(param_types);
@@ -241,7 +311,8 @@ impl Abi for Aarch64SystemV {
         ctx_ptr: PointerValue<'ctx>,
         values: &[BasicValueEnum<'ctx>],
         intrinsics: &Intrinsics<'ctx>,
-    ) -> Vec<BasicValueEnum<'ctx>> {
+        g0m0: LocalFunctionG0M0params<'ctx>,
+    ) -> Result<Vec<BasicValueEnum<'ctx>>, CompileError> {
         // If it's an sret, allocate the return space.
         let sret = if llvm_fn_ty.get_return_type().is_none() && func_sig.results().len() > 1 {
             let llvm_params: Vec<_> = func_sig
@@ -252,20 +323,29 @@ impl Abi for Aarch64SystemV {
             let llvm_params = llvm_fn_ty
                 .get_context()
                 .struct_type(llvm_params.as_slice(), false);
-            Some(alloca_builder.build_alloca(llvm_params, "sret"))
+            Some(err!(alloca_builder.build_alloca(llvm_params, "sret")))
         } else {
             None
         };
 
-        let values = std::iter::once(ctx_ptr.as_basic_value_enum()).chain(values.iter().copied());
+        let mut args = vec![ctx_ptr.as_basic_value_enum()];
+
+        if let Some((g0, m0)) = g0m0 {
+            args.push(g0.into());
+            args.push(m0.into());
+        }
+
+        let args = args.into_iter().chain(values.iter().copied());
 
-        if let Some(sret) = sret {
+        let ret = if let Some(sret) = sret {
             std::iter::once(sret.as_basic_value_enum())
-                .chain(values)
+                .chain(args)
                 .collect()
         } else {
-            values.collect()
-        }
+            args.collect()
+        };
+
+        Ok(ret)
     }
 
     // Given a CallSite, extract the returned values and return them in a Vec.
@@ -275,72 +355,78 @@ impl Abi for Aarch64SystemV {
         intrinsics: &Intrinsics<'ctx>,
         call_site: CallSiteValue<'ctx>,
         func_sig: &FuncSig,
-    ) -> Vec<BasicValueEnum<'ctx>> {
-        let split_i64 = |value: IntValue<'ctx>| -> (IntValue<'ctx>, IntValue<'ctx>) {
-            assert!(value.get_type() == intrinsics.i64_ty);
-            let low = builder.build_int_truncate(value, intrinsics.i32_ty, "");
-            let lshr =
-                builder.build_right_shift(value, intrinsics.i64_ty.const_int(32, false), false, "");
-            let high = builder.build_int_truncate(lshr, intrinsics.i32_ty, "");
-            (low, high)
-        };
+    ) -> Result<Vec<BasicValueEnum<'ctx>>, CompileError> {
+        let split_i64 =
+            |value: IntValue<'ctx>| -> Result<(IntValue<'ctx>, IntValue<'ctx>), CompileError> {
+                assert!(value.get_type() == intrinsics.i64_ty);
+                let low = err!(builder.build_int_truncate(value, intrinsics.i32_ty, ""));
+                let lshr = err!(builder.build_right_shift(
+                    value,
+                    intrinsics.i64_ty.const_int(32, false),
+                    false,
+                    "",
+                ));
+                let high = err!(builder.build_int_truncate(lshr, intrinsics.i32_ty, ""));
+                Ok((low, high))
+            };
 
-        let casted = |value: BasicValueEnum<'ctx>, ty: Type| -> BasicValueEnum<'ctx> {
-            match ty {
-                Type::I32 => {
-                    assert!(
-                        value.get_type() == intrinsics.i32_ty.as_basic_type_enum()
-                            || value.get_type() == intrinsics.f32_ty.as_basic_type_enum()
-                    );
-                    builder.build_bitcast(value, intrinsics.i32_ty, "")
-                }
-                Type::F32 => {
-                    assert!(
-                        value.get_type() == intrinsics.i32_ty.as_basic_type_enum()
-                            || value.get_type() == intrinsics.f32_ty.as_basic_type_enum()
-                    );
-                    builder.build_bitcast(value, intrinsics.f32_ty, "")
-                }
-                Type::I64 => {
-                    assert!(
-                        value.get_type() == intrinsics.i64_ty.as_basic_type_enum()
-                            || value.get_type() == intrinsics.f64_ty.as_basic_type_enum()
-                    );
-                    builder.build_bitcast(value, intrinsics.i64_ty, "")
-                }
-                Type::F64 => {
-                    assert!(
-                        value.get_type() == intrinsics.i64_ty.as_basic_type_enum()
-                            || value.get_type() == intrinsics.f64_ty.as_basic_type_enum()
-                    );
-                    builder.build_bitcast(value, intrinsics.f64_ty, "")
-                }
-                Type::V128 => {
-                    assert!(value.get_type() == intrinsics.i128_ty.as_basic_type_enum());
-                    value
-                }
-                Type::ExternRef | Type::FuncRef => {
-                    assert!(value.get_type() == intrinsics.funcref_ty.as_basic_type_enum());
-                    value
+        let casted =
+            |value: BasicValueEnum<'ctx>, ty: Type| -> Result<BasicValueEnum<'ctx>, CompileError> {
+                match ty {
+                    Type::I32 => {
+                        assert!(
+                            value.get_type() == intrinsics.i32_ty.as_basic_type_enum()
+                                || value.get_type() == intrinsics.f32_ty.as_basic_type_enum()
+                        );
+                        err_nt!(builder.build_bit_cast(value, intrinsics.i32_ty, ""))
+                    }
+                    Type::F32 => {
+                        assert!(
+                            value.get_type() == intrinsics.i32_ty.as_basic_type_enum()
+                                || value.get_type() == intrinsics.f32_ty.as_basic_type_enum()
+                        );
+                        err_nt!(builder.build_bit_cast(value, intrinsics.f32_ty, ""))
+                    }
+                    Type::I64 => {
+                        assert!(
+                            value.get_type() == intrinsics.i64_ty.as_basic_type_enum()
+                                || value.get_type() == intrinsics.f64_ty.as_basic_type_enum()
+                        );
+                        err_nt!(builder.build_bit_cast(value, intrinsics.i64_ty, ""))
+                    }
+                    Type::F64 => {
+                        assert!(
+                            value.get_type() == intrinsics.i64_ty.as_basic_type_enum()
+                                || value.get_type() == intrinsics.f64_ty.as_basic_type_enum()
+                        );
+                        err_nt!(builder.build_bit_cast(value, intrinsics.f64_ty, ""))
+                    }
+                    Type::V128 => {
+                        assert!(value.get_type() == intrinsics.i128_ty.as_basic_type_enum());
+                        Ok(value)
+                    }
+                    Type::ExternRef | Type::FuncRef | Type::ExceptionRef => {
+                        assert!(value.get_type() == intrinsics.ptr_ty.as_basic_type_enum());
+                        Ok(value)
+                    }
                 }
-            }
-        };
+            };
 
         if let Some(basic_value) = call_site.try_as_basic_value().left() {
             if func_sig.results().len() > 1 {
                 if basic_value.get_type() == intrinsics.i64_ty.as_basic_type_enum() {
                     assert!(func_sig.results().len() == 2);
                     let value = basic_value.into_int_value();
-                    let (low, high) = split_i64(value);
-                    let low = casted(low.into(), func_sig.results()[0]);
-                    let high = casted(high.into(), func_sig.results()[1]);
-                    return vec![low, high];
+                    let (low, high) = split_i64(value)?;
+                    let low = casted(low.into(), func_sig.results()[0])?;
+                    let high = casted(high.into(), func_sig.results()[1])?;
+                    return Ok(vec![low, high]);
                 }
                 if basic_value.is_struct_value() {
                     let struct_value = basic_value.into_struct_value();
-                    return (0..struct_value.get_type().count_fields())
+                    return Ok((0..struct_value.get_type().count_fields())
                         .map(|i| builder.build_extract_value(struct_value, i, "").unwrap())
-                        .collect::<Vec<_>>();
+                        .collect::<Vec<_>>());
                 }
                 let array_value = basic_value.into_array_value();
                 let low = builder
@@ -358,64 +444,64 @@ impl Abi for Aarch64SystemV {
                         Type::I32 | Type::F32 => 32,
                         Type::I64 | Type::F64 => 64,
                         Type::V128 => 128,
-                        Type::ExternRef | Type::FuncRef => 64, /* pointer */
+                        Type::ExternRef | Type::FuncRef | Type::ExceptionRef => 64, /* pointer */
                     })
                     .collect::<Vec<i32>>();
 
                 match func_sig_returns_bitwidths.as_slice() {
                     [32, 64] => {
-                        let (low, _) = split_i64(low);
-                        let low = casted(low.into(), func_sig.results()[0]);
-                        let high = casted(high.into(), func_sig.results()[1]);
-                        vec![low, high]
+                        let (low, _) = split_i64(low)?;
+                        let low = casted(low.into(), func_sig.results()[0])?;
+                        let high = casted(high.into(), func_sig.results()[1])?;
+                        Ok(vec![low, high])
                     }
                     [64, 32] => {
-                        let (high, _) = split_i64(high);
-                        let low = casted(low.into(), func_sig.results()[0]);
-                        let high = casted(high.into(), func_sig.results()[1]);
-                        vec![low, high]
+                        let (high, _) = split_i64(high)?;
+                        let low = casted(low.into(), func_sig.results()[0])?;
+                        let high = casted(high.into(), func_sig.results()[1])?;
+                        Ok(vec![low, high])
                     }
                     [64, 64] => {
-                        let low = casted(low.into(), func_sig.results()[0]);
-                        let high = casted(high.into(), func_sig.results()[1]);
-                        vec![low, high]
+                        let low = casted(low.into(), func_sig.results()[0])?;
+                        let high = casted(high.into(), func_sig.results()[1])?;
+                        Ok(vec![low, high])
                     }
                     [32, 32, 32] => {
-                        let (v1, v2) = split_i64(low);
-                        let (v3, _) = split_i64(high);
-                        let v1 = casted(v1.into(), func_sig.results()[0]);
-                        let v2 = casted(v2.into(), func_sig.results()[1]);
-                        let v3 = casted(v3.into(), func_sig.results()[2]);
-                        vec![v1, v2, v3]
+                        let (v1, v2) = split_i64(low)?;
+                        let (v3, _) = split_i64(high)?;
+                        let v1 = casted(v1.into(), func_sig.results()[0])?;
+                        let v2 = casted(v2.into(), func_sig.results()[1])?;
+                        let v3 = casted(v3.into(), func_sig.results()[2])?;
+                        Ok(vec![v1, v2, v3])
                     }
                     [32, 32, 64] => {
-                        let (v1, v2) = split_i64(low);
-                        let v1 = casted(v1.into(), func_sig.results()[0]);
-                        let v2 = casted(v2.into(), func_sig.results()[1]);
-                        let v3 = casted(high.into(), func_sig.results()[2]);
-                        vec![v1, v2, v3]
+                        let (v1, v2) = split_i64(low)?;
+                        let v1 = casted(v1.into(), func_sig.results()[0])?;
+                        let v2 = casted(v2.into(), func_sig.results()[1])?;
+                        let v3 = casted(high.into(), func_sig.results()[2])?;
+                        Ok(vec![v1, v2, v3])
                     }
                     [64, 32, 32] => {
-                        let v1 = casted(low.into(), func_sig.results()[0]);
-                        let (v2, v3) = split_i64(high);
-                        let v2 = casted(v2.into(), func_sig.results()[1]);
-                        let v3 = casted(v3.into(), func_sig.results()[2]);
-                        vec![v1, v2, v3]
+                        let v1 = casted(low.into(), func_sig.results()[0])?;
+                        let (v2, v3) = split_i64(high)?;
+                        let v2 = casted(v2.into(), func_sig.results()[1])?;
+                        let v3 = casted(v3.into(), func_sig.results()[2])?;
+                        Ok(vec![v1, v2, v3])
                     }
                     [32, 32, 32, 32] => {
-                        let (v1, v2) = split_i64(low);
-                        let (v3, v4) = split_i64(high);
-                        let v1 = casted(v1.into(), func_sig.results()[0]);
-                        let v2 = casted(v2.into(), func_sig.results()[1]);
-                        let v3 = casted(v3.into(), func_sig.results()[2]);
-                        let v4 = casted(v4.into(), func_sig.results()[3]);
-                        vec![v1, v2, v3, v4]
+                        let (v1, v2) = split_i64(low)?;
+                        let (v3, v4) = split_i64(high)?;
+                        let v1 = casted(v1.into(), func_sig.results()[0])?;
+                        let v2 = casted(v2.into(), func_sig.results()[1])?;
+                        let v3 = casted(v3.into(), func_sig.results()[2])?;
+                        let v4 = casted(v4.into(), func_sig.results()[3])?;
+                        Ok(vec![v1, v2, v3, v4])
                     }
                     _ => unreachable!("expected an sret for this type"),
                 }
             } else {
                 assert!(func_sig.results().len() == 1);
-                vec![basic_value]
+                Ok(vec![basic_value])
             }
         } else {
             assert!(call_site.count_arguments() > 0); // Either sret or vmctx.
@@ -446,19 +532,18 @@ impl Abi for Aarch64SystemV {
                     .get_context()
                     .struct_type(llvm_results.as_slice(), false);
 
-                let struct_value = builder
-                    .build_load(struct_type, sret, "")
-                    .into_struct_value();
+                let struct_value =
+                    err!(builder.build_load(struct_type, sret, "")).into_struct_value();
                 let mut rets: Vec<_> = Vec::new();
                 for i in 0..struct_value.get_type().count_fields() {
-                    let value = builder.build_extract_value(struct_value, i, "").unwrap();
+                    let value = err!(builder.build_extract_value(struct_value, i, ""));
                     rets.push(value);
                 }
                 assert!(func_sig.results().len() == rets.len());
-                rets
+                Ok(rets)
             } else {
                 assert!(func_sig.results().is_empty());
-                vec![]
+                Ok(vec![])
             }
         }
     }
@@ -471,7 +556,7 @@ impl Abi for Aarch64SystemV {
                 Type::I32 | Type::F32 => 32,
                 Type::I64 | Type::F64 => 64,
                 Type::V128 => 128,
-                Type::ExternRef | Type::FuncRef => 64, /* pointer */
+                Type::ExternRef | Type::FuncRef | Type::ExceptionRef => 64, /* pointer */
             })
             .collect::<Vec<i32>>();
 
@@ -511,56 +596,59 @@ impl Abi for Aarch64SystemV {
             assert!(low.get_type() == intrinsics.i32_ty.as_basic_type_enum());
             assert!(high.get_type() == intrinsics.i32_ty.as_basic_type_enum());
             let (low, high) = (low.into_int_value(), high.into_int_value());
-            let low = builder.build_int_z_extend(low, intrinsics.i64_ty, "");
-            let high = builder.build_int_z_extend(high, intrinsics.i64_ty, "");
-            let high = builder.build_left_shift(high, intrinsics.i64_ty.const_int(32, false), "");
-            builder.build_or(low, high, "").as_basic_value_enum()
+            let low = err!(builder.build_int_z_extend(low, intrinsics.i64_ty, ""));
+            let high = err!(builder.build_int_z_extend(high, intrinsics.i64_ty, ""));
+            let high =
+                err!(builder.build_left_shift(high, intrinsics.i64_ty.const_int(32, false), ""));
+            err_nt!(builder
+                .build_or(low, high, "")
+                .map(|v| v.as_basic_value_enum()))
         };
 
-        let to_i64 = |v: BasicValueEnum<'ctx>| {
+        let to_i64 = |v: BasicValueEnum<'ctx>| -> Result<BasicValueEnum<'_>, CompileError> {
             if v.is_float_value() {
                 let v = v.into_float_value();
                 if v.get_type() == intrinsics.f32_ty {
-                    let v = builder
-                        .build_bitcast(v, intrinsics.i32_ty, "")
-                        .into_int_value();
-                    let v = builder.build_int_z_extend(v, intrinsics.i64_ty, "");
-                    v.as_basic_value_enum()
+                    let v = err!(builder.build_bit_cast(v, intrinsics.i32_ty, "")).into_int_value();
+                    let v = err!(builder.build_int_z_extend(v, intrinsics.i64_ty, ""));
+                    Ok(v.as_basic_value_enum())
                 } else {
                     debug_assert!(v.get_type() == intrinsics.f64_ty);
-                    let v = builder.build_bitcast(v, intrinsics.i64_ty, "");
-                    v.as_basic_value_enum()
+                    let v = err!(builder.build_bit_cast(v, intrinsics.i64_ty, ""));
+                    Ok(v.as_basic_value_enum())
                 }
             } else {
                 let v = v.into_int_value();
                 if v.get_type() == intrinsics.i32_ty {
-                    let v = builder.build_int_z_extend(v, intrinsics.i64_ty, "");
-                    v.as_basic_value_enum()
+                    let v = err!(builder.build_int_z_extend(v, intrinsics.i64_ty, ""));
+                    Ok(v.as_basic_value_enum())
                 } else {
                     debug_assert!(v.get_type() == intrinsics.i64_ty);
-                    v.as_basic_value_enum()
+                    Ok(v.as_basic_value_enum())
                 }
             }
         };
 
-        let build_struct = |ty: StructType<'ctx>, values: &[BasicValueEnum<'ctx>]| {
+        let build_struct = |ty: StructType<'ctx>,
+                            values: &[BasicValueEnum<'ctx>]|
+         -> Result<BasicValueEnum<'_>, CompileError> {
             let mut struct_value = ty.get_undef();
             for (i, v) in values.iter().enumerate() {
-                struct_value = builder
-                    .build_insert_value(struct_value, *v, i as u32, "")
-                    .unwrap()
+                struct_value = err!(builder.build_insert_value(struct_value, *v, i as u32, ""))
                     .into_struct_value();
             }
-            struct_value.as_basic_value_enum()
+            Ok(struct_value.as_basic_value_enum())
         };
 
-        let build_2xi64 = |low: BasicValueEnum<'ctx>, high: BasicValueEnum<'ctx>| {
-            let low = to_i64(low);
-            let high = to_i64(high);
+        let build_2xi64 = |low: BasicValueEnum<'ctx>,
+                           high: BasicValueEnum<'ctx>|
+         -> Result<BasicValueEnum<'_>, CompileError> {
+            let low = to_i64(low)?;
+            let high = to_i64(high)?;
             let value = intrinsics.i64_ty.array_type(2).get_undef();
-            let value = builder.build_insert_value(value, low, 0, "").unwrap();
-            let value = builder.build_insert_value(value, high, 1, "").unwrap();
-            value.as_basic_value_enum()
+            let value = err!(builder.build_insert_value(value, low, 0, ""));
+            let value = err!(builder.build_insert_value(value, high, 1, ""));
+            Ok(value.as_basic_value_enum())
         };
 
         Ok(match *values {
@@ -573,14 +661,14 @@ impl Abi for Aarch64SystemV {
                 build_struct(
                     func_type.get_return_type().unwrap().into_struct_type(),
                     &[v1, v2],
-                )
+                )?
             }
             [v1, v2] if is_32(v1) && is_32(v2) => {
-                let v1 = builder.build_bitcast(v1, intrinsics.i32_ty, "");
-                let v2 = builder.build_bitcast(v2, intrinsics.i32_ty, "");
-                pack_i32s(v1, v2)
+                let v1 = err!(builder.build_bit_cast(v1, intrinsics.i32_ty, ""));
+                let v2 = err!(builder.build_bit_cast(v2, intrinsics.i32_ty, ""));
+                pack_i32s(v1, v2)?
             }
-            [v1, v2] => build_2xi64(v1, v2),
+            [v1, v2] => build_2xi64(v1, v2)?,
             [v1, v2, v3]
                 if is_32(v1)
                     && is_32(v2)
@@ -592,19 +680,19 @@ impl Abi for Aarch64SystemV {
                 build_struct(
                     func_type.get_return_type().unwrap().into_struct_type(),
                     &[v1, v2, v3],
-                )
+                )?
             }
             [v1, v2, v3] if is_32(v1) && is_32(v2) => {
-                let v1 = builder.build_bitcast(v1, intrinsics.i32_ty, "");
-                let v2 = builder.build_bitcast(v2, intrinsics.i32_ty, "");
-                let v1v2_pack = pack_i32s(v1, v2);
-                build_2xi64(v1v2_pack, v3)
+                let v1 = err!(builder.build_bit_cast(v1, intrinsics.i32_ty, ""));
+                let v2 = err!(builder.build_bit_cast(v2, intrinsics.i32_ty, ""));
+                let v1v2_pack = pack_i32s(v1, v2)?;
+                build_2xi64(v1v2_pack, v3)?
             }
             [v1, v2, v3] if is_64(v1) && is_32(v2) && is_32(v3) => {
-                let v2 = builder.build_bitcast(v2, intrinsics.i32_ty, "");
-                let v3 = builder.build_bitcast(v3, intrinsics.i32_ty, "");
-                let v2v3_pack = pack_i32s(v2, v3);
-                build_2xi64(v1, v2v3_pack)
+                let v2 = err!(builder.build_bit_cast(v2, intrinsics.i32_ty, ""));
+                let v3 = err!(builder.build_bit_cast(v3, intrinsics.i32_ty, ""));
+                let v2v3_pack = pack_i32s(v2, v3)?;
+                build_2xi64(v1, v2v3_pack)?
             }
             [v1, v2, v3, v4]
                 if is_32(v1)
@@ -619,16 +707,16 @@ impl Abi for Aarch64SystemV {
                 build_struct(
                     func_type.get_return_type().unwrap().into_struct_type(),
                     &[v1, v2, v3, v4],
-                )
+                )?
             }
             [v1, v2, v3, v4] if is_32(v1) && is_32(v2) && is_32(v3) && is_32(v4) => {
-                let v1 = builder.build_bitcast(v1, intrinsics.i32_ty, "");
-                let v2 = builder.build_bitcast(v2, intrinsics.i32_ty, "");
-                let v1v2_pack = pack_i32s(v1, v2);
-                let v3 = builder.build_bitcast(v3, intrinsics.i32_ty, "");
-                let v4 = builder.build_bitcast(v4, intrinsics.i32_ty, "");
-                let v3v4_pack = pack_i32s(v3, v4);
-                build_2xi64(v1v2_pack, v3v4_pack)
+                let v1 = err!(builder.build_bit_cast(v1, intrinsics.i32_ty, ""));
+                let v2 = err!(builder.build_bit_cast(v2, intrinsics.i32_ty, ""));
+                let v1v2_pack = pack_i32s(v1, v2)?;
+                let v3 = err!(builder.build_bit_cast(v3, intrinsics.i32_ty, ""));
+                let v4 = err!(builder.build_bit_cast(v4, intrinsics.i32_ty, ""));
+                let v3v4_pack = pack_i32s(v3, v4)?;
+                build_2xi64(v1v2_pack, v3v4_pack)?
             }
             _ => {
                 unreachable!("called to perform register return on struct return or void function")
diff --git a/lib/compiler-llvm/src/abi/mod.rs b/lib/compiler-llvm/src/abi/mod.rs
index 06c3bbf993..1bc6446e4a 100644
--- a/lib/compiler-llvm/src/abi/mod.rs
+++ b/lib/compiler-llvm/src/abi/mod.rs
@@ -12,7 +12,7 @@ use inkwell::{
     context::Context,
     targets::TargetMachine,
     types::FunctionType,
-    values::{BasicValueEnum, CallSiteValue, FunctionValue, PointerValue},
+    values::{BasicValueEnum, CallSiteValue, FunctionValue, IntValue, PointerValue},
 };
 use wasmer_types::CompileError;
 use wasmer_types::FunctionType as FuncSig;
@@ -37,6 +37,25 @@ pub fn get_abi(target_machine: &TargetMachine) -> Box<dyn Abi> {
     }
 }
 
+#[derive(Debug)]
+pub(crate) enum G0M0FunctionKind {
+    Local,
+    Imported,
+}
+
+impl G0M0FunctionKind {
+    /// Returns `true` if the function kind is [`Local`].
+    ///
+    /// [`Local`]: FunctionKind::Local
+    #[must_use]
+    pub(crate) fn is_local(&self) -> bool {
+        matches!(self, Self::Local)
+    }
+}
+
+/// The two additional parameters needed for g0m0 optimization.
+pub(crate) type LocalFunctionG0M0params<'ctx> = Option<(IntValue<'ctx>, PointerValue<'ctx>)>;
+
 /// We need to produce different LLVM IR for different platforms. (Contrary to
 /// popular knowledge LLVM IR is not intended to be portable in that way.) This
 /// trait deals with differences between function signatures on different
@@ -45,16 +64,33 @@ pub trait Abi {
     /// Given a function definition, retrieve the parameter that is the vmctx pointer.
     fn get_vmctx_ptr_param<'ctx>(&self, func_value: &FunctionValue<'ctx>) -> PointerValue<'ctx>;
 
+    /// Given a function definition, retrieve the parameter that is the pointer to the first --
+    /// number 0 -- local global.
+    #[allow(unused)]
+    fn get_g0_ptr_param<'ctx>(&self, func_value: &FunctionValue<'ctx>) -> IntValue<'ctx>;
+
+    /// Given a function definition, retrieve the parameter that is the pointer to the first --
+    /// number 0 -- local memory.
+    ///
+    /// # Notes
+    /// This function assumes that g0m0 is enabled.
+    fn get_m0_ptr_param<'ctx>(&self, func_value: &FunctionValue<'ctx>) -> PointerValue<'ctx>;
+
     /// Given a wasm function type, produce an llvm function declaration.
+    ///
+    /// # Notes
+    /// This function assumes that g0m0 is enabled.
     fn func_type_to_llvm<'ctx>(
         &self,
         context: &'ctx Context,
         intrinsics: &Intrinsics<'ctx>,
         offsets: Option<&VMOffsets>,
         sig: &FuncSig,
+        function_kind: Option<G0M0FunctionKind>,
     ) -> Result<(FunctionType<'ctx>, Vec<(Attribute, AttributeLoc)>), CompileError>;
 
     /// Marshall wasm stack values into function parameters.
+    #[allow(clippy::too_many_arguments)]
     fn args_to_call<'ctx>(
         &self,
         alloca_builder: &Builder<'ctx>,
@@ -63,7 +99,8 @@ pub trait Abi {
         ctx_ptr: PointerValue<'ctx>,
         values: &[BasicValueEnum<'ctx>],
         intrinsics: &Intrinsics<'ctx>,
-    ) -> Vec<BasicValueEnum<'ctx>>;
+        g0m0: LocalFunctionG0M0params<'ctx>,
+    ) -> Result<Vec<BasicValueEnum<'ctx>>, CompileError>;
 
     /// Given a CallSite, extract the returned values and return them in a Vec.
     fn rets_from_call<'ctx>(
@@ -72,7 +109,7 @@ pub trait Abi {
         intrinsics: &Intrinsics<'ctx>,
         call_site: CallSiteValue<'ctx>,
         func_sig: &FuncSig,
-    ) -> Vec<BasicValueEnum<'ctx>>;
+    ) -> Result<Vec<BasicValueEnum<'ctx>>, CompileError>;
 
     /// Whether the llvm equivalent of this wasm function has an `sret` attribute.
     fn is_sret(&self, func_sig: &FuncSig) -> Result<bool, CompileError>;
diff --git a/lib/compiler-llvm/src/abi/x86_64_systemv.rs b/lib/compiler-llvm/src/abi/x86_64_systemv.rs
index 47f1f75d16..f0bad7fb01 100644
--- a/lib/compiler-llvm/src/abi/x86_64_systemv.rs
+++ b/lib/compiler-llvm/src/abi/x86_64_systemv.rs
@@ -1,4 +1,5 @@
 use crate::abi::Abi;
+use crate::error::{err, err_nt};
 use crate::translator::intrinsics::{type_to_llvm, Intrinsics};
 use inkwell::{
     attributes::{Attribute, AttributeLoc},
@@ -16,13 +17,15 @@ use wasmer_vm::VMOffsets;
 
 use std::convert::TryInto;
 
+use super::{G0M0FunctionKind, LocalFunctionG0M0params};
+
 /// Implementation of the [`Abi`] trait for the AMD64 SystemV ABI.
 pub struct X86_64SystemV {}
 
 impl Abi for X86_64SystemV {
-    // Given a function definition, retrieve the parameter that is the vmctx pointer.
+    /// Given a function definition, retrieve the parameter that is the vmctx pointer.
     fn get_vmctx_ptr_param<'ctx>(&self, func_value: &FunctionValue<'ctx>) -> PointerValue<'ctx> {
-        func_value
+        let param = func_value
             .get_nth_param(u32::from(
                 func_value
                     .get_enum_attribute(
@@ -31,8 +34,48 @@ impl Abi for X86_64SystemV {
                     )
                     .is_some(),
             ))
-            .unwrap()
-            .into_pointer_value()
+            .unwrap();
+        //param.set_name("vmctx");
+
+        param.into_pointer_value()
+    }
+
+    /// Given a function definition, retrieve the parameter that is the pointer to the first --
+    /// number 0 -- local global.
+    fn get_g0_ptr_param<'ctx>(&self, func_value: &FunctionValue<'ctx>) -> IntValue<'ctx> {
+        // g0 is always after the vmctx.
+        let vmctx_idx = u32::from(
+            func_value
+                .get_enum_attribute(
+                    AttributeLoc::Param(0),
+                    Attribute::get_named_enum_kind_id("sret"),
+                )
+                .is_some(),
+        );
+
+        let param = func_value.get_nth_param(vmctx_idx + 1).unwrap();
+        param.set_name("g0");
+
+        param.into_int_value()
+    }
+
+    /// Given a function definition, retrieve the parameter that is the pointer to the first --
+    /// number 0 -- local memory.
+    fn get_m0_ptr_param<'ctx>(&self, func_value: &FunctionValue<'ctx>) -> PointerValue<'ctx> {
+        // m0 is always after g0.
+        let vmctx_idx = u32::from(
+            func_value
+                .get_enum_attribute(
+                    AttributeLoc::Param(0),
+                    Attribute::get_named_enum_kind_id("sret"),
+                )
+                .is_some(),
+        );
+
+        let param = func_value.get_nth_param(vmctx_idx + 2).unwrap();
+        param.set_name("m0_base_ptr");
+
+        param.into_pointer_value()
     }
 
     // Given a wasm function type, produce an llvm function declaration.
@@ -42,11 +85,19 @@ impl Abi for X86_64SystemV {
         intrinsics: &Intrinsics<'ctx>,
         offsets: Option<&VMOffsets>,
         sig: &FuncSig,
+        function_kind: Option<G0M0FunctionKind>,
     ) -> Result<(FunctionType<'ctx>, Vec<(Attribute, AttributeLoc)>), CompileError> {
         let user_param_types = sig.params().iter().map(|&ty| type_to_llvm(intrinsics, ty));
 
-        let param_types =
-            std::iter::once(Ok(intrinsics.ctx_ptr_ty.as_basic_type_enum())).chain(user_param_types);
+        let mut param_types = vec![Ok(intrinsics.ptr_ty.as_basic_type_enum())];
+        if function_kind.is_some_and(|v| v.is_local()) {
+            // The value of g0
+            param_types.push(Ok(intrinsics.i32_ty.as_basic_type_enum()));
+            // The base pointer to m0
+            param_types.push(Ok(intrinsics.ptr_ty.as_basic_type_enum()));
+        }
+
+        let param_types = param_types.into_iter().chain(user_param_types);
 
         // TODO: figure out how many bytes long vmctx is, and mark it dereferenceable. (no need to mark it nonnull once we do this.)
         let vmctx_attributes = |i: u32| {
@@ -86,7 +137,7 @@ impl Abi for X86_64SystemV {
                 Type::I32 | Type::F32 => 32,
                 Type::I64 | Type::F64 => 64,
                 Type::V128 => 128,
-                Type::ExternRef | Type::FuncRef => 64, /* pointer */
+                Type::ExternRef | Type::FuncRef | Type::ExceptionRef => 64, /* pointer */
             })
             .collect::<Vec<i32>>();
 
@@ -258,7 +309,7 @@ impl Abi for X86_64SystemV {
                     .collect::<Result<_, _>>()?;
 
                 let sret = context.struct_type(&basic_types, false);
-                let sret_ptr = sret.ptr_type(AddressSpace::default());
+                let sret_ptr = context.ptr_type(AddressSpace::default());
 
                 let param_types =
                     std::iter::once(Ok(sret_ptr.as_basic_type_enum())).chain(param_types);
@@ -295,7 +346,8 @@ impl Abi for X86_64SystemV {
         ctx_ptr: PointerValue<'ctx>,
         values: &[BasicValueEnum<'ctx>],
         intrinsics: &Intrinsics<'ctx>,
-    ) -> Vec<BasicValueEnum<'ctx>> {
+        g0m0: LocalFunctionG0M0params<'ctx>,
+    ) -> Result<Vec<BasicValueEnum<'ctx>>, CompileError> {
         // If it's an sret, allocate the return space.
         let sret = if llvm_fn_ty.get_return_type().is_none() && func_sig.results().len() > 1 {
             let llvm_params: Vec<_> = func_sig
@@ -306,20 +358,29 @@ impl Abi for X86_64SystemV {
             let llvm_params = llvm_fn_ty
                 .get_context()
                 .struct_type(llvm_params.as_slice(), false);
-            Some(alloca_builder.build_alloca(llvm_params, "sret"))
+            Some(err!(alloca_builder.build_alloca(llvm_params, "sret")))
         } else {
             None
         };
 
-        let values = std::iter::once(ctx_ptr.as_basic_value_enum()).chain(values.iter().copied());
+        let mut args = vec![ctx_ptr.as_basic_value_enum()];
+
+        if let Some((g0, m0)) = g0m0 {
+            args.push(g0.into());
+            args.push(m0.into());
+        }
 
-        if let Some(sret) = sret {
+        let args = args.into_iter().chain(values.iter().copied());
+
+        let ret = if let Some(sret) = sret {
             std::iter::once(sret.as_basic_value_enum())
-                .chain(values)
+                .chain(args)
                 .collect()
         } else {
-            values.collect()
-        }
+            args.collect()
+        };
+
+        Ok(ret)
     }
 
     // Given a CallSite, extract the returned values and return them in a Vec.
@@ -329,62 +390,68 @@ impl Abi for X86_64SystemV {
         intrinsics: &Intrinsics<'ctx>,
         call_site: CallSiteValue<'ctx>,
         func_sig: &FuncSig,
-    ) -> Vec<BasicValueEnum<'ctx>> {
-        let split_i64 = |value: IntValue<'ctx>| -> (IntValue<'ctx>, IntValue<'ctx>) {
-            assert!(value.get_type() == intrinsics.i64_ty);
-            let low = builder.build_int_truncate(value, intrinsics.i32_ty, "");
-            let lshr =
-                builder.build_right_shift(value, intrinsics.i64_ty.const_int(32, false), false, "");
-            let high = builder.build_int_truncate(lshr, intrinsics.i32_ty, "");
-            (low, high)
-        };
+    ) -> Result<Vec<BasicValueEnum<'ctx>>, CompileError> {
+        let split_i64 =
+            |value: IntValue<'ctx>| -> Result<(IntValue<'ctx>, IntValue<'ctx>), CompileError> {
+                assert!(value.get_type() == intrinsics.i64_ty);
+                let low = err!(builder.build_int_truncate(value, intrinsics.i32_ty, ""));
+                let lshr = err!(builder.build_right_shift(
+                    value,
+                    intrinsics.i64_ty.const_int(32, false),
+                    false,
+                    ""
+                ));
+                let high = err!(builder.build_int_truncate(lshr, intrinsics.i32_ty, ""));
+                Ok((low, high))
+            };
 
         let f32x2_ty = intrinsics.f32_ty.vec_type(2).as_basic_type_enum();
-        let extract_f32x2 = |value: VectorValue<'ctx>| -> (FloatValue<'ctx>, FloatValue<'ctx>) {
+        let extract_f32x2 = |value: VectorValue<'ctx>| -> Result<(FloatValue<'ctx>, FloatValue<'ctx>), CompileError> {
             assert!(value.get_type() == f32x2_ty.into_vector_type());
-            let ret0 = builder
-                .build_extract_element(value, intrinsics.i32_ty.const_int(0, false), "")
+            let ret0 = err!(builder
+                .build_extract_element(value, intrinsics.i32_ty.const_int(0, false), ""))
                 .into_float_value();
-            let ret1 = builder
-                .build_extract_element(value, intrinsics.i32_ty.const_int(1, false), "")
+            let ret1 = err!(builder
+                .build_extract_element(value, intrinsics.i32_ty.const_int(1, false), ""))
                 .into_float_value();
-            (ret0, ret1)
+            Ok((ret0, ret1))
         };
 
-        let casted = |value: BasicValueEnum<'ctx>, ty: Type| -> BasicValueEnum<'ctx> {
-            match ty {
-                Type::I32 => {
-                    assert!(
-                        value.get_type() == intrinsics.i32_ty.as_basic_type_enum()
-                            || value.get_type() == intrinsics.f32_ty.as_basic_type_enum()
-                    );
-                    builder.build_bitcast(value, intrinsics.i32_ty, "")
-                }
-                Type::F32 => {
-                    assert!(
-                        value.get_type() == intrinsics.i32_ty.as_basic_type_enum()
-                            || value.get_type() == intrinsics.f32_ty.as_basic_type_enum()
-                    );
-                    builder.build_bitcast(value, intrinsics.f32_ty, "")
+        let casted =
+            |value: BasicValueEnum<'ctx>, ty: Type| -> Result<BasicValueEnum<'ctx>, CompileError> {
+                match ty {
+                    Type::I32 => {
+                        assert!(
+                            value.get_type() == intrinsics.i32_ty.as_basic_type_enum()
+                                || value.get_type() == intrinsics.f32_ty.as_basic_type_enum()
+                        );
+                        err_nt!(builder.build_bit_cast(value, intrinsics.i32_ty, ""))
+                    }
+                    Type::F32 => {
+                        assert!(
+                            value.get_type() == intrinsics.i32_ty.as_basic_type_enum()
+                                || value.get_type() == intrinsics.f32_ty.as_basic_type_enum()
+                        );
+                        err_nt!(builder.build_bit_cast(value, intrinsics.f32_ty, ""))
+                    }
+                    _ => panic!("should only be called to repack 32-bit values"),
                 }
-                _ => panic!("should only be called to repack 32-bit values"),
-            }
-        };
+            };
 
         if let Some(basic_value) = call_site.try_as_basic_value().left() {
             if func_sig.results().len() > 1 {
                 if basic_value.get_type() == intrinsics.i64_ty.as_basic_type_enum() {
                     assert!(func_sig.results().len() == 2);
                     let value = basic_value.into_int_value();
-                    let (low, high) = split_i64(value);
-                    let low = casted(low.into(), func_sig.results()[0]);
-                    let high = casted(high.into(), func_sig.results()[1]);
-                    return vec![low, high];
+                    let (low, high) = split_i64(value)?;
+                    let low = casted(low.into(), func_sig.results()[0])?;
+                    let high = casted(high.into(), func_sig.results()[1])?;
+                    return Ok(vec![low, high]);
                 }
                 if basic_value.get_type() == f32x2_ty {
                     assert!(func_sig.results().len() == 2);
-                    let (ret0, ret1) = extract_f32x2(basic_value.into_vector_value());
-                    return vec![ret0.into(), ret1.into()];
+                    let (ret0, ret1) = extract_f32x2(basic_value.into_vector_value())?;
+                    return Ok(vec![ret0.into(), ret1.into()]);
                 }
                 let struct_value = basic_value.into_struct_value();
                 let rets = (0..struct_value.get_type().count_fields())
@@ -397,11 +464,11 @@ impl Abi for X86_64SystemV {
                         Type::I32 | Type::F32 => 32,
                         Type::I64 | Type::F64 => 64,
                         Type::V128 => 128,
-                        Type::ExternRef | Type::FuncRef => 64, /* pointer */
+                        Type::ExternRef | Type::FuncRef | Type::ExceptionRef => 64, /* pointer */
                     })
                     .collect::<Vec<i32>>();
 
-                match func_sig_returns_bitwidths.as_slice() {
+                let ret = match func_sig_returns_bitwidths.as_slice() {
                     [32, 64] | [64, 32] | [64, 64] => {
                         assert!(func_sig.results().len() == 2);
                         vec![rets[0], rets[1]]
@@ -411,14 +478,14 @@ impl Abi for X86_64SystemV {
                             == intrinsics.f32_ty.vec_type(2).as_basic_type_enum() =>
                     {
                         assert!(func_sig.results().len() == 3);
-                        let (rets0, rets1) = extract_f32x2(rets[0].into_vector_value());
+                        let (rets0, rets1) = extract_f32x2(rets[0].into_vector_value())?;
                         vec![rets0.into(), rets1.into(), rets[1]]
                     }
                     [32, 32, _] => {
                         assert!(func_sig.results().len() == 3);
-                        let (low, high) = split_i64(rets[0].into_int_value());
-                        let low = casted(low.into(), func_sig.results()[0]);
-                        let high = casted(high.into(), func_sig.results()[1]);
+                        let (low, high) = split_i64(rets[0].into_int_value())?;
+                        let low = casted(low.into(), func_sig.results()[0])?;
+                        let high = casted(high.into(), func_sig.results()[1])?;
                         vec![low, high, rets[1]]
                     }
                     [64, 32, 32]
@@ -426,14 +493,14 @@ impl Abi for X86_64SystemV {
                             == intrinsics.f32_ty.vec_type(2).as_basic_type_enum() =>
                     {
                         assert!(func_sig.results().len() == 3);
-                        let (rets1, rets2) = extract_f32x2(rets[1].into_vector_value());
+                        let (rets1, rets2) = extract_f32x2(rets[1].into_vector_value())?;
                         vec![rets[0], rets1.into(), rets2.into()]
                     }
                     [64, 32, 32] => {
                         assert!(func_sig.results().len() == 3);
-                        let (rets1, rets2) = split_i64(rets[1].into_int_value());
-                        let rets1 = casted(rets1.into(), func_sig.results()[1]);
-                        let rets2 = casted(rets2.into(), func_sig.results()[2]);
+                        let (rets1, rets2) = split_i64(rets[1].into_int_value())?;
+                        let rets1 = casted(rets1.into(), func_sig.results()[1])?;
+                        let rets2 = casted(rets2.into(), func_sig.results()[2])?;
                         vec![rets[0], rets1, rets2]
                     }
                     [32, 32, 32, 32] => {
@@ -441,32 +508,34 @@ impl Abi for X86_64SystemV {
                         let (low0, high0) = if rets[0].get_type()
                             == intrinsics.f32_ty.vec_type(2).as_basic_type_enum()
                         {
-                            let (x, y) = extract_f32x2(rets[0].into_vector_value());
+                            let (x, y) = extract_f32x2(rets[0].into_vector_value())?;
                             (x.into(), y.into())
                         } else {
-                            let (x, y) = split_i64(rets[0].into_int_value());
+                            let (x, y) = split_i64(rets[0].into_int_value())?;
                             (x.into(), y.into())
                         };
                         let (low1, high1) = if rets[1].get_type()
                             == intrinsics.f32_ty.vec_type(2).as_basic_type_enum()
                         {
-                            let (x, y) = extract_f32x2(rets[1].into_vector_value());
+                            let (x, y) = extract_f32x2(rets[1].into_vector_value())?;
                             (x.into(), y.into())
                         } else {
-                            let (x, y) = split_i64(rets[1].into_int_value());
+                            let (x, y) = split_i64(rets[1].into_int_value())?;
                             (x.into(), y.into())
                         };
-                        let low0 = casted(low0, func_sig.results()[0]);
-                        let high0 = casted(high0, func_sig.results()[1]);
-                        let low1 = casted(low1, func_sig.results()[2]);
-                        let high1 = casted(high1, func_sig.results()[3]);
+                        let low0 = casted(low0, func_sig.results()[0])?;
+                        let high0 = casted(high0, func_sig.results()[1])?;
+                        let low1 = casted(low1, func_sig.results()[2])?;
+                        let high1 = casted(high1, func_sig.results()[3])?;
                         vec![low0, high0, low1, high1]
                     }
                     _ => unreachable!("expected an sret for this type"),
-                }
+                };
+
+                Ok(ret)
             } else {
                 assert!(func_sig.results().len() == 1);
-                vec![basic_value]
+                Ok(vec![basic_value])
             }
         } else {
             assert!(call_site.count_arguments() > 0); // Either sret or vmctx.
@@ -497,19 +566,18 @@ impl Abi for X86_64SystemV {
                     .get_context()
                     .struct_type(llvm_results.as_slice(), false);
 
-                let struct_value = builder
-                    .build_load(struct_type, sret, "")
-                    .into_struct_value();
+                let struct_value =
+                    err!(builder.build_load(struct_type, sret, "")).into_struct_value();
                 let mut rets: Vec<_> = Vec::new();
                 for i in 0..struct_value.get_type().count_fields() {
                     let value = builder.build_extract_value(struct_value, i, "").unwrap();
                     rets.push(value);
                 }
                 assert!(func_sig.results().len() == rets.len());
-                rets
+                Ok(rets)
             } else {
                 assert!(func_sig.results().is_empty());
-                vec![]
+                Ok(vec![])
             }
         }
     }
@@ -522,7 +590,7 @@ impl Abi for X86_64SystemV {
                 Type::I32 | Type::F32 => 32,
                 Type::I64 | Type::F64 => 64,
                 Type::V128 => 128,
-                Type::ExternRef | Type::FuncRef => 64, /* pointer */
+                Type::ExternRef | Type::FuncRef | Type::ExceptionRef => 64, /* pointer */
             })
             .collect::<Vec<i32>>();
 
@@ -565,24 +633,31 @@ impl Abi for X86_64SystemV {
             assert!(low.get_type() == intrinsics.i32_ty.as_basic_type_enum());
             assert!(high.get_type() == intrinsics.i32_ty.as_basic_type_enum());
             let (low, high) = (low.into_int_value(), high.into_int_value());
-            let low = builder.build_int_z_extend(low, intrinsics.i64_ty, "");
-            let high = builder.build_int_z_extend(high, intrinsics.i64_ty, "");
-            let high = builder.build_left_shift(high, intrinsics.i64_ty.const_int(32, false), "");
-            builder.build_or(low, high, "").as_basic_value_enum()
+            let low = err!(builder.build_int_z_extend(low, intrinsics.i64_ty, ""));
+            let high = err!(builder.build_int_z_extend(high, intrinsics.i64_ty, ""));
+            let high =
+                err!(builder.build_left_shift(high, intrinsics.i64_ty.const_int(32, false), ""));
+            err_nt!(builder
+                .build_or(low, high, "")
+                .map(|v| v.as_basic_value_enum()))
         };
 
         let pack_f32s = |first: BasicValueEnum<'ctx>,
                          second: BasicValueEnum<'ctx>|
-         -> BasicValueEnum<'ctx> {
+         -> Result<BasicValueEnum<'ctx>, CompileError> {
             assert!(first.get_type() == intrinsics.f32_ty.as_basic_type_enum());
             assert!(second.get_type() == intrinsics.f32_ty.as_basic_type_enum());
             let (first, second) = (first.into_float_value(), second.into_float_value());
             let vec_ty = intrinsics.f32_ty.vec_type(2);
-            let vec =
-                builder.build_insert_element(vec_ty.get_undef(), first, intrinsics.i32_zero, "");
-            builder
+            let vec = err!(builder.build_insert_element(
+                vec_ty.get_undef(),
+                first,
+                intrinsics.i32_zero,
+                ""
+            ));
+            err_nt!(builder
                 .build_insert_element(vec, second, intrinsics.i32_ty.const_int(1, false), "")
-                .as_basic_value_enum()
+                .map(|v| v.as_basic_value_enum()))
         };
 
         let build_struct = |ty: StructType<'ctx>, values: &[BasicValueEnum<'ctx>]| {
@@ -598,11 +673,11 @@ impl Abi for X86_64SystemV {
 
         Ok(match *values {
             [one_value] => one_value,
-            [v1, v2] if is_f32(v1) && is_f32(v2) => pack_f32s(v1, v2),
+            [v1, v2] if is_f32(v1) && is_f32(v2) => pack_f32s(v1, v2)?,
             [v1, v2] if is_32(v1) && is_32(v2) => {
-                let v1 = builder.build_bitcast(v1, intrinsics.i32_ty, "");
-                let v2 = builder.build_bitcast(v2, intrinsics.i32_ty, "");
-                pack_i32s(v1, v2)
+                let v1 = err!(builder.build_bit_cast(v1, intrinsics.i32_ty, ""));
+                let v2 = err!(builder.build_bit_cast(v2, intrinsics.i32_ty, ""));
+                pack_i32s(v1, v2)?
             }
             [v1, v2] => {
                 assert!(!(is_32(v1) && is_32(v2)));
@@ -613,42 +688,42 @@ impl Abi for X86_64SystemV {
             }
             [v1, v2, v3] if is_f32(v1) && is_f32(v2) => build_struct(
                 func_type.get_return_type().unwrap().into_struct_type(),
-                &[pack_f32s(v1, v2), v3],
+                &[pack_f32s(v1, v2)?, v3],
             ),
             [v1, v2, v3] if is_32(v1) && is_32(v2) => {
-                let v1 = builder.build_bitcast(v1, intrinsics.i32_ty, "");
-                let v2 = builder.build_bitcast(v2, intrinsics.i32_ty, "");
+                let v1 = err!(builder.build_bit_cast(v1, intrinsics.i32_ty, ""));
+                let v2 = err!(builder.build_bit_cast(v2, intrinsics.i32_ty, ""));
                 build_struct(
                     func_type.get_return_type().unwrap().into_struct_type(),
-                    &[pack_i32s(v1, v2), v3],
+                    &[pack_i32s(v1, v2)?, v3],
                 )
             }
             [v1, v2, v3] if is_64(v1) && is_f32(v2) && is_f32(v3) => build_struct(
                 func_type.get_return_type().unwrap().into_struct_type(),
-                &[v1, pack_f32s(v2, v3)],
+                &[v1, pack_f32s(v2, v3)?],
             ),
             [v1, v2, v3] if is_64(v1) && is_32(v2) && is_32(v3) => {
-                let v2 = builder.build_bitcast(v2, intrinsics.i32_ty, "");
-                let v3 = builder.build_bitcast(v3, intrinsics.i32_ty, "");
+                let v2 = err!(builder.build_bit_cast(v2, intrinsics.i32_ty, ""));
+                let v3 = err!(builder.build_bit_cast(v3, intrinsics.i32_ty, ""));
                 build_struct(
                     func_type.get_return_type().unwrap().into_struct_type(),
-                    &[v1, pack_i32s(v2, v3)],
+                    &[v1, pack_i32s(v2, v3)?],
                 )
             }
             [v1, v2, v3, v4] if is_32(v1) && is_32(v2) && is_32(v3) && is_32(v4) => {
                 let v1v2_pack = if is_f32(v1) && is_f32(v2) {
-                    pack_f32s(v1, v2)
+                    pack_f32s(v1, v2)?
                 } else {
-                    let v1 = builder.build_bitcast(v1, intrinsics.i32_ty, "");
-                    let v2 = builder.build_bitcast(v2, intrinsics.i32_ty, "");
-                    pack_i32s(v1, v2)
+                    let v1 = err!(builder.build_bit_cast(v1, intrinsics.i32_ty, ""));
+                    let v2 = err!(builder.build_bit_cast(v2, intrinsics.i32_ty, ""));
+                    pack_i32s(v1, v2)?
                 };
                 let v3v4_pack = if is_f32(v3) && is_f32(v4) {
-                    pack_f32s(v3, v4)
+                    pack_f32s(v3, v4)?
                 } else {
-                    let v3 = builder.build_bitcast(v3, intrinsics.i32_ty, "");
-                    let v4 = builder.build_bitcast(v4, intrinsics.i32_ty, "");
-                    pack_i32s(v3, v4)
+                    let v3 = err!(builder.build_bit_cast(v3, intrinsics.i32_ty, ""));
+                    let v4 = err!(builder.build_bit_cast(v4, intrinsics.i32_ty, ""));
+                    pack_i32s(v3, v4)?
                 };
                 build_struct(
                     func_type.get_return_type().unwrap().into_struct_type(),
diff --git a/lib/compiler-llvm/src/compiler.rs b/lib/compiler-llvm/src/compiler.rs
index 176402c47b..376dd03207 100644
--- a/lib/compiler-llvm/src/compiler.rs
+++ b/lib/compiler-llvm/src/compiler.rs
@@ -9,19 +9,29 @@ use inkwell::targets::FileType;
 use inkwell::DLLStorageClass;
 use rayon::iter::ParallelBridge;
 use rayon::prelude::{IntoParallelIterator, IntoParallelRefIterator, ParallelIterator};
+use rayon::ThreadPoolBuilder;
+use std::borrow::Cow;
+use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
-use wasmer_compiler::{Compiler, FunctionBodyData, ModuleMiddleware, ModuleTranslationState};
-use wasmer_types::entity::{EntityRef, PrimaryMap};
-use wasmer_types::{
-    Compilation, CompileError, CompileModuleInfo, CustomSection, CustomSectionProtection, Dwarf,
-    FunctionIndex, LocalFunctionIndex, RelocationTarget, SectionBody, SectionIndex, SignatureIndex,
-    Symbol, SymbolRegistry, Target,
+use wasmer_compiler::types::function::{Compilation, UnwindInfo};
+use wasmer_compiler::types::module::CompileModuleInfo;
+use wasmer_compiler::types::relocation::RelocationKind;
+use wasmer_compiler::{
+    types::{
+        relocation::RelocationTarget,
+        section::{CustomSection, CustomSectionProtection, SectionBody, SectionIndex},
+        symbols::{Symbol, SymbolRegistry},
+    },
+    Compiler, FunctionBodyData, ModuleMiddleware, ModuleTranslationState,
 };
-
-//use std::sync::Mutex;
+use wasmer_types::entity::{EntityRef, PrimaryMap};
+use wasmer_types::target::Target;
+use wasmer_types::{CompileError, FunctionIndex, LocalFunctionIndex, ModuleInfo, SignatureIndex};
+use wasmer_vm::LibCall;
 
 /// A compiler that compiles a WebAssembly module with LLVM, translating the Wasm to LLVM IR,
 /// optimizing it and then translating to assembly.
+#[derive(Debug)]
 pub struct LLVMCompiler {
     config: LLVM,
 }
@@ -75,7 +85,85 @@ impl SymbolRegistry for ShortNames {
     }
 }
 
+struct ModuleBasedSymbolRegistry {
+    wasm_module: Arc<ModuleInfo>,
+    local_func_names: HashMap<String, LocalFunctionIndex>,
+    short_names: ShortNames,
+}
+
+impl ModuleBasedSymbolRegistry {
+    const PROBLEMATIC_PREFIXES: &[&'static str] = &[
+        ".L",    // .L is used for local symbols
+        "llvm.", // llvm. is used for LLVM's own intrinsics
+    ];
+
+    fn new(wasm_module: Arc<ModuleInfo>) -> Self {
+        let local_func_names = HashMap::from_iter(
+            wasm_module
+                .function_names
+                .iter()
+                .map(|(f, v)| (wasm_module.local_func_index(*f), v))
+                .filter(|(f, _)| f.is_some())
+                .map(|(f, v)| (format!("{}_{}", v.clone(), f.unwrap().as_u32()), f.unwrap())),
+        );
+        Self {
+            wasm_module,
+            local_func_names,
+            short_names: ShortNames {},
+        }
+    }
+
+    // If the name starts with a problematic prefix, we prefix it with an underscore.
+    fn fixup_problematic_name(name: &str) -> Cow<str> {
+        for prefix in Self::PROBLEMATIC_PREFIXES {
+            if name.starts_with(prefix) {
+                return format!("_{name}").into();
+            }
+        }
+        name.into()
+    }
+
+    // If the name starts with an underscore and the rest starts with a problematic prefix,
+    // remove the underscore to get back the original name. This is necessary to be able
+    // to match the name back to the original name in the wasm module.
+    fn unfixup_problematic_name(name: &str) -> &str {
+        if let Some(stripped_name) = name.strip_prefix('_') {
+            for prefix in Self::PROBLEMATIC_PREFIXES {
+                if stripped_name.starts_with(prefix) {
+                    return stripped_name;
+                }
+            }
+        }
+
+        name
+    }
+}
+
+impl SymbolRegistry for ModuleBasedSymbolRegistry {
+    fn symbol_to_name(&self, symbol: Symbol) -> String {
+        match symbol {
+            Symbol::LocalFunction(index) => self
+                .wasm_module
+                .function_names
+                .get(&self.wasm_module.func_index(index))
+                .map(|name| format!("{}_{}", Self::fixup_problematic_name(name), index.as_u32()))
+                .unwrap_or(self.short_names.symbol_to_name(symbol)),
+            _ => self.short_names.symbol_to_name(symbol),
+        }
+    }
+
+    fn name_to_symbol(&self, name: &str) -> Option<Symbol> {
+        let name = Self::unfixup_problematic_name(name);
+        if let Some(idx) = self.local_func_names.get(name) {
+            Some(Symbol::LocalFunction(*idx))
+        } else {
+            self.short_names.name_to_symbol(name)
+        }
+    }
+}
+
 impl LLVMCompiler {
+    #[allow(clippy::too_many_arguments)]
     fn compile_native_object(
         &self,
         target: &Target,
@@ -84,6 +172,7 @@ impl LLVMCompiler {
         function_body_inputs: &PrimaryMap<LocalFunctionIndex, FunctionBodyData<'_>>,
         symbol_registry: &dyn SymbolRegistry,
         wasmer_metadata: &[u8],
+        binary_format: target_lexicon::BinaryFormat,
     ) -> Result<Vec<u8>, CompileError> {
         let target_machine = self.config().target_machine(target);
         let ctx = Context::create();
@@ -93,7 +182,7 @@ impl LLVMCompiler {
         let merged_bitcode = function_body_inputs.into_iter().par_bridge().map_init(
             || {
                 let target_machine = self.config().target_machine(target);
-                FuncTranslator::new(target_machine)
+                FuncTranslator::new(target_machine, binary_format).unwrap()
             },
             |func_translator, (i, input)| {
                 let module = func_translator.translate_to_module(
@@ -106,6 +195,7 @@ impl LLVMCompiler {
                     &compile_info.table_styles,
                     symbol_registry,
                 )?;
+
                 Ok(module.write_bitcode_to_memory().as_slice().to_vec())
             },
         );
@@ -113,11 +203,16 @@ impl LLVMCompiler {
         let trampolines_bitcode = compile_info.module.signatures.iter().par_bridge().map_init(
             || {
                 let target_machine = self.config().target_machine(target);
-                FuncTrampoline::new(target_machine)
+                FuncTrampoline::new(target_machine, binary_format).unwrap()
             },
             |func_trampoline, (i, sig)| {
                 let name = symbol_registry.symbol_to_name(Symbol::FunctionCallTrampoline(i));
-                let module = func_trampoline.trampoline_to_module(sig, self.config(), &name)?;
+                let module = func_trampoline.trampoline_to_module(
+                    sig,
+                    self.config(),
+                    &name,
+                    compile_info,
+                )?;
                 Ok(module.write_bitcode_to_memory().as_slice().to_vec())
             },
         );
@@ -127,7 +222,7 @@ impl LLVMCompiler {
                 || {
                     let target_machine = self.config().target_machine(target);
                     (
-                        FuncTrampoline::new(target_machine),
+                        FuncTrampoline::new(target_machine, binary_format).unwrap(),
                         &compile_info.module.signatures,
                     )
                 },
@@ -172,7 +267,7 @@ impl LLVMCompiler {
         let metadata_gv = merged_module.add_global(
             metadata_init.get_type(),
             None,
-            &symbol_registry.symbol_to_name(wasmer_types::Symbol::Metadata),
+            &symbol_registry.symbol_to_name(wasmer_compiler::types::symbols::Symbol::Metadata),
         );
         metadata_gv.set_initializer(&metadata_init);
         metadata_gv.set_linkage(Linkage::DLLExport);
@@ -190,6 +285,7 @@ impl LLVMCompiler {
             callbacks.obj_memory_buffer(&CompiledKind::Module, &memory_buffer);
         }
 
+        tracing::trace!("Finished compling the module!");
         Ok(memory_buffer.as_slice().to_vec())
     }
 }
@@ -199,6 +295,28 @@ impl Compiler for LLVMCompiler {
         "llvm"
     }
 
+    fn get_perfmap_enabled(&self) -> bool {
+        self.config.enable_perfmap
+    }
+
+    fn deterministic_id(&self) -> String {
+        let mut ret = format!(
+            "llvm-{}",
+            match self.config.opt_level {
+                inkwell::OptimizationLevel::None => "opt0",
+                inkwell::OptimizationLevel::Less => "optl",
+                inkwell::OptimizationLevel::Default => "optd",
+                inkwell::OptimizationLevel::Aggressive => "opta",
+            }
+        );
+
+        if self.config.enable_g0m0_opt {
+            ret.push_str("-g0m0");
+        }
+
+        ret
+    }
+
     /// Get the middlewares for this compiler
     fn get_middlewares(&self) -> &[Arc<dyn ModuleMiddleware>] {
         &self.config.middlewares
@@ -222,6 +340,7 @@ impl Compiler for LLVMCompiler {
             function_body_inputs,
             symbol_registry,
             wasmer_metadata,
+            self.config.target_binary_format(target),
         ))
     }
 
@@ -235,41 +354,94 @@ impl Compiler for LLVMCompiler {
         function_body_inputs: PrimaryMap<LocalFunctionIndex, FunctionBodyData<'_>>,
     ) -> Result<Compilation, CompileError> {
         //let data = Arc::new(Mutex::new(0));
+
         let memory_styles = &compile_info.memory_styles;
         let table_styles = &compile_info.table_styles;
+        let binary_format = self.config.target_binary_format(target);
 
         let module = &compile_info.module;
 
         // TODO: merge constants in sections.
 
         let mut module_custom_sections = PrimaryMap::new();
-        let mut frame_section_bytes = vec![];
-        let mut frame_section_relocations = vec![];
-        let functions = function_body_inputs
-            .iter()
-            .collect::<Vec<(LocalFunctionIndex, &FunctionBodyData<'_>)>>()
-            .par_iter()
-            .map_init(
-                || {
-                    let target_machine = self.config().target_machine(target);
-                    FuncTranslator::new(target_machine)
-                },
-                |func_translator, (i, input)| {
+
+        let mut eh_frame_section_bytes = vec![];
+        let mut eh_frame_section_relocations = vec![];
+
+        let mut compact_unwind_section_bytes = vec![];
+        let mut compact_unwind_section_relocations = vec![];
+
+        let mut got_targets: HashSet<wasmer_compiler::types::relocation::RelocationTarget> = if matches!(
+            target.triple().binary_format,
+            target_lexicon::BinaryFormat::Macho
+        ) {
+            HashSet::from_iter(vec![RelocationTarget::LibCall(LibCall::EHPersonality)])
+        } else {
+            HashSet::default()
+        };
+
+        let symbol_registry = ModuleBasedSymbolRegistry::new(module.clone());
+
+        let functions = if self.config.num_threads.get() > 1 {
+            let pool = ThreadPoolBuilder::new()
+                .num_threads(self.config.num_threads.get())
+                .build()
+                .map_err(|e| CompileError::Resource(e.to_string()))?;
+            pool.install(|| {
+                function_body_inputs
+                    .iter()
+                    .collect::<Vec<(LocalFunctionIndex, &FunctionBodyData<'_>)>>()
+                    .par_iter()
+                    .map_init(
+                        || {
+                            let target_machine = self.config().target_machine(target);
+                            FuncTranslator::new(target_machine, binary_format).unwrap()
+                        },
+                        |func_translator, (i, input)| {
+                            // TODO: remove (to serialize)
+                            //let _data = data.lock().unwrap();
+
+                            func_translator.translate(
+                                module,
+                                module_translation,
+                                i,
+                                input,
+                                self.config(),
+                                memory_styles,
+                                table_styles,
+                                &symbol_registry,
+                            )
+                        },
+                    )
+                    .collect::<Result<Vec<_>, CompileError>>()
+            })?
+        } else {
+            let target_machine = self.config().target_machine(target);
+            let func_translator = FuncTranslator::new(target_machine, binary_format).unwrap();
+
+            function_body_inputs
+                .iter()
+                .collect::<Vec<(LocalFunctionIndex, &FunctionBodyData<'_>)>>()
+                .into_iter()
+                .map(|(i, input)| {
                     // TODO: remove (to serialize)
                     //let _data = data.lock().unwrap();
+
                     func_translator.translate(
                         module,
                         module_translation,
-                        i,
+                        &i,
                         input,
                         self.config(),
                         memory_styles,
                         table_styles,
-                        &ShortNames {},
+                        &symbol_registry,
                     )
-                },
-            )
-            .collect::<Result<Vec<_>, CompileError>>()?
+                })
+                .collect::<Result<Vec<_>, CompileError>>()?
+        };
+
+        let functions = functions
             .into_iter()
             .map(|mut compiled_function| {
                 let first_section = module_custom_sections.len() as u32;
@@ -282,20 +454,44 @@ impl Compiler for LLVMCompiler {
                                 SectionIndex::from_u32(first_section + index.as_u32()),
                             )
                         }
+
+                        if reloc.kind.needs_got() {
+                            got_targets.insert(reloc.reloc_target);
+                        }
                     }
+
                     if compiled_function
                         .eh_frame_section_indices
                         .contains(&section_index)
                     {
-                        let offset = frame_section_bytes.len() as u32;
+                        let offset = eh_frame_section_bytes.len() as u32;
+                        for reloc in &mut custom_section.relocations {
+                            reloc.offset += offset;
+                        }
+                        eh_frame_section_bytes.extend_from_slice(custom_section.bytes.as_slice());
+                        eh_frame_section_relocations.extend(custom_section.relocations);
+                        // TODO: we do this to keep the count right, remove it.
+                        module_custom_sections.push(CustomSection {
+                            protection: CustomSectionProtection::Read,
+                            alignment: None,
+                            bytes: SectionBody::new_with_vec(vec![]),
+                            relocations: vec![],
+                        });
+                    } else if compiled_function
+                        .compact_unwind_section_indices
+                        .contains(&section_index)
+                    {
+                        let offset = compact_unwind_section_bytes.len() as u32;
                         for reloc in &mut custom_section.relocations {
                             reloc.offset += offset;
                         }
-                        frame_section_bytes.extend_from_slice(custom_section.bytes.as_slice());
-                        frame_section_relocations.extend(custom_section.relocations);
+                        compact_unwind_section_bytes
+                            .extend_from_slice(custom_section.bytes.as_slice());
+                        compact_unwind_section_relocations.extend(custom_section.relocations);
                         // TODO: we do this to keep the count right, remove it.
                         module_custom_sections.push(CustomSection {
                             protection: CustomSectionProtection::Read,
+                            alignment: None,
                             bytes: SectionBody::new_with_vec(vec![]),
                             relocations: vec![],
                         });
@@ -309,67 +505,178 @@ impl Compiler for LLVMCompiler {
                             SectionIndex::from_u32(first_section + index.as_u32()),
                         )
                     }
+
+                    if reloc.kind.needs_got() {
+                        got_targets.insert(reloc.reloc_target);
+                    }
                 }
                 compiled_function.compiled_function
             })
             .collect::<PrimaryMap<LocalFunctionIndex, _>>();
 
-        let dwarf = if !frame_section_bytes.is_empty() {
-            let dwarf = Some(Dwarf::new(SectionIndex::from_u32(
-                module_custom_sections.len() as u32,
-            )));
-            // Do not terminate dwarf info with a zero-length CIE.
-            // Because more info will be added later
-            // in lib/object/src/module.rs emit_compilation
+        let mut unwind_info = UnwindInfo::default();
+
+        if !eh_frame_section_bytes.is_empty() {
+            let eh_frame_idx = SectionIndex::from_u32(module_custom_sections.len() as u32);
+            // Terminate the eh_frame info with a zero-length CIE.
+            //
+            // There may be more info added later in lib/object/src/module.rs emit_compilation
+            // but that's okay, because an eh_frame can have multiple CIEs.
+            eh_frame_section_bytes.extend_from_slice(&[0, 0, 0, 0]);
             module_custom_sections.push(CustomSection {
                 protection: CustomSectionProtection::Read,
-                bytes: SectionBody::new_with_vec(frame_section_bytes),
-                relocations: frame_section_relocations,
+                alignment: None,
+                bytes: SectionBody::new_with_vec(eh_frame_section_bytes),
+                relocations: eh_frame_section_relocations,
             });
-            dwarf
+            unwind_info.eh_frame = Some(eh_frame_idx);
+        }
+
+        if !compact_unwind_section_bytes.is_empty() {
+            let cu_index = SectionIndex::from_u32(module_custom_sections.len() as u32);
+            module_custom_sections.push(CustomSection {
+                protection: CustomSectionProtection::Read,
+                alignment: None,
+                bytes: SectionBody::new_with_vec(compact_unwind_section_bytes),
+                relocations: compact_unwind_section_relocations,
+            });
+            unwind_info.compact_unwind = Some(cu_index);
+        }
+
+        let function_call_trampolines = if self.config.num_threads.get() > 1 {
+            let pool = ThreadPoolBuilder::new()
+                .num_threads(self.config.num_threads.get())
+                .build()
+                .map_err(|e| CompileError::Resource(e.to_string()))?;
+            pool.install(|| {
+                module
+                    .signatures
+                    .values()
+                    .collect::<Vec<_>>()
+                    .par_iter()
+                    .map_init(
+                        || {
+                            let target_machine = self.config().target_machine(target);
+                            FuncTrampoline::new(target_machine, binary_format).unwrap()
+                        },
+                        |func_trampoline, sig| {
+                            func_trampoline.trampoline(sig, self.config(), "", compile_info)
+                        },
+                    )
+                    .collect::<Vec<_>>()
+                    .into_iter()
+                    .collect::<Result<PrimaryMap<_, _>, CompileError>>()
+            })?
         } else {
-            None
+            let target_machine = self.config().target_machine(target);
+            let func_trampoline = FuncTrampoline::new(target_machine, binary_format).unwrap();
+            module
+                .signatures
+                .values()
+                .collect::<Vec<_>>()
+                .into_iter()
+                .map(|sig| func_trampoline.trampoline(sig, self.config(), "", compile_info))
+                .collect::<Vec<_>>()
+                .into_iter()
+                .collect::<Result<PrimaryMap<_, _>, CompileError>>()?
         };
 
-        let function_call_trampolines = module
-            .signatures
-            .values()
-            .collect::<Vec<_>>()
-            .par_iter()
-            .map_init(
-                || {
-                    let target_machine = self.config().target_machine(target);
-                    FuncTrampoline::new(target_machine)
-                },
-                |func_trampoline, sig| func_trampoline.trampoline(sig, self.config(), ""),
-            )
-            .collect::<Vec<_>>()
-            .into_iter()
-            .collect::<Result<PrimaryMap<_, _>, CompileError>>()?;
+        let dynamic_function_trampolines = if self.config.num_threads.get() > 1 {
+            let pool = ThreadPoolBuilder::new()
+                .num_threads(self.config.num_threads.get())
+                .build()
+                .map_err(|e| CompileError::Resource(e.to_string()))?;
+            pool.install(|| {
+                module
+                    .imported_function_types()
+                    .collect::<Vec<_>>()
+                    .par_iter()
+                    .map_init(
+                        || {
+                            let target_machine = self.config().target_machine(target);
+                            FuncTrampoline::new(target_machine, binary_format).unwrap()
+                        },
+                        |func_trampoline, func_type| {
+                            func_trampoline.dynamic_trampoline(func_type, self.config(), "")
+                        },
+                    )
+                    .collect::<Vec<_>>()
+                    .into_iter()
+                    .collect::<Result<PrimaryMap<_, _>, CompileError>>()
+            })?
+        } else {
+            let target_machine = self.config().target_machine(target);
+            let func_trampoline = FuncTrampoline::new(target_machine, binary_format).unwrap();
+            module
+                .imported_function_types()
+                .collect::<Vec<_>>()
+                .into_iter()
+                .map(|func_type| func_trampoline.dynamic_trampoline(&func_type, self.config(), ""))
+                .collect::<Vec<_>>()
+                .into_iter()
+                .collect::<Result<PrimaryMap<_, _>, CompileError>>()?
+        };
 
-        let dynamic_function_trampolines = module
-            .imported_function_types()
-            .collect::<Vec<_>>()
-            .par_iter()
-            .map_init(
-                || {
-                    let target_machine = self.config().target_machine(target);
-                    FuncTrampoline::new(target_machine)
-                },
-                |func_trampoline, func_type| {
-                    func_trampoline.dynamic_trampoline(func_type, self.config(), "")
-                },
-            )
-            .collect::<Result<Vec<_>, CompileError>>()?
-            .into_iter()
-            .collect::<PrimaryMap<_, _>>();
+        let mut got = wasmer_compiler::types::function::GOT::empty();
+
+        if !got_targets.is_empty() {
+            let pointer_width = target
+                .triple()
+                .pointer_width()
+                .map_err(|_| CompileError::Codegen("Could not get pointer width".to_string()))?;
+
+            let got_entry_size = match pointer_width {
+                target_lexicon::PointerWidth::U64 => 8,
+                target_lexicon::PointerWidth::U32 => 4,
+                target_lexicon::PointerWidth::U16 => todo!(),
+            };
+
+            let got_entry_reloc_kind = match pointer_width {
+                target_lexicon::PointerWidth::U64 => RelocationKind::Abs8,
+                target_lexicon::PointerWidth::U32 => RelocationKind::Abs4,
+                target_lexicon::PointerWidth::U16 => todo!(),
+            };
+
+            let got_data: Vec<u8> = vec![0; got_targets.len() * got_entry_size];
+            let mut got_relocs = vec![];
+
+            for (i, target) in got_targets.into_iter().enumerate() {
+                got_relocs.push(wasmer_compiler::types::relocation::Relocation {
+                    kind: got_entry_reloc_kind,
+                    reloc_target: target,
+                    offset: (i * got_entry_size) as u32,
+                    addend: 0,
+                });
+            }
+
+            let got_idx = SectionIndex::from_u32(module_custom_sections.len() as u32);
+            module_custom_sections.push(CustomSection {
+                protection: CustomSectionProtection::Read,
+                alignment: None,
+                bytes: SectionBody::new_with_vec(got_data),
+                relocations: got_relocs,
+            });
+            got.index = Some(got_idx);
+        };
 
+        tracing::trace!("Finished compling the module!");
         Ok(Compilation {
             functions,
             custom_sections: module_custom_sections,
             function_call_trampolines,
             dynamic_function_trampolines,
-            debug: dwarf,
+            unwind_info,
+            got,
         })
     }
+
+    fn with_opts(
+        &mut self,
+        suggested_compiler_opts: &wasmer_types::target::UserCompilerOptimizations,
+    ) -> Result<(), CompileError> {
+        if suggested_compiler_opts.pass_params.is_some_and(|v| v) {
+            self.config.enable_g0m0_opt = true;
+        }
+        Ok(())
+    }
 }
diff --git a/lib/compiler-llvm/src/config.rs b/lib/compiler-llvm/src/config.rs
index a4c5ebf6e1..1a0261b0b4 100644
--- a/lib/compiler-llvm/src/config.rs
+++ b/lib/compiler-llvm/src/config.rs
@@ -5,11 +5,14 @@ use inkwell::targets::{
 };
 pub use inkwell::OptimizationLevel as LLVMOptLevel;
 use itertools::Itertools;
-use std::fmt::Debug;
 use std::sync::Arc;
-use target_lexicon::Architecture;
+use std::{fmt::Debug, num::NonZero};
+use target_lexicon::BinaryFormat;
 use wasmer_compiler::{Compiler, CompilerConfig, Engine, EngineBuilder, ModuleMiddleware};
-use wasmer_types::{FunctionType, LocalFunctionIndex, Target, Triple};
+use wasmer_types::{
+    target::{Architecture, OperatingSystem, Target, Triple},
+    Features, FunctionType, LocalFunctionIndex,
+};
 
 /// The InkWell ModuleInfo type
 pub type InkwellModule<'ctx> = inkwell::module::Module<'ctx>;
@@ -35,17 +38,22 @@ pub trait LLVMCallbacks: Debug + Send + Sync {
     fn preopt_ir(&self, function: &CompiledKind, module: &InkwellModule);
     fn postopt_ir(&self, function: &CompiledKind, module: &InkwellModule);
     fn obj_memory_buffer(&self, function: &CompiledKind, memory_buffer: &InkwellMemoryBuffer);
+    fn asm_memory_buffer(&self, function: &CompiledKind, memory_buffer: &InkwellMemoryBuffer);
 }
 
 #[derive(Debug, Clone)]
 pub struct LLVM {
     pub(crate) enable_nan_canonicalization: bool,
+    pub(crate) enable_g0m0_opt: bool,
     pub(crate) enable_verifier: bool,
+    pub(crate) enable_perfmap: bool,
     pub(crate) opt_level: LLVMOptLevel,
     is_pic: bool,
     pub(crate) callbacks: Option<Arc<dyn LLVMCallbacks>>,
     /// The middleware chain.
     pub(crate) middlewares: Vec<Arc<dyn ModuleMiddleware>>,
+    /// Number of threads to use when compiling a module.
+    pub(crate) num_threads: NonZero<usize>,
 }
 
 impl LLVM {
@@ -55,10 +63,13 @@ impl LLVM {
         Self {
             enable_nan_canonicalization: false,
             enable_verifier: false,
+            enable_perfmap: false,
             opt_level: LLVMOptLevel::Aggressive,
             is_pic: false,
             callbacks: None,
             middlewares: vec![],
+            enable_g0m0_opt: false,
+            num_threads: std::thread::available_parallelism().unwrap_or(NonZero::new(1).unwrap()),
         }
     }
 
@@ -68,6 +79,19 @@ impl LLVM {
         self
     }
 
+    /// (warning: experimental) Pass the value of the first (#0) global and the base pointer of the
+    /// first (#0) memory as parameter between guest functions.
+    pub fn enable_pass_params_opt(&mut self) -> &mut Self {
+        // internally, the "pass_params" opt is known as g0m0 opt.
+        self.enable_g0m0_opt = true;
+        self
+    }
+
+    pub fn num_threads(&mut self, num_threads: NonZero<usize>) -> &mut Self {
+        self.num_threads = num_threads;
+        self
+    }
+
     /// Callbacks that will triggered in the different compilation
     /// phases in LLVM.
     pub fn callbacks(&mut self, callbacks: Option<Arc<dyn LLVMCallbacks>>) -> &mut Self {
@@ -75,7 +99,11 @@ impl LLVM {
         self
     }
 
-    fn reloc_mode(&self) -> RelocMode {
+    fn reloc_mode(&self, binary_format: BinaryFormat) -> RelocMode {
+        if matches!(binary_format, BinaryFormat::Macho) {
+            return RelocMode::Static;
+        }
+
         if self.is_pic {
             RelocMode::PIC
         } else {
@@ -83,12 +111,16 @@ impl LLVM {
         }
     }
 
-    fn code_model(&self) -> CodeModel {
+    fn code_model(&self, binary_format: BinaryFormat) -> CodeModel {
         // We normally use the large code model, but when targeting shared
         // objects, we are required to use PIC. If we use PIC anyways, we lose
         // any benefit from large code model and there's some cost on all
         // platforms, plus some platforms (MachO) don't support PIC + large
         // at all.
+        if matches!(binary_format, BinaryFormat::Macho) {
+            return CodeModel::Default;
+        }
+
         if self.is_pic {
             CodeModel::Small
         } else {
@@ -96,20 +128,8 @@ impl LLVM {
         }
     }
 
-    fn target_triple(&self, target: &Target) -> TargetTriple {
-        let architecture = if target.triple().architecture
-            == Architecture::Riscv64(target_lexicon::Riscv64Architecture::Riscv64gc)
-        {
-            target_lexicon::Architecture::Riscv64(target_lexicon::Riscv64Architecture::Riscv64)
-        } else {
-            target.triple().architecture
-        };
-        // Hack: we're using is_pic to determine whether this is a native
-        // build or not.
-        let operating_system = if target.triple().operating_system
-            == wasmer_types::OperatingSystem::Darwin
-            && !self.is_pic
-        {
+    pub(crate) fn target_operating_system(&self, target: &Target) -> OperatingSystem {
+        if target.triple().operating_system == OperatingSystem::Darwin && !self.is_pic {
             // LLVM detects static relocation + darwin + 64-bit and
             // force-enables PIC because MachO doesn't support that
             // combination. They don't check whether they're targeting
@@ -119,16 +139,39 @@ impl LLVM {
             //  but not in the case of Aarch64, there the ABI is slightly different
             #[allow(clippy::match_single_binding)]
             match target.triple().architecture {
-                _ => wasmer_types::OperatingSystem::Linux,
+                Architecture::Aarch64(_) => OperatingSystem::Darwin,
+                _ => OperatingSystem::Linux,
             }
         } else {
             target.triple().operating_system
-        };
-        let binary_format = if self.is_pic {
+        }
+    }
+
+    pub(crate) fn target_binary_format(&self, target: &Target) -> target_lexicon::BinaryFormat {
+        if self.is_pic {
             target.triple().binary_format
         } else {
-            target_lexicon::BinaryFormat::Elf
+            match self.target_operating_system(target) {
+                OperatingSystem::Darwin => target_lexicon::BinaryFormat::Macho,
+                _ => target_lexicon::BinaryFormat::Elf,
+            }
+        }
+    }
+
+    fn target_triple(&self, target: &Target) -> TargetTriple {
+        let architecture = if target.triple().architecture
+            == Architecture::Riscv64(target_lexicon::Riscv64Architecture::Riscv64gc)
+        {
+            target_lexicon::Architecture::Riscv64(target_lexicon::Riscv64Architecture::Riscv64)
+        } else {
+            target.triple().architecture
         };
+        // Hack: we're using is_pic to determine whether this is a native
+        // build or not.
+
+        let operating_system = self.target_operating_system(target);
+        let binary_format = self.target_binary_format(target);
+
         let triple = Triple {
             architecture,
             vendor: target.triple().vendor.clone(),
@@ -171,6 +214,16 @@ impl LLVM {
                 info: true,
                 machine_code: true,
             }),
+            Architecture::LoongArch64 => {
+                InkwellTarget::initialize_loongarch(&InitializationConfig {
+                    asm_parser: true,
+                    asm_printer: true,
+                    base: true,
+                    disassembler: true,
+                    info: true,
+                    machine_code: true,
+                })
+            }
             // Architecture::Arm(_) => InkwellTarget::initialize_arm(&InitializationConfig {
             //     asm_parser: true,
             //     asm_printer: true,
@@ -187,7 +240,7 @@ impl LLVM {
         // are compliant with the same string representations as gcc.
         let llvm_cpu_features = cpu_features
             .iter()
-            .map(|feature| format!("+{}", feature.to_string()))
+            .map(|feature| format!("+{feature}"))
             .join(",");
 
         let target_triple = self.target_triple(target);
@@ -197,17 +250,19 @@ impl LLVM {
                 &target_triple,
                 match triple.architecture {
                     Architecture::Riscv64(_) => "generic-rv64",
+                    Architecture::LoongArch64 => "generic-la64",
                     _ => "generic",
                 },
                 match triple.architecture {
                     Architecture::Riscv64(_) => "+m,+a,+c,+d,+f",
+                    Architecture::LoongArch64 => "+f,+d",
                     _ => &llvm_cpu_features,
                 },
                 self.opt_level,
-                self.reloc_mode(),
+                self.reloc_mode(self.target_binary_format(target)),
                 match triple.architecture {
-                    Architecture::Riscv64(_) => CodeModel::Medium,
-                    _ => self.code_model(),
+                    Architecture::LoongArch64 | Architecture::Riscv64(_) => CodeModel::Medium,
+                    _ => self.code_model(self.target_binary_format(target)),
                 },
             )
             .unwrap();
@@ -233,12 +288,14 @@ impl LLVM {
 
                 *((my_target_machine.target_machine as *mut u8).offset(0x410) as *mut u64) = 5;
                 std::ptr::copy_nonoverlapping(
-                    "lp64d\0".as_ptr(),
-                    (my_target_machine.target_machine as *mut u8).offset(0x418),
+                    c"lp64d".as_ptr(),
+                    (my_target_machine.target_machine as *mut i8).offset(0x418),
                     6,
                 );
 
-                std::mem::transmute(my_target_machine)
+                std::mem::transmute::<MyTargetMachine, inkwell::targets::TargetMachine>(
+                    my_target_machine,
+                )
             }
         } else {
             llvm_target_machine
@@ -254,6 +311,10 @@ impl CompilerConfig for LLVM {
         self.is_pic = true;
     }
 
+    fn enable_perfmap(&mut self) {
+        self.enable_perfmap = true
+    }
+
     /// Whether to verify compiler IR.
     fn enable_verifier(&mut self) {
         self.enable_verifier = true;
@@ -272,6 +333,12 @@ impl CompilerConfig for LLVM {
     fn push_middleware(&mut self, middleware: Arc<dyn ModuleMiddleware>) {
         self.middlewares.push(middleware);
     }
+
+    fn supported_features_for_target(&self, _target: &Target) -> wasmer_types::Features {
+        let mut feats = Features::default();
+        feats.exceptions(true);
+        feats
+    }
 }
 
 impl Default for LLVM {
diff --git a/lib/compiler-llvm/src/error.rs b/lib/compiler-llvm/src/error.rs
new file mode 100644
index 0000000000..0ebe4ade2c
--- /dev/null
+++ b/lib/compiler-llvm/src/error.rs
@@ -0,0 +1,14 @@
+macro_rules! err_nt {
+    ($e: expr) => {
+        $e.map_err(|v| CompileError::Codegen(v.to_string()))
+    };
+}
+
+macro_rules! err {
+    ($e: expr) => {
+        $e.map_err(|v| CompileError::Codegen(v.to_string()))?
+    };
+}
+
+pub(crate) use err;
+pub(crate) use err_nt;
diff --git a/lib/compiler-llvm/src/lib.rs b/lib/compiler-llvm/src/lib.rs
index 49231b7324..fc07773983 100644
--- a/lib/compiler-llvm/src/lib.rs
+++ b/lib/compiler-llvm/src/lib.rs
@@ -17,6 +17,7 @@
 mod abi;
 mod compiler;
 mod config;
+mod error;
 mod object_file;
 mod trampoline;
 mod translator;
diff --git a/lib/compiler-llvm/src/object_file.rs b/lib/compiler-llvm/src/object_file.rs
index de8702b44c..e6392e5d8a 100644
--- a/lib/compiler-llvm/src/object_file.rs
+++ b/lib/compiler-llvm/src/object_file.rs
@@ -1,135 +1,182 @@
 use object::{Object, ObjectSection, ObjectSymbol};
+use target_lexicon::BinaryFormat;
 
 use std::collections::{HashMap, HashSet};
 use std::convert::TryInto;
 use std::num::TryFromIntError;
 
-use wasmer_types::entity::PrimaryMap;
-use wasmer_types::{
-    CompileError, CompiledFunctionFrameInfo, CustomSection, CustomSectionProtection,
-    CustomSections, FunctionAddressMap, FunctionBody, InstructionAddressMap, Relocation,
-    RelocationKind, RelocationTarget, SectionBody, SectionIndex, SourceLoc,
+use wasmer_types::{entity::PrimaryMap, CompileError, SourceLoc};
+
+use wasmer_compiler::types::{
+    address_map::{FunctionAddressMap, InstructionAddressMap},
+    function::{CompiledFunctionFrameInfo, CustomSections, FunctionBody},
+    relocation::{Relocation, RelocationKind, RelocationTarget},
+    section::{CustomSection, CustomSectionProtection, SectionBody, SectionIndex},
 };
+
 use wasmer_vm::libcalls::LibCall;
 
 fn map_tryfromint_err(error: TryFromIntError) -> CompileError {
-    CompileError::Codegen(format!("int doesn't fit: {}", error))
+    CompileError::Codegen(format!("int doesn't fit: {error}"))
 }
 
 fn map_object_err(error: object::read::Error) -> CompileError {
-    CompileError::Codegen(format!("error parsing object file: {}", error))
+    CompileError::Codegen(format!("error parsing object file: {error}"))
 }
 
+#[derive(Debug)]
 pub struct CompiledFunction {
-    pub compiled_function: wasmer_types::CompiledFunction,
+    pub compiled_function: wasmer_compiler::types::function::CompiledFunction,
     pub custom_sections: CustomSections,
     pub eh_frame_section_indices: Vec<SectionIndex>,
+    pub compact_unwind_section_indices: Vec<SectionIndex>,
 }
 
+static LIBCALLS_ELF: phf::Map<&'static str, LibCall> = phf::phf_map! {
+    "ceilf" => LibCall::CeilF32,
+    "ceil" => LibCall::CeilF64,
+    "floorf" => LibCall::FloorF32,
+    "floor" => LibCall::FloorF64,
+    "nearbyintf" => LibCall::NearestF32,
+    "nearbyint" => LibCall::NearestF64,
+    "truncf" => LibCall::TruncF32,
+    "trunc" => LibCall::TruncF64,
+    "wasmer_vm_f32_ceil" => LibCall::CeilF32,
+    "wasmer_vm_f64_ceil" => LibCall::CeilF64,
+    "wasmer_vm_f32_floor" => LibCall::FloorF32,
+    "wasmer_vm_f64_floor" => LibCall::FloorF64,
+    "wasmer_vm_f32_nearest" => LibCall::NearestF32,
+    "wasmer_vm_f64_nearest" => LibCall::NearestF64,
+    "wasmer_vm_f32_trunc" => LibCall::TruncF32,
+    "wasmer_vm_f64_trunc" => LibCall::TruncF64,
+    "wasmer_vm_memory32_size" => LibCall::Memory32Size,
+    "wasmer_vm_imported_memory32_size" => LibCall::ImportedMemory32Size,
+    "wasmer_vm_table_copy" => LibCall::TableCopy,
+    "wasmer_vm_table_init" => LibCall::TableInit,
+    "wasmer_vm_table_fill" => LibCall::TableFill,
+    "wasmer_vm_table_size" => LibCall::TableSize,
+    "wasmer_vm_imported_table_size" => LibCall::ImportedTableSize,
+    "wasmer_vm_table_get" => LibCall::TableGet,
+    "wasmer_vm_imported_table_get" => LibCall::ImportedTableGet,
+    "wasmer_vm_table_set" => LibCall::TableSet,
+    "wasmer_vm_imported_table_set" => LibCall::ImportedTableSet,
+    "wasmer_vm_table_grow" => LibCall::TableGrow,
+    "wasmer_vm_imported_table_grow" => LibCall::ImportedTableGrow,
+    "wasmer_vm_func_ref" => LibCall::FuncRef,
+    "wasmer_vm_elem_drop" => LibCall::ElemDrop,
+    "wasmer_vm_memory32_copy" => LibCall::Memory32Copy,
+    "wasmer_vm_imported_memory32_copy" => LibCall::ImportedMemory32Copy,
+    "wasmer_vm_memory32_fill" => LibCall::Memory32Fill,
+    "wasmer_vm_imported_memory32_fill" => LibCall::ImportedMemory32Fill,
+    "wasmer_vm_memory32_init" => LibCall::Memory32Init,
+    "wasmer_vm_data_drop" => LibCall::DataDrop,
+    "wasmer_vm_raise_trap" => LibCall::RaiseTrap,
+    "wasmer_vm_memory32_atomic_wait32" => LibCall::Memory32AtomicWait32,
+    "wasmer_vm_imported_memory32_atomic_wait32" => LibCall::ImportedMemory32AtomicWait32,
+    "wasmer_vm_memory32_atomic_wait64" => LibCall::Memory32AtomicWait64,
+    "wasmer_vm_imported_memory32_atomic_wait64" => LibCall::ImportedMemory32AtomicWait64,
+    "wasmer_vm_memory32_atomic_notify" => LibCall::Memory32AtomicNotify,
+    "wasmer_vm_imported_memory32_atomic_notify" => LibCall::ImportedMemory32AtomicNotify,
+    "wasmer_vm_throw" => LibCall::Throw,
+    "wasmer_vm_rethrow" => LibCall::Rethrow,
+    "wasmer_vm_alloc_exception" => LibCall::AllocException,
+    "wasmer_vm_delete_exception" => LibCall::DeleteException,
+    "wasmer_vm_read_exception" => LibCall::ReadException,
+    "wasmer_vm_dbg_usize" => LibCall::DebugUsize,
+    "wasmer_eh_personality" => LibCall::EHPersonality,
+    "wasmer_eh_personality2" => LibCall::EHPersonality2,
+    "wasmer_vm_dbg_str" => LibCall::DebugStr,
+};
+
+static LIBCALLS_MACHO: phf::Map<&'static str, LibCall> = phf::phf_map! {
+    "_ceilf" => LibCall::CeilF32,
+    "_ceil" => LibCall::CeilF64,
+    "_floorf" => LibCall::FloorF32,
+    "_floor" => LibCall::FloorF64,
+    "_nearbyintf" => LibCall::NearestF32,
+    "_nearbyint" => LibCall::NearestF64,
+    "_truncf" => LibCall::TruncF32,
+    "_trunc" => LibCall::TruncF64,
+    "_wasmer_vm_f32_ceil" => LibCall::CeilF32,
+    "_wasmer_vm_f64_ceil" => LibCall::CeilF64,
+    "_wasmer_vm_f32_floor" => LibCall::FloorF32,
+    "_wasmer_vm_f64_floor" => LibCall::FloorF64,
+    "_wasmer_vm_f32_nearest" => LibCall::NearestF32,
+    "_wasmer_vm_f64_nearest" => LibCall::NearestF64,
+    "_wasmer_vm_f32_trunc" => LibCall::TruncF32,
+    "_wasmer_vm_f64_trunc" => LibCall::TruncF64,
+    "_wasmer_vm_memory32_size" => LibCall::Memory32Size,
+    "_wasmer_vm_imported_memory32_size" => LibCall::ImportedMemory32Size,
+    "_wasmer_vm_table_copy" => LibCall::TableCopy,
+    "_wasmer_vm_table_init" => LibCall::TableInit,
+    "_wasmer_vm_table_fill" => LibCall::TableFill,
+    "_wasmer_vm_table_size" => LibCall::TableSize,
+    "_wasmer_vm_imported_table_size" => LibCall::ImportedTableSize,
+    "_wasmer_vm_table_get" => LibCall::TableGet,
+    "_wasmer_vm_imported_table_get" => LibCall::ImportedTableGet,
+    "_wasmer_vm_table_set" => LibCall::TableSet,
+    "_wasmer_vm_imported_table_set" => LibCall::ImportedTableSet,
+    "_wasmer_vm_table_grow" => LibCall::TableGrow,
+    "_wasmer_vm_imported_table_grow" => LibCall::ImportedTableGrow,
+    "_wasmer_vm_func_ref" => LibCall::FuncRef,
+    "_wasmer_vm_elem_drop" => LibCall::ElemDrop,
+    "_wasmer_vm_memory32_copy" => LibCall::Memory32Copy,
+    "_wasmer_vm_imported_memory32_copy" => LibCall::ImportedMemory32Copy,
+    "_wasmer_vm_memory32_fill" => LibCall::Memory32Fill,
+    "_wasmer_vm_imported_memory32_fill" => LibCall::ImportedMemory32Fill,
+    "_wasmer_vm_memory32_init" => LibCall::Memory32Init,
+    "_wasmer_vm_data_drop" => LibCall::DataDrop,
+    "_wasmer_vm_raise_trap" => LibCall::RaiseTrap,
+    "_wasmer_vm_memory32_atomic_wait32" => LibCall::Memory32AtomicWait32,
+    "_wasmer_vm_imported_memory32_atomic_wait32" => LibCall::ImportedMemory32AtomicWait32,
+    "_wasmer_vm_memory32_atomic_wait64" => LibCall::Memory32AtomicWait64,
+    "_wasmer_vm_imported_memory32_atomic_wait64" => LibCall::ImportedMemory32AtomicWait64,
+    "_wasmer_vm_memory32_atomic_notify" => LibCall::Memory32AtomicNotify,
+    "_wasmer_vm_imported_memory32_atomic_notify" => LibCall::ImportedMemory32AtomicNotify,
+    "_wasmer_vm_throw" => LibCall::Throw,
+    "_wasmer_vm_rethrow" => LibCall::Rethrow,
+    "_wasmer_vm_alloc_exception" => LibCall::AllocException,
+    "_wasmer_vm_delete_exception" => LibCall::DeleteException,
+    "_wasmer_vm_read_exception" => LibCall::ReadException,
+    "_wasmer_vm_dbg_usize" => LibCall::DebugUsize,
+    // Note: on macOS+Mach-O the personality function *must* be called like this, otherwise LLVM
+    // will generate things differently than "normal", wreaking havoc.
+    //
+    // todo: find out if it is a bug in LLVM or it is expected.
+    "___gxx_personality_v0" => LibCall::EHPersonality,
+    "_wasmer_eh_personality2" => LibCall::EHPersonality2,
+    "_wasmer_vm_dbg_str" => LibCall::DebugStr,
+};
+
 pub fn load_object_file<F>(
     contents: &[u8],
     root_section: &str,
     root_section_reloc_target: RelocationTarget,
     mut symbol_name_to_relocation_target: F,
+    binary_fmt: BinaryFormat,
 ) -> Result<CompiledFunction, CompileError>
 where
     F: FnMut(&str) -> Result<Option<RelocationTarget>, CompileError>,
 {
-    // TODO: use perfect hash function?
-    let mut libcalls = HashMap::new();
-    libcalls.insert("ceilf".to_string(), LibCall::CeilF32);
-    libcalls.insert("ceil".to_string(), LibCall::CeilF64);
-    libcalls.insert("floorf".to_string(), LibCall::FloorF32);
-    libcalls.insert("floor".to_string(), LibCall::FloorF64);
-    libcalls.insert("nearbyintf".to_string(), LibCall::NearestF32);
-    libcalls.insert("nearbyint".to_string(), LibCall::NearestF64);
-    libcalls.insert("truncf".to_string(), LibCall::TruncF32);
-    libcalls.insert("trunc".to_string(), LibCall::TruncF64);
-    libcalls.insert("wasmer_vm_f32_ceil".to_string(), LibCall::CeilF32);
-    libcalls.insert("wasmer_vm_f64_ceil".to_string(), LibCall::CeilF64);
-    libcalls.insert("wasmer_vm_f32_floor".to_string(), LibCall::FloorF32);
-    libcalls.insert("wasmer_vm_f64_floor".to_string(), LibCall::FloorF64);
-    libcalls.insert("wasmer_vm_f32_nearest".to_string(), LibCall::NearestF32);
-    libcalls.insert("wasmer_vm_f64_nearest".to_string(), LibCall::NearestF64);
-    libcalls.insert("wasmer_vm_f32_trunc".to_string(), LibCall::TruncF32);
-    libcalls.insert("wasmer_vm_f64_trunc".to_string(), LibCall::TruncF64);
-    libcalls.insert("wasmer_vm_memory32_size".to_string(), LibCall::Memory32Size);
-    libcalls.insert(
-        "wasmer_vm_imported_memory32_size".to_string(),
-        LibCall::ImportedMemory32Size,
-    );
-    libcalls.insert("wasmer_vm_table_copy".to_string(), LibCall::TableCopy);
-    libcalls.insert("wasmer_vm_table_init".to_string(), LibCall::TableInit);
-    libcalls.insert("wasmer_vm_table_fill".to_string(), LibCall::TableFill);
-    libcalls.insert("wasmer_vm_table_size".to_string(), LibCall::TableSize);
-    libcalls.insert(
-        "wasmer_vm_imported_table_size".to_string(),
-        LibCall::ImportedTableSize,
-    );
-    libcalls.insert("wasmer_vm_table_get".to_string(), LibCall::TableGet);
-    libcalls.insert(
-        "wasmer_vm_imported_table_get".to_string(),
-        LibCall::ImportedTableGet,
-    );
-    libcalls.insert("wasmer_vm_table_set".to_string(), LibCall::TableSet);
-    libcalls.insert(
-        "wasmer_vm_imported_table_set".to_string(),
-        LibCall::ImportedTableSet,
-    );
-    libcalls.insert("wasmer_vm_table_grow".to_string(), LibCall::TableGrow);
-    libcalls.insert(
-        "wasmer_vm_imported_table_grow".to_string(),
-        LibCall::ImportedTableGrow,
-    );
-    libcalls.insert("wasmer_vm_func_ref".to_string(), LibCall::FuncRef);
-    libcalls.insert("wasmer_vm_elem_drop".to_string(), LibCall::ElemDrop);
-    libcalls.insert("wasmer_vm_memory32_copy".to_string(), LibCall::Memory32Copy);
-    libcalls.insert(
-        "wasmer_vm_imported_memory32_copy".to_string(),
-        LibCall::ImportedMemory32Copy,
-    );
-    libcalls.insert("wasmer_vm_memory32_fill".to_string(), LibCall::Memory32Fill);
-    libcalls.insert(
-        "wasmer_vm_imported_memory32_fill".to_string(),
-        LibCall::ImportedMemory32Fill,
-    );
-    libcalls.insert("wasmer_vm_memory32_init".to_string(), LibCall::Memory32Init);
-    libcalls.insert("wasmer_vm_data_drop".to_string(), LibCall::DataDrop);
-    libcalls.insert("wasmer_vm_raise_trap".to_string(), LibCall::RaiseTrap);
-    libcalls.insert(
-        "wasmer_vm_memory32_atomic_wait32".to_string(),
-        LibCall::Memory32AtomicWait32,
-    );
-    libcalls.insert(
-        "wasmer_vm_imported_memory32_atomic_wait32".to_string(),
-        LibCall::ImportedMemory32AtomicWait32,
-    );
-    libcalls.insert(
-        "wasmer_vm_memory32_atomic_wait64".to_string(),
-        LibCall::Memory32AtomicWait64,
-    );
-    libcalls.insert(
-        "wasmer_vm_imported_memory32_atomic_wait64".to_string(),
-        LibCall::ImportedMemory32AtomicWait64,
-    );
-    libcalls.insert(
-        "wasmer_vm_memory32_atomic_notify".to_string(),
-        LibCall::Memory32AtomicNotify,
-    );
-    libcalls.insert(
-        "wasmer_vm_imported_memory32_atomic_notify".to_string(),
-        LibCall::ImportedMemory32AtomicNotify,
-    );
-
-    let elf = object::File::parse(contents).map_err(map_object_err)?;
+    let obj = object::File::parse(contents).map_err(map_object_err)?;
+
+    let libcalls = match binary_fmt {
+        BinaryFormat::Elf => &LIBCALLS_ELF,
+        BinaryFormat::Macho => &LIBCALLS_MACHO,
+        _ => {
+            return Err(CompileError::UnsupportedTarget(format!(
+                "Unsupported binary format {binary_fmt:?}"
+            )))
+        }
+    };
 
     let mut visited: HashSet<object::read::SectionIndex> = HashSet::new();
     let mut worklist: Vec<object::read::SectionIndex> = Vec::new();
     let mut section_targets: HashMap<object::read::SectionIndex, RelocationTarget> = HashMap::new();
 
-    let root_section_index = elf
+    let root_section_index = obj
         .section_by_name(root_section)
-        .ok_or_else(|| CompileError::Codegen(format!("no section named {}", root_section)))?
+        .ok_or_else(|| CompileError::Codegen(format!("no section named {root_section}")))?
         .index();
 
     let mut section_to_custom_section = HashMap::new();
@@ -137,6 +184,7 @@ where
     section_targets.insert(root_section_index, root_section_reloc_target);
 
     let mut next_custom_section: u32 = 0;
+
     let mut elf_section_to_target = |elf_section_index: object::read::SectionIndex| {
         *section_targets.entry(elf_section_index).or_insert_with(|| {
             let next = SectionIndex::from_u32(next_custom_section);
@@ -152,7 +200,7 @@ where
     let mut relocations: HashMap<object::read::SectionIndex, Vec<Relocation>> = HashMap::new();
 
     // Each iteration of this loop pulls a section and the relocations
-    // relocations that apply to it. We begin with the ".root_section"
+    // that apply to it. We begin with the ".root_section"
     // section, and then parse all relocation sections that apply to that
     // section. Those relocations may refer to additional sections which we
     // then add to the worklist until we've visited the closure of
@@ -167,81 +215,40 @@ where
     worklist.push(root_section_index);
     visited.insert(root_section_index);
 
-    // Also add any .eh_frame sections.
+    // Add any .eh_frame sections.
     let mut eh_frame_section_indices = vec![];
-    for section in elf.sections() {
-        if section.kind() == object::SectionKind::Elf(object::elf::SHT_X86_64_UNWIND) {
-            let index = section.index();
+
+    // Add macos-specific unwind sections.
+    let mut compact_unwind_section_indices = vec![];
+
+    for section in obj.sections() {
+        let index = section.index();
+        if section.kind() == object::SectionKind::Elf(object::elf::SHT_X86_64_UNWIND)
+            || section.name().unwrap_or_default() == "__eh_frame"
+        {
             worklist.push(index);
-            visited.insert(index);
             eh_frame_section_indices.push(index);
+
             // This allocates a custom section index for the ELF section.
+            elf_section_to_target(index);
+        } else if section.name().unwrap_or_default() == "__compact_unwind" {
+            worklist.push(index);
+            compact_unwind_section_indices.push(index);
+
             elf_section_to_target(index);
         }
     }
 
     while let Some(section_index) = worklist.pop() {
-        for (offset, reloc) in elf
+        let sec = obj
             .section_by_index(section_index)
-            .map_err(map_object_err)?
-            .relocations()
-        {
-            let kind = match (elf.architecture(), reloc.kind(), reloc.size()) {
-                (_, object::RelocationKind::Absolute, 64) => RelocationKind::Abs8,
-                (
-                    object::Architecture::X86_64,
-                    object::RelocationKind::Elf(object::elf::R_X86_64_PC64),
-                    0,
-                ) => RelocationKind::X86PCRel8,
-                (object::Architecture::Aarch64, object::RelocationKind::PltRelative, 26) => {
-                    RelocationKind::Arm64Call
-                }
-                (
-                    object::Architecture::Aarch64,
-                    object::RelocationKind::Elf(object::elf::R_AARCH64_MOVW_UABS_G0_NC),
-                    0,
-                ) => RelocationKind::Arm64Movw0,
-                (
-                    object::Architecture::Aarch64,
-                    object::RelocationKind::Elf(object::elf::R_AARCH64_MOVW_UABS_G1_NC),
-                    0,
-                ) => RelocationKind::Arm64Movw1,
-                (
-                    object::Architecture::Aarch64,
-                    object::RelocationKind::Elf(object::elf::R_AARCH64_MOVW_UABS_G2_NC),
-                    0,
-                ) => RelocationKind::Arm64Movw2,
-                (
-                    object::Architecture::Aarch64,
-                    object::RelocationKind::Elf(object::elf::R_AARCH64_MOVW_UABS_G3),
-                    0,
-                ) => RelocationKind::Arm64Movw3,
-                (
-                    object::Architecture::Riscv64,
-                    object::RelocationKind::Elf(object::elf::R_RISCV_CALL_PLT),
-                    0,
-                ) => RelocationKind::RiscvCall,
-                (
-                    object::Architecture::Riscv64,
-                    object::RelocationKind::Elf(object::elf::R_RISCV_PCREL_HI20),
-                    0,
-                ) => RelocationKind::RiscvPCRelHi20,
-                (
-                    object::Architecture::Riscv64,
-                    object::RelocationKind::Elf(object::elf::R_RISCV_PCREL_LO12_I),
-                    0,
-                ) => RelocationKind::RiscvPCRelLo12I,
-                _ => {
-                    return Err(CompileError::Codegen(format!(
-                        "unknown relocation {:?}",
-                        reloc
-                    )));
-                }
-            };
+            .map_err(map_object_err)?;
+        let relocs = sec.relocations();
+        for (offset, reloc) in relocs {
             let mut addend = reloc.addend();
             let target = match reloc.target() {
                 object::read::RelocationTarget::Symbol(index) => {
-                    let symbol = elf.symbol_by_index(index).map_err(map_object_err)?;
+                    let symbol = obj.symbol_by_index(index).map_err(map_object_err)?;
                     let symbol_name = symbol.name().map_err(map_object_err)?;
                     if symbol.kind() == object::SymbolKind::Section {
                         match symbol.section() {
@@ -257,21 +264,66 @@ where
                             }
                             _ => {
                                 return Err(CompileError::Codegen(format!(
-                                    "relocation targets unknown section {:?}",
-                                    reloc
+                                    "relocation targets unknown section {reloc:?}",
                                 )));
                             }
                         }
                         // Maybe a libcall then?
                     } else if let Some(libcall) = libcalls.get(symbol_name) {
                         RelocationTarget::LibCall(*libcall)
-                    } else if let Some(reloc_target) =
-                        symbol_name_to_relocation_target(symbol_name)?
+                    } else if let Ok(Some(reloc_target)) =
+                        symbol_name_to_relocation_target(symbol_name)
                     {
                         reloc_target
                     } else if let object::SymbolSection::Section(section_index) = symbol.section() {
-                        // TODO: Encode symbol address into addend, I think this is a bit hacky.
-                        addend = addend.wrapping_add(symbol.address() as i64);
+                        if matches!(
+                            reloc.kind(),
+                            object::RelocationKind::MachO {
+                                value: object::macho::ARM64_RELOC_GOT_LOAD_PAGEOFF12,
+                                relative: false
+                            } | object::RelocationKind::MachO {
+                                value: object::macho::ARM64_RELOC_POINTER_TO_GOT,
+                                relative: true
+                            } | object::RelocationKind::MachO {
+                                value: object::macho::ARM64_RELOC_GOT_LOAD_PAGE21,
+                                relative: true
+                            } | object::RelocationKind::MachO {
+                                value: object::macho::ARM64_RELOC_PAGE21,
+                                relative: true
+                            } | object::RelocationKind::MachO {
+                                value: object::macho::ARM64_RELOC_PAGEOFF12,
+                                relative: false
+                            }
+                        ) {
+                            // (caveat: this comment comes from a point in time after the `addend`
+                            // math in the else branch)
+                            //
+                            // (caveat2: this is mach-o + aarch64 only)
+                            //
+                            // The tampering with the addend in the else branch causes some
+                            // problems with GOT-based relocs, as a non-zero addend has no meaning
+                            // when dealing with GOT entries, for our use-case.
+                            //
+                            // However, for some reasons, it happens that we conceptually need to
+                            // have relocations that pretty much mean "the contents of this GOT
+                            // entry plus a non-zero addend". When in this case, we will later
+                            // perform what is known as "GOT relaxation", i.e. we can change the
+                            // `ldr` opcode to an `add`.
+                            //
+                            // For this to make sense we need to fix the addend to be the delta
+                            // between the section whose address is an entry of the GOT and the
+                            // symbol that is the target of the relocation.
+
+                            let symbol_sec = obj
+                                .section_by_index(section_index)
+                                .map_err(map_object_err)?;
+
+                            addend = addend
+                                .wrapping_add((symbol.address() - symbol_sec.address()) as i64);
+                        } else {
+                            // TODO: Encode symbol address into addend, I think this is a bit hacky.
+                            addend = addend.wrapping_add(symbol.address() as i64);
+                        }
 
                         if section_index == root_section_index {
                             root_section_reloc_target
@@ -284,8 +336,7 @@ where
                         }
                     } else {
                         return Err(CompileError::Codegen(format!(
-                            "relocation targets unknown symbol {:?}",
-                            reloc
+                            "relocation {reloc:?} targets unknown symbol '{symbol:?}'",
                         )));
                     }
                 }
@@ -306,8 +357,7 @@ where
                     // addresses in them because none of the parts of the Wasm
                     // VM, nor the generated code are loaded at fixed addresses.
                     return Err(CompileError::Codegen(format!(
-                        "relocation targets absolute address {:?}",
-                        reloc
+                        "relocation targets absolute address {reloc:?}",
                     )));
                 }
 
@@ -319,11 +369,209 @@ where
                 // be added to account for any future variants.
                 t => {
                     return Err(CompileError::Codegen(format!(
-                        "relocation target is unknown `{:?}`",
-                        t
+                        "relocation target is unknown `{t:?}`",
                     )));
                 }
             };
+            let kind = match (obj.architecture(), reloc.kind(), reloc.size()) {
+                (_, object::RelocationKind::Absolute, 64) => RelocationKind::Abs8,
+                (_, object::RelocationKind::Absolute, 32) => RelocationKind::Abs4,
+                (
+                    object::Architecture::X86_64,
+                    object::RelocationKind::Elf(object::elf::R_X86_64_PC64),
+                    0,
+                ) => RelocationKind::X86PCRel8,
+                (object::Architecture::Aarch64, object::RelocationKind::PltRelative, 26) => {
+                    RelocationKind::Arm64Call
+                }
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationKind::Elf(object::elf::R_AARCH64_MOVW_UABS_G0_NC),
+                    0,
+                ) => RelocationKind::Arm64Movw0,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationKind::Elf(object::elf::R_AARCH64_MOVW_UABS_G1_NC),
+                    0,
+                ) => RelocationKind::Arm64Movw1,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationKind::Elf(object::elf::R_AARCH64_MOVW_UABS_G2_NC),
+                    0,
+                ) => RelocationKind::Arm64Movw2,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationKind::Elf(object::elf::R_AARCH64_MOVW_UABS_G3),
+                    0,
+                ) => RelocationKind::Arm64Movw3,
+                (
+                    object::Architecture::Riscv64,
+                    object::RelocationKind::Elf(object::elf::R_RISCV_CALL_PLT),
+                    0,
+                ) => RelocationKind::RiscvCall,
+                (
+                    object::Architecture::Riscv64,
+                    object::RelocationKind::Elf(object::elf::R_RISCV_PCREL_HI20),
+                    0,
+                ) => RelocationKind::RiscvPCRelHi20,
+                (
+                    object::Architecture::Riscv64,
+                    object::RelocationKind::Elf(object::elf::R_RISCV_PCREL_LO12_I),
+                    0,
+                ) => RelocationKind::RiscvPCRelLo12I,
+                (
+                    object::Architecture::LoongArch64,
+                    object::RelocationKind::Elf(object::elf::R_LARCH_ABS_HI20),
+                    0,
+                ) => RelocationKind::LArchAbsHi20,
+                (
+                    object::Architecture::LoongArch64,
+                    object::RelocationKind::Elf(object::elf::R_LARCH_ABS_LO12),
+                    0,
+                ) => RelocationKind::LArchAbsLo12,
+                (
+                    object::Architecture::LoongArch64,
+                    object::RelocationKind::Elf(object::elf::R_LARCH_ABS64_HI12),
+                    0,
+                ) => RelocationKind::LArchAbs64Hi12,
+                (
+                    object::Architecture::LoongArch64,
+                    object::RelocationKind::Elf(object::elf::R_LARCH_ABS64_LO20),
+                    0,
+                ) => RelocationKind::LArchAbs64Lo20,
+                (
+                    object::Architecture::LoongArch64,
+                    // FIXME: Replace with R_LARCH_CALL36 while object is updated
+                    // to 0.32.2.
+                    // https://github.com/gimli-rs/object/commit/16b6d902f6c9b39ec7aaea141460f8981e57dd79
+                    object::RelocationKind::Elf(110),
+                    0,
+                ) => RelocationKind::LArchCall36,
+                (
+                    object::Architecture::LoongArch64,
+                    object::RelocationKind::Elf(object::elf::R_LARCH_PCALA_HI20),
+                    0,
+                ) => RelocationKind::LArchPCAlaHi20,
+                (
+                    object::Architecture::LoongArch64,
+                    object::RelocationKind::Elf(object::elf::R_LARCH_PCALA_LO12),
+                    0,
+                ) => RelocationKind::LArchPCAlaLo12,
+                (
+                    object::Architecture::LoongArch64,
+                    object::RelocationKind::Elf(object::elf::R_LARCH_PCALA64_HI12),
+                    0,
+                ) => RelocationKind::LArchPCAla64Hi12,
+                (
+                    object::Architecture::LoongArch64,
+                    object::RelocationKind::Elf(object::elf::R_LARCH_PCALA64_LO20),
+                    0,
+                ) => RelocationKind::LArchPCAla64Lo20,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationKind::Elf(object::elf::R_AARCH64_ADR_PREL_LO21),
+                    0,
+                ) => RelocationKind::Aarch64AdrPrelLo21,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationKind::Elf(object::elf::R_AARCH64_ADR_PREL_PG_HI21),
+                    0,
+                ) => RelocationKind::Aarch64AdrPrelPgHi21,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationKind::Elf(object::elf::R_AARCH64_LDST128_ABS_LO12_NC),
+                    0,
+                ) => RelocationKind::Aarch64Ldst128AbsLo12Nc,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationKind::Elf(object::elf::R_AARCH64_ADD_ABS_LO12_NC),
+                    0,
+                ) => RelocationKind::Aarch64AddAbsLo12Nc,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationKind::Elf(object::elf::R_AARCH64_LDST64_ABS_LO12_NC),
+                    0,
+                ) => RelocationKind::Aarch64Ldst64AbsLo12Nc,
+                (object::Architecture::Aarch64, object::RelocationKind::MachO { value, .. }, _) => {
+                    match value {
+                        object::macho::ARM64_RELOC_UNSIGNED => {
+                            RelocationKind::MachoArm64RelocUnsigned
+                        }
+                        object::macho::ARM64_RELOC_SUBTRACTOR => {
+                            RelocationKind::MachoArm64RelocSubtractor
+                        }
+                        object::macho::ARM64_RELOC_BRANCH26 => {
+                            RelocationKind::MachoArm64RelocBranch26
+                        }
+                        object::macho::ARM64_RELOC_PAGE21 => RelocationKind::MachoArm64RelocPage21,
+                        object::macho::ARM64_RELOC_PAGEOFF12 => {
+                            RelocationKind::MachoArm64RelocPageoff12
+                        }
+                        object::macho::ARM64_RELOC_GOT_LOAD_PAGE21 => {
+                            RelocationKind::MachoArm64RelocGotLoadPage21
+                        }
+                        object::macho::ARM64_RELOC_GOT_LOAD_PAGEOFF12 => {
+                            RelocationKind::MachoArm64RelocGotLoadPageoff12
+                        }
+                        object::macho::ARM64_RELOC_POINTER_TO_GOT => {
+                            RelocationKind::MachoArm64RelocPointerToGot
+                        }
+                        object::macho::ARM64_RELOC_TLVP_LOAD_PAGE21 => {
+                            RelocationKind::MachoArm64RelocTlvpLoadPage21
+                        }
+                        object::macho::ARM64_RELOC_TLVP_LOAD_PAGEOFF12 => {
+                            RelocationKind::MachoArm64RelocTlvpLoadPageoff12
+                        }
+                        object::macho::ARM64_RELOC_ADDEND => RelocationKind::MachoArm64RelocAddend,
+                        _ => {
+                            return Err(CompileError::Codegen(format!(
+                                "unknown relocation {reloc:?}",
+                            )))
+                        }
+                    }
+                }
+                (object::Architecture::X86_64, object::RelocationKind::MachO { value, .. }, _) => {
+                    match value {
+                        object::macho::X86_64_RELOC_UNSIGNED => {
+                            RelocationKind::MachoX86_64RelocUnsigned
+                        }
+                        object::macho::X86_64_RELOC_SIGNED => {
+                            RelocationKind::MachoX86_64RelocSigned
+                        }
+                        object::macho::X86_64_RELOC_BRANCH => {
+                            RelocationKind::MachoX86_64RelocBranch
+                        }
+                        object::macho::X86_64_RELOC_GOT_LOAD => {
+                            RelocationKind::MachoX86_64RelocGotLoad
+                        }
+                        object::macho::X86_64_RELOC_GOT => RelocationKind::MachoX86_64RelocGot,
+                        object::macho::X86_64_RELOC_SUBTRACTOR => {
+                            RelocationKind::MachoX86_64RelocSubtractor
+                        }
+                        object::macho::X86_64_RELOC_SIGNED_1 => {
+                            RelocationKind::MachoX86_64RelocSigned1
+                        }
+                        object::macho::X86_64_RELOC_SIGNED_2 => {
+                            RelocationKind::MachoX86_64RelocSigned2
+                        }
+                        object::macho::X86_64_RELOC_SIGNED_4 => {
+                            RelocationKind::MachoX86_64RelocSigned4
+                        }
+                        object::macho::X86_64_RELOC_TLV => RelocationKind::MachoX86_64RelocTlv,
+                        _ => {
+                            return Err(CompileError::Codegen(format!(
+                                "unknown relocation {reloc:?}"
+                            )))
+                        }
+                    }
+                }
+                _ => {
+                    return Err(CompileError::Codegen(format!(
+                        "unknown relocation {reloc:?}",
+                    )));
+                }
+            };
+
             relocations
                 .entry(section_index)
                 .or_default()
@@ -342,8 +590,21 @@ where
             section_to_custom_section.get(index).map_or_else(
                 || {
                     Err(CompileError::Codegen(format!(
-                        ".eh_frame section with index={:?} was never loaded",
-                        index
+                        ".eh_frame section with index={index:?} was never loaded",
+                    )))
+                },
+                |idx| Ok(*idx),
+            )
+        })
+        .collect::<Result<Vec<SectionIndex>, _>>()?;
+
+    let compact_unwind_section_indices = compact_unwind_section_indices
+        .iter()
+        .map(|index| {
+            section_to_custom_section.get(index).map_or_else(
+                || {
+                    Err(CompileError::Codegen(format!(
+                        "_compact_unwind section with index={index:?} was never loaded",
                     )))
                 },
                 |idx| Ok(*idx),
@@ -354,17 +615,13 @@ where
     let mut custom_sections = section_to_custom_section
         .iter()
         .map(|(elf_section_index, custom_section_index)| {
+            let section = obj.section_by_index(*elf_section_index).unwrap();
             (
                 custom_section_index,
                 CustomSection {
                     protection: CustomSectionProtection::Read,
-                    bytes: SectionBody::new_with_vec(
-                        elf.section_by_index(*elf_section_index)
-                            .unwrap()
-                            .data()
-                            .unwrap()
-                            .to_vec(),
-                    ),
+                    alignment: Some(section.align()),
+                    bytes: SectionBody::new_with_vec(section.data().unwrap().to_vec()),
                     relocations: relocations
                         .remove_entry(elf_section_index)
                         .map_or(vec![], |(_, v)| v),
@@ -379,7 +636,7 @@ where
         .collect::<PrimaryMap<SectionIndex, _>>();
 
     let function_body = FunctionBody {
-        body: elf
+        body: obj
             .section_by_index(root_section_index)
             .unwrap()
             .data()
@@ -401,7 +658,7 @@ where
     };
 
     Ok(CompiledFunction {
-        compiled_function: wasmer_types::CompiledFunction {
+        compiled_function: wasmer_compiler::types::function::CompiledFunction {
             body: function_body,
             relocations: relocations
                 .remove_entry(&root_section_index)
@@ -413,5 +670,6 @@ where
         },
         custom_sections,
         eh_frame_section_indices,
+        compact_unwind_section_indices,
     })
 }
diff --git a/lib/compiler-llvm/src/trampoline/wasm.rs b/lib/compiler-llvm/src/trampoline/wasm.rs
index a3be2314c0..e9a95f3a3d 100644
--- a/lib/compiler-llvm/src/trampoline/wasm.rs
+++ b/lib/compiler-llvm/src/trampoline/wasm.rs
@@ -1,40 +1,60 @@
-use crate::abi::{get_abi, Abi};
-use crate::config::{CompiledKind, LLVM};
-use crate::object_file::{load_object_file, CompiledFunction};
-use crate::translator::intrinsics::{type_to_llvm, type_to_llvm_ptr, Intrinsics};
-use inkwell::values::BasicMetadataValueEnum;
+use crate::{
+    abi::{get_abi, Abi, G0M0FunctionKind},
+    config::{CompiledKind, LLVM},
+    error::{err, err_nt},
+    object_file::{load_object_file, CompiledFunction},
+    translator::intrinsics::{type_to_llvm, type_to_llvm_ptr, Intrinsics},
+};
 use inkwell::{
     attributes::{Attribute, AttributeLoc},
     context::Context,
     module::{Linkage, Module},
-    passes::PassManager,
+    passes::PassBuilderOptions,
     targets::{FileType, TargetMachine},
-    types::{BasicType, FunctionType},
-    values::FunctionValue,
+    types::FunctionType,
+    values::{BasicMetadataValueEnum, FunctionValue},
     AddressSpace, DLLStorageClass,
 };
-use std::cmp;
-use std::convert::TryInto;
-use wasmer_types::{
-    CompileError, FunctionBody, FunctionType as FuncType, LocalFunctionIndex, RelocationTarget,
+use std::{cmp, convert::TryInto};
+use target_lexicon::BinaryFormat;
+use wasmer_compiler::types::{
+    function::FunctionBody, module::CompileModuleInfo, relocation::RelocationTarget,
 };
+use wasmer_types::{CompileError, FunctionType as FuncType, LocalFunctionIndex};
+use wasmer_vm::MemoryStyle;
 
 pub struct FuncTrampoline {
     ctx: Context,
     target_machine: TargetMachine,
     abi: Box<dyn Abi>,
+    binary_fmt: BinaryFormat,
+    func_section: String,
 }
 
-const FUNCTION_SECTION: &str = "__TEXT,wasmer_trmpl"; // Needs to be between 1 and 16 chars
+const FUNCTION_SECTION_ELF: &str = "__TEXT,wasmer_trmpl"; // Needs to be between 1 and 16 chars
+const FUNCTION_SECTION_MACHO: &str = "wasmer_trmpl"; // Needs to be between 1 and 16 chars
 
 impl FuncTrampoline {
-    pub fn new(target_machine: TargetMachine) -> Self {
+    pub fn new(
+        target_machine: TargetMachine,
+        binary_fmt: BinaryFormat,
+    ) -> Result<Self, CompileError> {
         let abi = get_abi(&target_machine);
-        Self {
+        Ok(Self {
             ctx: Context::create(),
             target_machine,
             abi,
-        }
+            func_section: match binary_fmt {
+                BinaryFormat::Elf => FUNCTION_SECTION_ELF.to_string(),
+                BinaryFormat::Macho => FUNCTION_SECTION_MACHO.to_string(),
+                _ => {
+                    return Err(CompileError::UnsupportedTarget(format!(
+                        "Unsupported binary format: {binary_fmt:?}",
+                    )))
+                }
+            },
+            binary_fmt,
+        })
     }
 
     pub fn trampoline_to_module(
@@ -42,6 +62,7 @@ impl FuncTrampoline {
         ty: &FuncType,
         config: &LLVM,
         name: &str,
+        compile_info: &CompileModuleInfo,
     ) -> Result<Module, CompileError> {
         // The function type, used for the callbacks.
         let function = CompiledKind::FunctionCallTrampoline(ty.clone());
@@ -51,16 +72,22 @@ impl FuncTrampoline {
         let target_data = target_machine.get_target_data();
         module.set_triple(&target_triple);
         module.set_data_layout(&target_data.get_data_layout());
-        let intrinsics = Intrinsics::declare(&module, &self.ctx, &target_data);
+        let intrinsics = Intrinsics::declare(&module, &self.ctx, &target_data, &self.binary_fmt);
+
+        let func_kind = if config.enable_g0m0_opt {
+            Some(G0M0FunctionKind::Local)
+        } else {
+            None
+        };
 
         let (callee_ty, callee_attrs) =
             self.abi
-                .func_type_to_llvm(&self.ctx, &intrinsics, None, ty)?;
+                .func_type_to_llvm(&self.ctx, &intrinsics, None, ty, func_kind)?;
         let trampoline_ty = intrinsics.void_ty.fn_type(
             &[
-                intrinsics.ctx_ptr_ty.into(),                       // vmctx ptr
-                callee_ty.ptr_type(AddressSpace::default()).into(), // callee function address
-                intrinsics.i128_ptr_ty.into(),                      // in/out values ptr
+                intrinsics.ptr_ty.into(), // vmctx ptr
+                intrinsics.ptr_ty.into(), // callee function address
+                intrinsics.ptr_ty.into(), // in/out values ptr
             ],
             false,
         );
@@ -68,14 +95,18 @@ impl FuncTrampoline {
         let trampoline_func = module.add_function(name, trampoline_ty, Some(Linkage::External));
         trampoline_func
             .as_global_value()
-            .set_section(Some(FUNCTION_SECTION));
+            .set_section(Some(&self.func_section));
         trampoline_func
             .as_global_value()
             .set_linkage(Linkage::DLLExport);
         trampoline_func
             .as_global_value()
             .set_dll_storage_class(DLLStorageClass::Export);
+        trampoline_func.add_attribute(AttributeLoc::Function, intrinsics.uwtable);
+        trampoline_func.add_attribute(AttributeLoc::Function, intrinsics.frame_pointer);
         self.generate_trampoline(
+            config,
+            compile_info,
             trampoline_func,
             ty,
             callee_ty,
@@ -88,20 +119,32 @@ impl FuncTrampoline {
             callbacks.preopt_ir(&function, &module);
         }
 
-        let pass_manager = PassManager::create(());
+        let mut passes = vec![];
 
         if config.enable_verifier {
-            pass_manager.add_verifier_pass();
+            passes.push("verify");
         }
 
-        pass_manager.add_early_cse_pass();
-
-        pass_manager.run_on(&module);
+        passes.push("instcombine");
+        module
+            .run_passes(
+                passes.join(",").as_str(),
+                target_machine,
+                PassBuilderOptions::create(),
+            )
+            .unwrap();
 
         if let Some(ref callbacks) = config.callbacks {
             callbacks.postopt_ir(&function, &module);
         }
 
+        // -- Uncomment to enable dumping intermediate LLVM objects
+        //module
+        //    .print_to_file(format!(
+        //        "{}/obj_trmpl.ll",
+        //        std::env!("LLVM_EH_TESTS_DUMP_DIR")
+        //    ))
+        //    .unwrap();
         Ok(module)
     }
 
@@ -110,8 +153,9 @@ impl FuncTrampoline {
         ty: &FuncType,
         config: &LLVM,
         name: &str,
+        compile_info: &CompileModuleInfo,
     ) -> Result<FunctionBody, CompileError> {
-        let module = self.trampoline_to_module(ty, config, name)?;
+        let module = self.trampoline_to_module(ty, config, name, compile_info)?;
         let function = CompiledKind::FunctionCallTrampoline(ty.clone());
         let target_machine = &self.target_machine;
 
@@ -121,6 +165,10 @@ impl FuncTrampoline {
 
         if let Some(ref callbacks) = config.callbacks {
             callbacks.obj_memory_buffer(&function, &memory_buffer);
+            let asm_buffer = target_machine
+                .write_to_memory_buffer(&module, FileType::Assembly)
+                .unwrap();
+            callbacks.asm_memory_buffer(&function, &asm_buffer);
         }
 
         let mem_buf_slice = memory_buffer.as_slice();
@@ -128,24 +176,27 @@ impl FuncTrampoline {
             compiled_function,
             custom_sections,
             eh_frame_section_indices,
+            mut compact_unwind_section_indices,
+            ..
         } = load_object_file(
             mem_buf_slice,
-            FUNCTION_SECTION,
+            &self.func_section,
             RelocationTarget::LocalFunc(LocalFunctionIndex::from_u32(0)),
             |name: &str| {
                 Err(CompileError::Codegen(format!(
-                    "trampoline generation produced reference to unknown function {}",
-                    name
+                    "trampoline generation produced reference to unknown function {name}",
                 )))
             },
+            self.binary_fmt,
         )?;
         let mut all_sections_are_eh_sections = true;
-        if eh_frame_section_indices.len() != custom_sections.len() {
+        let mut unwind_section_indices = eh_frame_section_indices;
+        unwind_section_indices.append(&mut compact_unwind_section_indices);
+        if unwind_section_indices.len() != custom_sections.len() {
             all_sections_are_eh_sections = false;
         } else {
-            let mut eh_frame_section_indices = eh_frame_section_indices;
-            eh_frame_section_indices.sort_unstable();
-            for (idx, section_idx) in eh_frame_section_indices.iter().enumerate() {
+            unwind_section_indices.sort_unstable();
+            for (idx, section_idx) in unwind_section_indices.iter().enumerate() {
                 if idx as u32 != section_idx.as_u32() {
                     all_sections_are_eh_sections = false;
                     break;
@@ -184,18 +235,18 @@ impl FuncTrampoline {
         let target_triple = target_machine.get_triple();
         module.set_triple(&target_triple);
         module.set_data_layout(&target_data.get_data_layout());
-        let intrinsics = Intrinsics::declare(&module, &self.ctx, &target_data);
+        let intrinsics = Intrinsics::declare(&module, &self.ctx, &target_data, &self.binary_fmt);
 
         let (trampoline_ty, trampoline_attrs) =
             self.abi
-                .func_type_to_llvm(&self.ctx, &intrinsics, None, ty)?;
+                .func_type_to_llvm(&self.ctx, &intrinsics, None, ty, None)?;
         let trampoline_func = module.add_function(name, trampoline_ty, Some(Linkage::External));
         for (attr, attr_loc) in trampoline_attrs {
             trampoline_func.add_attribute(attr_loc, attr);
         }
         trampoline_func
             .as_global_value()
-            .set_section(Some(FUNCTION_SECTION));
+            .set_section(Some(&self.func_section));
         trampoline_func
             .as_global_value()
             .set_linkage(Linkage::DLLExport);
@@ -208,15 +259,20 @@ impl FuncTrampoline {
             callbacks.preopt_ir(&function, &module);
         }
 
-        let pass_manager = PassManager::create(());
+        let mut passes = vec![];
 
         if config.enable_verifier {
-            pass_manager.add_verifier_pass();
+            passes.push("verify");
         }
 
-        pass_manager.add_early_cse_pass();
-
-        pass_manager.run_on(&module);
+        passes.push("early-cse");
+        module
+            .run_passes(
+                passes.join(",").as_str(),
+                target_machine,
+                PassBuilderOptions::create(),
+            )
+            .unwrap();
 
         if let Some(ref callbacks) = config.callbacks {
             callbacks.postopt_ir(&function, &module);
@@ -241,6 +297,10 @@ impl FuncTrampoline {
 
         if let Some(ref callbacks) = config.callbacks {
             callbacks.obj_memory_buffer(&function, &memory_buffer);
+            let asm_buffer = target_machine
+                .write_to_memory_buffer(&module, FileType::Assembly)
+                .unwrap();
+            callbacks.asm_memory_buffer(&function, &asm_buffer)
         }
 
         let mem_buf_slice = memory_buffer.as_slice();
@@ -248,24 +308,28 @@ impl FuncTrampoline {
             compiled_function,
             custom_sections,
             eh_frame_section_indices,
+            mut compact_unwind_section_indices,
+            ..
         } = load_object_file(
             mem_buf_slice,
-            FUNCTION_SECTION,
+            &self.func_section,
             RelocationTarget::LocalFunc(LocalFunctionIndex::from_u32(0)),
             |name: &str| {
                 Err(CompileError::Codegen(format!(
-                    "trampoline generation produced reference to unknown function {}",
-                    name
+                    "trampoline generation produced reference to unknown function {name}",
                 )))
             },
+            self.binary_fmt,
         )?;
         let mut all_sections_are_eh_sections = true;
-        if eh_frame_section_indices.len() != custom_sections.len() {
+        let mut unwind_section_indices = eh_frame_section_indices;
+        unwind_section_indices.append(&mut compact_unwind_section_indices);
+
+        if unwind_section_indices.len() != custom_sections.len() {
             all_sections_are_eh_sections = false;
         } else {
-            let mut eh_frame_section_indices = eh_frame_section_indices;
-            eh_frame_section_indices.sort_unstable();
-            for (idx, section_idx) in eh_frame_section_indices.iter().enumerate() {
+            unwind_section_indices.sort_unstable();
+            for (idx, section_idx) in unwind_section_indices.iter().enumerate() {
                 if idx as u32 != section_idx.as_u32() {
                     all_sections_are_eh_sections = false;
                     break;
@@ -290,8 +354,11 @@ impl FuncTrampoline {
         })
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn generate_trampoline<'ctx>(
         &self,
+        config: &LLVM,
+        compile_info: &CompileModuleInfo,
         trampoline_func: FunctionValue,
         func_sig: &FuncType,
         llvm_func_type: FunctionType,
@@ -318,7 +385,11 @@ impl FuncTrampoline {
             };
 
         let mut args_vec: Vec<BasicMetadataValueEnum> =
-            Vec::with_capacity(func_sig.params().len() + 1);
+            Vec::with_capacity(if config.enable_g0m0_opt {
+                func_sig.params().len() + 3
+            } else {
+                func_sig.params().len() + 1
+            });
 
         if self.abi.is_sret(func_sig)? {
             let basic_types: Vec<_> = func_sig
@@ -328,53 +399,176 @@ impl FuncTrampoline {
                 .collect::<Result<_, _>>()?;
 
             let sret_ty = context.struct_type(&basic_types, false);
-            args_vec.push(builder.build_alloca(sret_ty, "sret").into());
+            args_vec.push(err!(builder.build_alloca(sret_ty, "sret")).into());
         }
 
         args_vec.push(callee_vmctx_ptr.into());
 
+        if config.enable_g0m0_opt {
+            let wasm_module = &compile_info.module;
+            let memory_styles = &compile_info.memory_styles;
+            let callee_vmctx_ptr_value = callee_vmctx_ptr.into_pointer_value();
+            // get value of G0, get a pointer to M0's base
+
+            let offsets = wasmer_vm::VMOffsets::new(8, wasm_module);
+
+            let global_index = wasmer_types::GlobalIndex::from_u32(0);
+            let global_type = wasm_module.globals[global_index];
+            let global_value_type = global_type.ty;
+            let global_mutability = global_type.mutability;
+
+            let offset =
+                if let Some(local_global_index) = wasm_module.local_global_index(global_index) {
+                    offsets.vmctx_vmglobal_definition(local_global_index)
+                } else {
+                    offsets.vmctx_vmglobal_import(global_index)
+                };
+            let offset = intrinsics.i32_ty.const_int(offset.into(), false);
+            let global_ptr = {
+                let global_ptr_ptr = unsafe {
+                    err!(builder.build_gep(intrinsics.i8_ty, callee_vmctx_ptr_value, &[offset], ""))
+                };
+                let global_ptr_ptr =
+                    err!(builder.build_bit_cast(global_ptr_ptr, intrinsics.ptr_ty, ""))
+                        .into_pointer_value();
+                let global_ptr = err!(builder.build_load(intrinsics.ptr_ty, global_ptr_ptr, ""))
+                    .into_pointer_value();
+
+                global_ptr
+            };
+
+            let global_ptr = err!(builder.build_bit_cast(
+                global_ptr,
+                type_to_llvm_ptr(intrinsics, global_value_type)?,
+                "",
+            ))
+            .into_pointer_value();
+
+            let global_value = match global_mutability {
+                wasmer_types::Mutability::Const => {
+                    err!(builder.build_load(
+                        type_to_llvm(intrinsics, global_value_type)?,
+                        global_ptr,
+                        "g0",
+                    ))
+                }
+                wasmer_types::Mutability::Var => {
+                    err!(builder.build_load(
+                        type_to_llvm(intrinsics, global_value_type)?,
+                        global_ptr,
+                        ""
+                    ))
+                }
+            };
+
+            global_value.set_name("trmpl_g0");
+            args_vec.push(global_value.into());
+
+            // load mem
+            let memory_index = wasmer_types::MemoryIndex::from_u32(0);
+            let memory_definition_ptr = if let Some(local_memory_index) =
+                wasm_module.local_memory_index(memory_index)
+            {
+                let offset = offsets.vmctx_vmmemory_definition(local_memory_index);
+                let offset = intrinsics.i32_ty.const_int(offset.into(), false);
+                unsafe {
+                    err!(builder.build_gep(intrinsics.i8_ty, callee_vmctx_ptr_value, &[offset], ""))
+                }
+            } else {
+                let offset = offsets.vmctx_vmmemory_import(memory_index);
+                let offset = intrinsics.i32_ty.const_int(offset.into(), false);
+                let memory_definition_ptr_ptr = unsafe {
+                    err!(builder.build_gep(intrinsics.i8_ty, callee_vmctx_ptr_value, &[offset], ""))
+                };
+                let memory_definition_ptr_ptr =
+                    err!(builder.build_bit_cast(memory_definition_ptr_ptr, intrinsics.ptr_ty, "",))
+                        .into_pointer_value();
+                let memory_definition_ptr =
+                    err!(builder.build_load(intrinsics.ptr_ty, memory_definition_ptr_ptr, ""))
+                        .into_pointer_value();
+
+                memory_definition_ptr
+            };
+            let memory_definition_ptr =
+                err!(builder.build_bit_cast(memory_definition_ptr, intrinsics.ptr_ty, "",))
+                    .into_pointer_value();
+            let base_ptr = err!(builder.build_struct_gep(
+                intrinsics.vmmemory_definition_ty,
+                memory_definition_ptr,
+                intrinsics.vmmemory_definition_base_element,
+                "",
+            ));
+
+            let memory_style = &memory_styles[memory_index];
+            let base_ptr = if let MemoryStyle::Dynamic { .. } = memory_style {
+                base_ptr
+            } else {
+                let base_ptr =
+                    err!(builder.build_load(intrinsics.ptr_ty, base_ptr, "")).into_pointer_value();
+
+                base_ptr
+            };
+
+            base_ptr.set_name("trmpl_m0_base_ptr");
+
+            args_vec.push(base_ptr.into());
+        }
+
         for (i, param_ty) in func_sig.params().iter().enumerate() {
             let index = intrinsics.i32_ty.const_int(i as _, false);
             let item_pointer = unsafe {
-                builder.build_in_bounds_gep(intrinsics.i128_ty, args_rets_ptr, &[index], "arg_ptr")
+                err!(builder.build_in_bounds_gep(
+                    intrinsics.i128_ty,
+                    args_rets_ptr,
+                    &[index],
+                    "arg_ptr"
+                ))
             };
 
             let casted_type = type_to_llvm(intrinsics, *param_ty)?;
             let casted_pointer_type = type_to_llvm_ptr(intrinsics, *param_ty)?;
 
-            let typed_item_pointer =
-                builder.build_pointer_cast(item_pointer, casted_pointer_type, "typed_arg_pointer");
+            let typed_item_pointer = err!(builder.build_pointer_cast(
+                item_pointer,
+                casted_pointer_type,
+                "typed_arg_pointer"
+            ));
 
-            let arg = builder.build_load(casted_type, typed_item_pointer, "arg");
+            let arg = err!(builder.build_load(casted_type, typed_item_pointer, "arg"));
             args_vec.push(arg.into());
         }
 
-        let call_site =
-            builder.build_indirect_call(llvm_func_type, func_ptr, args_vec.as_slice(), "call");
+        let call_site = err!(builder.build_indirect_call(
+            llvm_func_type,
+            func_ptr,
+            args_vec.as_slice(),
+            "call"
+        ));
         for (attr, attr_loc) in func_attrs {
             call_site.add_attribute(*attr_loc, *attr);
         }
 
         let rets = self
             .abi
-            .rets_from_call(&builder, intrinsics, call_site, func_sig);
-        let mut idx = 0;
-        rets.iter().for_each(|v| {
+            .rets_from_call(&builder, intrinsics, call_site, func_sig)?;
+        for (idx, v) in rets.into_iter().enumerate() {
             let ptr = unsafe {
-                builder.build_gep(
+                err!(builder.build_gep(
                     intrinsics.i128_ty,
                     args_rets_ptr,
-                    &[intrinsics.i32_ty.const_int(idx, false)],
+                    &[intrinsics.i32_ty.const_int(idx as u64, false)],
                     "",
-                )
+                ))
             };
-            let ptr =
-                builder.build_pointer_cast(ptr, v.get_type().ptr_type(AddressSpace::default()), "");
-            builder.build_store(ptr, *v);
-            idx += 1;
-        });
+            let ptr = err!(builder.build_pointer_cast(
+                ptr,
+                self.ctx.ptr_type(AddressSpace::default()),
+                ""
+            ));
+            err!(builder.build_store(ptr, v));
+        }
 
-        builder.build_return(None);
+        err!(builder.build_return(None));
         Ok(())
     }
 
@@ -390,61 +584,63 @@ impl FuncTrampoline {
         builder.position_at_end(entry_block);
 
         // Allocate stack space for the params and results.
-        let values = builder.build_alloca(
+        let values = err!(builder.build_alloca(
             intrinsics.i128_ty.array_type(cmp::max(
                 func_sig.params().len().try_into().unwrap(),
                 func_sig.results().len().try_into().unwrap(),
             )),
             "",
-        );
+        ));
 
         // Copy params to 'values'.
         let first_user_param = if self.abi.is_sret(func_sig)? { 2 } else { 1 };
         for i in 0..func_sig.params().len() {
             let ptr = unsafe {
-                builder.build_in_bounds_gep(
+                err!(builder.build_in_bounds_gep(
                     intrinsics.i128_ty,
                     values,
                     &[intrinsics.i32_ty.const_int(i.try_into().unwrap(), false)],
                     "args",
-                )
+                ))
             };
-            let ptr = builder
-                .build_bitcast(ptr, type_to_llvm_ptr(intrinsics, func_sig.params()[i])?, "")
-                .into_pointer_value();
-            builder.build_store(
+            let ptr = err!(builder.build_bit_cast(
+                ptr,
+                type_to_llvm_ptr(intrinsics, func_sig.params()[i])?,
+                ""
+            ))
+            .into_pointer_value();
+            err!(builder.build_store(
                 ptr,
                 trampoline_func
                     .get_nth_param(i as u32 + first_user_param)
                     .unwrap(),
-            );
+            ));
         }
 
         let callee_ptr_ty = intrinsics.void_ty.fn_type(
             &[
-                intrinsics.ctx_ptr_ty.into(),  // vmctx ptr
-                intrinsics.i128_ptr_ty.into(), // in/out values ptr
+                intrinsics.ptr_ty.into(), // vmctx ptr
+                intrinsics.ptr_ty.into(), // in/out values ptr
             ],
             false,
         );
-        let callee_ty = callee_ptr_ty.ptr_type(AddressSpace::default());
         let vmctx = self.abi.get_vmctx_ptr_param(&trampoline_func);
         let callee_ty =
-            builder.build_bitcast(vmctx, callee_ty.ptr_type(AddressSpace::default()), "");
-        let callee = builder
-            .build_load(intrinsics.ctx_ptr_ty, callee_ty.into_pointer_value(), "")
-            .into_pointer_value();
+            err!(builder.build_bit_cast(vmctx, self.ctx.ptr_type(AddressSpace::default()), ""));
+        let callee =
+            err!(builder.build_load(intrinsics.ptr_ty, callee_ty.into_pointer_value(), ""))
+                .into_pointer_value();
 
-        let values_ptr = builder.build_pointer_cast(values, intrinsics.i128_ptr_ty, "");
-        builder.build_indirect_call(
+        let values_ptr = err!(builder.build_pointer_cast(values, intrinsics.ptr_ty, ""));
+        err!(builder.build_indirect_call(
             callee_ptr_ty,
             callee,
             &[vmctx.into(), values_ptr.into()],
             "",
-        );
+        ));
 
         if func_sig.results().is_empty() {
-            builder.build_return(None);
+            err!(builder.build_return(None));
         } else {
             let results = func_sig
                 .results()
@@ -452,16 +648,19 @@ impl FuncTrampoline {
                 .enumerate()
                 .map(|(idx, ty)| {
                     let ptr = unsafe {
-                        builder.build_gep(
+                        err!(builder.build_gep(
                             intrinsics.i128_ty,
                             values,
                             &[intrinsics.i32_ty.const_int(idx.try_into().unwrap(), false)],
                             "",
-                        )
+                        ))
                     };
-                    let ptr =
-                        builder.build_pointer_cast(ptr, type_to_llvm_ptr(intrinsics, *ty)?, "");
-                    Ok(builder.build_load(type_to_llvm(intrinsics, *ty)?, ptr, ""))
+                    let ptr = err!(builder.build_pointer_cast(
+                        ptr,
+                        type_to_llvm_ptr(intrinsics, *ty)?,
+                        ""
+                    ));
+                    err_nt!(builder.build_load(type_to_llvm(intrinsics, *ty)?, ptr, ""))
                 })
                 .collect::<Result<Vec<_>, CompileError>>()?;
 
@@ -479,25 +678,26 @@ impl FuncTrampoline {
                 let mut struct_value = context.struct_type(&basic_types, false).get_undef();
 
                 for (idx, value) in results.iter().enumerate() {
-                    let value = builder.build_bitcast(
+                    let value = err!(builder.build_bit_cast(
                         *value,
                         type_to_llvm(intrinsics, func_sig.results()[idx])?,
                         "",
-                    );
-                    struct_value = builder
-                        .build_insert_value(struct_value, value, idx as u32, "")
-                        .unwrap()
-                        .into_struct_value();
+                    ));
+                    struct_value =
+                        err!(builder.build_insert_value(struct_value, value, idx as u32, ""))
+                            .into_struct_value();
                 }
-                builder.build_store(sret, struct_value);
-                builder.build_return(None);
+                err!(builder.build_store(sret, struct_value));
+                err!(builder.build_return(None));
             } else {
-                builder.build_return(Some(&self.abi.pack_values_for_register_return(
-                    intrinsics,
-                    &builder,
-                    results.as_slice(),
-                    &trampoline_func.get_type(),
-                )?));
+                err!(
+                    builder.build_return(Some(&self.abi.pack_values_for_register_return(
+                        intrinsics,
+                        &builder,
+                        results.as_slice(),
+                        &trampoline_func.get_type(),
+                    )?))
+                );
             }
         }
 
diff --git a/lib/compiler-llvm/src/translator/code.rs b/lib/compiler-llvm/src/translator/code.rs
index e4d00ee271..6991054b0c 100644
--- a/lib/compiler-llvm/src/translator/code.rs
+++ b/lib/compiler-llvm/src/translator/code.rs
@@ -1,61 +1,94 @@
+use std::collections::HashMap;
+
 use super::{
     intrinsics::{
         tbaa_label, type_to_llvm, CtxType, FunctionCache, GlobalCache, Intrinsics, MemoryCache,
     },
     // stackmap::{StackmapEntry, StackmapEntryKind, StackmapRegistry, ValueSemantic},
-    state::{ControlFrame, ExtraInfo, IfElseState, State},
+    state::{ControlFrame, ExtraInfo, IfElseState, State, TagCatchInfo},
 };
 use inkwell::{
     attributes::AttributeLoc,
     builder::Builder,
     context::Context,
     module::{Linkage, Module},
-    passes::PassManager,
+    passes::PassBuilderOptions,
     targets::{FileType, TargetMachine},
     types::{BasicType, BasicTypeEnum, FloatMathType, IntType, PointerType, VectorType},
     values::{
-        BasicMetadataValueEnum, BasicValue, BasicValueEnum, FloatValue, FunctionValue,
-        InstructionOpcode, InstructionValue, IntValue, PhiValue, PointerValue, VectorValue,
+        AnyValue, BasicMetadataValueEnum, BasicValue, BasicValueEnum, CallSiteValue, FloatValue,
+        FunctionValue, InstructionOpcode, InstructionValue, IntValue, PhiValue, PointerValue,
+        VectorValue,
     },
     AddressSpace, AtomicOrdering, AtomicRMWBinOp, DLLStorageClass, FloatPredicate, IntPredicate,
 };
+use itertools::Itertools;
 use smallvec::SmallVec;
+use target_lexicon::BinaryFormat;
 
-use crate::abi::{get_abi, Abi};
-use crate::config::{CompiledKind, LLVM};
-use crate::object_file::{load_object_file, CompiledFunction};
-use wasmer_compiler::wasmparser::{MemArg, Operator};
+use crate::{
+    abi::{get_abi, Abi, G0M0FunctionKind, LocalFunctionG0M0params},
+    config::{CompiledKind, LLVM},
+    error::{err, err_nt},
+    object_file::{load_object_file, CompiledFunction},
+};
 use wasmer_compiler::{
-    from_binaryreadererror_wasmerror, wpheaptype_to_type, wptype_to_type, FunctionBinaryReader,
-    FunctionBodyData, MiddlewareBinaryReader, ModuleMiddlewareChain, ModuleTranslationState,
+    from_binaryreadererror_wasmerror,
+    types::{
+        relocation::RelocationTarget,
+        symbols::{Symbol, SymbolRegistry},
+    },
+    wasmparser::{Catch, MemArg, Operator},
+    wpheaptype_to_type, wptype_to_type, FunctionBinaryReader, FunctionBodyData,
+    MiddlewareBinaryReader, ModuleMiddlewareChain, ModuleTranslationState,
 };
-use wasmer_types::entity::PrimaryMap;
+use wasmer_types::{entity::PrimaryMap, TagIndex};
 use wasmer_types::{
     CompileError, FunctionIndex, FunctionType, GlobalIndex, LocalFunctionIndex, MemoryIndex,
-    ModuleInfo, RelocationTarget, SignatureIndex, Symbol, SymbolRegistry, TableIndex, Type,
+    ModuleInfo, SignatureIndex, TableIndex, Type,
 };
 use wasmer_vm::{MemoryStyle, TableStyle, VMOffsets};
 
-const FUNCTION_SECTION: &str = "__TEXT,wasmer_function";
+const FUNCTION_SECTION_ELF: &str = "__TEXT,wasmer_function";
+const FUNCTION_SECTION_MACHO: &str = "__TEXT";
+const FUNCTION_SEGMENT_MACHO: &str = "wasmer_function";
 
-fn to_compile_error(err: impl std::error::Error) -> CompileError {
-    CompileError::Codegen(format!("{}", err))
-}
+// Since we want to use module-local tag numbers for landing pads,
+// the catch-all tag can't be zero; we instead use i32::MAX, which
+// is hopefully large enough to not conflict with any real tag.
+// If you have 2 billion tags in a single module, you deserve what you get.
+// ( Arshia: that comment above is AI-generated... AI is savage XD )
+const CATCH_ALL_TAG_VALUE: i32 = i32::MAX;
 
 pub struct FuncTranslator {
     ctx: Context,
     target_machine: TargetMachine,
     abi: Box<dyn Abi>,
+    binary_fmt: BinaryFormat,
+    func_section: String,
 }
 
 impl FuncTranslator {
-    pub fn new(target_machine: TargetMachine) -> Self {
+    pub fn new(
+        target_machine: TargetMachine,
+        binary_fmt: BinaryFormat,
+    ) -> Result<Self, CompileError> {
         let abi = get_abi(&target_machine);
-        Self {
+        Ok(Self {
             ctx: Context::create(),
             target_machine,
             abi,
-        }
+            func_section: match binary_fmt {
+                BinaryFormat::Elf => FUNCTION_SECTION_ELF.to_string(),
+                BinaryFormat::Macho => FUNCTION_SEGMENT_MACHO.to_string(),
+                _ => {
+                    return Err(CompileError::UnsupportedTarget(format!(
+                        "Unsupported binary format: {binary_fmt:?}"
+                    )))
+                }
+            },
+            binary_fmt,
+        })
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -75,9 +108,17 @@ impl FuncTranslator {
         let func_index = wasm_module.func_index(*local_func_index);
         let function_name =
             symbol_registry.symbol_to_name(Symbol::LocalFunction(*local_func_index));
+
+        let g0m0_is_enabled = config.enable_g0m0_opt;
+        let func_kind = if g0m0_is_enabled {
+            Some(G0M0FunctionKind::Local)
+        } else {
+            None
+        };
+
         let module_name = match wasm_module.name.as_ref() {
-            None => format!("<anonymous module> function {}", function_name),
-            Some(module_name) => format!("module {} function {}", module_name, function_name),
+            None => format!("<anonymous module> function {function_name}"),
+            Some(module_name) => format!("module {module_name} function {function_name}"),
         };
         let module = self.ctx.create_module(module_name.as_str());
 
@@ -93,10 +134,14 @@ impl FuncTranslator {
 
         // TODO: pointer width
         let offsets = VMOffsets::new(8, wasm_module);
-        let intrinsics = Intrinsics::declare(&module, &self.ctx, &target_data);
-        let (func_type, func_attrs) =
-            self.abi
-                .func_type_to_llvm(&self.ctx, &intrinsics, Some(&offsets), wasm_fn_type)?;
+        let intrinsics = Intrinsics::declare(&module, &self.ctx, &target_data, &self.binary_fmt);
+        let (func_type, func_attrs) = self.abi.func_type_to_llvm(
+            &self.ctx,
+            &intrinsics,
+            Some(&offsets),
+            wasm_fn_type,
+            func_kind,
+        )?;
 
         let func = module.add_function(&function_name, func_type, Some(Linkage::External));
         for (attr, attr_loc) in &func_attrs {
@@ -104,8 +149,25 @@ impl FuncTranslator {
         }
 
         func.add_attribute(AttributeLoc::Function, intrinsics.stack_probe);
+        func.add_attribute(AttributeLoc::Function, intrinsics.uwtable);
+        func.add_attribute(AttributeLoc::Function, intrinsics.frame_pointer);
+
+        let section = match self.binary_fmt {
+            BinaryFormat::Elf => FUNCTION_SECTION_ELF.to_string(),
+            BinaryFormat::Macho => {
+                format!("{FUNCTION_SECTION_MACHO},{FUNCTION_SEGMENT_MACHO}")
+            }
+            _ => {
+                return Err(CompileError::UnsupportedTarget(format!(
+                    "Unsupported binary format: {:?}",
+                    self.binary_fmt
+                )))
+            }
+        };
+
         func.set_personality_function(intrinsics.personality);
-        func.as_global_value().set_section(Some(FUNCTION_SECTION));
+        func.as_global_value().set_section(Some(&section));
+
         func.set_linkage(Linkage::DLLExport);
         func.as_global_value()
             .set_dll_storage_class(DLLStorageClass::Export);
@@ -117,7 +179,7 @@ impl FuncTranslator {
         let cache_builder = self.ctx.create_builder();
         let builder = self.ctx.create_builder();
         cache_builder.position_at_end(entry);
-        let br = cache_builder.build_unconditional_branch(start_of_code);
+        let br = err!(cache_builder.build_unconditional_branch(start_of_code));
         alloca_builder.position_before(&br);
         cache_builder.position_before(&br);
         builder.position_at_end(start_of_code);
@@ -127,9 +189,11 @@ impl FuncTranslator {
         let phis: SmallVec<[PhiValue; 1]> = wasm_fn_type
             .results()
             .iter()
-            .map(|&wasm_ty| type_to_llvm(&intrinsics, wasm_ty).map(|ty| builder.build_phi(ty, "")))
+            .map(|&wasm_ty| {
+                type_to_llvm(&intrinsics, wasm_ty).map(|ty| builder.build_phi(ty, "").unwrap())
+            })
             .collect::<Result<_, _>>()?;
-        state.push_block(return_, phis);
+        state.push_block(return_, phis, 0);
         builder.position_at_end(start_of_code);
 
         let mut reader = MiddlewareBinaryReader::new_with_offset(
@@ -145,40 +209,63 @@ impl FuncTranslator {
         let mut params = vec![];
         let first_param =
             if func_type.get_return_type().is_none() && wasm_fn_type.results().len() > 1 {
-                2
+                if g0m0_is_enabled {
+                    4
+                } else {
+                    2
+                }
+            } else if g0m0_is_enabled {
+                3
             } else {
                 1
             };
         let mut is_first_alloca = true;
-        let mut insert_alloca = |ty, name| {
-            let alloca = alloca_builder.build_alloca(ty, name);
+        let mut insert_alloca = |ty, name: String| -> Result<PointerValue, CompileError> {
+            let alloca = err!(alloca_builder.build_alloca(ty, &name));
             if is_first_alloca {
                 alloca_builder.position_at(entry, &alloca.as_instruction_value().unwrap());
                 is_first_alloca = false;
             }
-            alloca
+            Ok(alloca)
         };
 
+        // Uncomment to print, at the start of the function, the function name.
+        // (poor man's debugger!)
+        //let func_name_str =
+        //    err!(alloca_builder.build_global_string_ptr(&function_name, "function_name"));
+        //
+        //_ = alloca_builder.build_call(
+        //    intrinsics.debug_str,
+        //    &[
+        //        func_name_str.as_pointer_value().into(),
+        //        intrinsics
+        //            .i32_ty
+        //            .const_int(function_name.len() as _, false)
+        //            .into(),
+        //    ],
+        //    "",
+        //);
+
         for idx in 0..wasm_fn_type.params().len() {
             let ty = wasm_fn_type.params()[idx];
             let ty = type_to_llvm(&intrinsics, ty)?;
             let value = func
                 .get_nth_param((idx as u32).checked_add(first_param).unwrap())
                 .unwrap();
-            let alloca = insert_alloca(ty, "param");
-            cache_builder.build_store(alloca, value);
+            let alloca = insert_alloca(ty, format!("param_{idx}"))?;
+            err!(cache_builder.build_store(alloca, value));
             params.push((ty, alloca));
         }
 
         let mut locals = vec![];
         let num_locals = reader.read_local_count()?;
-        for _ in 0..num_locals {
+        for idx in 0..num_locals {
             let (count, ty) = reader.read_local_decl()?;
-            let ty = wptype_to_type(ty).map_err(to_compile_error)?;
+            let ty = err!(wptype_to_type(ty));
             let ty = type_to_llvm(&intrinsics, ty)?;
             for _ in 0..count {
-                let alloca = insert_alloca(ty, "local");
-                cache_builder.build_store(alloca, ty.const_zero());
+                let alloca = insert_alloca(ty, format!("local_{idx}"))?;
+                err!(cache_builder.build_store(alloca, ty.const_zero()));
                 locals.push((ty, alloca));
             }
         }
@@ -186,7 +273,21 @@ impl FuncTranslator {
         let mut params_locals = params.clone();
         params_locals.extend(locals.iter().cloned());
 
+        let mut g0m0_params = None;
+
+        if g0m0_is_enabled {
+            let value = self.abi.get_g0_ptr_param(&func);
+            let g0 = insert_alloca(intrinsics.i32_ty.as_basic_type_enum(), "g0".to_string())?;
+            err!(cache_builder.build_store(g0, value));
+            g0.set_name("g0");
+            let m0 = self.abi.get_m0_ptr_param(&func);
+            m0.set_name("m0_base_ptr");
+
+            g0m0_params = Some((g0, m0));
+        }
+
         let mut fcg = LLVMFunctionCodeGenerator {
+            g0m0: g0m0_params,
             context: &self.ctx,
             builder,
             alloca_builder,
@@ -194,7 +295,7 @@ impl FuncTranslator {
             state,
             function: func,
             locals: params_locals,
-            ctx: CtxType::new(wasm_module, &func, &cache_builder, &*self.abi),
+            ctx: CtxType::new(wasm_module, &func, &cache_builder, &*self.abi, config),
             unreachable_depth: 0,
             memory_styles,
             _table_styles,
@@ -204,7 +305,12 @@ impl FuncTranslator {
             symbol_registry,
             abi: &*self.abi,
             config,
+            exception_types_cache: HashMap::new(),
+            vmctx_alloca: None,
+            tags_cache: HashMap::new(),
+            binary_fmt: self.binary_fmt,
         };
+
         fcg.ctx.add_func(
             func_index,
             func.as_global_value().as_pointer_value(),
@@ -225,42 +331,64 @@ impl FuncTranslator {
             callbacks.preopt_ir(&function, &module);
         }
 
-        let pass_manager = PassManager::create(());
+        let mut passes = vec![];
 
         if config.enable_verifier {
-            pass_manager.add_verifier_pass();
+            passes.push("verify");
         }
 
-        pass_manager.add_type_based_alias_analysis_pass();
-        pass_manager.add_sccp_pass();
-        pass_manager.add_prune_eh_pass();
-        pass_manager.add_dead_arg_elimination_pass();
-        pass_manager.add_lower_expect_intrinsic_pass();
-        pass_manager.add_scalar_repl_aggregates_pass();
-        pass_manager.add_instruction_combining_pass();
-        pass_manager.add_jump_threading_pass();
-        pass_manager.add_correlated_value_propagation_pass();
-        pass_manager.add_cfg_simplification_pass();
-        pass_manager.add_reassociate_pass();
-        pass_manager.add_loop_rotate_pass();
-        pass_manager.add_ind_var_simplify_pass();
-        pass_manager.add_licm_pass();
-        pass_manager.add_loop_vectorize_pass();
-        pass_manager.add_instruction_combining_pass();
-        pass_manager.add_sccp_pass();
-        pass_manager.add_reassociate_pass();
-        pass_manager.add_cfg_simplification_pass();
-        pass_manager.add_gvn_pass();
-        pass_manager.add_memcpy_optimize_pass();
-        pass_manager.add_dead_store_elimination_pass();
-        pass_manager.add_bit_tracking_dce_pass();
-        pass_manager.add_instruction_combining_pass();
-        pass_manager.add_reassociate_pass();
-        pass_manager.add_cfg_simplification_pass();
-        pass_manager.add_slp_vectorize_pass();
-        pass_manager.add_early_cse_pass();
-
-        pass_manager.run_on(&module);
+        passes.push("sccp");
+        passes.push("early-cse");
+        //passes.push("deadargelim");
+        passes.push("adce");
+        passes.push("sroa");
+        passes.push("aggressive-instcombine");
+        passes.push("jump-threading");
+        //passes.push("ipsccp");
+        passes.push("simplifycfg");
+        passes.push("reassociate");
+        passes.push("loop-rotate");
+        passes.push("indvars");
+        //passes.push("lcssa");
+        //passes.push("licm");
+        //passes.push("instcombine");
+        passes.push("sccp");
+        passes.push("reassociate");
+        passes.push("simplifycfg");
+        passes.push("gvn");
+        passes.push("memcpyopt");
+        passes.push("dse");
+        passes.push("dce");
+        //passes.push("instcombine");
+        passes.push("reassociate");
+        passes.push("simplifycfg");
+        passes.push("mem2reg");
+
+        //let llvm_dump_path = std::env::var("WASMER_LLVM_DUMP_DIR");
+        //if let Ok(ref llvm_dump_path) = llvm_dump_path {
+        //    let path = std::path::Path::new(llvm_dump_path);
+        //    if !path.exists() {
+        //        std::fs::create_dir_all(path).unwrap()
+        //    }
+        //    let path = path.join(format!("{function_name}.ll"));
+        //    _ = module.print_to_file(path).unwrap();
+        //}
+
+        module
+            .run_passes(
+                passes.join(",").as_str(),
+                target_machine,
+                PassBuilderOptions::create(),
+            )
+            .unwrap();
+
+        //if let Ok(ref llvm_dump_path) = llvm_dump_path {
+        //    if !passes.is_empty() {
+        //        let path =
+        //            std::path::Path::new(llvm_dump_path).join(format!("{function_name}_opt.ll"));
+        //        _ = module.print_to_file(path).unwrap();
+        //    }
+        //}
 
         if let Some(ref callbacks) = config.callbacks {
             callbacks.postopt_ir(&function, &module);
@@ -299,51 +427,66 @@ impl FuncTranslator {
 
         if let Some(ref callbacks) = config.callbacks {
             callbacks.obj_memory_buffer(&function, &memory_buffer);
+            let asm_buffer = target_machine
+                .write_to_memory_buffer(&module, FileType::Assembly)
+                .unwrap();
+            callbacks.asm_memory_buffer(&function, &asm_buffer)
         }
 
         let mem_buf_slice = memory_buffer.as_slice();
+
         load_object_file(
             mem_buf_slice,
-            FUNCTION_SECTION,
+            &self.func_section,
             RelocationTarget::LocalFunc(*local_func_index),
             |name: &str| {
-                Ok(
+                Ok({
+                    let name = if matches!(self.binary_fmt, BinaryFormat::Macho) {
+                        if name.starts_with("_") {
+                            name.replacen("_", "", 1)
+                        } else {
+                            name.to_string()
+                        }
+                    } else {
+                        name.to_string()
+                    };
                     if let Some(Symbol::LocalFunction(local_func_index)) =
-                        symbol_registry.name_to_symbol(name)
+                        symbol_registry.name_to_symbol(&name)
                     {
                         Some(RelocationTarget::LocalFunc(local_func_index))
                     } else {
                         None
-                    },
-                )
+                    }
+                })
             },
+            self.binary_fmt,
         )
     }
 }
 
-impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
+impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
     // Create a vector where each lane contains the same value.
     fn splat_vector(
         &self,
         value: BasicValueEnum<'ctx>,
         vec_ty: VectorType<'ctx>,
-    ) -> VectorValue<'ctx> {
+    ) -> Result<VectorValue<'ctx>, CompileError> {
         // Use insert_element to insert the element into an undef vector, then use
         // shuffle vector to copy that lane to all lanes.
-        self.builder.build_shuffle_vector(
-            self.builder.build_insert_element(
+        err_nt!(self.builder.build_shuffle_vector(
+            err!(self.builder.build_insert_element(
                 vec_ty.get_undef(),
                 value,
                 self.intrinsics.i32_zero,
                 "",
-            ),
+            )),
             vec_ty.get_undef(),
             self.intrinsics
                 .i32_ty
                 .vec_type(vec_ty.get_size())
                 .const_zero(),
             "",
-        )
+        ))
     }
 
     // Convert floating point vector to integer and saturate when out of range.
@@ -358,7 +501,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
         int_min_value: u64,
         int_max_value: u64,
         value: IntValue<'ctx>,
-    ) -> VectorValue<'ctx> {
+    ) -> Result<VectorValue<'ctx>, CompileError> {
         // a) Compare vector with itself to identify NaN lanes.
         // b) Compare vector with splat of inttofp(upper_bound) to identify
         //    lanes that need to saturate to max.
@@ -383,70 +526,69 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 .const_int(int_min_value, is_signed)
                 .as_basic_value_enum(),
             ivec_ty,
-        );
+        )?;
         let int_max_value = self.splat_vector(
             ivec_element_ty
                 .const_int(int_max_value, is_signed)
                 .as_basic_value_enum(),
             ivec_ty,
-        );
+        )?;
         let lower_bound = if is_signed {
-            self.builder.build_signed_int_to_float(
+            err!(self.builder.build_signed_int_to_float(
                 ivec_element_ty.const_int(lower_bound, is_signed),
                 fvec_element_ty,
                 "",
-            )
+            ))
         } else {
-            self.builder.build_unsigned_int_to_float(
+            err!(self.builder.build_unsigned_int_to_float(
                 ivec_element_ty.const_int(lower_bound, is_signed),
                 fvec_element_ty,
                 "",
-            )
+            ))
         };
         let upper_bound = if is_signed {
-            self.builder.build_signed_int_to_float(
+            err!(self.builder.build_signed_int_to_float(
                 ivec_element_ty.const_int(upper_bound, is_signed),
                 fvec_element_ty,
                 "",
-            )
+            ))
         } else {
-            self.builder.build_unsigned_int_to_float(
+            err!(self.builder.build_unsigned_int_to_float(
                 ivec_element_ty.const_int(upper_bound, is_signed),
                 fvec_element_ty,
                 "",
-            )
+            ))
         };
 
-        let value = self
-            .builder
-            .build_bitcast(value, fvec_ty, "")
-            .into_vector_value();
+        let value = err!(self.builder.build_bit_cast(value, fvec_ty, "")).into_vector_value();
         let zero = fvec_ty.const_zero();
-        let lower_bound = self.splat_vector(lower_bound.as_basic_value_enum(), fvec_ty);
-        let upper_bound = self.splat_vector(upper_bound.as_basic_value_enum(), fvec_ty);
-        let nan_cmp = self
-            .builder
-            .build_float_compare(FloatPredicate::UNO, value, zero, "nan");
-        let above_upper_bound_cmp = self.builder.build_float_compare(
+        let lower_bound = self.splat_vector(lower_bound.as_basic_value_enum(), fvec_ty)?;
+        let upper_bound = self.splat_vector(upper_bound.as_basic_value_enum(), fvec_ty)?;
+        let nan_cmp =
+            err!(self
+                .builder
+                .build_float_compare(FloatPredicate::UNO, value, zero, "nan"));
+        let above_upper_bound_cmp = err!(self.builder.build_float_compare(
             FloatPredicate::OGT,
             value,
             upper_bound,
             "above_upper_bound",
-        );
-        let below_lower_bound_cmp = self.builder.build_float_compare(
+        ));
+        let below_lower_bound_cmp = err!(self.builder.build_float_compare(
             FloatPredicate::OLT,
             value,
             lower_bound,
             "below_lower_bound",
-        );
-        let not_representable = self.builder.build_or(
-            self.builder.build_or(nan_cmp, above_upper_bound_cmp, ""),
+        ));
+        let not_representable = err!(self.builder.build_or(
+            err!(self.builder.build_or(nan_cmp, above_upper_bound_cmp, "")),
             below_lower_bound_cmp,
             "not_representable_as_int",
-        );
-        let value = self
-            .builder
-            .build_select(not_representable, zero, value, "safe_to_convert")
+        ));
+        let value =
+            err!(self
+                .builder
+                .build_select(not_representable, zero, value, "safe_to_convert"))
             .into_vector_value();
         let value = if is_signed {
             self.builder
@@ -455,13 +597,17 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             self.builder
                 .build_float_to_unsigned_int(value, ivec_ty, "as_int")
         };
-        let value = self
-            .builder
-            .build_select(above_upper_bound_cmp, int_max_value, value, "")
+
+        let value = err!(value);
+        let value =
+            err!(self
+                .builder
+                .build_select(above_upper_bound_cmp, int_max_value, value, ""))
             .into_vector_value();
-        self.builder
+        err_nt!(self
+            .builder
             .build_select(below_lower_bound_cmp, int_min_value, value, "")
-            .into_vector_value()
+            .map(|v| v.into_vector_value()))
     }
 
     // Convert floating point vector to integer and saturate when out of range.
@@ -476,7 +622,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
         int_min_value: u64,
         int_max_value: u64,
         value: IntValue<'ctx>,
-    ) -> IntValue<'ctx> {
+    ) -> Result<IntValue<'ctx>, CompileError> {
         let res = self.trunc_sat(
             fvec_ty,
             ivec_ty,
@@ -485,10 +631,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             int_min_value,
             int_max_value,
             value,
-        );
-        self.builder
-            .build_bitcast(res, self.intrinsics.i128_ty, "")
-            .into_int_value()
+        )?;
+        err_nt!(self
+            .builder
+            .build_bit_cast(res, self.intrinsics.i128_ty, "")
+            .map(|v| v.into_int_value()))
     }
 
     // Convert floating point vector to integer and saturate when out of range.
@@ -501,7 +648,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
         int_min_value: u64,
         int_max_value: u64,
         value: FloatValue<'ctx>,
-    ) -> IntValue<'ctx> {
+    ) -> Result<IntValue<'ctx>, CompileError> {
         // TODO: this is a scalarized version of the process in trunc_sat. Either
         // we should merge with trunc_sat, or we should simplify this function.
 
@@ -522,76 +669,84 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
         let int_max_value = int_ty.const_int(int_max_value, is_signed);
 
         let lower_bound = if is_signed {
-            self.builder.build_signed_int_to_float(
+            err!(self.builder.build_signed_int_to_float(
                 int_ty.const_int(lower_bound, is_signed),
                 value.get_type(),
                 "",
-            )
+            ))
         } else {
-            self.builder.build_unsigned_int_to_float(
+            err!(self.builder.build_unsigned_int_to_float(
                 int_ty.const_int(lower_bound, is_signed),
                 value.get_type(),
                 "",
-            )
+            ))
         };
         let upper_bound = if is_signed {
-            self.builder.build_signed_int_to_float(
+            err!(self.builder.build_signed_int_to_float(
                 int_ty.const_int(upper_bound, is_signed),
                 value.get_type(),
                 "",
-            )
+            ))
         } else {
-            self.builder.build_unsigned_int_to_float(
+            err!(self.builder.build_unsigned_int_to_float(
                 int_ty.const_int(upper_bound, is_signed),
                 value.get_type(),
                 "",
-            )
+            ))
         };
 
         let zero = value.get_type().const_zero();
 
-        let nan_cmp = self
-            .builder
-            .build_float_compare(FloatPredicate::UNO, value, zero, "nan");
-        let above_upper_bound_cmp = self.builder.build_float_compare(
+        let nan_cmp =
+            err!(self
+                .builder
+                .build_float_compare(FloatPredicate::UNO, value, zero, "nan"));
+        let above_upper_bound_cmp = err!(self.builder.build_float_compare(
             FloatPredicate::OGT,
             value,
             upper_bound,
             "above_upper_bound",
-        );
-        let below_lower_bound_cmp = self.builder.build_float_compare(
+        ));
+        let below_lower_bound_cmp = err!(self.builder.build_float_compare(
             FloatPredicate::OLT,
             value,
             lower_bound,
             "below_lower_bound",
-        );
-        let not_representable = self.builder.build_or(
-            self.builder.build_or(nan_cmp, above_upper_bound_cmp, ""),
+        ));
+        let not_representable = err!(self.builder.build_or(
+            err!(self.builder.build_or(nan_cmp, above_upper_bound_cmp, "")),
             below_lower_bound_cmp,
             "not_representable_as_int",
-        );
-        let value = self
-            .builder
-            .build_select(not_representable, zero, value, "safe_to_convert")
+        ));
+        let value =
+            err!(self
+                .builder
+                .build_select(not_representable, zero, value, "safe_to_convert"))
             .into_float_value();
         let value = if is_signed {
-            self.builder
-                .build_float_to_signed_int(value, int_ty, "as_int")
+            err!(self
+                .builder
+                .build_float_to_signed_int(value, int_ty, "as_int"))
         } else {
-            self.builder
-                .build_float_to_unsigned_int(value, int_ty, "as_int")
+            err!(self
+                .builder
+                .build_float_to_unsigned_int(value, int_ty, "as_int"))
         };
-        let value = self
-            .builder
-            .build_select(above_upper_bound_cmp, int_max_value, value, "")
+        let value =
+            err!(self
+                .builder
+                .build_select(above_upper_bound_cmp, int_max_value, value, ""))
             .into_int_value();
-        let value = self
-            .builder
-            .build_select(below_lower_bound_cmp, int_min_value, value, "")
+        let value =
+            err!(self
+                .builder
+                .build_select(below_lower_bound_cmp, int_min_value, value, ""))
             .into_int_value();
-        self.builder
-            .build_bitcast(value, int_ty, "")
-            .into_int_value()
+
+        err_nt!(self
+            .builder
+            .build_bit_cast(value, int_ty, "")
+            .map(|v| v.into_int_value()))
     }
 
     fn trap_if_not_representable_as_int(
@@ -599,7 +754,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
         lower_bound: u64, // Inclusive (not a trapping value)
         upper_bound: u64, // Inclusive (not a trapping value)
         value: FloatValue,
-    ) {
+    ) -> Result<(), CompileError> {
         let float_ty = value.get_type();
         let int_ty = if float_ty == self.intrinsics.f32_ty {
             self.intrinsics.i32_ty
@@ -607,35 +762,37 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             self.intrinsics.i64_ty
         };
 
-        let lower_bound = self
-            .builder
-            .build_bitcast(int_ty.const_int(lower_bound, false), float_ty, "")
+        let lower_bound =
+            err!(self
+                .builder
+                .build_bit_cast(int_ty.const_int(lower_bound, false), float_ty, ""))
             .into_float_value();
-        let upper_bound = self
-            .builder
-            .build_bitcast(int_ty.const_int(upper_bound, false), float_ty, "")
+        let upper_bound =
+            err!(self
+                .builder
+                .build_bit_cast(int_ty.const_int(upper_bound, false), float_ty, ""))
             .into_float_value();
 
         // The 'U' in the float predicate is short for "unordered" which means that
         // the comparison will compare true if either operand is a NaN. Thus, NaNs
         // are out of bounds.
-        let above_upper_bound_cmp = self.builder.build_float_compare(
+        let above_upper_bound_cmp = err!(self.builder.build_float_compare(
             FloatPredicate::UGT,
             value,
             upper_bound,
             "above_upper_bound",
-        );
-        let below_lower_bound_cmp = self.builder.build_float_compare(
+        ));
+        let below_lower_bound_cmp = err!(self.builder.build_float_compare(
             FloatPredicate::ULT,
             value,
             lower_bound,
             "below_lower_bound",
-        );
-        let out_of_bounds = self.builder.build_or(
+        ));
+        let out_of_bounds = err!(self.builder.build_or(
             above_upper_bound_cmp,
             below_lower_bound_cmp,
             "out_of_bounds",
-        );
+        ));
 
         let failure_block = self
             .context
@@ -644,75 +801,86 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             .context
             .append_basic_block(self.function, "conversion_success_block");
 
-        self.builder
-            .build_conditional_branch(out_of_bounds, failure_block, continue_block);
-        self.builder.position_at_end(failure_block);
-        let is_nan = self
+        err!(self
             .builder
-            .build_float_compare(FloatPredicate::UNO, value, value, "is_nan");
-        let trap_code = self.builder.build_select(
+            .build_conditional_branch(out_of_bounds, failure_block, continue_block));
+        self.builder.position_at_end(failure_block);
+        let is_nan =
+            err!(self
+                .builder
+                .build_float_compare(FloatPredicate::UNO, value, value, "is_nan"));
+        let trap_code = err!(self.builder.build_select(
             is_nan,
             self.intrinsics.trap_bad_conversion_to_integer,
             self.intrinsics.trap_illegal_arithmetic,
             "",
-        );
-        self.builder
-            .build_call(self.intrinsics.throw_trap, &[trap_code.into()], "throw");
-        self.builder.build_unreachable();
+        ));
+        err!(self
+            .builder
+            .build_call(self.intrinsics.throw_trap, &[trap_code.into()], "throw"));
+        err!(self.builder.build_unreachable());
         self.builder.position_at_end(continue_block);
+
+        Ok(())
     }
 
-    fn trap_if_zero_or_overflow(&self, left: IntValue, right: IntValue) {
+    fn trap_if_zero_or_overflow(
+        &self,
+        left: IntValue,
+        right: IntValue,
+    ) -> Result<(), CompileError> {
         let int_type = left.get_type();
 
         let (min_value, neg_one_value) = if int_type == self.intrinsics.i32_ty {
-            let min_value = int_type.const_int(i32::min_value() as u64, false);
+            let min_value = int_type.const_int(i32::MIN as u64, false);
             let neg_one_value = int_type.const_int(-1i32 as u32 as u64, false);
             (min_value, neg_one_value)
         } else if int_type == self.intrinsics.i64_ty {
-            let min_value = int_type.const_int(i64::min_value() as u64, false);
+            let min_value = int_type.const_int(i64::MIN as u64, false);
             let neg_one_value = int_type.const_int(-1i64 as u64, false);
             (min_value, neg_one_value)
         } else {
             unreachable!()
         };
 
-        let divisor_is_zero = self.builder.build_int_compare(
+        let divisor_is_zero = err!(self.builder.build_int_compare(
             IntPredicate::EQ,
             right,
             int_type.const_zero(),
             "divisor_is_zero",
-        );
-        let should_trap = self.builder.build_or(
+        ));
+        let should_trap = err!(self.builder.build_or(
             divisor_is_zero,
-            self.builder.build_and(
-                self.builder
-                    .build_int_compare(IntPredicate::EQ, left, min_value, "left_is_min"),
-                self.builder.build_int_compare(
+            err!(self.builder.build_and(
+                err!(self.builder.build_int_compare(
+                    IntPredicate::EQ,
+                    left,
+                    min_value,
+                    "left_is_min"
+                )),
+                err!(self.builder.build_int_compare(
                     IntPredicate::EQ,
                     right,
                     neg_one_value,
                     "right_is_neg_one",
-                ),
+                )),
                 "div_will_overflow",
-            ),
+            )),
             "div_should_trap",
-        );
-
-        let should_trap = self
-            .builder
-            .build_call(
-                self.intrinsics.expect_i1,
-                &[
-                    should_trap.into(),
-                    self.intrinsics.i1_ty.const_zero().into(),
-                ],
-                "should_trap_expect",
-            )
-            .try_as_basic_value()
-            .left()
-            .unwrap()
-            .into_int_value();
+        ));
+
+        let should_trap = err!(self.builder.build_call(
+            self.intrinsics.expect_i1,
+            &[
+                should_trap.into(),
+                self.intrinsics.i1_ty.const_zero().into(),
+            ],
+            "should_trap_expect",
+        ))
+        .try_as_basic_value()
+        .left()
+        .unwrap()
+        .into_int_value();
 
         let shouldnt_trap_block = self
             .context
@@ -720,44 +888,48 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
         let should_trap_block = self
             .context
             .append_basic_block(self.function, "should_trap_block");
-        self.builder
-            .build_conditional_branch(should_trap, should_trap_block, shouldnt_trap_block);
+        err!(self.builder.build_conditional_branch(
+            should_trap,
+            should_trap_block,
+            shouldnt_trap_block
+        ));
         self.builder.position_at_end(should_trap_block);
-        let trap_code = self.builder.build_select(
+        let trap_code = err!(self.builder.build_select(
             divisor_is_zero,
             self.intrinsics.trap_integer_division_by_zero,
             self.intrinsics.trap_illegal_arithmetic,
             "",
-        );
-        self.builder
-            .build_call(self.intrinsics.throw_trap, &[trap_code.into()], "throw");
-        self.builder.build_unreachable();
+        ));
+        err!(self
+            .builder
+            .build_call(self.intrinsics.throw_trap, &[trap_code.into()], "throw"));
+        err!(self.builder.build_unreachable());
         self.builder.position_at_end(shouldnt_trap_block);
+
+        Ok(())
     }
 
-    fn trap_if_zero(&self, value: IntValue) {
+    fn trap_if_zero(&self, value: IntValue) -> Result<(), CompileError> {
         let int_type = value.get_type();
-        let should_trap = self.builder.build_int_compare(
+        let should_trap = err!(self.builder.build_int_compare(
             IntPredicate::EQ,
             value,
             int_type.const_zero(),
             "divisor_is_zero",
-        );
-
-        let should_trap = self
-            .builder
-            .build_call(
-                self.intrinsics.expect_i1,
-                &[
-                    should_trap.into(),
-                    self.intrinsics.i1_ty.const_zero().into(),
-                ],
-                "should_trap_expect",
-            )
-            .try_as_basic_value()
-            .left()
-            .unwrap()
-            .into_int_value();
+        ));
+
+        let should_trap = err!(self.builder.build_call(
+            self.intrinsics.expect_i1,
+            &[
+                should_trap.into(),
+                self.intrinsics.i1_ty.const_zero().into(),
+            ],
+            "should_trap_expect",
+        ))
+        .try_as_basic_value()
+        .left()
+        .unwrap()
+        .into_int_value();
 
         let shouldnt_trap_block = self
             .context
@@ -765,16 +937,21 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
         let should_trap_block = self
             .context
             .append_basic_block(self.function, "should_trap_block");
-        self.builder
-            .build_conditional_branch(should_trap, should_trap_block, shouldnt_trap_block);
+        err!(self.builder.build_conditional_branch(
+            should_trap,
+            should_trap_block,
+            shouldnt_trap_block
+        ));
         self.builder.position_at_end(should_trap_block);
-        self.builder.build_call(
+        err!(self.builder.build_call(
             self.intrinsics.throw_trap,
             &[self.intrinsics.trap_integer_division_by_zero.into()],
             "throw",
-        );
-        self.builder.build_unreachable();
+        ));
+        err!(self.builder.build_unreachable());
         self.builder.position_at_end(shouldnt_trap_block);
+
+        Ok(())
     }
 
     fn v128_into_int_vec(
@@ -782,33 +959,31 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
         value: BasicValueEnum<'ctx>,
         info: ExtraInfo,
         int_vec_ty: VectorType<'ctx>,
-    ) -> (VectorValue<'ctx>, ExtraInfo) {
+    ) -> Result<(VectorValue<'ctx>, ExtraInfo), CompileError> {
         let (value, info) = if info.has_pending_f32_nan() {
-            let value = self
+            let value = err!(self
                 .builder
-                .build_bitcast(value, self.intrinsics.f32x4_ty, "");
-            (self.canonicalize_nans(value), info.strip_pending())
+                .build_bit_cast(value, self.intrinsics.f32x4_ty, ""));
+            (self.canonicalize_nans(value)?, info.strip_pending())
         } else if info.has_pending_f64_nan() {
-            let value = self
+            let value = err!(self
                 .builder
-                .build_bitcast(value, self.intrinsics.f64x2_ty, "");
-            (self.canonicalize_nans(value), info.strip_pending())
+                .build_bit_cast(value, self.intrinsics.f64x2_ty, ""));
+            (self.canonicalize_nans(value)?, info.strip_pending())
         } else {
             (value, info)
         };
-        (
-            self.builder
-                .build_bitcast(value, int_vec_ty, "")
-                .into_vector_value(),
+        Ok((
+            err!(self.builder.build_bit_cast(value, int_vec_ty, "")).into_vector_value(),
             info,
-        )
+        ))
     }
 
     fn v128_into_i8x16(
         &self,
         value: BasicValueEnum<'ctx>,
         info: ExtraInfo,
-    ) -> (VectorValue<'ctx>, ExtraInfo) {
+    ) -> Result<(VectorValue<'ctx>, ExtraInfo), CompileError> {
         self.v128_into_int_vec(value, info, self.intrinsics.i8x16_ty)
     }
 
@@ -816,7 +991,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
         &self,
         value: BasicValueEnum<'ctx>,
         info: ExtraInfo,
-    ) -> (VectorValue<'ctx>, ExtraInfo) {
+    ) -> Result<(VectorValue<'ctx>, ExtraInfo), CompileError> {
         self.v128_into_int_vec(value, info, self.intrinsics.i16x8_ty)
     }
 
@@ -824,7 +999,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
         &self,
         value: BasicValueEnum<'ctx>,
         info: ExtraInfo,
-    ) -> (VectorValue<'ctx>, ExtraInfo) {
+    ) -> Result<(VectorValue<'ctx>, ExtraInfo), CompileError> {
         self.v128_into_int_vec(value, info, self.intrinsics.i32x4_ty)
     }
 
@@ -832,7 +1007,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
         &self,
         value: BasicValueEnum<'ctx>,
         info: ExtraInfo,
-    ) -> (VectorValue<'ctx>, ExtraInfo) {
+    ) -> Result<(VectorValue<'ctx>, ExtraInfo), CompileError> {
         self.v128_into_int_vec(value, info, self.intrinsics.i64x2_ty)
     }
 
@@ -842,21 +1017,22 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
         &self,
         value: BasicValueEnum<'ctx>,
         info: ExtraInfo,
-    ) -> (VectorValue<'ctx>, ExtraInfo) {
+    ) -> Result<(VectorValue<'ctx>, ExtraInfo), CompileError> {
         let (value, info) = if info.has_pending_f64_nan() {
-            let value = self
+            let value = err!(self
                 .builder
-                .build_bitcast(value, self.intrinsics.f64x2_ty, "");
-            (self.canonicalize_nans(value), info.strip_pending())
+                .build_bit_cast(value, self.intrinsics.f64x2_ty, ""));
+            (self.canonicalize_nans(value)?, info.strip_pending())
         } else {
             (value, info)
         };
-        (
-            self.builder
-                .build_bitcast(value, self.intrinsics.f32x4_ty, "")
-                .into_vector_value(),
+        Ok((
+            err!(self
+                .builder
+                .build_bit_cast(value, self.intrinsics.f32x4_ty, ""))
+            .into_vector_value(),
             info,
-        )
+        ))
     }
 
     // If the value is pending a 32-bit canonicalization, do it now.
@@ -865,30 +1041,31 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
         &self,
         value: BasicValueEnum<'ctx>,
         info: ExtraInfo,
-    ) -> (VectorValue<'ctx>, ExtraInfo) {
+    ) -> Result<(VectorValue<'ctx>, ExtraInfo), CompileError> {
         let (value, info) = if info.has_pending_f32_nan() {
-            let value = self
+            let value = err!(self
                 .builder
-                .build_bitcast(value, self.intrinsics.f32x4_ty, "");
-            (self.canonicalize_nans(value), info.strip_pending())
+                .build_bit_cast(value, self.intrinsics.f32x4_ty, ""));
+            (self.canonicalize_nans(value)?, info.strip_pending())
         } else {
             (value, info)
         };
-        (
-            self.builder
-                .build_bitcast(value, self.intrinsics.f64x2_ty, "")
-                .into_vector_value(),
+        Ok((
+            err!(self
+                .builder
+                .build_bit_cast(value, self.intrinsics.f64x2_ty, ""))
+            .into_vector_value(),
             info,
-        )
+        ))
     }
 
     fn apply_pending_canonicalization(
         &self,
         value: BasicValueEnum<'ctx>,
         info: ExtraInfo,
-    ) -> BasicValueEnum<'ctx> {
+    ) -> Result<BasicValueEnum<'ctx>, CompileError> {
         if !self.config.enable_nan_canonicalization {
-            return value;
+            return Ok(value);
         }
 
         if info.has_pending_f32_nan() {
@@ -896,11 +1073,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 || value.get_type() == self.intrinsics.i128_ty.as_basic_type_enum()
             {
                 let ty = value.get_type();
-                let value = self
+                let value = err!(self
                     .builder
-                    .build_bitcast(value, self.intrinsics.f32x4_ty, "");
-                let value = self.canonicalize_nans(value);
-                self.builder.build_bitcast(value, ty, "")
+                    .build_bit_cast(value, self.intrinsics.f32x4_ty, ""));
+                let value = self.canonicalize_nans(value)?;
+                err_nt!(self.builder.build_bit_cast(value, ty, ""))
             } else {
                 self.canonicalize_nans(value)
             }
@@ -909,23 +1086,26 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 || value.get_type() == self.intrinsics.i128_ty.as_basic_type_enum()
             {
                 let ty = value.get_type();
-                let value = self
+                let value = err!(self
                     .builder
-                    .build_bitcast(value, self.intrinsics.f64x2_ty, "");
-                let value = self.canonicalize_nans(value);
-                self.builder.build_bitcast(value, ty, "")
+                    .build_bit_cast(value, self.intrinsics.f64x2_ty, ""));
+                let value = self.canonicalize_nans(value)?;
+                err_nt!(self.builder.build_bit_cast(value, ty, ""))
             } else {
                 self.canonicalize_nans(value)
             }
         } else {
-            value
+            Ok(value)
         }
     }
 
     // Replaces any NaN with the canonical QNaN, otherwise leaves the value alone.
-    fn canonicalize_nans(&self, value: BasicValueEnum<'ctx>) -> BasicValueEnum<'ctx> {
+    fn canonicalize_nans(
+        &self,
+        value: BasicValueEnum<'ctx>,
+    ) -> Result<BasicValueEnum<'ctx>, CompileError> {
         if !self.config.enable_nan_canonicalization {
-            return value;
+            return Ok(value);
         }
 
         let f_ty = value.get_type();
@@ -933,32 +1113,36 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             let value = value.into_vector_value();
             let f_ty = f_ty.into_vector_type();
             let zero = f_ty.const_zero();
-            let nan_cmp = self
-                .builder
-                .build_float_compare(FloatPredicate::UNO, value, zero, "nan");
+            let nan_cmp =
+                err!(self
+                    .builder
+                    .build_float_compare(FloatPredicate::UNO, value, zero, "nan"));
             let canonical_qnan = f_ty
                 .get_element_type()
                 .into_float_type()
-                .const_float(std::f64::NAN);
-            let canonical_qnan = self.splat_vector(canonical_qnan.as_basic_value_enum(), f_ty);
-            self.builder
+                .const_float(f64::NAN);
+            let canonical_qnan = self.splat_vector(canonical_qnan.as_basic_value_enum(), f_ty)?;
+            err_nt!(self
+                .builder
                 .build_select(nan_cmp, canonical_qnan, value, "")
-                .as_basic_value_enum()
+                .map(|v| v.as_basic_value_enum()))
         } else {
             let value = value.into_float_value();
             let f_ty = f_ty.into_float_type();
             let zero = f_ty.const_zero();
-            let nan_cmp = self
+            let nan_cmp =
+                err!(self
+                    .builder
+                    .build_float_compare(FloatPredicate::UNO, value, zero, "nan"));
+            let canonical_qnan = f_ty.const_float(f64::NAN);
+            err_nt!(self
                 .builder
-                .build_float_compare(FloatPredicate::UNO, value, zero, "nan");
-            let canonical_qnan = f_ty.const_float(std::f64::NAN);
-            self.builder
                 .build_select(nan_cmp, canonical_qnan, value, "")
-                .as_basic_value_enum()
+                .map(|v| v.as_basic_value_enum()))
         }
     }
 
-    fn quiet_nan(&self, value: BasicValueEnum<'ctx>) -> BasicValueEnum<'ctx> {
+    fn quiet_nan(&self, value: BasicValueEnum<'ctx>) -> Result<BasicValueEnum<'ctx>, CompileError> {
         let intrinsic = if value
             .get_type()
             .eq(&self.intrinsics.f32_ty.as_basic_type_enum())
@@ -984,7 +1168,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
         };
 
         match intrinsic {
-            Some(intrinsic) => self
+            Some(intrinsic) => err_nt!(self
                 .builder
                 .build_call(
                     intrinsic,
@@ -996,10 +1180,8 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     ],
                     "",
                 )
-                .try_as_basic_value()
-                .left()
-                .unwrap(),
-            None => value,
+                .map(|v| v.try_as_basic_value().left().unwrap())),
+            None => Ok(value),
         }
     }
 
@@ -1016,7 +1198,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             self.intrinsics,
             self.module,
             self.memory_styles,
-        ) {
+        )? {
             // The best we've got is `volatile`.
             // TODO: convert unwrap fail to CompileError
             memaccess.set_volatile(true).unwrap();
@@ -1062,14 +1244,16 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
 
         // Compute the offset into the storage.
         let imm_offset = intrinsics.i64_ty.const_int(memarg.offset, false);
-        let var_offset = builder.build_int_z_extend(var_offset, intrinsics.i64_ty, "");
-        let offset = builder.build_int_add(var_offset, imm_offset, "");
+        let var_offset = err!(builder.build_int_z_extend(var_offset, intrinsics.i64_ty, ""));
+        let offset = err!(builder.build_int_add(var_offset, imm_offset, ""));
 
         // Look up the memory base (as pointer) and bounds (as unsigned integer).
-        let base_ptr =
+        let base_ptr = if let Some((_, ref m0)) = self.g0m0 {
+            *m0
+        } else {
             match self
                 .ctx
-                .memory(memory_index, intrinsics, self.module, self.memory_styles)
+                .memory(memory_index, intrinsics, self.module, self.memory_styles)?
             {
                 MemoryCache::Dynamic {
                     ptr_to_base_ptr,
@@ -1093,29 +1277,44 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         }
                     } else {
                         None
-                    }
-                    .unwrap_or_else(|| {
-                        let load_offset_end = builder.build_int_add(offset, value_size_v, "");
-
-                        let current_length = builder
-                            .build_load(self.intrinsics.i32_ty, ptr_to_current_length, "")
+                    };
+
+                    let ptr_in_bounds = match ptr_in_bounds {
+                        Some(ptr) => ptr,
+                        None => {
+                            let load_offset_end = err!(builder.build_int_add(
+                                offset,
+                                value_size_v,
+                                "load_offset_end"
+                            ));
+
+                            let current_length = err!(builder.build_load(
+                                self.intrinsics.i32_ty,
+                                ptr_to_current_length,
+                                "current_length"
+                            ))
                             .into_int_value();
-                        tbaa_label(
-                            self.module,
-                            self.intrinsics,
-                            format!("memory {} length", memory_index.as_u32()),
-                            current_length.as_instruction_value().unwrap(),
-                        );
-                        let current_length =
-                            builder.build_int_z_extend(current_length, intrinsics.i64_ty, "");
+                            tbaa_label(
+                                self.module,
+                                self.intrinsics,
+                                format!("memory {} length", memory_index.as_u32()),
+                                current_length.as_instruction_value().unwrap(),
+                            );
+                            let current_length = err!(builder.build_int_z_extend(
+                                current_length,
+                                intrinsics.i64_ty,
+                                "current_length_zextd"
+                            ));
+
+                            err!(builder.build_int_compare(
+                                IntPredicate::ULE,
+                                load_offset_end,
+                                current_length,
+                                "ptr_in_bounds",
+                            ))
+                        }
+                    };
 
-                        builder.build_int_compare(
-                            IntPredicate::ULE,
-                            load_offset_end,
-                            current_length,
-                            "",
-                        )
-                    });
                     if !ptr_in_bounds.is_constant_int()
                         || ptr_in_bounds.get_zero_extended_constant().unwrap() != 1
                     {
@@ -1124,41 +1323,40 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         // constant expression, not known to be either true or false yet.
                         // If it's false, unknown-but-constant, or not-a-constant, emit a
                         // runtime bounds check. LLVM may yet succeed at optimizing it away.
-                        let ptr_in_bounds = builder
-                            .build_call(
-                                intrinsics.expect_i1,
-                                &[
-                                    ptr_in_bounds.into(),
-                                    intrinsics.i1_ty.const_int(1, true).into(),
-                                ],
-                                "ptr_in_bounds_expect",
-                            )
-                            .try_as_basic_value()
-                            .left()
-                            .unwrap()
-                            .into_int_value();
+                        let ptr_in_bounds = err!(builder.build_call(
+                            intrinsics.expect_i1,
+                            &[
+                                ptr_in_bounds.into(),
+                                intrinsics.i1_ty.const_int(1, true).into(),
+                            ],
+                            "ptr_in_bounds_expect",
+                        ))
+                        .try_as_basic_value()
+                        .left()
+                        .unwrap()
+                        .into_int_value();
 
                         let in_bounds_continue_block =
                             context.append_basic_block(*function, "in_bounds_continue_block");
                         let not_in_bounds_block =
                             context.append_basic_block(*function, "not_in_bounds_block");
-                        builder.build_conditional_branch(
+                        err!(builder.build_conditional_branch(
                             ptr_in_bounds,
                             in_bounds_continue_block,
                             not_in_bounds_block,
-                        );
+                        ));
                         builder.position_at_end(not_in_bounds_block);
-                        builder.build_call(
+                        err!(builder.build_call(
                             intrinsics.throw_trap,
                             &[intrinsics.trap_memory_oob.into()],
                             "throw",
-                        );
-                        builder.build_unreachable();
+                        ));
+                        err!(builder.build_unreachable());
                         builder.position_at_end(in_bounds_continue_block);
                     }
-                    let ptr_to_base = builder
-                        .build_load(intrinsics.i8_ptr_ty, ptr_to_base_ptr, "")
-                        .into_pointer_value();
+                    let ptr_to_base =
+                        err!(builder.build_load(intrinsics.ptr_ty, ptr_to_base_ptr, "ptr_to_base"))
+                            .into_pointer_value();
                     tbaa_label(
                         self.module,
                         self.intrinsics,
@@ -1168,43 +1366,52 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     ptr_to_base
                 }
                 MemoryCache::Static { base_ptr } => base_ptr,
-            };
-        let value_ptr =
-            unsafe { builder.build_gep(self.intrinsics.i8_ty, base_ptr, &[offset], "") };
-        Ok(builder
-            .build_bitcast(value_ptr, ptr_ty, "")
-            .into_pointer_value())
+            }
+        };
+        let value_ptr = unsafe {
+            err!(builder.build_gep(self.intrinsics.i8_ty, base_ptr, &[offset], "mem_value_ptr"))
+        };
+        err_nt!(builder
+            .build_bit_cast(value_ptr, ptr_ty, "mem_value")
+            .map(|v| v.into_pointer_value()))
     }
 
-    fn trap_if_misaligned(&self, _memarg: &MemArg, ptr: PointerValue<'ctx>, align: u8) {
+    fn trap_if_misaligned(
+        &self,
+        _memarg: &MemArg,
+        ptr: PointerValue<'ctx>,
+        align: u8,
+    ) -> Result<(), CompileError> {
         if align <= 1 {
-            return;
+            return Ok(());
         }
-        let value = self
-            .builder
-            .build_ptr_to_int(ptr, self.intrinsics.i64_ty, "");
-        let and = self.builder.build_and(
+        let value =
+            err!(self
+                .builder
+                .build_ptr_to_int(ptr, self.intrinsics.i64_ty, "mischeck_value"));
+        let and = err!(self.builder.build_and(
             value,
             self.intrinsics.i64_ty.const_int((align - 1).into(), false),
             "misaligncheck",
-        );
-        let aligned =
-            self.builder
-                .build_int_compare(IntPredicate::EQ, and, self.intrinsics.i64_zero, "");
-        let aligned = self
-            .builder
-            .build_call(
-                self.intrinsics.expect_i1,
-                &[
-                    aligned.into(),
-                    self.intrinsics.i1_ty.const_int(1, false).into(),
-                ],
-                "",
-            )
-            .try_as_basic_value()
-            .left()
-            .unwrap()
-            .into_int_value();
+        ));
+        let aligned = err!(self.builder.build_int_compare(
+            IntPredicate::EQ,
+            and,
+            self.intrinsics.i64_zero,
+            "is_aligned"
+        ));
+        let aligned = err!(self.builder.build_call(
+            self.intrinsics.expect_i1,
+            &[
+                aligned.into(),
+                self.intrinsics.i1_ty.const_int(1, false).into(),
+            ],
+            "is_aligned_expect",
+        ))
+        .try_as_basic_value()
+        .left()
+        .unwrap()
+        .into_int_value();
 
         let continue_block = self
             .context
@@ -1212,29 +1419,33 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
         let not_aligned_block = self
             .context
             .append_basic_block(self.function, "misaligned_trap_block");
-        self.builder
-            .build_conditional_branch(aligned, continue_block, not_aligned_block);
+        err!(self
+            .builder
+            .build_conditional_branch(aligned, continue_block, not_aligned_block));
 
         self.builder.position_at_end(not_aligned_block);
-        self.builder.build_call(
+        err!(self.builder.build_call(
             self.intrinsics.throw_trap,
             &[self.intrinsics.trap_unaligned_atomic.into()],
             "throw",
-        );
-        self.builder.build_unreachable();
+        ));
+        err!(self.builder.build_unreachable());
 
         self.builder.position_at_end(continue_block);
+        Ok(())
     }
 
     fn finalize(&mut self, wasm_fn_type: &FunctionType) -> Result<(), CompileError> {
         let func_type = self.function.get_type();
 
         let results = self.state.popn_save_extra(wasm_fn_type.results().len())?;
-        let results = results
+        let results = err!(results
             .into_iter()
-            .map(|(v, i)| self.apply_pending_canonicalization(v, i));
+            .map(|(v, i)| self.apply_pending_canonicalization(v, i))
+            .collect::<Result<Vec<_>, _>>());
+
         if wasm_fn_type.results().is_empty() {
-            self.builder.build_return(None);
+            err!(self.builder.build_return(None));
         } else if self.abi.is_sret(wasm_fn_type)? {
             let sret = self
                 .function
@@ -1250,98 +1461,429 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 .context
                 .struct_type(llvm_params.as_slice(), false)
                 .get_undef();
-            for (idx, value) in results.enumerate() {
-                let value = self.builder.build_bitcast(
+            for (idx, value) in results.into_iter().enumerate() {
+                let value = err!(self.builder.build_bit_cast(
                     value,
                     type_to_llvm(self.intrinsics, wasm_fn_type.results()[idx])?,
                     "",
-                );
-                struct_value = self
-                    .builder
-                    .build_insert_value(struct_value, value, idx as u32, "")
-                    .unwrap()
+                ));
+                struct_value =
+                    err!(self
+                        .builder
+                        .build_insert_value(struct_value, value, idx as u32, ""))
                     .into_struct_value();
             }
-            self.builder.build_store(sret, struct_value);
-            self.builder.build_return(None);
+            err!(self.builder.build_store(sret, struct_value));
+            err!(self.builder.build_return(None));
         } else {
-            self.builder
+            err!(self
+                .builder
                 .build_return(Some(&self.abi.pack_values_for_register_return(
                     self.intrinsics,
                     &self.builder,
-                    &results.collect::<Vec<_>>(),
+                    &results,
                     &func_type,
-                )?));
+                )?)));
         }
         Ok(())
     }
-}
 
-/*
-fn emit_stack_map<'ctx>(
-    intrinsics: &Intrinsics<'ctx>,
-    builder: &Builder<'ctx>,
-    local_function_id: usize,
-    target: &mut StackmapRegistry,
-    kind: StackmapEntryKind,
-    locals: &[PointerValue],
-    state: &State<'ctx>,
-    _ctx: &mut CtxType<'ctx>,
-    opcode_offset: usize,
-) {
-    let stackmap_id = target.entries.len();
+    // Generates a global constant with the tag's module-local index, which can be used
+    // as the "type info" of a catch clause.
+    fn get_or_insert_tag_type_info_global(&mut self, tag: i32) -> BasicValueEnum<'ctx> {
+        if let Some(tag) = self.tags_cache.get(&tag) {
+            return *tag;
+        }
 
-    let mut params = Vec::with_capacity(2 + locals.len() + state.stack.len());
+        let tag_ty = self
+            .context
+            .struct_type(&[self.intrinsics.i32_ty.into()], false);
+        let tag_glbl = self.module.add_global(
+            tag_ty,
+            Some(AddressSpace::default()),
+            &format!("__wasmer_eh_type_info_{tag}"),
+        );
+        tag_glbl.set_initializer(
+            &tag_ty
+                .const_named_struct(&[self.intrinsics.i32_ty.const_int(tag as _, false).into()])
+                .as_basic_value_enum(),
+        );
 
-    params.push(
-        intrinsics
-            .i64_ty
-            .const_int(stackmap_id as u64, false)
-            .as_basic_value_enum(),
-    );
-    params.push(intrinsics.i32_ty.const_zero().as_basic_value_enum());
+        tag_glbl.set_linkage(Linkage::External);
+        tag_glbl.set_constant(true);
+        // Why set this to a specific section? On macOS it would land on a specifc read only data
+        // section. GOT-based relocations will probably be generated with a non-zero addend, making
+        // some EH-related intricacies not working.
+        //
+        // The general idea is that each tag has its own section, so the GOT-based relocation can
+        // have a zero addend, i.e. the data of the tag is the first (and only) value in a specific
+        // section we can target in relocations.
+        if matches!(self.binary_fmt, target_lexicon::BinaryFormat::Macho) {
+            tag_glbl.set_section(Some(&format!("{FUNCTION_SECTION_MACHO},_eh_ti_{tag}")));
+        }
 
-    let locals: Vec<_> = locals.iter().map(|x| x.as_basic_value_enum()).collect();
-    let mut value_semantics: Vec<ValueSemantic> =
-        Vec::with_capacity(locals.len() + state.stack.len());
+        let tag_glbl = tag_glbl.as_basic_value_enum();
 
-    params.extend_from_slice(&locals);
-    value_semantics.extend((0..locals.len()).map(ValueSemantic::WasmLocal));
+        self.tags_cache.insert(tag, tag_glbl);
+        tag_glbl
+    }
 
-    params.extend(state.stack.iter().map(|x| x.0));
-    value_semantics.extend((0..state.stack.len()).map(ValueSemantic::WasmStack));
+    fn get_or_insert_exception_type(
+        &mut self,
+        tag: u32,
+        signature: &FunctionType,
+    ) -> Result<inkwell::types::StructType<'ctx>, CompileError> {
+        if let Some(ty) = self.exception_types_cache.get(&tag) {
+            return Ok(*ty);
+        }
+        let types = signature
+            .params()
+            .iter()
+            .map(|v| type_to_llvm(self.intrinsics, *v))
+            .collect::<Result<Vec<_>, CompileError>>()?;
 
-    // FIXME: Information needed for Abstract -> Runtime state transform is not fully preserved
-    // to accelerate compilation and reduce memory usage. Check this again when we try to support
-    // "full" LLVM OSR.
+        let ty = self.context.struct_type(&types, false);
+        self.exception_types_cache.insert(tag, ty);
+        Ok(ty)
+    }
 
-    assert_eq!(params.len(), value_semantics.len() + 2);
+    fn build_g0m0_indirect_call(
+        &mut self,
+        table_index: u32,
+        ctx_ptr: PointerValue<'ctx>,
+        func_type: &FunctionType,
+        func_ptr: PointerValue<'ctx>,
+        func_index: IntValue<'ctx>,
+    ) -> Result<(), CompileError> {
+        let Some((g0, m0)) = self.g0m0 else {
+            return Err(CompileError::Codegen(
+                "Call to build_g0m0_indirect_call without g0m0 parameters!".to_string(),
+            ));
+        };
 
-    builder.build_call(intrinsics.experimental_stackmap, &params, "");
+        let mut local_func_indices = vec![];
+        let mut foreign_func_indices = vec![];
 
-    target.entries.push(StackmapEntry {
-        kind,
-        local_function_id,
-        local_count: locals.len(),
-        stack_count: state.stack.len(),
-        opcode_offset,
-        value_semantics,
-        is_start: true,
-    });
-}
+        for t in &self.wasm_module.table_initializers {
+            if t.table_index.as_u32() == table_index {
+                for (func_in_table_idx, func_idx) in t.elements.iter().enumerate() {
+                    if self.wasm_module.local_func_index(*func_idx).is_some() {
+                        local_func_indices.push(func_in_table_idx)
+                    } else {
+                        foreign_func_indices.push(func_in_table_idx)
+                    }
+                }
+                break;
+            }
+        }
 
-fn finalize_opcode_stack_map<'ctx>(
-    intrinsics: &Intrinsics<'ctx>,
-    builder: &Builder<'ctx>,
-    local_function_id: usize,
-    target: &mut StackmapRegistry,
-    kind: StackmapEntryKind,
-    opcode_offset: usize,
-) {
-    let stackmap_id = target.entries.len();
-    builder.build_call(
-        intrinsics.experimental_stackmap,
-        &[
+        // removed with mem2reg.
+        //
+        let g0_value = err!(self.builder.build_load(self.intrinsics.i32_ty, g0, "g0"));
+
+        let needs_switch = self.g0m0.is_some()
+            && !local_func_indices.is_empty()
+            && !foreign_func_indices.is_empty();
+
+        if needs_switch {
+            let foreign_idx_block = self
+                .context
+                .append_basic_block(self.function, "foreign_call_block");
+            let local_idx_block = self
+                .context
+                .append_basic_block(self.function, "local_call_block");
+            let unreachable_indirect_call_branch_block = self
+                .context
+                .append_basic_block(self.function, "unreachable_indirect_call_branch");
+
+            let cont = self.context.append_basic_block(self.function, "cont");
+
+            err!(self.builder.build_switch(
+                func_index,
+                unreachable_indirect_call_branch_block,
+                &local_func_indices
+                    .into_iter()
+                    .map(|v| (
+                        self.intrinsics.i32_ty.const_int(v as _, false),
+                        local_idx_block
+                    ))
+                    .chain(foreign_func_indices.into_iter().map(|v| (
+                        self.intrinsics.i32_ty.const_int(v as _, false),
+                        foreign_idx_block
+                    )))
+                    .collect::<Vec<_>>()
+            ));
+
+            self.builder
+                .position_at_end(unreachable_indirect_call_branch_block);
+            err!(self.builder.build_unreachable());
+
+            //let current_block = self.builder.get_insert_block().unwrap();
+            self.builder.position_at_end(local_idx_block);
+            let local_call_site = self.build_indirect_call(
+                ctx_ptr,
+                func_type,
+                func_ptr,
+                Some(G0M0FunctionKind::Local),
+                Some((g0_value.into_int_value(), m0)),
+            )?;
+
+            let local_rets = self.abi.rets_from_call(
+                &self.builder,
+                self.intrinsics,
+                local_call_site,
+                func_type,
+            )?;
+
+            err!(self.builder.build_unconditional_branch(cont));
+
+            self.builder.position_at_end(foreign_idx_block);
+            let foreign_call_site = self.build_indirect_call(
+                ctx_ptr,
+                func_type,
+                func_ptr,
+                Some(G0M0FunctionKind::Imported),
+                None,
+            )?;
+
+            let foreign_rets = self.abi.rets_from_call(
+                &self.builder,
+                self.intrinsics,
+                foreign_call_site,
+                func_type,
+            )?;
+
+            err!(self.builder.build_unconditional_branch(cont));
+
+            self.builder.position_at_end(cont);
+
+            for i in 0..foreign_rets.len() {
+                let f_i = foreign_rets[i];
+                let l_i = local_rets[i];
+                let ty = f_i.get_type();
+                let v = err!(self.builder.build_phi(ty, ""));
+                v.add_incoming(&[(&f_i, foreign_idx_block), (&l_i, local_idx_block)]);
+                self.state.push1(v.as_basic_value());
+            }
+        } else if foreign_func_indices.is_empty() {
+            let call_site = self.build_indirect_call(
+                ctx_ptr,
+                func_type,
+                func_ptr,
+                Some(G0M0FunctionKind::Local),
+                Some((g0_value.into_int_value(), m0)),
+            )?;
+
+            self.abi
+                .rets_from_call(&self.builder, self.intrinsics, call_site, func_type)?
+                .iter()
+                .for_each(|ret| self.state.push1(*ret));
+        } else {
+            let call_site = self.build_indirect_call(
+                ctx_ptr,
+                func_type,
+                func_ptr,
+                Some(G0M0FunctionKind::Imported),
+                Some((g0_value.into_int_value(), m0)),
+            )?;
+            self.abi
+                .rets_from_call(&self.builder, self.intrinsics, call_site, func_type)?
+                .iter()
+                .for_each(|ret| self.state.push1(*ret));
+        }
+
+        Ok(())
+    }
+
+    fn build_indirect_call(
+        &mut self,
+        ctx_ptr: PointerValue<'ctx>,
+        func_type: &FunctionType,
+        func_ptr: PointerValue<'ctx>,
+        func_kind: Option<G0M0FunctionKind>,
+        g0m0_params: LocalFunctionG0M0params<'ctx>,
+    ) -> Result<CallSiteValue<'ctx>, CompileError> {
+        let (llvm_func_type, llvm_func_attrs) = self.abi.func_type_to_llvm(
+            self.context,
+            self.intrinsics,
+            Some(self.ctx.get_offsets()),
+            func_type,
+            func_kind,
+        )?;
+
+        let params = self.state.popn_save_extra(func_type.params().len())?;
+
+        // Apply pending canonicalizations.
+        let params = params
+            .iter()
+            .zip(func_type.params().iter())
+            .map(|((v, info), wasm_ty)| match wasm_ty {
+                Type::F32 => err_nt!(self.builder.build_bit_cast(
+                    self.apply_pending_canonicalization(*v, *info)?,
+                    self.intrinsics.f32_ty,
+                    "",
+                )),
+                Type::F64 => err_nt!(self.builder.build_bit_cast(
+                    self.apply_pending_canonicalization(*v, *info)?,
+                    self.intrinsics.f64_ty,
+                    "",
+                )),
+                Type::V128 => self.apply_pending_canonicalization(*v, *info),
+                _ => Ok(*v),
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let params = self.abi.args_to_call(
+            &self.alloca_builder,
+            func_type,
+            &llvm_func_type,
+            ctx_ptr,
+            params.as_slice(),
+            self.intrinsics,
+            g0m0_params,
+        )?;
+
+        let typed_func_ptr = err!(self.builder.build_pointer_cast(
+            func_ptr,
+            self.context.ptr_type(AddressSpace::default()),
+            "typed_func_ptr",
+        ));
+
+        /*
+        if self.track_state {
+            if let Some(offset) = opcode_offset {
+                let mut stackmaps = self.stackmaps.borrow_mut();
+                emit_stack_map(
+                    &info,
+                    self.intrinsics,
+                    self.builder,
+                    self.index,
+                    &mut *stackmaps,
+                    StackmapEntryKind::Call,
+                    &self.locals,
+                    state,
+                    ctx,
+                    offset,
+                )
+            }
+        }
+        */
+
+        let call_site_local = if let Some(lpad) = self.state.get_innermost_landingpad() {
+            let then_block = self.context.append_basic_block(self.function, "then_block");
+
+            let ret = err!(self.builder.build_indirect_invoke(
+                llvm_func_type,
+                typed_func_ptr,
+                params.as_slice(),
+                then_block,
+                lpad,
+                "",
+            ));
+
+            self.builder.position_at_end(then_block);
+            ret
+        } else {
+            err!(self.builder.build_indirect_call(
+                llvm_func_type,
+                typed_func_ptr,
+                params
+                    .iter()
+                    .copied()
+                    .map(Into::into)
+                    .collect::<Vec<BasicMetadataValueEnum>>()
+                    .as_slice(),
+                "indirect_call",
+            ))
+        };
+        for (attr, attr_loc) in llvm_func_attrs {
+            call_site_local.add_attribute(attr_loc, attr);
+        }
+
+        Ok(call_site_local)
+    }
+
+    fn build_or_get_vmctx_alloca(&mut self) -> Result<PointerValue<'ctx>, CompileError> {
+        if let Some(vmctx_alloca) = self.vmctx_alloca {
+            return Ok(vmctx_alloca);
+        }
+
+        let vmctx_alloca = err!(self
+            .alloca_builder
+            .build_alloca(self.intrinsics.ptr_ty, "vmctx"));
+        err!(self
+            .alloca_builder
+            .build_store(vmctx_alloca, self.ctx.basic()));
+        self.vmctx_alloca = Some(vmctx_alloca);
+        Ok(vmctx_alloca)
+    }
+}
+
+/*
+fn emit_stack_map<'ctx>(
+    intrinsics: &Intrinsics<'ctx>,
+    builder: &Builder<'ctx>,
+    local_function_id: usize,
+    target: &mut StackmapRegistry,
+    kind: StackmapEntryKind,
+    locals: &[PointerValue],
+    state: &State<'ctx>,
+    _ctx: &mut CtxType<'ctx>,
+    opcode_offset: usize,
+) {
+    let stackmap_id = target.entries.len();
+
+    let mut params = Vec::with_capacity(2 + locals.len() + state.stack.len());
+
+    params.push(
+        intrinsics
+            .i64_ty
+            .const_int(stackmap_id as u64, false)
+            .as_basic_value_enum(),
+    );
+    params.push(intrinsics.i32_ty.const_zero().as_basic_value_enum());
+
+    let locals: Vec<_> = locals.iter().map(|x| x.as_basic_value_enum()).collect();
+    let mut value_semantics: Vec<ValueSemantic> =
+        Vec::with_capacity(locals.len() + state.stack.len());
+
+    params.extend_from_slice(&locals);
+    value_semantics.extend((0..locals.len()).map(ValueSemantic::WasmLocal));
+
+    params.extend(state.stack.iter().map(|x| x.0));
+    value_semantics.extend((0..state.stack.len()).map(ValueSemantic::WasmStack));
+
+    // FIXME: Information needed for Abstract -> Runtime state transform is not fully preserved
+    // to accelerate compilation and reduce memory usage. Check this again when we try to support
+    // "full" LLVM OSR.
+
+    assert_eq!(params.len(), value_semantics.len() + 2);
+
+    builder.build_call(intrinsics.experimental_stackmap, &params, "");
+
+    target.entries.push(StackmapEntry {
+        kind,
+        local_function_id,
+        local_count: locals.len(),
+        stack_count: state.stack.len(),
+        opcode_offset,
+        value_semantics,
+        is_start: true,
+    });
+}
+
+fn finalize_opcode_stack_map<'ctx>(
+    intrinsics: &Intrinsics<'ctx>,
+    builder: &Builder<'ctx>,
+    local_function_id: usize,
+    target: &mut StackmapRegistry,
+    kind: StackmapEntryKind,
+    opcode_offset: usize,
+) {
+    let stackmap_id = target.entries.len();
+    builder.build_call(
+        intrinsics.experimental_stackmap,
+        &[
             intrinsics
                 .i64_ty
                 .const_int(stackmap_id as u64, false)
@@ -1363,6 +1905,7 @@ fn finalize_opcode_stack_map<'ctx>(
  */
 
 pub struct LLVMFunctionCodeGenerator<'ctx, 'a> {
+    g0m0: Option<(PointerValue<'ctx>, PointerValue<'ctx>)>,
     context: &'ctx Context,
     builder: Builder<'ctx>,
     alloca_builder: Builder<'ctx>,
@@ -1388,9 +1931,13 @@ pub struct LLVMFunctionCodeGenerator<'ctx, 'a> {
     symbol_registry: &'a dyn SymbolRegistry,
     abi: &'a dyn Abi,
     config: &'a LLVM,
+    tags_cache: HashMap<i32, BasicValueEnum<'ctx>>,
+    exception_types_cache: HashMap<u32, inkwell::types::StructType<'ctx>>,
+    vmctx_alloca: Option<PointerValue<'ctx>>,
+    binary_fmt: target_lexicon::BinaryFormat,
 }
 
-impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
+impl<'ctx> LLVMFunctionCodeGenerator<'ctx, '_> {
     fn translate_operator(&mut self, op: Operator, _source_loc: u32) -> Result<(), CompileError> {
         // TODO: remove this vmctx by moving everything into CtxType. Values
         // computed off vmctx usually benefit from caching.
@@ -1443,16 +1990,21 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     .1
                     .iter()
                     .map(|&wp_ty| {
-                        wptype_to_type(wp_ty)
-                            .map_err(to_compile_error)
-                            .and_then(|wasm_ty| {
-                                type_to_llvm(self.intrinsics, wasm_ty)
-                                    .map(|ty| self.builder.build_phi(ty, ""))
-                            })
+                        err_nt!(wptype_to_type(wp_ty)).and_then(|wasm_ty| {
+                            type_to_llvm(self.intrinsics, wasm_ty)
+                                .and_then(|ty| err_nt!(self.builder.build_phi(ty, "")))
+                        })
                     })
                     .collect::<Result<_, _>>()?;
 
-                self.state.push_block(end_block, phis);
+                self.state.push_block(
+                    end_block,
+                    phis,
+                    self.module_translation
+                        .blocktype_params_results(&blockty)?
+                        .0
+                        .len(),
+                );
                 self.builder.position_at_end(current_block);
             }
             Operator::Loop { blockty } => {
@@ -1460,7 +2012,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let loop_next = self.context.append_basic_block(self.function, "loop_outer");
                 let pre_loop_block = self.builder.get_insert_block().unwrap();
 
-                self.builder.build_unconditional_branch(loop_body);
+                err!(self.builder.build_unconditional_branch(loop_body));
 
                 self.builder.position_at_end(loop_next);
                 let blocktypes = self.module_translation.blocktype_params_results(&blockty)?;
@@ -1468,12 +2020,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     .1
                     .iter()
                     .map(|&wp_ty| {
-                        wptype_to_type(wp_ty)
-                            .map_err(to_compile_error)
-                            .and_then(|wasm_ty| {
-                                type_to_llvm(self.intrinsics, wasm_ty)
-                                    .map(|ty| self.builder.build_phi(ty, ""))
-                            })
+                        err_nt!(wptype_to_type(wp_ty)).and_then(|wasm_ty| {
+                            type_to_llvm(self.intrinsics, wasm_ty)
+                                .and_then(|ty| err_nt!(self.builder.build_phi(ty, "")))
+                        })
                     })
                     .collect::<Result<_, _>>()?;
                 self.builder.position_at_end(loop_body);
@@ -1481,56 +2031,24 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     .0
                     .iter()
                     .map(|&wp_ty| {
-                        wptype_to_type(wp_ty)
-                            .map_err(to_compile_error)
-                            .and_then(|wasm_ty| {
-                                type_to_llvm(self.intrinsics, wasm_ty)
-                                    .map(|ty| self.builder.build_phi(ty, ""))
-                            })
+                        err_nt!(wptype_to_type(wp_ty)).and_then(|wasm_ty| {
+                            type_to_llvm(self.intrinsics, wasm_ty)
+                                .and_then(|ty| err_nt!(self.builder.build_phi(ty, "")))
+                        })
                     })
                     .collect::<Result<_, _>>()?;
                 for phi in loop_phis.iter().rev() {
                     let (value, info) = self.state.pop1_extra()?;
-                    let value = self.apply_pending_canonicalization(value, info);
+                    let value = self.apply_pending_canonicalization(value, info)?;
                     phi.add_incoming(&[(&value, pre_loop_block)]);
                 }
                 for phi in &loop_phis {
                     self.state.push1(phi.as_basic_value());
                 }
 
-                /*
-                if self.track_state {
-                    if let Some(offset) = opcode_offset {
-                        let mut stackmaps = self.stackmaps.borrow_mut();
-                        emit_stack_map(
-                            self.intrinsics,
-                            self.builder,
-                            self.index,
-                            &mut *stackmaps,
-                            StackmapEntryKind::Loop,
-                            &self.self.locals,
-                            state,
-                            ctx,
-                            offset,
-                        );
-                        let signal_mem = ctx.signal_mem();
-                        let iv = self.builder
-                            .build_store(signal_mem, self.context.i8_type().const_zero());
-                        // Any 'store' can be made volatile.
-                        iv.set_volatile(true).unwrap();
-                        finalize_opcode_stack_map(
-                            self.intrinsics,
-                            self.builder,
-                            self.index,
-                            &mut *stackmaps,
-                            StackmapEntryKind::Loop,
-                            offset,
-                        );
-                    }
-                }
-                */
-
-                self.state.push_loop(loop_body, loop_next, loop_phis, phis);
+                let num_inputs = loop_phis.len();
+                self.state
+                    .push_loop(loop_body, loop_next, loop_phis, phis, num_inputs);
             }
             Operator::Br { relative_depth } => {
                 let frame = self.state.frame_at_depth(relative_depth)?;
@@ -1550,16 +2068,17 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let values = self.state.peekn_extra(len)?;
                 let values = values
                     .iter()
-                    .map(|(v, info)| self.apply_pending_canonicalization(*v, *info));
+                    .map(|(v, info)| self.apply_pending_canonicalization(*v, *info))
+                    .collect::<Result<Vec<_>, _>>()?;
 
                 // For each result of the block we're branching to,
                 // pop a value off the value stack and load it into
                 // the corresponding phi.
-                for (phi, value) in phis.iter().zip(values) {
+                for (phi, value) in phis.iter().zip(values.into_iter()) {
                     phi.add_incoming(&[(&value, current_block)]);
                 }
 
-                self.builder.build_unconditional_branch(*frame.br_dest());
+                err!(self.builder.build_unconditional_branch(*frame.br_dest()));
 
                 self.state.popn(len)?;
                 self.state.reachable = false;
@@ -1582,7 +2101,8 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let param_stack = self.state.peekn_extra(phis.len())?;
                 let param_stack = param_stack
                     .iter()
-                    .map(|(v, info)| self.apply_pending_canonicalization(*v, *info));
+                    .map(|(v, info)| self.apply_pending_canonicalization(*v, *info))
+                    .collect::<Result<Vec<_>, _>>()?;
 
                 for (phi, value) in phis.iter().zip(param_stack) {
                     phi.add_incoming(&[(&value, current_block)]);
@@ -1590,14 +2110,17 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
 
                 let else_block = self.context.append_basic_block(self.function, "else");
 
-                let cond_value = self.builder.build_int_compare(
+                let cond_value = err!(self.builder.build_int_compare(
                     IntPredicate::NE,
                     cond.into_int_value(),
                     self.intrinsics.i32_zero,
                     "",
-                );
-                self.builder
-                    .build_conditional_branch(cond_value, *frame.br_dest(), else_block);
+                ));
+                err!(self.builder.build_conditional_branch(
+                    cond_value,
+                    *frame.br_dest(),
+                    else_block
+                ));
                 self.builder.position_at_end(else_block);
             }
             Operator::BrTable { ref targets } => {
@@ -1647,11 +2170,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     })
                     .collect::<Result<_, _>>()?;
 
-                self.builder.build_switch(
+                err!(self.builder.build_switch(
                     index.into_int_value(),
                     *default_frame.br_dest(),
                     &cases[..],
-                );
+                ));
 
                 let args_len = args.len();
                 self.state.popn(args_len)?;
@@ -1675,12 +2198,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         .1
                         .iter()
                         .map(|&wp_ty| {
-                            wptype_to_type(wp_ty)
-                                .map_err(to_compile_error)
-                                .and_then(|wasm_ty| {
-                                    type_to_llvm(self.intrinsics, wasm_ty)
-                                        .map(|ty| self.builder.build_phi(ty, ""))
-                                })
+                            err_nt!(wptype_to_type(wp_ty)).and_then(|wasm_ty| {
+                                type_to_llvm(self.intrinsics, wasm_ty)
+                                    .and_then(|ty| err_nt!(self.builder.build_phi(ty, "")))
+                            })
                         })
                         .collect::<Result<_, _>>()?;
 
@@ -1690,15 +2211,18 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
 
                 let cond = self.state.pop1()?;
 
-                let cond_value = self.builder.build_int_compare(
+                let cond_value = err!(self.builder.build_int_compare(
                     IntPredicate::NE,
                     cond.into_int_value(),
                     self.intrinsics.i32_zero,
                     "",
-                );
+                ));
 
-                self.builder
-                    .build_conditional_branch(cond_value, if_then_block, if_else_block);
+                err!(self.builder.build_conditional_branch(
+                    cond_value,
+                    if_then_block,
+                    if_else_block
+                ));
                 self.builder.position_at_end(if_else_block);
                 let block_param_types = self
                     .module_translation
@@ -1706,23 +2230,22 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     .0
                     .iter()
                     .map(|&wp_ty| {
-                        wptype_to_type(wp_ty)
-                            .map_err(to_compile_error)
+                        err_nt!(wptype_to_type(wp_ty))
                             .and_then(|wasm_ty| type_to_llvm(self.intrinsics, wasm_ty))
                     })
                     .collect::<Result<Vec<_>, _>>()?;
                 let else_phis: SmallVec<[PhiValue<'ctx>; 1]> = block_param_types
                     .iter()
-                    .map(|&ty| self.builder.build_phi(ty, ""))
-                    .collect();
+                    .map(|&ty| err_nt!(self.builder.build_phi(ty, "")))
+                    .collect::<Result<SmallVec<_>, _>>()?;
                 self.builder.position_at_end(if_then_block);
                 let then_phis: SmallVec<[PhiValue<'ctx>; 1]> = block_param_types
                     .iter()
-                    .map(|&ty| self.builder.build_phi(ty, ""))
-                    .collect();
+                    .map(|&ty| err_nt!(self.builder.build_phi(ty, "")))
+                    .collect::<Result<SmallVec<_>, _>>()?;
                 for (else_phi, then_phi) in else_phis.iter().rev().zip(then_phis.iter().rev()) {
                     let (value, info) = self.state.pop1_extra()?;
-                    let value = self.apply_pending_canonicalization(value, info);
+                    let value = self.apply_pending_canonicalization(value, info)?;
                     else_phi.add_incoming(&[(&value, current_block)]);
                     then_phi.add_incoming(&[(&value, current_block)]);
                 }
@@ -1737,6 +2260,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     then_phis,
                     else_phis,
                     end_phis,
+                    block_param_types.len(),
                 );
             }
             Operator::Else => {
@@ -1748,12 +2272,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
 
                     for phi in frame.phis().to_vec().iter().rev() {
                         let (value, info) = self.state.pop1_extra()?;
-                        let value = self.apply_pending_canonicalization(value, info);
+                        let value = self.apply_pending_canonicalization(value, info)?;
                         phi.add_incoming(&[(&value, current_block)])
                     }
 
                     let frame = self.state.frame_at_depth(0)?;
-                    self.builder.build_unconditional_branch(*frame.code_after());
+                    err!(self.builder.build_unconditional_branch(*frame.code_after()));
                 }
 
                 let (if_else_block, if_else_state) = if let ControlFrame::IfElse {
@@ -1790,11 +2314,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 if self.state.reachable {
                     for phi in frame.phis().iter().rev() {
                         let (value, info) = self.state.pop1_extra()?;
-                        let value = self.apply_pending_canonicalization(value, info);
+                        let value = self.apply_pending_canonicalization(value, info)?;
                         phi.add_incoming(&[(&value, current_block)]);
                     }
 
-                    self.builder.build_unconditional_branch(*frame.code_after());
+                    err!(self.builder.build_unconditional_branch(*frame.code_after()));
                 }
 
                 if let ControlFrame::IfElse {
@@ -1809,8 +2333,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         phi.add_incoming(&[(&else_phi.as_basic_value(), *if_else)]);
                     }
                     self.builder.position_at_end(*if_else);
-                    self.builder.build_unconditional_branch(*next);
-                }
+                    err!(self.builder.build_unconditional_branch(*next));
+                } else if let ControlFrame::Landingpad { .. } = &frame {
+                    self.state.pop_landingpad();
+                };
 
                 self.builder.position_at_end(*frame.code_after());
                 self.state.reset_stack(&frame);
@@ -1822,6 +2348,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     if phi.count_incoming() != 0 {
                         self.state.push1(phi.as_basic_value());
                     } else {
+                        // TODO if there are no incoming phi values, it means
+                        // this block has no predecessors, and we can skip it
+                        // altogether. However, fixing this is non-trivial as
+                        // some places in the code rely on code getting generated
+                        // for unreachable end blocks. For now, we let LLVM remove
+                        // the block during dead code elimination instead.
                         let basic_ty = phi.as_basic_value().get_type();
                         let placeholder_value = basic_ty.const_zero();
                         self.state.push1(placeholder_value);
@@ -1838,56 +2370,22 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let frame = self.state.outermost_frame()?;
                 for phi in frame.phis().to_vec().iter().rev() {
                     let (arg, info) = self.state.pop1_extra()?;
-                    let arg = self.apply_pending_canonicalization(arg, info);
+                    let arg = self.apply_pending_canonicalization(arg, info)?;
                     phi.add_incoming(&[(&arg, current_block)]);
                 }
                 let frame = self.state.outermost_frame()?;
-                self.builder.build_unconditional_branch(*frame.br_dest());
+                err!(self.builder.build_unconditional_branch(*frame.br_dest()));
 
                 self.state.reachable = false;
             }
 
             Operator::Unreachable => {
-                // Emit an unreachable instruction.
-                // If llvm cannot prove that this is never reached,
-                // it will emit a `ud2` instruction on x86_64 arches.
-
-                // Comment out this `if` block to allow spectests to pass.
-                // TODO: fix this
-                /*
-                if let Some(offset) = opcode_offset {
-                    if self.track_state {
-                        let mut stackmaps = self.stackmaps.borrow_mut();
-                        emit_stack_map(
-                            self.intrinsics,
-                            self.builder,
-                            self.index,
-                            &mut *stackmaps,
-                            StackmapEntryKind::Trappable,
-                            &self.self.locals,
-                            state,
-                            ctx,
-                            offset,
-                        );
-                        self.builder.build_call(self.intrinsics.trap, &[], "trap");
-                        finalize_opcode_stack_map(
-                            self.intrinsics,
-                            self.builder,
-                            self.index,
-                            &mut *stackmaps,
-                            StackmapEntryKind::Trappable,
-                            offset,
-                        );
-                    }
-                }
-                */
-
-                self.builder.build_call(
+                err!(self.builder.build_call(
                     self.intrinsics.throw_trap,
                     &[self.intrinsics.trap_unreachable.into()],
                     "throw",
-                );
-                self.builder.build_unreachable();
+                ));
+                err!(self.builder.build_unreachable());
 
                 self.state.reachable = false;
             }
@@ -1929,9 +2427,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 } else {
                     Default::default()
                 };
-                let f = self
+                let f = err!(self
                     .builder
-                    .build_bitcast(bits, self.intrinsics.f32_ty, "f");
+                    .build_bit_cast(bits, self.intrinsics.f32_ty, "f"));
                 self.state.push1_extra(f, info);
             }
             Operator::F64Const { value } => {
@@ -1941,9 +2439,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 } else {
                     Default::default()
                 };
-                let f = self
+                let f = err!(self
                     .builder
-                    .build_bitcast(bits, self.intrinsics.f64_ty, "f");
+                    .build_bit_cast(bits, self.intrinsics.f64_ty, "f"));
                 self.state.push1_extra(f, info);
             }
             Operator::V128Const { value } => {
@@ -1981,47 +2479,59 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             Operator::I8x16Splat => {
                 let (v, i) = self.state.pop1_extra()?;
                 let v = v.into_int_value();
-                let v = self
+                let v = err!(self
+                    .builder
+                    .build_int_truncate(v, self.intrinsics.i8_ty, ""));
+                let res = self.splat_vector(v.as_basic_value_enum(), self.intrinsics.i8x16_ty)?;
+                let res = err!(self
                     .builder
-                    .build_int_truncate(v, self.intrinsics.i8_ty, "");
-                let res = self.splat_vector(v.as_basic_value_enum(), self.intrinsics.i8x16_ty);
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1_extra(res, i);
             }
             Operator::I16x8Splat => {
                 let (v, i) = self.state.pop1_extra()?;
                 let v = v.into_int_value();
-                let v = self
+                let v = err!(self
+                    .builder
+                    .build_int_truncate(v, self.intrinsics.i16_ty, ""));
+                let res = self.splat_vector(v.as_basic_value_enum(), self.intrinsics.i16x8_ty)?;
+                let res = err!(self
                     .builder
-                    .build_int_truncate(v, self.intrinsics.i16_ty, "");
-                let res = self.splat_vector(v.as_basic_value_enum(), self.intrinsics.i16x8_ty);
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1_extra(res, i);
             }
             Operator::I32x4Splat => {
                 let (v, i) = self.state.pop1_extra()?;
-                let res = self.splat_vector(v, self.intrinsics.i32x4_ty);
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = self.splat_vector(v, self.intrinsics.i32x4_ty)?;
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1_extra(res, i);
             }
             Operator::I64x2Splat => {
                 let (v, i) = self.state.pop1_extra()?;
-                let res = self.splat_vector(v, self.intrinsics.i64x2_ty);
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = self.splat_vector(v, self.intrinsics.i64x2_ty)?;
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1_extra(res, i);
             }
             Operator::F32x4Splat => {
                 let (v, i) = self.state.pop1_extra()?;
-                let res = self.splat_vector(v, self.intrinsics.f32x4_ty);
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = self.splat_vector(v, self.intrinsics.f32x4_ty)?;
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 // The spec is unclear, we interpret splat as preserving NaN
                 // payload bits.
                 self.state.push1_extra(res, i);
             }
             Operator::F64x2Splat => {
                 let (v, i) = self.state.pop1_extra()?;
-                let res = self.splat_vector(v, self.intrinsics.f64x2_ty);
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = self.splat_vector(v, self.intrinsics.f64x2_ty)?;
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 // The spec is unclear, we interpret splat as preserving NaN
                 // payload bits.
                 self.state.push1_extra(res, i);
@@ -2030,11 +2540,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             // Operate on self.locals.
             Operator::LocalGet { local_index } => {
                 let (type_value, pointer_value) = self.locals[local_index as usize];
-                let v = self.builder.build_load(type_value, pointer_value, "");
+                let v = err!(self.builder.build_load(
+                    type_value,
+                    pointer_value,
+                    &format!("local_{local_index}_get")
+                ));
                 tbaa_label(
                     self.module,
                     self.intrinsics,
-                    format!("local {}", local_index),
+                    format!("local {local_index}"),
                     v.as_instruction_value().unwrap(),
                 );
                 self.state.push1(v);
@@ -2042,75 +2556,98 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             Operator::LocalSet { local_index } => {
                 let pointer_value = self.locals[local_index as usize].1;
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
-                let store = self.builder.build_store(pointer_value, v);
+                let v = self.apply_pending_canonicalization(v, i)?;
+                let store = err!(self.builder.build_store(pointer_value, v));
                 tbaa_label(
                     self.module,
                     self.intrinsics,
-                    format!("local {}", local_index),
+                    format!("local {local_index}"),
                     store,
                 );
             }
             Operator::LocalTee { local_index } => {
                 let pointer_value = self.locals[local_index as usize].1;
                 let (v, i) = self.state.peek1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
-                let store = self.builder.build_store(pointer_value, v);
+                let v = self.apply_pending_canonicalization(v, i)?;
+                let store = err!(self.builder.build_store(pointer_value, v));
                 tbaa_label(
                     self.module,
                     self.intrinsics,
-                    format!("local {}", local_index),
+                    format!("local {local_index}"),
                     store,
                 );
             }
 
             Operator::GlobalGet { global_index } => {
-                let global_index = GlobalIndex::from_u32(global_index);
-                match self
-                    .ctx
-                    .global(global_index, self.intrinsics, self.module)?
-                {
-                    GlobalCache::Const { value } => {
-                        self.state.push1(*value);
-                    }
-                    GlobalCache::Mut {
-                        ptr_to_value,
-                        value_type,
-                    } => {
-                        let value = self.builder.build_load(*value_type, *ptr_to_value, "");
-                        tbaa_label(
-                            self.module,
-                            self.intrinsics,
-                            format!("global {}", global_index.as_u32()),
-                            value.as_instruction_value().unwrap(),
-                        );
-                        self.state.push1(value);
+                if self.g0m0.is_some() && global_index == 0 {
+                    let Some((g0, _)) = self.g0m0 else {
+                        unreachable!()
+                    };
+
+                    // Removed with mem2reg.
+                    let value = err!(self.builder.build_load(self.intrinsics.i32_ty, g0, ""));
+
+                    self.state.push1(value);
+                } else {
+                    let global_index = GlobalIndex::from_u32(global_index);
+                    match self
+                        .ctx
+                        .global(global_index, self.intrinsics, self.module)?
+                    {
+                        GlobalCache::Const { value } => {
+                            self.state.push1(*value);
+                        }
+                        GlobalCache::Mut {
+                            ptr_to_value,
+                            value_type,
+                        } => {
+                            let value =
+                                err!(self.builder.build_load(*value_type, *ptr_to_value, ""));
+                            tbaa_label(
+                                self.module,
+                                self.intrinsics,
+                                format!("global {}", global_index.as_u32()),
+                                value.as_instruction_value().unwrap(),
+                            );
+                            self.state.push1(value);
+                        }
                     }
                 }
             }
             Operator::GlobalSet { global_index } => {
-                let global_index = GlobalIndex::from_u32(global_index);
-                match self
-                    .ctx
-                    .global(global_index, self.intrinsics, self.module)?
-                {
-                    GlobalCache::Const { value: _ } => {
-                        return Err(CompileError::Codegen(format!(
-                            "global.set on immutable global index {}",
-                            global_index.as_u32()
-                        )))
-                    }
-                    GlobalCache::Mut { ptr_to_value, .. } => {
-                        let ptr_to_value = *ptr_to_value;
-                        let (value, info) = self.state.pop1_extra()?;
-                        let value = self.apply_pending_canonicalization(value, info);
-                        let store = self.builder.build_store(ptr_to_value, value);
-                        tbaa_label(
-                            self.module,
-                            self.intrinsics,
-                            format!("global {}", global_index.as_u32()),
-                            store,
-                        );
+                if self.g0m0.is_some() && global_index == 0 {
+                    let Some((g0, _)) = self.g0m0 else {
+                        unreachable!()
+                    };
+                    let ptr_to_value = g0;
+                    let (value, info) = self.state.pop1_extra()?;
+                    let value = self.apply_pending_canonicalization(value, info)?;
+                    let store = err!(self.builder.build_store(ptr_to_value, value));
+                    tbaa_label(self.module, self.intrinsics, "global 0".to_string(), store);
+                } else {
+                    let global_index = GlobalIndex::from_u32(global_index);
+                    match self
+                        .ctx
+                        .global(global_index, self.intrinsics, self.module)?
+                    {
+                        GlobalCache::Const { value: _ } => {
+                            return Err(CompileError::Codegen(format!(
+                                "global.set on immutable global index {}",
+                                global_index.as_u32()
+                            )))
+                        }
+                        GlobalCache::Mut { ptr_to_value, .. } => {
+                            let ptr_to_value = *ptr_to_value;
+                            let (value, info) = self.state.pop1_extra()?;
+                            let value = self.apply_pending_canonicalization(value, info)?;
+                            let store = err!(self.builder.build_store(ptr_to_value, value));
+                            tbaa_label(
+                                self.module,
+                                self.intrinsics,
+                                format!("global {}", global_index.as_u32()),
+                                store,
+                            );
+                        }
                     }
                 }
             }
@@ -2130,30 +2667,30 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     || i1.has_pending_f64_nan() != i2.has_pending_f64_nan()
                 {
                     (
-                        self.apply_pending_canonicalization(v1, i1),
+                        self.apply_pending_canonicalization(v1, i1)?,
                         i1.strip_pending(),
-                        self.apply_pending_canonicalization(v2, i2),
+                        self.apply_pending_canonicalization(v2, i2)?,
                         i2.strip_pending(),
                     )
                 } else {
                     (v1, i1, v2, i2)
                 };
-                let cond_value = self.builder.build_int_compare(
+                let cond_value = err!(self.builder.build_int_compare(
                     IntPredicate::NE,
                     cond.into_int_value(),
                     self.intrinsics.i32_zero,
                     "",
-                );
-                let res = self.builder.build_select(cond_value, v1, v2, "");
+                ));
+                let res = err!(self.builder.build_select(cond_value, v1, v2, ""));
                 let info = {
-                    let mut info = i1.strip_pending() & i2.strip_pending();
+                    let mut info = (i1.strip_pending() & i2.strip_pending())?;
                     if i1.has_pending_f32_nan() {
                         debug_assert!(i2.has_pending_f32_nan());
-                        info |= ExtraInfo::pending_f32_nan();
+                        info = (info | ExtraInfo::pending_f32_nan())?;
                     }
                     if i1.has_pending_f64_nan() {
                         debug_assert!(i2.has_pending_f64_nan());
-                        info |= ExtraInfo::pending_f64_nan();
+                        info = (info | ExtraInfo::pending_f64_nan())?;
                     }
                     info
                 };
@@ -2164,15 +2701,25 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let sigindex = &self.wasm_module.functions[func_index];
                 let func_type = &self.wasm_module.signatures[*sigindex];
 
+                let mut g0m0_params = None;
+
                 let FunctionCache {
                     func,
                     llvm_func_type,
                     vmctx: callee_vmctx,
                     attrs,
                 } = if let Some(local_func_index) = self.wasm_module.local_func_index(func_index) {
+                    if let Some((g0, m0)) = &self.g0m0 {
+                        // removed with mem2reg.
+                        let value = err!(self.builder.build_load(self.intrinsics.i32_ty, *g0, ""));
+
+                        g0m0_params = Some((value.into_int_value(), *m0));
+                    }
+
                     let function_name = self
                         .symbol_registry
                         .symbol_to_name(Symbol::LocalFunction(local_func_index));
+
                     self.ctx.local_func(
                         local_func_index,
                         func_index,
@@ -2203,20 +2750,20 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     .iter()
                     .zip(func_type.params().iter())
                     .map(|((v, info), wasm_ty)| match wasm_ty {
-                        Type::F32 => self.builder.build_bitcast(
-                            self.apply_pending_canonicalization(*v, *info),
+                        Type::F32 => err_nt!(self.builder.build_bit_cast(
+                            self.apply_pending_canonicalization(*v, *info)?,
                             self.intrinsics.f32_ty,
                             "",
-                        ),
-                        Type::F64 => self.builder.build_bitcast(
-                            self.apply_pending_canonicalization(*v, *info),
+                        )),
+                        Type::F64 => err_nt!(self.builder.build_bit_cast(
+                            self.apply_pending_canonicalization(*v, *info)?,
                             self.intrinsics.f64_ty,
                             "",
-                        ),
+                        )),
                         Type::V128 => self.apply_pending_canonicalization(*v, *info),
-                        _ => *v,
+                        _ => Ok(*v),
                     })
-                    .collect::<Vec<_>>();
+                    .collect::<Result<Vec<_>, _>>()?;
 
                 let params = self.abi.args_to_call(
                     &self.alloca_builder,
@@ -2225,7 +2772,8 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     callee_vmctx.into_pointer_value(),
                     params.as_slice(),
                     self.intrinsics,
-                );
+                    g0m0_params,
+                )?;
 
                 /*
                 if self.track_state {
@@ -2246,17 +2794,33 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     }
                 }
                 */
-                let call_site = self.builder.build_indirect_call(
-                    llvm_func_type,
-                    func,
-                    params
-                        .iter()
-                        .copied()
-                        .map(Into::into)
-                        .collect::<Vec<BasicMetadataValueEnum>>()
-                        .as_slice(),
-                    "",
-                );
+                let call_site = if let Some(lpad) = self.state.get_innermost_landingpad() {
+                    let then_block = self.context.append_basic_block(self.function, "then_block");
+
+                    let ret = err!(self.builder.build_indirect_invoke(
+                        llvm_func_type,
+                        func,
+                        params.as_slice(),
+                        then_block,
+                        lpad,
+                        "",
+                    ));
+
+                    self.builder.position_at_end(then_block);
+                    ret
+                } else {
+                    err!(self.builder.build_indirect_call(
+                        llvm_func_type,
+                        func,
+                        params
+                            .iter()
+                            .copied()
+                            .map(Into::into)
+                            .collect::<Vec<BasicMetadataValueEnum>>()
+                            .as_slice(),
+                        "",
+                    ))
+                };
                 for (attr, attr_loc) in attrs {
                     call_site.add_attribute(attr_loc, attr);
                 }
@@ -2277,55 +2841,53 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 */
 
                 self.abi
-                    .rets_from_call(&self.builder, self.intrinsics, call_site, func_type)
+                    .rets_from_call(&self.builder, self.intrinsics, call_site, func_type)?
                     .iter()
                     .for_each(|ret| self.state.push1(*ret));
             }
             Operator::CallIndirect {
                 type_index,
                 table_index,
-                table_byte: _,
             } => {
                 let sigindex = SignatureIndex::from_u32(type_index);
                 let func_type = &self.wasm_module.signatures[sigindex];
                 let expected_dynamic_sigindex =
                     self.ctx
-                        .dynamic_sigindex(sigindex, self.intrinsics, self.module);
+                        .dynamic_sigindex(sigindex, self.intrinsics, self.module)?;
                 let (table_base, table_bound) = self.ctx.table(
                     TableIndex::from_u32(table_index),
                     self.intrinsics,
                     self.module,
-                );
+                    &self.builder,
+                )?;
                 let func_index = self.state.pop1()?.into_int_value();
 
-                let truncated_table_bounds = self.builder.build_int_truncate(
+                let truncated_table_bounds = err!(self.builder.build_int_truncate(
                     table_bound,
                     self.intrinsics.i32_ty,
                     "truncated_table_bounds",
-                );
+                ));
 
                 // First, check if the index is outside of the table bounds.
-                let index_in_bounds = self.builder.build_int_compare(
+                let index_in_bounds = err!(self.builder.build_int_compare(
                     IntPredicate::ULT,
                     func_index,
                     truncated_table_bounds,
                     "index_in_bounds",
-                );
-
-                let index_in_bounds = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.expect_i1,
-                        &[
-                            index_in_bounds.into(),
-                            self.intrinsics.i1_ty.const_int(1, false).into(),
-                        ],
-                        "index_in_bounds_expect",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_int_value();
+                ));
+
+                let index_in_bounds = err!(self.builder.build_call(
+                    self.intrinsics.expect_i1,
+                    &[
+                        index_in_bounds.into(),
+                        self.intrinsics.i1_ty.const_int(1, false).into(),
+                    ],
+                    "index_in_bounds_expect",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_int_value();
 
                 let in_bounds_continue_block = self
                     .context
@@ -2333,52 +2895,50 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let not_in_bounds_block = self
                     .context
                     .append_basic_block(self.function, "not_in_bounds_block");
-                self.builder.build_conditional_branch(
+                err!(self.builder.build_conditional_branch(
                     index_in_bounds,
                     in_bounds_continue_block,
                     not_in_bounds_block,
-                );
+                ));
                 self.builder.position_at_end(not_in_bounds_block);
-                self.builder.build_call(
+                err!(self.builder.build_call(
                     self.intrinsics.throw_trap,
                     &[self.intrinsics.trap_table_access_oob.into()],
                     "throw",
-                );
-                self.builder.build_unreachable();
+                ));
+                err!(self.builder.build_unreachable());
                 self.builder.position_at_end(in_bounds_continue_block);
 
                 // We assume the table has the `funcref` (pointer to `anyfunc`)
                 // element type.
-                let casted_table_base = self.builder.build_pointer_cast(
+                let casted_table_base = err!(self.builder.build_pointer_cast(
                     table_base,
-                    self.intrinsics.funcref_ty.ptr_type(AddressSpace::default()),
+                    self.context.ptr_type(AddressSpace::default()),
                     "casted_table_base",
-                );
+                ));
 
                 let funcref_ptr = unsafe {
-                    self.builder.build_in_bounds_gep(
-                        self.intrinsics.funcref_ty,
+                    err!(self.builder.build_in_bounds_gep(
+                        self.intrinsics.ptr_ty,
                         casted_table_base,
                         &[func_index],
                         "funcref_ptr",
-                    )
+                    ))
                 };
 
                 // a funcref (pointer to `anyfunc`)
-                let anyfunc_struct_ptr = self
-                    .builder
-                    .build_load(
-                        self.intrinsics.funcref_ty,
-                        funcref_ptr,
-                        "anyfunc_struct_ptr",
-                    )
-                    .into_pointer_value();
+                let anyfunc_struct_ptr = err!(self.builder.build_load(
+                    self.intrinsics.ptr_ty,
+                    funcref_ptr,
+                    "anyfunc_struct_ptr",
+                ))
+                .into_pointer_value();
 
                 // trap if we're trying to call a null funcref
                 {
-                    let funcref_not_null = self
+                    let funcref_not_null = err!(self
                         .builder
-                        .build_is_not_null(anyfunc_struct_ptr, "null funcref check");
+                        .build_is_not_null(anyfunc_struct_ptr, "null funcref check"));
 
                     let funcref_continue_deref_block = self
                         .context
@@ -2387,18 +2947,18 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     let funcref_is_null_block = self
                         .context
                         .append_basic_block(self.function, "funcref_is_null_block");
-                    self.builder.build_conditional_branch(
+                    err!(self.builder.build_conditional_branch(
                         funcref_not_null,
                         funcref_continue_deref_block,
                         funcref_is_null_block,
-                    );
+                    ));
                     self.builder.position_at_end(funcref_is_null_block);
-                    self.builder.build_call(
+                    err!(self.builder.build_call(
                         self.intrinsics.throw_trap,
                         &[self.intrinsics.trap_call_indirect_null.into()],
                         "throw",
-                    );
-                    self.builder.build_unreachable();
+                    ));
+                    err!(self.builder.build_unreachable());
                     self.builder.position_at_end(funcref_continue_deref_block);
                 }
 
@@ -2431,49 +2991,51 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     )
                     .unwrap();
                 let (func_ptr, found_dynamic_sigindex, ctx_ptr) = (
-                    self.builder
-                        .build_load(self.intrinsics.i8_ptr_ty, func_ptr_ptr, "func_ptr")
-                        .into_pointer_value(),
-                    self.builder
-                        .build_load(self.intrinsics.i32_ty, sigindex_ptr, "sigindex")
-                        .into_int_value(),
-                    self.builder
-                        .build_load(self.intrinsics.ctx_ptr_ty, ctx_ptr_ptr, "ctx_ptr"),
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.ptr_ty, func_ptr_ptr, "func_ptr"))
+                    .into_pointer_value(),
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i32_ty, sigindex_ptr, "sigindex"))
+                    .into_int_value(),
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.ptr_ty, ctx_ptr_ptr, "ctx_ptr")),
                 );
 
                 // Next, check if the table element is initialized.
 
                 // TODO: we may not need this check anymore
-                let elem_initialized = self.builder.build_is_not_null(func_ptr, "");
+                let elem_initialized = err!(self.builder.build_is_not_null(func_ptr, ""));
 
                 // Next, check if the signature id is correct.
 
-                let sigindices_equal = self.builder.build_int_compare(
+                let sigindices_equal = err!(self.builder.build_int_compare(
                     IntPredicate::EQ,
                     expected_dynamic_sigindex,
                     found_dynamic_sigindex,
                     "sigindices_equal",
-                );
+                ));
 
                 let initialized_and_sigindices_match =
-                    self.builder
-                        .build_and(elem_initialized, sigindices_equal, "");
+                    err!(self
+                        .builder
+                        .build_and(elem_initialized, sigindices_equal, ""));
 
                 // Tell llvm that `expected_dynamic_sigindex` should equal `found_dynamic_sigindex`.
-                let initialized_and_sigindices_match = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.expect_i1,
-                        &[
-                            initialized_and_sigindices_match.into(),
-                            self.intrinsics.i1_ty.const_int(1, false).into(),
-                        ],
-                        "initialized_and_sigindices_match_expect",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_int_value();
+                let initialized_and_sigindices_match = err!(self.builder.build_call(
+                    self.intrinsics.expect_i1,
+                    &[
+                        initialized_and_sigindices_match.into(),
+                        self.intrinsics.i1_ty.const_int(1, false).into(),
+                    ],
+                    "initialized_and_sigindices_match_expect",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_int_value();
 
                 let continue_block = self
                     .context
@@ -2481,121 +3043,49 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let sigindices_notequal_block = self
                     .context
                     .append_basic_block(self.function, "sigindices_notequal_block");
-                self.builder.build_conditional_branch(
+                err!(self.builder.build_conditional_branch(
                     initialized_and_sigindices_match,
                     continue_block,
                     sigindices_notequal_block,
-                );
+                ));
 
                 self.builder.position_at_end(sigindices_notequal_block);
-                let trap_code = self.builder.build_select(
+                let trap_code = err!(self.builder.build_select(
                     elem_initialized,
                     self.intrinsics.trap_call_indirect_sig,
                     self.intrinsics.trap_call_indirect_null,
                     "",
-                );
-                self.builder
-                    .build_call(self.intrinsics.throw_trap, &[trap_code.into()], "throw");
-                self.builder.build_unreachable();
+                ));
+                err!(self.builder.build_call(
+                    self.intrinsics.throw_trap,
+                    &[trap_code.into()],
+                    "throw"
+                ));
+                err!(self.builder.build_unreachable());
                 self.builder.position_at_end(continue_block);
 
-                let (llvm_func_type, llvm_func_attrs) = self.abi.func_type_to_llvm(
-                    self.context,
-                    self.intrinsics,
-                    Some(self.ctx.get_offsets()),
-                    func_type,
-                )?;
-
-                let params = self.state.popn_save_extra(func_type.params().len())?;
-
-                // Apply pending canonicalizations.
-                let params =
-                    params
-                        .iter()
-                        .zip(func_type.params().iter())
-                        .map(|((v, info), wasm_ty)| match wasm_ty {
-                            Type::F32 => self.builder.build_bitcast(
-                                self.apply_pending_canonicalization(*v, *info),
-                                self.intrinsics.f32_ty,
-                                "",
-                            ),
-                            Type::F64 => self.builder.build_bitcast(
-                                self.apply_pending_canonicalization(*v, *info),
-                                self.intrinsics.f64_ty,
-                                "",
-                            ),
-                            Type::V128 => self.apply_pending_canonicalization(*v, *info),
-                            _ => *v,
-                        });
-
-                let params = self.abi.args_to_call(
-                    &self.alloca_builder,
-                    func_type,
-                    &llvm_func_type,
-                    ctx_ptr.into_pointer_value(),
-                    params.collect::<Vec<_>>().as_slice(),
-                    self.intrinsics,
-                );
-
-                let typed_func_ptr = self.builder.build_pointer_cast(
-                    func_ptr,
-                    llvm_func_type.ptr_type(AddressSpace::default()),
-                    "typed_func_ptr",
-                );
+                if self.g0m0.is_some() {
+                    self.build_g0m0_indirect_call(
+                        table_index,
+                        ctx_ptr.into_pointer_value(),
+                        func_type,
+                        func_ptr,
+                        func_index,
+                    )?;
+                } else {
+                    let call_site = self.build_indirect_call(
+                        ctx_ptr.into_pointer_value(),
+                        func_type,
+                        func_ptr,
+                        None,
+                        None,
+                    )?;
 
-                /*
-                if self.track_state {
-                    if let Some(offset) = opcode_offset {
-                        let mut stackmaps = self.stackmaps.borrow_mut();
-                        emit_stack_map(
-                            &info,
-                            self.intrinsics,
-                            self.builder,
-                            self.index,
-                            &mut *stackmaps,
-                            StackmapEntryKind::Call,
-                            &self.locals,
-                            state,
-                            ctx,
-                            offset,
-                        )
-                    }
-                }
-                */
-                let call_site = self.builder.build_indirect_call(
-                    llvm_func_type,
-                    typed_func_ptr,
-                    params
+                    self.abi
+                        .rets_from_call(&self.builder, self.intrinsics, call_site, func_type)?
                         .iter()
-                        .copied()
-                        .map(Into::into)
-                        .collect::<Vec<BasicMetadataValueEnum>>()
-                        .as_slice(),
-                    "indirect_call",
-                );
-                for (attr, attr_loc) in llvm_func_attrs {
-                    call_site.add_attribute(attr_loc, attr);
-                }
-                /*
-                if self.track_state {
-                    if let Some(offset) = opcode_offset {
-                        let mut stackmaps = self.stackmaps.borrow_mut();
-                        finalize_opcode_stack_map(
-                            self.intrinsics,
-                            self.builder,
-                            self.index,
-                            &mut *stackmaps,
-                            StackmapEntryKind::Call,
-                            offset,
-                        )
-                    }
+                        .for_each(|ret| self.state.push1(*ret));
                 }
-                */
-
-                self.abi
-                    .rets_from_call(&self.builder, self.intrinsics, call_site, func_type)
-                    .iter()
-                    .for_each(|ret| self.state.push1(*ret));
             }
 
             /***************************
@@ -2604,26 +3094,30 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
              ***************************/
             Operator::I32Add | Operator::I64Add => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
-                let res = self.builder.build_int_add(v1, v2, "");
+                let res = err!(self.builder.build_int_add(v1, v2, ""));
                 self.state.push1(res);
             }
             Operator::I8x16Add => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let (v2, _) = self.v128_into_i8x16(v2, i2);
-                let res = self.builder.build_int_add(v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
+                let res = err!(self.builder.build_int_add(v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8Add => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
-                let res = self.builder.build_int_add(v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
+                let res = err!(self.builder.build_int_add(v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8ExtAddPairwiseI8x16S | Operator::I16x8ExtAddPairwiseI8x16U => {
@@ -2637,9 +3131,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     _ => unreachable!("Unhandled internal variant"),
                 };
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i8x16(v, i);
+                let (v, _) = self.v128_into_i8x16(v, i)?;
 
-                let left = self.builder.build_shuffle_vector(
+                let left = err!(self.builder.build_shuffle_vector(
                     v,
                     v.get_type().get_undef(),
                     VectorType::const_vector(&[
@@ -2653,9 +3147,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[14],
                     ]),
                     "",
-                );
-                let left = extend_op(self, left);
-                let right = self.builder.build_shuffle_vector(
+                ));
+                let left = err!(extend_op(self, left));
+                let right = err!(self.builder.build_shuffle_vector(
                     v,
                     v.get_type().get_undef(),
                     VectorType::const_vector(&[
@@ -2669,19 +3163,23 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[15],
                     ]),
                     "",
-                );
-                let right = extend_op(self, right);
+                ));
+                let right = err!(extend_op(self, right));
 
-                let res = self.builder.build_int_add(left, right, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self.builder.build_int_add(left, right, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4Add => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let (v2, _) = self.v128_into_i32x4(v2, i2);
-                let res = self.builder.build_int_add(v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_i32x4(v2, i2)?;
+                let res = err!(self.builder.build_int_add(v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4ExtAddPairwiseI16x8S | Operator::I32x4ExtAddPairwiseI16x8U => {
@@ -2695,9 +3193,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     _ => unreachable!("Unhandled internal variant"),
                 };
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i16x8(v, i);
+                let (v, _) = self.v128_into_i16x8(v, i)?;
 
-                let left = self.builder.build_shuffle_vector(
+                let left = err!(self.builder.build_shuffle_vector(
                     v,
                     v.get_type().get_undef(),
                     VectorType::const_vector(&[
@@ -2707,9 +3205,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[6],
                     ]),
                     "",
-                );
-                let left = extend_op(self, left);
-                let right = self.builder.build_shuffle_vector(
+                ));
+                let left = err!(extend_op(self, left));
+                let right = err!(self.builder.build_shuffle_vector(
                     v,
                     v.get_type().get_undef(),
                     VectorType::const_vector(&[
@@ -2719,243 +3217,293 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[7],
                     ]),
                     "",
-                );
-                let right = extend_op(self, right);
+                ));
+                let right = err!(extend_op(self, right));
 
-                let res = self.builder.build_int_add(left, right, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self.builder.build_int_add(left, right, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64x2Add => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i64x2(v1, i1);
-                let (v2, _) = self.v128_into_i64x2(v2, i2);
-                let res = self.builder.build_int_add(v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let (v1, _) = self.v128_into_i64x2(v1, i1)?;
+                let (v2, _) = self.v128_into_i64x2(v2, i2)?;
+                let res = err!(self.builder.build_int_add(v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I8x16AddSatS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let (v2, _) = self.v128_into_i8x16(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.sadd_sat_i8x16,
+                    &[v1.into(), v2.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
+                let res = err!(self
                     .builder
-                    .build_call(self.intrinsics.sadd_sat_i8x16, &[v1.into(), v2.into()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8AddSatS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.sadd_sat_i16x8,
+                    &[v1.into(), v2.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
+                let res = err!(self
                     .builder
-                    .build_call(self.intrinsics.sadd_sat_i16x8, &[v1.into(), v2.into()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I8x16AddSatU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let (v2, _) = self.v128_into_i8x16(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.uadd_sat_i8x16,
+                    &[v1.into(), v2.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
+                let res = err!(self
                     .builder
-                    .build_call(self.intrinsics.uadd_sat_i8x16, &[v1.into(), v2.into()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8AddSatU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.uadd_sat_i16x8,
+                    &[v1.into(), v2.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
+                let res = err!(self
                     .builder
-                    .build_call(self.intrinsics.uadd_sat_i16x8, &[v1.into(), v2.into()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32Sub | Operator::I64Sub => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
-                let res = self.builder.build_int_sub(v1, v2, "");
+                let res = err!(self.builder.build_int_sub(v1, v2, ""));
                 self.state.push1(res);
             }
             Operator::I8x16Sub => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let (v2, _) = self.v128_into_i8x16(v2, i2);
-                let res = self.builder.build_int_sub(v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
+                let res = err!(self.builder.build_int_sub(v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8Sub => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
-                let res = self.builder.build_int_sub(v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
+                let res = err!(self.builder.build_int_sub(v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4Sub => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let (v2, _) = self.v128_into_i32x4(v2, i2);
-                let res = self.builder.build_int_sub(v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_i32x4(v2, i2)?;
+                let res = err!(self.builder.build_int_sub(v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64x2Sub => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i64x2(v1, i1);
-                let (v2, _) = self.v128_into_i64x2(v2, i2);
-                let res = self.builder.build_int_sub(v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let (v1, _) = self.v128_into_i64x2(v1, i1)?;
+                let (v2, _) = self.v128_into_i64x2(v2, i2)?;
+                let res = err!(self.builder.build_int_sub(v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I8x16SubSatS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let (v2, _) = self.v128_into_i8x16(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.ssub_sat_i8x16,
+                    &[v1.into(), v2.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
+                let res = err!(self
                     .builder
-                    .build_call(self.intrinsics.ssub_sat_i8x16, &[v1.into(), v2.into()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8SubSatS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.ssub_sat_i16x8,
+                    &[v1.into(), v2.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
+                let res = err!(self
                     .builder
-                    .build_call(self.intrinsics.ssub_sat_i16x8, &[v1.into(), v2.into()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I8x16SubSatU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let (v2, _) = self.v128_into_i8x16(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.usub_sat_i8x16,
+                    &[v1.into(), v2.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
+                let res = err!(self
                     .builder
-                    .build_call(self.intrinsics.usub_sat_i8x16, &[v1.into(), v2.into()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8SubSatU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.usub_sat_i16x8,
+                    &[v1.into(), v2.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
+                let res = err!(self
                     .builder
-                    .build_call(self.intrinsics.usub_sat_i16x8, &[v1.into(), v2.into()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32Mul | Operator::I64Mul => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
-                let res = self.builder.build_int_mul(v1, v2, "");
+                let res = err!(self.builder.build_int_mul(v1, v2, ""));
                 self.state.push1(res);
             }
             Operator::I16x8Mul => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
-                let res = self.builder.build_int_mul(v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
+                let res = err!(self.builder.build_int_mul(v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4Mul => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let (v2, _) = self.v128_into_i32x4(v2, i2);
-                let res = self.builder.build_int_mul(v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_i32x4(v2, i2)?;
+                let res = err!(self.builder.build_int_mul(v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64x2Mul => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i64x2(v1, i1);
-                let (v2, _) = self.v128_into_i64x2(v2, i2);
-                let res = self.builder.build_int_mul(v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let (v1, _) = self.v128_into_i64x2(v1, i1)?;
+                let (v2, _) = self.v128_into_i64x2(v2, i2)?;
+                let res = err!(self.builder.build_int_mul(v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8Q15MulrSatS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
 
-                let max_value = self
-                    .intrinsics
-                    .i16_ty
-                    .const_int(i16::max_value() as u64, false);
+                let max_value = self.intrinsics.i16_ty.const_int(i16::MAX as u64, false);
                 let max_values = VectorType::const_vector(&[max_value; 8]);
 
-                let v1 = self
+                let v1 = err!(self
                     .builder
-                    .build_int_s_extend(v1, self.intrinsics.i32x8_ty, "");
-                let v2 = self
+                    .build_int_s_extend(v1, self.intrinsics.i32x8_ty, ""));
+                let v2 = err!(self
                     .builder
-                    .build_int_s_extend(v2, self.intrinsics.i32x8_ty, "");
-                let res = self.builder.build_int_mul(v1, v2, "");
+                    .build_int_s_extend(v2, self.intrinsics.i32x8_ty, ""));
+                let res = err!(self.builder.build_int_mul(v1, v2, ""));
 
                 // magic number specified by the spec
                 let bit = self.intrinsics.i32_ty.const_int(0x4000, false);
                 let bits = VectorType::const_vector(&[bit; 8]);
 
-                let res = self.builder.build_int_add(res, bits, "");
+                let res = err!(self.builder.build_int_add(res, bits, ""));
 
                 let fifteen = self.intrinsics.i32_consts[15];
                 let fifteens = VectorType::const_vector(&[fifteen; 8]);
 
-                let res = self.builder.build_right_shift(res, fifteens, true, "");
+                let res = err!(self.builder.build_right_shift(res, fifteens, true, ""));
                 let saturate_up = {
-                    let max_values =
-                        self.builder
-                            .build_int_s_extend(max_values, self.intrinsics.i32x8_ty, "");
-                    self.builder
-                        .build_int_compare(IntPredicate::SGT, res, max_values, "")
+                    let max_values = err!(self.builder.build_int_s_extend(
+                        max_values,
+                        self.intrinsics.i32x8_ty,
+                        ""
+                    ));
+                    err!(self
+                        .builder
+                        .build_int_compare(IntPredicate::SGT, res, max_values, ""))
                 };
 
-                let res = self
+                let res = err!(self
                     .builder
-                    .build_int_truncate(res, self.intrinsics.i16x8_ty, "");
+                    .build_int_truncate(res, self.intrinsics.i16x8_ty, ""));
 
-                let res = self
-                    .builder
-                    .build_select(saturate_up, max_values, res, "")
+                let res = err!(self.builder.build_select(saturate_up, max_values, res, ""))
                     .into_vector_value();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8ExtMulLowI8x16S
@@ -2964,10 +3512,14 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             | Operator::I16x8ExtMulHighI8x16U => {
                 let extend_op = match op {
                     Operator::I16x8ExtMulLowI8x16S | Operator::I16x8ExtMulHighI8x16S => {
-                        |s: &Self, v| s.builder.build_int_s_extend(v, s.intrinsics.i16x8_ty, "")
+                        |s: &Self, v| -> Result<VectorValue, CompileError> {
+                            err_nt!(s.builder.build_int_s_extend(v, s.intrinsics.i16x8_ty, ""))
+                        }
                     }
                     Operator::I16x8ExtMulLowI8x16U | Operator::I16x8ExtMulHighI8x16U => {
-                        |s: &Self, v| s.builder.build_int_z_extend(v, s.intrinsics.i16x8_ty, "")
+                        |s: &Self, v| -> Result<VectorValue, CompileError> {
+                            err_nt!(s.builder.build_int_z_extend(v, s.intrinsics.i16x8_ty, ""))
+                        }
                     }
                     _ => unreachable!("Unhandled internal variant"),
                 };
@@ -2995,24 +3547,26 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     _ => unreachable!("Unhandled internal variant"),
                 };
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let (v2, _) = self.v128_into_i8x16(v2, i2);
-                let val1 = self.builder.build_shuffle_vector(
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
+                let val1 = err!(self.builder.build_shuffle_vector(
                     v1,
                     v1.get_type().get_undef(),
                     VectorType::const_vector(&shuffle_array),
                     "",
-                );
-                let val1 = extend_op(self, val1);
-                let val2 = self.builder.build_shuffle_vector(
+                ));
+                let val1 = err!(extend_op(self, val1));
+                let val2 = err!(self.builder.build_shuffle_vector(
                     v2,
                     v2.get_type().get_undef(),
                     VectorType::const_vector(&shuffle_array),
                     "",
-                );
-                let val2 = extend_op(self, val2);
-                let res = self.builder.build_int_mul(val1, val2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                ));
+                let val2 = err!(extend_op(self, val2));
+                let res = err!(self.builder.build_int_mul(val1, val2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4ExtMulLowI16x8S
@@ -3044,24 +3598,26 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     _ => unreachable!("Unhandled internal variant"),
                 };
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
-                let val1 = self.builder.build_shuffle_vector(
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
+                let val1 = err!(self.builder.build_shuffle_vector(
                     v1,
                     v1.get_type().get_undef(),
                     VectorType::const_vector(&shuffle_array),
                     "",
-                );
-                let val1 = extend_op(self, val1);
-                let val2 = self.builder.build_shuffle_vector(
+                ));
+                let val1 = err!(extend_op(self, val1));
+                let val2 = err!(self.builder.build_shuffle_vector(
                     v2,
                     v2.get_type().get_undef(),
                     VectorType::const_vector(&shuffle_array),
                     "",
-                );
-                let val2 = extend_op(self, val2);
-                let res = self.builder.build_int_mul(val1, val2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                ));
+                let val2 = err!(extend_op(self, val2));
+                let res = err!(self.builder.build_int_mul(val1, val2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64x2ExtMulLowI32x4S
@@ -3087,30 +3643,32 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     _ => unreachable!("Unhandled internal variant"),
                 };
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let (v2, _) = self.v128_into_i32x4(v2, i2);
-                let val1 = self.builder.build_shuffle_vector(
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_i32x4(v2, i2)?;
+                let val1 = err!(self.builder.build_shuffle_vector(
                     v1,
                     v1.get_type().get_undef(),
                     VectorType::const_vector(&shuffle_array),
                     "",
-                );
-                let val1 = extend_op(self, val1);
-                let val2 = self.builder.build_shuffle_vector(
+                ));
+                let val1 = err!(extend_op(self, val1));
+                let val2 = err!(self.builder.build_shuffle_vector(
                     v2,
                     v2.get_type().get_undef(),
                     VectorType::const_vector(&shuffle_array),
                     "",
-                );
-                let val2 = extend_op(self, val2);
-                let res = self.builder.build_int_mul(val1, val2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                ));
+                let val2 = err!(extend_op(self, val2));
+                let res = err!(self.builder.build_int_mul(val1, val2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4DotI16x8S => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
                 let low_i16 = [
                     self.intrinsics.i32_consts[0],
                     self.intrinsics.i32_consts[2],
@@ -3123,90 +3681,96 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     self.intrinsics.i32_consts[5],
                     self.intrinsics.i32_consts[7],
                 ];
-                let v1_low = self.builder.build_shuffle_vector(
+                let v1_low = err!(self.builder.build_shuffle_vector(
                     v1,
                     v1.get_type().get_undef(),
                     VectorType::const_vector(&low_i16),
                     "",
-                );
-                let v1_low = self
-                    .builder
-                    .build_int_s_extend(v1_low, self.intrinsics.i32x4_ty, "");
-                let v1_high = self.builder.build_shuffle_vector(
+                ));
+                let v1_low =
+                    err!(self
+                        .builder
+                        .build_int_s_extend(v1_low, self.intrinsics.i32x4_ty, ""));
+                let v1_high = err!(self.builder.build_shuffle_vector(
                     v1,
                     v1.get_type().get_undef(),
                     VectorType::const_vector(&high_i16),
                     "",
-                );
+                ));
                 let v1_high =
-                    self.builder
-                        .build_int_s_extend(v1_high, self.intrinsics.i32x4_ty, "");
-                let v2_low = self.builder.build_shuffle_vector(
+                    err!(self
+                        .builder
+                        .build_int_s_extend(v1_high, self.intrinsics.i32x4_ty, ""));
+                let v2_low = err!(self.builder.build_shuffle_vector(
                     v2,
                     v2.get_type().get_undef(),
                     VectorType::const_vector(&low_i16),
                     "",
-                );
-                let v2_low = self
-                    .builder
-                    .build_int_s_extend(v2_low, self.intrinsics.i32x4_ty, "");
-                let v2_high = self.builder.build_shuffle_vector(
+                ));
+                let v2_low =
+                    err!(self
+                        .builder
+                        .build_int_s_extend(v2_low, self.intrinsics.i32x4_ty, ""));
+                let v2_high = err!(self.builder.build_shuffle_vector(
                     v2,
                     v2.get_type().get_undef(),
                     VectorType::const_vector(&high_i16),
                     "",
-                );
+                ));
                 let v2_high =
-                    self.builder
-                        .build_int_s_extend(v2_high, self.intrinsics.i32x4_ty, "");
-                let low_product = self.builder.build_int_mul(v1_low, v2_low, "");
-                let high_product = self.builder.build_int_mul(v1_high, v2_high, "");
+                    err!(self
+                        .builder
+                        .build_int_s_extend(v2_high, self.intrinsics.i32x4_ty, ""));
+                let low_product = err!(self.builder.build_int_mul(v1_low, v2_low, ""));
+                let high_product = err!(self.builder.build_int_mul(v1_high, v2_high, ""));
 
-                let res = self.builder.build_int_add(low_product, high_product, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self.builder.build_int_add(low_product, high_product, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32DivS | Operator::I64DivS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
 
-                self.trap_if_zero_or_overflow(v1, v2);
+                self.trap_if_zero_or_overflow(v1, v2)?;
 
-                let res = self.builder.build_int_signed_div(v1, v2, "");
+                let res = err!(self.builder.build_int_signed_div(v1, v2, ""));
                 self.state.push1(res);
             }
             Operator::I32DivU | Operator::I64DivU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
 
-                self.trap_if_zero(v2);
+                self.trap_if_zero(v2)?;
 
-                let res = self.builder.build_int_unsigned_div(v1, v2, "");
+                let res = err!(self.builder.build_int_unsigned_div(v1, v2, ""));
                 self.state.push1(res);
             }
             Operator::I32RemS | Operator::I64RemS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
                 let int_type = v1.get_type();
                 let (min_value, neg_one_value) = if int_type == self.intrinsics.i32_ty {
-                    let min_value = int_type.const_int(i32::min_value() as u64, false);
+                    let min_value = int_type.const_int(i32::MIN as u64, false);
                     let neg_one_value = int_type.const_int(-1i32 as u32 as u64, false);
                     (min_value, neg_one_value)
                 } else if int_type == self.intrinsics.i64_ty {
-                    let min_value = int_type.const_int(i64::min_value() as u64, false);
+                    let min_value = int_type.const_int(i64::MIN as u64, false);
                     let neg_one_value = int_type.const_int(-1i64 as u64, false);
                     (min_value, neg_one_value)
                 } else {
                     unreachable!()
                 };
 
-                self.trap_if_zero(v2);
+                self.trap_if_zero(v2)?;
 
                 // "Overflow also leads to undefined behavior; this is a rare
                 // case, but can occur, for example, by taking the remainder of
@@ -3219,546 +3783,577 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 // In Wasm, the i32.rem_s i32.const -2147483648 i32.const -1 is
                 // i32.const 0. We implement this by swapping out the left value
                 // for 0 in this case.
-                let will_overflow = self.builder.build_and(
-                    self.builder
-                        .build_int_compare(IntPredicate::EQ, v1, min_value, "left_is_min"),
-                    self.builder.build_int_compare(
+                let will_overflow = err!(self.builder.build_and(
+                    err!(self.builder.build_int_compare(
+                        IntPredicate::EQ,
+                        v1,
+                        min_value,
+                        "left_is_min"
+                    )),
+                    err!(self.builder.build_int_compare(
                         IntPredicate::EQ,
                         v2,
                         neg_one_value,
                         "right_is_neg_one",
-                    ),
+                    )),
                     "srem_will_overflow",
-                );
-                let v1 = self
-                    .builder
-                    .build_select(will_overflow, int_type.const_zero(), v1, "")
+                ));
+                let v1 =
+                    err!(self
+                        .builder
+                        .build_select(will_overflow, int_type.const_zero(), v1, ""))
                     .into_int_value();
-                let res = self.builder.build_int_signed_rem(v1, v2, "");
+                let res = err!(self.builder.build_int_signed_rem(v1, v2, ""));
                 self.state.push1(res);
             }
             Operator::I32RemU | Operator::I64RemU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
 
-                self.trap_if_zero(v2);
+                self.trap_if_zero(v2)?;
 
-                let res = self.builder.build_int_unsigned_rem(v1, v2, "");
+                let res = err!(self.builder.build_int_unsigned_rem(v1, v2, ""));
                 self.state.push1(res);
             }
             Operator::I32And | Operator::I64And | Operator::V128And => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
-                let res = self.builder.build_and(v1, v2, "");
+                let res = err!(self.builder.build_and(v1, v2, ""));
                 self.state.push1(res);
             }
             Operator::I32Or | Operator::I64Or | Operator::V128Or => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
-                let res = self.builder.build_or(v1, v2, "");
+                let res = err!(self.builder.build_or(v1, v2, ""));
                 self.state.push1(res);
             }
             Operator::I32Xor | Operator::I64Xor | Operator::V128Xor => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
-                let res = self.builder.build_xor(v1, v2, "");
+                let res = err!(self.builder.build_xor(v1, v2, ""));
                 self.state.push1(res);
             }
             Operator::V128AndNot => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
-                let v2 = self.builder.build_not(v2, "");
-                let res = self.builder.build_and(v1, v2, "");
+                let v2 = err!(self.builder.build_not(v2, ""));
+                let res = err!(self.builder.build_and(v1, v2, ""));
                 self.state.push1(res);
             }
             Operator::V128Bitselect => {
                 let ((v1, i1), (v2, i2), (cond, cond_info)) = self.state.pop3_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
-                let cond = self.apply_pending_canonicalization(cond, cond_info);
-                let v1 = self
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
+                let cond = self.apply_pending_canonicalization(cond, cond_info)?;
+                let v1 = err!(self
                     .builder
-                    .build_bitcast(v1, self.intrinsics.i1x128_ty, "")
-                    .into_vector_value();
-                let v2 = self
+                    .build_bit_cast(v1, self.intrinsics.i1x128_ty, ""))
+                .into_vector_value();
+                let v2 = err!(self
                     .builder
-                    .build_bitcast(v2, self.intrinsics.i1x128_ty, "")
-                    .into_vector_value();
-                let cond = self
+                    .build_bit_cast(v2, self.intrinsics.i1x128_ty, ""))
+                .into_vector_value();
+                let cond = err!(self
                     .builder
-                    .build_bitcast(cond, self.intrinsics.i1x128_ty, "")
-                    .into_vector_value();
-                let res = self.builder.build_select(cond, v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(cond, self.intrinsics.i1x128_ty, ""))
+                .into_vector_value();
+                let res = err!(self.builder.build_select(cond, v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I8x16Bitmask => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i8x16(v, i);
+                let (v, _) = self.v128_into_i8x16(v, i)?;
 
                 let zeros = self.intrinsics.i8x16_ty.const_zero();
-                let res = self
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SLT, v, zeros, "");
-                let res = self
-                    .builder
-                    .build_bitcast(res, self.intrinsics.i16_ty, "")
+                    .build_int_compare(IntPredicate::SLT, v, zeros, ""));
+                let res = err!(self.builder.build_bit_cast(res, self.intrinsics.i16_ty, ""))
                     .into_int_value();
-                let res = self
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(res, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(res, self.intrinsics.i32_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8Bitmask => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i16x8(v, i);
+                let (v, _) = self.v128_into_i16x8(v, i)?;
 
                 let zeros = self.intrinsics.i16x8_ty.const_zero();
-                let res = self
-                    .builder
-                    .build_int_compare(IntPredicate::SLT, v, zeros, "");
-                let res = self
+                let res = err!(self
                     .builder
-                    .build_bitcast(res, self.intrinsics.i8_ty, "")
+                    .build_int_compare(IntPredicate::SLT, v, zeros, ""));
+                let res = err!(self.builder.build_bit_cast(res, self.intrinsics.i8_ty, ""))
                     .into_int_value();
-                let res = self
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(res, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(res, self.intrinsics.i32_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4Bitmask => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i32x4(v, i);
+                let (v, _) = self.v128_into_i32x4(v, i)?;
 
                 let zeros = self.intrinsics.i32x4_ty.const_zero();
-                let res = self
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SLT, v, zeros, "");
-                let res = self
-                    .builder
-                    .build_bitcast(res, self.intrinsics.i4_ty, "")
+                    .build_int_compare(IntPredicate::SLT, v, zeros, ""));
+                let res = err!(self.builder.build_bit_cast(res, self.intrinsics.i4_ty, ""))
                     .into_int_value();
-                let res = self
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(res, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(res, self.intrinsics.i32_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64x2Bitmask => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i64x2(v, i);
+                let (v, _) = self.v128_into_i64x2(v, i)?;
 
                 let zeros = self.intrinsics.i64x2_ty.const_zero();
-                let res = self
-                    .builder
-                    .build_int_compare(IntPredicate::SLT, v, zeros, "");
-                let res = self
+                let res = err!(self
                     .builder
-                    .build_bitcast(res, self.intrinsics.i2_ty, "")
+                    .build_int_compare(IntPredicate::SLT, v, zeros, ""));
+                let res = err!(self.builder.build_bit_cast(res, self.intrinsics.i2_ty, ""))
                     .into_int_value();
-                let res = self
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(res, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(res, self.intrinsics.i32_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32Shl => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
                 let mask = self.intrinsics.i32_ty.const_int(31u64, false);
-                let v2 = self.builder.build_and(v2, mask, "");
-                let res = self.builder.build_left_shift(v1, v2, "");
+                let v2 = err!(self.builder.build_and(v2, mask, ""));
+                let res = err!(self.builder.build_left_shift(v1, v2, ""));
                 self.state.push1(res);
             }
             Operator::I64Shl => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
                 let mask = self.intrinsics.i64_ty.const_int(63u64, false);
-                let v2 = self.builder.build_and(v2, mask, "");
-                let res = self.builder.build_left_shift(v1, v2, "");
+                let v2 = err!(self.builder.build_and(v2, mask, ""));
+                let res = err!(self.builder.build_left_shift(v1, v2, ""));
                 self.state.push1(res);
             }
             Operator::I8x16Shl => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let v2 = v2.into_int_value();
-                let v2 = self
+                let v2 = err!(self
                     .builder
-                    .build_and(v2, self.intrinsics.i32_consts[7], "");
-                let v2 = self
+                    .build_and(v2, self.intrinsics.i32_consts[7], ""));
+                let v2 = err!(self
                     .builder
-                    .build_int_truncate(v2, self.intrinsics.i8_ty, "");
-                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i8x16_ty);
-                let res = self.builder.build_left_shift(v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_truncate(v2, self.intrinsics.i8_ty, ""));
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i8x16_ty)?;
+                let res = err!(self.builder.build_left_shift(v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8Shl => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let v2 = v2.into_int_value();
-                let v2 = self
+                let v2 = err!(self
+                    .builder
+                    .build_and(v2, self.intrinsics.i32_consts[15], ""));
+                let v2 = err!(self
                     .builder
-                    .build_and(v2, self.intrinsics.i32_consts[15], "");
-                let v2 = self
+                    .build_int_truncate(v2, self.intrinsics.i16_ty, ""));
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i16x8_ty)?;
+                let res = err!(self.builder.build_left_shift(v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_truncate(v2, self.intrinsics.i16_ty, "");
-                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i16x8_ty);
-                let res = self.builder.build_left_shift(v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4Shl => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let v2 = v2.into_int_value();
-                let v2 =
-                    self.builder
-                        .build_and(v2, self.intrinsics.i32_ty.const_int(31, false), "");
-                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i32x4_ty);
-                let res = self.builder.build_left_shift(v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let v2 = err!(self.builder.build_and(
+                    v2,
+                    self.intrinsics.i32_ty.const_int(31, false),
+                    ""
+                ));
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i32x4_ty)?;
+                let res = err!(self.builder.build_left_shift(v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64x2Shl => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i64x2(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, _) = self.v128_into_i64x2(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let v2 = v2.into_int_value();
-                let v2 =
-                    self.builder
-                        .build_and(v2, self.intrinsics.i32_ty.const_int(63, false), "");
-                let v2 = self
+                let v2 = err!(self.builder.build_and(
+                    v2,
+                    self.intrinsics.i32_ty.const_int(63, false),
+                    ""
+                ));
+                let v2 = err!(self
+                    .builder
+                    .build_int_z_extend(v2, self.intrinsics.i64_ty, ""));
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i64x2_ty)?;
+                let res = err!(self.builder.build_left_shift(v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(v2, self.intrinsics.i64_ty, "");
-                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i64x2_ty);
-                let res = self.builder.build_left_shift(v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32ShrS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
                 let mask = self.intrinsics.i32_ty.const_int(31u64, false);
-                let v2 = self.builder.build_and(v2, mask, "");
-                let res = self.builder.build_right_shift(v1, v2, true, "");
+                let v2 = err!(self.builder.build_and(v2, mask, ""));
+                let res = err!(self.builder.build_right_shift(v1, v2, true, ""));
                 self.state.push1(res);
             }
             Operator::I64ShrS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
                 let mask = self.intrinsics.i64_ty.const_int(63u64, false);
-                let v2 = self.builder.build_and(v2, mask, "");
-                let res = self.builder.build_right_shift(v1, v2, true, "");
+                let v2 = err!(self.builder.build_and(v2, mask, ""));
+                let res = err!(self.builder.build_right_shift(v1, v2, true, ""));
                 self.state.push1(res);
             }
             Operator::I8x16ShrS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let v2 = v2.into_int_value();
-                let v2 = self
+                let v2 = err!(self
                     .builder
-                    .build_and(v2, self.intrinsics.i32_consts[7], "");
-                let v2 = self
+                    .build_and(v2, self.intrinsics.i32_consts[7], ""));
+                let v2 = err!(self
                     .builder
-                    .build_int_truncate(v2, self.intrinsics.i8_ty, "");
-                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i8x16_ty);
-                let res = self.builder.build_right_shift(v1, v2, true, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_truncate(v2, self.intrinsics.i8_ty, ""));
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i8x16_ty)?;
+                let res = err!(self.builder.build_right_shift(v1, v2, true, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8ShrS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let v2 = v2.into_int_value();
-                let v2 = self
+                let v2 = err!(self
+                    .builder
+                    .build_and(v2, self.intrinsics.i32_consts[15], ""));
+                let v2 = err!(self
                     .builder
-                    .build_and(v2, self.intrinsics.i32_consts[15], "");
-                let v2 = self
+                    .build_int_truncate(v2, self.intrinsics.i16_ty, ""));
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i16x8_ty)?;
+                let res = err!(self.builder.build_right_shift(v1, v2, true, ""));
+                let res = err!(self
                     .builder
-                    .build_int_truncate(v2, self.intrinsics.i16_ty, "");
-                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i16x8_ty);
-                let res = self.builder.build_right_shift(v1, v2, true, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4ShrS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let v2 = v2.into_int_value();
-                let v2 =
-                    self.builder
-                        .build_and(v2, self.intrinsics.i32_ty.const_int(31, false), "");
-                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i32x4_ty);
-                let res = self.builder.build_right_shift(v1, v2, true, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let v2 = err!(self.builder.build_and(
+                    v2,
+                    self.intrinsics.i32_ty.const_int(31, false),
+                    ""
+                ));
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i32x4_ty)?;
+                let res = err!(self.builder.build_right_shift(v1, v2, true, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64x2ShrS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i64x2(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, _) = self.v128_into_i64x2(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let v2 = v2.into_int_value();
-                let v2 =
-                    self.builder
-                        .build_and(v2, self.intrinsics.i32_ty.const_int(63, false), "");
-                let v2 = self
+                let v2 = err!(self.builder.build_and(
+                    v2,
+                    self.intrinsics.i32_ty.const_int(63, false),
+                    ""
+                ));
+                let v2 = err!(self
+                    .builder
+                    .build_int_z_extend(v2, self.intrinsics.i64_ty, ""));
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i64x2_ty)?;
+                let res = err!(self.builder.build_right_shift(v1, v2, true, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(v2, self.intrinsics.i64_ty, "");
-                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i64x2_ty);
-                let res = self.builder.build_right_shift(v1, v2, true, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32ShrU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
                 let mask = self.intrinsics.i32_ty.const_int(31u64, false);
-                let v2 = self.builder.build_and(v2, mask, "");
-                let res = self.builder.build_right_shift(v1, v2, false, "");
+                let v2 = err!(self.builder.build_and(v2, mask, ""));
+                let res = err!(self.builder.build_right_shift(v1, v2, false, ""));
                 self.state.push1(res);
             }
             Operator::I64ShrU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
                 let mask = self.intrinsics.i64_ty.const_int(63u64, false);
-                let v2 = self.builder.build_and(v2, mask, "");
-                let res = self.builder.build_right_shift(v1, v2, false, "");
+                let v2 = err!(self.builder.build_and(v2, mask, ""));
+                let res = err!(self.builder.build_right_shift(v1, v2, false, ""));
                 self.state.push1(res);
             }
             Operator::I8x16ShrU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let v2 = v2.into_int_value();
-                let v2 = self
+                let v2 = err!(self
                     .builder
-                    .build_and(v2, self.intrinsics.i32_consts[7], "");
-                let v2 = self
+                    .build_and(v2, self.intrinsics.i32_consts[7], ""));
+                let v2 = err!(self
                     .builder
-                    .build_int_truncate(v2, self.intrinsics.i8_ty, "");
-                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i8x16_ty);
-                let res = self.builder.build_right_shift(v1, v2, false, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_truncate(v2, self.intrinsics.i8_ty, ""));
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i8x16_ty)?;
+                let res = err!(self.builder.build_right_shift(v1, v2, false, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8ShrU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let v2 = v2.into_int_value();
-                let v2 = self
+                let v2 = err!(self
+                    .builder
+                    .build_and(v2, self.intrinsics.i32_consts[15], ""));
+                let v2 = err!(self
                     .builder
-                    .build_and(v2, self.intrinsics.i32_consts[15], "");
-                let v2 = self
+                    .build_int_truncate(v2, self.intrinsics.i16_ty, ""));
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i16x8_ty)?;
+                let res = err!(self.builder.build_right_shift(v1, v2, false, ""));
+                let res = err!(self
                     .builder
-                    .build_int_truncate(v2, self.intrinsics.i16_ty, "");
-                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i16x8_ty);
-                let res = self.builder.build_right_shift(v1, v2, false, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4ShrU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let v2 = v2.into_int_value();
-                let v2 =
-                    self.builder
-                        .build_and(v2, self.intrinsics.i32_ty.const_int(31, false), "");
-                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i32x4_ty);
-                let res = self.builder.build_right_shift(v1, v2, false, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let v2 = err!(self.builder.build_and(
+                    v2,
+                    self.intrinsics.i32_ty.const_int(31, false),
+                    ""
+                ));
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i32x4_ty)?;
+                let res = err!(self.builder.build_right_shift(v1, v2, false, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64x2ShrU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i64x2(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, _) = self.v128_into_i64x2(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let v2 = v2.into_int_value();
-                let v2 =
-                    self.builder
-                        .build_and(v2, self.intrinsics.i32_ty.const_int(63, false), "");
-                let v2 = self
+                let v2 = err!(self.builder.build_and(
+                    v2,
+                    self.intrinsics.i32_ty.const_int(63, false),
+                    ""
+                ));
+                let v2 = err!(self
+                    .builder
+                    .build_int_z_extend(v2, self.intrinsics.i64_ty, ""));
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i64x2_ty)?;
+                let res = err!(self.builder.build_right_shift(v1, v2, false, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(v2, self.intrinsics.i64_ty, "");
-                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i64x2_ty);
-                let res = self.builder.build_right_shift(v1, v2, false, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32Rotl => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
                 let mask = self.intrinsics.i32_ty.const_int(31u64, false);
-                let v2 = self.builder.build_and(v2, mask, "");
-                let lhs = self.builder.build_left_shift(v1, v2, "");
+                let v2 = err!(self.builder.build_and(v2, mask, ""));
+                let lhs = err!(self.builder.build_left_shift(v1, v2, ""));
                 let rhs = {
-                    let negv2 = self.builder.build_int_neg(v2, "");
-                    let rhs = self.builder.build_and(negv2, mask, "");
-                    self.builder.build_right_shift(v1, rhs, false, "")
+                    let negv2 = err!(self.builder.build_int_neg(v2, ""));
+                    let rhs = err!(self.builder.build_and(negv2, mask, ""));
+                    err!(self.builder.build_right_shift(v1, rhs, false, ""))
                 };
-                let res = self.builder.build_or(lhs, rhs, "");
+                let res = err!(self.builder.build_or(lhs, rhs, ""));
                 self.state.push1(res);
             }
             Operator::I64Rotl => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
                 let mask = self.intrinsics.i64_ty.const_int(63u64, false);
-                let v2 = self.builder.build_and(v2, mask, "");
-                let lhs = self.builder.build_left_shift(v1, v2, "");
+                let v2 = err!(self.builder.build_and(v2, mask, ""));
+                let lhs = err!(self.builder.build_left_shift(v1, v2, ""));
                 let rhs = {
-                    let negv2 = self.builder.build_int_neg(v2, "");
-                    let rhs = self.builder.build_and(negv2, mask, "");
-                    self.builder.build_right_shift(v1, rhs, false, "")
+                    let negv2 = err!(self.builder.build_int_neg(v2, ""));
+                    let rhs = err!(self.builder.build_and(negv2, mask, ""));
+                    err!(self.builder.build_right_shift(v1, rhs, false, ""))
                 };
-                let res = self.builder.build_or(lhs, rhs, "");
+                let res = err!(self.builder.build_or(lhs, rhs, ""));
                 self.state.push1(res);
             }
             Operator::I32Rotr => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
                 let mask = self.intrinsics.i32_ty.const_int(31u64, false);
-                let v2 = self.builder.build_and(v2, mask, "");
-                let lhs = self.builder.build_right_shift(v1, v2, false, "");
+                let v2 = err!(self.builder.build_and(v2, mask, ""));
+                let lhs = err!(self.builder.build_right_shift(v1, v2, false, ""));
                 let rhs = {
-                    let negv2 = self.builder.build_int_neg(v2, "");
-                    let rhs = self.builder.build_and(negv2, mask, "");
-                    self.builder.build_left_shift(v1, rhs, "")
+                    let negv2 = err!(self.builder.build_int_neg(v2, ""));
+                    let rhs = err!(self.builder.build_and(negv2, mask, ""));
+                    err!(self.builder.build_left_shift(v1, rhs, ""))
                 };
-                let res = self.builder.build_or(lhs, rhs, "");
+                let res = err!(self.builder.build_or(lhs, rhs, ""));
                 self.state.push1(res);
             }
             Operator::I64Rotr => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
                 let mask = self.intrinsics.i64_ty.const_int(63u64, false);
-                let v2 = self.builder.build_and(v2, mask, "");
-                let lhs = self.builder.build_right_shift(v1, v2, false, "");
+                let v2 = err!(self.builder.build_and(v2, mask, ""));
+                let lhs = err!(self.builder.build_right_shift(v1, v2, false, ""));
                 let rhs = {
-                    let negv2 = self.builder.build_int_neg(v2, "");
-                    let rhs = self.builder.build_and(negv2, mask, "");
-                    self.builder.build_left_shift(v1, rhs, "")
+                    let negv2 = err!(self.builder.build_int_neg(v2, ""));
+                    let rhs = err!(self.builder.build_and(negv2, mask, ""));
+                    err!(self.builder.build_left_shift(v1, rhs, ""))
                 };
-                let res = self.builder.build_or(lhs, rhs, "");
+                let res = err!(self.builder.build_or(lhs, rhs, ""));
                 self.state.push1(res);
             }
             Operator::I32Clz => {
                 let (input, info) = self.state.pop1_extra()?;
-                let input = self.apply_pending_canonicalization(input, info);
+                let input = self.apply_pending_canonicalization(input, info)?;
                 let is_zero_undef = self.intrinsics.i1_zero;
-                let res = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.ctlz_i32,
-                        &[input.into(), is_zero_undef.into()],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.ctlz_i32,
+                    &[input.into(), is_zero_undef.into()],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 self.state.push1_extra(res, ExtraInfo::arithmetic_f32());
             }
             Operator::I64Clz => {
                 let (input, info) = self.state.pop1_extra()?;
-                let input = self.apply_pending_canonicalization(input, info);
+                let input = self.apply_pending_canonicalization(input, info)?;
                 let is_zero_undef = self.intrinsics.i1_zero;
-                let res = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.ctlz_i64,
-                        &[input.into(), is_zero_undef.into()],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.ctlz_i64,
+                    &[input.into(), is_zero_undef.into()],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 self.state.push1_extra(res, ExtraInfo::arithmetic_f64());
             }
             Operator::I32Ctz => {
                 let (input, info) = self.state.pop1_extra()?;
-                let input = self.apply_pending_canonicalization(input, info);
+                let input = self.apply_pending_canonicalization(input, info)?;
                 let is_zero_undef = self.intrinsics.i1_zero;
-                let res = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cttz_i32,
-                        &[input.into(), is_zero_undef.into()],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.cttz_i32,
+                    &[input.into(), is_zero_undef.into()],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 self.state.push1_extra(res, ExtraInfo::arithmetic_f32());
             }
             Operator::I64Ctz => {
                 let (input, info) = self.state.pop1_extra()?;
-                let input = self.apply_pending_canonicalization(input, info);
+                let input = self.apply_pending_canonicalization(input, info)?;
                 let is_zero_undef = self.intrinsics.i1_zero;
-                let res = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cttz_i64,
-                        &[input.into(), is_zero_undef.into()],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.cttz_i64,
+                    &[input.into(), is_zero_undef.into()],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 self.state.push1_extra(res, ExtraInfo::arithmetic_f64());
             }
             Operator::I8x16Popcnt => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i8x16(v, i);
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.ctpop_i8x16, &[v.into()], "")
+                let (v, _) = self.v128_into_i8x16(v, i)?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.ctpop_i8x16, &[v.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32Popcnt => {
                 let (input, info) = self.state.pop1_extra()?;
-                let input = self.apply_pending_canonicalization(input, info);
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.ctpop_i32, &[input.into()], "")
+                let input = self.apply_pending_canonicalization(input, info)?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.ctpop_i32, &[input.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
@@ -3766,10 +4361,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             }
             Operator::I64Popcnt => {
                 let (input, info) = self.state.pop1_extra()?;
-                let input = self.apply_pending_canonicalization(input, info);
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.ctpop_i64, &[input.into()], "")
+                let input = self.apply_pending_canonicalization(input, info)?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.ctpop_i64, &[input.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
@@ -3777,214 +4373,246 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             }
             Operator::I32Eqz => {
                 let input = self.state.pop1()?.into_int_value();
-                let cond = self.builder.build_int_compare(
+                let cond = err!(self.builder.build_int_compare(
                     IntPredicate::EQ,
                     input,
                     self.intrinsics.i32_zero,
                     "",
-                );
-                let res = self
+                ));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(res, ExtraInfo::arithmetic_f32());
             }
             Operator::I64Eqz => {
                 let input = self.state.pop1()?.into_int_value();
-                let cond = self.builder.build_int_compare(
+                let cond = err!(self.builder.build_int_compare(
                     IntPredicate::EQ,
                     input,
                     self.intrinsics.i64_zero,
                     "",
-                );
-                let res = self
+                ));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(res, ExtraInfo::arithmetic_f64());
             }
             Operator::I8x16Abs => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i8x16(v, i);
+                let (v, _) = self.v128_into_i8x16(v, i)?;
 
                 let seven = self.intrinsics.i8_ty.const_int(7, false);
                 let seven = VectorType::const_vector(&[seven; 16]);
-                let all_sign_bits = self.builder.build_right_shift(v, seven, true, "");
-                let xor = self.builder.build_xor(v, all_sign_bits, "");
-                let res = self.builder.build_int_sub(xor, all_sign_bits, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let all_sign_bits = err!(self.builder.build_right_shift(v, seven, true, ""));
+                let xor = err!(self.builder.build_xor(v, all_sign_bits, ""));
+                let res = err!(self.builder.build_int_sub(xor, all_sign_bits, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8Abs => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i16x8(v, i);
+                let (v, _) = self.v128_into_i16x8(v, i)?;
 
                 let fifteen = self.intrinsics.i16_ty.const_int(15, false);
                 let fifteen = VectorType::const_vector(&[fifteen; 8]);
-                let all_sign_bits = self.builder.build_right_shift(v, fifteen, true, "");
-                let xor = self.builder.build_xor(v, all_sign_bits, "");
-                let res = self.builder.build_int_sub(xor, all_sign_bits, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let all_sign_bits = err!(self.builder.build_right_shift(v, fifteen, true, ""));
+                let xor = err!(self.builder.build_xor(v, all_sign_bits, ""));
+                let res = err!(self.builder.build_int_sub(xor, all_sign_bits, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4Abs => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i32x4(v, i);
+                let (v, _) = self.v128_into_i32x4(v, i)?;
 
                 let thirtyone = self.intrinsics.i32_ty.const_int(31, false);
                 let thirtyone = VectorType::const_vector(&[thirtyone; 4]);
-                let all_sign_bits = self.builder.build_right_shift(v, thirtyone, true, "");
-                let xor = self.builder.build_xor(v, all_sign_bits, "");
-                let res = self.builder.build_int_sub(xor, all_sign_bits, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let all_sign_bits = err!(self.builder.build_right_shift(v, thirtyone, true, ""));
+                let xor = err!(self.builder.build_xor(v, all_sign_bits, ""));
+                let res = err!(self.builder.build_int_sub(xor, all_sign_bits, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64x2Abs => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i64x2(v, i);
+                let (v, _) = self.v128_into_i64x2(v, i)?;
 
                 let sixtythree = self.intrinsics.i64_ty.const_int(63, false);
                 let sixtythree = VectorType::const_vector(&[sixtythree; 2]);
-                let all_sign_bits = self.builder.build_right_shift(v, sixtythree, true, "");
-                let xor = self.builder.build_xor(v, all_sign_bits, "");
-                let res = self.builder.build_int_sub(xor, all_sign_bits, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let all_sign_bits = err!(self.builder.build_right_shift(v, sixtythree, true, ""));
+                let xor = err!(self.builder.build_xor(v, all_sign_bits, ""));
+                let res = err!(self.builder.build_int_sub(xor, all_sign_bits, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I8x16MinS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let (v2, _) = self.v128_into_i8x16(v2, i2);
-                let cmp = self
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
+                let cmp = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SLT, v1, v2, "");
-                let res = self.builder.build_select(cmp, v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_compare(IntPredicate::SLT, v1, v2, ""));
+                let res = err!(self.builder.build_select(cmp, v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I8x16MinU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let (v2, _) = self.v128_into_i8x16(v2, i2);
-                let cmp = self
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
+                let cmp = err!(self
+                    .builder
+                    .build_int_compare(IntPredicate::ULT, v1, v2, ""));
+                let res = err!(self.builder.build_select(cmp, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::ULT, v1, v2, "");
-                let res = self.builder.build_select(cmp, v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I8x16MaxS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let (v2, _) = self.v128_into_i8x16(v2, i2);
-                let cmp = self
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
+                let cmp = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SGT, v1, v2, "");
-                let res = self.builder.build_select(cmp, v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_compare(IntPredicate::SGT, v1, v2, ""));
+                let res = err!(self.builder.build_select(cmp, v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I8x16MaxU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let (v2, _) = self.v128_into_i8x16(v2, i2);
-                let cmp = self
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
+                let cmp = err!(self
+                    .builder
+                    .build_int_compare(IntPredicate::UGT, v1, v2, ""));
+                let res = err!(self.builder.build_select(cmp, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::UGT, v1, v2, "");
-                let res = self.builder.build_select(cmp, v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8MinS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
-                let cmp = self
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
+                let cmp = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SLT, v1, v2, "");
-                let res = self.builder.build_select(cmp, v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_compare(IntPredicate::SLT, v1, v2, ""));
+                let res = err!(self.builder.build_select(cmp, v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8MinU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
-                let cmp = self
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
+                let cmp = err!(self
+                    .builder
+                    .build_int_compare(IntPredicate::ULT, v1, v2, ""));
+                let res = err!(self.builder.build_select(cmp, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::ULT, v1, v2, "");
-                let res = self.builder.build_select(cmp, v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8MaxS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
-                let cmp = self
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
+                let cmp = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SGT, v1, v2, "");
-                let res = self.builder.build_select(cmp, v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_compare(IntPredicate::SGT, v1, v2, ""));
+                let res = err!(self.builder.build_select(cmp, v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8MaxU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
-                let cmp = self
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
+                let cmp = err!(self
+                    .builder
+                    .build_int_compare(IntPredicate::UGT, v1, v2, ""));
+                let res = err!(self.builder.build_select(cmp, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::UGT, v1, v2, "");
-                let res = self.builder.build_select(cmp, v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4MinS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let (v2, _) = self.v128_into_i32x4(v2, i2);
-                let cmp = self
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_i32x4(v2, i2)?;
+                let cmp = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SLT, v1, v2, "");
-                let res = self.builder.build_select(cmp, v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_compare(IntPredicate::SLT, v1, v2, ""));
+                let res = err!(self.builder.build_select(cmp, v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4MinU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let (v2, _) = self.v128_into_i32x4(v2, i2);
-                let cmp = self
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_i32x4(v2, i2)?;
+                let cmp = err!(self
+                    .builder
+                    .build_int_compare(IntPredicate::ULT, v1, v2, ""));
+                let res = err!(self.builder.build_select(cmp, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::ULT, v1, v2, "");
-                let res = self.builder.build_select(cmp, v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4MaxS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let (v2, _) = self.v128_into_i32x4(v2, i2);
-                let cmp = self
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_i32x4(v2, i2)?;
+                let cmp = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SGT, v1, v2, "");
-                let res = self.builder.build_select(cmp, v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_compare(IntPredicate::SGT, v1, v2, ""));
+                let res = err!(self.builder.build_select(cmp, v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4MaxU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let (v2, _) = self.v128_into_i32x4(v2, i2);
-                let cmp = self
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_i32x4(v2, i2)?;
+                let cmp = err!(self
+                    .builder
+                    .build_int_compare(IntPredicate::UGT, v1, v2, ""));
+                let res = err!(self.builder.build_select(cmp, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::UGT, v1, v2, "");
-                let res = self.builder.build_select(cmp, v1, v2, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I8x16AvgrU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let (v2, _) = self.v128_into_i8x16(v2, i2);
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
 
                 // This approach is faster on x86-64 when the PAVG[BW]
                 // instructions are available. On other platforms, an alternative
@@ -4000,22 +4628,26 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let one = self.intrinsics.i16_ty.const_int(1, false);
                 let one = VectorType::const_vector(&[one; 16]);
 
-                let v1 = self.builder.build_int_z_extend(v1, ext_ty, "");
-                let v2 = self.builder.build_int_z_extend(v2, ext_ty, "");
-                let res =
-                    self.builder
-                        .build_int_add(self.builder.build_int_add(one, v1, ""), v2, "");
-                let res = self.builder.build_right_shift(res, one, false, "");
-                let res = self
+                let v1 = err!(self.builder.build_int_z_extend(v1, ext_ty, ""));
+                let v2 = err!(self.builder.build_int_z_extend(v2, ext_ty, ""));
+                let res = err!(self.builder.build_int_add(
+                    err!(self.builder.build_int_add(one, v1, "")),
+                    v2,
+                    ""
+                ));
+                let res = err!(self.builder.build_right_shift(res, one, false, ""));
+                let res = err!(self
                     .builder
-                    .build_int_truncate(res, self.intrinsics.i8x16_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_truncate(res, self.intrinsics.i8x16_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8AvgrU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
 
                 // This approach is faster on x86-64 when the PAVG[BW]
                 // instructions are available. On other platforms, an alternative
@@ -4031,16 +4663,20 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let one = self.intrinsics.i32_consts[1];
                 let one = VectorType::const_vector(&[one; 8]);
 
-                let v1 = self.builder.build_int_z_extend(v1, ext_ty, "");
-                let v2 = self.builder.build_int_z_extend(v2, ext_ty, "");
-                let res =
-                    self.builder
-                        .build_int_add(self.builder.build_int_add(one, v1, ""), v2, "");
-                let res = self.builder.build_right_shift(res, one, false, "");
-                let res = self
+                let v1 = err!(self.builder.build_int_z_extend(v1, ext_ty, ""));
+                let v2 = err!(self.builder.build_int_z_extend(v2, ext_ty, ""));
+                let res = err!(self.builder.build_int_add(
+                    err!(self.builder.build_int_add(one, v1, "")),
+                    v2,
+                    ""
+                ));
+                let res = err!(self.builder.build_right_shift(res, one, false, ""));
+                let res = err!(self
+                    .builder
+                    .build_int_truncate(res, self.intrinsics.i16x8_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_truncate(res, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
 
@@ -4050,380 +4686,365 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
              ***************************/
             Operator::F32Add => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let res = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.add_f32,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_rounding_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.add_f32,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_rounding_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 self.state.push1_extra(
                     res,
-                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f32_nan(),
+                    ((i1.strip_pending() & i2.strip_pending())? | ExtraInfo::pending_f32_nan())?,
                 );
             }
             Operator::F64Add => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
                 let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
-                let res = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.add_f64,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_rounding_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.add_f64,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_rounding_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 self.state.push1_extra(
                     res,
-                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f64_nan(),
+                    ((i1.strip_pending() & i2.strip_pending())? | ExtraInfo::pending_f64_nan())?,
                 );
             }
             Operator::F32x4Add => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, i1) = self.v128_into_f32x4(v1, i1);
-                let (v2, i2) = self.v128_into_f32x4(v2, i2);
-                let res = self
+                let (v1, i1) = self.v128_into_f32x4(v1, i1)?;
+                let (v2, i2) = self.v128_into_f32x4(v2, i2)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.add_f32x4,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_rounding_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
+                let res = err!(self
                     .builder
-                    .build_call(
-                        self.intrinsics.add_f32x4,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_rounding_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1_extra(
                     res,
-                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f32_nan(),
+                    ((i1.strip_pending() & i2.strip_pending())? | ExtraInfo::pending_f32_nan())?,
                 );
             }
             Operator::F64x2Add => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, i1) = self.v128_into_f64x2(v1, i1);
-                let (v2, i2) = self.v128_into_f64x2(v2, i2);
-                let res = self
+                let (v1, i1) = self.v128_into_f64x2(v1, i1)?;
+                let (v2, i2) = self.v128_into_f64x2(v2, i2)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.add_f64x2,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_rounding_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
+                let res = err!(self
                     .builder
-                    .build_call(
-                        self.intrinsics.add_f64x2,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_rounding_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1_extra(
                     res,
-                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f64_nan(),
+                    ((i1.strip_pending() & i2.strip_pending())? | ExtraInfo::pending_f64_nan())?,
                 );
             }
             Operator::F32Sub => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
                 let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
-                let res = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.sub_f32,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_rounding_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.sub_f32,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_rounding_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 self.state.push1_extra(
                     res,
-                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f32_nan(),
+                    ((i1.strip_pending() & i2.strip_pending())? | ExtraInfo::pending_f32_nan())?,
                 );
             }
             Operator::F64Sub => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
                 let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
-                let res = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.sub_f64,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_rounding_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.sub_f64,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_rounding_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 self.state.push1_extra(
                     res,
-                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f64_nan(),
+                    ((i1.strip_pending() & i2.strip_pending())? | ExtraInfo::pending_f64_nan())?,
                 );
             }
             Operator::F32x4Sub => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, i1) = self.v128_into_f32x4(v1, i1);
-                let (v2, i2) = self.v128_into_f32x4(v2, i2);
-                let res = self
+                let (v1, i1) = self.v128_into_f32x4(v1, i1)?;
+                let (v2, i2) = self.v128_into_f32x4(v2, i2)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.sub_f32x4,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_rounding_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
+                let res = err!(self
                     .builder
-                    .build_call(
-                        self.intrinsics.sub_f32x4,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_rounding_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1_extra(
                     res,
-                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f32_nan(),
+                    ((i1.strip_pending() & i2.strip_pending())? | ExtraInfo::pending_f32_nan())?,
                 );
             }
             Operator::F64x2Sub => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, i1) = self.v128_into_f64x2(v1, i1);
-                let (v2, i2) = self.v128_into_f64x2(v2, i2);
-                let res = self
+                let (v1, i1) = self.v128_into_f64x2(v1, i1)?;
+                let (v2, i2) = self.v128_into_f64x2(v2, i2)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.sub_f64x2,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_rounding_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
+                let res = err!(self
                     .builder
-                    .build_call(
-                        self.intrinsics.sub_f64x2,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_rounding_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1_extra(
                     res,
-                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f64_nan(),
+                    ((i1.strip_pending() & i2.strip_pending())? | ExtraInfo::pending_f64_nan())?,
                 );
             }
             Operator::F32Mul => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
                 let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
-                let res = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.mul_f32,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_rounding_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.mul_f32,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_rounding_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 self.state.push1_extra(
                     res,
-                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f32_nan(),
+                    ((i1.strip_pending() & i2.strip_pending())? | ExtraInfo::pending_f32_nan())?,
                 );
             }
             Operator::F64Mul => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
                 let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
-                let res = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.mul_f64,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_rounding_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.mul_f64,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_rounding_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 self.state.push1_extra(
                     res,
-                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f64_nan(),
+                    ((i1.strip_pending() & i2.strip_pending())? | ExtraInfo::pending_f64_nan())?,
                 );
             }
             Operator::F32x4Mul => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, i1) = self.v128_into_f32x4(v1, i1);
-                let (v2, i2) = self.v128_into_f32x4(v2, i2);
-                let res = self
+                let (v1, i1) = self.v128_into_f32x4(v1, i1)?;
+                let (v2, i2) = self.v128_into_f32x4(v2, i2)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.mul_f32x4,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_rounding_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
+                let res = err!(self
                     .builder
-                    .build_call(
-                        self.intrinsics.mul_f32x4,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_rounding_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1_extra(
                     res,
-                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f32_nan(),
+                    ((i1.strip_pending() & i2.strip_pending())? | ExtraInfo::pending_f32_nan())?,
                 );
             }
             Operator::F64x2Mul => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, i1) = self.v128_into_f64x2(v1, i1);
-                let (v2, i2) = self.v128_into_f64x2(v2, i2);
-                let res = self
+                let (v1, i1) = self.v128_into_f64x2(v1, i1)?;
+                let (v2, i2) = self.v128_into_f64x2(v2, i2)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.mul_f64x2,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_rounding_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
+                let res = err!(self
                     .builder
-                    .build_call(
-                        self.intrinsics.mul_f64x2,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_rounding_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1_extra(
                     res,
-                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f64_nan(),
+                    ((i1.strip_pending() & i2.strip_pending())? | ExtraInfo::pending_f64_nan())?,
                 );
             }
             Operator::F32Div => {
                 let (v1, v2) = self.state.pop2()?;
                 let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
-                let res = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.div_f32,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_rounding_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.div_f32,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_rounding_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 self.state.push1_extra(res, ExtraInfo::pending_f32_nan());
             }
             Operator::F64Div => {
                 let (v1, v2) = self.state.pop2()?;
                 let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
-                let res = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.div_f64,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_rounding_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.div_f64,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_rounding_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 self.state.push1_extra(res, ExtraInfo::pending_f64_nan());
             }
             Operator::F32x4Div => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_f32x4(v1, i1);
-                let (v2, _) = self.v128_into_f32x4(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_f32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_f32x4(v2, i2)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.div_f32x4,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_rounding_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
+                let res = err!(self
                     .builder
-                    .build_call(
-                        self.intrinsics.div_f32x4,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_rounding_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1_extra(res, ExtraInfo::pending_f32_nan());
             }
             Operator::F64x2Div => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_f64x2(v1, i1);
-                let (v2, _) = self.v128_into_f64x2(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_f64x2(v1, i1)?;
+                let (v2, _) = self.v128_into_f64x2(v2, i2)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.div_f64x2,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_rounding_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
+                let res = err!(self
                     .builder
-                    .build_call(
-                        self.intrinsics.div_f64x2,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_rounding_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1_extra(res, ExtraInfo::pending_f64_nan());
             }
             Operator::F32Sqrt => {
                 let input = self.state.pop1()?;
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.sqrt_f32, &[input.into()], "")
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.sqrt_f32, &[input.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
@@ -4431,9 +5052,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             }
             Operator::F64Sqrt => {
                 let input = self.state.pop1()?;
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.sqrt_f64, &[input.into()], "")
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.sqrt_f64, &[input.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
@@ -4441,30 +5063,32 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             }
             Operator::F32x4Sqrt => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_f32x4(v, i);
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.sqrt_f32x4, &[v.into()], "")
+                let (v, _) = self.v128_into_f32x4(v, i)?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.sqrt_f32x4, &[v.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
-                let bits = self
+                let bits = err!(self
                     .builder
-                    .build_bitcast(res, self.intrinsics.i128_ty, "bits");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, "bits"));
                 self.state.push1_extra(bits, ExtraInfo::pending_f32_nan());
             }
             Operator::F64x2Sqrt => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_f64x2(v, i);
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.sqrt_f64x2, &[v.into()], "")
+                let (v, _) = self.v128_into_f64x2(v, i)?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.sqrt_f64x2, &[v.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
-                let bits = self
+                let bits = err!(self
                     .builder
-                    .build_bitcast(res, self.intrinsics.i128_ty, "bits");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, "bits"));
                 self.state.push1(bits);
             }
             Operator::F32Min => {
@@ -4472,107 +5096,105 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 // intrinsic would, but x86 lowering of that intrinsic
                 // encounters a fatal error in LLVM 11.
                 let (v1, v2) = self.state.pop2()?;
-                let v1 = self.canonicalize_nans(v1);
-                let v2 = self.canonicalize_nans(v2);
+                let v1 = self.canonicalize_nans(v1)?;
+                let v2 = self.canonicalize_nans(v2)?;
 
-                let v1_is_nan = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f32,
-                        &[
-                            v1.into(),
-                            self.intrinsics.f32_zero.into(),
-                            self.intrinsics.fp_uno_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_int_value();
-                let v2_is_nan = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f32,
-                        &[
-                            v2.into(),
-                            self.intrinsics.f32_zero.into(),
-                            self.intrinsics.fp_uno_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_int_value();
-                let v1_lt_v2 = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f32,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_olt_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_int_value();
-                let v1_gt_v2 = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f32,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_ogt_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_int_value();
+                let v1_is_nan = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f32,
+                    &[
+                        v1.into(),
+                        self.intrinsics.f32_zero.into(),
+                        self.intrinsics.fp_uno_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_int_value();
+                let v2_is_nan = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f32,
+                    &[
+                        v2.into(),
+                        self.intrinsics.f32_zero.into(),
+                        self.intrinsics.fp_uno_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_int_value();
+                let v1_lt_v2 = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f32,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_olt_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_int_value();
+                let v1_gt_v2 = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f32,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_ogt_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_int_value();
 
-                let res = self.builder.build_select(
+                let res = err!(self.builder.build_select(
                     v1_is_nan,
-                    self.quiet_nan(v1),
-                    self.builder.build_select(
+                    self.quiet_nan(v1)?,
+                    err!(self.builder.build_select(
                         v2_is_nan,
-                        self.quiet_nan(v2),
-                        self.builder.build_select(
+                        self.quiet_nan(v2)?,
+                        err!(self.builder.build_select(
                             v1_lt_v2,
                             v1,
-                            self.builder.build_select(
+                            err!(self.builder.build_select(
                                 v1_gt_v2,
                                 v2,
-                                self.builder.build_bitcast(
-                                    self.builder.build_or(
-                                        self.builder
-                                            .build_bitcast(v1, self.intrinsics.i32_ty, "")
-                                            .into_int_value(),
-                                        self.builder
-                                            .build_bitcast(v2, self.intrinsics.i32_ty, "")
-                                            .into_int_value(),
+                                err!(self.builder.build_bit_cast(
+                                    err!(self.builder.build_or(
+                                        err!(self.builder.build_bit_cast(
+                                            v1,
+                                            self.intrinsics.i32_ty,
+                                            ""
+                                        ))
+                                        .into_int_value(),
+                                        err!(self.builder.build_bit_cast(
+                                            v2,
+                                            self.intrinsics.i32_ty,
+                                            ""
+                                        ))
+                                        .into_int_value(),
                                         "",
-                                    ),
+                                    )),
                                     self.intrinsics.f32_ty,
                                     "",
-                                ),
+                                )),
                                 "",
-                            ),
+                            )),
                             "",
-                        ),
+                        )),
                         "",
-                    ),
+                    )),
                     "",
-                );
+                ));
 
                 self.state.push1(res);
             }
@@ -4581,107 +5203,105 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 // intrinsic would, but x86 lowering of that intrinsic
                 // encounters a fatal error in LLVM 11.
                 let (v1, v2) = self.state.pop2()?;
-                let v1 = self.canonicalize_nans(v1);
-                let v2 = self.canonicalize_nans(v2);
+                let v1 = self.canonicalize_nans(v1)?;
+                let v2 = self.canonicalize_nans(v2)?;
 
-                let v1_is_nan = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f64,
-                        &[
-                            v1.into(),
-                            self.intrinsics.f64_zero.into(),
-                            self.intrinsics.fp_uno_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_int_value();
-                let v2_is_nan = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f64,
-                        &[
-                            v2.into(),
-                            self.intrinsics.f64_zero.into(),
-                            self.intrinsics.fp_uno_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_int_value();
-                let v1_lt_v2 = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f64,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_olt_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_int_value();
-                let v1_gt_v2 = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f64,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_ogt_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_int_value();
+                let v1_is_nan = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f64,
+                    &[
+                        v1.into(),
+                        self.intrinsics.f64_zero.into(),
+                        self.intrinsics.fp_uno_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_int_value();
+                let v2_is_nan = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f64,
+                    &[
+                        v2.into(),
+                        self.intrinsics.f64_zero.into(),
+                        self.intrinsics.fp_uno_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_int_value();
+                let v1_lt_v2 = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f64,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_olt_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_int_value();
+                let v1_gt_v2 = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f64,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_ogt_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_int_value();
 
-                let res = self.builder.build_select(
+                let res = err!(self.builder.build_select(
                     v1_is_nan,
-                    self.quiet_nan(v1),
-                    self.builder.build_select(
+                    self.quiet_nan(v1)?,
+                    err!(self.builder.build_select(
                         v2_is_nan,
-                        self.quiet_nan(v2),
-                        self.builder.build_select(
+                        self.quiet_nan(v2)?,
+                        err!(self.builder.build_select(
                             v1_lt_v2,
                             v1,
-                            self.builder.build_select(
+                            err!(self.builder.build_select(
                                 v1_gt_v2,
                                 v2,
-                                self.builder.build_bitcast(
-                                    self.builder.build_or(
-                                        self.builder
-                                            .build_bitcast(v1, self.intrinsics.i64_ty, "")
-                                            .into_int_value(),
-                                        self.builder
-                                            .build_bitcast(v2, self.intrinsics.i64_ty, "")
-                                            .into_int_value(),
+                                err!(self.builder.build_bit_cast(
+                                    err!(self.builder.build_or(
+                                        err!(self.builder.build_bit_cast(
+                                            v1,
+                                            self.intrinsics.i64_ty,
+                                            ""
+                                        ))
+                                        .into_int_value(),
+                                        err!(self.builder.build_bit_cast(
+                                            v2,
+                                            self.intrinsics.i64_ty,
+                                            ""
+                                        ))
+                                        .into_int_value(),
                                         "",
-                                    ),
+                                    )),
                                     self.intrinsics.f64_ty,
                                     "",
-                                ),
+                                )),
                                 "",
-                            ),
+                            )),
                             "",
-                        ),
+                        )),
                         "",
-                    ),
+                    )),
                     "",
-                );
+                ));
 
                 self.state.push1(res);
             }
@@ -4690,125 +5310,125 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 // intrinsic would, but x86 lowering of that intrinsic
                 // encounters a fatal error in LLVM 11.
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_f32x4(v1, i1);
-                let (v2, _) = self.v128_into_f32x4(v2, i2);
+                let (v1, _) = self.v128_into_f32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_f32x4(v2, i2)?;
 
-                let v1_is_nan = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f32x4,
-                        &[
-                            v1.into(),
-                            self.intrinsics.f32x4_zero.into(),
-                            self.intrinsics.fp_uno_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_vector_value();
-                let v2_is_nan = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f32x4,
-                        &[
-                            v2.into(),
-                            self.intrinsics.f32x4_zero.into(),
-                            self.intrinsics.fp_uno_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_vector_value();
-                let v1_lt_v2 = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f32x4,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_olt_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_vector_value();
-                let v1_gt_v2 = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f32x4,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_ogt_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_vector_value();
+                let v1_is_nan = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f32x4,
+                    &[
+                        v1.into(),
+                        self.intrinsics.f32x4_zero.into(),
+                        self.intrinsics.fp_uno_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_vector_value();
+                let v2_is_nan = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f32x4,
+                    &[
+                        v2.into(),
+                        self.intrinsics.f32x4_zero.into(),
+                        self.intrinsics.fp_uno_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_vector_value();
+                let v1_lt_v2 = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f32x4,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_olt_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_vector_value();
+                let v1_gt_v2 = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f32x4,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_ogt_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_vector_value();
 
-                let res = self.builder.build_select(
+                let res = err!(self.builder.build_select(
                     v1_is_nan,
-                    self.quiet_nan(v1.into()).into_vector_value(),
-                    self.builder
-                        .build_select(
-                            v2_is_nan,
-                            self.quiet_nan(v2.into()).into_vector_value(),
-                            self.builder
-                                .build_select(
-                                    v1_lt_v2,
-                                    v1.into(),
-                                    self.builder.build_select(
-                                        v1_gt_v2,
-                                        v2.into(),
-                                        self.builder.build_bitcast(
-                                            self.builder.build_or(
-                                                self.builder
-                                                    .build_bitcast(v1, self.intrinsics.i32x4_ty, "")
-                                                    .into_vector_value(),
-                                                self.builder
-                                                    .build_bitcast(v2, self.intrinsics.i32x4_ty, "")
-                                                    .into_vector_value(),
-                                                "",
-                                            ),
-                                            self.intrinsics.f32x4_ty,
+                    self.quiet_nan(v1.into())?.into_vector_value(),
+                    err!(self.builder.build_select(
+                        v2_is_nan,
+                        self.quiet_nan(v2.into())?.into_vector_value(),
+                        err!(self.builder.build_select(
+                            v1_lt_v2,
+                            v1.into(),
+                            err!(self.builder.build_select(
+                                v1_gt_v2,
+                                v2.into(),
+                                err!(self.builder.build_bit_cast(
+                                    err!(self.builder.build_or(
+                                        err!(self.builder.build_bit_cast(
+                                            v1,
+                                            self.intrinsics.i32x4_ty,
+                                            "",
+                                        ))
+                                        .into_vector_value(),
+                                        err!(self.builder.build_bit_cast(
+                                            v2,
+                                            self.intrinsics.i32x4_ty,
                                             "",
-                                        ),
+                                        ))
+                                        .into_vector_value(),
                                         "",
-                                    ),
+                                    )),
+                                    self.intrinsics.f32x4_ty,
                                     "",
-                                )
-                                .into_vector_value(),
+                                )),
+                                "",
+                            )),
                             "",
-                        )
+                        ))
                         .into_vector_value(),
+                        "",
+                    ))
+                    .into_vector_value(),
                     "",
-                );
+                ));
 
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::F32x4PMin => {
                 // Pseudo-min: b < a ? b : a
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _i1) = self.v128_into_f32x4(v1, i1);
-                let (v2, _i2) = self.v128_into_f32x4(v2, i2);
-                let cmp = self
+                let (v1, _i1) = self.v128_into_f32x4(v1, i1)?;
+                let (v2, _i2) = self.v128_into_f32x4(v2, i2)?;
+                let cmp = err!(self
                     .builder
-                    .build_float_compare(FloatPredicate::OLT, v2, v1, "");
-                let res = self.builder.build_select(cmp, v2, v1, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_float_compare(FloatPredicate::OLT, v2, v1, ""));
+                let res = err!(self.builder.build_select(cmp, v2, v1, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::F64x2Min => {
@@ -4816,125 +5436,125 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 // intrinsic would, but x86 lowering of that intrinsic
                 // encounters a fatal error in LLVM 11.
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_f64x2(v1, i1);
-                let (v2, _) = self.v128_into_f64x2(v2, i2);
+                let (v1, _) = self.v128_into_f64x2(v1, i1)?;
+                let (v2, _) = self.v128_into_f64x2(v2, i2)?;
 
-                let v1_is_nan = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f64x2,
-                        &[
-                            v1.into(),
-                            self.intrinsics.f64x2_zero.into(),
-                            self.intrinsics.fp_uno_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_vector_value();
-                let v2_is_nan = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f64x2,
-                        &[
-                            v2.into(),
-                            self.intrinsics.f64x2_zero.into(),
-                            self.intrinsics.fp_uno_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_vector_value();
-                let v1_lt_v2 = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f64x2,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_olt_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_vector_value();
-                let v1_gt_v2 = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f64x2,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_ogt_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_vector_value();
+                let v1_is_nan = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f64x2,
+                    &[
+                        v1.into(),
+                        self.intrinsics.f64x2_zero.into(),
+                        self.intrinsics.fp_uno_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_vector_value();
+                let v2_is_nan = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f64x2,
+                    &[
+                        v2.into(),
+                        self.intrinsics.f64x2_zero.into(),
+                        self.intrinsics.fp_uno_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_vector_value();
+                let v1_lt_v2 = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f64x2,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_olt_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_vector_value();
+                let v1_gt_v2 = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f64x2,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_ogt_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_vector_value();
 
-                let res = self.builder.build_select(
+                let res = err!(self.builder.build_select(
                     v1_is_nan,
-                    self.quiet_nan(v1.into()).into_vector_value(),
-                    self.builder
-                        .build_select(
-                            v2_is_nan,
-                            self.quiet_nan(v2.into()).into_vector_value(),
-                            self.builder
-                                .build_select(
-                                    v1_lt_v2,
-                                    v1.into(),
-                                    self.builder.build_select(
-                                        v1_gt_v2,
-                                        v2.into(),
-                                        self.builder.build_bitcast(
-                                            self.builder.build_or(
-                                                self.builder
-                                                    .build_bitcast(v1, self.intrinsics.i64x2_ty, "")
-                                                    .into_vector_value(),
-                                                self.builder
-                                                    .build_bitcast(v2, self.intrinsics.i64x2_ty, "")
-                                                    .into_vector_value(),
-                                                "",
-                                            ),
-                                            self.intrinsics.f64x2_ty,
+                    self.quiet_nan(v1.into())?.into_vector_value(),
+                    err!(self.builder.build_select(
+                        v2_is_nan,
+                        self.quiet_nan(v2.into())?.into_vector_value(),
+                        err!(self.builder.build_select(
+                            v1_lt_v2,
+                            v1.into(),
+                            err!(self.builder.build_select(
+                                v1_gt_v2,
+                                v2.into(),
+                                err!(self.builder.build_bit_cast(
+                                    err!(self.builder.build_or(
+                                        err!(self.builder.build_bit_cast(
+                                            v1,
+                                            self.intrinsics.i64x2_ty,
                                             "",
-                                        ),
+                                        ))
+                                        .into_vector_value(),
+                                        err!(self.builder.build_bit_cast(
+                                            v2,
+                                            self.intrinsics.i64x2_ty,
+                                            "",
+                                        ))
+                                        .into_vector_value(),
                                         "",
-                                    ),
+                                    )),
+                                    self.intrinsics.f64x2_ty,
                                     "",
-                                )
-                                .into_vector_value(),
+                                )),
+                                "",
+                            )),
                             "",
-                        )
+                        ))
                         .into_vector_value(),
+                        "",
+                    ))
+                    .into_vector_value(),
                     "",
-                );
+                ));
 
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::F64x2PMin => {
                 // Pseudo-min: b < a ? b : a
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _i1) = self.v128_into_f64x2(v1, i1);
-                let (v2, _i2) = self.v128_into_f64x2(v2, i2);
-                let cmp = self
+                let (v1, _i1) = self.v128_into_f64x2(v1, i1)?;
+                let (v2, _i2) = self.v128_into_f64x2(v2, i2)?;
+                let cmp = err!(self
+                    .builder
+                    .build_float_compare(FloatPredicate::OLT, v2, v1, ""));
+                let res = err!(self.builder.build_select(cmp, v2, v1, ""));
+                let res = err!(self
                     .builder
-                    .build_float_compare(FloatPredicate::OLT, v2, v1, "");
-                let res = self.builder.build_select(cmp, v2, v1, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::F32Max => {
@@ -4942,216 +5562,212 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 // intrinsic would, but x86 lowering of that intrinsic
                 // encounters a fatal error in LLVM 11.
                 let (v1, v2) = self.state.pop2()?;
-                let v1 = self.canonicalize_nans(v1);
-                let v2 = self.canonicalize_nans(v2);
+                let v1 = self.canonicalize_nans(v1)?;
+                let v2 = self.canonicalize_nans(v2)?;
 
-                let v1_is_nan = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f32,
-                        &[
-                            v1.into(),
-                            self.intrinsics.f32_zero.into(),
-                            self.intrinsics.fp_uno_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_int_value();
-                let v2_is_nan = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f32,
-                        &[
-                            v2.into(),
-                            self.intrinsics.f32_zero.into(),
-                            self.intrinsics.fp_uno_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_int_value();
-                let v1_lt_v2 = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f32,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_olt_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_int_value();
-                let v1_gt_v2 = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f32,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_ogt_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_int_value();
+                let v1_is_nan = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f32,
+                    &[
+                        v1.into(),
+                        self.intrinsics.f32_zero.into(),
+                        self.intrinsics.fp_uno_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_int_value();
+                let v2_is_nan = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f32,
+                    &[
+                        v2.into(),
+                        self.intrinsics.f32_zero.into(),
+                        self.intrinsics.fp_uno_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_int_value();
+                let v1_lt_v2 = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f32,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_olt_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_int_value();
+                let v1_gt_v2 = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f32,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_ogt_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_int_value();
 
-                let res = self.builder.build_select(
+                let res = err!(self.builder.build_select(
                     v1_is_nan,
-                    self.quiet_nan(v1),
-                    self.builder.build_select(
+                    self.quiet_nan(v1)?,
+                    err!(self.builder.build_select(
                         v2_is_nan,
-                        self.quiet_nan(v2),
-                        self.builder.build_select(
+                        self.quiet_nan(v2)?,
+                        err!(self.builder.build_select(
                             v1_lt_v2,
                             v2,
-                            self.builder.build_select(
+                            err!(self.builder.build_select(
                                 v1_gt_v2,
                                 v1,
-                                self.builder.build_bitcast(
-                                    self.builder.build_and(
-                                        self.builder
-                                            .build_bitcast(v1, self.intrinsics.i32_ty, "")
-                                            .into_int_value(),
-                                        self.builder
-                                            .build_bitcast(v2, self.intrinsics.i32_ty, "")
-                                            .into_int_value(),
+                                err!(self.builder.build_bit_cast(
+                                    err!(self.builder.build_and(
+                                        err!(self.builder.build_bit_cast(
+                                            v1,
+                                            self.intrinsics.i32_ty,
+                                            ""
+                                        ))
+                                        .into_int_value(),
+                                        err!(self.builder.build_bit_cast(
+                                            v2,
+                                            self.intrinsics.i32_ty,
+                                            ""
+                                        ))
+                                        .into_int_value(),
                                         "",
-                                    ),
+                                    )),
                                     self.intrinsics.f32_ty,
                                     "",
-                                ),
+                                )),
                                 "",
-                            ),
+                            )),
                             "",
-                        ),
+                        )),
                         "",
-                    ),
+                    )),
                     "",
-                );
+                ));
 
                 self.state.push1(res);
             }
             Operator::F64Max => {
                 // This implements the same logic as LLVM's @llvm.maximum
-                // intrinsic would, but x86 lowering of that intrinsic
-                // encounters a fatal error in LLVM 11.
-                let (v1, v2) = self.state.pop2()?;
-                let v1 = self.canonicalize_nans(v1);
-                let v2 = self.canonicalize_nans(v2);
-
-                let v1_is_nan = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f64,
-                        &[
-                            v1.into(),
-                            self.intrinsics.f64_zero.into(),
-                            self.intrinsics.fp_uno_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_int_value();
-                let v2_is_nan = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f64,
-                        &[
-                            v2.into(),
-                            self.intrinsics.f64_zero.into(),
-                            self.intrinsics.fp_uno_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_int_value();
-                let v1_lt_v2 = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f64,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_olt_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_int_value();
-                let v1_gt_v2 = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f64,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_ogt_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_int_value();
+                // intrinsic would, but x86 lowering of that intrinsic
+                // encounters a fatal error in LLVM 11.
+                let (v1, v2) = self.state.pop2()?;
+                let v1 = self.canonicalize_nans(v1)?;
+                let v2 = self.canonicalize_nans(v2)?;
+
+                let v1_is_nan = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f64,
+                    &[
+                        v1.into(),
+                        self.intrinsics.f64_zero.into(),
+                        self.intrinsics.fp_uno_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_int_value();
+                let v2_is_nan = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f64,
+                    &[
+                        v2.into(),
+                        self.intrinsics.f64_zero.into(),
+                        self.intrinsics.fp_uno_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_int_value();
+                let v1_lt_v2 = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f64,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_olt_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_int_value();
+                let v1_gt_v2 = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f64,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_ogt_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_int_value();
 
-                let res = self.builder.build_select(
+                let res = err!(self.builder.build_select(
                     v1_is_nan,
-                    self.quiet_nan(v1),
-                    self.builder.build_select(
+                    self.quiet_nan(v1)?,
+                    err!(self.builder.build_select(
                         v2_is_nan,
-                        self.quiet_nan(v2),
-                        self.builder.build_select(
+                        self.quiet_nan(v2)?,
+                        err!(self.builder.build_select(
                             v1_lt_v2,
                             v2,
-                            self.builder.build_select(
+                            err!(self.builder.build_select(
                                 v1_gt_v2,
                                 v1,
-                                self.builder.build_bitcast(
-                                    self.builder.build_and(
-                                        self.builder
-                                            .build_bitcast(v1, self.intrinsics.i64_ty, "")
-                                            .into_int_value(),
-                                        self.builder
-                                            .build_bitcast(v2, self.intrinsics.i64_ty, "")
-                                            .into_int_value(),
+                                err!(self.builder.build_bit_cast(
+                                    err!(self.builder.build_and(
+                                        err!(self.builder.build_bit_cast(
+                                            v1,
+                                            self.intrinsics.i64_ty,
+                                            ""
+                                        ))
+                                        .into_int_value(),
+                                        err!(self.builder.build_bit_cast(
+                                            v2,
+                                            self.intrinsics.i64_ty,
+                                            ""
+                                        ))
+                                        .into_int_value(),
                                         "",
-                                    ),
+                                    )),
                                     self.intrinsics.f64_ty,
                                     "",
-                                ),
+                                )),
                                 "",
-                            ),
+                            )),
                             "",
-                        ),
+                        )),
                         "",
-                    ),
+                    )),
                     "",
-                );
+                ));
 
                 self.state.push1(res);
             }
@@ -5160,126 +5776,126 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 // intrinsic would, but x86 lowering of that intrinsic
                 // encounters a fatal error in LLVM 11.
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_f32x4(v1, i1);
-                let (v2, _) = self.v128_into_f32x4(v2, i2);
+                let (v1, _) = self.v128_into_f32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_f32x4(v2, i2)?;
 
-                let v1_is_nan = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f32x4,
-                        &[
-                            v1.into(),
-                            self.intrinsics.f32x4_zero.into(),
-                            self.intrinsics.fp_uno_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_vector_value();
-                let v2_is_nan = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f32x4,
-                        &[
-                            v2.into(),
-                            self.intrinsics.f32x4_zero.into(),
-                            self.intrinsics.fp_uno_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_vector_value();
-                let v1_lt_v2 = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f32x4,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_olt_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_vector_value();
-                let v1_gt_v2 = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f32x4,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_ogt_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_vector_value();
+                let v1_is_nan = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f32x4,
+                    &[
+                        v1.into(),
+                        self.intrinsics.f32x4_zero.into(),
+                        self.intrinsics.fp_uno_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_vector_value();
+                let v2_is_nan = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f32x4,
+                    &[
+                        v2.into(),
+                        self.intrinsics.f32x4_zero.into(),
+                        self.intrinsics.fp_uno_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_vector_value();
+                let v1_lt_v2 = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f32x4,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_olt_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_vector_value();
+                let v1_gt_v2 = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f32x4,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_ogt_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_vector_value();
 
-                let res = self.builder.build_select(
+                let res = err!(self.builder.build_select(
                     v1_is_nan,
-                    self.quiet_nan(v1.into()).into_vector_value(),
-                    self.builder
-                        .build_select(
-                            v2_is_nan,
-                            self.quiet_nan(v2.into()).into_vector_value(),
-                            self.builder
-                                .build_select(
-                                    v1_lt_v2,
-                                    v2.into(),
-                                    self.builder.build_select(
-                                        v1_gt_v2,
-                                        v1.into(),
-                                        self.builder.build_bitcast(
-                                            self.builder.build_and(
-                                                self.builder
-                                                    .build_bitcast(v1, self.intrinsics.i32x4_ty, "")
-                                                    .into_vector_value(),
-                                                self.builder
-                                                    .build_bitcast(v2, self.intrinsics.i32x4_ty, "")
-                                                    .into_vector_value(),
-                                                "",
-                                            ),
-                                            self.intrinsics.f32x4_ty,
+                    self.quiet_nan(v1.into())?.into_vector_value(),
+                    err!(self.builder.build_select(
+                        v2_is_nan,
+                        self.quiet_nan(v2.into())?.into_vector_value(),
+                        err!(self.builder.build_select(
+                            v1_lt_v2,
+                            v2.into(),
+                            err!(self.builder.build_select(
+                                v1_gt_v2,
+                                v1.into(),
+                                err!(self.builder.build_bit_cast(
+                                    err!(self.builder.build_and(
+                                        err!(self.builder.build_bit_cast(
+                                            v1,
+                                            self.intrinsics.i32x4_ty,
+                                            "",
+                                        ))
+                                        .into_vector_value(),
+                                        err!(self.builder.build_bit_cast(
+                                            v2,
+                                            self.intrinsics.i32x4_ty,
                                             "",
-                                        ),
+                                        ))
+                                        .into_vector_value(),
                                         "",
-                                    ),
+                                    )),
+                                    self.intrinsics.f32x4_ty,
                                     "",
-                                )
-                                .into_vector_value(),
+                                )),
+                                "",
+                            )),
                             "",
-                        )
+                        ))
                         .into_vector_value(),
+                        "",
+                    ))
+                    .into_vector_value(),
                     "",
-                );
+                ));
 
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::F32x4PMax => {
                 // Pseudo-max: a < b ? b : a
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _i1) = self.v128_into_f32x4(v1, i1);
-                let (v2, _i2) = self.v128_into_f32x4(v2, i2);
-                let cmp = self
+                let (v1, _i1) = self.v128_into_f32x4(v1, i1)?;
+                let (v2, _i2) = self.v128_into_f32x4(v2, i2)?;
+                let cmp = err!(self
                     .builder
-                    .build_float_compare(FloatPredicate::OLT, v1, v2, "");
-                let res = self.builder.build_select(cmp, v2, v1, "");
+                    .build_float_compare(FloatPredicate::OLT, v1, v2, ""));
+                let res = err!(self.builder.build_select(cmp, v2, v1, ""));
 
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::F64x2Max => {
@@ -5287,439 +5903,493 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 // intrinsic would, but x86 lowering of that intrinsic
                 // encounters a fatal error in LLVM 11.
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_f64x2(v1, i1);
-                let (v2, _) = self.v128_into_f64x2(v2, i2);
+                let (v1, _) = self.v128_into_f64x2(v1, i1)?;
+                let (v2, _) = self.v128_into_f64x2(v2, i2)?;
 
-                let v1_is_nan = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f64x2,
-                        &[
-                            v1.into(),
-                            self.intrinsics.f64x2_zero.into(),
-                            self.intrinsics.fp_uno_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_vector_value();
-                let v2_is_nan = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f64x2,
-                        &[
-                            v2.into(),
-                            self.intrinsics.f64x2_zero.into(),
-                            self.intrinsics.fp_uno_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_vector_value();
-                let v1_lt_v2 = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f64x2,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_olt_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_vector_value();
-                let v1_gt_v2 = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.cmp_f64x2,
-                        &[
-                            v1.into(),
-                            v2.into(),
-                            self.intrinsics.fp_ogt_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap()
-                    .into_vector_value();
+                let v1_is_nan = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f64x2,
+                    &[
+                        v1.into(),
+                        self.intrinsics.f64x2_zero.into(),
+                        self.intrinsics.fp_uno_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_vector_value();
+                let v2_is_nan = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f64x2,
+                    &[
+                        v2.into(),
+                        self.intrinsics.f64x2_zero.into(),
+                        self.intrinsics.fp_uno_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_vector_value();
+                let v1_lt_v2 = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f64x2,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_olt_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_vector_value();
+                let v1_gt_v2 = err!(self.builder.build_call(
+                    self.intrinsics.cmp_f64x2,
+                    &[
+                        v1.into(),
+                        v2.into(),
+                        self.intrinsics.fp_ogt_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap()
+                .into_vector_value();
 
-                let res = self.builder.build_select(
+                let res = err!(self.builder.build_select(
                     v1_is_nan,
-                    self.quiet_nan(v1.into()).into_vector_value(),
-                    self.builder
-                        .build_select(
-                            v2_is_nan,
-                            self.quiet_nan(v2.into()).into_vector_value(),
-                            self.builder
-                                .build_select(
-                                    v1_lt_v2,
-                                    v2.into(),
-                                    self.builder.build_select(
-                                        v1_gt_v2,
-                                        v1.into(),
-                                        self.builder.build_bitcast(
-                                            self.builder.build_and(
-                                                self.builder
-                                                    .build_bitcast(v1, self.intrinsics.i64x2_ty, "")
-                                                    .into_vector_value(),
-                                                self.builder
-                                                    .build_bitcast(v2, self.intrinsics.i64x2_ty, "")
-                                                    .into_vector_value(),
-                                                "",
-                                            ),
-                                            self.intrinsics.f64x2_ty,
+                    self.quiet_nan(v1.into())?.into_vector_value(),
+                    err!(self.builder.build_select(
+                        v2_is_nan,
+                        self.quiet_nan(v2.into())?.into_vector_value(),
+                        err!(self.builder.build_select(
+                            v1_lt_v2,
+                            v2.into(),
+                            err!(self.builder.build_select(
+                                v1_gt_v2,
+                                v1.into(),
+                                err!(self.builder.build_bit_cast(
+                                    err!(self.builder.build_and(
+                                        err!(self.builder.build_bit_cast(
+                                            v1,
+                                            self.intrinsics.i64x2_ty,
+                                            "",
+                                        ))
+                                        .into_vector_value(),
+                                        err!(self.builder.build_bit_cast(
+                                            v2,
+                                            self.intrinsics.i64x2_ty,
                                             "",
-                                        ),
+                                        ))
+                                        .into_vector_value(),
                                         "",
-                                    ),
+                                    )),
+                                    self.intrinsics.f64x2_ty,
                                     "",
-                                )
-                                .into_vector_value(),
+                                )),
+                                "",
+                            )),
                             "",
-                        )
+                        ))
                         .into_vector_value(),
+                        "",
+                    ))
+                    .into_vector_value(),
                     "",
-                );
+                ));
 
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::F64x2PMax => {
                 // Pseudo-max: a < b ? b : a
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _i1) = self.v128_into_f64x2(v1, i1);
-                let (v2, _i2) = self.v128_into_f64x2(v2, i2);
-                let cmp = self
+                let (v1, _i1) = self.v128_into_f64x2(v1, i1)?;
+                let (v2, _i2) = self.v128_into_f64x2(v2, i2)?;
+                let cmp = err!(self
                     .builder
-                    .build_float_compare(FloatPredicate::OLT, v1, v2, "");
-                let res = self.builder.build_select(cmp, v2, v1, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_float_compare(FloatPredicate::OLT, v1, v2, ""));
+                let res = err!(self.builder.build_select(cmp, v2, v1, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::F32Ceil => {
                 let (input, info) = self.state.pop1_extra()?;
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.ceil_f32, &[input.into()], "")
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.ceil_f32, &[input.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
                 self.state
-                    .push1_extra(res, info | ExtraInfo::pending_f32_nan());
+                    .push1_extra(res, (info | ExtraInfo::pending_f32_nan())?);
             }
             Operator::F32x4Ceil => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_f32x4(v, i);
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.ceil_f32x4, &[v.into()], "")
+                let (v, _) = self.v128_into_f32x4(v, i)?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.ceil_f32x4, &[v.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state
-                    .push1_extra(res, i | ExtraInfo::pending_f32_nan());
+                    .push1_extra(res, (i | ExtraInfo::pending_f32_nan())?);
             }
             Operator::F64Ceil => {
                 let (input, info) = self.state.pop1_extra()?;
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.ceil_f64, &[input.into()], "")
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.ceil_f64, &[input.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
                 self.state
-                    .push1_extra(res, info | ExtraInfo::pending_f64_nan());
+                    .push1_extra(res, (info | ExtraInfo::pending_f64_nan())?);
             }
             Operator::F64x2Ceil => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_f64x2(v, i);
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.ceil_f64x2, &[v.into()], "")
+                let (v, _) = self.v128_into_f64x2(v, i)?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.ceil_f64x2, &[v.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state
-                    .push1_extra(res, i | ExtraInfo::pending_f64_nan());
+                    .push1_extra(res, (i | ExtraInfo::pending_f64_nan())?);
             }
             Operator::F32Floor => {
                 let (input, info) = self.state.pop1_extra()?;
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.floor_f32, &[input.into()], "")
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.floor_f32, &[input.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
                 self.state
-                    .push1_extra(res, info | ExtraInfo::pending_f32_nan());
+                    .push1_extra(res, (info | ExtraInfo::pending_f32_nan())?);
             }
             Operator::F32x4Floor => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_f32x4(v, i);
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.floor_f32x4, &[v.into()], "")
+                let (v, _) = self.v128_into_f32x4(v, i)?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.floor_f32x4, &[v.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state
-                    .push1_extra(res, i | ExtraInfo::pending_f32_nan());
+                    .push1_extra(res, (i | ExtraInfo::pending_f32_nan())?);
             }
             Operator::F64Floor => {
                 let (input, info) = self.state.pop1_extra()?;
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.floor_f64, &[input.into()], "")
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.floor_f64, &[input.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
                 self.state
-                    .push1_extra(res, info | ExtraInfo::pending_f64_nan());
+                    .push1_extra(res, (info | ExtraInfo::pending_f64_nan())?);
             }
             Operator::F64x2Floor => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_f64x2(v, i);
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.floor_f64x2, &[v.into()], "")
+                let (v, _) = self.v128_into_f64x2(v, i)?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.floor_f64x2, &[v.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state
-                    .push1_extra(res, i | ExtraInfo::pending_f64_nan());
+                    .push1_extra(res, (i | ExtraInfo::pending_f64_nan())?);
             }
             Operator::F32Trunc => {
                 let (v, i) = self.state.pop1_extra()?;
-                let res = self
+                let res = err!(self
                     .builder
-                    .build_call(self.intrinsics.trunc_f32, &[v.into()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .build_call(self.intrinsics.trunc_f32, &[v.into()], ""))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 self.state
-                    .push1_extra(res, i | ExtraInfo::pending_f32_nan());
+                    .push1_extra(res, (i | ExtraInfo::pending_f32_nan())?);
             }
             Operator::F32x4Trunc => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_f32x4(v, i);
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.trunc_f32x4, &[v.into()], "")
+                let (v, _) = self.v128_into_f32x4(v, i)?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.trunc_f32x4, &[v.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state
-                    .push1_extra(res, i | ExtraInfo::pending_f32_nan());
+                    .push1_extra(res, (i | ExtraInfo::pending_f32_nan())?);
             }
             Operator::F64Trunc => {
                 let (v, i) = self.state.pop1_extra()?;
-                let res = self
+                let res = err!(self
                     .builder
-                    .build_call(self.intrinsics.trunc_f64, &[v.into()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .build_call(self.intrinsics.trunc_f64, &[v.into()], ""))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 self.state
-                    .push1_extra(res, i | ExtraInfo::pending_f64_nan());
+                    .push1_extra(res, (i | ExtraInfo::pending_f64_nan())?);
             }
             Operator::F64x2Trunc => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_f64x2(v, i);
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.trunc_f64x2, &[v.into()], "")
+                let (v, _) = self.v128_into_f64x2(v, i)?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.trunc_f64x2, &[v.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state
-                    .push1_extra(res, i | ExtraInfo::pending_f64_nan());
+                    .push1_extra(res, (i | ExtraInfo::pending_f64_nan())?);
             }
             Operator::F32Nearest => {
                 let (v, i) = self.state.pop1_extra()?;
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.nearbyint_f32, &[v.into()], "")
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.nearbyint_f32, &[v.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
                 self.state
-                    .push1_extra(res, i | ExtraInfo::pending_f32_nan());
+                    .push1_extra(res, (i | ExtraInfo::pending_f32_nan())?);
             }
             Operator::F32x4Nearest => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_f32x4(v, i);
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.nearbyint_f32x4, &[v.into()], "")
+                let (v, _) = self.v128_into_f32x4(v, i)?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.nearbyint_f32x4, &[v.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state
-                    .push1_extra(res, i | ExtraInfo::pending_f32_nan());
+                    .push1_extra(res, (i | ExtraInfo::pending_f32_nan())?);
             }
             Operator::F64Nearest => {
                 let (v, i) = self.state.pop1_extra()?;
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.nearbyint_f64, &[v.into()], "")
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.nearbyint_f64, &[v.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
                 self.state
-                    .push1_extra(res, i | ExtraInfo::pending_f64_nan());
+                    .push1_extra(res, (i | ExtraInfo::pending_f64_nan())?);
             }
             Operator::F64x2Nearest => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_f64x2(v, i);
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.nearbyint_f64x2, &[v.into()], "")
+                let (v, _) = self.v128_into_f64x2(v, i)?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.nearbyint_f64x2, &[v.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state
-                    .push1_extra(res, i | ExtraInfo::pending_f64_nan());
+                    .push1_extra(res, (i | ExtraInfo::pending_f64_nan())?);
             }
             Operator::F32Abs => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
-                let res = self
+                let v = self.apply_pending_canonicalization(v, i)?;
+                let res = err!(self
                     .builder
-                    .build_call(self.intrinsics.fabs_f32, &[v.into()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .build_call(self.intrinsics.fabs_f32, &[v.into()], ""))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 // The exact NaN returned by F32Abs is fully defined. Do not
                 // adjust.
                 self.state.push1_extra(res, i.strip_pending());
             }
             Operator::F64Abs => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
-                let res = self
+                let v = self.apply_pending_canonicalization(v, i)?;
+                let res = err!(self
                     .builder
-                    .build_call(self.intrinsics.fabs_f64, &[v.into()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                    .build_call(self.intrinsics.fabs_f64, &[v.into()], ""))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 // The exact NaN returned by F64Abs is fully defined. Do not
                 // adjust.
                 self.state.push1_extra(res, i.strip_pending());
             }
             Operator::F32x4Abs => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v =
-                    self.builder
-                        .build_bitcast(v.into_int_value(), self.intrinsics.f32x4_ty, "");
-                let v = self.apply_pending_canonicalization(v, i);
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.fabs_f32x4, &[v.into()], "")
+                let v = err!(self.builder.build_bit_cast(
+                    v.into_int_value(),
+                    self.intrinsics.f32x4_ty,
+                    ""
+                ));
+                let v = self.apply_pending_canonicalization(v, i)?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.fabs_f32x4, &[v.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 // The exact NaN returned by F32x4Abs is fully defined. Do not
                 // adjust.
                 self.state.push1_extra(res, i.strip_pending());
             }
             Operator::F64x2Abs => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v =
-                    self.builder
-                        .build_bitcast(v.into_int_value(), self.intrinsics.f64x2_ty, "");
-                let v = self.apply_pending_canonicalization(v, i);
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.fabs_f64x2, &[v.into()], "")
+                let v = err!(self.builder.build_bit_cast(
+                    v.into_int_value(),
+                    self.intrinsics.f64x2_ty,
+                    ""
+                ));
+                let v = self.apply_pending_canonicalization(v, i)?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_call(self.intrinsics.fabs_f64x2, &[v.into()], ""))
                     .try_as_basic_value()
                     .left()
                     .unwrap();
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 // The exact NaN returned by F32x4Abs is fully defined. Do not
                 // adjust.
                 self.state.push1_extra(res, i.strip_pending());
             }
             Operator::F32x4Neg => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v =
-                    self.builder
-                        .build_bitcast(v.into_int_value(), self.intrinsics.f32x4_ty, "");
+                let v = err!(self.builder.build_bit_cast(
+                    v.into_int_value(),
+                    self.intrinsics.f32x4_ty,
+                    ""
+                ));
                 let v = self
-                    .apply_pending_canonicalization(v, i)
+                    .apply_pending_canonicalization(v, i)?
                     .into_vector_value();
-                let res = self.builder.build_float_neg(v, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self.builder.build_float_neg(v, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 // The exact NaN returned by F32x4Neg is fully defined. Do not
                 // adjust.
                 self.state.push1_extra(res, i.strip_pending());
             }
             Operator::F64x2Neg => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v =
-                    self.builder
-                        .build_bitcast(v.into_int_value(), self.intrinsics.f64x2_ty, "");
+                let v = err!(self.builder.build_bit_cast(
+                    v.into_int_value(),
+                    self.intrinsics.f64x2_ty,
+                    ""
+                ));
                 let v = self
-                    .apply_pending_canonicalization(v, i)
+                    .apply_pending_canonicalization(v, i)?
                     .into_vector_value();
-                let res = self.builder.build_float_neg(v, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self.builder.build_float_neg(v, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 // The exact NaN returned by F64x2Neg is fully defined. Do not
                 // adjust.
                 self.state.push1_extra(res, i.strip_pending());
             }
             Operator::F32Neg | Operator::F64Neg => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i).into_float_value();
-                let res = self.builder.build_float_neg(v, "");
+                let v = self
+                    .apply_pending_canonicalization(v, i)?
+                    .into_float_value();
+                let res = err!(self.builder.build_float_neg(v, ""));
                 // The exact NaN returned by F32Neg and F64Neg are fully defined.
                 // Do not adjust.
                 self.state.push1_extra(res, i.strip_pending());
             }
             Operator::F32Copysign => {
                 let ((mag, mag_info), (sgn, sgn_info)) = self.state.pop2_extra()?;
-                let mag = self.apply_pending_canonicalization(mag, mag_info);
-                let sgn = self.apply_pending_canonicalization(sgn, sgn_info);
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.copysign_f32, &[mag.into(), sgn.into()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let mag = self.apply_pending_canonicalization(mag, mag_info)?;
+                let sgn = self.apply_pending_canonicalization(sgn, sgn_info)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.copysign_f32,
+                    &[mag.into(), sgn.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 // The exact NaN returned by F32Copysign is fully defined.
                 // Do not adjust.
                 self.state.push1_extra(res, mag_info.strip_pending());
             }
             Operator::F64Copysign => {
                 let ((mag, mag_info), (sgn, sgn_info)) = self.state.pop2_extra()?;
-                let mag = self.apply_pending_canonicalization(mag, mag_info);
-                let sgn = self.apply_pending_canonicalization(sgn, sgn_info);
-                let res = self
-                    .builder
-                    .build_call(self.intrinsics.copysign_f64, &[mag.into(), sgn.into()], "")
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let mag = self.apply_pending_canonicalization(mag, mag_info)?;
+                let sgn = self.apply_pending_canonicalization(sgn, sgn_info)?;
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.copysign_f64,
+                    &[mag.into(), sgn.into()],
+                    ""
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 // The exact NaN returned by F32Copysign is fully defined.
                 // Do not adjust.
                 self.state.push1_extra(res, mag_info.strip_pending());
@@ -5731,604 +6401,676 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
              ***************************/
             Operator::I32Eq | Operator::I64Eq => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
-                let cond = self.builder.build_int_compare(IntPredicate::EQ, v1, v2, "");
-                let res = self
+                let cond = err!(self.builder.build_int_compare(IntPredicate::EQ, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(
                     res,
-                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                    (ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64())?,
                 );
             }
             Operator::I8x16Eq => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let (v2, _) = self.v128_into_i8x16(v2, i2);
-                let res = self.builder.build_int_compare(IntPredicate::EQ, v1, v2, "");
-                let res = self
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
+                let res = err!(self.builder.build_int_compare(IntPredicate::EQ, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8Eq => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
-                let res = self.builder.build_int_compare(IntPredicate::EQ, v1, v2, "");
-                let res = self
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
+                let res = err!(self.builder.build_int_compare(IntPredicate::EQ, v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4Eq => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let (v2, _) = self.v128_into_i32x4(v2, i2);
-                let res = self.builder.build_int_compare(IntPredicate::EQ, v1, v2, "");
-                let res = self
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_i32x4(v2, i2)?;
+                let res = err!(self.builder.build_int_compare(IntPredicate::EQ, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64x2Eq => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i64x2(v1, i1);
-                let (v2, _) = self.v128_into_i64x2(v2, i2);
-                let res = self.builder.build_int_compare(IntPredicate::EQ, v1, v2, "");
-                let res = self
+                let (v1, _) = self.v128_into_i64x2(v1, i1)?;
+                let (v2, _) = self.v128_into_i64x2(v2, i2)?;
+                let res = err!(self.builder.build_int_compare(IntPredicate::EQ, v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32Ne | Operator::I64Ne => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
-                let cond = self.builder.build_int_compare(IntPredicate::NE, v1, v2, "");
-                let res = self
+                let cond = err!(self.builder.build_int_compare(IntPredicate::NE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(
                     res,
-                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                    (ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64())?,
                 );
             }
             Operator::I8x16Ne => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let (v2, _) = self.v128_into_i8x16(v2, i2);
-                let res = self.builder.build_int_compare(IntPredicate::NE, v1, v2, "");
-                let res = self
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
+                let res = err!(self.builder.build_int_compare(IntPredicate::NE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8Ne => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
-                let res = self.builder.build_int_compare(IntPredicate::NE, v1, v2, "");
-                let res = self
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
+                let res = err!(self.builder.build_int_compare(IntPredicate::NE, v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4Ne => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let (v2, _) = self.v128_into_i32x4(v2, i2);
-                let res = self.builder.build_int_compare(IntPredicate::NE, v1, v2, "");
-                let res = self
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_i32x4(v2, i2)?;
+                let res = err!(self.builder.build_int_compare(IntPredicate::NE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64x2Ne => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i64x2(v1, i1);
-                let (v2, _) = self.v128_into_i64x2(v2, i2);
-                let res = self.builder.build_int_compare(IntPredicate::NE, v1, v2, "");
-                let res = self
+                let (v1, _) = self.v128_into_i64x2(v1, i1)?;
+                let (v2, _) = self.v128_into_i64x2(v2, i2)?;
+                let res = err!(self.builder.build_int_compare(IntPredicate::NE, v1, v2, ""));
+                let res = err!(self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32LtS | Operator::I64LtS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
-                let cond = self
+                let cond = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SLT, v1, v2, "");
-                let res = self
+                    .build_int_compare(IntPredicate::SLT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(
                     res,
-                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                    (ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64())?,
                 );
             }
             Operator::I8x16LtS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let (v2, _) = self.v128_into_i8x16(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SLT, v1, v2, "");
-                let res = self
+                    .build_int_compare(IntPredicate::SLT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8LtS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
+                let res = err!(self
+                    .builder
+                    .build_int_compare(IntPredicate::SLT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SLT, v1, v2, "");
-                let res = self
+                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4LtS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let (v2, _) = self.v128_into_i32x4(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_i32x4(v2, i2)?;
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SLT, v1, v2, "");
-                let res = self
+                    .build_int_compare(IntPredicate::SLT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64x2LtS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i64x2(v1, i1);
-                let (v2, _) = self.v128_into_i64x2(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i64x2(v1, i1)?;
+                let (v2, _) = self.v128_into_i64x2(v2, i2)?;
+                let res = err!(self
+                    .builder
+                    .build_int_compare(IntPredicate::SLT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SLT, v1, v2, "");
-                let res = self
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32LtU | Operator::I64LtU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
-                let cond = self
+                let cond = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::ULT, v1, v2, "");
-                let res = self
+                    .build_int_compare(IntPredicate::ULT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, ""));
                 self.state.push1(res);
             }
             Operator::I8x16LtU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let (v2, _) = self.v128_into_i8x16(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::ULT, v1, v2, "");
-                let res = self
+                    .build_int_compare(IntPredicate::ULT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8LtU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
+                let res = err!(self
+                    .builder
+                    .build_int_compare(IntPredicate::ULT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::ULT, v1, v2, "");
-                let res = self
+                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4LtU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let (v2, _) = self.v128_into_i32x4(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_i32x4(v2, i2)?;
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::ULT, v1, v2, "");
-                let res = self
+                    .build_int_compare(IntPredicate::ULT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32LeS | Operator::I64LeS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
-                let cond = self
+                let cond = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SLE, v1, v2, "");
-                let res = self
+                    .build_int_compare(IntPredicate::SLE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(
                     res,
-                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                    (ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64())?,
                 );
             }
             Operator::I8x16LeS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let (v2, _) = self.v128_into_i8x16(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
+                let res = err!(self
+                    .builder
+                    .build_int_compare(IntPredicate::SLE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SLE, v1, v2, "");
-                let res = self
+                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8LeS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SLE, v1, v2, "");
-                let res = self
+                    .build_int_compare(IntPredicate::SLE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4LeS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let (v2, _) = self.v128_into_i32x4(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_i32x4(v2, i2)?;
+                let res = err!(self
+                    .builder
+                    .build_int_compare(IntPredicate::SLE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SLE, v1, v2, "");
-                let res = self
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64x2LeS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i64x2(v1, i1);
-                let (v2, _) = self.v128_into_i64x2(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i64x2(v1, i1)?;
+                let (v2, _) = self.v128_into_i64x2(v2, i2)?;
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SLE, v1, v2, "");
-                let res = self
+                    .build_int_compare(IntPredicate::SLE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32LeU | Operator::I64LeU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
-                let cond = self
+                let cond = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::ULE, v1, v2, "");
-                let res = self
+                    .build_int_compare(IntPredicate::ULE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(
                     res,
-                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                    (ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64())?,
                 );
             }
             Operator::I8x16LeU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let (v2, _) = self.v128_into_i8x16(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
+                let res = err!(self
+                    .builder
+                    .build_int_compare(IntPredicate::ULE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::ULE, v1, v2, "");
-                let res = self
+                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8LeU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::ULE, v1, v2, "");
-                let res = self
+                    .build_int_compare(IntPredicate::ULE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4LeU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let (v2, _) = self.v128_into_i32x4(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_i32x4(v2, i2)?;
+                let res = err!(self
+                    .builder
+                    .build_int_compare(IntPredicate::ULE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::ULE, v1, v2, "");
-                let res = self
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32GtS | Operator::I64GtS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
-                let cond = self
+                let cond = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SGT, v1, v2, "");
-                let res = self
+                    .build_int_compare(IntPredicate::SGT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(
                     res,
-                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                    (ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64())?,
                 );
             }
             Operator::I8x16GtS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let (v2, _) = self.v128_into_i8x16(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SGT, v1, v2, "");
-                let res = self
+                    .build_int_compare(IntPredicate::SGT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8GtS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
+                let res = err!(self
+                    .builder
+                    .build_int_compare(IntPredicate::SGT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SGT, v1, v2, "");
-                let res = self
+                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4GtS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let (v2, _) = self.v128_into_i32x4(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_i32x4(v2, i2)?;
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SGT, v1, v2, "");
-                let res = self
+                    .build_int_compare(IntPredicate::SGT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64x2GtS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i64x2(v1, i1);
-                let (v2, _) = self.v128_into_i64x2(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i64x2(v1, i1)?;
+                let (v2, _) = self.v128_into_i64x2(v2, i2)?;
+                let res = err!(self
+                    .builder
+                    .build_int_compare(IntPredicate::SGT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SGT, v1, v2, "");
-                let res = self
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32GtU | Operator::I64GtU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
-                let cond = self
+                let cond = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::UGT, v1, v2, "");
-                let res = self
+                    .build_int_compare(IntPredicate::UGT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(
                     res,
-                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                    (ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64())?,
                 );
             }
             Operator::I8x16GtU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let (v2, _) = self.v128_into_i8x16(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::UGT, v1, v2, "");
-                let res = self
+                    .build_int_compare(IntPredicate::UGT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8GtU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
+                let res = err!(self
+                    .builder
+                    .build_int_compare(IntPredicate::UGT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::UGT, v1, v2, "");
-                let res = self
+                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4GtU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let (v2, _) = self.v128_into_i32x4(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_i32x4(v2, i2)?;
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::UGT, v1, v2, "");
-                let res = self
+                    .build_int_compare(IntPredicate::UGT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32GeS | Operator::I64GeS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
-                let cond = self
+                let cond = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SGE, v1, v2, "");
-                let res = self
+                    .build_int_compare(IntPredicate::SGE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, ""));
                 self.state.push1(res);
             }
             Operator::I8x16GeS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let (v2, _) = self.v128_into_i8x16(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
+                let res = err!(self
+                    .builder
+                    .build_int_compare(IntPredicate::SGE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SGE, v1, v2, "");
-                let res = self
+                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8GeS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SGE, v1, v2, "");
-                let res = self
+                    .build_int_compare(IntPredicate::SGE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4GeS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let (v2, _) = self.v128_into_i32x4(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_i32x4(v2, i2)?;
+                let res = err!(self
+                    .builder
+                    .build_int_compare(IntPredicate::SGE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SGE, v1, v2, "");
-                let res = self
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64x2GeS => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i64x2(v1, i1);
-                let (v2, _) = self.v128_into_i64x2(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i64x2(v1, i1)?;
+                let (v2, _) = self.v128_into_i64x2(v2, i2)?;
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::SGE, v1, v2, "");
-                let res = self
+                    .build_int_compare(IntPredicate::SGE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32GeU | Operator::I64GeU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
-                let cond = self
+                let cond = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::UGE, v1, v2, "");
-                let res = self
+                    .build_int_compare(IntPredicate::UGE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(
                     res,
-                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                    (ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64())?,
                 );
             }
             Operator::I8x16GeU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
-                let (v2, _) = self.v128_into_i8x16(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
+                let (v2, _) = self.v128_into_i8x16(v2, i2)?;
+                let res = err!(self
+                    .builder
+                    .build_int_compare(IntPredicate::UGE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::UGE, v1, v2, "");
-                let res = self
+                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8GeU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::UGE, v1, v2, "");
-                let res = self
+                    .build_int_compare(IntPredicate::UGE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4GeU => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let (v2, _) = self.v128_into_i32x4(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_i32x4(v2, i2)?;
+                let res = err!(self
+                    .builder
+                    .build_int_compare(IntPredicate::UGE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_compare(IntPredicate::UGE, v1, v2, "");
-                let res = self
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
 
@@ -6339,241 +7081,265 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             Operator::F32Eq | Operator::F64Eq => {
                 let (v1, v2) = self.state.pop2()?;
                 let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
-                let cond = self
+                let cond = err!(self
                     .builder
-                    .build_float_compare(FloatPredicate::OEQ, v1, v2, "");
-                let res = self
+                    .build_float_compare(FloatPredicate::OEQ, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(
                     res,
-                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                    (ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64())?,
                 );
             }
             Operator::F32x4Eq => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_f32x4(v1, i1);
-                let (v2, _) = self.v128_into_f32x4(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_f32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_f32x4(v2, i2)?;
+                let res = err!(self
                     .builder
-                    .build_float_compare(FloatPredicate::OEQ, v1, v2, "");
-                let res = self
+                    .build_float_compare(FloatPredicate::OEQ, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::F64x2Eq => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_f64x2(v1, i1);
-                let (v2, _) = self.v128_into_f64x2(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_f64x2(v1, i1)?;
+                let (v2, _) = self.v128_into_f64x2(v2, i2)?;
+                let res = err!(self
+                    .builder
+                    .build_float_compare(FloatPredicate::OEQ, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_float_compare(FloatPredicate::OEQ, v1, v2, "");
-                let res = self
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::F32Ne | Operator::F64Ne => {
                 let (v1, v2) = self.state.pop2()?;
                 let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
-                let cond = self
+                let cond = err!(self
                     .builder
-                    .build_float_compare(FloatPredicate::UNE, v1, v2, "");
-                let res = self
+                    .build_float_compare(FloatPredicate::UNE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(
                     res,
-                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                    (ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64())?,
                 );
             }
             Operator::F32x4Ne => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_f32x4(v1, i1);
-                let (v2, _) = self.v128_into_f32x4(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_f32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_f32x4(v2, i2)?;
+                let res = err!(self
                     .builder
-                    .build_float_compare(FloatPredicate::UNE, v1, v2, "");
-                let res = self
+                    .build_float_compare(FloatPredicate::UNE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::F64x2Ne => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_f64x2(v1, i1);
-                let (v2, _) = self.v128_into_f64x2(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_f64x2(v1, i1)?;
+                let (v2, _) = self.v128_into_f64x2(v2, i2)?;
+                let res = err!(self
+                    .builder
+                    .build_float_compare(FloatPredicate::UNE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_float_compare(FloatPredicate::UNE, v1, v2, "");
-                let res = self
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::F32Lt | Operator::F64Lt => {
                 let (v1, v2) = self.state.pop2()?;
                 let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
-                let cond = self
+                let cond = err!(self
                     .builder
-                    .build_float_compare(FloatPredicate::OLT, v1, v2, "");
-                let res = self
+                    .build_float_compare(FloatPredicate::OLT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(
                     res,
-                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                    (ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64())?,
                 );
             }
             Operator::F32x4Lt => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_f32x4(v1, i1);
-                let (v2, _) = self.v128_into_f32x4(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_f32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_f32x4(v2, i2)?;
+                let res = err!(self
                     .builder
-                    .build_float_compare(FloatPredicate::OLT, v1, v2, "");
-                let res = self
+                    .build_float_compare(FloatPredicate::OLT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::F64x2Lt => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_f64x2(v1, i1);
-                let (v2, _) = self.v128_into_f64x2(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_f64x2(v1, i1)?;
+                let (v2, _) = self.v128_into_f64x2(v2, i2)?;
+                let res = err!(self
+                    .builder
+                    .build_float_compare(FloatPredicate::OLT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_float_compare(FloatPredicate::OLT, v1, v2, "");
-                let res = self
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::F32Le | Operator::F64Le => {
                 let (v1, v2) = self.state.pop2()?;
                 let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
-                let cond = self
+                let cond = err!(self
                     .builder
-                    .build_float_compare(FloatPredicate::OLE, v1, v2, "");
-                let res = self
+                    .build_float_compare(FloatPredicate::OLE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(
                     res,
-                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                    (ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64())?,
                 );
             }
             Operator::F32x4Le => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_f32x4(v1, i1);
-                let (v2, _) = self.v128_into_f32x4(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_f32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_f32x4(v2, i2)?;
+                let res = err!(self
                     .builder
-                    .build_float_compare(FloatPredicate::OLE, v1, v2, "");
-                let res = self
+                    .build_float_compare(FloatPredicate::OLE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::F64x2Le => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_f64x2(v1, i1);
-                let (v2, _) = self.v128_into_f64x2(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_f64x2(v1, i1)?;
+                let (v2, _) = self.v128_into_f64x2(v2, i2)?;
+                let res = err!(self
+                    .builder
+                    .build_float_compare(FloatPredicate::OLE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_float_compare(FloatPredicate::OLE, v1, v2, "");
-                let res = self
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::F32Gt | Operator::F64Gt => {
                 let (v1, v2) = self.state.pop2()?;
                 let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
-                let cond = self
+                let cond = err!(self
                     .builder
-                    .build_float_compare(FloatPredicate::OGT, v1, v2, "");
-                let res = self
+                    .build_float_compare(FloatPredicate::OGT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(
                     res,
-                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                    (ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64())?,
                 );
             }
             Operator::F32x4Gt => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_f32x4(v1, i1);
-                let (v2, _) = self.v128_into_f32x4(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_f32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_f32x4(v2, i2)?;
+                let res = err!(self
                     .builder
-                    .build_float_compare(FloatPredicate::OGT, v1, v2, "");
-                let res = self
+                    .build_float_compare(FloatPredicate::OGT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::F64x2Gt => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_f64x2(v1, i1);
-                let (v2, _) = self.v128_into_f64x2(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_f64x2(v1, i1)?;
+                let (v2, _) = self.v128_into_f64x2(v2, i2)?;
+                let res = err!(self
+                    .builder
+                    .build_float_compare(FloatPredicate::OGT, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_float_compare(FloatPredicate::OGT, v1, v2, "");
-                let res = self
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::F32Ge | Operator::F64Ge => {
                 let (v1, v2) = self.state.pop2()?;
                 let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
-                let cond = self
+                let cond = err!(self
                     .builder
-                    .build_float_compare(FloatPredicate::OGE, v1, v2, "");
-                let res = self
+                    .build_float_compare(FloatPredicate::OGE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(
                     res,
-                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                    (ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64())?,
                 );
             }
             Operator::F32x4Ge => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_f32x4(v1, i1);
-                let (v2, _) = self.v128_into_f32x4(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_f32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_f32x4(v2, i2)?;
+                let res = err!(self
                     .builder
-                    .build_float_compare(FloatPredicate::OGE, v1, v2, "");
-                let res = self
+                    .build_float_compare(FloatPredicate::OGE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::F64x2Ge => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_f64x2(v1, i1);
-                let (v2, _) = self.v128_into_f64x2(v2, i2);
-                let res = self
+                let (v1, _) = self.v128_into_f64x2(v1, i1)?;
+                let (v2, _) = self.v128_into_f64x2(v2, i2)?;
+                let res = err!(self
+                    .builder
+                    .build_float_compare(FloatPredicate::OGE, v1, v2, ""));
+                let res = err!(self
                     .builder
-                    .build_float_compare(FloatPredicate::OGE, v1, v2, "");
-                let res = self
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
 
@@ -6583,35 +7349,35 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
              ***************************/
             Operator::I32WrapI64 => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
+                let v = self.apply_pending_canonicalization(v, i)?;
                 let v = v.into_int_value();
-                let res = self
+                let res = err!(self
                     .builder
-                    .build_int_truncate(v, self.intrinsics.i32_ty, "");
+                    .build_int_truncate(v, self.intrinsics.i32_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64ExtendI32S => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
+                let v = self.apply_pending_canonicalization(v, i)?;
                 let v = v.into_int_value();
-                let res = self
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(v, self.intrinsics.i64_ty, "");
+                    .build_int_s_extend(v, self.intrinsics.i64_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64ExtendI32U => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
+                let v = self.apply_pending_canonicalization(v, i)?;
                 let v = v.into_int_value();
-                let res = self
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(v, self.intrinsics.i64_ty, "");
+                    .build_int_z_extend(v, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(res, ExtraInfo::arithmetic_f64());
             }
             Operator::I16x8ExtendLowI8x16S => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i8x16(v, i);
-                let low = self.builder.build_shuffle_vector(
+                let (v, _) = self.v128_into_i8x16(v, i)?;
+                let low = err!(self.builder.build_shuffle_vector(
                     v,
                     v.get_type().get_undef(),
                     VectorType::const_vector(&[
@@ -6625,17 +7391,19 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[7],
                     ]),
                     "",
-                );
-                let res = self
+                ));
+                let res = err!(self
+                    .builder
+                    .build_int_s_extend(low, self.intrinsics.i16x8_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(low, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8ExtendHighI8x16S => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i8x16(v, i);
-                let low = self.builder.build_shuffle_vector(
+                let (v, _) = self.v128_into_i8x16(v, i)?;
+                let low = err!(self.builder.build_shuffle_vector(
                     v,
                     v.get_type().get_undef(),
                     VectorType::const_vector(&[
@@ -6649,17 +7417,19 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[15],
                     ]),
                     "",
-                );
-                let res = self
+                ));
+                let res = err!(self
+                    .builder
+                    .build_int_s_extend(low, self.intrinsics.i16x8_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(low, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8ExtendLowI8x16U => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i8x16(v, i);
-                let low = self.builder.build_shuffle_vector(
+                let (v, _) = self.v128_into_i8x16(v, i)?;
+                let low = err!(self.builder.build_shuffle_vector(
                     v,
                     v.get_type().get_undef(),
                     VectorType::const_vector(&[
@@ -6673,17 +7443,19 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[7],
                     ]),
                     "",
-                );
-                let res = self
+                ));
+                let res = err!(self
+                    .builder
+                    .build_int_z_extend(low, self.intrinsics.i16x8_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(low, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8ExtendHighI8x16U => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i8x16(v, i);
-                let low = self.builder.build_shuffle_vector(
+                let (v, _) = self.v128_into_i8x16(v, i)?;
+                let low = err!(self.builder.build_shuffle_vector(
                     v,
                     v.get_type().get_undef(),
                     VectorType::const_vector(&[
@@ -6697,17 +7469,19 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[15],
                     ]),
                     "",
-                );
-                let res = self
+                ));
+                let res = err!(self
+                    .builder
+                    .build_int_z_extend(low, self.intrinsics.i16x8_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(low, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4ExtendLowI16x8S => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i16x8(v, i);
-                let low = self.builder.build_shuffle_vector(
+                let (v, _) = self.v128_into_i16x8(v, i)?;
+                let low = err!(self.builder.build_shuffle_vector(
                     v,
                     v.get_type().get_undef(),
                     VectorType::const_vector(&[
@@ -6717,17 +7491,19 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[3],
                     ]),
                     "",
-                );
-                let res = self
+                ));
+                let res = err!(self
+                    .builder
+                    .build_int_s_extend(low, self.intrinsics.i32x4_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(low, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4ExtendHighI16x8S => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i16x8(v, i);
-                let low = self.builder.build_shuffle_vector(
+                let (v, _) = self.v128_into_i16x8(v, i)?;
+                let low = err!(self.builder.build_shuffle_vector(
                     v,
                     v.get_type().get_undef(),
                     VectorType::const_vector(&[
@@ -6737,17 +7513,19 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[7],
                     ]),
                     "",
-                );
-                let res = self
+                ));
+                let res = err!(self
+                    .builder
+                    .build_int_s_extend(low, self.intrinsics.i32x4_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(low, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4ExtendLowI16x8U => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i16x8(v, i);
-                let low = self.builder.build_shuffle_vector(
+                let (v, _) = self.v128_into_i16x8(v, i)?;
+                let low = err!(self.builder.build_shuffle_vector(
                     v,
                     v.get_type().get_undef(),
                     VectorType::const_vector(&[
@@ -6757,17 +7535,19 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[3],
                     ]),
                     "",
-                );
-                let res = self
+                ));
+                let res = err!(self
+                    .builder
+                    .build_int_z_extend(low, self.intrinsics.i32x4_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(low, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4ExtendHighI16x8U => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i16x8(v, i);
-                let low = self.builder.build_shuffle_vector(
+                let (v, _) = self.v128_into_i16x8(v, i)?;
+                let low = err!(self.builder.build_shuffle_vector(
                     v,
                     v.get_type().get_undef(),
                     VectorType::const_vector(&[
@@ -6777,11 +7557,13 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[7],
                     ]),
                     "",
-                );
-                let res = self
+                ));
+                let res = err!(self
+                    .builder
+                    .build_int_z_extend(low, self.intrinsics.i32x4_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(low, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64x2ExtendLowI32x4U
@@ -6807,60 +7589,62 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     _ => unreachable!("Unhandled inner case"),
                 };
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i32x4(v, i);
-                let low = self.builder.build_shuffle_vector(
+                let (v, _) = self.v128_into_i32x4(v, i)?;
+                let low = err!(self.builder.build_shuffle_vector(
                     v,
                     v.get_type().get_undef(),
                     VectorType::const_vector(&indices),
                     "",
-                );
-                let res = extend(self, low);
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                ));
+                let res = err!(extend(self, low));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I8x16NarrowI16x8S => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
                 let min = self.intrinsics.i16_ty.const_int(0xff80, false);
                 let max = self.intrinsics.i16_ty.const_int(0x007f, false);
                 let min = VectorType::const_vector(&[min; 8]);
                 let max = VectorType::const_vector(&[max; 8]);
                 let apply_min_clamp_v1 =
-                    self.builder
-                        .build_int_compare(IntPredicate::SLT, v1, min, "");
+                    err!(self
+                        .builder
+                        .build_int_compare(IntPredicate::SLT, v1, min, ""));
                 let apply_max_clamp_v1 =
-                    self.builder
-                        .build_int_compare(IntPredicate::SGT, v1, max, "");
+                    err!(self
+                        .builder
+                        .build_int_compare(IntPredicate::SGT, v1, max, ""));
                 let apply_min_clamp_v2 =
-                    self.builder
-                        .build_int_compare(IntPredicate::SLT, v2, min, "");
+                    err!(self
+                        .builder
+                        .build_int_compare(IntPredicate::SLT, v2, min, ""));
                 let apply_max_clamp_v2 =
-                    self.builder
-                        .build_int_compare(IntPredicate::SGT, v2, max, "");
-                let v1 = self
-                    .builder
-                    .build_select(apply_min_clamp_v1, min, v1, "")
+                    err!(self
+                        .builder
+                        .build_int_compare(IntPredicate::SGT, v2, max, ""));
+                let v1 = err!(self.builder.build_select(apply_min_clamp_v1, min, v1, ""))
                     .into_vector_value();
-                let v1 = self
-                    .builder
-                    .build_select(apply_max_clamp_v1, max, v1, "")
+                let v1 = err!(self.builder.build_select(apply_max_clamp_v1, max, v1, ""))
                     .into_vector_value();
-                let v1 = self
-                    .builder
-                    .build_int_truncate(v1, self.intrinsics.i8_ty.vec_type(8), "");
-                let v2 = self
-                    .builder
-                    .build_select(apply_min_clamp_v2, min, v2, "")
+                let v1 = err!(self.builder.build_int_truncate(
+                    v1,
+                    self.intrinsics.i8_ty.vec_type(8),
+                    ""
+                ));
+                let v2 = err!(self.builder.build_select(apply_min_clamp_v2, min, v2, ""))
                     .into_vector_value();
-                let v2 = self
-                    .builder
-                    .build_select(apply_max_clamp_v2, max, v2, "")
+                let v2 = err!(self.builder.build_select(apply_max_clamp_v2, max, v2, ""))
                     .into_vector_value();
-                let v2 = self
-                    .builder
-                    .build_int_truncate(v2, self.intrinsics.i8_ty.vec_type(8), "");
-                let res = self.builder.build_shuffle_vector(
+                let v2 = err!(self.builder.build_int_truncate(
+                    v2,
+                    self.intrinsics.i8_ty.vec_type(8),
+                    ""
+                ));
+                let res = err!(self.builder.build_shuffle_vector(
                     v1,
                     v2,
                     VectorType::const_vector(&[
@@ -6882,52 +7666,54 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[15],
                     ]),
                     "",
-                );
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                ));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I8x16NarrowI16x8U => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
-                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
+                let (v2, _) = self.v128_into_i16x8(v2, i2)?;
                 let min = self.intrinsics.i16x8_ty.const_zero();
                 let max = self.intrinsics.i16_ty.const_int(0x00ff, false);
                 let max = VectorType::const_vector(&[max; 8]);
                 let apply_min_clamp_v1 =
-                    self.builder
-                        .build_int_compare(IntPredicate::SLT, v1, min, "");
+                    err!(self
+                        .builder
+                        .build_int_compare(IntPredicate::SLT, v1, min, ""));
                 let apply_max_clamp_v1 =
-                    self.builder
-                        .build_int_compare(IntPredicate::SGT, v1, max, "");
+                    err!(self
+                        .builder
+                        .build_int_compare(IntPredicate::SGT, v1, max, ""));
                 let apply_min_clamp_v2 =
-                    self.builder
-                        .build_int_compare(IntPredicate::SLT, v2, min, "");
+                    err!(self
+                        .builder
+                        .build_int_compare(IntPredicate::SLT, v2, min, ""));
                 let apply_max_clamp_v2 =
-                    self.builder
-                        .build_int_compare(IntPredicate::SGT, v2, max, "");
-                let v1 = self
-                    .builder
-                    .build_select(apply_min_clamp_v1, min, v1, "")
+                    err!(self
+                        .builder
+                        .build_int_compare(IntPredicate::SGT, v2, max, ""));
+                let v1 = err!(self.builder.build_select(apply_min_clamp_v1, min, v1, ""))
                     .into_vector_value();
-                let v1 = self
-                    .builder
-                    .build_select(apply_max_clamp_v1, max, v1, "")
+                let v1 = err!(self.builder.build_select(apply_max_clamp_v1, max, v1, ""))
                     .into_vector_value();
-                let v1 = self
-                    .builder
-                    .build_int_truncate(v1, self.intrinsics.i8_ty.vec_type(8), "");
-                let v2 = self
-                    .builder
-                    .build_select(apply_min_clamp_v2, min, v2, "")
+                let v1 = err!(self.builder.build_int_truncate(
+                    v1,
+                    self.intrinsics.i8_ty.vec_type(8),
+                    ""
+                ));
+                let v2 = err!(self.builder.build_select(apply_min_clamp_v2, min, v2, ""))
                     .into_vector_value();
-                let v2 = self
-                    .builder
-                    .build_select(apply_max_clamp_v2, max, v2, "")
+                let v2 = err!(self.builder.build_select(apply_max_clamp_v2, max, v2, ""))
                     .into_vector_value();
-                let v2 = self
-                    .builder
-                    .build_int_truncate(v2, self.intrinsics.i8_ty.vec_type(8), "");
-                let res = self.builder.build_shuffle_vector(
+                let v2 = err!(self.builder.build_int_truncate(
+                    v2,
+                    self.intrinsics.i8_ty.vec_type(8),
+                    ""
+                ));
+                let res = err!(self.builder.build_shuffle_vector(
                     v1,
                     v2,
                     VectorType::const_vector(&[
@@ -6949,53 +7735,55 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[15],
                     ]),
                     "",
-                );
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                ));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8NarrowI32x4S => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let (v2, _) = self.v128_into_i32x4(v2, i2);
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_i32x4(v2, i2)?;
                 let min = self.intrinsics.i32_ty.const_int(0xffff8000, false);
                 let max = self.intrinsics.i32_ty.const_int(0x00007fff, false);
                 let min = VectorType::const_vector(&[min; 4]);
                 let max = VectorType::const_vector(&[max; 4]);
                 let apply_min_clamp_v1 =
-                    self.builder
-                        .build_int_compare(IntPredicate::SLT, v1, min, "");
+                    err!(self
+                        .builder
+                        .build_int_compare(IntPredicate::SLT, v1, min, ""));
                 let apply_max_clamp_v1 =
-                    self.builder
-                        .build_int_compare(IntPredicate::SGT, v1, max, "");
+                    err!(self
+                        .builder
+                        .build_int_compare(IntPredicate::SGT, v1, max, ""));
                 let apply_min_clamp_v2 =
-                    self.builder
-                        .build_int_compare(IntPredicate::SLT, v2, min, "");
+                    err!(self
+                        .builder
+                        .build_int_compare(IntPredicate::SLT, v2, min, ""));
                 let apply_max_clamp_v2 =
-                    self.builder
-                        .build_int_compare(IntPredicate::SGT, v2, max, "");
-                let v1 = self
-                    .builder
-                    .build_select(apply_min_clamp_v1, min, v1, "")
+                    err!(self
+                        .builder
+                        .build_int_compare(IntPredicate::SGT, v2, max, ""));
+                let v1 = err!(self.builder.build_select(apply_min_clamp_v1, min, v1, ""))
                     .into_vector_value();
-                let v1 = self
-                    .builder
-                    .build_select(apply_max_clamp_v1, max, v1, "")
+                let v1 = err!(self.builder.build_select(apply_max_clamp_v1, max, v1, ""))
                     .into_vector_value();
-                let v1 =
-                    self.builder
-                        .build_int_truncate(v1, self.intrinsics.i16_ty.vec_type(4), "");
-                let v2 = self
-                    .builder
-                    .build_select(apply_min_clamp_v2, min, v2, "")
+                let v1 = err!(self.builder.build_int_truncate(
+                    v1,
+                    self.intrinsics.i16_ty.vec_type(4),
+                    ""
+                ));
+                let v2 = err!(self.builder.build_select(apply_min_clamp_v2, min, v2, ""))
                     .into_vector_value();
-                let v2 = self
-                    .builder
-                    .build_select(apply_max_clamp_v2, max, v2, "")
+                let v2 = err!(self.builder.build_select(apply_max_clamp_v2, max, v2, ""))
                     .into_vector_value();
-                let v2 =
-                    self.builder
-                        .build_int_truncate(v2, self.intrinsics.i16_ty.vec_type(4), "");
-                let res = self.builder.build_shuffle_vector(
+                let v2 = err!(self.builder.build_int_truncate(
+                    v2,
+                    self.intrinsics.i16_ty.vec_type(4),
+                    ""
+                ));
+                let res = err!(self.builder.build_shuffle_vector(
                     v1,
                     v2,
                     VectorType::const_vector(&[
@@ -7009,52 +7797,54 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[7],
                     ]),
                     "",
-                );
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                ));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8NarrowI32x4U => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i32x4(v1, i1);
-                let (v2, _) = self.v128_into_i32x4(v2, i2);
+                let (v1, _) = self.v128_into_i32x4(v1, i1)?;
+                let (v2, _) = self.v128_into_i32x4(v2, i2)?;
                 let min = self.intrinsics.i32x4_ty.const_zero();
                 let max = self.intrinsics.i32_ty.const_int(0xffff, false);
                 let max = VectorType::const_vector(&[max; 4]);
                 let apply_min_clamp_v1 =
-                    self.builder
-                        .build_int_compare(IntPredicate::SLT, v1, min, "");
+                    err!(self
+                        .builder
+                        .build_int_compare(IntPredicate::SLT, v1, min, ""));
                 let apply_max_clamp_v1 =
-                    self.builder
-                        .build_int_compare(IntPredicate::SGT, v1, max, "");
+                    err!(self
+                        .builder
+                        .build_int_compare(IntPredicate::SGT, v1, max, ""));
                 let apply_min_clamp_v2 =
-                    self.builder
-                        .build_int_compare(IntPredicate::SLT, v2, min, "");
+                    err!(self
+                        .builder
+                        .build_int_compare(IntPredicate::SLT, v2, min, ""));
                 let apply_max_clamp_v2 =
-                    self.builder
-                        .build_int_compare(IntPredicate::SGT, v2, max, "");
-                let v1 = self
-                    .builder
-                    .build_select(apply_min_clamp_v1, min, v1, "")
+                    err!(self
+                        .builder
+                        .build_int_compare(IntPredicate::SGT, v2, max, ""));
+                let v1 = err!(self.builder.build_select(apply_min_clamp_v1, min, v1, ""))
                     .into_vector_value();
-                let v1 = self
-                    .builder
-                    .build_select(apply_max_clamp_v1, max, v1, "")
+                let v1 = err!(self.builder.build_select(apply_max_clamp_v1, max, v1, ""))
                     .into_vector_value();
-                let v1 =
-                    self.builder
-                        .build_int_truncate(v1, self.intrinsics.i16_ty.vec_type(4), "");
-                let v2 = self
-                    .builder
-                    .build_select(apply_min_clamp_v2, min, v2, "")
+                let v1 = err!(self.builder.build_int_truncate(
+                    v1,
+                    self.intrinsics.i16_ty.vec_type(4),
+                    ""
+                ));
+                let v2 = err!(self.builder.build_select(apply_min_clamp_v2, min, v2, ""))
                     .into_vector_value();
-                let v2 = self
-                    .builder
-                    .build_select(apply_max_clamp_v2, max, v2, "")
+                let v2 = err!(self.builder.build_select(apply_max_clamp_v2, max, v2, ""))
                     .into_vector_value();
-                let v2 =
-                    self.builder
-                        .build_int_truncate(v2, self.intrinsics.i16_ty.vec_type(4), "");
-                let res = self.builder.build_shuffle_vector(
+                let v2 = err!(self.builder.build_int_truncate(
+                    v2,
+                    self.intrinsics.i16_ty.vec_type(4),
+                    ""
+                ));
+                let res = err!(self.builder.build_shuffle_vector(
                     v1,
                     v2,
                     VectorType::const_vector(&[
@@ -7068,54 +7858,56 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[7],
                     ]),
                     "",
-                );
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                ));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4TruncSatF32x4S => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
+                let v = self.apply_pending_canonicalization(v, i)?;
                 let v = v.into_int_value();
                 let res = self.trunc_sat_into_int(
                     self.intrinsics.f32x4_ty,
                     self.intrinsics.i32x4_ty,
                     LEF32_GEQ_I32_MIN,
                     GEF32_LEQ_I32_MAX,
-                    std::i32::MIN as u64,
-                    std::i32::MAX as u64,
+                    i32::MIN as u64,
+                    i32::MAX as u64,
                     v,
-                );
+                )?;
                 self.state.push1(res);
             }
             Operator::I32x4TruncSatF32x4U => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
+                let v = self.apply_pending_canonicalization(v, i)?;
                 let v = v.into_int_value();
                 let res = self.trunc_sat_into_int(
                     self.intrinsics.f32x4_ty,
                     self.intrinsics.i32x4_ty,
                     LEF32_GEQ_U32_MIN,
                     GEF32_LEQ_U32_MAX,
-                    std::u32::MIN as u64,
-                    std::u32::MAX as u64,
+                    u32::MIN as u64,
+                    u32::MAX as u64,
                     v,
-                );
+                )?;
                 self.state.push1(res);
             }
             Operator::I32x4TruncSatF64x2SZero | Operator::I32x4TruncSatF64x2UZero => {
                 let ((min, max), (cmp_min, cmp_max)) = match op {
                     Operator::I32x4TruncSatF64x2SZero => (
-                        (std::i32::MIN as u64, std::i32::MAX as u64),
+                        (i32::MIN as u64, i32::MAX as u64),
                         (LEF64_GEQ_I32_MIN, GEF64_LEQ_I32_MAX),
                     ),
                     Operator::I32x4TruncSatF64x2UZero => (
-                        (std::u32::MIN as u64, std::u32::MAX as u64),
+                        (u32::MIN as u64, u32::MAX as u64),
                         (LEF64_GEQ_U32_MIN, GEF64_LEQ_U32_MAX),
                     ),
                     _ => unreachable!("Unhandled internal variant"),
                 };
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
+                let v = self.apply_pending_canonicalization(v, i)?;
                 let v = v.into_int_value();
                 let res = self.trunc_sat(
                     self.intrinsics.f64x2_ty,
@@ -7125,11 +7917,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     min,
                     max,
                     v,
-                );
+                )?;
 
                 let zero = self.intrinsics.i32_consts[0];
                 let zeros = VectorType::const_vector(&[zero; 2]);
-                let res = self.builder.build_shuffle_vector(
+                let res = err!(self.builder.build_shuffle_vector(
                     res,
                     zeros,
                     VectorType::const_vector(&[
@@ -7139,38 +7931,40 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[3],
                     ]),
                     "",
-                );
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                ));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             // Operator::I64x2TruncSatF64x2S => {
             //     let (v, i) = self.state.pop1_extra()?;
-            //     let v = self.apply_pending_canonicalization(v, i);
+            //     let v = self.apply_pending_canonicalization(v, i)?;
             //     let v = v.into_int_value();
             //     let res = self.trunc_sat_into_int(
             //         self.intrinsics.f64x2_ty,
             //         self.intrinsics.i64x2_ty,
-            //         std::i64::MIN as u64,
-            //         std::i64::MAX as u64,
-            //         std::i64::MIN as u64,
-            //         std::i64::MAX as u64,
+            //         i64::MIN as u64,
+            //         i64::MAX as u64,
+            //         i64::MIN as u64,
+            //         i64::MAX as u64,
             //         v,
-            //     );
+            //     )?;
             //     self.state.push1(res);
             // }
             // Operator::I64x2TruncSatF64x2U => {
             //     let (v, i) = self.state.pop1_extra()?;
-            //     let v = self.apply_pending_canonicalization(v, i);
+            //     let v = self.apply_pending_canonicalization(v, i)?;
             //     let v = v.into_int_value();
             //     let res = self.trunc_sat_into_int(
             //         self.intrinsics.f64x2_ty,
             //         self.intrinsics.i64x2_ty,
-            //         std::u64::MIN,
-            //         std::u64::MAX,
-            //         std::u64::MIN,
-            //         std::u64::MAX,
+            //         u64::MIN,
+            //         u64::MAX,
+            //         u64::MIN,
+            //         u64::MAX,
             //         v,
-            //     );
+            //     )?;
             //     self.state.push1(res);
             // }
             Operator::I32TruncF32S => {
@@ -7179,10 +7973,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0xcf000000, // -2147483600.0
                     0x4effffff, // 2147483500.0
                     v1,
-                );
-                let res = self
-                    .builder
-                    .build_float_to_signed_int(v1, self.intrinsics.i32_ty, "");
+                )?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_float_to_signed_int(v1, self.intrinsics.i32_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32TruncF64S => {
@@ -7191,38 +7986,39 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0xc1e00000001fffff, // -2147483648.9999995
                     0x41dfffffffffffff, // 2147483647.9999998
                     v1,
-                );
-                let res = self
-                    .builder
-                    .build_float_to_signed_int(v1, self.intrinsics.i32_ty, "");
+                )?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_float_to_signed_int(v1, self.intrinsics.i32_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32TruncSatF32S => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
+                let v = self.apply_pending_canonicalization(v, i)?;
                 let v = v.into_float_value();
                 let res = self.trunc_sat_scalar(
                     self.intrinsics.i32_ty,
                     LEF32_GEQ_I32_MIN,
                     GEF32_LEQ_I32_MAX,
-                    std::i32::MIN as u32 as u64,
-                    std::i32::MAX as u32 as u64,
+                    i32::MIN as u32 as u64,
+                    i32::MAX as u32 as u64,
                     v,
-                );
+                )?;
                 self.state.push1(res);
             }
             Operator::I32TruncSatF64S => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
+                let v = self.apply_pending_canonicalization(v, i)?;
                 let v = v.into_float_value();
                 let res = self.trunc_sat_scalar(
                     self.intrinsics.i32_ty,
                     LEF64_GEQ_I32_MIN,
                     GEF64_LEQ_I32_MAX,
-                    std::i32::MIN as u64,
-                    std::i32::MAX as u64,
+                    i32::MIN as u64,
+                    i32::MAX as u64,
                     v,
-                );
+                )?;
                 self.state.push1(res);
             }
             Operator::I64TruncF32S => {
@@ -7231,10 +8027,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0xdf000000, // -9223372000000000000.0
                     0x5effffff, // 9223371500000000000.0
                     v1,
-                );
-                let res = self
-                    .builder
-                    .build_float_to_signed_int(v1, self.intrinsics.i64_ty, "");
+                )?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_float_to_signed_int(v1, self.intrinsics.i64_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64TruncF64S => {
@@ -7243,38 +8040,39 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0xc3e0000000000000, // -9223372036854776000.0
                     0x43dfffffffffffff, // 9223372036854775000.0
                     v1,
-                );
-                let res = self
-                    .builder
-                    .build_float_to_signed_int(v1, self.intrinsics.i64_ty, "");
+                )?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_float_to_signed_int(v1, self.intrinsics.i64_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64TruncSatF32S => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
+                let v = self.apply_pending_canonicalization(v, i)?;
                 let v = v.into_float_value();
                 let res = self.trunc_sat_scalar(
                     self.intrinsics.i64_ty,
                     LEF32_GEQ_I64_MIN,
                     GEF32_LEQ_I64_MAX,
-                    std::i64::MIN as u64,
-                    std::i64::MAX as u64,
+                    i64::MIN as u64,
+                    i64::MAX as u64,
                     v,
-                );
+                )?;
                 self.state.push1(res);
             }
             Operator::I64TruncSatF64S => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
+                let v = self.apply_pending_canonicalization(v, i)?;
                 let v = v.into_float_value();
                 let res = self.trunc_sat_scalar(
                     self.intrinsics.i64_ty,
                     LEF64_GEQ_I64_MIN,
                     GEF64_LEQ_I64_MAX,
-                    std::i64::MIN as u64,
-                    std::i64::MAX as u64,
+                    i64::MIN as u64,
+                    i64::MAX as u64,
                     v,
-                );
+                )?;
                 self.state.push1(res);
             }
             Operator::I32TruncF32U => {
@@ -7283,10 +8081,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0xbf7fffff, // -0.99999994
                     0x4f7fffff, // 4294967000.0
                     v1,
-                );
-                let res = self
-                    .builder
-                    .build_float_to_unsigned_int(v1, self.intrinsics.i32_ty, "");
+                )?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_float_to_unsigned_int(v1, self.intrinsics.i32_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32TruncF64U => {
@@ -7295,38 +8094,39 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0xbfefffffffffffff, // -0.9999999999999999
                     0x41efffffffffffff, // 4294967295.9999995
                     v1,
-                );
-                let res = self
-                    .builder
-                    .build_float_to_unsigned_int(v1, self.intrinsics.i32_ty, "");
+                )?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_float_to_unsigned_int(v1, self.intrinsics.i32_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32TruncSatF32U => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
+                let v = self.apply_pending_canonicalization(v, i)?;
                 let v = v.into_float_value();
                 let res = self.trunc_sat_scalar(
                     self.intrinsics.i32_ty,
                     LEF32_GEQ_U32_MIN,
                     GEF32_LEQ_U32_MAX,
-                    std::u32::MIN as u64,
-                    std::u32::MAX as u64,
+                    u32::MIN as u64,
+                    u32::MAX as u64,
                     v,
-                );
+                )?;
                 self.state.push1(res);
             }
             Operator::I32TruncSatF64U => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
+                let v = self.apply_pending_canonicalization(v, i)?;
                 let v = v.into_float_value();
                 let res = self.trunc_sat_scalar(
                     self.intrinsics.i32_ty,
                     LEF64_GEQ_U32_MIN,
                     GEF64_LEQ_U32_MAX,
-                    std::u32::MIN as u64,
-                    std::u32::MAX as u64,
+                    u32::MIN as u64,
+                    u32::MAX as u64,
                     v,
-                );
+                )?;
                 self.state.push1(res);
             }
             Operator::I64TruncF32U => {
@@ -7335,10 +8135,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0xbf7fffff, // -0.99999994
                     0x5f7fffff, // 18446743000000000000.0
                     v1,
-                );
-                let res = self
-                    .builder
-                    .build_float_to_unsigned_int(v1, self.intrinsics.i64_ty, "");
+                )?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_float_to_unsigned_int(v1, self.intrinsics.i64_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64TruncF64U => {
@@ -7347,132 +8148,135 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0xbfefffffffffffff, // -0.9999999999999999
                     0x43efffffffffffff, // 18446744073709550000.0
                     v1,
-                );
-                let res = self
-                    .builder
-                    .build_float_to_unsigned_int(v1, self.intrinsics.i64_ty, "");
+                )?;
+                let res =
+                    err!(self
+                        .builder
+                        .build_float_to_unsigned_int(v1, self.intrinsics.i64_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64TruncSatF32U => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
+                let v = self.apply_pending_canonicalization(v, i)?;
                 let v = v.into_float_value();
                 let res = self.trunc_sat_scalar(
                     self.intrinsics.i64_ty,
                     LEF32_GEQ_U64_MIN,
                     GEF32_LEQ_U64_MAX,
-                    std::u64::MIN,
-                    std::u64::MAX,
+                    u64::MIN,
+                    u64::MAX,
                     v,
-                );
+                )?;
                 self.state.push1(res);
             }
             Operator::I64TruncSatF64U => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
+                let v = self.apply_pending_canonicalization(v, i)?;
                 let v = v.into_float_value();
                 let res = self.trunc_sat_scalar(
                     self.intrinsics.i64_ty,
                     LEF64_GEQ_U64_MIN,
                     GEF64_LEQ_U64_MAX,
-                    std::u64::MIN,
-                    std::u64::MAX,
+                    u64::MIN,
+                    u64::MAX,
                     v,
-                );
+                )?;
                 self.state.push1(res);
             }
             Operator::F32DemoteF64 => {
                 let v = self.state.pop1()?;
                 let v = v.into_float_value();
-                let res = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.fptrunc_f64,
-                        &[
-                            v.into(),
-                            self.intrinsics.fp_rounding_md,
-                            self.intrinsics.fp_exception_md,
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.fptrunc_f64,
+                    &[
+                        v.into(),
+                        self.intrinsics.fp_rounding_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 self.state.push1_extra(res, ExtraInfo::pending_f32_nan());
             }
             Operator::F64PromoteF32 => {
                 let v = self.state.pop1()?;
                 let v = v.into_float_value();
-                let res = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.fpext_f32,
-                        &[v.into(), self.intrinsics.fp_exception_md],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let res = err!(self.builder.build_call(
+                    self.intrinsics.fpext_f32,
+                    &[v.into(), self.intrinsics.fp_exception_md],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 self.state.push1_extra(res, ExtraInfo::pending_f64_nan());
             }
             Operator::F32ConvertI32S | Operator::F32ConvertI64S => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
+                let v = self.apply_pending_canonicalization(v, i)?;
                 let v = v.into_int_value();
-                let res = self
-                    .builder
-                    .build_signed_int_to_float(v, self.intrinsics.f32_ty, "");
+                let res =
+                    err!(self
+                        .builder
+                        .build_signed_int_to_float(v, self.intrinsics.f32_ty, ""));
                 self.state.push1(res);
             }
             Operator::F64ConvertI32S | Operator::F64ConvertI64S => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
+                let v = self.apply_pending_canonicalization(v, i)?;
                 let v = v.into_int_value();
-                let res = self
-                    .builder
-                    .build_signed_int_to_float(v, self.intrinsics.f64_ty, "");
+                let res =
+                    err!(self
+                        .builder
+                        .build_signed_int_to_float(v, self.intrinsics.f64_ty, ""));
                 self.state.push1(res);
             }
             Operator::F32ConvertI32U | Operator::F32ConvertI64U => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
+                let v = self.apply_pending_canonicalization(v, i)?;
                 let v = v.into_int_value();
-                let res = self
-                    .builder
-                    .build_unsigned_int_to_float(v, self.intrinsics.f32_ty, "");
+                let res =
+                    err!(self
+                        .builder
+                        .build_unsigned_int_to_float(v, self.intrinsics.f32_ty, ""));
                 self.state.push1(res);
             }
             Operator::F64ConvertI32U | Operator::F64ConvertI64U => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
+                let v = self.apply_pending_canonicalization(v, i)?;
                 let v = v.into_int_value();
-                let res = self
-                    .builder
-                    .build_unsigned_int_to_float(v, self.intrinsics.f64_ty, "");
+                let res =
+                    err!(self
+                        .builder
+                        .build_unsigned_int_to_float(v, self.intrinsics.f64_ty, ""));
                 self.state.push1(res);
             }
             Operator::F32x4ConvertI32x4S => {
                 let v = self.state.pop1()?;
-                let v = self
-                    .builder
-                    .build_bitcast(v, self.intrinsics.i32x4_ty, "")
+                let v = err!(self.builder.build_bit_cast(v, self.intrinsics.i32x4_ty, ""))
                     .into_vector_value();
-                let res = self
+                let res =
+                    err!(self
+                        .builder
+                        .build_signed_int_to_float(v, self.intrinsics.f32x4_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_signed_int_to_float(v, self.intrinsics.f32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::F32x4ConvertI32x4U => {
                 let v = self.state.pop1()?;
-                let v = self
-                    .builder
-                    .build_bitcast(v, self.intrinsics.i32x4_ty, "")
+                let v = err!(self.builder.build_bit_cast(v, self.intrinsics.i32x4_ty, ""))
                     .into_vector_value();
-                let res = self
+                let res =
+                    err!(self
+                        .builder
+                        .build_unsigned_int_to_float(v, self.intrinsics.f32x4_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_unsigned_int_to_float(v, self.intrinsics.f32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::F64x2ConvertLowI32x4S | Operator::F64x2ConvertLowI32x4U => {
@@ -7486,8 +8290,8 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     _ => unreachable!("Unhandled inner case"),
                 };
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i32x4(v, i);
-                let low = self.builder.build_shuffle_vector(
+                let (v, _) = self.v128_into_i32x4(v, i)?;
+                let low = err!(self.builder.build_shuffle_vector(
                     v,
                     v.get_type().get_undef(),
                     VectorType::const_vector(&[
@@ -7495,18 +8299,21 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[1],
                     ]),
                     "",
-                );
-                let res = extend(self, low);
-                let res = self
+                ));
+                let res = err!(extend(self, low));
+                let res =
+                    err!(self
+                        .builder
+                        .build_signed_int_to_float(res, self.intrinsics.f64x2_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_signed_int_to_float(res, self.intrinsics.f64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::F64x2PromoteLowF32x4 => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_f32x4(v, i);
-                let low = self.builder.build_shuffle_vector(
+                let (v, _) = self.v128_into_f32x4(v, i)?;
+                let low = err!(self.builder.build_shuffle_vector(
                     v,
                     v.get_type().get_undef(),
                     VectorType::const_vector(&[
@@ -7514,20 +8321,22 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[1],
                     ]),
                     "",
-                );
-                let res = self
+                ));
+                let res = err!(self
                     .builder
-                    .build_float_ext(low, self.intrinsics.f64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_float_ext(low, self.intrinsics.f64x2_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1_extra(res, ExtraInfo::pending_f64_nan());
             }
             Operator::F32x4DemoteF64x2Zero => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_f64x2(v, i);
+                let (v, _) = self.v128_into_f64x2(v, i)?;
                 let f32x2_ty = self.intrinsics.f32_ty.vec_type(2);
-                let res = self.builder.build_float_trunc(v, f32x2_ty, "");
+                let res = err!(self.builder.build_float_trunc(v, f32x2_ty, ""));
                 let zeros = f32x2_ty.const_zero();
-                let res = self.builder.build_shuffle_vector(
+                let res = err!(self.builder.build_shuffle_vector(
                     res,
                     zeros,
                     VectorType::const_vector(&[
@@ -7537,54 +8346,56 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_consts[3],
                     ]),
                     "",
-                );
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                ));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1_extra(res, ExtraInfo::pending_f32_nan());
             }
             // Operator::F64x2ConvertI64x2S => {
             //     let v = self.state.pop1()?;
             //     let v = self
             //         .builder
-            //         .build_bitcast(v, self.intrinsics.i64x2_ty, "")
+            //         .build_bit_cast(v, self.intrinsics.i64x2_ty, "")
             //         .into_vector_value();
             //     let res = self
             //         .builder
             //         .build_signed_int_to_float(v, self.intrinsics.f64x2_ty, "");
-            //     let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+            //     let res = chck_err!(self.builder.build_bit_cast(res, self.intrinsics.i128_ty, ""));
             //     self.state.push1(res);
             // }
             // Operator::F64x2ConvertI64x2U => {
             //     let v = self.state.pop1()?;
             //     let v = self
             //         .builder
-            //         .build_bitcast(v, self.intrinsics.i64x2_ty, "")
+            //         .build_bit_cast(v, self.intrinsics.i64x2_ty, "")
             //         .into_vector_value();
             //     let res = self
             //         .builder
             //         .build_unsigned_int_to_float(v, self.intrinsics.f64x2_ty, "");
-            //     let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+            //     let res = chck_err!(self.builder.build_bit_cast(res, self.intrinsics.i128_ty, ""));
             //     self.state.push1(res);
             // }
             Operator::I32ReinterpretF32 => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
-                let ret = self.builder.build_bitcast(v, self.intrinsics.i32_ty, "");
+                let v = self.apply_pending_canonicalization(v, i)?;
+                let ret = err!(self.builder.build_bit_cast(v, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(ret, ExtraInfo::arithmetic_f32());
             }
             Operator::I64ReinterpretF64 => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
-                let ret = self.builder.build_bitcast(v, self.intrinsics.i64_ty, "");
+                let v = self.apply_pending_canonicalization(v, i)?;
+                let ret = err!(self.builder.build_bit_cast(v, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(ret, ExtraInfo::arithmetic_f64());
             }
             Operator::F32ReinterpretI32 => {
                 let (v, i) = self.state.pop1_extra()?;
-                let ret = self.builder.build_bitcast(v, self.intrinsics.f32_ty, "");
+                let ret = err!(self.builder.build_bit_cast(v, self.intrinsics.f32_ty, ""));
                 self.state.push1_extra(ret, i);
             }
             Operator::F64ReinterpretI64 => {
                 let (v, i) = self.state.pop1_extra()?;
-                let ret = self.builder.build_bitcast(v, self.intrinsics.f64_ty, "");
+                let ret = err!(self.builder.build_bit_cast(v, self.intrinsics.f64_ty, ""));
                 self.state.push1_extra(ret, i);
             }
 
@@ -7595,51 +8406,61 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             Operator::I32Extend8S => {
                 let value = self.state.pop1()?.into_int_value();
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
                 let extended_value =
-                    self.builder
-                        .build_int_s_extend(narrow_value, self.intrinsics.i32_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_s_extend(narrow_value, self.intrinsics.i32_ty, ""));
                 self.state.push1(extended_value);
             }
             Operator::I32Extend16S => {
                 let value = self.state.pop1()?.into_int_value();
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
                 let extended_value =
-                    self.builder
-                        .build_int_s_extend(narrow_value, self.intrinsics.i32_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_s_extend(narrow_value, self.intrinsics.i32_ty, ""));
                 self.state.push1(extended_value);
             }
             Operator::I64Extend8S => {
                 let value = self.state.pop1()?.into_int_value();
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
                 let extended_value =
-                    self.builder
-                        .build_int_s_extend(narrow_value, self.intrinsics.i64_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_s_extend(narrow_value, self.intrinsics.i64_ty, ""));
                 self.state.push1(extended_value);
             }
             Operator::I64Extend16S => {
                 let value = self.state.pop1()?.into_int_value();
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
                 let extended_value =
-                    self.builder
-                        .build_int_s_extend(narrow_value, self.intrinsics.i64_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_s_extend(narrow_value, self.intrinsics.i64_ty, ""));
                 self.state.push1(extended_value);
             }
             Operator::I64Extend32S => {
                 let value = self.state.pop1()?.into_int_value();
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i32_ty, ""));
                 let extended_value =
-                    self.builder
-                        .build_int_s_extend(narrow_value, self.intrinsics.i64_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_s_extend(narrow_value, self.intrinsics.i64_ty, ""));
                 self.state.push1(extended_value);
             }
 
@@ -7653,13 +8474,14 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
-                let result = self
-                    .builder
-                    .build_load(self.intrinsics.i32_ty, effective_address, "");
+                let result =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i32_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -7674,13 +8496,14 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
-                let result = self
-                    .builder
-                    .build_load(self.intrinsics.i64_ty, effective_address, "");
+                let result =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i64_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -7695,13 +8518,14 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.f32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
-                let result = self
-                    .builder
-                    .build_load(self.intrinsics.f32_ty, effective_address, "");
+                let result =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.f32_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -7716,13 +8540,14 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.f64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
-                let result = self
-                    .builder
-                    .build_load(self.intrinsics.f64_ty, effective_address, "");
+                let result =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.f64_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -7737,13 +8562,14 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i128_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     16,
                 )?;
                 let result =
-                    self.builder
-                        .build_load(self.intrinsics.i128_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i128_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -7754,19 +8580,20 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             }
             Operator::V128Load8Lane { ref memarg, lane } => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _i) = self.v128_into_i8x16(v, i);
+                let (v, _i) = self.v128_into_i8x16(v, i)?;
                 let offset = self.state.pop1()?.into_int_value();
                 let memory_index = MemoryIndex::from_u32(memarg.memory);
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
-                let element = self
-                    .builder
-                    .build_load(self.intrinsics.i8_ty, effective_address, "");
+                let element =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i8_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -7774,25 +8601,28 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     element.as_instruction_value().unwrap(),
                 )?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
-                let res = self.builder.build_insert_element(v, element, idx, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self.builder.build_insert_element(v, element, idx, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::V128Load16Lane { ref memarg, lane } => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, i) = self.v128_into_i16x8(v, i);
+                let (v, i) = self.v128_into_i16x8(v, i)?;
                 let offset = self.state.pop1()?.into_int_value();
                 let memory_index = MemoryIndex::from_u32(memarg.memory);
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
                 let element =
-                    self.builder
-                        .build_load(self.intrinsics.i16_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i16_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -7800,25 +8630,28 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     element.as_instruction_value().unwrap(),
                 )?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
-                let res = self.builder.build_insert_element(v, element, idx, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self.builder.build_insert_element(v, element, idx, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1_extra(res, i);
             }
             Operator::V128Load32Lane { ref memarg, lane } => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, i) = self.v128_into_i32x4(v, i);
+                let (v, i) = self.v128_into_i32x4(v, i)?;
                 let offset = self.state.pop1()?.into_int_value();
                 let memory_index = MemoryIndex::from_u32(memarg.memory);
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
                 let element =
-                    self.builder
-                        .build_load(self.intrinsics.i32_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i32_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -7826,25 +8659,28 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     element.as_instruction_value().unwrap(),
                 )?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
-                let res = self.builder.build_insert_element(v, element, idx, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self.builder.build_insert_element(v, element, idx, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1_extra(res, i);
             }
             Operator::V128Load64Lane { ref memarg, lane } => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, i) = self.v128_into_i64x2(v, i);
+                let (v, i) = self.v128_into_i64x2(v, i)?;
                 let offset = self.state.pop1()?.into_int_value();
                 let memory_index = MemoryIndex::from_u32(memarg.memory);
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
                 let element =
-                    self.builder
-                        .build_load(self.intrinsics.i64_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i64_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -7852,8 +8688,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     element.as_instruction_value().unwrap(),
                 )?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
-                let res = self.builder.build_insert_element(v, element, idx, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self.builder.build_insert_element(v, element, idx, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1_extra(res, i);
             }
 
@@ -7864,20 +8702,21 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
                 let dead_load =
-                    self.builder
-                        .build_load(self.intrinsics.i32_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i32_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     1,
                     dead_load.as_instruction_value().unwrap(),
                 )?;
-                let store = self.builder.build_store(effective_address, value);
+                let store = err!(self.builder.build_store(effective_address, value));
                 self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
             }
             Operator::I64Store { ref memarg } => {
@@ -7887,110 +8726,115 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
                 let dead_load =
-                    self.builder
-                        .build_load(self.intrinsics.i64_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i64_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     1,
                     dead_load.as_instruction_value().unwrap(),
                 )?;
-                let store = self.builder.build_store(effective_address, value);
+                let store = err!(self.builder.build_store(effective_address, value));
                 self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
             }
             Operator::F32Store { ref memarg } => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
+                let v = self.apply_pending_canonicalization(v, i)?;
                 let offset = self.state.pop1()?.into_int_value();
                 let memory_index = MemoryIndex::from_u32(0);
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.f32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
                 let dead_load =
-                    self.builder
-                        .build_load(self.intrinsics.f32_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.f32_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     1,
                     dead_load.as_instruction_value().unwrap(),
                 )?;
-                let store = self.builder.build_store(effective_address, v);
+                let store = err!(self.builder.build_store(effective_address, v));
                 self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
             }
             Operator::F64Store { ref memarg } => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
+                let v = self.apply_pending_canonicalization(v, i)?;
                 let offset = self.state.pop1()?.into_int_value();
                 let memory_index = MemoryIndex::from_u32(0);
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.f64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
                 let dead_load =
-                    self.builder
-                        .build_load(self.intrinsics.f64_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.f64_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     1,
                     dead_load.as_instruction_value().unwrap(),
                 )?;
-                let store = self.builder.build_store(effective_address, v);
+                let store = err!(self.builder.build_store(effective_address, v));
                 self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
             }
             Operator::V128Store { ref memarg } => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i);
+                let v = self.apply_pending_canonicalization(v, i)?;
                 let offset = self.state.pop1()?.into_int_value();
                 let memory_index = MemoryIndex::from_u32(0);
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i128_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     16,
                 )?;
                 let dead_load =
-                    self.builder
-                        .build_load(self.intrinsics.i128_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i128_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     1,
                     dead_load.as_instruction_value().unwrap(),
                 )?;
-                let store = self.builder.build_store(effective_address, v);
+                let store = err!(self.builder.build_store(effective_address, v));
                 self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
             }
             Operator::V128Store8Lane { ref memarg, lane } => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _i) = self.v128_into_i8x16(v, i);
+                let (v, _i) = self.v128_into_i8x16(v, i)?;
                 let offset = self.state.pop1()?.into_int_value();
                 let memory_index = MemoryIndex::from_u32(memarg.memory);
 
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
                 let dead_load =
-                    self.builder
-                        .build_load(self.intrinsics.i8_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i8_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -7998,26 +8842,27 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     dead_load.as_instruction_value().unwrap(),
                 )?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
-                let val = self.builder.build_extract_element(v, idx, "");
-                let store = self.builder.build_store(effective_address, val);
+                let val = err!(self.builder.build_extract_element(v, idx, ""));
+                let store = err!(self.builder.build_store(effective_address, val));
                 self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
             }
             Operator::V128Store16Lane { ref memarg, lane } => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _i) = self.v128_into_i16x8(v, i);
+                let (v, _i) = self.v128_into_i16x8(v, i)?;
                 let offset = self.state.pop1()?.into_int_value();
                 let memory_index = MemoryIndex::from_u32(memarg.memory);
 
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
                 let dead_load =
-                    self.builder
-                        .build_load(self.intrinsics.i16_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i16_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -8025,26 +8870,27 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     dead_load.as_instruction_value().unwrap(),
                 )?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
-                let val = self.builder.build_extract_element(v, idx, "");
-                let store = self.builder.build_store(effective_address, val);
+                let val = err!(self.builder.build_extract_element(v, idx, ""));
+                let store = err!(self.builder.build_store(effective_address, val));
                 self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
             }
             Operator::V128Store32Lane { ref memarg, lane } => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _i) = self.v128_into_i32x4(v, i);
+                let (v, _i) = self.v128_into_i32x4(v, i)?;
                 let offset = self.state.pop1()?.into_int_value();
                 let memory_index = MemoryIndex::from_u32(memarg.memory);
 
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
                 let dead_load =
-                    self.builder
-                        .build_load(self.intrinsics.i32_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i32_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -8052,26 +8898,27 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     dead_load.as_instruction_value().unwrap(),
                 )?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
-                let val = self.builder.build_extract_element(v, idx, "");
-                let store = self.builder.build_store(effective_address, val);
+                let val = err!(self.builder.build_extract_element(v, idx, ""));
+                let store = err!(self.builder.build_store(effective_address, val));
                 self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
             }
             Operator::V128Store64Lane { ref memarg, lane } => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _i) = self.v128_into_i64x2(v, i);
+                let (v, _i) = self.v128_into_i64x2(v, i)?;
                 let offset = self.state.pop1()?.into_int_value();
                 let memory_index = MemoryIndex::from_u32(memarg.memory);
 
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
                 let dead_load =
-                    self.builder
-                        .build_load(self.intrinsics.i64_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i64_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -8079,8 +8926,8 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     dead_load.as_instruction_value().unwrap(),
                 )?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
-                let val = self.builder.build_extract_element(v, idx, "");
-                let store = self.builder.build_store(effective_address, val);
+                let val = err!(self.builder.build_extract_element(v, idx, ""));
+                let store = err!(self.builder.build_store(effective_address, val));
                 self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
             }
             Operator::I32Load8S { ref memarg } => {
@@ -8089,24 +8936,25 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
                 let narrow_result =
-                    self.builder
-                        .build_load(self.intrinsics.i8_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i8_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     1,
                     narrow_result.as_instruction_value().unwrap(),
                 )?;
-                let result = self.builder.build_int_s_extend(
+                let result = err!(self.builder.build_int_s_extend(
                     narrow_result.into_int_value(),
                     self.intrinsics.i32_ty,
                     "",
-                );
+                ));
                 self.state.push1(result);
             }
             Operator::I32Load16S { ref memarg } => {
@@ -8115,24 +8963,25 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
                 let narrow_result =
-                    self.builder
-                        .build_load(self.intrinsics.i16_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i16_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     1,
                     narrow_result.as_instruction_value().unwrap(),
                 )?;
-                let result = self.builder.build_int_s_extend(
+                let result = err!(self.builder.build_int_s_extend(
                     narrow_result.into_int_value(),
                     self.intrinsics.i32_ty,
                     "",
-                );
+                ));
                 self.state.push1(result);
             }
             Operator::I64Load8S { ref memarg } => {
@@ -8141,13 +8990,14 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
-                let narrow_result = self
-                    .builder
-                    .build_load(self.intrinsics.i8_ty, effective_address, "")
+                let narrow_result =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i8_ty, effective_address, ""))
                     .into_int_value();
                 self.annotate_user_memaccess(
                     memory_index,
@@ -8155,9 +9005,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     1,
                     narrow_result.as_instruction_value().unwrap(),
                 )?;
-                let result =
-                    self.builder
-                        .build_int_s_extend(narrow_result, self.intrinsics.i64_ty, "");
+                let result = err!(self.builder.build_int_s_extend(
+                    narrow_result,
+                    self.intrinsics.i64_ty,
+                    ""
+                ));
                 self.state.push1(result);
             }
             Operator::I64Load16S { ref memarg } => {
@@ -8166,13 +9018,14 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
-                let narrow_result = self
-                    .builder
-                    .build_load(self.intrinsics.i16_ty, effective_address, "")
+                let narrow_result =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i16_ty, effective_address, ""))
                     .into_int_value();
                 self.annotate_user_memaccess(
                     memory_index,
@@ -8180,9 +9033,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     1,
                     narrow_result.as_instruction_value().unwrap(),
                 )?;
-                let result =
-                    self.builder
-                        .build_int_s_extend(narrow_result, self.intrinsics.i64_ty, "");
+                let result = err!(self.builder.build_int_s_extend(
+                    narrow_result,
+                    self.intrinsics.i64_ty,
+                    ""
+                ));
                 self.state.push1(result);
             }
             Operator::I64Load32S { ref memarg } => {
@@ -8191,24 +9046,25 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
                 let narrow_result =
-                    self.builder
-                        .build_load(self.intrinsics.i32_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i32_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     1,
                     narrow_result.as_instruction_value().unwrap(),
                 )?;
-                let result = self.builder.build_int_s_extend(
+                let result = err!(self.builder.build_int_s_extend(
                     narrow_result.into_int_value(),
                     self.intrinsics.i64_ty,
                     "",
-                );
+                ));
                 self.state.push1(result);
             }
 
@@ -8218,24 +9074,25 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
                 let narrow_result =
-                    self.builder
-                        .build_load(self.intrinsics.i8_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i8_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     1,
                     narrow_result.as_instruction_value().unwrap(),
                 )?;
-                let result = self.builder.build_int_z_extend(
+                let result = err!(self.builder.build_int_z_extend(
                     narrow_result.into_int_value(),
                     self.intrinsics.i32_ty,
                     "",
-                );
+                ));
                 self.state.push1_extra(result, ExtraInfo::arithmetic_f32());
             }
             Operator::I32Load16U { ref memarg } => {
@@ -8244,24 +9101,25 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
                 let narrow_result =
-                    self.builder
-                        .build_load(self.intrinsics.i16_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i16_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     1,
                     narrow_result.as_instruction_value().unwrap(),
                 )?;
-                let result = self.builder.build_int_z_extend(
+                let result = err!(self.builder.build_int_z_extend(
                     narrow_result.into_int_value(),
                     self.intrinsics.i32_ty,
                     "",
-                );
+                ));
                 self.state.push1_extra(result, ExtraInfo::arithmetic_f32());
             }
             Operator::I64Load8U { ref memarg } => {
@@ -8270,24 +9128,25 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
                 let narrow_result =
-                    self.builder
-                        .build_load(self.intrinsics.i8_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i8_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     1,
                     narrow_result.as_instruction_value().unwrap(),
                 )?;
-                let result = self.builder.build_int_z_extend(
+                let result = err!(self.builder.build_int_z_extend(
                     narrow_result.into_int_value(),
                     self.intrinsics.i64_ty,
                     "",
-                );
+                ));
                 self.state.push1_extra(result, ExtraInfo::arithmetic_f64());
             }
             Operator::I64Load16U { ref memarg } => {
@@ -8296,24 +9155,25 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
                 let narrow_result =
-                    self.builder
-                        .build_load(self.intrinsics.i16_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i16_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     1,
                     narrow_result.as_instruction_value().unwrap(),
                 )?;
-                let result = self.builder.build_int_z_extend(
+                let result = err!(self.builder.build_int_z_extend(
                     narrow_result.into_int_value(),
                     self.intrinsics.i64_ty,
                     "",
-                );
+                ));
                 self.state.push1_extra(result, ExtraInfo::arithmetic_f64());
             }
             Operator::I64Load32U { ref memarg } => {
@@ -8322,24 +9182,25 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
                 let narrow_result =
-                    self.builder
-                        .build_load(self.intrinsics.i32_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i32_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     1,
                     narrow_result.as_instruction_value().unwrap(),
                 )?;
-                let result = self.builder.build_int_z_extend(
+                let result = err!(self.builder.build_int_z_extend(
                     narrow_result.into_int_value(),
                     self.intrinsics.i64_ty,
                     "",
-                );
+                ));
                 self.state.push1_extra(result, ExtraInfo::arithmetic_f64());
             }
 
@@ -8350,13 +9211,14 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
                 let dead_load =
-                    self.builder
-                        .build_load(self.intrinsics.i8_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i8_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -8364,9 +9226,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     dead_load.as_instruction_value().unwrap(),
                 )?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
-                let store = self.builder.build_store(effective_address, narrow_value);
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
+                let store = err!(self.builder.build_store(effective_address, narrow_value));
                 self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
             }
             Operator::I32Store16 { ref memarg } | Operator::I64Store16 { ref memarg } => {
@@ -8376,13 +9239,14 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
                 let dead_load =
-                    self.builder
-                        .build_load(self.intrinsics.i16_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i16_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -8390,9 +9254,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     dead_load.as_instruction_value().unwrap(),
                 )?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
-                let store = self.builder.build_store(effective_address, narrow_value);
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
+                let store = err!(self.builder.build_store(effective_address, narrow_value));
                 self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
             }
             Operator::I64Store32 { ref memarg } => {
@@ -8402,13 +9267,14 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
                 let dead_load =
-                    self.builder
-                        .build_load(self.intrinsics.i32_ty, effective_address, "");
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i32_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
@@ -8416,61 +9282,70 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     dead_load.as_instruction_value().unwrap(),
                 )?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
-                let store = self.builder.build_store(effective_address, narrow_value);
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i32_ty, ""));
+                let store = err!(self.builder.build_store(effective_address, narrow_value));
                 self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
             }
             Operator::I8x16Neg => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i8x16(v, i);
-                let res = self.builder.build_int_sub(v.get_type().const_zero(), v, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let (v, _) = self.v128_into_i8x16(v, i)?;
+                let res = err!(self.builder.build_int_sub(v.get_type().const_zero(), v, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8Neg => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i16x8(v, i);
-                let res = self.builder.build_int_sub(v.get_type().const_zero(), v, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let (v, _) = self.v128_into_i16x8(v, i)?;
+                let res = err!(self.builder.build_int_sub(v.get_type().const_zero(), v, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4Neg => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i32x4(v, i);
-                let res = self.builder.build_int_sub(v.get_type().const_zero(), v, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let (v, _) = self.v128_into_i32x4(v, i)?;
+                let res = err!(self.builder.build_int_sub(v.get_type().const_zero(), v, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I64x2Neg => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i64x2(v, i);
-                let res = self.builder.build_int_sub(v.get_type().const_zero(), v, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let (v, _) = self.v128_into_i64x2(v, i)?;
+                let res = err!(self.builder.build_int_sub(v.get_type().const_zero(), v, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::V128Not => {
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i).into_int_value();
-                let res = self.builder.build_not(v, "");
+                let v = self.apply_pending_canonicalization(v, i)?.into_int_value();
+                let res = err!(self.builder.build_not(v, ""));
                 self.state.push1(res);
             }
             Operator::V128AnyTrue => {
                 // | Operator::I64x2AnyTrue
                 // Skip canonicalization, it never changes non-zero values to zero or vice versa.
                 let v = self.state.pop1()?.into_int_value();
-                let res = self.builder.build_int_compare(
+                let res = err!(self.builder.build_int_compare(
                     IntPredicate::NE,
                     v,
                     v.get_type().const_zero(),
                     "",
-                );
-                let res = self
+                ));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(res, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(res, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(
                     res,
-                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                    (ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64())?,
                 );
             }
             Operator::I8x16AllTrue
@@ -8485,290 +9360,279 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     _ => unreachable!(),
                 };
                 let (v, i) = self.state.pop1_extra()?;
-                let v = self.apply_pending_canonicalization(v, i).into_int_value();
+                let v = self.apply_pending_canonicalization(v, i)?.into_int_value();
                 let lane_int_ty = self.context.custom_width_int_type(vec_ty.get_size());
-                let vec = self
-                    .builder
-                    .build_bitcast(v, vec_ty, "vec")
-                    .into_vector_value();
-                let mask = self.builder.build_int_compare(
+                let vec = err!(self.builder.build_bit_cast(v, vec_ty, "vec")).into_vector_value();
+                let mask = err!(self.builder.build_int_compare(
                     IntPredicate::NE,
                     vec,
                     vec_ty.const_zero(),
                     "mask",
-                );
-                let cmask = self
-                    .builder
-                    .build_bitcast(mask, lane_int_ty, "cmask")
-                    .into_int_value();
-                let res = self.builder.build_int_compare(
+                ));
+                let cmask =
+                    err!(self.builder.build_bit_cast(mask, lane_int_ty, "cmask")).into_int_value();
+                let res = err!(self.builder.build_int_compare(
                     IntPredicate::EQ,
                     cmask,
-                    lane_int_ty.const_int(std::u64::MAX, true),
+                    lane_int_ty.const_int(u64::MAX, true),
                     "",
-                );
-                let res = self
+                ));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(res, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(res, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(
                     res,
-                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                    (ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64())?,
                 );
             }
             Operator::I8x16ExtractLaneS { lane } => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i8x16(v, i);
+                let (v, _) = self.v128_into_i8x16(v, i)?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
-                let res = self
+                let res = err!(self.builder.build_extract_element(v, idx, "")).into_int_value();
+                let res = err!(self
                     .builder
-                    .build_extract_element(v, idx, "")
-                    .into_int_value();
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i32_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i32_ty, ""));
                 self.state.push1(res);
             }
             Operator::I8x16ExtractLaneU { lane } => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i8x16(v, i);
+                let (v, _) = self.v128_into_i8x16(v, i)?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
-                let res = self
-                    .builder
-                    .build_extract_element(v, idx, "")
-                    .into_int_value();
-                let res = self
+                let res = err!(self.builder.build_extract_element(v, idx, "")).into_int_value();
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(res, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(res, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(res, ExtraInfo::arithmetic_f32());
             }
             Operator::I16x8ExtractLaneS { lane } => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i16x8(v, i);
+                let (v, _) = self.v128_into_i16x8(v, i)?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
-                let res = self
+                let res = err!(self.builder.build_extract_element(v, idx, "")).into_int_value();
+                let res = err!(self
                     .builder
-                    .build_extract_element(v, idx, "")
-                    .into_int_value();
-                let res = self
-                    .builder
-                    .build_int_s_extend(res, self.intrinsics.i32_ty, "");
+                    .build_int_s_extend(res, self.intrinsics.i32_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8ExtractLaneU { lane } => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, _) = self.v128_into_i16x8(v, i);
+                let (v, _) = self.v128_into_i16x8(v, i)?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
-                let res = self
-                    .builder
-                    .build_extract_element(v, idx, "")
-                    .into_int_value();
-                let res = self
+                let res = err!(self.builder.build_extract_element(v, idx, "")).into_int_value();
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(res, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(res, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(res, ExtraInfo::arithmetic_f32());
             }
             Operator::I32x4ExtractLane { lane } => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, i) = self.v128_into_i32x4(v, i);
+                let (v, i) = self.v128_into_i32x4(v, i)?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
-                let res = self.builder.build_extract_element(v, idx, "");
+                let res = err!(self.builder.build_extract_element(v, idx, ""));
                 self.state.push1_extra(res, i);
             }
             Operator::I64x2ExtractLane { lane } => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, i) = self.v128_into_i64x2(v, i);
+                let (v, i) = self.v128_into_i64x2(v, i)?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
-                let res = self.builder.build_extract_element(v, idx, "");
+                let res = err!(self.builder.build_extract_element(v, idx, ""));
                 self.state.push1_extra(res, i);
             }
             Operator::F32x4ExtractLane { lane } => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, i) = self.v128_into_f32x4(v, i);
+                let (v, i) = self.v128_into_f32x4(v, i)?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
-                let res = self.builder.build_extract_element(v, idx, "");
+                let res = err!(self.builder.build_extract_element(v, idx, ""));
                 self.state.push1_extra(res, i);
             }
             Operator::F64x2ExtractLane { lane } => {
                 let (v, i) = self.state.pop1_extra()?;
-                let (v, i) = self.v128_into_f64x2(v, i);
+                let (v, i) = self.v128_into_f64x2(v, i)?;
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
-                let res = self.builder.build_extract_element(v, idx, "");
+                let res = err!(self.builder.build_extract_element(v, idx, ""));
                 self.state.push1_extra(res, i);
             }
             Operator::I8x16ReplaceLane { lane } => {
                 let ((v1, i1), (v2, _)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v1, _) = self.v128_into_i8x16(v1, i1)?;
                 let v2 = v2.into_int_value();
-                let v2 = self.builder.build_int_cast(v2, self.intrinsics.i8_ty, "");
+                let v2 = err!(self.builder.build_int_cast(v2, self.intrinsics.i8_ty, ""));
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
-                let res = self.builder.build_insert_element(v1, v2, idx, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self.builder.build_insert_element(v1, v2, idx, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I16x8ReplaceLane { lane } => {
                 let ((v1, i1), (v2, _)) = self.state.pop2_extra()?;
-                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v1, _) = self.v128_into_i16x8(v1, i1)?;
                 let v2 = v2.into_int_value();
-                let v2 = self.builder.build_int_cast(v2, self.intrinsics.i16_ty, "");
+                let v2 = err!(self.builder.build_int_cast(v2, self.intrinsics.i16_ty, ""));
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
-                let res = self.builder.build_insert_element(v1, v2, idx, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self.builder.build_insert_element(v1, v2, idx, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I32x4ReplaceLane { lane } => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, i1) = self.v128_into_i32x4(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, i1) = self.v128_into_i32x4(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let v2 = v2.into_int_value();
                 let i2 = i2.strip_pending();
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
-                let res = self.builder.build_insert_element(v1, v2, idx, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self.builder.build_insert_element(v1, v2, idx, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state
-                    .push1_extra(res, i1 & i2 & ExtraInfo::arithmetic_f32());
+                    .push1_extra(res, ((i1 & i2)? & ExtraInfo::arithmetic_f32())?);
             }
             Operator::I64x2ReplaceLane { lane } => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, i1) = self.v128_into_i64x2(v1, i1);
-                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, i1) = self.v128_into_i64x2(v1, i1)?;
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
                 let v2 = v2.into_int_value();
                 let i2 = i2.strip_pending();
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
-                let res = self.builder.build_insert_element(v1, v2, idx, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self.builder.build_insert_element(v1, v2, idx, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state
-                    .push1_extra(res, i1 & i2 & ExtraInfo::arithmetic_f64());
+                    .push1_extra(res, ((i1 & i2)? & ExtraInfo::arithmetic_f64())?);
             }
             Operator::F32x4ReplaceLane { lane } => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, i1) = self.v128_into_f32x4(v1, i1);
+                let (v1, i1) = self.v128_into_f32x4(v1, i1)?;
                 let push_pending_f32_nan_to_result =
                     i1.has_pending_f32_nan() && i2.has_pending_f32_nan();
                 let (v1, v2) = if !push_pending_f32_nan_to_result {
                     (
-                        self.apply_pending_canonicalization(v1.as_basic_value_enum(), i1)
+                        self.apply_pending_canonicalization(v1.as_basic_value_enum(), i1)?
                             .into_vector_value(),
-                        self.apply_pending_canonicalization(v2.as_basic_value_enum(), i2)
+                        self.apply_pending_canonicalization(v2.as_basic_value_enum(), i2)?
                             .into_float_value(),
                     )
                 } else {
                     (v1, v2.into_float_value())
                 };
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
-                let res = self.builder.build_insert_element(v1, v2, idx, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self.builder.build_insert_element(v1, v2, idx, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 let info = if push_pending_f32_nan_to_result {
                     ExtraInfo::pending_f32_nan()
                 } else {
-                    i1.strip_pending() & i2.strip_pending()
+                    (i1.strip_pending() & i2.strip_pending())?
                 };
                 self.state.push1_extra(res, info);
             }
             Operator::F64x2ReplaceLane { lane } => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let (v1, i1) = self.v128_into_f64x2(v1, i1);
+                let (v1, i1) = self.v128_into_f64x2(v1, i1)?;
                 let push_pending_f64_nan_to_result =
                     i1.has_pending_f64_nan() && i2.has_pending_f64_nan();
                 let (v1, v2) = if !push_pending_f64_nan_to_result {
                     (
-                        self.apply_pending_canonicalization(v1.as_basic_value_enum(), i1)
+                        self.apply_pending_canonicalization(v1.as_basic_value_enum(), i1)?
                             .into_vector_value(),
-                        self.apply_pending_canonicalization(v2.as_basic_value_enum(), i2)
+                        self.apply_pending_canonicalization(v2.as_basic_value_enum(), i2)?
                             .into_float_value(),
                     )
                 } else {
                     (v1, v2.into_float_value())
                 };
                 let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
-                let res = self.builder.build_insert_element(v1, v2, idx, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self.builder.build_insert_element(v1, v2, idx, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 let info = if push_pending_f64_nan_to_result {
                     ExtraInfo::pending_f64_nan()
                 } else {
-                    i1.strip_pending() & i2.strip_pending()
+                    (i1.strip_pending() & i2.strip_pending())?
                 };
                 self.state.push1_extra(res, info);
             }
             Operator::I8x16Swizzle => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v1 = self
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v1 = err!(self
                     .builder
-                    .build_bitcast(v1, self.intrinsics.i8x16_ty, "")
-                    .into_vector_value();
-                let v2 = self.apply_pending_canonicalization(v2, i2);
-                let v2 = self
+                    .build_bit_cast(v1, self.intrinsics.i8x16_ty, ""))
+                .into_vector_value();
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
+                let v2 = err!(self
                     .builder
-                    .build_bitcast(v2, self.intrinsics.i8x16_ty, "")
-                    .into_vector_value();
+                    .build_bit_cast(v2, self.intrinsics.i8x16_ty, ""))
+                .into_vector_value();
                 let lanes = self.intrinsics.i8_ty.const_int(16, false);
                 let lanes =
-                    self.splat_vector(lanes.as_basic_value_enum(), self.intrinsics.i8x16_ty);
+                    self.splat_vector(lanes.as_basic_value_enum(), self.intrinsics.i8x16_ty)?;
                 let mut res = self.intrinsics.i8x16_ty.get_undef();
-                let idx_out_of_range = self.builder.build_int_compare(
+                let idx_out_of_range = err!(self.builder.build_int_compare(
                     IntPredicate::UGE,
                     v2,
                     lanes,
                     "idx_out_of_range",
-                );
-                let idx_clamped = self
-                    .builder
-                    .build_select(
-                        idx_out_of_range,
-                        self.intrinsics.i8x16_ty.const_zero(),
-                        v2,
-                        "idx_clamped",
-                    )
-                    .into_vector_value();
+                ));
+                let idx_clamped = err!(self.builder.build_select(
+                    idx_out_of_range,
+                    self.intrinsics.i8x16_ty.const_zero(),
+                    v2,
+                    "idx_clamped",
+                ))
+                .into_vector_value();
                 for i in 0..16 {
-                    let idx = self
-                        .builder
-                        .build_extract_element(
-                            idx_clamped,
-                            self.intrinsics.i32_ty.const_int(i, false),
-                            "idx",
-                        )
-                        .into_int_value();
-                    let replace_with_zero = self
-                        .builder
-                        .build_extract_element(
-                            idx_out_of_range,
-                            self.intrinsics.i32_ty.const_int(i, false),
-                            "replace_with_zero",
-                        )
-                        .into_int_value();
-                    let elem = self
-                        .builder
-                        .build_extract_element(v1, idx, "elem")
-                        .into_int_value();
-                    let elem_or_zero = self.builder.build_select(
+                    let idx = err!(self.builder.build_extract_element(
+                        idx_clamped,
+                        self.intrinsics.i32_ty.const_int(i, false),
+                        "idx",
+                    ))
+                    .into_int_value();
+                    let replace_with_zero = err!(self.builder.build_extract_element(
+                        idx_out_of_range,
+                        self.intrinsics.i32_ty.const_int(i, false),
+                        "replace_with_zero",
+                    ))
+                    .into_int_value();
+                    let elem =
+                        err!(self.builder.build_extract_element(v1, idx, "elem")).into_int_value();
+                    let elem_or_zero = err!(self.builder.build_select(
                         replace_with_zero,
                         self.intrinsics.i8_zero,
                         elem,
                         "elem_or_zero",
-                    );
-                    res = self.builder.build_insert_element(
+                    ));
+                    res = err!(self.builder.build_insert_element(
                         res,
                         elem_or_zero,
                         self.intrinsics.i32_ty.const_int(i, false),
                         "",
-                    );
+                    ));
                 }
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::I8x16Shuffle { lanes } => {
                 let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
-                let v1 = self.apply_pending_canonicalization(v1, i1);
-                let v1 = self
+                let v1 = self.apply_pending_canonicalization(v1, i1)?;
+                let v1 = err!(self
                     .builder
-                    .build_bitcast(v1, self.intrinsics.i8x16_ty, "")
-                    .into_vector_value();
-                let v2 = self.apply_pending_canonicalization(v2, i2);
-                let v2 = self
+                    .build_bit_cast(v1, self.intrinsics.i8x16_ty, ""))
+                .into_vector_value();
+                let v2 = self.apply_pending_canonicalization(v2, i2)?;
+                let v2 = err!(self
                     .builder
-                    .build_bitcast(v2, self.intrinsics.i8x16_ty, "")
-                    .into_vector_value();
+                    .build_bit_cast(v2, self.intrinsics.i8x16_ty, ""))
+                .into_vector_value();
                 let mask = VectorType::const_vector(
                     lanes
                         .iter()
@@ -8776,8 +9640,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         .collect::<Vec<IntValue>>()
                         .as_slice(),
                 );
-                let res = self.builder.build_shuffle_vector(v1, v2, mask, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = err!(self.builder.build_shuffle_vector(v1, v2, mask, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::V128Load8x8S { ref memarg } => {
@@ -8786,21 +9652,24 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
-                let v = self
+                let v =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i64_ty, effective_address, ""));
+                let v = err!(self
                     .builder
-                    .build_load(self.intrinsics.i64_ty, effective_address, "");
-                let v = self
+                    .build_bit_cast(v, self.intrinsics.i8_ty.vec_type(8), ""))
+                .into_vector_value();
+                let res = err!(self
                     .builder
-                    .build_bitcast(v, self.intrinsics.i8_ty.vec_type(8), "")
-                    .into_vector_value();
-                let res = self
+                    .build_int_s_extend(v, self.intrinsics.i16x8_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(v, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::V128Load8x8U { ref memarg } => {
@@ -8809,21 +9678,24 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
-                let v = self
+                let v =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i64_ty, effective_address, ""));
+                let v = err!(self
                     .builder
-                    .build_load(self.intrinsics.i64_ty, effective_address, "");
-                let v = self
+                    .build_bit_cast(v, self.intrinsics.i8_ty.vec_type(8), ""))
+                .into_vector_value();
+                let res = err!(self
                     .builder
-                    .build_bitcast(v, self.intrinsics.i8_ty.vec_type(8), "")
-                    .into_vector_value();
-                let res = self
+                    .build_int_z_extend(v, self.intrinsics.i16x8_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(v, self.intrinsics.i16x8_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::V128Load16x4S { ref memarg } => {
@@ -8832,21 +9704,25 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
-                let v = self
-                    .builder
-                    .build_load(self.intrinsics.i64_ty, effective_address, "");
-                let v = self
-                    .builder
-                    .build_bitcast(v, self.intrinsics.i16_ty.vec_type(4), "")
+                let v =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i64_ty, effective_address, ""));
+                let v =
+                    err!(self
+                        .builder
+                        .build_bit_cast(v, self.intrinsics.i16_ty.vec_type(4), ""))
                     .into_vector_value();
-                let res = self
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(v, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(v, self.intrinsics.i32x4_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::V128Load16x4U { ref memarg } => {
@@ -8855,21 +9731,25 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
-                let v = self
-                    .builder
-                    .build_load(self.intrinsics.i64_ty, effective_address, "");
-                let v = self
-                    .builder
-                    .build_bitcast(v, self.intrinsics.i16_ty.vec_type(4), "")
+                let v =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i64_ty, effective_address, ""));
+                let v =
+                    err!(self
+                        .builder
+                        .build_bit_cast(v, self.intrinsics.i16_ty.vec_type(4), ""))
                     .into_vector_value();
-                let res = self
+                let res = err!(self
+                    .builder
+                    .build_int_z_extend(v, self.intrinsics.i32x4_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(v, self.intrinsics.i32x4_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::V128Load32x2S { ref memarg } => {
@@ -8878,21 +9758,25 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
-                let v = self
-                    .builder
-                    .build_load(self.intrinsics.i64_ty, effective_address, "");
-                let v = self
-                    .builder
-                    .build_bitcast(v, self.intrinsics.i32_ty.vec_type(2), "")
+                let v =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i64_ty, effective_address, ""));
+                let v =
+                    err!(self
+                        .builder
+                        .build_bit_cast(v, self.intrinsics.i32_ty.vec_type(2), ""))
                     .into_vector_value();
-                let res = self
+                let res = err!(self
                     .builder
-                    .build_int_s_extend(v, self.intrinsics.i64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_int_s_extend(v, self.intrinsics.i64x2_ty, ""));
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::V128Load32x2U { ref memarg } => {
@@ -8901,21 +9785,25 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
-                let v = self
-                    .builder
-                    .build_load(self.intrinsics.i64_ty, effective_address, "");
-                let v = self
-                    .builder
-                    .build_bitcast(v, self.intrinsics.i32_ty.vec_type(2), "")
+                let v =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i64_ty, effective_address, ""));
+                let v =
+                    err!(self
+                        .builder
+                        .build_bit_cast(v, self.intrinsics.i32_ty.vec_type(2), ""))
                     .into_vector_value();
-                let res = self
+                let res = err!(self
+                    .builder
+                    .build_int_z_extend(v, self.intrinsics.i64x2_ty, ""));
+                let res = err!(self
                     .builder
-                    .build_int_z_extend(v, self.intrinsics.i64x2_ty, "");
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::V128Load32Zero { ref memarg } => {
@@ -8924,24 +9812,25 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
-                let elem = self
-                    .builder
-                    .build_load(self.intrinsics.i32_ty, effective_address, "");
+                let elem =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i32_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     1,
                     elem.as_instruction_value().unwrap(),
                 )?;
-                let res = self.builder.build_int_z_extend(
+                let res = err!(self.builder.build_int_z_extend(
                     elem.into_int_value(),
                     self.intrinsics.i128_ty,
                     "",
-                );
+                ));
                 self.state.push1(res);
             }
             Operator::V128Load64Zero { ref memarg } => {
@@ -8950,24 +9839,25 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
-                let elem = self
-                    .builder
-                    .build_load(self.intrinsics.i64_ty, effective_address, "");
+                let elem =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i64_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     1,
                     elem.as_instruction_value().unwrap(),
                 )?;
-                let res = self.builder.build_int_z_extend(
+                let res = err!(self.builder.build_int_z_extend(
                     elem.into_int_value(),
                     self.intrinsics.i128_ty,
                     "",
-                );
+                ));
                 self.state.push1(res);
             }
             Operator::V128Load8Splat { ref memarg } => {
@@ -8976,21 +9866,24 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
-                let elem = self
-                    .builder
-                    .build_load(self.intrinsics.i8_ty, effective_address, "");
+                let elem =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i8_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     1,
                     elem.as_instruction_value().unwrap(),
                 )?;
-                let res = self.splat_vector(elem, self.intrinsics.i8x16_ty);
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = self.splat_vector(elem, self.intrinsics.i8x16_ty)?;
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::V128Load16Splat { ref memarg } => {
@@ -8999,21 +9892,24 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
-                let elem = self
-                    .builder
-                    .build_load(self.intrinsics.i16_ty, effective_address, "");
+                let elem =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i16_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     1,
                     elem.as_instruction_value().unwrap(),
                 )?;
-                let res = self.splat_vector(elem, self.intrinsics.i16x8_ty);
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = self.splat_vector(elem, self.intrinsics.i16x8_ty)?;
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::V128Load32Splat { ref memarg } => {
@@ -9022,21 +9918,24 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
-                let elem = self
-                    .builder
-                    .build_load(self.intrinsics.i32_ty, effective_address, "");
+                let elem =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i32_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     1,
                     elem.as_instruction_value().unwrap(),
                 )?;
-                let res = self.splat_vector(elem, self.intrinsics.i32x4_ty);
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = self.splat_vector(elem, self.intrinsics.i32x4_ty)?;
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::V128Load64Splat { ref memarg } => {
@@ -9045,21 +9944,24 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
-                let elem = self
-                    .builder
-                    .build_load(self.intrinsics.i64_ty, effective_address, "");
+                let elem =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i64_ty, effective_address, ""));
                 self.annotate_user_memaccess(
                     memory_index,
                     memarg,
                     1,
                     elem.as_instruction_value().unwrap(),
                 )?;
-                let res = self.splat_vector(elem, self.intrinsics.i64x2_ty);
-                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let res = self.splat_vector(elem, self.intrinsics.i64x2_ty)?;
+                let res = err!(self
+                    .builder
+                    .build_bit_cast(res, self.intrinsics.i128_ty, ""));
                 self.state.push1(res);
             }
             Operator::AtomicFence => {
@@ -9077,14 +9979,16 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 4);
-                let result = self
-                    .builder
-                    .build_load(self.intrinsics.i32_ty, effective_address, "");
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
+                let result = err!(self.builder.build_load(
+                    self.intrinsics.i32_ty,
+                    effective_address,
+                    "atomic_load"
+                ));
                 let load = result.as_instruction_value().unwrap();
                 self.annotate_user_memaccess(memory_index, memarg, 4, load)?;
                 load.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
@@ -9097,14 +10001,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 8);
-                let result = self
-                    .builder
-                    .build_load(self.intrinsics.i64_ty, effective_address, "");
+                self.trap_if_misaligned(memarg, effective_address, 8)?;
+                let result =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i64_ty, effective_address, ""));
                 let load = result.as_instruction_value().unwrap();
                 self.annotate_user_memaccess(memory_index, memarg, 8, load)?;
                 load.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
@@ -9117,22 +10022,25 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 1);
-                let narrow_result = self
-                    .builder
-                    .build_load(self.intrinsics.i8_ty, effective_address, "")
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
+                let narrow_result =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i8_ty, effective_address, ""))
                     .into_int_value();
                 let load = narrow_result.as_instruction_value().unwrap();
                 self.annotate_user_memaccess(memory_index, memarg, 1, load)?;
                 load.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
                     .unwrap();
-                let result =
-                    self.builder
-                        .build_int_z_extend(narrow_result, self.intrinsics.i32_ty, "");
+                let result = err!(self.builder.build_int_z_extend(
+                    narrow_result,
+                    self.intrinsics.i32_ty,
+                    ""
+                ));
                 self.state.push1_extra(result, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicLoad16U { ref memarg } => {
@@ -9141,22 +10049,25 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 2);
-                let narrow_result = self
-                    .builder
-                    .build_load(self.intrinsics.i16_ty, effective_address, "")
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
+                let narrow_result =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i16_ty, effective_address, ""))
                     .into_int_value();
                 let load = narrow_result.as_instruction_value().unwrap();
                 self.annotate_user_memaccess(memory_index, memarg, 2, load)?;
                 load.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
                     .unwrap();
-                let result =
-                    self.builder
-                        .build_int_z_extend(narrow_result, self.intrinsics.i32_ty, "");
+                let result = err!(self.builder.build_int_z_extend(
+                    narrow_result,
+                    self.intrinsics.i32_ty,
+                    ""
+                ));
                 self.state.push1_extra(result, ExtraInfo::arithmetic_f32());
             }
             Operator::I64AtomicLoad8U { ref memarg } => {
@@ -9165,22 +10076,25 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 1);
-                let narrow_result = self
-                    .builder
-                    .build_load(self.intrinsics.i8_ty, effective_address, "")
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
+                let narrow_result =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i8_ty, effective_address, ""))
                     .into_int_value();
                 let load = narrow_result.as_instruction_value().unwrap();
                 self.annotate_user_memaccess(memory_index, memarg, 1, load)?;
                 load.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
                     .unwrap();
-                let result =
-                    self.builder
-                        .build_int_z_extend(narrow_result, self.intrinsics.i64_ty, "");
+                let result = err!(self.builder.build_int_z_extend(
+                    narrow_result,
+                    self.intrinsics.i64_ty,
+                    ""
+                ));
                 self.state.push1_extra(result, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicLoad16U { ref memarg } => {
@@ -9189,22 +10103,25 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 2);
-                let narrow_result = self
-                    .builder
-                    .build_load(self.intrinsics.i16_ty, effective_address, "")
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
+                let narrow_result =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i16_ty, effective_address, ""))
                     .into_int_value();
                 let load = narrow_result.as_instruction_value().unwrap();
                 self.annotate_user_memaccess(memory_index, memarg, 2, load)?;
                 load.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
                     .unwrap();
-                let result =
-                    self.builder
-                        .build_int_z_extend(narrow_result, self.intrinsics.i64_ty, "");
+                let result = err!(self.builder.build_int_z_extend(
+                    narrow_result,
+                    self.intrinsics.i64_ty,
+                    ""
+                ));
                 self.state.push1_extra(result, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicLoad32U { ref memarg } => {
@@ -9213,22 +10130,25 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 4);
-                let narrow_result = self
-                    .builder
-                    .build_load(self.intrinsics.i32_ty, effective_address, "")
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
+                let narrow_result =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.i32_ty, effective_address, ""))
                     .into_int_value();
                 let load = narrow_result.as_instruction_value().unwrap();
                 self.annotate_user_memaccess(memory_index, memarg, 4, load)?;
                 load.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
                     .unwrap();
-                let result =
-                    self.builder
-                        .build_int_z_extend(narrow_result, self.intrinsics.i64_ty, "");
+                let result = err!(self.builder.build_int_z_extend(
+                    narrow_result,
+                    self.intrinsics.i64_ty,
+                    ""
+                ));
                 self.state.push1_extra(result, ExtraInfo::arithmetic_f64());
             }
             Operator::I32AtomicStore { ref memarg } => {
@@ -9238,12 +10158,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 4);
-                let store = self.builder.build_store(effective_address, value);
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
+                let store = err!(self.builder.build_store(effective_address, value));
                 self.annotate_user_memaccess(memory_index, memarg, 4, store)?;
                 store
                     .set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
@@ -9256,12 +10176,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 8);
-                let store = self.builder.build_store(effective_address, value);
+                self.trap_if_misaligned(memarg, effective_address, 8)?;
+                let store = err!(self.builder.build_store(effective_address, value));
                 self.annotate_user_memaccess(memory_index, memarg, 8, store)?;
                 store
                     .set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
@@ -9274,15 +10194,16 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 1);
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
-                let store = self.builder.build_store(effective_address, narrow_value);
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
+                let store = err!(self.builder.build_store(effective_address, narrow_value));
                 self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
                 store
                     .set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
@@ -9296,15 +10217,16 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 2);
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
-                let store = self.builder.build_store(effective_address, narrow_value);
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
+                let store = err!(self.builder.build_store(effective_address, narrow_value));
                 self.annotate_user_memaccess(memory_index, memarg, 2, store)?;
                 store
                     .set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
@@ -9317,15 +10239,16 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 4);
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
-                let store = self.builder.build_store(effective_address, narrow_value);
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i32_ty, ""));
+                let store = err!(self.builder.build_store(effective_address, narrow_value));
                 self.annotate_user_memaccess(memory_index, memarg, 4, store)?;
                 store
                     .set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
@@ -9338,14 +10261,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 1);
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9361,9 +10285,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     format!("memory {}", memory_index.as_u32()),
                     old.as_instruction_value().unwrap(),
                 );
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmw16AddU { ref memarg } => {
@@ -9373,14 +10297,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 2);
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9396,9 +10321,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     format!("memory {}", memory_index.as_u32()),
                     old.as_instruction_value().unwrap(),
                 );
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmwAdd { ref memarg } => {
@@ -9408,11 +10333,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 4);
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9437,14 +10362,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 1);
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9460,9 +10386,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw16AddU { ref memarg } => {
@@ -9472,14 +10398,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 2);
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9495,9 +10422,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw32AddU { ref memarg } => {
@@ -9507,14 +10434,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 4);
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i32_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9530,9 +10458,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmwAdd { ref memarg } => {
@@ -9542,11 +10470,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 8);
+                self.trap_if_misaligned(memarg, effective_address, 8)?;
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9571,14 +10499,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 1);
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9594,9 +10523,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmw16SubU { ref memarg } => {
@@ -9606,14 +10535,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 2);
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9629,9 +10559,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmwSub { ref memarg } => {
@@ -9641,11 +10571,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 4);
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9670,14 +10600,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 1);
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9693,9 +10624,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I64AtomicRmw16SubU { ref memarg } => {
@@ -9705,14 +10636,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 2);
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9728,9 +10660,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw32SubU { ref memarg } => {
@@ -9740,14 +10672,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 4);
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i32_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9763,9 +10696,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmwSub { ref memarg } => {
@@ -9775,11 +10708,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 8);
+                self.trap_if_misaligned(memarg, effective_address, 8)?;
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9804,14 +10737,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 1);
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9827,9 +10761,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmw16AndU { ref memarg } => {
@@ -9839,14 +10773,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 2);
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9862,9 +10797,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmwAnd { ref memarg } => {
@@ -9874,11 +10809,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 4);
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9903,14 +10838,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 1);
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9926,9 +10862,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw16AndU { ref memarg } => {
@@ -9938,14 +10874,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 2);
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9961,9 +10898,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw32AndU { ref memarg } => {
@@ -9973,14 +10910,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 4);
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i32_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -9996,9 +10934,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmwAnd { ref memarg } => {
@@ -10008,11 +10946,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 8);
+                self.trap_if_misaligned(memarg, effective_address, 8)?;
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10037,14 +10975,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 1);
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10060,9 +10999,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmw16OrU { ref memarg } => {
@@ -10072,14 +11011,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 2);
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10095,9 +11035,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmwOr { ref memarg } => {
@@ -10107,11 +11047,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 4);
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10127,9 +11067,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I64AtomicRmw8OrU { ref memarg } => {
@@ -10139,14 +11079,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 1);
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10162,9 +11103,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw16OrU { ref memarg } => {
@@ -10174,14 +11115,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 2);
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10197,9 +11139,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw32OrU { ref memarg } => {
@@ -10209,14 +11151,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 4);
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i32_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10232,9 +11175,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmwOr { ref memarg } => {
@@ -10244,11 +11187,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 8);
+                self.trap_if_misaligned(memarg, effective_address, 8)?;
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10273,14 +11216,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 2);
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10296,9 +11240,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmw16XorU { ref memarg } => {
@@ -10308,14 +11252,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 2);
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10331,9 +11276,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmwXor { ref memarg } => {
@@ -10343,11 +11288,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 4);
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10372,14 +11317,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 1);
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10395,9 +11341,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw16XorU { ref memarg } => {
@@ -10407,14 +11353,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 2);
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10430,9 +11377,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw32XorU { ref memarg } => {
@@ -10442,14 +11389,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 4);
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i32_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10465,9 +11413,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmwXor { ref memarg } => {
@@ -10477,11 +11425,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 8);
+                self.trap_if_misaligned(memarg, effective_address, 8)?;
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10506,14 +11454,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 1);
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10529,9 +11478,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmw16XchgU { ref memarg } => {
@@ -10541,14 +11490,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 2);
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10564,9 +11514,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmwXchg { ref memarg } => {
@@ -10576,11 +11526,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 4);
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10605,14 +11555,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 1);
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10628,9 +11579,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw16XchgU { ref memarg } => {
@@ -10640,14 +11591,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 2);
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10663,9 +11615,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw32XchgU { ref memarg } => {
@@ -10675,14 +11627,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 4);
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
                 let narrow_value =
-                    self.builder
-                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
+                    err!(self
+                        .builder
+                        .build_int_truncate(value, self.intrinsics.i32_ty, ""));
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10698,9 +11651,9 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmwXchg { ref memarg } => {
@@ -10710,11 +11663,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 8);
+                self.trap_if_misaligned(memarg, effective_address, 8)?;
                 let old = self
                     .builder
                     .build_atomicrmw(
@@ -10734,25 +11687,27 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             }
             Operator::I32AtomicRmw8CmpxchgU { ref memarg } => {
                 let ((cmp, cmp_info), (new, new_info)) = self.state.pop2_extra()?;
-                let cmp = self.apply_pending_canonicalization(cmp, cmp_info);
-                let new = self.apply_pending_canonicalization(new, new_info);
+                let cmp = self.apply_pending_canonicalization(cmp, cmp_info)?;
+                let new = self.apply_pending_canonicalization(new, new_info)?;
                 let (cmp, new) = (cmp.into_int_value(), new.into_int_value());
                 let offset = self.state.pop1()?.into_int_value();
                 let memory_index = MemoryIndex::from_u32(0);
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 1);
-                let narrow_cmp = self
-                    .builder
-                    .build_int_truncate(cmp, self.intrinsics.i8_ty, "");
-                let narrow_new = self
-                    .builder
-                    .build_int_truncate(new, self.intrinsics.i8_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
+                let narrow_cmp =
+                    err!(self
+                        .builder
+                        .build_int_truncate(cmp, self.intrinsics.i8_ty, ""));
+                let narrow_new =
+                    err!(self
+                        .builder
+                        .build_int_truncate(new, self.intrinsics.i8_ty, ""));
                 let old = self
                     .builder
                     .build_cmpxchg(
@@ -10774,32 +11729,34 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     .build_extract_value(old, 0, "")
                     .unwrap()
                     .into_int_value();
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmw16CmpxchgU { ref memarg } => {
                 let ((cmp, cmp_info), (new, new_info)) = self.state.pop2_extra()?;
-                let cmp = self.apply_pending_canonicalization(cmp, cmp_info);
-                let new = self.apply_pending_canonicalization(new, new_info);
+                let cmp = self.apply_pending_canonicalization(cmp, cmp_info)?;
+                let new = self.apply_pending_canonicalization(new, new_info)?;
                 let (cmp, new) = (cmp.into_int_value(), new.into_int_value());
                 let offset = self.state.pop1()?.into_int_value();
                 let memory_index = MemoryIndex::from_u32(0);
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 2);
-                let narrow_cmp = self
-                    .builder
-                    .build_int_truncate(cmp, self.intrinsics.i16_ty, "");
-                let narrow_new = self
-                    .builder
-                    .build_int_truncate(new, self.intrinsics.i16_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
+                let narrow_cmp =
+                    err!(self
+                        .builder
+                        .build_int_truncate(cmp, self.intrinsics.i16_ty, ""));
+                let narrow_new =
+                    err!(self
+                        .builder
+                        .build_int_truncate(new, self.intrinsics.i16_ty, ""));
                 let old = self
                     .builder
                     .build_cmpxchg(
@@ -10821,26 +11778,26 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     .build_extract_value(old, 0, "")
                     .unwrap()
                     .into_int_value();
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
             }
             Operator::I32AtomicRmwCmpxchg { ref memarg } => {
                 let ((cmp, cmp_info), (new, new_info)) = self.state.pop2_extra()?;
-                let cmp = self.apply_pending_canonicalization(cmp, cmp_info);
-                let new = self.apply_pending_canonicalization(new, new_info);
+                let cmp = self.apply_pending_canonicalization(cmp, cmp_info)?;
+                let new = self.apply_pending_canonicalization(new, new_info)?;
                 let (cmp, new) = (cmp.into_int_value(), new.into_int_value());
                 let offset = self.state.pop1()?.into_int_value();
                 let memory_index = MemoryIndex::from_u32(0);
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 4);
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
                 let old = self
                     .builder
                     .build_cmpxchg(
@@ -10857,30 +11814,32 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self.builder.build_extract_value(old, 0, "").unwrap();
+                let old = err!(self.builder.build_extract_value(old, 0, ""));
                 self.state.push1(old);
             }
             Operator::I64AtomicRmw8CmpxchgU { ref memarg } => {
                 let ((cmp, cmp_info), (new, new_info)) = self.state.pop2_extra()?;
-                let cmp = self.apply_pending_canonicalization(cmp, cmp_info);
-                let new = self.apply_pending_canonicalization(new, new_info);
+                let cmp = self.apply_pending_canonicalization(cmp, cmp_info)?;
+                let new = self.apply_pending_canonicalization(new, new_info)?;
                 let (cmp, new) = (cmp.into_int_value(), new.into_int_value());
                 let offset = self.state.pop1()?.into_int_value();
                 let memory_index = MemoryIndex::from_u32(0);
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i8_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     1,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 1);
-                let narrow_cmp = self
-                    .builder
-                    .build_int_truncate(cmp, self.intrinsics.i8_ty, "");
-                let narrow_new = self
-                    .builder
-                    .build_int_truncate(new, self.intrinsics.i8_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 1)?;
+                let narrow_cmp =
+                    err!(self
+                        .builder
+                        .build_int_truncate(cmp, self.intrinsics.i8_ty, ""));
+                let narrow_new =
+                    err!(self
+                        .builder
+                        .build_int_truncate(new, self.intrinsics.i8_ty, ""));
                 let old = self
                     .builder
                     .build_cmpxchg(
@@ -10902,32 +11861,34 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     .build_extract_value(old, 0, "")
                     .unwrap()
                     .into_int_value();
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw16CmpxchgU { ref memarg } => {
                 let ((cmp, cmp_info), (new, new_info)) = self.state.pop2_extra()?;
-                let cmp = self.apply_pending_canonicalization(cmp, cmp_info);
-                let new = self.apply_pending_canonicalization(new, new_info);
+                let cmp = self.apply_pending_canonicalization(cmp, cmp_info)?;
+                let new = self.apply_pending_canonicalization(new, new_info)?;
                 let (cmp, new) = (cmp.into_int_value(), new.into_int_value());
                 let offset = self.state.pop1()?.into_int_value();
                 let memory_index = MemoryIndex::from_u32(0);
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i16_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     2,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 2);
-                let narrow_cmp = self
-                    .builder
-                    .build_int_truncate(cmp, self.intrinsics.i16_ty, "");
-                let narrow_new = self
-                    .builder
-                    .build_int_truncate(new, self.intrinsics.i16_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 2)?;
+                let narrow_cmp =
+                    err!(self
+                        .builder
+                        .build_int_truncate(cmp, self.intrinsics.i16_ty, ""));
+                let narrow_new =
+                    err!(self
+                        .builder
+                        .build_int_truncate(new, self.intrinsics.i16_ty, ""));
                 let old = self
                     .builder
                     .build_cmpxchg(
@@ -10949,32 +11910,34 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     .build_extract_value(old, 0, "")
                     .unwrap()
                     .into_int_value();
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmw32CmpxchgU { ref memarg } => {
                 let ((cmp, cmp_info), (new, new_info)) = self.state.pop2_extra()?;
-                let cmp = self.apply_pending_canonicalization(cmp, cmp_info);
-                let new = self.apply_pending_canonicalization(new, new_info);
+                let cmp = self.apply_pending_canonicalization(cmp, cmp_info)?;
+                let new = self.apply_pending_canonicalization(new, new_info)?;
                 let (cmp, new) = (cmp.into_int_value(), new.into_int_value());
                 let offset = self.state.pop1()?.into_int_value();
                 let memory_index = MemoryIndex::from_u32(0);
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i32_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     4,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 4);
-                let narrow_cmp = self
-                    .builder
-                    .build_int_truncate(cmp, self.intrinsics.i32_ty, "");
-                let narrow_new = self
-                    .builder
-                    .build_int_truncate(new, self.intrinsics.i32_ty, "");
+                self.trap_if_misaligned(memarg, effective_address, 4)?;
+                let narrow_cmp =
+                    err!(self
+                        .builder
+                        .build_int_truncate(cmp, self.intrinsics.i32_ty, ""));
+                let narrow_new =
+                    err!(self
+                        .builder
+                        .build_int_truncate(new, self.intrinsics.i32_ty, ""));
                 let old = self
                     .builder
                     .build_cmpxchg(
@@ -10996,26 +11959,26 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     .build_extract_value(old, 0, "")
                     .unwrap()
                     .into_int_value();
-                let old = self
+                let old = err!(self
                     .builder
-                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, ""));
                 self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
             }
             Operator::I64AtomicRmwCmpxchg { ref memarg } => {
                 let ((cmp, cmp_info), (new, new_info)) = self.state.pop2_extra()?;
-                let cmp = self.apply_pending_canonicalization(cmp, cmp_info);
-                let new = self.apply_pending_canonicalization(new, new_info);
+                let cmp = self.apply_pending_canonicalization(cmp, cmp_info)?;
+                let new = self.apply_pending_canonicalization(new, new_info)?;
                 let (cmp, new) = (cmp.into_int_value(), new.into_int_value());
                 let offset = self.state.pop1()?.into_int_value();
                 let memory_index = MemoryIndex::from_u32(0);
                 let effective_address = self.resolve_memory_ptr(
                     memory_index,
                     memarg,
-                    self.intrinsics.i64_ptr_ty,
+                    self.intrinsics.ptr_ty,
                     offset,
                     8,
                 )?;
-                self.trap_if_misaligned(memarg, effective_address, 8);
+                self.trap_if_misaligned(memarg, effective_address, 8)?;
                 let old = self
                     .builder
                     .build_cmpxchg(
@@ -11032,15 +11995,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     0,
                     old.as_instruction_value().unwrap(),
                 )?;
-                let old = self.builder.build_extract_value(old, 0, "").unwrap();
+                let old = err!(self.builder.build_extract_value(old, 0, ""));
                 self.state.push1(old);
             }
 
-            Operator::MemoryGrow { mem, mem_byte: _ } => {
+            Operator::MemoryGrow { mem } => {
                 let memory_index = MemoryIndex::from_u32(mem);
                 let delta = self.state.pop1()?;
-                let grow_fn_ptr = self.ctx.memory_grow(memory_index, self.intrinsics);
-                let grow = self.builder.build_indirect_call(
+                let grow_fn_ptr = self.ctx.memory_grow(memory_index, self.intrinsics)?;
+                let grow = err!(self.builder.build_indirect_call(
                     self.intrinsics.memory_grow_ty,
                     grow_fn_ptr,
                     &[
@@ -11049,13 +12012,13 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_ty.const_int(mem.into(), false).into(),
                     ],
                     "",
-                );
+                ));
                 self.state.push1(grow.try_as_basic_value().left().unwrap());
             }
-            Operator::MemorySize { mem, mem_byte: _ } => {
+            Operator::MemorySize { mem } => {
                 let memory_index = MemoryIndex::from_u32(mem);
-                let size_fn_ptr = self.ctx.memory_size(memory_index, self.intrinsics);
-                let size = self.builder.build_indirect_call(
+                let size_fn_ptr = self.ctx.memory_size(memory_index, self.intrinsics)?;
+                let size = err!(self.builder.build_indirect_call(
                     self.intrinsics.memory_size_ty,
                     size_fn_ptr,
                     &[
@@ -11063,15 +12026,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         self.intrinsics.i32_ty.const_int(mem.into(), false).into(),
                     ],
                     "",
-                );
-                size.add_attribute(AttributeLoc::Function, self.intrinsics.readonly);
+                ));
+                //size.add_attribute(AttributeLoc::Function, self.intrinsics.readonly);
                 self.state.push1(size.try_as_basic_value().left().unwrap());
             }
             Operator::MemoryInit { data_index, mem } => {
                 let (dest, src, len) = self.state.pop3()?;
                 let mem = self.intrinsics.i32_ty.const_int(mem.into(), false);
                 let segment = self.intrinsics.i32_ty.const_int(data_index.into(), false);
-                self.builder.build_call(
+                err!(self.builder.build_call(
                     self.intrinsics.memory_init,
                     &[
                         vmctx.as_basic_value_enum().into(),
@@ -11082,15 +12045,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         len.into(),
                     ],
                     "",
-                );
+                ));
             }
             Operator::DataDrop { data_index } => {
                 let segment = self.intrinsics.i32_ty.const_int(data_index.into(), false);
-                self.builder.build_call(
+                err!(self.builder.build_call(
                     self.intrinsics.data_drop,
                     &[vmctx.as_basic_value_enum().into(), segment.into()],
                     "",
-                );
+                ));
             }
             Operator::MemoryCopy { dst_mem, src_mem } => {
                 // ignored until we support multiple memories
@@ -11106,7 +12069,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
 
                 let (dest_pos, src_pos, len) = self.state.pop3()?;
                 let src_index = self.intrinsics.i32_ty.const_int(src.into(), false);
-                self.builder.build_call(
+                err!(self.builder.build_call(
                     memory_copy,
                     &[
                         vmctx.as_basic_value_enum().into(),
@@ -11116,7 +12079,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         len.into(),
                     ],
                     "",
-                );
+                ));
             }
             Operator::MemoryFill { mem } => {
                 let (memory_fill, mem) = if let Some(local_memory_index) = self
@@ -11130,7 +12093,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
 
                 let (dst, val, len) = self.state.pop3()?;
                 let mem_index = self.intrinsics.i32_ty.const_int(mem.into(), false);
-                self.builder.build_call(
+                err!(self.builder.build_call(
                     memory_fill,
                     &[
                         vmctx.as_basic_value_enum().into(),
@@ -11140,23 +12103,24 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         len.into(),
                     ],
                     "",
-                );
+                ));
             }
             /***************************
              * Reference types.
              * https://github.com/WebAssembly/reference-types/blob/master/proposals/reference-types/Overview.md
              ***************************/
             Operator::RefNull { hty } => {
-                let ty = wpheaptype_to_type(hty).map_err(to_compile_error)?;
+                let ty = err!(wpheaptype_to_type(hty));
                 let ty = type_to_llvm(self.intrinsics, ty)?;
                 self.state.push1(ty.const_zero());
             }
             Operator::RefIsNull => {
                 let value = self.state.pop1()?.into_pointer_value();
-                let is_null = self.builder.build_is_null(value, "");
-                let is_null = self
-                    .builder
-                    .build_int_z_extend(is_null, self.intrinsics.i32_ty, "");
+                let is_null = err!(self.builder.build_is_null(value, ""));
+                let is_null =
+                    err!(self
+                        .builder
+                        .build_int_z_extend(is_null, self.intrinsics.i32_ty, ""));
                 self.state.push1(is_null);
             }
             Operator::RefFunc { function_index } => {
@@ -11164,16 +12128,14 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     .intrinsics
                     .i32_ty
                     .const_int(function_index.into(), false);
-                let value = self
-                    .builder
-                    .build_call(
-                        self.intrinsics.func_ref,
-                        &[self.ctx.basic().into(), index.into()],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let value = err!(self.builder.build_call(
+                    self.intrinsics.func_ref,
+                    &[self.ctx.basic().into(), index.into()],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 self.state.push1(value);
             }
             Operator::TableGet { table } => {
@@ -11188,17 +12150,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 } else {
                     self.intrinsics.imported_table_get
                 };
-                let value = self
-                    .builder
-                    .build_call(
-                        table_get,
-                        &[self.ctx.basic().into(), table_index.into(), elem.into()],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
-                let value = self.builder.build_bitcast(
+                let value = err!(self.builder.build_call(
+                    table_get,
+                    &[self.ctx.basic().into(), table_index.into(), elem.into()],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
+                let value = err!(self.builder.build_bit_cast(
                     value,
                     type_to_llvm(
                         self.intrinsics,
@@ -11209,15 +12169,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                             .ty,
                     )?,
                     "",
-                );
+                ));
                 self.state.push1(value);
             }
             Operator::TableSet { table } => {
                 let table_index = self.intrinsics.i32_ty.const_int(table.into(), false);
                 let (elem, value) = self.state.pop2()?;
-                let value = self
+                let value = err!(self
                     .builder
-                    .build_bitcast(value, self.intrinsics.anyref_ty, "");
+                    .build_bit_cast(value, self.intrinsics.ptr_ty, ""));
                 let table_set = if self
                     .wasm_module
                     .local_table_index(TableIndex::from_u32(table))
@@ -11227,7 +12187,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 } else {
                     self.intrinsics.imported_table_set
                 };
-                self.builder.build_call(
+                err!(self.builder.build_call(
                     table_set,
                     &[
                         self.ctx.basic().into(),
@@ -11236,7 +12196,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         value.into(),
                     ],
                     "",
-                );
+                ));
             }
             Operator::TableCopy {
                 dst_table,
@@ -11245,7 +12205,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 let (dst, src, len) = self.state.pop3()?;
                 let dst_table = self.intrinsics.i32_ty.const_int(dst_table as u64, false);
                 let src_table = self.intrinsics.i32_ty.const_int(src_table as u64, false);
-                self.builder.build_call(
+                err!(self.builder.build_call(
                     self.intrinsics.table_copy,
                     &[
                         self.ctx.basic().into(),
@@ -11256,13 +12216,13 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         len.into(),
                     ],
                     "",
-                );
+                ));
             }
             Operator::TableInit { elem_index, table } => {
                 let (dst, src, len) = self.state.pop3()?;
                 let segment = self.intrinsics.i32_ty.const_int(elem_index as u64, false);
                 let table = self.intrinsics.i32_ty.const_int(table as u64, false);
-                self.builder.build_call(
+                err!(self.builder.build_call(
                     self.intrinsics.table_init,
                     &[
                         self.ctx.basic().into(),
@@ -11273,23 +12233,23 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         len.into(),
                     ],
                     "",
-                );
+                ));
             }
             Operator::ElemDrop { elem_index } => {
                 let segment = self.intrinsics.i32_ty.const_int(elem_index as u64, false);
-                self.builder.build_call(
+                err!(self.builder.build_call(
                     self.intrinsics.elem_drop,
                     &[self.ctx.basic().into(), segment.into()],
                     "",
-                );
+                ));
             }
             Operator::TableFill { table } => {
                 let table = self.intrinsics.i32_ty.const_int(table as u64, false);
                 let (start, elem, len) = self.state.pop3()?;
-                let elem = self
+                let elem = err!(self
                     .builder
-                    .build_bitcast(elem, self.intrinsics.anyref_ty, "");
-                self.builder.build_call(
+                    .build_bit_cast(elem, self.intrinsics.ptr_ty, ""));
+                err!(self.builder.build_call(
                     self.intrinsics.table_fill,
                     &[
                         self.ctx.basic().into(),
@@ -11299,13 +12259,13 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         len.into(),
                     ],
                     "",
-                );
+                ));
             }
             Operator::TableGrow { table } => {
                 let (elem, delta) = self.state.pop2()?;
-                let elem = self
+                let elem = err!(self
                     .builder
-                    .build_bitcast(elem, self.intrinsics.anyref_ty, "");
+                    .build_bit_cast(elem, self.intrinsics.ptr_ty, ""));
                 let (table_grow, table_index) = if let Some(local_table_index) = self
                     .wasm_module
                     .local_table_index(TableIndex::from_u32(table))
@@ -11315,21 +12275,19 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     (self.intrinsics.imported_table_grow, table)
                 };
                 let table_index = self.intrinsics.i32_ty.const_int(table_index as u64, false);
-                let size = self
-                    .builder
-                    .build_call(
-                        table_grow,
-                        &[
-                            self.ctx.basic().into(),
-                            elem.into(),
-                            delta.into(),
-                            table_index.into(),
-                        ],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let size = err!(self.builder.build_call(
+                    table_grow,
+                    &[
+                        self.ctx.basic().into(),
+                        elem.into(),
+                        delta.into(),
+                        table_index.into(),
+                    ],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 self.state.push1(size);
             }
             Operator::TableSize { table } => {
@@ -11342,23 +12300,21 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     (self.intrinsics.imported_table_size, table)
                 };
                 let table_index = self.intrinsics.i32_ty.const_int(table_index as u64, false);
-                let size = self
-                    .builder
-                    .build_call(
-                        table_size,
-                        &[self.ctx.basic().into(), table_index.into()],
-                        "",
-                    )
-                    .try_as_basic_value()
-                    .left()
-                    .unwrap();
+                let size = err!(self.builder.build_call(
+                    table_size,
+                    &[self.ctx.basic().into(), table_index.into()],
+                    "",
+                ))
+                .try_as_basic_value()
+                .left()
+                .unwrap();
                 self.state.push1(size);
             }
             Operator::MemoryAtomicWait32 { memarg } => {
                 let memory_index = MemoryIndex::from_u32(memarg.memory);
                 let (dst, val, timeout) = self.state.pop3()?;
-                let wait32_fn_ptr = self.ctx.memory_wait32(memory_index, self.intrinsics);
-                let ret = self.builder.build_indirect_call(
+                let wait32_fn_ptr = self.ctx.memory_wait32(memory_index, self.intrinsics)?;
+                let ret = err!(self.builder.build_indirect_call(
                     self.intrinsics.memory_wait32_ty,
                     wait32_fn_ptr,
                     &[
@@ -11372,14 +12328,14 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         timeout.into(),
                     ],
                     "",
-                );
+                ));
                 self.state.push1(ret.try_as_basic_value().left().unwrap());
             }
             Operator::MemoryAtomicWait64 { memarg } => {
                 let memory_index = MemoryIndex::from_u32(memarg.memory);
                 let (dst, val, timeout) = self.state.pop3()?;
-                let wait64_fn_ptr = self.ctx.memory_wait64(memory_index, self.intrinsics);
-                let ret = self.builder.build_indirect_call(
+                let wait64_fn_ptr = self.ctx.memory_wait64(memory_index, self.intrinsics)?;
+                let ret = err!(self.builder.build_indirect_call(
                     self.intrinsics.memory_wait64_ty,
                     wait64_fn_ptr,
                     &[
@@ -11393,14 +12349,14 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         timeout.into(),
                     ],
                     "",
-                );
+                ));
                 self.state.push1(ret.try_as_basic_value().left().unwrap());
             }
             Operator::MemoryAtomicNotify { memarg } => {
                 let memory_index = MemoryIndex::from_u32(memarg.memory);
                 let (dst, count) = self.state.pop2()?;
-                let notify_fn_ptr = self.ctx.memory_notify(memory_index, self.intrinsics);
-                let cnt = self.builder.build_indirect_call(
+                let notify_fn_ptr = self.ctx.memory_notify(memory_index, self.intrinsics)?;
+                let cnt = err!(self.builder.build_indirect_call(
                     self.intrinsics.memory_notify_ty,
                     notify_fn_ptr,
                     &[
@@ -11413,13 +12369,619 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         count.into(),
                     ],
                     "",
-                );
+                ));
                 self.state.push1(cnt.try_as_basic_value().left().unwrap());
             }
+
+            Operator::TryTable { try_table } => {
+                let current_block = self
+                    .builder
+                    .get_insert_block()
+                    .ok_or_else(|| CompileError::Codegen("not currently in a block".to_string()))?;
+
+                self.builder.position_at_end(current_block);
+
+                let end_block = self.context.append_basic_block(self.function, "try_end");
+
+                let end_phis = {
+                    self.builder.position_at_end(end_block);
+
+                    let phis = self
+                        .module_translation
+                        .blocktype_params_results(&try_table.ty)?
+                        .1
+                        .iter()
+                        .map(|&wp_ty| {
+                            err_nt!(wptype_to_type(wp_ty)).and_then(|wasm_ty| {
+                                type_to_llvm(self.intrinsics, wasm_ty)
+                                    .and_then(|ty| err_nt!(self.builder.build_phi(ty, "")))
+                            })
+                        })
+                        .collect::<Result<_, _>>()?;
+
+                    self.builder.position_at_end(current_block);
+                    phis
+                };
+
+                // Collect unique catches. It is not a "hard" error on the wasm side,
+                // but LLVM will definitely complain about having the same identifier
+                // match two different branches in the switch below.
+                let catches: Vec<_> = try_table
+                    .catches
+                    .into_iter()
+                    .unique_by(|v| match v {
+                        Catch::One { tag, .. } | Catch::OneRef { tag, .. } => *tag as i32,
+                        Catch::All { .. } | Catch::AllRef { .. } => CATCH_ALL_TAG_VALUE,
+                    })
+                    .collect();
+
+                // Build the landing pad.
+                let null = self.intrinsics.ptr_ty.const_zero();
+                let exception_type = self.context.struct_type(
+                    &[self.intrinsics.ptr_ty.into(), self.intrinsics.i32_ty.into()],
+                    false,
+                );
+
+                let mut catch_tag_values = vec![];
+                let mut lpad_clauses: Vec<BasicValueEnum<'ctx>> = catches
+                    .iter()
+                    .map(|catch| match catch {
+                        Catch::All { .. } | Catch::AllRef { .. } => {
+                            catch_tag_values.push(CATCH_ALL_TAG_VALUE as u32);
+                            Ok(null.into())
+                        }
+                        Catch::One { tag, .. } | Catch::OneRef { tag, .. } => {
+                            catch_tag_values.push(*tag);
+                            Ok(self.get_or_insert_tag_type_info_global(*tag as i32))
+                        }
+                    })
+                    .collect::<Result<Vec<BasicValueEnum<'ctx>>, CompileError>>()?;
+
+                // Since jumping between landingpads is not possible, we need to collect
+                // all tags from outer try_tables as well to build a clause for *every*
+                // possible tag that might be caught.
+                let mut outer_catch_blocks = vec![];
+                for outer_landingpad in self.state.landingpads.iter().rev() {
+                    for catch_info @ TagCatchInfo { tag, .. } in &outer_landingpad.tags {
+                        if !catch_tag_values.contains(tag) {
+                            catch_tag_values.push(*tag);
+                            lpad_clauses.push(if *tag as i32 == CATCH_ALL_TAG_VALUE {
+                                null.into()
+                            } else {
+                                *self.tags_cache.get(&(*tag as i32)).expect(
+                                    "If a previous try_table encountered a tag, \
+                                    it should be in the cache",
+                                )
+                            });
+                            outer_catch_blocks.push(*catch_info);
+                        }
+                    }
+                }
+
+                // If there are no catch clauses, we have to skip everything, since
+                // an lpad without catch clauses is invalid (and won't ever be jumped
+                // to anyway)
+                let mut maybe_lpad_block = None;
+                let mut catch_blocks = vec![];
+                if !lpad_clauses.is_empty() {
+                    let lpad_block = self.context.append_basic_block(self.function, "catch");
+                    let catch_all_block =
+                        self.context.append_basic_block(self.function, "catch_all");
+                    let catch_specific_block = self
+                        .context
+                        .append_basic_block(self.function, "catch_specific");
+                    let catch_end_block =
+                        self.context.append_basic_block(self.function, "catch_end");
+                    let rethrow_block = self.context.append_basic_block(self.function, "rethrow");
+
+                    self.builder.position_at_end(lpad_block);
+
+                    let res = err!(self.builder.build_landing_pad(
+                        exception_type,
+                        self.intrinsics.personality,
+                        &lpad_clauses,
+                        false,
+                        "exc_struct",
+                    ));
+
+                    let res = res.into_struct_value();
+
+                    let uw_exc = err!(self.builder.build_extract_value(res, 0, "exc_ptr"));
+                    let pre_selector =
+                        err!(self.builder.build_extract_value(res, 1, "pre_selector"));
+
+                    // The pre-selector can be either 0 (for catch-all) or 1 (for a
+                    // specific, but as-yet-unknown tag).
+                    let pre_selector_is_zero = err!(self.builder.build_int_compare(
+                        IntPredicate::EQ,
+                        pre_selector.into_int_value(),
+                        self.intrinsics.i32_zero,
+                        "pre_selector_is_zero"
+                    ));
+                    err!(self.builder.build_conditional_branch(
+                        pre_selector_is_zero,
+                        catch_all_block,
+                        catch_specific_block
+                    ));
+
+                    self.builder.position_at_end(catch_all_block);
+                    err!(self.builder.build_unconditional_branch(catch_end_block));
+
+                    self.builder.position_at_end(catch_specific_block);
+                    let vmctx_alloca = err!(self.build_or_get_vmctx_alloca());
+                    let vmctx_ptr = err!(self.builder.build_load(
+                        self.intrinsics.ptr_ty,
+                        vmctx_alloca,
+                        "vmctx"
+                    ));
+                    let selector_value = err!(self.builder.build_call(
+                        self.intrinsics.personality2,
+                        &[vmctx_ptr.into(), uw_exc.into()],
+                        "selector"
+                    ));
+                    err!(self.builder.build_unconditional_branch(catch_end_block));
+
+                    self.builder.position_at_end(catch_end_block);
+                    let selector = err!(self.builder.build_phi(self.intrinsics.i32_ty, "selector"));
+                    selector.add_incoming(&[
+                        (
+                            &self
+                                .intrinsics
+                                .i32_ty
+                                .const_int(CATCH_ALL_TAG_VALUE as u64, false),
+                            catch_all_block,
+                        ),
+                        (
+                            &selector_value
+                                .try_as_basic_value()
+                                .left()
+                                .unwrap()
+                                .into_int_value(),
+                            catch_specific_block,
+                        ),
+                    ]);
+
+                    // The exception we get at this point is a wrapper around the [`WasmerException`]
+                    // type. This is needed because when we create the exception to pass it to
+                    // libunwind, the exception object needs to begin with a specific set of fields
+                    // (those in `__Unwind_Exception`). During unwinding, libunwind uses some of these
+                    // fields and we need to pass them back when rethrowing. This to say, we need to
+                    // keep the original exception passed to us by libunwind to be able to rethrow it.
+                    let uw_exc = uw_exc.into_pointer_value();
+                    let wasmer_exc = err!(self.builder.build_call(
+                        self.intrinsics.read_exception,
+                        &[uw_exc.into()],
+                        "wasmer_exc_ptr"
+                    ));
+
+                    let wasmer_exc = wasmer_exc.as_any_value_enum().into_pointer_value();
+                    let selector = selector.as_basic_value().into_int_value();
+
+                    for catch in catches.iter() {
+                        match catch {
+                            Catch::All { label } => {
+                                let b = self
+                                    .context
+                                    .append_basic_block(self.function, "catch_all_clause");
+                                self.builder.position_at_end(b);
+                                let frame = self.state.frame_at_depth(*label)?;
+
+                                err!(self.builder.build_unconditional_branch(*frame.br_dest()));
+
+                                self.builder.position_at_end(catch_end_block);
+                                catch_blocks.push((b, None, None));
+                            }
+                            Catch::One { tag, label } => {
+                                let tag_idx = self.wasm_module.tags[TagIndex::from_u32(*tag)];
+                                let signature = &self.wasm_module.signatures[tag_idx];
+                                let params = signature.params();
+
+                                let b = self
+                                    .context
+                                    .append_basic_block(self.function, "catch_one_clause");
+                                self.builder.position_at_end(b);
+
+                                let wasmer_exc_phi = err!(self
+                                    .builder
+                                    .build_phi(self.intrinsics.ptr_ty, "wasmer_exc_phi"));
+                                wasmer_exc_phi.add_incoming(&[(&wasmer_exc, catch_end_block)]);
+
+                                // Get the type of the exception.
+                                let inner_exc_ty =
+                                    self.get_or_insert_exception_type(*tag, signature)?;
+
+                                // Cast the outer exception - a pointer - to a pointer to a struct of
+                                // type WasmerException.
+                                // let wasmer_exc_ptr = err!(self.builder.build_pointer_cast(
+                                //     exc,
+                                //     self.intrinsics.exc_ty,
+                                //     "wasmer_exc_ptr"
+                                // ));
+                                //
+                                // Not actually needed, since ptr is a single, unique type.
+
+                                // Points at the `data` field of the exception.
+                                let wasmer_exc_data_ptr_ptr = err!(self.builder.build_struct_gep(
+                                    self.intrinsics.exc_ty,
+                                    wasmer_exc_phi.as_basic_value().into_pointer_value(),
+                                    1,
+                                    "wasmer_exc_data_ptr_ptr"
+                                ));
+
+                                let wasmer_exc_data_ptr = err!(self.builder.build_load(
+                                    self.intrinsics.ptr_ty,
+                                    wasmer_exc_data_ptr_ptr,
+                                    "wasmer_exc_data_ptr"
+                                ));
+
+                                let wasmer_exc_data_ptr = wasmer_exc_data_ptr.into_pointer_value();
+
+                                // Read each value from the data ptr.
+                                let values = params
+                                    .iter()
+                                    .enumerate()
+                                    .map(|(i, v)| {
+                                        let name = format!("value{i}");
+                                        let ptr = err!(self.builder.build_struct_gep(
+                                            inner_exc_ty,
+                                            wasmer_exc_data_ptr,
+                                            i as u32,
+                                            &(name.clone() + "ptr")
+                                        ));
+                                        err_nt!(self.builder.build_load(
+                                            type_to_llvm(self.intrinsics, *v)?,
+                                            ptr,
+                                            &name,
+                                        ))
+                                    })
+                                    .collect::<Result<Vec<_>, CompileError>>()?;
+
+                                let frame = self.state.frame_at_depth(*label)?;
+
+                                // todo: check that the types are compatible
+
+                                for (phi, value) in frame.phis().iter().zip(values.iter()) {
+                                    phi.add_incoming(&[(value, b)])
+                                }
+
+                                err!(self.builder.build_unconditional_branch(*frame.br_dest()));
+
+                                self.builder.position_at_end(catch_end_block);
+                                catch_blocks.push((b, Some(wasmer_exc_phi), None));
+                            }
+                            Catch::OneRef { label, tag } => {
+                                let tag_idx = self.wasm_module.tags[TagIndex::from_u32(*tag)];
+                                let signature = &self.wasm_module.signatures[tag_idx];
+                                let params = signature.params();
+
+                                let b = self
+                                    .context
+                                    .append_basic_block(self.function, "catch_one_ref_clause");
+                                self.builder.position_at_end(b);
+
+                                let wasmer_exc_phi = err!(self
+                                    .builder
+                                    .build_phi(self.intrinsics.ptr_ty, "wasmer_exc_phi"));
+                                wasmer_exc_phi.add_incoming(&[(&wasmer_exc, catch_end_block)]);
+
+                                let uw_exc_ptr_phi = err!(self
+                                    .builder
+                                    .build_phi(self.intrinsics.ptr_ty, "uw_exc_ptr_phi"));
+                                uw_exc_ptr_phi.add_incoming(&[(&uw_exc, catch_end_block)]);
+
+                                // Get the type of the exception.
+                                let inner_exc_ty =
+                                    self.get_or_insert_exception_type(*tag, signature)?;
+
+                                // Cast the outer exception - a pointer - to a pointer to a struct of
+                                // type WasmerException.
+                                // let wasmer_exc_ptr = err!(self.builder.build_pointer_cast(
+                                //     exc,
+                                //     self.intrinsics.exc_ty,
+                                //     "wasmer_exc_ptr"
+                                // ));
+                                //
+                                // Not actually needed, since ptr is a single, unique type.
+
+                                // Points at the `data` field of the exception.
+                                let wasmer_exc_data_ptr_ptr = err!(self.builder.build_struct_gep(
+                                    self.intrinsics.exc_ty,
+                                    wasmer_exc_phi.as_basic_value().into_pointer_value(),
+                                    1,
+                                    "wasmer_exc_data_ptr"
+                                ));
+
+                                let wasmer_exc_data_ptr = err!(self.builder.build_load(
+                                    self.intrinsics.ptr_ty,
+                                    wasmer_exc_data_ptr_ptr,
+                                    "wasmer_exc_data_ptr"
+                                ));
+
+                                let wasmer_exc_data_ptr = wasmer_exc_data_ptr.into_pointer_value();
+
+                                // Read each value from the data ptr.
+                                let mut values = params
+                                    .iter()
+                                    .enumerate()
+                                    .map(|(i, v)| {
+                                        let name = format!("value{i}");
+                                        let ptr = err!(self.builder.build_struct_gep(
+                                            inner_exc_ty,
+                                            wasmer_exc_data_ptr,
+                                            i as u32,
+                                            &(name.clone() + "ptr")
+                                        ));
+                                        err_nt!(self.builder.build_load(
+                                            type_to_llvm(self.intrinsics, *v)?,
+                                            ptr,
+                                            &name,
+                                        ))
+                                    })
+                                    .collect::<Result<Vec<_>, CompileError>>()?;
+
+                                values.push(uw_exc_ptr_phi.as_basic_value());
+
+                                let frame = self.state.frame_at_depth(*label)?;
+
+                                // todo: check that the types are compatible
+
+                                for (phi, value) in frame.phis().iter().zip(values.iter()) {
+                                    phi.add_incoming(&[(value, b)])
+                                }
+
+                                err!(self.builder.build_unconditional_branch(*frame.br_dest()));
+
+                                self.builder.position_at_end(catch_end_block);
+                                catch_blocks.push((b, Some(wasmer_exc_phi), Some(uw_exc_ptr_phi)));
+                            }
+                            Catch::AllRef { label } => {
+                                let b = self
+                                    .context
+                                    .append_basic_block(self.function, "catch_all_ref_clause");
+                                self.builder.position_at_end(b);
+
+                                let uw_exc_ptr_phi = err!(self
+                                    .builder
+                                    .build_phi(self.intrinsics.ptr_ty, "uw_exc_ptr_phi"));
+                                uw_exc_ptr_phi.add_incoming(&[(&uw_exc, catch_end_block)]);
+
+                                let frame = self.state.frame_at_depth(*label)?;
+
+                                let phis = frame.phis();
+
+                                // sanity check (todo): check that the phi has only one element
+
+                                for phi in phis.iter() {
+                                    phi.add_incoming(&[(&uw_exc_ptr_phi.as_basic_value(), b)])
+                                }
+
+                                err!(self.builder.build_unconditional_branch(*frame.br_dest()));
+
+                                self.builder.position_at_end(catch_end_block);
+                                catch_blocks.push((b, None, Some(uw_exc_ptr_phi)));
+                            }
+                        }
+                    }
+
+                    for catch_info in &outer_catch_blocks {
+                        if let Some(phi) = catch_info.wasmer_exc_phi {
+                            phi.add_incoming(&[(
+                                &wasmer_exc.as_basic_value_enum(),
+                                catch_end_block,
+                            )]);
+                        }
+                        if let Some(phi) = catch_info.uw_exc_ptr_phi {
+                            phi.add_incoming(&[(&uw_exc.as_basic_value_enum(), catch_end_block)]);
+                        }
+                    }
+
+                    err!(self.builder.build_switch(
+                        selector,
+                        rethrow_block,
+                        catch_blocks
+                            .iter()
+                            .enumerate()
+                            .map(|(i, v)| (
+                                self.intrinsics
+                                    .i32_ty
+                                    .const_int(catch_tag_values[i] as _, false),
+                                v.0
+                            ))
+                            .chain(outer_catch_blocks.iter().map(|catch_info| (
+                                self.intrinsics.i32_ty.const_int(catch_info.tag as _, false),
+                                catch_info.catch_block
+                            )))
+                            .collect::<Vec<_>>()
+                            .as_slice()
+                    ));
+
+                    // -- end
+
+                    // -- The rethrow block
+                    self.builder.position_at_end(rethrow_block);
+
+                    err!(self.builder.build_call(
+                        self.intrinsics.rethrow,
+                        &[uw_exc.into()],
+                        "rethrow"
+                    ));
+                    // can't reach after an explicit throw!
+                    err!(self.builder.build_unreachable());
+
+                    maybe_lpad_block = Some(lpad_block);
+                }
+
+                // Move back to current block
+                self.builder.position_at_end(current_block);
+
+                // Note: catch_tag_values also containes outer tags, but zipping with
+                // catch_blocks will let us ignore the extra ones.
+                let catch_tags_and_blocks = catch_tag_values
+                    .into_iter()
+                    .zip(catch_blocks)
+                    .map(
+                        |(tag, (block, wasmer_exc_phi, uw_exc_ptr_phi))| TagCatchInfo {
+                            tag,
+                            catch_block: block,
+                            wasmer_exc_phi,
+                            uw_exc_ptr_phi,
+                        },
+                    )
+                    .collect::<Vec<_>>();
+                self.state.push_landingpad(
+                    maybe_lpad_block,
+                    end_block,
+                    end_phis,
+                    &catch_tags_and_blocks,
+                    self.module_translation
+                        .blocktype_params_results(&try_table.ty)?
+                        .0
+                        .len(),
+                );
+            }
+            Operator::Throw { tag_index } => {
+                let current_block = self
+                    .builder
+                    .get_insert_block()
+                    .ok_or_else(|| CompileError::Codegen("not currently in a block".to_string()))?;
+
+                let tag = self.wasm_module.tags[TagIndex::from_u32(tag_index)];
+                let signature = &self.wasm_module.signatures[tag];
+                let params = signature.params();
+                let values = self.state.popn_save_extra(params.len())?;
+
+                let vmctx_alloca = err!(self.build_or_get_vmctx_alloca());
+                let vmctx_ptr =
+                    err!(self
+                        .builder
+                        .build_load(self.intrinsics.ptr_ty, vmctx_alloca, "vmctx"));
+
+                values.iter().enumerate().try_for_each(|(i, (v, _))| {
+                    let t = type_to_llvm(self.intrinsics, params[i])?;
+                    if t != v.get_type() {
+                        return Err(CompileError::Codegen(format!(
+                            "Incompatible types: {:?} != {:?}",
+                            t,
+                            v.get_type()
+                        )));
+                    }
+
+                    Ok(())
+                })?;
+
+                let exception_type: inkwell::types::StructType =
+                    self.get_or_insert_exception_type(tag_index, signature)?;
+
+                let size = exception_type.size_of().unwrap();
+
+                // Allocate the necessary bytes for the exception.
+                let exc = err!(self.builder.build_direct_call(
+                    self.intrinsics.alloc_exception,
+                    &[size.into()],
+                    "exception_ptr",
+                ));
+                let exc = exc.try_as_basic_value().left().unwrap();
+                let exc = exc.into_pointer_value();
+
+                for (i, value) in values.into_iter().enumerate() {
+                    let ptr = err!(self.builder.build_struct_gep(
+                        exception_type,
+                        exc,
+                        i as u32,
+                        i.to_string().as_str(),
+                    ));
+                    err!(self.builder.build_store(ptr, value.0));
+                }
+
+                if let Some(pad) = self.state.get_innermost_landingpad() {
+                    let unreachable_block = self
+                        .context
+                        .append_basic_block(self.function, "_throw_unreachable");
+
+                    err!(self.builder.build_invoke(
+                        self.intrinsics.throw,
+                        &[
+                            self.intrinsics
+                                .i32_ty
+                                .const_int(tag_index as _, false)
+                                .into(),
+                            vmctx_ptr,
+                            exc.into(),
+                            size.into()
+                        ],
+                        unreachable_block,
+                        pad,
+                        "throw",
+                    ));
+
+                    self.builder.position_at_end(unreachable_block);
+                    // can't reach after an explicit throw!
+                    err!(self.builder.build_unreachable());
+
+                    self.builder.position_at_end(current_block);
+                } else {
+                    err!(self.builder.build_call(
+                        self.intrinsics.throw,
+                        &[
+                            // We pass in the module-local tag index, but it'll be translated
+                            // to a store-unique index in the `throw` intrinsic.
+                            self.intrinsics
+                                .i32_ty
+                                .const_int(tag_index as _, false)
+                                .into(),
+                            vmctx_ptr.into(),
+                            exc.into(),
+                            size.into()
+                        ],
+                        "throw"
+                    ));
+                    // can't reach after an explicit throw!
+                    err!(self.builder.build_unreachable());
+                }
+
+                self.state.reachable = false;
+            }
+            Operator::ThrowRef => {
+                let current_block = self
+                    .builder
+                    .get_insert_block()
+                    .ok_or_else(|| CompileError::Codegen("not currently in a block".to_string()))?;
+
+                let exc = self.state.pop1()?;
+
+                if let Some(pad) = self.state.get_innermost_landingpad() {
+                    let unreachable_block = self
+                        .context
+                        .append_basic_block(self.function, "_rethrow_unreachable");
+
+                    err!(self.builder.build_invoke(
+                        self.intrinsics.rethrow,
+                        &[exc],
+                        unreachable_block,
+                        pad,
+                        "throw",
+                    ));
+
+                    self.builder.position_at_end(unreachable_block);
+                    // can't reach after an explicit throw!
+                    err!(self.builder.build_unreachable());
+
+                    self.builder.position_at_end(current_block);
+                } else {
+                    err!(self.builder.build_call(
+                        self.intrinsics.rethrow,
+                        &[exc.into(),],
+                        "rethrow"
+                    ));
+                    // can't reach after an explicit throw!
+                    err!(self.builder.build_unreachable());
+                }
+
+                self.state.reachable = false;
+            }
             _ => {
                 return Err(CompileError::Codegen(format!(
-                    "Operator {:?} unimplemented",
-                    op
+                    "Operator {op:?} unimplemented",
                 )));
             }
         }
@@ -11447,34 +13009,34 @@ fn is_f64_arithmetic(bits: u64) -> bool {
 // rounding towards zero.
 
 /// Least Exact Float (32 bits) greater-than-or-equal-to i32::MIN when rounding towards zero.
-const LEF32_GEQ_I32_MIN: u64 = std::i32::MIN as u64;
+const LEF32_GEQ_I32_MIN: u64 = i32::MIN as u64;
 /// Greatest Exact Float (32 bits) less-than-or-equal-to i32::MAX when rounding towards zero.
 const GEF32_LEQ_I32_MAX: u64 = 2147483520; // bits as f32: 0x4eff_ffff
 /// Least Exact Float (64 bits) greater-than-or-equal-to i32::MIN when rounding towards zero.
-const LEF64_GEQ_I32_MIN: u64 = std::i32::MIN as u64;
+const LEF64_GEQ_I32_MIN: u64 = i32::MIN as u64;
 /// Greatest Exact Float (64 bits) less-than-or-equal-to i32::MAX when rounding towards zero.
-const GEF64_LEQ_I32_MAX: u64 = std::i32::MAX as u64;
+const GEF64_LEQ_I32_MAX: u64 = i32::MAX as u64;
 /// Least Exact Float (32 bits) greater-than-or-equal-to u32::MIN when rounding towards zero.
-const LEF32_GEQ_U32_MIN: u64 = std::u32::MIN as u64;
+const LEF32_GEQ_U32_MIN: u64 = u32::MIN as u64;
 /// Greatest Exact Float (32 bits) less-than-or-equal-to u32::MAX when rounding towards zero.
 const GEF32_LEQ_U32_MAX: u64 = 4294967040; // bits as f32: 0x4f7f_ffff
 /// Least Exact Float (64 bits) greater-than-or-equal-to u32::MIN when rounding towards zero.
-const LEF64_GEQ_U32_MIN: u64 = std::u32::MIN as u64;
+const LEF64_GEQ_U32_MIN: u64 = u32::MIN as u64;
 /// Greatest Exact Float (64 bits) less-than-or-equal-to u32::MAX when rounding towards zero.
 const GEF64_LEQ_U32_MAX: u64 = 4294967295; // bits as f64: 0x41ef_ffff_ffff_ffff
 /// Least Exact Float (32 bits) greater-than-or-equal-to i64::MIN when rounding towards zero.
-const LEF32_GEQ_I64_MIN: u64 = std::i64::MIN as u64;
+const LEF32_GEQ_I64_MIN: u64 = i64::MIN as u64;
 /// Greatest Exact Float (32 bits) less-than-or-equal-to i64::MAX when rounding towards zero.
 const GEF32_LEQ_I64_MAX: u64 = 9223371487098961920; // bits as f32: 0x5eff_ffff
 /// Least Exact Float (64 bits) greater-than-or-equal-to i64::MIN when rounding towards zero.
-const LEF64_GEQ_I64_MIN: u64 = std::i64::MIN as u64;
+const LEF64_GEQ_I64_MIN: u64 = i64::MIN as u64;
 /// Greatest Exact Float (64 bits) less-than-or-equal-to i64::MAX when rounding towards zero.
 const GEF64_LEQ_I64_MAX: u64 = 9223372036854774784; // bits as f64: 0x43df_ffff_ffff_ffff
 /// Least Exact Float (32 bits) greater-than-or-equal-to u64::MIN when rounding towards zero.
-const LEF32_GEQ_U64_MIN: u64 = std::u64::MIN;
+const LEF32_GEQ_U64_MIN: u64 = u64::MIN;
 /// Greatest Exact Float (32 bits) less-than-or-equal-to u64::MAX when rounding towards zero.
 const GEF32_LEQ_U64_MAX: u64 = 18446742974197923840; // bits as f32: 0x5f7f_ffff
 /// Least Exact Float (64 bits) greater-than-or-equal-to u64::MIN when rounding towards zero.
-const LEF64_GEQ_U64_MIN: u64 = std::u64::MIN;
+const LEF64_GEQ_U64_MIN: u64 = u64::MIN;
 /// Greatest Exact Float (64 bits) less-than-or-equal-to u64::MAX when rounding towards zero.
 const GEF64_LEQ_U64_MAX: u64 = 18446744073709549568; // bits as f64: 0x43ef_ffff_ffff_ffff
diff --git a/lib/compiler-llvm/src/translator/intrinsics.rs b/lib/compiler-llvm/src/translator/intrinsics.rs
index f1f7346c41..661fe5b7c5 100644
--- a/lib/compiler-llvm/src/translator/intrinsics.rs
+++ b/lib/compiler-llvm/src/translator/intrinsics.rs
@@ -5,6 +5,8 @@
 //! [llvm-intrinsics]: https://llvm.org/docs/LangRef.html#intrinsic-functions
 
 use crate::abi::Abi;
+use crate::error::err;
+use crate::LLVM;
 use inkwell::values::BasicMetadataValueEnum;
 use inkwell::{
     attributes::{Attribute, AttributeLoc},
@@ -32,17 +34,10 @@ use wasmer_vm::{MemoryStyle, TrapCode, VMBuiltinFunctionIndex, VMOffsets};
 
 pub fn type_to_llvm_ptr<'ctx>(
     intrinsics: &Intrinsics<'ctx>,
-    ty: Type,
+    _ty: Type,
 ) -> Result<PointerType<'ctx>, CompileError> {
-    match ty {
-        Type::I32 => Ok(intrinsics.i32_ptr_ty),
-        Type::I64 => Ok(intrinsics.i64_ptr_ty),
-        Type::F32 => Ok(intrinsics.f32_ptr_ty),
-        Type::F64 => Ok(intrinsics.f64_ptr_ty),
-        Type::V128 => Ok(intrinsics.i128_ptr_ty),
-        Type::FuncRef => Ok(intrinsics.funcref_ty.ptr_type(AddressSpace::default())),
-        Type::ExternRef => Ok(intrinsics.externref_ty.ptr_type(AddressSpace::default())),
-    }
+    // LLVM v. > 15 has a single pointer type.
+    Ok(intrinsics.ptr_ty)
 }
 
 pub fn type_to_llvm<'ctx>(
@@ -55,12 +50,14 @@ pub fn type_to_llvm<'ctx>(
         Type::F32 => Ok(intrinsics.f32_ty.as_basic_type_enum()),
         Type::F64 => Ok(intrinsics.f64_ty.as_basic_type_enum()),
         Type::V128 => Ok(intrinsics.i128_ty.as_basic_type_enum()),
-        Type::FuncRef => Ok(intrinsics.funcref_ty.as_basic_type_enum()),
-        Type::ExternRef => Ok(intrinsics.externref_ty.as_basic_type_enum()),
+        Type::FuncRef | Type::ExceptionRef | Type::ExternRef => {
+            Ok(intrinsics.ptr_ty.as_basic_type_enum())
+        }
     }
 }
 
 /// Struct containing LLVM and VM intrinsics.
+#[allow(dead_code)]
 pub struct Intrinsics<'ctx> {
     pub ctlz_i32: FunctionValue<'ctx>,
     pub ctlz_i64: FunctionValue<'ctx>,
@@ -156,8 +153,11 @@ pub struct Intrinsics<'ctx> {
     pub debug_trap: FunctionValue<'ctx>,
 
     pub personality: FunctionValue<'ctx>,
+    pub personality2: FunctionValue<'ctx>,
     pub readonly: Attribute,
     pub stack_probe: Attribute,
+    pub uwtable: Attribute,
+    pub frame_pointer: Attribute,
 
     pub void_ty: VoidType<'ctx>,
     pub i1_ty: IntType<'ctx>,
@@ -181,20 +181,10 @@ pub struct Intrinsics<'ctx> {
     pub f64x2_ty: VectorType<'ctx>,
     pub i32x8_ty: VectorType<'ctx>,
 
-    pub i8_ptr_ty: PointerType<'ctx>,
-    pub i16_ptr_ty: PointerType<'ctx>,
-    pub i32_ptr_ty: PointerType<'ctx>,
-    pub i64_ptr_ty: PointerType<'ctx>,
-    pub i128_ptr_ty: PointerType<'ctx>,
-    pub isize_ptr_ty: PointerType<'ctx>,
-    pub f32_ptr_ty: PointerType<'ctx>,
-    pub f64_ptr_ty: PointerType<'ctx>,
+    pub ptr_ty: PointerType<'ctx>,
 
     pub anyfunc_ty: StructType<'ctx>,
-
-    pub funcref_ty: PointerType<'ctx>,
-    pub externref_ty: PointerType<'ctx>,
-    pub anyref_ty: PointerType<'ctx>,
+    pub exc_ty: StructType<'ctx>,
 
     pub i1_zero: IntValue<'ctx>,
     pub i8_zero: IntValue<'ctx>,
@@ -254,30 +244,34 @@ pub struct Intrinsics<'ctx> {
 
     pub throw_trap: FunctionValue<'ctx>,
 
+    // EH
+    pub throw: FunctionValue<'ctx>,
+    pub rethrow: FunctionValue<'ctx>,
+    pub alloc_exception: FunctionValue<'ctx>,
+    pub delete_exception: FunctionValue<'ctx>,
+    pub read_exception: FunctionValue<'ctx>,
+
+    // Debug
+    pub debug_ptr: FunctionValue<'ctx>,
+    pub debug_str: FunctionValue<'ctx>,
+
     // VM builtins.
-    pub vmfunction_import_ptr_ty: PointerType<'ctx>,
     pub vmfunction_import_ty: StructType<'ctx>,
     pub vmfunction_import_body_element: u32,
     pub vmfunction_import_vmctx_element: u32,
 
-    pub vmmemory_definition_ptr_ty: PointerType<'ctx>,
     pub vmmemory_definition_ty: StructType<'ctx>,
     pub vmmemory_definition_base_element: u32,
     pub vmmemory_definition_current_length_element: u32,
+}
 
-    pub memory32_grow_ptr_ty: PointerType<'ctx>,
-    pub imported_memory32_grow_ptr_ty: PointerType<'ctx>,
-    pub memory32_size_ptr_ty: PointerType<'ctx>,
-    pub imported_memory32_size_ptr_ty: PointerType<'ctx>,
-    pub memory32_wait32_ptr_ty: PointerType<'ctx>,
-    pub imported_memory32_wait32_ptr_ty: PointerType<'ctx>,
-    pub memory32_wait64_ptr_ty: PointerType<'ctx>,
-    pub imported_memory32_wait64_ptr_ty: PointerType<'ctx>,
-    pub memory32_notify_ptr_ty: PointerType<'ctx>,
-    pub imported_memory32_notify_ptr_ty: PointerType<'ctx>,
-
-    // Pointer to the VM.
-    pub ctx_ptr_ty: PointerType<'ctx>,
+#[derive(Debug, Hash, PartialEq, Eq)]
+enum MemoryOp {
+    Size,
+    Grow,
+    Wait32,
+    Wait64,
+    Notify,
 }
 
 impl<'ctx> Intrinsics<'ctx> {
@@ -286,6 +280,7 @@ impl<'ctx> Intrinsics<'ctx> {
         module: &Module<'ctx>,
         context: &'ctx Context,
         target_data: &TargetData,
+        binary_fmt: &target_lexicon::BinaryFormat,
     ) -> Self {
         let void_ty = context.void_type();
         let i1_ty = context.bool_type();
@@ -311,14 +306,7 @@ impl<'ctx> Intrinsics<'ctx> {
         let f64x2_ty = f64_ty.vec_type(2);
         let i32x8_ty = i32_ty.vec_type(8);
 
-        let i8_ptr_ty = i8_ty.ptr_type(AddressSpace::default());
-        let i16_ptr_ty = i16_ty.ptr_type(AddressSpace::default());
-        let i32_ptr_ty = i32_ty.ptr_type(AddressSpace::default());
-        let i64_ptr_ty = i64_ty.ptr_type(AddressSpace::default());
-        let i128_ptr_ty = i128_ty.ptr_type(AddressSpace::default());
-        let isize_ptr_ty = isize_ty.ptr_type(AddressSpace::default());
-        let f32_ptr_ty = f32_ty.ptr_type(AddressSpace::default());
-        let f64_ptr_ty = f64_ty.ptr_type(AddressSpace::default());
+        let ptr_ty = context.ptr_type(AddressSpace::default());
 
         let i1_zero = i1_ty.const_int(0, false);
         let i8_zero = i8_ty.const_int(0, false);
@@ -351,7 +339,7 @@ impl<'ctx> Intrinsics<'ctx> {
 
         let md_ty = context.metadata_type();
 
-        let i8_ptr_ty_basic = i8_ptr_ty.as_basic_type_enum();
+        let i8_ptr_ty_basic = ptr_ty.as_basic_type_enum();
 
         let i1_ty_basic_md: BasicMetadataTypeEnum = i1_ty.into();
         let i32_ty_basic_md: BasicMetadataTypeEnum = i32_ty.into();
@@ -364,8 +352,7 @@ impl<'ctx> Intrinsics<'ctx> {
         let f64x2_ty_basic_md: BasicMetadataTypeEnum = f64x2_ty.into();
         let md_ty_basic_md: BasicMetadataTypeEnum = md_ty.into();
 
-        let ctx_ty = i8_ty;
-        let ctx_ptr_ty = ctx_ty.ptr_type(AddressSpace::default());
+        let ctx_ptr_ty = ptr_ty;
         let ctx_ptr_ty_basic = ctx_ptr_ty.as_basic_type_enum();
         let ctx_ptr_ty_basic_md: BasicMetadataTypeEnum = ctx_ptr_ty.into();
 
@@ -375,9 +362,8 @@ impl<'ctx> Intrinsics<'ctx> {
             &[i8_ptr_ty_basic, sigindex_ty.into(), ctx_ptr_ty_basic],
             false,
         );
-        let funcref_ty = anyfunc_ty.ptr_type(AddressSpace::default());
-        let externref_ty = funcref_ty;
-        let anyref_ty = i8_ptr_ty;
+        let funcref_ty = ptr_ty;
+        let anyref_ty = ptr_ty;
         let anyref_ty_basic_md: BasicMetadataTypeEnum = anyref_ty.into();
 
         let ret_i8x16_take_i8x16 = i8x16_ty.fn_type(&[i8x16_ty_basic_md], false);
@@ -715,14 +701,35 @@ impl<'ctx> Intrinsics<'ctx> {
             trap: module.add_function("llvm.trap", void_ty.fn_type(&[], false), None),
             debug_trap: module.add_function("llvm.debugtrap", void_ty.fn_type(&[], false), None),
             personality: module.add_function(
-                "__gxx_personality_v0",
-                i32_ty.fn_type(&[], false),
-                Some(Linkage::External),
+                if matches!(binary_fmt, target_lexicon::BinaryFormat::Macho) {
+                    // Note: on macOS+Mach-O the personality function *must* be called like this, otherwise LLVM
+                    // will generate things differently than "normal", wreaking havoc.
+                    "__gxx_personality_v0"
+                } else {
+                    "wasmer_eh_personality"
+                },
+                i32_ty.fn_type(
+                    &[
+                        i32_ty.into(),
+                        i32_ty.into(),
+                        i64_ty.into(),
+                        ptr_ty.into(),
+                        ptr_ty.into(),
+                    ],
+                    false,
+                ),
+                None,
+            ),
+            personality2: module.add_function(
+                "wasmer_eh_personality2",
+                i32_ty.fn_type(&[ptr_ty.into(), ptr_ty.into()], false),
+                None,
             ),
             readonly: context
                 .create_enum_attribute(Attribute::get_named_enum_kind_id("readonly"), 0),
             stack_probe: context.create_string_attribute("probe-stack", "inline-asm"),
-
+            uwtable: context.create_enum_attribute(Attribute::get_named_enum_kind_id("uwtable"), 1),
+            frame_pointer: context.create_string_attribute("frame-pointer", "non-leaf"),
             void_ty,
             i1_ty,
             i2_ty,
@@ -745,21 +752,8 @@ impl<'ctx> Intrinsics<'ctx> {
             f64x2_ty,
             i32x8_ty,
 
-            i8_ptr_ty,
-            i16_ptr_ty,
-            i32_ptr_ty,
-            i64_ptr_ty,
-            i128_ptr_ty,
-            isize_ptr_ty,
-            f32_ptr_ty,
-            f64_ptr_ty,
-
             anyfunc_ty,
-
-            funcref_ty,
-            externref_ty,
-            anyref_ty,
-
+            exc_ty: context.struct_type(&[i32_ty.into(), ptr_ty.into(), i64_ty.into()], false),
             i1_zero,
             i8_zero,
             i32_zero,
@@ -1031,6 +1025,46 @@ impl<'ctx> Intrinsics<'ctx> {
                 void_ty.fn_type(&[i32_ty_basic_md], false),
                 None,
             ),
+
+            throw: module.add_function(
+                "wasmer_vm_throw",
+                void_ty.fn_type(
+                    &[i32_ty.into(), ptr_ty.into(), ptr_ty.into(), i64_ty.into()],
+                    false,
+                ),
+                None,
+            ),
+            rethrow: module.add_function(
+                "wasmer_vm_rethrow",
+                void_ty.fn_type(&[ptr_ty.into()], false),
+                None,
+            ),
+            alloc_exception: module.add_function(
+                "wasmer_vm_alloc_exception",
+                ptr_ty.fn_type(&[i64_ty.into()], false),
+                None,
+            ),
+            delete_exception: module.add_function(
+                "wasmer_vm_delete_exception",
+                void_ty.fn_type(&[ptr_ty.into()], false),
+                None,
+            ),
+            read_exception: module.add_function(
+                "wasmer_vm_read_exception",
+                ptr_ty.fn_type(&[ptr_ty.into()], false),
+                None,
+            ),
+
+            debug_ptr: module.add_function(
+                "wasmer_vm_dbg_usize",
+                void_ty.fn_type(&[ptr_ty.into()], false),
+                None,
+            ),
+            debug_str: module.add_function(
+                "wasmer_vm_dbg_str",
+                void_ty.fn_type(&[ptr_ty.into(), i32_ty.into()], false),
+                None,
+            ),
             memory_wait32: module.add_function(
                 "wasmer_vm_memory32_atomic_wait32",
                 i32_ty.fn_type(
@@ -1143,110 +1177,15 @@ impl<'ctx> Intrinsics<'ctx> {
                 None,
             ),
 
-            vmfunction_import_ptr_ty: context
-                .struct_type(&[i8_ptr_ty_basic, i8_ptr_ty_basic], false)
-                .ptr_type(AddressSpace::default()),
             vmfunction_import_ty: context.struct_type(&[i8_ptr_ty_basic, i8_ptr_ty_basic], false),
             vmfunction_import_body_element: 0,
             vmfunction_import_vmctx_element: 1,
-
-            vmmemory_definition_ptr_ty: context
-                .struct_type(&[i8_ptr_ty_basic, isize_ty.into()], false)
-                .ptr_type(AddressSpace::default()),
             vmmemory_definition_ty: context.struct_type(&[i8_ptr_ty_basic, isize_ty.into()], false),
             vmmemory_definition_base_element: 0,
             vmmemory_definition_current_length_element: 1,
 
-            memory32_grow_ptr_ty: i32_ty
-                .fn_type(
-                    &[ctx_ptr_ty_basic_md, i32_ty_basic_md, i32_ty_basic_md],
-                    false,
-                )
-                .ptr_type(AddressSpace::default()),
-            imported_memory32_grow_ptr_ty: i32_ty
-                .fn_type(
-                    &[ctx_ptr_ty_basic_md, i32_ty_basic_md, i32_ty_basic_md],
-                    false,
-                )
-                .ptr_type(AddressSpace::default()),
-            memory32_size_ptr_ty: i32_ty
-                .fn_type(&[ctx_ptr_ty_basic_md, i32_ty_basic_md], false)
-                .ptr_type(AddressSpace::default()),
-            imported_memory32_size_ptr_ty: i32_ty
-                .fn_type(&[ctx_ptr_ty_basic_md, i32_ty_basic_md], false)
-                .ptr_type(AddressSpace::default()),
-            memory32_wait32_ptr_ty: i32_ty
-                .fn_type(
-                    &[
-                        ctx_ptr_ty_basic_md,
-                        i32_ty_basic_md,
-                        i32_ty_basic_md,
-                        i32_ty_basic_md,
-                        i64_ty_basic_md,
-                    ],
-                    false,
-                )
-                .ptr_type(AddressSpace::default()),
-            imported_memory32_wait32_ptr_ty: i32_ty
-                .fn_type(
-                    &[
-                        ctx_ptr_ty_basic_md,
-                        i32_ty_basic_md,
-                        i32_ty_basic_md,
-                        i32_ty_basic_md,
-                        i64_ty_basic_md,
-                    ],
-                    false,
-                )
-                .ptr_type(AddressSpace::default()),
-            memory32_wait64_ptr_ty: i32_ty
-                .fn_type(
-                    &[
-                        ctx_ptr_ty_basic_md,
-                        i32_ty_basic_md,
-                        i32_ty_basic_md,
-                        i64_ty_basic_md,
-                        i64_ty_basic_md,
-                    ],
-                    false,
-                )
-                .ptr_type(AddressSpace::default()),
-            imported_memory32_wait64_ptr_ty: i32_ty
-                .fn_type(
-                    &[
-                        ctx_ptr_ty_basic_md,
-                        i32_ty_basic_md,
-                        i32_ty_basic_md,
-                        i64_ty_basic_md,
-                        i64_ty_basic_md,
-                    ],
-                    false,
-                )
-                .ptr_type(AddressSpace::default()),
-            memory32_notify_ptr_ty: i32_ty
-                .fn_type(
-                    &[
-                        ctx_ptr_ty_basic_md,
-                        i32_ty_basic_md,
-                        i32_ty_basic_md,
-                        i32_ty_basic_md,
-                    ],
-                    false,
-                )
-                .ptr_type(AddressSpace::default()),
-            imported_memory32_notify_ptr_ty: i32_ty
-                .fn_type(
-                    &[
-                        ctx_ptr_ty_basic_md,
-                        i32_ty_basic_md,
-                        i32_ty_basic_md,
-                        i32_ty_basic_md,
-                    ],
-                    false,
-                )
-                .ptr_type(AddressSpace::default()),
-
-            ctx_ptr_ty,
+            // LLVM > 15 has a single type for pointers.
+            ptr_ty,
         };
 
         let noreturn =
@@ -1254,10 +1193,6 @@ impl<'ctx> Intrinsics<'ctx> {
         intrinsics
             .throw_trap
             .add_attribute(AttributeLoc::Function, noreturn);
-        intrinsics
-            .func_ref
-            .add_attribute(AttributeLoc::Function, intrinsics.readonly);
-
         intrinsics
     }
 }
@@ -1273,6 +1208,7 @@ pub enum MemoryCache<'ctx> {
     Static { base_ptr: PointerValue<'ctx> },
 }
 
+#[derive(Clone)]
 struct TableCache<'ctx> {
     ptr_to_base_ptr: PointerValue<'ctx>,
     ptr_to_bounds: PointerValue<'ctx>,
@@ -1300,6 +1236,7 @@ pub struct FunctionCache<'ctx> {
 pub struct CtxType<'ctx, 'a> {
     ctx_ptr_value: PointerValue<'ctx>,
 
+    config: &'a LLVM,
     wasm_module: &'a WasmerCompilerModule,
     cache_builder: &'a Builder<'ctx>,
     abi: &'a dyn Abi,
@@ -1309,8 +1246,7 @@ pub struct CtxType<'ctx, 'a> {
     cached_sigindices: HashMap<SignatureIndex, IntValue<'ctx>>,
     cached_globals: HashMap<GlobalIndex, GlobalCache<'ctx>>,
     cached_functions: HashMap<FunctionIndex, FunctionCache<'ctx>>,
-    cached_memory_grow: HashMap<MemoryIndex, PointerValue<'ctx>>,
-    cached_memory_size: HashMap<MemoryIndex, PointerValue<'ctx>>,
+    cached_memory_op: HashMap<(MemoryIndex, MemoryOp), PointerValue<'ctx>>,
 
     offsets: VMOffsets,
 }
@@ -1321,8 +1257,10 @@ impl<'ctx, 'a> CtxType<'ctx, 'a> {
         func_value: &FunctionValue<'ctx>,
         cache_builder: &'a Builder<'ctx>,
         abi: &'a dyn Abi,
+        config: &'a LLVM,
     ) -> CtxType<'ctx, 'a> {
         CtxType {
+            config,
             ctx_ptr_value: abi.get_vmctx_ptr_param(func_value),
 
             wasm_module,
@@ -1334,8 +1272,7 @@ impl<'ctx, 'a> CtxType<'ctx, 'a> {
             cached_sigindices: HashMap::new(),
             cached_globals: HashMap::new(),
             cached_functions: HashMap::new(),
-            cached_memory_grow: HashMap::new(),
-            cached_memory_size: HashMap::new(),
+            cached_memory_op: HashMap::new(),
 
             // TODO: pointer width
             offsets: VMOffsets::new(8, wasm_module),
@@ -1352,7 +1289,7 @@ impl<'ctx, 'a> CtxType<'ctx, 'a> {
         intrinsics: &Intrinsics<'ctx>,
         module: &Module<'ctx>,
         memory_styles: &PrimaryMap<MemoryIndex, MemoryStyle>,
-    ) -> MemoryCache<'ctx> {
+    ) -> Result<MemoryCache<'ctx>, CompileError> {
         let (cached_memories, wasm_module, ctx_ptr_value, cache_builder, offsets) = (
             &mut self.cached_memories,
             self.wasm_module,
@@ -1361,78 +1298,162 @@ impl<'ctx, 'a> CtxType<'ctx, 'a> {
             &self.offsets,
         );
         let memory_style = &memory_styles[index];
-        *cached_memories.entry(index).or_insert_with(|| {
-            let memory_definition_ptr = if let Some(local_memory_index) =
-                wasm_module.local_memory_index(index)
-            {
-                let offset = offsets.vmctx_vmmemory_definition(local_memory_index);
-                let offset = intrinsics.i32_ty.const_int(offset.into(), false);
-                unsafe { cache_builder.build_gep(intrinsics.i8_ty, ctx_ptr_value, &[offset], "") }
-            } else {
-                let offset = offsets.vmctx_vmmemory_import(index);
-                let offset = intrinsics.i32_ty.const_int(offset.into(), false);
-                let memory_definition_ptr_ptr = unsafe {
-                    cache_builder.build_gep(intrinsics.i8_ty, ctx_ptr_value, &[offset], "")
-                };
-                let memory_definition_ptr_ptr = cache_builder
-                    .build_bitcast(
-                        memory_definition_ptr_ptr,
-                        intrinsics.i8_ptr_ty.ptr_type(AddressSpace::default()),
-                        "",
-                    )
-                    .into_pointer_value();
-                let memory_definition_ptr = cache_builder
-                    .build_load(intrinsics.i8_ptr_ty, memory_definition_ptr_ptr, "")
-                    .into_pointer_value();
-                tbaa_label(
-                    module,
-                    intrinsics,
-                    format!("memory {} definition", index.as_u32()),
-                    memory_definition_ptr.as_instruction_value().unwrap(),
-                );
-                memory_definition_ptr
-            };
-            let memory_definition_ptr = cache_builder
-                .build_bitcast(
+        match cached_memories.get(&index) {
+            Some(r) => Ok(*r),
+            None => {
+                let memory_definition_ptr =
+                    if let Some(local_memory_index) = wasm_module.local_memory_index(index) {
+                        let offset = offsets.vmctx_vmmemory_definition(local_memory_index);
+                        let offset = intrinsics.i32_ty.const_int(offset.into(), false);
+                        unsafe {
+                            err!(cache_builder.build_gep(
+                                intrinsics.i8_ty,
+                                ctx_ptr_value,
+                                &[offset],
+                                ""
+                            ))
+                        }
+                    } else {
+                        let offset = offsets.vmctx_vmmemory_import(index);
+                        let offset = intrinsics.i32_ty.const_int(offset.into(), false);
+                        let memory_definition_ptr_ptr = unsafe {
+                            err!(cache_builder.build_gep(
+                                intrinsics.i8_ty,
+                                ctx_ptr_value,
+                                &[offset],
+                                ""
+                            ))
+                        };
+                        let memory_definition_ptr_ptr = err!(cache_builder.build_bit_cast(
+                            memory_definition_ptr_ptr,
+                            intrinsics.ptr_ty,
+                            "",
+                        ))
+                        .into_pointer_value();
+                        let memory_definition_ptr = err!(cache_builder.build_load(
+                            intrinsics.ptr_ty,
+                            memory_definition_ptr_ptr,
+                            ""
+                        ))
+                        .into_pointer_value();
+                        tbaa_label(
+                            module,
+                            intrinsics,
+                            format!("memory {} definition", index.as_u32()),
+                            memory_definition_ptr.as_instruction_value().unwrap(),
+                        );
+                        memory_definition_ptr
+                    };
+                let memory_definition_ptr = err!(cache_builder.build_bit_cast(
                     memory_definition_ptr,
-                    intrinsics.vmmemory_definition_ptr_ty,
+                    intrinsics.ptr_ty,
                     "",
-                )
+                ))
                 .into_pointer_value();
-            let base_ptr = cache_builder
-                .build_struct_gep(
+                let base_ptr = err!(cache_builder.build_struct_gep(
                     intrinsics.vmmemory_definition_ty,
                     memory_definition_ptr,
                     intrinsics.vmmemory_definition_base_element,
                     "",
-                )
-                .unwrap();
-            if let MemoryStyle::Dynamic { .. } = memory_style {
-                let current_length_ptr = cache_builder
-                    .build_struct_gep(
+                ));
+                let value = if let MemoryStyle::Dynamic { .. } = memory_style {
+                    let current_length_ptr = err!(cache_builder.build_struct_gep(
                         intrinsics.vmmemory_definition_ty,
                         memory_definition_ptr,
                         intrinsics.vmmemory_definition_current_length_element,
                         "",
-                    )
-                    .unwrap();
-                MemoryCache::Dynamic {
-                    ptr_to_base_ptr: base_ptr,
-                    ptr_to_current_length: current_length_ptr,
-                }
-            } else {
-                let base_ptr = cache_builder
-                    .build_load(intrinsics.i8_ptr_ty, base_ptr, "")
-                    .into_pointer_value();
-                tbaa_label(
-                    module,
-                    intrinsics,
-                    format!("memory base_ptr {}", index.as_u32()),
-                    base_ptr.as_instruction_value().unwrap(),
-                );
-                MemoryCache::Static { base_ptr }
+                    ));
+                    MemoryCache::Dynamic {
+                        ptr_to_base_ptr: base_ptr,
+                        ptr_to_current_length: current_length_ptr,
+                    }
+                } else {
+                    let base_ptr = err!(cache_builder.build_load(intrinsics.ptr_ty, base_ptr, ""))
+                        .into_pointer_value();
+                    tbaa_label(
+                        module,
+                        intrinsics,
+                        format!("memory base_ptr {}", index.as_u32()),
+                        base_ptr.as_instruction_value().unwrap(),
+                    );
+                    MemoryCache::Static { base_ptr }
+                };
+
+                self.cached_memories.insert(index, value);
+                Ok(*self.cached_memories.get(&index).unwrap())
             }
-        })
+        }
+    }
+
+    fn build_table_prepare(
+        table_index: TableIndex,
+        intrinsics: &Intrinsics<'ctx>,
+        module: &Module<'ctx>,
+        wasm_module: &WasmerCompilerModule,
+        ctx_ptr_value: PointerValue<'ctx>,
+        offsets: &VMOffsets,
+        builder: &Builder<'ctx>,
+    ) -> Result<(PointerValue<'ctx>, PointerValue<'ctx>), CompileError> {
+        if let Some(local_table_index) = wasm_module.local_table_index(table_index) {
+            let offset = intrinsics.i64_ty.const_int(
+                offsets
+                    .vmctx_vmtable_definition_base(local_table_index)
+                    .into(),
+                false,
+            );
+            let ptr_to_base_ptr =
+                unsafe { err!(builder.build_gep(intrinsics.i8_ty, ctx_ptr_value, &[offset], "")) };
+            let ptr_to_base_ptr =
+                err!(builder.build_bit_cast(ptr_to_base_ptr, intrinsics.ptr_ty, ""))
+                    .into_pointer_value();
+            let offset = intrinsics.i64_ty.const_int(
+                offsets
+                    .vmctx_vmtable_definition_current_elements(local_table_index)
+                    .into(),
+                false,
+            );
+            let ptr_to_bounds =
+                unsafe { err!(builder.build_gep(intrinsics.i8_ty, ctx_ptr_value, &[offset], "")) };
+            let ptr_to_bounds = err!(builder.build_bit_cast(ptr_to_bounds, intrinsics.ptr_ty, ""))
+                .into_pointer_value();
+            Ok((ptr_to_base_ptr, ptr_to_bounds))
+        } else {
+            let offset = intrinsics.i64_ty.const_int(
+                offsets.vmctx_vmtable_import_definition(table_index).into(),
+                false,
+            );
+            let definition_ptr_ptr =
+                unsafe { err!(builder.build_gep(intrinsics.i8_ty, ctx_ptr_value, &[offset], "")) };
+            let definition_ptr_ptr =
+                err!(builder.build_bit_cast(definition_ptr_ptr, intrinsics.ptr_ty, "",))
+                    .into_pointer_value();
+            let definition_ptr =
+                err!(builder.build_load(intrinsics.ptr_ty, definition_ptr_ptr, ""))
+                    .into_pointer_value();
+            tbaa_label(
+                module,
+                intrinsics,
+                format!("table {} definition", table_index.as_u32()),
+                definition_ptr.as_instruction_value().unwrap(),
+            );
+
+            let offset = intrinsics
+                .i64_ty
+                .const_int(offsets.vmtable_definition_base().into(), false);
+            let ptr_to_base_ptr =
+                unsafe { err!(builder.build_gep(intrinsics.i8_ty, definition_ptr, &[offset], "")) };
+            let ptr_to_base_ptr =
+                err!(builder.build_bit_cast(ptr_to_base_ptr, intrinsics.ptr_ty, ""))
+                    .into_pointer_value();
+            let offset = intrinsics
+                .i64_ty
+                .const_int(offsets.vmtable_definition_current_elements().into(), false);
+            let ptr_to_bounds =
+                unsafe { err!(builder.build_gep(intrinsics.i8_ty, definition_ptr, &[offset], "")) };
+            let ptr_to_bounds = err!(builder.build_bit_cast(ptr_to_bounds, intrinsics.ptr_ty, ""))
+                .into_pointer_value();
+            Ok((ptr_to_base_ptr, ptr_to_bounds))
+        }
     }
 
     fn table_prepare(
@@ -1440,7 +1461,8 @@ impl<'ctx, 'a> CtxType<'ctx, 'a> {
         table_index: TableIndex,
         intrinsics: &Intrinsics<'ctx>,
         module: &Module<'ctx>,
-    ) -> (PointerValue<'ctx>, PointerValue<'ctx>) {
+        body_builder: &Builder<'ctx>,
+    ) -> Result<(PointerValue<'ctx>, PointerValue<'ctx>), CompileError> {
         let (cached_tables, wasm_module, ctx_ptr_value, cache_builder, offsets) = (
             &mut self.cached_tables,
             self.wasm_module,
@@ -1448,97 +1470,56 @@ impl<'ctx, 'a> CtxType<'ctx, 'a> {
             &self.cache_builder,
             &self.offsets,
         );
-        let TableCache {
-            ptr_to_base_ptr,
-            ptr_to_bounds,
-        } = *cached_tables.entry(table_index).or_insert_with(|| {
-            let (ptr_to_base_ptr, ptr_to_bounds) =
-                if let Some(local_table_index) = wasm_module.local_table_index(table_index) {
-                    let offset = intrinsics.i64_ty.const_int(
-                        offsets
-                            .vmctx_vmtable_definition_base(local_table_index)
-                            .into(),
-                        false,
-                    );
-                    let ptr_to_base_ptr = unsafe {
-                        cache_builder.build_gep(intrinsics.i8_ty, ctx_ptr_value, &[offset], "")
-                    };
-                    let ptr_to_base_ptr = cache_builder
-                        .build_bitcast(
-                            ptr_to_base_ptr,
-                            intrinsics.i8_ptr_ty.ptr_type(AddressSpace::default()),
-                            "",
-                        )
-                        .into_pointer_value();
-                    let offset = intrinsics.i64_ty.const_int(
-                        offsets
-                            .vmctx_vmtable_definition_current_elements(local_table_index)
-                            .into(),
-                        false,
-                    );
-                    let ptr_to_bounds = unsafe {
-                        cache_builder.build_gep(intrinsics.i8_ty, ctx_ptr_value, &[offset], "")
-                    };
-                    let ptr_to_bounds = cache_builder
-                        .build_bitcast(ptr_to_bounds, intrinsics.i32_ptr_ty, "")
-                        .into_pointer_value();
-                    (ptr_to_base_ptr, ptr_to_bounds)
-                } else {
-                    let offset = intrinsics.i64_ty.const_int(
-                        offsets.vmctx_vmtable_import_definition(table_index).into(),
-                        false,
-                    );
-                    let definition_ptr_ptr = unsafe {
-                        cache_builder.build_gep(intrinsics.i8_ty, ctx_ptr_value, &[offset], "")
-                    };
-                    let definition_ptr_ptr = cache_builder
-                        .build_bitcast(
-                            definition_ptr_ptr,
-                            intrinsics.i8_ptr_ty.ptr_type(AddressSpace::default()),
-                            "",
-                        )
-                        .into_pointer_value();
-                    let definition_ptr = cache_builder
-                        .build_load(intrinsics.i8_ptr_ty, definition_ptr_ptr, "")
-                        .into_pointer_value();
-                    tbaa_label(
-                        module,
-                        intrinsics,
-                        format!("table {} definition", table_index.as_u32()),
-                        definition_ptr.as_instruction_value().unwrap(),
-                    );
 
-                    let offset = intrinsics
-                        .i64_ty
-                        .const_int(offsets.vmtable_definition_base().into(), false);
-                    let ptr_to_base_ptr = unsafe {
-                        cache_builder.build_gep(intrinsics.i8_ty, definition_ptr, &[offset], "")
-                    };
-                    let ptr_to_base_ptr = cache_builder
-                        .build_bitcast(
-                            ptr_to_base_ptr,
-                            intrinsics.i8_ptr_ty.ptr_type(AddressSpace::default()),
-                            "",
-                        )
-                        .into_pointer_value();
-                    let offset = intrinsics
-                        .i64_ty
-                        .const_int(offsets.vmtable_definition_current_elements().into(), false);
-                    let ptr_to_bounds = unsafe {
-                        cache_builder.build_gep(intrinsics.i8_ty, definition_ptr, &[offset], "")
-                    };
-                    let ptr_to_bounds = cache_builder
-                        .build_bitcast(ptr_to_bounds, intrinsics.i32_ptr_ty, "")
-                        .into_pointer_value();
-                    (ptr_to_base_ptr, ptr_to_bounds)
-                };
-            TableCache {
+        let is_growable = is_table_growable(wasm_module, table_index).ok_or_else(|| {
+            CompileError::Codegen(format!(
+                "Table index out of bounds: {}",
+                table_index.as_u32()
+            ))
+        })?;
+
+        // If the table is growable, it may change, so we can't cache the pointers; they need to
+        // go directly in the function body at the point where they're needed
+        if is_growable {
+            Self::build_table_prepare(
+                table_index,
+                intrinsics,
+                module,
+                wasm_module,
+                ctx_ptr_value,
+                offsets,
+                body_builder,
+            )
+        } else {
+            let TableCache {
                 ptr_to_base_ptr,
                 ptr_to_bounds,
-            }
-        });
+            } = match cached_tables.entry(table_index) {
+                Entry::Occupied(entry) => entry.get().clone(),
+                Entry::Vacant(entry) => {
+                    let (ptr_to_base_ptr, ptr_to_bounds) = Self::build_table_prepare(
+                        table_index,
+                        intrinsics,
+                        module,
+                        wasm_module,
+                        ctx_ptr_value,
+                        offsets,
+                        cache_builder,
+                    )?;
+
+                    let v = TableCache {
+                        ptr_to_base_ptr,
+                        ptr_to_bounds,
+                    };
+
+                    entry.insert(v.clone());
 
-        (ptr_to_base_ptr, ptr_to_bounds)
+                    v
+                }
+            };
+
+            Ok((ptr_to_base_ptr, ptr_to_bounds))
+        }
     }
 
     pub fn table(
@@ -1546,16 +1527,22 @@ impl<'ctx, 'a> CtxType<'ctx, 'a> {
         index: TableIndex,
         intrinsics: &Intrinsics<'ctx>,
         module: &Module<'ctx>,
-    ) -> (PointerValue<'ctx>, IntValue<'ctx>) {
-        let (ptr_to_base_ptr, ptr_to_bounds) = self.table_prepare(index, intrinsics, module);
-        let base_ptr = self
-            .cache_builder
-            .build_load(intrinsics.i8_ptr_ty, ptr_to_base_ptr, "base_ptr")
+        body_builder: &Builder<'ctx>,
+    ) -> Result<(PointerValue<'ctx>, IntValue<'ctx>), CompileError> {
+        let (ptr_to_base_ptr, ptr_to_bounds) =
+            self.table_prepare(index, intrinsics, module, body_builder)?;
+
+        // Safe to unwrap since an out-of-bounds index will be caught be table_prepare
+        let builder = if is_table_growable(self.wasm_module, index).unwrap() {
+            &body_builder
+        } else {
+            &self.cache_builder
+        };
+
+        let base_ptr = err!(builder.build_load(intrinsics.ptr_ty, ptr_to_base_ptr, "base_ptr"))
             .into_pointer_value();
-        let bounds = self
-            .cache_builder
-            .build_load(intrinsics.isize_ty, ptr_to_bounds, "bounds")
-            .into_int_value();
+        let bounds =
+            err!(builder.build_load(intrinsics.isize_ty, ptr_to_bounds, "bounds")).into_int_value();
         tbaa_label(
             module,
             intrinsics,
@@ -1568,7 +1555,7 @@ impl<'ctx, 'a> CtxType<'ctx, 'a> {
             format!("table_bounds {}", index.index()),
             bounds.as_instruction_value().unwrap(),
         );
-        (base_ptr, bounds)
+        Ok((base_ptr, bounds))
     }
 
     pub fn dynamic_sigindex(
@@ -1576,40 +1563,48 @@ impl<'ctx, 'a> CtxType<'ctx, 'a> {
         index: SignatureIndex,
         intrinsics: &Intrinsics<'ctx>,
         module: &Module<'ctx>,
-    ) -> IntValue<'ctx> {
+    ) -> Result<IntValue<'ctx>, CompileError> {
         let (cached_sigindices, ctx_ptr_value, cache_builder, offsets) = (
             &mut self.cached_sigindices,
             self.ctx_ptr_value,
             &self.cache_builder,
             &self.offsets,
         );
-        *cached_sigindices.entry(index).or_insert_with(|| {
-            let byte_offset = intrinsics
-                .i64_ty
-                .const_int(offsets.vmctx_vmshared_signature_id(index).into(), false);
-            let sigindex_ptr = unsafe {
-                cache_builder.build_gep(
-                    intrinsics.i8_ty,
-                    ctx_ptr_value,
-                    &[byte_offset],
-                    "dynamic_sigindex",
-                )
-            };
-            let sigindex_ptr = cache_builder
-                .build_bitcast(sigindex_ptr, intrinsics.i32_ptr_ty, "")
-                .into_pointer_value();
 
-            let sigindex = cache_builder
-                .build_load(intrinsics.i32_ty, sigindex_ptr, "sigindex")
-                .into_int_value();
-            tbaa_label(
-                module,
-                intrinsics,
-                format!("sigindex {}", index.as_u32()),
-                sigindex.as_instruction_value().unwrap(),
-            );
-            sigindex
-        })
+        match cached_sigindices.entry(index) {
+            Entry::Occupied(entry) => Ok(*entry.get()),
+            Entry::Vacant(entry) => {
+                let byte_offset = intrinsics
+                    .i64_ty
+                    .const_int(offsets.vmctx_vmshared_signature_id(index).into(), false);
+
+                let sigindex_ptr = unsafe {
+                    err!(cache_builder.build_gep(
+                        intrinsics.i8_ty,
+                        ctx_ptr_value,
+                        &[byte_offset],
+                        "dynamic_sigindex",
+                    ))
+                };
+
+                let sigindex_ptr =
+                    err!(cache_builder.build_bit_cast(sigindex_ptr, intrinsics.ptr_ty, ""))
+                        .into_pointer_value();
+
+                let sigindex =
+                    err!(cache_builder.build_load(intrinsics.i32_ty, sigindex_ptr, "sigindex"))
+                        .into_int_value();
+                tbaa_label(
+                    module,
+                    intrinsics,
+                    format!("sigindex {}", index.as_u32()),
+                    sigindex.as_instruction_value().unwrap(),
+                );
+
+                entry.insert(sigindex);
+                Ok(sigindex)
+            }
+        }
     }
 
     pub fn global(
@@ -1625,8 +1620,8 @@ impl<'ctx, 'a> CtxType<'ctx, 'a> {
             &self.cache_builder,
             &self.offsets,
         );
-        Ok(match cached_globals.entry(index) {
-            Entry::Occupied(entry) => entry.into_mut(),
+        match cached_globals.entry(index) {
+            Entry::Occupied(entry) => Ok(entry.into_mut()),
             Entry::Vacant(entry) => {
                 let global_type = wasm_module.globals[index];
                 let global_value_type = global_type.ty;
@@ -1641,18 +1636,19 @@ impl<'ctx, 'a> CtxType<'ctx, 'a> {
                 let offset = intrinsics.i32_ty.const_int(offset.into(), false);
                 let global_ptr = {
                     let global_ptr_ptr = unsafe {
-                        cache_builder.build_gep(intrinsics.i8_ty, ctx_ptr_value, &[offset], "")
+                        err!(cache_builder.build_gep(
+                            intrinsics.i8_ty,
+                            ctx_ptr_value,
+                            &[offset],
+                            ""
+                        ))
                     };
-                    let global_ptr_ptr = cache_builder
-                        .build_bitcast(
-                            global_ptr_ptr,
-                            intrinsics.i32_ptr_ty.ptr_type(AddressSpace::default()),
-                            "",
-                        )
-                        .into_pointer_value();
-                    let global_ptr = cache_builder
-                        .build_load(intrinsics.i32_ptr_ty, global_ptr_ptr, "")
-                        .into_pointer_value();
+                    let global_ptr_ptr =
+                        err!(cache_builder.build_bit_cast(global_ptr_ptr, intrinsics.ptr_ty, ""))
+                            .into_pointer_value();
+                    let global_ptr =
+                        err!(cache_builder.build_load(intrinsics.ptr_ty, global_ptr_ptr, ""))
+                            .into_pointer_value();
                     tbaa_label(
                         module,
                         intrinsics,
@@ -1661,21 +1657,20 @@ impl<'ctx, 'a> CtxType<'ctx, 'a> {
                     );
                     global_ptr
                 };
-                let global_ptr = cache_builder
-                    .build_bitcast(
-                        global_ptr,
-                        type_to_llvm_ptr(intrinsics, global_value_type)?,
-                        "",
-                    )
-                    .into_pointer_value();
+                let global_ptr = err!(cache_builder.build_bit_cast(
+                    global_ptr,
+                    type_to_llvm_ptr(intrinsics, global_value_type)?,
+                    "",
+                ))
+                .into_pointer_value();
 
-                entry.insert(match global_mutability {
+                let ret = entry.insert(match global_mutability {
                     Mutability::Const => {
-                        let value = cache_builder.build_load(
+                        let value = err!(cache_builder.build_load(
                             type_to_llvm(intrinsics, global_value_type)?,
                             global_ptr,
                             "",
-                        );
+                        ));
                         tbaa_label(
                             module,
                             intrinsics,
@@ -1688,9 +1683,11 @@ impl<'ctx, 'a> CtxType<'ctx, 'a> {
                         ptr_to_value: global_ptr,
                         value_type: type_to_llvm(intrinsics, global_value_type)?,
                     },
-                })
+                });
+
+                Ok(ret)
             }
-        })
+        }
     }
 
     pub fn add_func(
@@ -1734,9 +1731,17 @@ impl<'ctx, 'a> CtxType<'ctx, 'a> {
             Entry::Occupied(entry) => entry.into_mut(),
             Entry::Vacant(entry) => {
                 debug_assert!(module.get_function(function_name).is_none());
-                let (llvm_func_type, llvm_func_attrs) =
-                    self.abi
-                        .func_type_to_llvm(context, intrinsics, Some(offsets), func_type)?;
+                let (llvm_func_type, llvm_func_attrs) = self.abi.func_type_to_llvm(
+                    context,
+                    intrinsics,
+                    Some(offsets),
+                    func_type,
+                    if self.config.enable_g0m0_opt {
+                        Some(crate::abi::G0M0FunctionKind::Local)
+                    } else {
+                        None
+                    },
+                )?;
                 let func =
                     module.add_function(function_name, llvm_func_type, Some(Linkage::External));
                 for (attr, attr_loc) in &llvm_func_attrs {
@@ -1766,273 +1771,284 @@ impl<'ctx, 'a> CtxType<'ctx, 'a> {
             &self.cache_builder,
             &self.offsets,
         );
-        Ok(match cached_functions.entry(function_index) {
-            Entry::Occupied(entry) => entry.into_mut(),
+        match cached_functions.entry(function_index) {
+            Entry::Occupied(entry) => Ok(entry.into_mut()),
             Entry::Vacant(entry) => {
-                let (llvm_func_type, llvm_func_attrs) =
-                    self.abi
-                        .func_type_to_llvm(context, intrinsics, Some(offsets), func_type)?;
+                let (llvm_func_type, llvm_func_attrs) = self.abi.func_type_to_llvm(
+                    context,
+                    intrinsics,
+                    Some(offsets),
+                    func_type,
+                    None,
+                )?;
                 debug_assert!(wasm_module.local_func_index(function_index).is_none());
                 let offset = offsets.vmctx_vmfunction_import(function_index);
                 let offset = intrinsics.i32_ty.const_int(offset.into(), false);
                 let vmfunction_import_ptr = unsafe {
-                    cache_builder.build_gep(intrinsics.i8_ty, *ctx_ptr_value, &[offset], "")
+                    err!(cache_builder.build_gep(intrinsics.i8_ty, *ctx_ptr_value, &[offset], ""))
                 };
-                let vmfunction_import_ptr = cache_builder
-                    .build_bitcast(
-                        vmfunction_import_ptr,
-                        intrinsics.vmfunction_import_ptr_ty,
-                        "",
-                    )
-                    .into_pointer_value();
+                let vmfunction_import_ptr = err!(cache_builder.build_bit_cast(
+                    vmfunction_import_ptr,
+                    intrinsics.ptr_ty,
+                    "",
+                ))
+                .into_pointer_value();
 
-                let body_ptr_ptr = cache_builder
-                    .build_struct_gep(
-                        intrinsics.vmfunction_import_ty,
-                        vmfunction_import_ptr,
-                        intrinsics.vmfunction_import_body_element,
-                        "",
-                    )
-                    .unwrap();
-                let body_ptr = cache_builder.build_load(intrinsics.i8_ptr_ty, body_ptr_ptr, "");
-                let body_ptr = cache_builder
-                    .build_bitcast(
-                        body_ptr,
-                        llvm_func_type.ptr_type(AddressSpace::default()),
-                        "",
-                    )
+                let body_ptr_ptr = err!(cache_builder.build_struct_gep(
+                    intrinsics.vmfunction_import_ty,
+                    vmfunction_import_ptr,
+                    intrinsics.vmfunction_import_body_element,
+                    "",
+                ));
+                let body_ptr = err!(cache_builder.build_load(intrinsics.ptr_ty, body_ptr_ptr, ""));
+                let body_ptr = err!(cache_builder.build_bit_cast(body_ptr, intrinsics.ptr_ty, ""))
                     .into_pointer_value();
-                let vmctx_ptr_ptr = cache_builder
-                    .build_struct_gep(
-                        intrinsics.vmfunction_import_ty,
-                        vmfunction_import_ptr,
-                        intrinsics.vmfunction_import_vmctx_element,
-                        "",
-                    )
-                    .unwrap();
-                let vmctx_ptr = cache_builder.build_load(intrinsics.ctx_ptr_ty, vmctx_ptr_ptr, "");
-                entry.insert(FunctionCache {
+                let vmctx_ptr_ptr = err!(cache_builder.build_struct_gep(
+                    intrinsics.vmfunction_import_ty,
+                    vmfunction_import_ptr,
+                    intrinsics.vmfunction_import_vmctx_element,
+                    "",
+                ));
+                let vmctx_ptr =
+                    err!(cache_builder.build_load(intrinsics.ptr_ty, vmctx_ptr_ptr, ""));
+
+                Ok(entry.insert(FunctionCache {
                     func: body_ptr,
                     llvm_func_type,
                     vmctx: vmctx_ptr,
                     attrs: llvm_func_attrs,
-                })
+                }))
             }
-        })
+        }
     }
 
     pub fn memory_grow(
         &mut self,
         memory_index: MemoryIndex,
         intrinsics: &Intrinsics<'ctx>,
-    ) -> PointerValue<'ctx> {
-        let (cached_memory_grow, wasm_module, offsets, cache_builder, ctx_ptr_value) = (
-            &mut self.cached_memory_grow,
+    ) -> Result<PointerValue<'ctx>, CompileError> {
+        let (cached_memory_op, wasm_module, offsets, cache_builder, ctx_ptr_value) = (
+            &mut self.cached_memory_op,
             &self.wasm_module,
             &self.offsets,
             &self.cache_builder,
             &self.ctx_ptr_value,
         );
-        *cached_memory_grow.entry(memory_index).or_insert_with(|| {
-            let (grow_fn, grow_fn_ty) = if wasm_module.local_memory_index(memory_index).is_some() {
-                (
-                    VMBuiltinFunctionIndex::get_memory32_grow_index(),
-                    intrinsics.memory32_grow_ptr_ty,
-                )
-            } else {
-                (
-                    VMBuiltinFunctionIndex::get_imported_memory32_grow_index(),
-                    intrinsics.imported_memory32_grow_ptr_ty,
-                )
-            };
-            let offset = offsets.vmctx_builtin_function(grow_fn);
-            let offset = intrinsics.i32_ty.const_int(offset.into(), false);
-            let grow_fn_ptr_ptr =
-                unsafe { cache_builder.build_gep(intrinsics.i8_ty, *ctx_ptr_value, &[offset], "") };
-
-            let grow_fn_ptr_ptr = cache_builder
-                .build_bitcast(
-                    grow_fn_ptr_ptr,
-                    grow_fn_ty.ptr_type(AddressSpace::default()),
-                    "",
-                )
-                .into_pointer_value();
-            cache_builder
-                .build_load(grow_fn_ty, grow_fn_ptr_ptr, "")
-                .into_pointer_value()
-        })
+        match cached_memory_op.entry((memory_index, MemoryOp::Grow)) {
+            Entry::Occupied(entry) => Ok(*entry.get()),
+            Entry::Vacant(entry) => {
+                let (grow_fn, grow_fn_ty) =
+                    if wasm_module.local_memory_index(memory_index).is_some() {
+                        (
+                            VMBuiltinFunctionIndex::get_memory32_grow_index(),
+                            intrinsics.ptr_ty,
+                        )
+                    } else {
+                        (
+                            VMBuiltinFunctionIndex::get_imported_memory32_grow_index(),
+                            intrinsics.ptr_ty,
+                        )
+                    };
+                let offset = offsets.vmctx_builtin_function(grow_fn);
+                let offset = intrinsics.i32_ty.const_int(offset.into(), false);
+                let grow_fn_ptr_ptr = unsafe {
+                    err!(cache_builder.build_gep(intrinsics.i8_ty, *ctx_ptr_value, &[offset], ""))
+                };
+
+                let grow_fn_ptr_ptr =
+                    err!(cache_builder.build_bit_cast(grow_fn_ptr_ptr, intrinsics.ptr_ty, ""))
+                        .into_pointer_value();
+                let val = err!(cache_builder.build_load(grow_fn_ty, grow_fn_ptr_ptr, ""))
+                    .into_pointer_value();
+
+                entry.insert(val);
+                Ok(val)
+            }
+        }
     }
 
     pub fn memory_size(
         &mut self,
         memory_index: MemoryIndex,
         intrinsics: &Intrinsics<'ctx>,
-    ) -> PointerValue<'ctx> {
-        let (cached_memory_size, wasm_module, offsets, cache_builder, ctx_ptr_value) = (
-            &mut self.cached_memory_size,
+    ) -> Result<PointerValue<'ctx>, CompileError> {
+        let (cached_memory_op, wasm_module, offsets, cache_builder, ctx_ptr_value) = (
+            &mut self.cached_memory_op,
             &self.wasm_module,
             &self.offsets,
             &self.cache_builder,
             &self.ctx_ptr_value,
         );
-        *cached_memory_size.entry(memory_index).or_insert_with(|| {
-            let (size_fn, size_fn_ty) = if wasm_module.local_memory_index(memory_index).is_some() {
-                (
-                    VMBuiltinFunctionIndex::get_memory32_size_index(),
-                    intrinsics.memory32_size_ptr_ty,
-                )
-            } else {
-                (
-                    VMBuiltinFunctionIndex::get_imported_memory32_size_index(),
-                    intrinsics.imported_memory32_size_ptr_ty,
-                )
-            };
-            let offset = offsets.vmctx_builtin_function(size_fn);
-            let offset = intrinsics.i32_ty.const_int(offset.into(), false);
-            let size_fn_ptr_ptr =
-                unsafe { cache_builder.build_gep(intrinsics.i8_ty, *ctx_ptr_value, &[offset], "") };
-
-            let size_fn_ptr_ptr = cache_builder
-                .build_bitcast(
-                    size_fn_ptr_ptr,
-                    size_fn_ty.ptr_type(AddressSpace::default()),
-                    "",
-                )
-                .into_pointer_value();
 
-            cache_builder
-                .build_load(size_fn_ty, size_fn_ptr_ptr, "")
-                .into_pointer_value()
-        })
+        match cached_memory_op.entry((memory_index, MemoryOp::Size)) {
+            Entry::Occupied(entry) => Ok(*entry.get()),
+            Entry::Vacant(entry) => {
+                let (size_fn, size_fn_ty) =
+                    if wasm_module.local_memory_index(memory_index).is_some() {
+                        (
+                            VMBuiltinFunctionIndex::get_memory32_size_index(),
+                            intrinsics.ptr_ty,
+                        )
+                    } else {
+                        (
+                            VMBuiltinFunctionIndex::get_imported_memory32_size_index(),
+                            intrinsics.ptr_ty,
+                        )
+                    };
+                let offset = offsets.vmctx_builtin_function(size_fn);
+                let offset = intrinsics.i32_ty.const_int(offset.into(), false);
+                let size_fn_ptr_ptr = unsafe {
+                    err!(cache_builder.build_gep(intrinsics.i8_ty, *ctx_ptr_value, &[offset], ""))
+                };
+
+                let size_fn_ptr_ptr =
+                    err!(cache_builder.build_bit_cast(size_fn_ptr_ptr, intrinsics.ptr_ty, ""))
+                        .into_pointer_value();
+
+                let val = err!(cache_builder.build_load(size_fn_ty, size_fn_ptr_ptr, ""))
+                    .into_pointer_value();
+                entry.insert(val);
+                Ok(val)
+            }
+        }
     }
 
     pub fn memory_wait32(
         &mut self,
         memory_index: MemoryIndex,
         intrinsics: &Intrinsics<'ctx>,
-    ) -> PointerValue<'ctx> {
-        let (cached_memory_size, wasm_module, offsets, cache_builder, ctx_ptr_value) = (
-            &mut self.cached_memory_size,
+    ) -> Result<PointerValue<'ctx>, CompileError> {
+        let (cached_memory_op, wasm_module, offsets, cache_builder, ctx_ptr_value) = (
+            &mut self.cached_memory_op,
             &self.wasm_module,
             &self.offsets,
             &self.cache_builder,
             &self.ctx_ptr_value,
         );
-        *cached_memory_size.entry(memory_index).or_insert_with(|| {
-            let (size_fn, size_fn_ty) = if wasm_module.local_memory_index(memory_index).is_some() {
-                (
-                    VMBuiltinFunctionIndex::get_memory_atomic_wait32_index(),
-                    intrinsics.memory32_wait32_ptr_ty,
-                )
-            } else {
-                (
-                    VMBuiltinFunctionIndex::get_imported_memory_atomic_wait32_index(),
-                    intrinsics.imported_memory32_wait32_ptr_ty,
-                )
-            };
-            let offset = offsets.vmctx_builtin_function(size_fn);
-            let offset = intrinsics.i32_ty.const_int(offset.into(), false);
-            let size_fn_ptr_ptr =
-                unsafe { cache_builder.build_gep(intrinsics.i8_ty, *ctx_ptr_value, &[offset], "") };
-
-            let size_fn_ptr_ptr = cache_builder
-                .build_bitcast(
-                    size_fn_ptr_ptr,
-                    size_fn_ty.ptr_type(AddressSpace::default()),
-                    "",
-                )
-                .into_pointer_value();
+        match cached_memory_op.entry((memory_index, MemoryOp::Wait32)) {
+            Entry::Occupied(entry) => Ok(*entry.get()),
+            Entry::Vacant(entry) => {
+                let (size_fn, size_fn_ty) =
+                    if wasm_module.local_memory_index(memory_index).is_some() {
+                        (
+                            VMBuiltinFunctionIndex::get_memory_atomic_wait32_index(),
+                            intrinsics.ptr_ty,
+                        )
+                    } else {
+                        (
+                            VMBuiltinFunctionIndex::get_imported_memory_atomic_wait32_index(),
+                            intrinsics.ptr_ty,
+                        )
+                    };
+                let offset = offsets.vmctx_builtin_function(size_fn);
+                let offset = intrinsics.i32_ty.const_int(offset.into(), false);
+                let size_fn_ptr_ptr = unsafe {
+                    err!(cache_builder.build_gep(intrinsics.i8_ty, *ctx_ptr_value, &[offset], ""))
+                };
 
-            cache_builder
-                .build_load(size_fn_ty, size_fn_ptr_ptr, "")
-                .into_pointer_value()
-        })
+                let size_fn_ptr_ptr =
+                    err!(cache_builder.build_bit_cast(size_fn_ptr_ptr, intrinsics.ptr_ty, ""))
+                        .into_pointer_value();
+
+                let val = err!(cache_builder.build_load(size_fn_ty, size_fn_ptr_ptr, ""))
+                    .into_pointer_value();
+
+                entry.insert(val);
+                Ok(val)
+            }
+        }
     }
 
     pub fn memory_wait64(
         &mut self,
         memory_index: MemoryIndex,
         intrinsics: &Intrinsics<'ctx>,
-    ) -> PointerValue<'ctx> {
-        let (cached_memory_size, wasm_module, offsets, cache_builder, ctx_ptr_value) = (
-            &mut self.cached_memory_size,
+    ) -> Result<PointerValue<'ctx>, CompileError> {
+        let (cached_memory_op, wasm_module, offsets, cache_builder, ctx_ptr_value) = (
+            &mut self.cached_memory_op,
             &self.wasm_module,
             &self.offsets,
             &self.cache_builder,
             &self.ctx_ptr_value,
         );
-        *cached_memory_size.entry(memory_index).or_insert_with(|| {
-            let (size_fn, size_fn_ty) = if wasm_module.local_memory_index(memory_index).is_some() {
-                (
-                    VMBuiltinFunctionIndex::get_memory_atomic_wait64_index(),
-                    intrinsics.memory32_wait64_ptr_ty,
-                )
-            } else {
-                (
-                    VMBuiltinFunctionIndex::get_imported_memory_atomic_wait64_index(),
-                    intrinsics.imported_memory32_wait64_ptr_ty,
-                )
-            };
-            let offset = offsets.vmctx_builtin_function(size_fn);
-            let offset = intrinsics.i32_ty.const_int(offset.into(), false);
-            let size_fn_ptr_ptr =
-                unsafe { cache_builder.build_gep(intrinsics.i8_ty, *ctx_ptr_value, &[offset], "") };
-
-            let size_fn_ptr_ptr = cache_builder
-                .build_bitcast(
-                    size_fn_ptr_ptr,
-                    size_fn_ty.ptr_type(AddressSpace::default()),
-                    "",
-                )
-                .into_pointer_value();
 
-            cache_builder
-                .build_load(size_fn_ty, size_fn_ptr_ptr, "")
-                .into_pointer_value()
-        })
+        match cached_memory_op.entry((memory_index, MemoryOp::Wait64)) {
+            Entry::Occupied(entry) => Ok(*entry.get()),
+            Entry::Vacant(entry) => {
+                let (size_fn, size_fn_ty) =
+                    if wasm_module.local_memory_index(memory_index).is_some() {
+                        (
+                            VMBuiltinFunctionIndex::get_memory_atomic_wait64_index(),
+                            intrinsics.ptr_ty,
+                        )
+                    } else {
+                        (
+                            VMBuiltinFunctionIndex::get_imported_memory_atomic_wait64_index(),
+                            intrinsics.ptr_ty,
+                        )
+                    };
+                let offset = offsets.vmctx_builtin_function(size_fn);
+                let offset = intrinsics.i32_ty.const_int(offset.into(), false);
+                let size_fn_ptr_ptr = unsafe {
+                    err!(cache_builder.build_gep(intrinsics.i8_ty, *ctx_ptr_value, &[offset], ""))
+                };
+
+                let size_fn_ptr_ptr =
+                    err!(cache_builder.build_bit_cast(size_fn_ptr_ptr, intrinsics.ptr_ty, ""))
+                        .into_pointer_value();
+
+                let val = err!(cache_builder.build_load(size_fn_ty, size_fn_ptr_ptr, ""))
+                    .into_pointer_value();
+                entry.insert(val);
+                Ok(val)
+            }
+        }
     }
 
     pub fn memory_notify(
         &mut self,
         memory_index: MemoryIndex,
         intrinsics: &Intrinsics<'ctx>,
-    ) -> PointerValue<'ctx> {
-        let (cached_memory_size, wasm_module, offsets, cache_builder, ctx_ptr_value) = (
-            &mut self.cached_memory_size,
+    ) -> Result<PointerValue<'ctx>, CompileError> {
+        let (cached_memory_op, wasm_module, offsets, cache_builder, ctx_ptr_value) = (
+            &mut self.cached_memory_op,
             &self.wasm_module,
             &self.offsets,
             &self.cache_builder,
             &self.ctx_ptr_value,
         );
-        *cached_memory_size.entry(memory_index).or_insert_with(|| {
-            let (size_fn, size_fn_ty) = if wasm_module.local_memory_index(memory_index).is_some() {
-                (
-                    VMBuiltinFunctionIndex::get_memory_atomic_notify_index(),
-                    intrinsics.memory32_notify_ptr_ty,
-                )
-            } else {
-                (
-                    VMBuiltinFunctionIndex::get_imported_memory_atomic_notify_index(),
-                    intrinsics.imported_memory32_notify_ptr_ty,
-                )
-            };
-            let offset = offsets.vmctx_builtin_function(size_fn);
-            let offset = intrinsics.i32_ty.const_int(offset.into(), false);
-            let size_fn_ptr_ptr =
-                unsafe { cache_builder.build_gep(intrinsics.i8_ty, *ctx_ptr_value, &[offset], "") };
-
-            let size_fn_ptr_ptr = cache_builder
-                .build_bitcast(
-                    size_fn_ptr_ptr,
-                    size_fn_ty.ptr_type(AddressSpace::default()),
-                    "",
-                )
-                .into_pointer_value();
+        match cached_memory_op.entry((memory_index, MemoryOp::Notify)) {
+            Entry::Occupied(entry) => Ok(*entry.get()),
+            Entry::Vacant(entry) => {
+                let (size_fn, size_fn_ty) =
+                    if wasm_module.local_memory_index(memory_index).is_some() {
+                        (
+                            VMBuiltinFunctionIndex::get_memory_atomic_notify_index(),
+                            intrinsics.ptr_ty,
+                        )
+                    } else {
+                        (
+                            VMBuiltinFunctionIndex::get_imported_memory_atomic_notify_index(),
+                            intrinsics.ptr_ty,
+                        )
+                    };
+                let offset = offsets.vmctx_builtin_function(size_fn);
+                let offset = intrinsics.i32_ty.const_int(offset.into(), false);
+                let size_fn_ptr_ptr = unsafe {
+                    err!(cache_builder.build_gep(intrinsics.i8_ty, *ctx_ptr_value, &[offset], ""))
+                };
 
-            cache_builder
-                .build_load(size_fn_ty, size_fn_ptr_ptr, "")
-                .into_pointer_value()
-        })
+                let size_fn_ptr_ptr =
+                    err!(cache_builder.build_bit_cast(size_fn_ptr_ptr, intrinsics.ptr_ty, ""))
+                        .into_pointer_value();
+
+                let val = err!(cache_builder.build_load(size_fn_ty, size_fn_ptr_ptr, ""))
+                    .into_pointer_value();
+
+                entry.insert(val);
+                Ok(val)
+            }
+        }
     }
 
     pub fn get_offsets(&self) -> &VMOffsets {
@@ -2118,3 +2134,11 @@ pub fn tbaa_label<'ctx>(
     let tbaa_kind = context.get_kind_id("tbaa");
     instruction.set_metadata(type_tbaa, tbaa_kind).unwrap();
 }
+
+fn is_table_growable(module: &WasmerCompilerModule, index: TableIndex) -> Option<bool> {
+    let table = module.tables.get(index)?;
+    match table.maximum {
+        None => Some(true),
+        Some(max) => Some(max > table.minimum),
+    }
+}
diff --git a/lib/compiler-llvm/src/translator/state.rs b/lib/compiler-llvm/src/translator/state.rs
index 339d325e71..be9188fc54 100644
--- a/lib/compiler-llvm/src/translator/state.rs
+++ b/lib/compiler-llvm/src/translator/state.rs
@@ -3,10 +3,14 @@ use inkwell::{
     values::{BasicValue, BasicValueEnum, PhiValue},
 };
 use smallvec::SmallVec;
-use std::ops::{BitAnd, BitOr, BitOrAssign};
+use std::{
+    collections::VecDeque,
+    ops::{BitAnd, BitOr, BitOrAssign},
+};
 use wasmer_types::CompileError;
 
 #[derive(Debug)]
+#[allow(dead_code)]
 pub enum ControlFrame<'ctx> {
     Block {
         next: BasicBlock<'ctx>,
@@ -30,6 +34,11 @@ pub enum ControlFrame<'ctx> {
         stack_size_snapshot: usize,
         if_else_state: IfElseState,
     },
+    Landingpad {
+        next: BasicBlock<'ctx>,
+        next_phis: SmallVec<[PhiValue<'ctx>; 1]>,
+        stack_size_snapshot: usize,
+    },
 }
 
 #[derive(Debug)]
@@ -43,13 +52,16 @@ impl<'ctx> ControlFrame<'ctx> {
         match self {
             ControlFrame::Block { ref next, .. }
             | ControlFrame::Loop { ref next, .. }
+            | ControlFrame::Landingpad { ref next, .. }
             | ControlFrame::IfElse { ref next, .. } => next,
         }
     }
 
     pub fn br_dest(&self) -> &BasicBlock<'ctx> {
         match self {
-            ControlFrame::Block { ref next, .. } | ControlFrame::IfElse { ref next, .. } => next,
+            ControlFrame::Block { ref next, .. }
+            | ControlFrame::IfElse { ref next, .. }
+            | ControlFrame::Landingpad { ref next, .. } => next,
             ControlFrame::Loop { ref body, .. } => body,
         }
     }
@@ -59,17 +71,18 @@ impl<'ctx> ControlFrame<'ctx> {
             ControlFrame::Block { ref phis, .. } | ControlFrame::Loop { ref phis, .. } => {
                 phis.as_slice()
             }
-            ControlFrame::IfElse { ref next_phis, .. } => next_phis.as_slice(),
+            ControlFrame::IfElse { ref next_phis, .. }
+            | ControlFrame::Landingpad { ref next_phis, .. } => next_phis.as_slice(),
         }
     }
 
     /// PHI nodes for stack values in the loop body.
     pub fn loop_body_phis(&self) -> &[PhiValue<'ctx>] {
         match self {
-            ControlFrame::Block { .. } | ControlFrame::IfElse { .. } => &[],
             ControlFrame::Loop {
                 ref loop_body_phis, ..
             } => loop_body_phis.as_slice(),
+            _ => &[],
         }
     }
 
@@ -140,12 +153,16 @@ impl ExtraInfo {
 
 // Union two ExtraInfos.
 impl BitOr for ExtraInfo {
-    type Output = Self;
+    type Output = Result<Self, CompileError>;
 
-    fn bitor(self, other: Self) -> Self {
-        debug_assert!(!(self.has_pending_f32_nan() && other.has_pending_f64_nan()));
-        debug_assert!(!(self.has_pending_f64_nan() && other.has_pending_f32_nan()));
-        ExtraInfo {
+    fn bitor(self, other: Self) -> Self::Output {
+        if (self.has_pending_f32_nan() && other.has_pending_f64_nan())
+            || (self.has_pending_f64_nan() && other.has_pending_f32_nan())
+        {
+            return Err(CompileError::Codegen("Can't produce bitwise or of two different states if there are two different kinds of nan canonicalizations at the same time".to_string()));
+        }
+
+        Ok(ExtraInfo {
             state: if self.is_arithmetic_f32() || other.is_arithmetic_f32() {
                 ExtraInfo::arithmetic_f32().state
             } else if self.has_pending_f32_nan() || other.has_pending_f32_nan() {
@@ -159,19 +176,19 @@ impl BitOr for ExtraInfo {
             } else {
                 0
             },
-        }
+        })
     }
 }
 impl BitOrAssign for ExtraInfo {
     fn bitor_assign(&mut self, other: Self) {
-        *self = *self | other;
+        *self = (*self | other).unwrap();
     }
 }
 
 // Intersection for ExtraInfo.
 impl BitAnd for ExtraInfo {
-    type Output = Self;
-    fn bitand(self, other: Self) -> Self {
+    type Output = Result<Self, CompileError>;
+    fn bitand(self, other: Self) -> Self::Output {
         // Pending canonicalizations are not safe to discard, or even reorder.
         debug_assert!(
             self.has_pending_f32_nan() == other.has_pending_f32_nan()
@@ -190,10 +207,10 @@ impl BitAnd for ExtraInfo {
             (false, false) => Default::default(),
             (true, false) => ExtraInfo::arithmetic_f32(),
             (false, true) => ExtraInfo::arithmetic_f64(),
-            (true, true) => ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+            (true, true) => (ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64())?,
         };
         match (self.has_pending_f32_nan(), self.has_pending_f64_nan()) {
-            (false, false) => info,
+            (false, false) => Ok(info),
             (true, false) => info | ExtraInfo::pending_f32_nan(),
             (false, true) => info | ExtraInfo::pending_f64_nan(),
             (true, true) => unreachable!("Can't form ExtraInfo with two pending canonicalizations"),
@@ -201,11 +218,33 @@ impl BitAnd for ExtraInfo {
     }
 }
 
+#[derive(Debug, Clone, Copy)]
+pub struct TagCatchInfo<'ctx> {
+    pub tag: u32,
+    // The catch block
+    pub catch_block: BasicBlock<'ctx>,
+    // The PHI node to receive the exception object
+    pub wasmer_exc_phi: Option<PhiValue<'ctx>>,
+    // The PHI node to receive the libunwind exception pointer,
+    // which stands in as the exnref for now
+    pub uw_exc_ptr_phi: Option<PhiValue<'ctx>>,
+}
+
+#[derive(Debug)]
+pub struct Landingpad<'ctx> {
+    // The block that has the landingpad instruction.
+    // Will be None for catch-less try_table instructions
+    // with no outer landingpads.
+    pub lpad_block: Option<BasicBlock<'ctx>>,
+    // The tags that this landingpad can catch
+    pub tags: Vec<TagCatchInfo<'ctx>>,
+}
+
 #[derive(Debug)]
 pub struct State<'ctx> {
     pub stack: Vec<(BasicValueEnum<'ctx>, ExtraInfo)>,
-    control_stack: Vec<ControlFrame<'ctx>>,
-
+    pub control_stack: Vec<ControlFrame<'ctx>>,
+    pub landingpads: VecDeque<Landingpad<'ctx>>,
     pub reachable: bool,
 }
 
@@ -215,6 +254,7 @@ impl<'ctx> State<'ctx> {
             stack: vec![],
             control_stack: vec![],
             reachable: true,
+            landingpads: VecDeque::new(),
         }
     }
 
@@ -235,13 +275,17 @@ impl<'ctx> State<'ctx> {
             | ControlFrame::IfElse {
                 stack_size_snapshot,
                 ..
+            }
+            | ControlFrame::Landingpad {
+                stack_size_snapshot,
+                ..
             } => *stack_size_snapshot,
         };
         self.stack.truncate(stack_size_snapshot);
     }
 
     pub fn outermost_frame(&self) -> Result<&ControlFrame<'ctx>, CompileError> {
-        self.control_stack.get(0).ok_or_else(|| {
+        self.control_stack.first().ok_or_else(|| {
             CompileError::Codegen("outermost_frame: invalid control stack depth".to_string())
         })
     }
@@ -392,11 +436,20 @@ impl<'ctx> State<'ctx> {
         Ok(())
     }
 
-    pub fn push_block(&mut self, next: BasicBlock<'ctx>, phis: SmallVec<[PhiValue<'ctx>; 1]>) {
+    pub fn push_block(
+        &mut self,
+        next: BasicBlock<'ctx>,
+        phis: SmallVec<[PhiValue<'ctx>; 1]>,
+        num_inputs: usize,
+    ) {
         self.control_stack.push(ControlFrame::Block {
             next,
             phis,
-            stack_size_snapshot: self.stack.len(),
+            stack_size_snapshot: self
+                .stack
+                .len()
+                .checked_sub(num_inputs)
+                .expect("Internal codegen error: not enough inputs on stack"),
         });
     }
 
@@ -406,16 +459,22 @@ impl<'ctx> State<'ctx> {
         next: BasicBlock<'ctx>,
         loop_body_phis: SmallVec<[PhiValue<'ctx>; 1]>,
         phis: SmallVec<[PhiValue<'ctx>; 1]>,
+        num_inputs: usize,
     ) {
         self.control_stack.push(ControlFrame::Loop {
             body,
             next,
             loop_body_phis,
             phis,
-            stack_size_snapshot: self.stack.len(),
+            stack_size_snapshot: self
+                .stack
+                .len()
+                .checked_sub(num_inputs)
+                .expect("Internal codegen error: not enough inputs on stack"),
         });
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn push_if(
         &mut self,
         if_then: BasicBlock<'ctx>,
@@ -424,6 +483,7 @@ impl<'ctx> State<'ctx> {
         then_phis: SmallVec<[PhiValue<'ctx>; 1]>,
         else_phis: SmallVec<[PhiValue<'ctx>; 1]>,
         next_phis: SmallVec<[PhiValue<'ctx>; 1]>,
+        num_inputs: usize,
     ) {
         self.control_stack.push(ControlFrame::IfElse {
             if_then,
@@ -432,8 +492,53 @@ impl<'ctx> State<'ctx> {
             then_phis,
             else_phis,
             next_phis,
-            stack_size_snapshot: self.stack.len(),
             if_else_state: IfElseState::If,
+            stack_size_snapshot: self
+                .stack
+                .len()
+                .checked_sub(num_inputs)
+                .expect("Internal codegen error: not enough inputs on stack"),
         });
     }
+
+    pub fn push_landingpad(
+        &mut self,
+        lpad_block: Option<BasicBlock<'ctx>>,
+        next: BasicBlock<'ctx>,
+        next_phis: SmallVec<[PhiValue<'ctx>; 1]>,
+        tags: &[TagCatchInfo<'ctx>],
+        num_inputs: usize,
+    ) {
+        self.control_stack.push(ControlFrame::Landingpad {
+            next,
+            next_phis,
+            stack_size_snapshot: self
+                .stack
+                .len()
+                .checked_sub(num_inputs)
+                .expect("Internal codegen error: not enough inputs on stack"),
+        });
+
+        self.landingpads.push_back(Landingpad {
+            lpad_block,
+            tags: tags.to_vec(),
+        })
+    }
+
+    // Throws and function calls need to be turned into invokes targeting this
+    // landingpad if it exists; otherwise, there is no landingpad within this
+    // frame. Note that the innermost landing pad has catch clauses for *all*
+    // the tags that are active in this frame, including the ones from outer
+    // landingpads, so there's never a reason to target any other landingpad.
+    pub(crate) fn get_innermost_landingpad(&mut self) -> Option<BasicBlock<'ctx>> {
+        self.landingpads
+            .iter()
+            .rev()
+            .filter_map(|v| v.lpad_block)
+            .next()
+    }
+
+    pub(crate) fn pop_landingpad(&mut self) -> bool {
+        self.landingpads.pop_back().is_some()
+    }
 }
diff --git a/lib/compiler-singlepass/Cargo.toml b/lib/compiler-singlepass/Cargo.toml
index c417cdfebb..a0d961288b 100644
--- a/lib/compiler-singlepass/Cargo.toml
+++ b/lib/compiler-singlepass/Cargo.toml
@@ -8,29 +8,28 @@ readme = "README.md"
 authors.workspace = true
 edition.workspace = true
 homepage.workspace = true
-license.workspace = true
+license-file = "LICENSE"
 repository.workspace = true
 rust-version.workspace = true
 version.workspace = true
 
 [dependencies]
-wasmer-compiler = { path = "../compiler", version = "=4.3.7", features = ["translator", "compiler"], default-features = false }
-wasmer-types = { path = "../types", version = "=4.3.7", default-features = false, features = ["std"] }
-hashbrown = { version = "0.11", optional = true }
-gimli = { version = "0.26", optional = true }
+wasmer-compiler = { path = "../compiler", version = "=6.1.0", features = ["translator", "compiler"], default-features = false }
+wasmer-types = { path = "../types", version = "=6.1.0", default-features = false, features = ["std"] }
+hashbrown = { workspace = true, optional = true }
+gimli = { workspace = true, optional = true }
 enumset.workspace = true
-more-asserts = "0.2"
-dynasm = "1.2.3"
-dynasmrt = "1.2.3"
-lazy_static = "1.4"
-byteorder = "1.3"
-smallvec = "1.6"
+more-asserts.workspace = true
+dynasm = "4.0.0"
+dynasmrt = "4.0.0"
+byteorder.workspace = true
+smallvec.workspace = true
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-rayon = { version = "1.5", optional = true }
+rayon = { workspace = true, optional = true }
 
 [dev-dependencies]
-target-lexicon = { version = "0.12.2", default-features = false }
+target-lexicon = { workspace = true, default-features = false }
 
 [badges]
 maintenance = { status = "actively-developed" }
@@ -43,6 +42,7 @@ core = ["hashbrown", "wasmer-types/core"]
 unwind = ["gimli"]
 sse = []
 avx = []
+enable-serde = []
 
 [package.metadata.docs.rs]
 rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/compiler-singlepass/LICENSE b/lib/compiler-singlepass/LICENSE
new file mode 100644
index 0000000000..aa292ec0ad
--- /dev/null
+++ b/lib/compiler-singlepass/LICENSE
@@ -0,0 +1,86 @@
+License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved.
+"Business Source License" is a trademark of MariaDB Corporation Ab.
+
+Parameters
+
+Licensor:             Wasmer, Inc.
+Licensed Work:        Wasmer Singlepass Version 6.0.0 or later.  The Licensed Work is
+                      (c) 2025 Wasmer, Inc.
+Additional Use Grant: You may make production use of the Licensed Work provided you are
+                      either a Sponsor under the Wasmer Sponsorhip Program or an entity
+                      within the Sponsorship Network of any current Sponsor designated in
+                      accordance with Wasmer’s criteria.
+                      
+                      For purposes of this Agreement:
+                      A "Sponsor" is an entity actively enrolled in the Wasmer Sponsorship
+                      Program that fulfills all requirements—including the timely payment of
+                      an applicable monthly sponsorship fee determined in a separate,
+                      non-public Sponsorship Agreement with Wasmer—and maintains good
+                      standing with Wasmer.
+
+                      A "Sponsorship Network" means any network of systems or entities
+                      designated by Wasmer under a current Sponsor. The criteria and list of
+                      such elements shall be maintained and updated by Wasmer.
+
+                      "Wasmer Sponsorship Program" means the program established by Wasmer
+                      under which eligible participants, including Sponsor, may obtain access
+                      to and use of the Software, in exchange for the payment of a recurring
+                      Sponsorship Fee.
+
+                      The Additional Use Grant is conditioned on your continued compliance
+                      with the terms of the Wasmer Sponsorship Program, including the timely
+                      payment of the applicable monthly sponsorship fee determined by Wasmer;
+                      if the sponsor fail to meet these conditions or if your Sponsorship or
+                      that of your associated Sponsor is terminated for any reason, the
+                      additional rights granted under this Sponsor Exception shall
+                      immediately revert to the standard limitations of BUSL 1.1.
+Change Date:          Four years from the date the Licensed Work is published
+Change License:       MPL 2.0
+
+For information about alternative licensing arrangements for the Licensed Work,
+please contact licensing@wasmer.io.
+
+Notice
+
+Business Source License 1.1
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under
+the terms of the Change License, and the rights granted in the paragraph
+above terminate.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or authorized
+resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works
+of the Licensed Work, are subject to this License. This License applies
+separately for each version of the Licensed Work and the Change Date may vary
+for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy
+of the Licensed Work. If you receive the Licensed Work in original or
+modified form from a third party, the terms and conditions set forth in this
+License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other
+versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or logo of
+Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+TITLE.
diff --git a/lib/compiler-singlepass/README.md b/lib/compiler-singlepass/README.md
index ac49824fda..48a0d6dde0 100644
--- a/lib/compiler-singlepass/README.md
+++ b/lib/compiler-singlepass/README.md
@@ -1,11 +1,12 @@
-# `wasmer-compiler-singlepass` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE) [![crates.io](https://img.shields.io/crates/v/wasmer-compiler-singlepass.svg)](https://crates.io/crates/wasmer-compiler-singlepass)
+# `wasmer-compiler-singlepass` 
+[![Build Status](https://github.com/wasmerio/wasmer/actions/workflows/build.yml/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE) [![crates.io](https://img.shields.io/crates/v/wasmer-compiler-singlepass.svg)](https://crates.io/crates/wasmer-compiler-singlepass)
 
 This crate contains a compiler implementation based on the Singlepass linear compiler.
 
 ## Usage
 
 ```rust
-use wasmer::{Store, EngineBuilder};
+use wasmer::{Store, sys::EngineBuilder};
 use wasmer_compiler_singlepass::Singlepass;
 
 let compiler = Singlepass::new();
diff --git a/lib/compiler-singlepass/src/address_map.rs b/lib/compiler-singlepass/src/address_map.rs
index cc4eb6cde5..666000f07b 100644
--- a/lib/compiler-singlepass/src/address_map.rs
+++ b/lib/compiler-singlepass/src/address_map.rs
@@ -1,5 +1,6 @@
+use wasmer_compiler::types::address_map::{FunctionAddressMap, InstructionAddressMap};
 use wasmer_compiler::FunctionBodyData;
-use wasmer_types::{FunctionAddressMap, InstructionAddressMap, SourceLoc};
+use wasmer_types::SourceLoc;
 
 pub fn get_function_address_map(
     instructions: Vec<InstructionAddressMap>,
diff --git a/lib/compiler-singlepass/src/arm64_decl.rs b/lib/compiler-singlepass/src/arm64_decl.rs
index b000bdde83..e3deca42b1 100644
--- a/lib/compiler-singlepass/src/arm64_decl.rs
+++ b/lib/compiler-singlepass/src/arm64_decl.rs
@@ -1,11 +1,13 @@
 //! ARM64 structures.
 
-use crate::common_decl::{MachineState, MachineValue, RegisterIndex};
-use crate::location::CombinedRegister;
-use crate::location::Reg as AbstractReg;
+use crate::{
+    common_decl::{MachineState, MachineValue, RegisterIndex},
+    location::{CombinedRegister, Reg as AbstractReg},
+};
 use std::collections::BTreeMap;
 use std::slice::Iter;
-use wasmer_types::{CallingConvention, Type};
+use wasmer_types::target::CallingConvention;
+use wasmer_types::{CompileError, Type};
 
 /// General-purpose registers.
 #[repr(u8)]
@@ -46,6 +48,12 @@ pub enum GPR {
     XzrSp = 31,
 }
 
+impl From<GPR> for u8 {
+    fn from(val: GPR) -> Self {
+        val as u8
+    }
+}
+
 /// NEON registers.
 #[repr(u8)]
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
@@ -86,6 +94,12 @@ pub enum NEON {
     V31 = 31,
 }
 
+impl From<NEON> for u8 {
+    fn from(val: NEON) -> Self {
+        val as u8
+    }
+}
+
 impl AbstractReg for GPR {
     fn is_callee_save(self) -> bool {
         self as usize > 18
@@ -252,8 +266,8 @@ impl ArgumentRegisterAllocator {
         &mut self,
         ty: Type,
         calling_convention: CallingConvention,
-    ) -> Option<ARM64Register> {
-        match calling_convention {
+    ) -> Result<Option<ARM64Register>, CompileError> {
+        let ret = match calling_convention {
             CallingConvention::SystemV | CallingConvention::AppleAarch64 => {
                 static GPR_SEQ: &[GPR] = &[
                     GPR::X0,
@@ -294,14 +308,21 @@ impl ArgumentRegisterAllocator {
                             None
                         }
                     }
-                    _ => todo!(
-                        "ArgumentRegisterAllocator::next: Unsupported type: {:?}",
-                        ty
-                    ),
+                    _ => {
+                        return Err(CompileError::Codegen(format!(
+                            "No register available for {calling_convention:?} and type {ty}"
+                        )))
+                    }
                 }
             }
-            _ => unimplemented!(),
-        }
+            _ => {
+                return Err(CompileError::Codegen(format!(
+                    "No register available for {calling_convention:?} and type {ty}"
+                )))
+            }
+        };
+
+        Ok(ret)
     }
 }
 
@@ -312,6 +333,6 @@ pub fn new_machine_state() -> MachineState {
         register_values: vec![MachineValue::Undefined; 32 + 32],
         prev_frame: BTreeMap::new(),
         wasm_stack: vec![],
-        wasm_inst_offset: std::usize::MAX,
+        wasm_inst_offset: usize::MAX,
     }
 }
diff --git a/lib/compiler-singlepass/src/codegen.rs b/lib/compiler-singlepass/src/codegen.rs
index ab7a783cf4..795d9665d3 100644
--- a/lib/compiler-singlepass/src/codegen.rs
+++ b/lib/compiler-singlepass/src/codegen.rs
@@ -1,32 +1,43 @@
-use crate::address_map::get_function_address_map;
-use crate::codegen_error;
 #[cfg(feature = "unwind")]
 use crate::dwarf::WriterRelocate;
-use crate::location::{Location, Reg};
-use crate::machine::{Label, Machine, MachineStackOffset, NATIVE_PAGE_SIZE};
-use crate::unwind::UnwindFrame;
-use crate::{common_decl::*, config::Singlepass};
+
+use crate::{
+    address_map::get_function_address_map,
+    codegen_error,
+    common_decl::*,
+    config::Singlepass,
+    location::{Location, Reg},
+    machine::{Label, Machine, MachineStackOffset, NATIVE_PAGE_SIZE},
+    unwind::UnwindFrame,
+};
 #[cfg(feature = "unwind")]
 use gimli::write::Address;
 use smallvec::{smallvec, SmallVec};
-use std::cmp;
-use std::iter;
-use wasmer_compiler::wasmparser::{
-    BlockType as WpTypeOrFuncType, HeapType as WpHeapType, Operator, RefType as WpRefType,
-    ValType as WpType,
+use std::{cmp, iter};
+
+use wasmer_compiler::{
+    types::{
+        function::{CompiledFunction, CompiledFunctionFrameInfo, FunctionBody},
+        relocation::{Relocation, RelocationTarget},
+        section::SectionIndex,
+    },
+    wasmparser::{
+        BlockType as WpTypeOrFuncType, HeapType as WpHeapType, Operator, RefType as WpRefType,
+        ValType as WpType,
+    },
+    FunctionBodyData,
 };
-use wasmer_compiler::FunctionBodyData;
+
 #[cfg(feature = "unwind")]
-use wasmer_types::CompiledFunctionUnwindInfo;
+use wasmer_compiler::types::unwind::CompiledFunctionUnwindInfo;
+
+use wasmer_types::target::CallingConvention;
 use wasmer_types::{
     entity::{EntityRef, PrimaryMap},
-    CallingConvention, CompileError, FunctionIndex, FunctionType, GlobalIndex, LocalFunctionIndex,
-    LocalMemoryIndex, MemoryIndex, MemoryStyle, ModuleInfo, Relocation, RelocationTarget,
-    SectionIndex, SignatureIndex, TableIndex, TableStyle, TrapCode, Type, VMBuiltinFunctionIndex,
-    VMOffsets,
+    CompileError, FunctionIndex, FunctionType, GlobalIndex, LocalFunctionIndex, LocalMemoryIndex,
+    MemoryIndex, MemoryStyle, ModuleInfo, SignatureIndex, TableIndex, TableStyle, TrapCode, Type,
+    VMBuiltinFunctionIndex, VMOffsets,
 };
-use wasmer_types::{CompiledFunction, CompiledFunctionFrameInfo, FunctionBody};
-
 /// The singlepass per-function code generator.
 pub struct FuncGen<'a, M: Machine> {
     // Immutable properties assigned at creation time.
@@ -238,8 +249,9 @@ fn type_to_wp_type(ty: Type) -> WpType {
         Type::F32 => WpType::F32,
         Type::F64 => WpType::F64,
         Type::V128 => WpType::V128,
-        Type::ExternRef => WpType::Ref(WpRefType::new(true, WpHeapType::Extern).unwrap()),
-        Type::FuncRef => WpType::Ref(WpRefType::new(true, WpHeapType::Func).unwrap()),
+        Type::ExternRef => WpType::Ref(WpRefType::new(true, WpHeapType::EXTERN).unwrap()),
+        Type::FuncRef => WpType::Ref(WpRefType::new(true, WpHeapType::FUNC).unwrap()),
+        Type::ExceptionRef => todo!(),
     }
 }
 
@@ -1048,7 +1060,7 @@ impl<'a, M: Machine> FuncGen<'a, M> {
 
     pub fn get_state_diff(&mut self) -> usize {
         if !self.track_state {
-            return std::usize::MAX;
+            return usize::MAX;
         }
         let last_frame = self.control_stack.last_mut().unwrap();
         let mut diff = self.state.diff(&last_frame.state);
@@ -1104,9 +1116,9 @@ impl<'a, M: Machine> FuncGen<'a, M> {
         // anywhere in the function prologue.
         self.machine.insert_stackoverflow();
 
-        if self.state.wasm_inst_offset != std::usize::MAX {
+        if self.state.wasm_inst_offset != usize::MAX {
             return Err(CompileError::Codegen(
-                "emit_head: wasm_inst_offset not std::usize::MAX".to_owned(),
+                "emit_head: wasm_inst_offset not usize::MAX".to_owned(),
             ));
         }
         Ok(())
@@ -2719,7 +2731,6 @@ impl<'a, M: Machine> FuncGen<'a, M> {
             Operator::CallIndirect {
                 type_index,
                 table_index,
-                table_byte: _,
             } => {
                 // TODO: removed restriction on always being table idx 0;
                 // does any code depend on this?
@@ -3123,7 +3134,7 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 // TODO: Re-enable interrupt signal check without branching
             }
             Operator::Nop => {}
-            Operator::MemorySize { mem, mem_byte: _ } => {
+            Operator::MemorySize { mem } => {
                 let memory_index = MemoryIndex::new(mem as usize);
                 self.machine.move_location(
                     Size::S64,
@@ -3329,7 +3340,7 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 )?;
                 self.release_locations_only_stack(&[dst, val, len])?;
             }
-            Operator::MemoryGrow { mem, mem_byte: _ } => {
+            Operator::MemoryGrow { mem } => {
                 let memory_index = MemoryIndex::new(mem as usize);
                 let param_pages = self.value_stack.pop().unwrap();
 
@@ -4080,7 +4091,7 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 let targets = targets
                     .targets()
                     .collect::<Result<Vec<_>, _>>()
-                    .map_err(|e| CompileError::Codegen(format!("BrTable read_table: {:?}", e)))?;
+                    .map_err(|e| CompileError::Codegen(format!("BrTable read_table: {e:?}")))?;
                 let cond = self.pop_value_released()?;
                 let table_label = self.machine.get_label();
                 let mut table: Vec<Label> = vec![];
@@ -4103,8 +4114,7 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                     if !frame.loop_like && !frame.returns.is_empty() {
                         if frame.returns.len() != 1 {
                             return Err(CompileError::Codegen(format!(
-                                "BrTable: incorrect frame.returns for {:?}",
-                                target
+                                "BrTable: incorrect frame.returns for {target:?}",
                             )));
                         }
 
@@ -6072,7 +6082,7 @@ impl<'a, M: Machine> FuncGen<'a, M> {
 
                 let ret = self.acquire_locations(
                     &[(
-                        WpType::Ref(WpRefType::new(true, WpHeapType::Func).unwrap()),
+                        WpType::Ref(WpRefType::new(true, WpHeapType::FUNC).unwrap()),
                         MachineValue::WasmStack(self.value_stack.len()),
                     )],
                     false,
@@ -6097,6 +6107,7 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                 let table_index = TableIndex::new(index as _);
                 let value = self.value_stack.pop().unwrap();
                 let index = self.value_stack.pop().unwrap();
+
                 // double check this does what I think it does
                 self.release_locations_only_regs(&[value, index])?;
 
@@ -6134,6 +6145,7 @@ impl<'a, M: Machine> FuncGen<'a, M> {
             Operator::TableGet { table: index } => {
                 let table_index = TableIndex::new(index as _);
                 let index = self.value_stack.pop().unwrap();
+
                 self.release_locations_only_regs(&[index])?;
 
                 self.machine.move_location(
@@ -6168,7 +6180,7 @@ impl<'a, M: Machine> FuncGen<'a, M> {
 
                 let ret = self.acquire_locations(
                     &[(
-                        WpType::Ref(WpRefType::new(true, WpHeapType::Func).unwrap()),
+                        WpType::Ref(WpRefType::new(true, WpHeapType::FUNC).unwrap()),
                         MachineValue::WasmStack(self.value_stack.len()),
                     )],
                     false,
@@ -6233,7 +6245,7 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                             if self.module.local_table_index(table_index).is_some() {
                                 VMBuiltinFunctionIndex::get_table_grow_index()
                             } else {
-                                VMBuiltinFunctionIndex::get_imported_table_get_index()
+                                VMBuiltinFunctionIndex::get_imported_table_grow_index()
                             },
                         ) as i32,
                     ),
@@ -6606,8 +6618,7 @@ impl<'a, M: Machine> FuncGen<'a, M> {
             }
             _ => {
                 return Err(CompileError::Codegen(format!(
-                    "not yet implemented: {:?}",
-                    op
+                    "not yet implemented: {op:?}"
                 )));
             }
         }
diff --git a/lib/compiler-singlepass/src/common_decl.rs b/lib/compiler-singlepass/src/common_decl.rs
index 9d48cf6933..00090c344a 100644
--- a/lib/compiler-singlepass/src/common_decl.rs
+++ b/lib/compiler-singlepass/src/common_decl.rs
@@ -32,6 +32,7 @@ pub struct MachineState {
 /// A `MachineStateDiff` can only be applied after the `MachineStateDiff` its `last` field
 /// points to is already applied.
 #[derive(Clone, Debug, Default)]
+#[allow(dead_code)]
 pub struct MachineStateDiff {
     /// Link to the previous diff this diff is based on, or `None` if this is the first diff.
     pub last: Option<usize>,
@@ -83,6 +84,7 @@ pub enum MachineValue {
 
 /// A map of function states.
 #[derive(Clone, Debug)]
+#[allow(dead_code)]
 pub struct FunctionStateMap {
     /// Initial.
     pub initial: MachineState,
@@ -115,6 +117,7 @@ pub enum Size {
 }
 
 /// A kind of suspend offset.
+#[allow(dead_code)]
 #[derive(Clone, Copy, Debug)]
 pub enum SuspendOffset {
     /// A loop.
@@ -126,6 +129,7 @@ pub enum SuspendOffset {
 }
 
 /// Description of a machine code range following an offset.
+#[allow(dead_code)]
 #[derive(Clone, Debug)]
 pub struct OffsetInfo {
     /// Exclusive range-end offset.
@@ -193,7 +197,7 @@ impl MachineState {
             .chain(
                 old.prev_frame
                     .iter()
-                    .filter(|(k, _)| self.prev_frame.get(k).is_none())
+                    .filter(|(k, _)| !self.prev_frame.contains_key(k))
                     .map(|(&k, _)| (k, None)),
             )
             .collect();
diff --git a/lib/compiler-singlepass/src/compiler.rs b/lib/compiler-singlepass/src/compiler.rs
index 06f9cecf70..0b2d1b4272 100644
--- a/lib/compiler-singlepass/src/compiler.rs
+++ b/lib/compiler-singlepass/src/compiler.rs
@@ -16,24 +16,29 @@ use crate::machine_x64::MachineX86_64;
 use crate::unwind::{create_systemv_cie, UnwindFrame};
 use enumset::EnumSet;
 #[cfg(feature = "unwind")]
-use gimli::write::{EhFrame, FrameTable};
+use gimli::write::{EhFrame, FrameTable, Writer};
 #[cfg(feature = "rayon")]
 use rayon::prelude::{IntoParallelIterator, ParallelIterator};
 use std::sync::Arc;
 use wasmer_compiler::{
+    types::{
+        function::{Compilation, CompiledFunction, FunctionBody, UnwindInfo},
+        module::CompileModuleInfo,
+        section::SectionIndex,
+    },
     Compiler, CompilerConfig, FunctionBinaryReader, FunctionBodyData, MiddlewareBinaryReader,
     ModuleMiddleware, ModuleMiddlewareChain, ModuleTranslationState,
 };
 use wasmer_types::entity::{EntityRef, PrimaryMap};
+use wasmer_types::target::{Architecture, CallingConvention, CpuFeature, Target};
 use wasmer_types::{
-    Architecture, CallingConvention, Compilation, CompileError, CompileModuleInfo,
-    CompiledFunction, CpuFeature, Dwarf, FunctionBody, FunctionIndex, FunctionType,
-    LocalFunctionIndex, MemoryIndex, ModuleInfo, OperatingSystem, SectionIndex, TableIndex, Target,
-    TrapCode, TrapInformation, VMOffsets,
+    CompileError, FunctionIndex, FunctionType, LocalFunctionIndex, MemoryIndex, ModuleInfo,
+    TableIndex, TrapCode, TrapInformation, VMOffsets,
 };
 
 /// A compiler that compiles a WebAssembly module with Singlepass.
 /// It does the compilation in one pass
+#[derive(Debug)]
 pub struct SinglepassCompiler {
     config: Singlepass,
 }
@@ -55,6 +60,10 @@ impl Compiler for SinglepassCompiler {
         "singlepass"
     }
 
+    fn deterministic_id(&self) -> String {
+        String::from("singlepass")
+    }
+
     /// Get the middlewares for this compiler
     fn get_middlewares(&self) -> &[Arc<dyn ModuleMiddleware>] {
         &self.config.middlewares
@@ -232,8 +241,11 @@ impl Compiler for SinglepassCompiler {
             .into_iter()
             .collect::<PrimaryMap<FunctionIndex, FunctionBody>>();
 
+        #[allow(unused_mut)]
+        let mut unwind_info = UnwindInfo::default();
+
         #[cfg(feature = "unwind")]
-        let dwarf = if let Some((mut dwarf_frametable, cie_id)) = dwarf_frametable {
+        if let Some((mut dwarf_frametable, cie_id)) = dwarf_frametable {
             for fde in fdes.into_iter().flatten() {
                 match fde {
                     UnwindFrame::SystemV(fde) => dwarf_frametable.add_fde(cie_id, fde),
@@ -241,22 +253,22 @@ impl Compiler for SinglepassCompiler {
             }
             let mut eh_frame = EhFrame(WriterRelocate::new(target.triple().endianness().ok()));
             dwarf_frametable.write_eh_frame(&mut eh_frame).unwrap();
+            eh_frame.write(&[0, 0, 0, 0]).unwrap(); // Write a 0 length at the end of the table.
 
             let eh_frame_section = eh_frame.0.into_section();
             custom_sections.push(eh_frame_section);
-            Some(Dwarf::new(SectionIndex::new(custom_sections.len() - 1)))
-        } else {
-            None
+            unwind_info.eh_frame = Some(SectionIndex::new(custom_sections.len() - 1))
         };
-        #[cfg(not(feature = "unwind"))]
-        let dwarf = None;
+
+        let got = wasmer_compiler::types::function::GOT::empty();
 
         Ok(Compilation {
             functions: functions.into_iter().collect(),
             custom_sections,
             function_call_trampolines,
             dynamic_function_trampolines,
-            debug: dwarf,
+            unwind_info,
+            got,
         })
     }
 
@@ -291,7 +303,10 @@ mod tests {
     use std::str::FromStr;
     use target_lexicon::triple;
     use wasmer_compiler::Features;
-    use wasmer_types::{CpuFeature, MemoryStyle, TableStyle, Triple};
+    use wasmer_types::{
+        target::{CpuFeature, Triple},
+        MemoryStyle, TableStyle,
+    };
 
     fn dummy_compilation_ingredients<'a>() -> (
         CompileModuleInfo,
@@ -319,7 +334,7 @@ mod tests {
         let result = compiler.compile_module(&linux32, &info, &translation, inputs);
         match result.unwrap_err() {
             CompileError::UnsupportedTarget(name) => assert_eq!(name, "i686"),
-            error => panic!("Unexpected error: {:?}", error),
+            error => panic!("Unexpected error: {error:?}"),
         };
 
         // Compile for win32
@@ -328,7 +343,7 @@ mod tests {
         let result = compiler.compile_module(&win32, &info, &translation, inputs);
         match result.unwrap_err() {
             CompileError::UnsupportedTarget(name) => assert_eq!(name, "i686"), // Windows should be checked before architecture
-            error => panic!("Unexpected error: {:?}", error),
+            error => panic!("Unexpected error: {error:?}"),
         };
     }
 
diff --git a/lib/compiler-singlepass/src/config.rs b/lib/compiler-singlepass/src/config.rs
index ea01ebb6de..71cd41d614 100644
--- a/lib/compiler-singlepass/src/config.rs
+++ b/lib/compiler-singlepass/src/config.rs
@@ -4,7 +4,10 @@
 use crate::compiler::SinglepassCompiler;
 use std::sync::Arc;
 use wasmer_compiler::{Compiler, CompilerConfig, Engine, EngineBuilder, ModuleMiddleware};
-use wasmer_types::{CpuFeature, Features, Target};
+use wasmer_types::{
+    target::{CpuFeature, Target},
+    Features,
+};
 
 #[derive(Debug, Clone)]
 pub struct Singlepass {
@@ -40,8 +43,8 @@ impl CompilerConfig for Singlepass {
         Box::new(SinglepassCompiler::new(*self))
     }
 
-    /// Gets the default features for this compiler in the given target
-    fn default_features_for_target(&self, _target: &Target) -> Features {
+    /// Gets the supported features for this compiler in the given target
+    fn supported_features_for_target(&self, _target: &Target) -> Features {
         let mut features = Features::default();
         features.multi_value(false);
         features
diff --git a/lib/compiler-singlepass/src/dwarf.rs b/lib/compiler-singlepass/src/dwarf.rs
index 815787b468..98e954da53 100644
--- a/lib/compiler-singlepass/src/dwarf.rs
+++ b/lib/compiler-singlepass/src/dwarf.rs
@@ -1,10 +1,12 @@
-use gimli::write::{Address, EndianVec, Result, Writer};
-use gimli::{RunTimeEndian, SectionId};
-use wasmer_types::entity::EntityRef;
-use wasmer_types::{
-    CustomSection, CustomSectionProtection, Endianness, LocalFunctionIndex, Relocation,
-    RelocationKind, RelocationTarget, SectionBody,
+use gimli::{
+    write::{Address, EndianVec, Result, Writer},
+    RunTimeEndian, SectionId,
 };
+use wasmer_compiler::types::{
+    relocation::{Relocation, RelocationKind, RelocationTarget},
+    section::{CustomSection, CustomSectionProtection, SectionBody},
+};
+use wasmer_types::{entity::EntityRef, target::Endianness, LocalFunctionIndex};
 
 #[derive(Clone, Debug)]
 pub struct WriterRelocate {
@@ -33,6 +35,7 @@ impl WriterRelocate {
         let data = self.writer.into_vec();
         CustomSection {
             protection: CustomSectionProtection::Read,
+            alignment: None,
             bytes: SectionBody::new_with_vec(data),
             relocations: self.relocs,
         }
diff --git a/lib/compiler-singlepass/src/emitter_arm64.rs b/lib/compiler-singlepass/src/emitter_arm64.rs
index b7754f6ad7..1799f5c7aa 100644
--- a/lib/compiler-singlepass/src/emitter_arm64.rs
+++ b/lib/compiler-singlepass/src/emitter_arm64.rs
@@ -1,18 +1,21 @@
-pub use crate::arm64_decl::{ARM64Register, ArgumentRegisterAllocator, GPR, NEON};
-use crate::codegen_error;
-use crate::common_decl::Size;
-use crate::location::Location as AbstractLocation;
-pub use crate::location::{Multiplier, Reg};
-pub use crate::machine::{Label, Offset};
+pub use crate::{
+    arm64_decl::{ARM64Register, ArgumentRegisterAllocator, GPR, NEON},
+    location::{Multiplier, Reg},
+    machine::{Label, Offset},
+};
+use crate::{codegen_error, common_decl::Size, location::Location as AbstractLocation};
 use dynasm::dynasm;
 pub use dynasmrt::aarch64::{encode_logical_immediate_32bit, encode_logical_immediate_64bit};
 use dynasmrt::{
     aarch64::Aarch64Relocation, AssemblyOffset, DynamicLabel, DynasmApi, DynasmLabelApi,
     VecAssembler,
 };
+use wasmer_compiler::types::{
+    function::FunctionBody,
+    section::{CustomSection, CustomSectionProtection, SectionBody},
+};
 use wasmer_types::{
-    CallingConvention, CompileError, CustomSection, CustomSectionProtection, FunctionBody,
-    FunctionIndex, FunctionType, SectionBody, Type, VMOffsets,
+    target::CallingConvention, CompileError, FunctionIndex, FunctionType, Type, VMOffsets,
 };
 
 type Assembler = VecAssembler<Aarch64Relocation>;
@@ -84,6 +87,7 @@ pub enum GPROrMemory {
     Memory(GPR, i32),
 }
 
+#[allow(unused)]
 pub trait EmitterARM64 {
     fn get_label(&mut self) -> Label;
     fn get_offset(&self) -> Offset;
@@ -519,62 +523,47 @@ impl EmitterARM64 for Assembler {
         dynasm!(
             self
             ; const_neg_one_32:
-            ; .word -1
+            ; .i32 -1
             ; const_zero_32:
-            ; .word 0
+            ; .i32 0
             ; const_pos_one_32:
-            ; .word 1
+            ; .i32 1
         );
     }
 
     fn emit_str(&mut self, sz: Size, reg: Location, addr: Location) -> Result<(), CompileError> {
         match (sz, reg, addr) {
             (Size::S64, Location::GPR(reg), Location::Memory(addr, disp)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 let disp = disp as u32;
                 assert!((disp & 0x7) == 0 && (disp < 0x8000));
                 dynasm!(self ; str X(reg), [X(addr), disp]);
             }
             (Size::S32, Location::GPR(reg), Location::Memory(addr, disp)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 let disp = disp as u32;
                 assert!((disp & 0x3) == 0 && (disp < 0x4000));
                 dynasm!(self ; str W(reg), [X(addr), disp]);
             }
             (Size::S16, Location::GPR(reg), Location::Memory(addr, disp)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 let disp = disp as u32;
                 assert!((disp & 0x1) == 0 && (disp < 0x2000));
                 dynasm!(self ; strh W(reg), [X(addr), disp]);
             }
             (Size::S8, Location::GPR(reg), Location::Memory(addr, disp)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 let disp = disp as u32;
                 assert!(disp < 0x1000);
                 dynasm!(self ; strb W(reg), [X(addr), disp]);
             }
             (Size::S64, Location::SIMD(reg), Location::Memory(addr, disp)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 let disp = disp as u32;
                 assert!((disp & 0x7) == 0 && (disp < 0x8000));
                 dynasm!(self ; str D(reg), [X(addr), disp]);
             }
             (Size::S32, Location::SIMD(reg), Location::Memory(addr, disp)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 let disp = disp as u32;
                 assert!((disp & 0x3) == 0 && (disp < 0x4000));
                 dynasm!(self ; str S(reg), [X(addr), disp]);
             }
             (Size::S64, Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
-                let r2 = r2.into_index() as u32;
                 assert!(offs == 0);
                 let mult = mult as u32;
                 match mult {
@@ -584,9 +573,6 @@ impl EmitterARM64 for Assembler {
                 };
             }
             (Size::S32, Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
-                let r2 = r2.into_index() as u32;
                 assert!(offs == 0);
                 let mult = mult as u32;
                 match mult {
@@ -602,37 +588,26 @@ impl EmitterARM64 for Assembler {
     fn emit_ldr(&mut self, sz: Size, reg: Location, addr: Location) -> Result<(), CompileError> {
         match (sz, reg, addr) {
             (Size::S64, Location::GPR(reg), Location::Memory(addr, disp)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 assert!((disp & 0x7) == 0 && (disp < 0x8000));
                 let disp = disp as u32;
                 dynasm!(self ; ldr X(reg), [X(addr), disp]);
             }
             (Size::S32, Location::GPR(reg), Location::Memory(addr, disp)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 assert!((disp & 0x3) == 0 && (disp < 0x4000));
                 let disp = disp as u32;
                 dynasm!(self ; ldr W(reg), [X(addr), disp]);
             }
             (Size::S16, Location::GPR(reg), Location::Memory(addr, disp)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 assert!((disp & 0x1 == 0) && (disp < 0x2000));
                 let disp = disp as u32;
                 dynasm!(self ; ldrh W(reg), [X(addr), disp]);
             }
             (Size::S8, Location::GPR(reg), Location::Memory(addr, disp)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 assert!(disp < 0x1000);
                 let disp = disp as u32;
                 dynasm!(self ; ldrb W(reg), [X(addr), disp]);
             }
             (Size::S64, Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
-                let r2 = r2.into_index() as u32;
                 assert!(offs == 0);
                 let mult = mult as u32;
                 match mult {
@@ -642,9 +617,6 @@ impl EmitterARM64 for Assembler {
                 };
             }
             (Size::S32, Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
-                let r2 = r2.into_index() as u32;
                 assert!(offs == 0);
                 let mult = mult as u32;
                 match mult {
@@ -654,23 +626,16 @@ impl EmitterARM64 for Assembler {
                 };
             }
             (Size::S64, Location::SIMD(reg), Location::Memory(addr, disp)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 let disp = disp as u32;
                 assert!((disp & 0x7) == 0 && (disp < 0x8000));
                 dynasm!(self ; ldr D(reg), [X(addr), disp]);
             }
             (Size::S32, Location::SIMD(reg), Location::Memory(addr, disp)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 let disp = disp as u32;
                 assert!((disp & 0x3) == 0 && (disp < 0x4000));
                 dynasm!(self ; ldr S(reg), [X(addr), disp]);
             }
             (Size::S64, Location::SIMD(reg), Location::Memory2(addr, r2, mult, offs)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
-                let r2 = r2.into_index() as u32;
                 assert!(offs == 0);
                 let mult = mult as u32;
                 match mult {
@@ -680,9 +645,6 @@ impl EmitterARM64 for Assembler {
                 };
             }
             (Size::S32, Location::SIMD(reg), Location::Memory2(addr, r2, mult, offs)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
-                let r2 = r2.into_index() as u32;
                 assert!(offs == 0);
                 let mult = mult as u32;
                 match mult {
@@ -705,23 +667,15 @@ impl EmitterARM64 for Assembler {
         assert!((-255..=255).contains(&offset));
         match (sz, reg) {
             (Size::S64, Location::GPR(reg)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 dynasm!(self ; stur X(reg), [X(addr), offset]);
             }
             (Size::S32, Location::GPR(reg)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 dynasm!(self ; stur W(reg), [X(addr), offset]);
             }
             (Size::S64, Location::SIMD(reg)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 dynasm!(self ; stur D(reg), [X(addr), offset]);
             }
             (Size::S32, Location::SIMD(reg)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 dynasm!(self ; stur S(reg), [X(addr), offset]);
             }
             _ => codegen_error!(
@@ -744,23 +698,15 @@ impl EmitterARM64 for Assembler {
         assert!((-255..=255).contains(&offset));
         match (sz, reg) {
             (Size::S64, Location::GPR(reg)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 dynasm!(self ; ldur X(reg), [X(addr), offset]);
             }
             (Size::S32, Location::GPR(reg)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 dynasm!(self ; ldur W(reg), [X(addr), offset]);
             }
             (Size::S64, Location::SIMD(reg)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 dynasm!(self ; ldur D(reg), [X(addr), offset]);
             }
             (Size::S32, Location::SIMD(reg)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 dynasm!(self ; ldur S(reg), [X(addr), offset]);
             }
             _ => codegen_error!(
@@ -784,13 +730,9 @@ impl EmitterARM64 for Assembler {
         assert!(offset <= 255);
         match (sz, reg) {
             (Size::S64, Location::GPR(reg)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 dynasm!(self ; str X(reg), [X(addr), -(offset as i32)]!);
             }
             (Size::S64, Location::SIMD(reg)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 dynasm!(self ; str D(reg), [X(addr), -(offset as i32)]!);
             }
             _ => codegen_error!("singlepass can't emit STRDB"),
@@ -807,14 +749,10 @@ impl EmitterARM64 for Assembler {
         assert!(offset <= 255);
         match (sz, reg) {
             (Size::S64, Location::GPR(reg)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
-                dynasm!(self ; str X(reg), [X(addr)], (offset as i32));
+                dynasm!(self ; str X(reg), [X(addr)], offset as i32);
             }
             (Size::S64, Location::SIMD(reg)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
-                dynasm!(self ; str D(reg), [X(addr)], (offset as i32));
+                dynasm!(self ; str D(reg), [X(addr)], offset as i32);
             }
             _ => codegen_error!("singlepass can't emit STRIA"),
         }
@@ -830,14 +768,10 @@ impl EmitterARM64 for Assembler {
         assert!(offset <= 255);
         match (sz, reg) {
             (Size::S64, Location::GPR(reg)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
-                dynasm!(self ; ldr X(reg), [X(addr)], offset);
+                dynasm!(self ; ldr X(reg), [X(addr)], offset as _);
             }
             (Size::S64, Location::SIMD(reg)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
-                dynasm!(self ; ldr D(reg), [X(addr)], offset);
+                dynasm!(self ; ldr D(reg), [X(addr)], offset as _);
             }
             _ => codegen_error!("singlepass can't emit LDRIA"),
         }
@@ -855,9 +789,6 @@ impl EmitterARM64 for Assembler {
         assert!(offset <= 255);
         match (sz, reg1, reg2) {
             (Size::S64, Location::GPR(reg1), Location::GPR(reg2)) => {
-                let reg1 = reg1.into_index() as u32;
-                let reg2 = reg2.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 dynasm!(self ; stp X(reg1), X(reg2), [X(addr), -(offset as i32)]!);
             }
             _ => codegen_error!("singlepass can't emit STPDB"),
@@ -875,10 +806,7 @@ impl EmitterARM64 for Assembler {
         assert!(offset <= 255);
         match (sz, reg1, reg2) {
             (Size::S64, Location::GPR(reg1), Location::GPR(reg2)) => {
-                let reg1 = reg1.into_index() as u32;
-                let reg2 = reg2.into_index() as u32;
-                let addr = addr.into_index() as u32;
-                dynasm!(self ; ldp X(reg1), X(reg2), [X(addr)], offset);
+                dynasm!(self ; ldp X(reg1), X(reg2), [X(addr)], offset as _);
             }
             _ => codegen_error!("singlepass can't emit LDPIA"),
         }
@@ -888,16 +816,11 @@ impl EmitterARM64 for Assembler {
     fn emit_ldrb(&mut self, _sz: Size, reg: Location, dst: Location) -> Result<(), CompileError> {
         match (reg, dst) {
             (Location::GPR(reg), Location::Memory(addr, offset)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 let offset = offset as u32;
                 assert!(offset < 0x1000);
                 dynasm!(self ; ldrb W(reg), [X(addr), offset]);
             }
             (Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
-                let r2 = r2.into_index() as u32;
                 assert!(offs == 0);
                 let mult = mult as u32;
                 match mult {
@@ -913,16 +836,11 @@ impl EmitterARM64 for Assembler {
     fn emit_ldrh(&mut self, _sz: Size, reg: Location, dst: Location) -> Result<(), CompileError> {
         match (reg, dst) {
             (Location::GPR(reg), Location::Memory(addr, offset)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 let offset = offset as u32;
                 assert!((offset & 1 == 0) && (offset < 0x2000));
                 dynasm!(self ; ldrh W(reg), [X(addr), offset]);
             }
             (Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
-                let r2 = r2.into_index() as u32;
                 assert!(offs == 0);
                 let mult = mult as u32;
                 match mult {
@@ -938,23 +856,16 @@ impl EmitterARM64 for Assembler {
     fn emit_ldrsb(&mut self, sz: Size, reg: Location, dst: Location) -> Result<(), CompileError> {
         match (sz, reg, dst) {
             (Size::S64, Location::GPR(reg), Location::Memory(addr, offset)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 let offset = offset as u32;
                 assert!(offset < 0x1000);
                 dynasm!(self ; ldrsb X(reg), [X(addr), offset]);
             }
             (Size::S32, Location::GPR(reg), Location::Memory(addr, offset)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 let offset = offset as u32;
                 assert!(offset < 0x1000);
                 dynasm!(self ; ldrsb W(reg), [X(addr), offset]);
             }
             (Size::S64, Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
-                let r2 = r2.into_index() as u32;
                 assert!(offs == 0);
                 let mult = mult as u32;
                 match mult {
@@ -964,9 +875,6 @@ impl EmitterARM64 for Assembler {
                 };
             }
             (Size::S32, Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
-                let r2 = r2.into_index() as u32;
                 assert!(offs == 0);
                 let mult = mult as u32;
                 match mult {
@@ -982,23 +890,16 @@ impl EmitterARM64 for Assembler {
     fn emit_ldrsh(&mut self, sz: Size, reg: Location, dst: Location) -> Result<(), CompileError> {
         match (sz, reg, dst) {
             (Size::S64, Location::GPR(reg), Location::Memory(addr, offset)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 let offset = offset as u32;
                 assert!((offset & 1 == 0) && (offset < 0x2000));
                 dynasm!(self ; ldrsh X(reg), [X(addr), offset]);
             }
             (Size::S32, Location::GPR(reg), Location::Memory(addr, offset)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 let offset = offset as u32;
                 assert!((offset & 1 == 0) && (offset < 0x2000));
                 dynasm!(self ; ldrsh W(reg), [X(addr), offset]);
             }
             (Size::S64, Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
-                let r2 = r2.into_index() as u32;
                 assert!(offs == 0);
                 let mult = mult as u32;
                 match mult {
@@ -1008,9 +909,6 @@ impl EmitterARM64 for Assembler {
                 };
             }
             (Size::S32, Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
-                let r2 = r2.into_index() as u32;
                 assert!(offs == 0);
                 let mult = mult as u32;
                 match mult {
@@ -1026,16 +924,11 @@ impl EmitterARM64 for Assembler {
     fn emit_ldrsw(&mut self, sz: Size, reg: Location, dst: Location) -> Result<(), CompileError> {
         match (sz, reg, dst) {
             (Size::S64, Location::GPR(reg), Location::Memory(addr, offset)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 let offset = offset as u32;
                 assert!((offset & 3 == 0) && (offset < 0x4000));
                 dynasm!(self ; ldrsw X(reg), [X(addr), offset]);
             }
             (Size::S64, Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
-                let r2 = r2.into_index() as u32;
                 assert!(offs == 0);
                 let mult = mult as u32;
                 match mult {
@@ -1051,16 +944,11 @@ impl EmitterARM64 for Assembler {
     fn emit_strb(&mut self, _sz: Size, reg: Location, dst: Location) -> Result<(), CompileError> {
         match (reg, dst) {
             (Location::GPR(reg), Location::Memory(addr, offset)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 let offset = offset as u32;
                 assert!(offset < 0x1000);
                 dynasm!(self ; strb W(reg), [X(addr), offset]);
             }
             (Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
-                let r2 = r2.into_index() as u32;
                 assert!(offs == 0);
                 let mult = mult as u32;
                 match mult {
@@ -1076,16 +964,11 @@ impl EmitterARM64 for Assembler {
     fn emit_strh(&mut self, _sz: Size, reg: Location, dst: Location) -> Result<(), CompileError> {
         match (reg, dst) {
             (Location::GPR(reg), Location::Memory(addr, offset)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
                 let offset = offset as u32;
                 assert!((offset & 1 == 0) && (offset < 0x2000));
                 dynasm!(self ; strh W(reg), [X(addr), offset]);
             }
             (Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
-                let reg = reg.into_index() as u32;
-                let addr = addr.into_index() as u32;
-                let r2 = r2.into_index() as u32;
                 assert!(offs == 0);
                 let mult = mult as u32;
                 match mult {
@@ -1102,13 +985,9 @@ impl EmitterARM64 for Assembler {
     fn emit_ldaxr(&mut self, sz: Size, reg: Location, dst: Location) -> Result<(), CompileError> {
         match (sz, reg, dst) {
             (Size::S32, Location::GPR(reg), Location::GPR(dst)) => {
-                let reg = reg.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; ldaxr W(reg), [X(dst)]);
             }
             (Size::S64, Location::GPR(reg), Location::GPR(dst)) => {
-                let reg = reg.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; ldaxr X(reg), [X(dst)]);
             }
             _ => codegen_error!("singlepass can't emit LDAXR {:?}, {:?}", reg, dst),
@@ -1118,8 +997,6 @@ impl EmitterARM64 for Assembler {
     fn emit_ldaxrb(&mut self, _sz: Size, reg: Location, dst: Location) -> Result<(), CompileError> {
         match (reg, dst) {
             (Location::GPR(reg), Location::GPR(dst)) => {
-                let reg = reg.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; ldaxrb W(reg), [X(dst)]);
             }
             _ => codegen_error!("singlepass can't emit LDAXRB {:?}, {:?}", reg, dst),
@@ -1129,8 +1006,6 @@ impl EmitterARM64 for Assembler {
     fn emit_ldaxrh(&mut self, _sz: Size, reg: Location, dst: Location) -> Result<(), CompileError> {
         match (reg, dst) {
             (Location::GPR(reg), Location::GPR(dst)) => {
-                let reg = reg.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; ldaxrh W(reg), [X(dst)]);
             }
             _ => codegen_error!("singlepass can't emit LDAXRH {:?}, {:?}", reg, dst),
@@ -1146,15 +1021,9 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, status, reg, dst) {
             (Size::S32, Location::GPR(status), Location::GPR(reg), Location::GPR(dst)) => {
-                let reg = reg.into_index() as u32;
-                let dst = dst.into_index() as u32;
-                let status = status.into_index() as u32;
                 dynasm!(self ; stlxr W(status), W(reg), [X(dst)]);
             }
             (Size::S64, Location::GPR(status), Location::GPR(reg), Location::GPR(dst)) => {
-                let reg = reg.into_index() as u32;
-                let dst = dst.into_index() as u32;
-                let status = status.into_index() as u32;
                 dynasm!(self ; stlxr W(status), X(reg), [X(dst)]);
             }
             _ => codegen_error!("singlepass can't emit STLXR {:?}, {:?}", reg, dst),
@@ -1170,9 +1039,6 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (status, reg, dst) {
             (Location::GPR(status), Location::GPR(reg), Location::GPR(dst)) => {
-                let reg = reg.into_index() as u32;
-                let dst = dst.into_index() as u32;
-                let status = status.into_index() as u32;
                 dynasm!(self ; stlxrb W(status), W(reg), [X(dst)]);
             }
             _ => codegen_error!("singlepass can't emit STLXRB {:?}, {:?}", reg, dst),
@@ -1188,9 +1054,6 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (status, reg, dst) {
             (Location::GPR(status), Location::GPR(reg), Location::GPR(dst)) => {
-                let reg = reg.into_index() as u32;
-                let dst = dst.into_index() as u32;
-                let status = status.into_index() as u32;
                 dynasm!(self ; stlxrh W(status), W(reg), [X(dst)]);
             }
             _ => codegen_error!("singlepass can't emit STLXRH {:?}, {:?}", reg, dst),
@@ -1201,73 +1064,58 @@ impl EmitterARM64 for Assembler {
     fn emit_mov(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
         match (sz, src, dst) {
             (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; mov X(dst), X(src));
             }
             (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; mov W(dst), W(src));
             }
             (Size::S64, Location::SIMD(src), Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; mov V(dst).D[0], V(src).D[0]);
             }
             (Size::S32, Location::SIMD(src), Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; mov V(dst).S[0], V(src).S[0]);
             }
             (Size::S64, Location::GPR(src), Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; mov V(dst).D[0], X(src));
             }
             (Size::S32, Location::GPR(src), Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; mov V(dst).S[0], W(src));
             }
             (Size::S64, Location::SIMD(src), Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; mov X(dst), V(src).D[0]);
             }
             (Size::S32, Location::SIMD(src), Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; mov W(dst), V(src).S[0]);
             }
             (Size::S32, Location::Imm32(val), Location::GPR(dst)) => {
-                let dst = dst.into_index() as u32;
-                if val < 0x1000 {
-                    dynasm!(self ; mov W(dst), val as u64);
-                } else if encode_logical_immediate_32bit(val as _).is_some() {
-                    dynasm!(self ; orr W(dst), wzr, val);
+                if val < 0x1000 || encode_logical_immediate_32bit(val as _).is_some() {
+                    dynasm!(self ; mov W(dst), val);
                 } else {
-                    codegen_error!("singlepass can't emit MOV S32 {}, {:?}", val, dst);
+                    dynasm!(self
+                        ; movz W(dst), val
+                        ; movk W(dst), val, lsl #16);
                 }
             }
             (Size::S64, Location::Imm32(val), Location::GPR(dst)) => {
-                let dst = dst.into_index() as u32;
                 if val < 0x1000 {
-                    dynasm!(self ; mov W(dst), val as u64);
+                    dynasm!(self ; mov W(dst), val);
                 } else if encode_logical_immediate_64bit(val as _).is_some() {
-                    dynasm!(self ; orr X(dst), xzr, val as u64);
+                    dynasm!(self ; mov X(dst), val as _);
                 } else {
-                    codegen_error!("singlepass can't emit MOV S64 {}, {:?}", val, dst);
+                    dynasm!(self
+                        ; movz X(dst), val
+                        ; movk X(dst), val, lsl #16);
                 }
             }
             (Size::S64, Location::Imm64(val), Location::GPR(dst)) => {
-                let dst = dst.into_index() as u32;
-                if val < 0x1000 {
-                    dynasm!(self ; mov W(dst), val as u64);
-                } else if encode_logical_immediate_64bit(val as _).is_some() {
-                    dynasm!(self ; orr X(dst), xzr, val as u64);
+                if val < 0x1000 || encode_logical_immediate_64bit(val as _).is_some() {
+                    dynasm!(self ; mov X(dst), val as _);
                 } else {
-                    codegen_error!("singleplasse can't emit MOV S64 {}, {:?}", val, dst);
+                    dynasm!(self
+                        ; movz X(dst), val as _
+                        ; movk X(dst), val as _, lsl #16
+                        ; movk X(dst), val as _, lsl #32
+                        ; movk X(dst), val as _, lsl #48);
                 }
             }
             _ => codegen_error!("singlepass can't emit MOV {:?}, {:?}, {:?}", sz, src, dst),
@@ -1278,11 +1126,9 @@ impl EmitterARM64 for Assembler {
     fn emit_movn(&mut self, sz: Size, reg: Location, val: u32) -> Result<(), CompileError> {
         match (sz, reg) {
             (Size::S32, Location::GPR(reg)) => {
-                let reg = reg.into_index() as u32;
                 dynasm!(self ; movn W(reg), val);
             }
             (Size::S64, Location::GPR(reg)) => {
-                let reg = reg.into_index() as u32;
                 dynasm!(self ; movn X(reg), val);
             }
             _ => codegen_error!("singlepass can't emit MOVN"),
@@ -1292,7 +1138,6 @@ impl EmitterARM64 for Assembler {
     fn emit_movz(&mut self, reg: Location, val: u32) -> Result<(), CompileError> {
         match reg {
             Location::GPR(reg) => {
-                let reg = reg.into_index() as u32;
                 dynasm!(self ; movz W(reg), val);
             }
             _ => codegen_error!("singlepass can't emit MOVZ"),
@@ -1302,7 +1147,6 @@ impl EmitterARM64 for Assembler {
     fn emit_movk(&mut self, reg: Location, val: u32, shift: u32) -> Result<(), CompileError> {
         match reg {
             Location::GPR(reg) => {
-                let reg = reg.into_index() as u32;
                 dynasm!(self ; movk X(reg), val, LSL shift);
             }
             _ => codegen_error!("singlepass can't emit MOVK"),
@@ -1313,7 +1157,6 @@ impl EmitterARM64 for Assembler {
     fn emit_mov_imm(&mut self, dst: Location, val: u64) -> Result<(), CompileError> {
         match dst {
             Location::GPR(dst) => {
-                let dst = dst.into_index() as u32;
                 let offset = val.trailing_zeros() & 48;
                 let masked = 0xffff & (val >> offset);
                 if (masked << offset) == val {
@@ -1354,56 +1197,40 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src1, src2, dst) {
             (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
-                dynasm!(self ; add X(dst), X(src1), X(src2), UXTX);
+                dynasm!(self ; add XSP(dst), XSP(src1), X(src2), UXTX);
             }
             (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
-                dynasm!(self ; add W(dst), W(src1), W(src2), UXTX);
+                dynasm!(self ; add WSP(dst), WSP(src1), W(src2), UXTX);
             }
             (Size::S64, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
             | (Size::S64, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
-                dynasm!(self ; add X(dst), X(src1), imm as u32);
+                dynasm!(self ; add XSP(dst), XSP(src1), imm as _);
             }
             (Size::S64, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst))
             | (Size::S64, Location::Imm32(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm >= 0x1000 {
                     unreachable!();
                 }
-                dynasm!(self ; add X(dst), X(src1), imm);
+                dynasm!(self ; add XSP(dst), XSP(src1), imm);
             }
             (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst))
             | (Size::S64, Location::Imm64(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm >= 0x1000 {
                     unreachable!();
                 }
                 let imm = imm as u32;
-                dynasm!(self ; add X(dst), X(src1), imm);
+                dynasm!(self ; add XSP(dst), XSP(src1), imm);
             }
             (Size::S32, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
             | (Size::S32, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
-                dynasm!(self ; add W(dst), W(src1), imm as u32);
+                dynasm!(self ; add WSP(dst), WSP(src1), imm as u32);
             }
             (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst))
             | (Size::S32, Location::Imm32(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm >= 0x1000 {
                     unreachable!();
                 }
-                dynasm!(self ; add W(dst), W(src1), imm);
+                dynasm!(self ; add WSP(dst), WSP(src1), imm);
             }
             _ => codegen_error!(
                 "singlepass can't emit ADD {:?} {:?} {:?} {:?}",
@@ -1424,50 +1251,34 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src1, src2, dst) {
             (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
-                dynasm!(self ; sub X(dst), X(src1), X(src2), UXTX);
+                dynasm!(self; sub XSP(dst), XSP(src1), X(src2), UXTX 0);
             }
             (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
-                dynasm!(self ; sub W(dst), W(src1), W(src2), UXTX);
+                dynasm!(self ; sub WSP(dst), WSP(src1), W(src2), UXTX 0);
             }
             (Size::S64, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
-                dynasm!(self ; sub X(dst), X(src1), imm as u32);
+                dynasm!(self ; sub XSP(dst), XSP(src1), imm as u32);
             }
             (Size::S32, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
-                dynasm!(self ; sub W(dst), W(src1), imm as u32);
+                dynasm!(self ; sub WSP(dst), WSP(src1), imm as u32);
             }
             (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm >= 0x1000 {
                     unreachable!();
                 }
-                dynasm!(self ; sub W(dst), W(src1), imm);
+                dynasm!(self ; sub WSP(dst), WSP(src1), imm);
             }
             (Size::S64, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm >= 0x1000 {
                     unreachable!();
                 }
-                dynasm!(self ; sub X(dst), X(src1), imm);
+                dynasm!(self ; sub XSP(dst), XSP(src1), imm);
             }
             (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm >= 0x1000 {
                     unreachable!();
                 }
-                dynasm!(self ; sub X(dst), X(src1), imm as u32);
+                dynasm!(self ; sub XSP(dst), XSP(src1), imm as u32);
             }
             _ => codegen_error!(
                 "singlepass can't emit SUB {:?} {:?} {:?} {:?}",
@@ -1488,15 +1299,9 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src1, src2, dst) {
             (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; mul X(dst), X(src1), X(src2));
             }
             (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; mul W(dst), W(src1), W(src2));
             }
             _ => codegen_error!(
@@ -1518,46 +1323,32 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src1, src2, dst) {
             (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; adds X(dst), X(src1), X(src2));
             }
             (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; adds W(dst), W(src1), W(src2));
             }
             (Size::S64, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
             | (Size::S64, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
-                dynasm!(self ; adds X(dst), X(src1), imm as u32);
+                dynasm!(self ; adds X(dst), XSP(src1), imm as u32);
             }
             (Size::S64, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst))
             | (Size::S64, Location::Imm32(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm >= 0x1000 {
                     codegen_error!("singlepass ADD.S with imm too large {}", imm);
                 }
-                dynasm!(self ; adds X(dst), X(src1), imm);
+                dynasm!(self ; adds X(dst), XSP(src1), imm);
             }
             (Size::S32, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
             | (Size::S32, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
-                dynasm!(self ; adds W(dst), W(src1), imm as u32);
+                dynasm!(self ; adds W(dst), WSP(src1), imm as u32);
             }
             (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst))
             | (Size::S32, Location::Imm32(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm >= 0x1000 {
                     codegen_error!("singlepass ADD.S with imm too large {}", imm);
                 }
-                dynasm!(self ; adds W(dst), W(src1), imm);
+                dynasm!(self ; adds W(dst), WSP(src1), imm);
             }
             _ => codegen_error!(
                 "singlepass can't emit ADD.S {:?} {:?} {:?} {:?}",
@@ -1578,26 +1369,16 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src1, src2, dst) {
             (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; subs X(dst), X(src1), X(src2));
             }
             (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; subs W(dst), W(src1), W(src2));
             }
             (Size::S64, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
-                dynasm!(self ; subs X(dst), X(src1), imm as u32);
+                dynasm!(self ; subs X(dst), XSP(src1), imm as u32);
             }
             (Size::S32, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
-                dynasm!(self ; subs W(dst), W(src1), imm as u32);
+                dynasm!(self ; subs W(dst), WSP(src1), imm as u32);
             }
             _ => codegen_error!(
                 "singlepass can't emit SUB.S {:?} {:?} {:?} {:?}",
@@ -1619,9 +1400,6 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src1, src2, dst) {
             (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; add X(dst), X(src1), X(src2), LSL lsl);
             }
             _ => codegen_error!(
@@ -1639,43 +1417,34 @@ impl EmitterARM64 for Assembler {
     fn emit_cmp(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
         match (sz, src, dst) {
             (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; cmp X(dst), X(src));
             }
             (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; cmp W(dst), W(src));
             }
             (Size::S64, Location::Imm8(imm), Location::GPR(dst)) => {
-                let dst = dst.into_index() as u32;
-                dynasm!(self ; cmp X(dst), imm as u32);
+                dynasm!(self ; cmp XSP(dst), imm as u32);
             }
             (Size::S64, Location::Imm32(imm), Location::GPR(dst)) => {
-                let dst = dst.into_index() as u32;
                 if imm >= 0x1000 {
                     codegen_error!("singlepass CMP with imm too large {}", imm);
                 }
-                dynasm!(self ; cmp X(dst), imm as u32);
+                dynasm!(self ; cmp XSP(dst), imm as u32);
             }
             (Size::S64, Location::Imm64(imm), Location::GPR(dst)) => {
-                let dst = dst.into_index() as u32;
                 if imm >= 0x1000 {
                     codegen_error!("singlepass CMP with imm too large {}", imm);
                 }
-                dynasm!(self ; cmp X(dst), imm as u32);
+                dynasm!(self ; cmp XSP(dst), imm as u32);
             }
             (Size::S32, Location::Imm8(imm), Location::GPR(dst)) => {
-                let dst = dst.into_index() as u32;
-                dynasm!(self ; cmp W(dst), imm as u32);
+                dynasm!(self ; cmp WSP(dst), imm as u32);
             }
             (Size::S32, Location::Imm32(imm), Location::GPR(dst)) => {
-                let dst = dst.into_index() as u32;
                 if imm >= 0x1000 {
                     codegen_error!("singlepass CMP with imm too large {}", imm);
                 }
-                dynasm!(self ; cmp W(dst), imm as u32);
+                dynasm!(self ; cmp WSP(dst), imm as u32);
             }
             _ => codegen_error!("singlepass can't emit CMP {:?} {:?} {:?}", sz, src, dst),
         }
@@ -1685,31 +1454,24 @@ impl EmitterARM64 for Assembler {
     fn emit_tst(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
         match (sz, src, dst) {
             (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; tst X(dst), X(src));
             }
             (Size::S64, Location::Imm32(imm), Location::GPR(dst)) => {
-                let dst = dst.into_index() as u32;
                 if encode_logical_immediate_64bit(imm as u64).is_none() {
                     codegen_error!("singlepass TST with incompatible imm {}", imm);
                 }
                 dynasm!(self ; tst X(dst), imm as u64);
             }
             (Size::S64, Location::Imm64(imm), Location::GPR(dst)) => {
-                let dst = dst.into_index() as u32;
                 if encode_logical_immediate_64bit(imm as u64).is_none() {
                     codegen_error!("singlepass TST with incompatible imm {}", imm);
                 }
                 dynasm!(self ; tst X(dst), imm as u64);
             }
             (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; tst W(dst), W(src));
             }
             (Size::S32, Location::Imm32(imm), Location::GPR(dst)) => {
-                let dst = dst.into_index() as u32;
                 if encode_logical_immediate_64bit(imm as u64).is_none() {
                     codegen_error!("singlepass TST with incompatible imm {}", imm);
                 }
@@ -1729,30 +1491,21 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src1, src2, dst) {
             (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; lsl X(dst), X(src1), X(src2));
             }
             (Size::S64, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
                 if imm > 63 {
                     codegen_error!("singlepass LSL with incompatible imm {}", imm);
                 }
                 let imm = imm as u32;
-                let dst = dst.into_index() as u32;
+
                 dynasm!(self ; lsl X(dst), X(src1), imm);
             }
             (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; lsl W(dst), W(src1), W(src2));
             }
             (Size::S64, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
             | (Size::S64, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm > 63 {
                     codegen_error!("singlepass LSL with incompatible imm {}", imm);
                 }
@@ -1760,8 +1513,6 @@ impl EmitterARM64 for Assembler {
             }
             (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst))
             | (Size::S64, Location::Imm64(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm > 63 {
                     codegen_error!("singlepass LSL with incompatible imm {}", imm);
                 }
@@ -1769,8 +1520,6 @@ impl EmitterARM64 for Assembler {
             }
             (Size::S32, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
             | (Size::S32, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm > 31 {
                     codegen_error!("singlepass LSL with incompatible imm {}", imm);
                 }
@@ -1778,8 +1527,6 @@ impl EmitterARM64 for Assembler {
             }
             (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst))
             | (Size::S32, Location::Imm32(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm > 31 {
                     codegen_error!("singlepass LSL with incompatible imm {}", imm);
                 }
@@ -1804,30 +1551,21 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src1, src2, dst) {
             (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; asr X(dst), X(src1), X(src2));
             }
             (Size::S64, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
                 let imm = imm as u32;
-                let dst = dst.into_index() as u32;
+
                 if imm == 0 || imm > 63 {
                     codegen_error!("singlepass ASR with incompatible imm {}", imm);
                 }
                 dynasm!(self ; asr X(dst), X(src1), imm);
             }
             (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; asr W(dst), W(src1), W(src2));
             }
             (Size::S64, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
             | (Size::S64, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm == 0 || imm > 63 {
                     codegen_error!("singlepass ASR with incompatible imm {}", imm);
                 }
@@ -1835,8 +1573,6 @@ impl EmitterARM64 for Assembler {
             }
             (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst))
             | (Size::S64, Location::Imm64(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm == 0 || imm > 63 {
                     codegen_error!("singlepass ASR with incompatible imm {}", imm);
                 }
@@ -1844,8 +1580,6 @@ impl EmitterARM64 for Assembler {
             }
             (Size::S32, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
             | (Size::S32, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm == 0 || imm > 31 {
                     codegen_error!("singlepass ASR with incompatible imm {}", imm);
                 }
@@ -1853,8 +1587,6 @@ impl EmitterARM64 for Assembler {
             }
             (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst))
             | (Size::S32, Location::Imm32(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm == 0 || imm > 31 {
                     codegen_error!("singlepass ASR with incompatible imm {}", imm);
                 }
@@ -1879,30 +1611,21 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src1, src2, dst) {
             (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; lsr X(dst), X(src1), X(src2));
             }
             (Size::S64, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
                 let imm = imm as u32;
-                let dst = dst.into_index() as u32;
+
                 if imm == 0 || imm > 63 {
                     codegen_error!("singlepass LSR with incompatible imm {}", imm);
                 }
                 dynasm!(self ; lsr X(dst), X(src1), imm);
             }
             (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; lsr W(dst), W(src1), W(src2));
             }
             (Size::S64, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
             | (Size::S64, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm == 0 || imm > 63 {
                     codegen_error!("singlepass LSR with incompatible imm {}", imm);
                 }
@@ -1910,8 +1633,6 @@ impl EmitterARM64 for Assembler {
             }
             (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst))
             | (Size::S64, Location::Imm64(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm == 0 || imm > 63 {
                     codegen_error!("singlepass LSR with incompatible imm {}", imm);
                 }
@@ -1919,8 +1640,6 @@ impl EmitterARM64 for Assembler {
             }
             (Size::S32, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
             | (Size::S32, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm == 0 || imm > 31 {
                     codegen_error!("singlepass LSR with incompatible imm {}", imm);
                 }
@@ -1928,8 +1647,6 @@ impl EmitterARM64 for Assembler {
             }
             (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst))
             | (Size::S32, Location::Imm32(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm == 0 || imm > 31 {
                     codegen_error!("singlepass LSR with incompatible imm {}", imm);
                 }
@@ -1954,16 +1671,12 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src1, src2, dst) {
             (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; ror X(dst), X(src1), X(src2));
             }
             (Size::S64, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst))
             | (Size::S64, Location::Imm32(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
                 let imm = imm as u32;
-                let dst = dst.into_index() as u32;
+
                 if imm == 0 || imm > 63 {
                     codegen_error!("singlepass ROR with incompatible imm {}", imm);
                 }
@@ -1971,9 +1684,8 @@ impl EmitterARM64 for Assembler {
             }
             (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst))
             | (Size::S64, Location::Imm64(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
                 let imm = imm as u32;
-                let dst = dst.into_index() as u32;
+
                 if imm == 0 || imm > 63 {
                     codegen_error!("singlepass ROR with incompatible imm {}", imm);
                 }
@@ -1981,23 +1693,16 @@ impl EmitterARM64 for Assembler {
             }
             (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst))
             | (Size::S32, Location::Imm32(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm == 0 || imm > 31 {
                     codegen_error!("singlepass ROR with incompatible imm {}", imm);
                 }
                 dynasm!(self ; ror W(dst), W(src1), imm as u32);
             }
             (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; ror W(dst), W(src1), W(src2));
             }
             (Size::S64, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
             | (Size::S64, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm == 0 || imm > 63 {
                     codegen_error!("singlepass ROR with incompatible imm {}", imm);
                 }
@@ -2005,8 +1710,6 @@ impl EmitterARM64 for Assembler {
             }
             (Size::S32, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
             | (Size::S32, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 if imm == 0 || imm > 31 {
                     codegen_error!("singlepass ROR with incompatible imm {}", imm);
                 }
@@ -2032,33 +1735,25 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src1, src2, dst) {
             (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; orr X(dst), X(src1), X(src2));
             }
             (Size::S64, Location::GPR(src1), Location::Imm64(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
                 let src2 = src2 as u64;
-                let dst = dst.into_index() as u32;
+
                 if encode_logical_immediate_64bit(src2 as u64).is_none() {
                     codegen_error!("singlepass OR with incompatible imm {}", src2);
                 }
-                dynasm!(self ; orr X(dst), X(src1), src2);
+                dynasm!(self ; orr XSP(dst), X(src1), src2);
             }
             (Size::S32, Location::GPR(src1), Location::Imm32(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
                 let src2 = src2 as u32;
-                let dst = dst.into_index() as u32;
+
                 if encode_logical_immediate_32bit(src2).is_none() {
                     codegen_error!("singlepass OR with incompatible imm {}", src2);
                 }
-                dynasm!(self ; orr W(dst), W(src1), src2);
+                dynasm!(self ; orr WSP(dst), W(src1), src2);
             }
             (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; orr W(dst), W(src1), W(src2));
             }
             _ => codegen_error!(
@@ -2080,33 +1775,25 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src1, src2, dst) {
             (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; and X(dst), X(src1), X(src2));
             }
             (Size::S64, Location::GPR(src1), Location::Imm64(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
                 let src2 = src2 as u64;
-                let dst = dst.into_index() as u32;
+
                 if encode_logical_immediate_64bit(src2 as u64).is_none() {
                     codegen_error!("singlepass AND with incompatible imm {}", src2);
                 }
-                dynasm!(self ; and X(dst), X(src1), src2);
+                dynasm!(self ; and XSP(dst), X(src1), src2);
             }
             (Size::S32, Location::GPR(src1), Location::Imm32(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
                 let src2 = src2 as u32;
-                let dst = dst.into_index() as u32;
+
                 if encode_logical_immediate_32bit(src2).is_none() {
                     codegen_error!("singlepass AND with incompatible imm {}", src2);
                 }
-                dynasm!(self ; and W(dst), W(src1), src2);
+                dynasm!(self ; and WSP(dst), W(src1), src2);
             }
             (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; and W(dst), W(src1), W(src2));
             }
             _ => codegen_error!(
@@ -2128,33 +1815,25 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src1, src2, dst) {
             (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; eor X(dst), X(src1), X(src2));
             }
             (Size::S64, Location::GPR(src1), Location::Imm64(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
                 let src2 = src2 as u64;
-                let dst = dst.into_index() as u32;
+
                 if encode_logical_immediate_64bit(src2 as u64).is_none() {
                     codegen_error!("singlepass EOR with incompatible imm {}", src2);
                 }
-                dynasm!(self ; eor X(dst), X(src1), src2);
+                dynasm!(self ; eor XSP(dst), X(src1), src2);
             }
             (Size::S32, Location::GPR(src1), Location::Imm32(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
                 let src2 = src2 as u32;
-                let dst = dst.into_index() as u32;
+
                 if encode_logical_immediate_32bit(src2).is_none() {
                     codegen_error!("singlepass EOR with incompatible imm {}", src2);
                 }
-                dynasm!(self ; eor W(dst), W(src1), src2);
+                dynasm!(self ; eor WSP(dst), W(src1), src2);
             }
             (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; eor W(dst), W(src1), W(src2));
             }
             _ => codegen_error!(
@@ -2177,10 +1856,10 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, dst) {
             (Size::S32, Location::GPR(dst)) => {
-                dynasm!(self ; bfc W(dst as u32), lsb, width);
+                dynasm!(self ; bfc W(dst), lsb, width);
             }
             (Size::S64, Location::GPR(dst)) => {
-                dynasm!(self ; bfc X(dst as u32), lsb, width);
+                dynasm!(self ; bfc X(dst), lsb, width);
             }
             _ => codegen_error!("singlepass can't emit BFC"),
         }
@@ -2196,10 +1875,10 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src, dst) {
             (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
-                dynasm!(self ; bfi W(dst as u32), W(src as u32), lsb, width);
+                dynasm!(self ; bfi W(dst), W(src), lsb, width);
             }
             (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
-                dynasm!(self ; bfi X(dst as u32), X(src as u32), lsb, width);
+                dynasm!(self ; bfi X(dst), X(src), lsb, width);
             }
             _ => codegen_error!("singlepass can't emit BFI"),
         }
@@ -2215,15 +1894,9 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src1, src2, dst) {
             (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; udiv W(dst), W(src1), W(src2));
             }
             (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; udiv X(dst), X(src1), X(src2));
             }
             _ => codegen_error!(
@@ -2245,15 +1918,9 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src1, src2, dst) {
             (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; sdiv W(dst), W(src1), W(src2));
             }
             (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; sdiv X(dst), X(src1), X(src2));
             }
             _ => codegen_error!(
@@ -2284,10 +1951,6 @@ impl EmitterARM64 for Assembler {
                 Location::GPR(c),
                 Location::GPR(dst),
             ) => {
-                let a = a.into_index() as u32;
-                let b = b.into_index() as u32;
-                let c = c.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; msub W(dst), W(a), W(b), W(c));
             }
             (
@@ -2297,10 +1960,6 @@ impl EmitterARM64 for Assembler {
                 Location::GPR(c),
                 Location::GPR(dst),
             ) => {
-                let a = a.into_index() as u32;
-                let b = b.into_index() as u32;
-                let c = c.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; msub X(dst), X(a), X(b), X(c));
             }
             _ => codegen_error!(
@@ -2318,13 +1977,9 @@ impl EmitterARM64 for Assembler {
     fn emit_sxtb(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
         match (sz, src, dst) {
             (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; sxtb W(dst), W(src));
             }
             (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; sxtb X(dst), W(src));
             }
             _ => codegen_error!("singlepass can't emit SXTB {:?} {:?} {:?}", sz, src, dst),
@@ -2334,13 +1989,9 @@ impl EmitterARM64 for Assembler {
     fn emit_sxth(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
         match (sz, src, dst) {
             (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; sxth W(dst), W(src));
             }
             (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; sxth X(dst), W(src));
             }
             _ => codegen_error!("singlepass can't emit SXTH {:?} {:?} {:?}", sz, src, dst),
@@ -2350,8 +2001,6 @@ impl EmitterARM64 for Assembler {
     fn emit_sxtw(&mut self, _sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
         match (src, dst) {
             (Location::GPR(src), Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; sxtw X(dst), W(src));
             }
             _ => codegen_error!("singlepass can't emit SXTW {:?} {:?}", src, dst),
@@ -2361,8 +2010,6 @@ impl EmitterARM64 for Assembler {
     fn emit_uxtb(&mut self, _sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
         match (src, dst) {
             (Location::GPR(src), Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; uxtb W(dst), W(src));
             }
             _ => codegen_error!("singlepass can't emit UXTB {:?} {:?}", src, dst),
@@ -2372,8 +2019,6 @@ impl EmitterARM64 for Assembler {
     fn emit_uxth(&mut self, _sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
         match (src, dst) {
             (Location::GPR(src), Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; uxth W(dst), W(src));
             }
             _ => codegen_error!("singlepass can't emit UXTH {:?} {:?}", src, dst),
@@ -2383,92 +2028,80 @@ impl EmitterARM64 for Assembler {
 
     fn emit_cset(&mut self, sz: Size, dst: Location, cond: Condition) -> Result<(), CompileError> {
         match (sz, dst) {
-            (Size::S32, Location::GPR(reg)) => {
-                let reg = reg as u32;
-                match cond {
-                    Condition::Eq => dynasm!(self ; cset W(reg), eq),
-                    Condition::Ne => dynasm!(self ; cset W(reg), ne),
-                    Condition::Cs => dynasm!(self ; cset W(reg), cs),
-                    Condition::Cc => dynasm!(self ; cset W(reg), cc),
-                    Condition::Mi => dynasm!(self ; cset W(reg), mi),
-                    Condition::Pl => dynasm!(self ; cset W(reg), pl),
-                    Condition::Vs => dynasm!(self ; cset W(reg), vs),
-                    Condition::Vc => dynasm!(self ; cset W(reg), vc),
-                    Condition::Hi => dynasm!(self ; cset W(reg), hi),
-                    Condition::Ls => dynasm!(self ; cset W(reg), ls),
-                    Condition::Ge => dynasm!(self ; cset W(reg), ge),
-                    Condition::Lt => dynasm!(self ; cset W(reg), lt),
-                    Condition::Gt => dynasm!(self ; cset W(reg), gt),
-                    Condition::Le => dynasm!(self ; cset W(reg), le),
-                    Condition::Al => dynasm!(self ; cset W(reg), al),
-                }
-            }
-            (Size::S64, Location::GPR(reg)) => {
-                let reg = reg as u32;
-                match cond {
-                    Condition::Eq => dynasm!(self ; cset X(reg), eq),
-                    Condition::Ne => dynasm!(self ; cset X(reg), ne),
-                    Condition::Cs => dynasm!(self ; cset X(reg), cs),
-                    Condition::Cc => dynasm!(self ; cset X(reg), cc),
-                    Condition::Mi => dynasm!(self ; cset X(reg), mi),
-                    Condition::Pl => dynasm!(self ; cset X(reg), pl),
-                    Condition::Vs => dynasm!(self ; cset X(reg), vs),
-                    Condition::Vc => dynasm!(self ; cset X(reg), vc),
-                    Condition::Hi => dynasm!(self ; cset X(reg), hi),
-                    Condition::Ls => dynasm!(self ; cset X(reg), ls),
-                    Condition::Ge => dynasm!(self ; cset X(reg), ge),
-                    Condition::Lt => dynasm!(self ; cset X(reg), lt),
-                    Condition::Gt => dynasm!(self ; cset X(reg), gt),
-                    Condition::Le => dynasm!(self ; cset X(reg), le),
-                    Condition::Al => dynasm!(self ; cset X(reg), al),
-                }
-            }
+            (Size::S32, Location::GPR(reg)) => match cond {
+                Condition::Eq => dynasm!(self ; cset W(reg), eq),
+                Condition::Ne => dynasm!(self ; cset W(reg), ne),
+                Condition::Cs => dynasm!(self ; cset W(reg), cs),
+                Condition::Cc => dynasm!(self ; cset W(reg), cc),
+                Condition::Mi => dynasm!(self ; cset W(reg), mi),
+                Condition::Pl => dynasm!(self ; cset W(reg), pl),
+                Condition::Vs => dynasm!(self ; cset W(reg), vs),
+                Condition::Vc => dynasm!(self ; cset W(reg), vc),
+                Condition::Hi => dynasm!(self ; cset W(reg), hi),
+                Condition::Ls => dynasm!(self ; cset W(reg), ls),
+                Condition::Ge => dynasm!(self ; cset W(reg), ge),
+                Condition::Lt => dynasm!(self ; cset W(reg), lt),
+                Condition::Gt => dynasm!(self ; cset W(reg), gt),
+                Condition::Le => dynasm!(self ; cset W(reg), le),
+                Condition::Al => dynasm!(self ; cset W(reg), al),
+            },
+            (Size::S64, Location::GPR(reg)) => match cond {
+                Condition::Eq => dynasm!(self ; cset X(reg), eq),
+                Condition::Ne => dynasm!(self ; cset X(reg), ne),
+                Condition::Cs => dynasm!(self ; cset X(reg), cs),
+                Condition::Cc => dynasm!(self ; cset X(reg), cc),
+                Condition::Mi => dynasm!(self ; cset X(reg), mi),
+                Condition::Pl => dynasm!(self ; cset X(reg), pl),
+                Condition::Vs => dynasm!(self ; cset X(reg), vs),
+                Condition::Vc => dynasm!(self ; cset X(reg), vc),
+                Condition::Hi => dynasm!(self ; cset X(reg), hi),
+                Condition::Ls => dynasm!(self ; cset X(reg), ls),
+                Condition::Ge => dynasm!(self ; cset X(reg), ge),
+                Condition::Lt => dynasm!(self ; cset X(reg), lt),
+                Condition::Gt => dynasm!(self ; cset X(reg), gt),
+                Condition::Le => dynasm!(self ; cset X(reg), le),
+                Condition::Al => dynasm!(self ; cset X(reg), al),
+            },
             _ => codegen_error!("singlepass can't emit CSET {:?} {:?} {:?}", sz, dst, cond),
         }
         Ok(())
     }
     fn emit_csetm(&mut self, sz: Size, dst: Location, cond: Condition) -> Result<(), CompileError> {
         match (sz, dst) {
-            (Size::S32, Location::GPR(reg)) => {
-                let reg = reg as u32;
-                match cond {
-                    Condition::Eq => dynasm!(self ; csetm W(reg), eq),
-                    Condition::Ne => dynasm!(self ; csetm W(reg), ne),
-                    Condition::Cs => dynasm!(self ; csetm W(reg), cs),
-                    Condition::Cc => dynasm!(self ; csetm W(reg), cc),
-                    Condition::Mi => dynasm!(self ; csetm W(reg), mi),
-                    Condition::Pl => dynasm!(self ; csetm W(reg), pl),
-                    Condition::Vs => dynasm!(self ; csetm W(reg), vs),
-                    Condition::Vc => dynasm!(self ; csetm W(reg), vc),
-                    Condition::Hi => dynasm!(self ; csetm W(reg), hi),
-                    Condition::Ls => dynasm!(self ; csetm W(reg), ls),
-                    Condition::Ge => dynasm!(self ; csetm W(reg), ge),
-                    Condition::Lt => dynasm!(self ; csetm W(reg), lt),
-                    Condition::Gt => dynasm!(self ; csetm W(reg), gt),
-                    Condition::Le => dynasm!(self ; csetm W(reg), le),
-                    Condition::Al => dynasm!(self ; csetm W(reg), al),
-                }
-            }
-            (Size::S64, Location::GPR(reg)) => {
-                let reg = reg as u32;
-                match cond {
-                    Condition::Eq => dynasm!(self ; csetm X(reg), eq),
-                    Condition::Ne => dynasm!(self ; csetm X(reg), ne),
-                    Condition::Cs => dynasm!(self ; csetm X(reg), cs),
-                    Condition::Cc => dynasm!(self ; csetm X(reg), cc),
-                    Condition::Mi => dynasm!(self ; csetm X(reg), mi),
-                    Condition::Pl => dynasm!(self ; csetm X(reg), pl),
-                    Condition::Vs => dynasm!(self ; csetm X(reg), vs),
-                    Condition::Vc => dynasm!(self ; csetm X(reg), vc),
-                    Condition::Hi => dynasm!(self ; csetm X(reg), hi),
-                    Condition::Ls => dynasm!(self ; csetm X(reg), ls),
-                    Condition::Ge => dynasm!(self ; csetm X(reg), ge),
-                    Condition::Lt => dynasm!(self ; csetm X(reg), lt),
-                    Condition::Gt => dynasm!(self ; csetm X(reg), gt),
-                    Condition::Le => dynasm!(self ; csetm X(reg), le),
-                    Condition::Al => dynasm!(self ; csetm X(reg), al),
-                }
-            }
+            (Size::S32, Location::GPR(reg)) => match cond {
+                Condition::Eq => dynasm!(self ; csetm W(reg), eq),
+                Condition::Ne => dynasm!(self ; csetm W(reg), ne),
+                Condition::Cs => dynasm!(self ; csetm W(reg), cs),
+                Condition::Cc => dynasm!(self ; csetm W(reg), cc),
+                Condition::Mi => dynasm!(self ; csetm W(reg), mi),
+                Condition::Pl => dynasm!(self ; csetm W(reg), pl),
+                Condition::Vs => dynasm!(self ; csetm W(reg), vs),
+                Condition::Vc => dynasm!(self ; csetm W(reg), vc),
+                Condition::Hi => dynasm!(self ; csetm W(reg), hi),
+                Condition::Ls => dynasm!(self ; csetm W(reg), ls),
+                Condition::Ge => dynasm!(self ; csetm W(reg), ge),
+                Condition::Lt => dynasm!(self ; csetm W(reg), lt),
+                Condition::Gt => dynasm!(self ; csetm W(reg), gt),
+                Condition::Le => dynasm!(self ; csetm W(reg), le),
+                Condition::Al => dynasm!(self ; csetm W(reg), al),
+            },
+            (Size::S64, Location::GPR(reg)) => match cond {
+                Condition::Eq => dynasm!(self ; csetm X(reg), eq),
+                Condition::Ne => dynasm!(self ; csetm X(reg), ne),
+                Condition::Cs => dynasm!(self ; csetm X(reg), cs),
+                Condition::Cc => dynasm!(self ; csetm X(reg), cc),
+                Condition::Mi => dynasm!(self ; csetm X(reg), mi),
+                Condition::Pl => dynasm!(self ; csetm X(reg), pl),
+                Condition::Vs => dynasm!(self ; csetm X(reg), vs),
+                Condition::Vc => dynasm!(self ; csetm X(reg), vc),
+                Condition::Hi => dynasm!(self ; csetm X(reg), hi),
+                Condition::Ls => dynasm!(self ; csetm X(reg), ls),
+                Condition::Ge => dynasm!(self ; csetm X(reg), ge),
+                Condition::Lt => dynasm!(self ; csetm X(reg), lt),
+                Condition::Gt => dynasm!(self ; csetm X(reg), gt),
+                Condition::Le => dynasm!(self ; csetm X(reg), le),
+                Condition::Al => dynasm!(self ; csetm X(reg), al),
+            },
             _ => codegen_error!("singlepass can't emit CSETM {:?} {:?} {:?}", sz, dst, cond),
         }
         Ok(())
@@ -2482,8 +2115,6 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src, dst) {
             (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 match cond {
                     Condition::Eq => dynasm!(self ; cinc W(dst), W(src), eq),
                     Condition::Ne => dynasm!(self ; cinc W(dst), W(src), ne),
@@ -2503,8 +2134,6 @@ impl EmitterARM64 for Assembler {
                 };
             }
             (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 match cond {
                     Condition::Eq => dynasm!(self ; cinc X(src), X(dst), eq),
                     Condition::Ne => dynasm!(self ; cinc X(src), X(dst), ne),
@@ -2531,13 +2160,9 @@ impl EmitterARM64 for Assembler {
     fn emit_clz(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
         match (sz, src, dst) {
             (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; clz X(dst), X(src));
             }
             (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; clz W(dst), W(src));
             }
             _ => codegen_error!("singlepass can't emit CLS {:?} {:?} {:?}", sz, src, dst),
@@ -2547,13 +2172,9 @@ impl EmitterARM64 for Assembler {
     fn emit_rbit(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
         match (sz, src, dst) {
             (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; rbit X(dst), X(src));
             }
             (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; rbit W(dst), W(src));
             }
             _ => codegen_error!("singlepass can't emit CLS {:?} {:?} {:?}", sz, src, dst),
@@ -2566,7 +2187,6 @@ impl EmitterARM64 for Assembler {
         Ok(())
     }
     fn emit_load_label(&mut self, reg: GPR, label: Label) -> Result<(), CompileError> {
-        let reg = reg.into_index() as u32;
         dynasm!(self ; adr X(reg), =>label);
         Ok(())
     }
@@ -2583,11 +2203,9 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, reg) {
             (Size::S32, Location::GPR(reg)) => {
-                let reg = reg.into_index() as u32;
                 dynasm!(self ; cbz W(reg), =>label);
             }
             (Size::S64, Location::GPR(reg)) => {
-                let reg = reg.into_index() as u32;
                 dynasm!(self ; cbz X(reg), =>label);
             }
             _ => codegen_error!("singlepass can't emit CBZ {:?} {:?} {:?}", sz, reg, label),
@@ -2602,11 +2220,9 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, reg) {
             (Size::S32, Location::GPR(reg)) => {
-                let reg = reg.into_index() as u32;
                 dynasm!(self ; cbnz W(reg), =>label);
             }
             (Size::S64, Location::GPR(reg)) => {
-                let reg = reg.into_index() as u32;
                 dynasm!(self ; cbnz X(reg), =>label);
             }
             _ => codegen_error!("singlepass can't emit CBNZ {:?} {:?} {:?}", sz, reg, label),
@@ -2624,13 +2240,10 @@ impl EmitterARM64 for Assembler {
 
         match (sz, reg) {
             (Size::S32, Location::GPR(reg)) => {
-                let reg = reg.into_index() as u32;
-
                 dynasm!(self ; cbz W(reg), => near_label);
                 dynasm!(self ; b => continue_label);
             }
             (Size::S64, Location::GPR(reg)) => {
-                let reg = reg.into_index() as u32;
                 dynasm!(self ; cbz X(reg), => near_label);
                 dynasm!(self ; b => continue_label);
             }
@@ -2652,11 +2265,9 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, reg) {
             (Size::S32, Location::GPR(reg)) => {
-                let reg = reg.into_index() as u32;
                 dynasm!(self ; tbz W(reg), n, =>label);
             }
             (Size::S64, Location::GPR(reg)) => {
-                let reg = reg.into_index() as u32;
                 dynasm!(self ; tbz X(reg), n, =>label);
             }
             _ => codegen_error!(
@@ -2678,11 +2289,9 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, reg) {
             (Size::S32, Location::GPR(reg)) => {
-                let reg = reg.into_index() as u32;
                 dynasm!(self ; tbnz W(reg), n, =>label);
             }
             (Size::S64, Location::GPR(reg)) => {
-                let reg = reg.into_index() as u32;
                 dynasm!(self ; tbnz X(reg), n, =>label);
             }
             _ => codegen_error!(
@@ -2744,7 +2353,7 @@ impl EmitterARM64 for Assembler {
         Ok(())
     }
     fn emit_b_register(&mut self, reg: GPR) -> Result<(), CompileError> {
-        dynasm!(self ; br X(reg.into_index() as u32));
+        dynasm!(self ; br X(reg));
         Ok(())
     }
     fn emit_call_label(&mut self, label: Label) -> Result<(), CompileError> {
@@ -2752,7 +2361,7 @@ impl EmitterARM64 for Assembler {
         Ok(())
     }
     fn emit_call_register(&mut self, reg: GPR) -> Result<(), CompileError> {
-        dynasm!(self ; blr X(reg.into_index() as u32));
+        dynasm!(self ; blr X(reg));
         Ok(())
     }
     fn emit_ret(&mut self) -> Result<(), CompileError> {
@@ -2761,7 +2370,7 @@ impl EmitterARM64 for Assembler {
     }
 
     fn emit_udf(&mut self, payload: u16) -> Result<(), CompileError> {
-        dynasm!(self ; udf (payload as u32));
+        dynasm!(self ; udf payload as u32);
         Ok(())
     }
     fn emit_dmb(&mut self) -> Result<(), CompileError> {
@@ -2776,13 +2385,9 @@ impl EmitterARM64 for Assembler {
     fn emit_fcmp(&mut self, sz: Size, src1: Location, src2: Location) -> Result<(), CompileError> {
         match (sz, src1, src2) {
             (Size::S32, Location::SIMD(src1), Location::SIMD(src2)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
                 dynasm!(self ; fcmp S(src1), S(src2));
             }
             (Size::S64, Location::SIMD(src1), Location::SIMD(src2)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
                 dynasm!(self ; fcmp D(src1), D(src2));
             }
             _ => codegen_error!("singlepass can't emit FCMP {:?} {:?} {:?}", sz, src1, src2),
@@ -2793,13 +2398,9 @@ impl EmitterARM64 for Assembler {
     fn emit_fneg(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
         match (sz, src, dst) {
             (Size::S32, Location::SIMD(src), Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fneg S(dst), S(src));
             }
             (Size::S64, Location::SIMD(src), Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fneg D(dst), D(src));
             }
             _ => codegen_error!("singlepass can't emit FNEG {:?} {:?} {:?}", sz, src, dst),
@@ -2809,13 +2410,9 @@ impl EmitterARM64 for Assembler {
     fn emit_fsqrt(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
         match (sz, src, dst) {
             (Size::S32, Location::SIMD(src), Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fsqrt S(dst), S(src));
             }
             (Size::S64, Location::SIMD(src), Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fsqrt D(dst), D(src));
             }
             _ => codegen_error!("singlepass can't emit FSQRT {:?} {:?} {:?}", sz, src, dst),
@@ -2832,15 +2429,9 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src1, src2, dst) {
             (Size::S32, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fadd S(dst), S(src1), S(src2));
             }
             (Size::S64, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fadd D(dst), D(src1), D(src2));
             }
             _ => codegen_error!(
@@ -2862,15 +2453,9 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src1, src2, dst) {
             (Size::S32, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fsub S(dst), S(src1), S(src2));
             }
             (Size::S64, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fsub D(dst), D(src1), D(src2));
             }
             _ => codegen_error!(
@@ -2892,15 +2477,9 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src1, src2, dst) {
             (Size::S32, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fmul S(dst), S(src1), S(src2));
             }
             (Size::S64, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fmul D(dst), D(src1), D(src2));
             }
             _ => codegen_error!(
@@ -2922,15 +2501,9 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src1, src2, dst) {
             (Size::S32, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fdiv S(dst), S(src1), S(src2));
             }
             (Size::S64, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fdiv D(dst), D(src1), D(src2));
             }
             _ => codegen_error!(
@@ -2953,15 +2526,9 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src1, src2, dst) {
             (Size::S32, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fmin S(dst), S(src1), S(src2));
             }
             (Size::S64, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fmin D(dst), D(src1), D(src2));
             }
             _ => codegen_error!(
@@ -2983,15 +2550,9 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz, src1, src2, dst) {
             (Size::S32, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fmax S(dst), S(src1), S(src2));
             }
             (Size::S64, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
-                let src1 = src1.into_index() as u32;
-                let src2 = src2.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fmax D(dst), D(src1), D(src2));
             }
             _ => codegen_error!(
@@ -3008,13 +2569,9 @@ impl EmitterARM64 for Assembler {
     fn emit_frintz(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
         match (sz, src, dst) {
             (Size::S32, Location::SIMD(src), Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; frintz S(dst), S(src));
             }
             (Size::S64, Location::SIMD(src), Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; frintz D(dst), D(src));
             }
             _ => codegen_error!("singlepass can't emit FRINTZ {:?} {:?} {:?}", sz, src, dst),
@@ -3024,13 +2581,9 @@ impl EmitterARM64 for Assembler {
     fn emit_frintn(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
         match (sz, src, dst) {
             (Size::S32, Location::SIMD(src), Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; frintn S(dst), S(src));
             }
             (Size::S64, Location::SIMD(src), Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; frintn D(dst), D(src));
             }
             _ => codegen_error!("singlepass can't emit FRINTN {:?} {:?} {:?}", sz, src, dst),
@@ -3040,13 +2593,9 @@ impl EmitterARM64 for Assembler {
     fn emit_frintm(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
         match (sz, src, dst) {
             (Size::S32, Location::SIMD(src), Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; frintm S(dst), S(src));
             }
             (Size::S64, Location::SIMD(src), Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; frintm D(dst), D(src));
             }
             _ => codegen_error!("singlepass can't emit FRINTM {:?} {:?} {:?}", sz, src, dst),
@@ -3056,13 +2605,9 @@ impl EmitterARM64 for Assembler {
     fn emit_frintp(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
         match (sz, src, dst) {
             (Size::S32, Location::SIMD(src), Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; frintp S(dst), S(src));
             }
             (Size::S64, Location::SIMD(src), Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; frintp D(dst), D(src));
             }
             _ => codegen_error!("singlepass can't emit FRINTP {:?} {:?} {:?}", sz, src, dst),
@@ -3079,23 +2624,15 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz_in, src, sz_out, dst) {
             (Size::S32, Location::GPR(src), Size::S32, Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; scvtf S(dst), W(src));
             }
             (Size::S64, Location::GPR(src), Size::S32, Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; scvtf S(dst), X(src));
             }
             (Size::S32, Location::GPR(src), Size::S64, Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; scvtf D(dst), W(src));
             }
             (Size::S64, Location::GPR(src), Size::S64, Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; scvtf D(dst), X(src));
             }
             _ => codegen_error!(
@@ -3117,23 +2654,15 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz_in, src, sz_out, dst) {
             (Size::S32, Location::GPR(src), Size::S32, Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; ucvtf S(dst), W(src));
             }
             (Size::S64, Location::GPR(src), Size::S32, Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; ucvtf S(dst), X(src));
             }
             (Size::S32, Location::GPR(src), Size::S64, Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; ucvtf D(dst), W(src));
             }
             (Size::S64, Location::GPR(src), Size::S64, Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; ucvtf D(dst), X(src));
             }
             _ => codegen_error!(
@@ -3149,13 +2678,9 @@ impl EmitterARM64 for Assembler {
     fn emit_fcvt(&mut self, sz_in: Size, src: Location, dst: Location) -> Result<(), CompileError> {
         match (sz_in, src, dst) {
             (Size::S32, Location::SIMD(src), Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fcvt D(dst), S(src));
             }
             (Size::S64, Location::SIMD(src), Location::SIMD(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fcvt S(dst), D(src));
             }
             _ => codegen_error!(
@@ -3176,23 +2701,15 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz_in, src, sz_out, dst) {
             (Size::S32, Location::SIMD(src), Size::S32, Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fcvtzs W(dst), S(src));
             }
             (Size::S64, Location::SIMD(src), Size::S32, Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fcvtzs W(dst), D(src));
             }
             (Size::S32, Location::SIMD(src), Size::S64, Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fcvtzs X(dst), S(src));
             }
             (Size::S64, Location::SIMD(src), Size::S64, Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fcvtzs X(dst), D(src));
             }
             _ => codegen_error!(
@@ -3214,23 +2731,15 @@ impl EmitterARM64 for Assembler {
     ) -> Result<(), CompileError> {
         match (sz_in, src, sz_out, dst) {
             (Size::S32, Location::SIMD(src), Size::S32, Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fcvtzu W(dst), S(src));
             }
             (Size::S64, Location::SIMD(src), Size::S32, Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fcvtzu W(dst), D(src));
             }
             (Size::S32, Location::SIMD(src), Size::S64, Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fcvtzu X(dst), S(src));
             }
             (Size::S64, Location::SIMD(src), Size::S64, Location::GPR(dst)) => {
-                let src = src.into_index() as u32;
-                let dst = dst.into_index() as u32;
                 dynasm!(self ; fcvtzu X(dst), D(src));
             }
             _ => codegen_error!(
@@ -3246,33 +2755,34 @@ impl EmitterARM64 for Assembler {
 
     // 1 011 0100 0100 000 => fpcr
     fn emit_read_fpcr(&mut self, reg: GPR) -> Result<(), CompileError> {
-        dynasm!(self ; mrs X(reg as u32), 0b1_011_0100_0100_000);
+        dynasm!(self ; mrs X(reg), 0b1_011_0100_0100_000);
         Ok(())
     }
     fn emit_write_fpcr(&mut self, reg: GPR) -> Result<(), CompileError> {
-        dynasm!(self ; msr 0b1_011_0100_0100_000, X(reg as u32));
+        dynasm!(self ; msr 0b1_011_0100_0100_000, X(reg));
         Ok(())
     }
     // 1 011 0100 0100 001 => fpsr
     fn emit_read_fpsr(&mut self, reg: GPR) -> Result<(), CompileError> {
-        dynasm!(self ; mrs X(reg as u32), 0b1_011_0100_0100_001);
+        dynasm!(self ; mrs X(reg), 0b1_011_0100_0100_001);
         Ok(())
     }
     fn emit_write_fpsr(&mut self, reg: GPR) -> Result<(), CompileError> {
-        dynasm!(self ; msr 0b1_011_0100_0100_001, X(reg as u32));
+        dynasm!(self ; msr 0b1_011_0100_0100_001, X(reg));
         Ok(())
     }
 
     fn emit_cnt(&mut self, src: NEON, dst: NEON) -> Result<(), CompileError> {
-        dynasm!(self ; cnt V(dst.into_index() as u32).B8, V(src.into_index() as u32).B8);
+        dynasm!(self ; cnt V(dst).B8, V(src).B8);
         Ok(())
     }
 
     fn emit_addv(&mut self, src: NEON, dst: NEON) -> Result<(), CompileError> {
-        dynasm!(self ; addv B(dst.into_index() as u32), V(src.into_index() as u32).B8);
+        dynasm!(self ; addv B(dst), V(src).B8);
         Ok(())
     }
 
+    #[allow(clippy::unit_arg)]
     fn emit_fmov(
         &mut self,
         src_size: Size,
@@ -3280,37 +2790,44 @@ impl EmitterARM64 for Assembler {
         dst_size: Size,
         dst: Location,
     ) -> Result<(), CompileError> {
-        let res = match (src, dst) {
+        let mut err = false;
+        match (src, dst) {
             (AbstractLocation::GPR(src), AbstractLocation::SIMD(dst)) => {
                 match (src_size, dst_size) {
-                    (Size::S32, Size::S32) => Ok(dynasm!(self ; fmov S(dst as u32), W(src as u32))),
-                    (Size::S64, Size::S64) => Ok(dynasm!(self ; fmov D(dst as u32), X(src as u32))),
-                    _ => Err(()),
+                    (Size::S32, Size::S32) => dynasm!(self ; fmov S(dst), W(src)),
+                    (Size::S64, Size::S64) => dynasm!(self ; fmov D(dst), X(src)),
+                    _ => {
+                        err = true;
+                    }
                 }
             }
             (AbstractLocation::SIMD(src), AbstractLocation::GPR(dst)) => {
                 match (src_size, dst_size) {
-                    (Size::S32, Size::S32) => Ok(dynasm!(self ; fmov W(dst as u32), S(src as u32))),
-                    (Size::S64, Size::S64) => Ok(dynasm!(self ; fmov X(dst as u32), D(src as u32))),
-                    _ => Err(()),
+                    (Size::S32, Size::S32) => dynasm!(self ; fmov W(dst), S(src)),
+                    (Size::S64, Size::S64) => dynasm!(self ; fmov X(dst), D(src)),
+                    _ => {
+                        err = true;
+                    }
                 }
             }
             // (AbstractLocation::SIMD(src), AbstractLocation::SIMD(dst)) => todo!(),
             // (AbstractLocation::SIMD(src), AbstractLocation::Imm32(dst)) => todo!(),
             // (AbstractLocation::SIMD(src), AbstractLocation::Imm64(dst)) => todo!(),
-            _ => Err(()),
+            _ => {
+                err = true;
+            }
         };
 
-        match res {
-            Ok(_) => Ok(()),
-            Err(_) => codegen_error!(
+        if err {
+            codegen_error!(
                 "singlepass can't generate fmov instruction for src_size: {:?}, src: {:?}, dst_size: {:?}, dst: {:?}",
                 src_size,
                 src,
                 dst_size,
                 dst,
-            ),
+            )
         }
+        Ok(())
     }
 }
 
@@ -3326,10 +2843,10 @@ pub fn gen_std_trampoline_arm64(
     dynasm!(a
         ; sub sp, sp, 32
         ; stp x29, x30, [sp]
-        ; stp X(fptr as u32), X(args as u32), [sp, 16]
+        ; stp X(fptr), X(args), [sp, 16]
         ; mov x29, sp
-        ; mov X(fptr as u32), x1
-        ; mov X(args as u32), x2
+        ; mov X(fptr), x1
+        ; mov X(args), x2
     );
 
     let stack_args = sig.params().len().saturating_sub(7); //1st arg is ctx, not an actual arg
@@ -3411,7 +2928,7 @@ pub fn gen_std_trampoline_arm64(
         }
     }
 
-    dynasm!(a  ; blr X(fptr as u32));
+    dynasm!(a  ; blr X(fptr));
 
     // Write return value.
     if !sig.results().is_empty() {
@@ -3420,7 +2937,7 @@ pub fn gen_std_trampoline_arm64(
 
     // Restore stack.
     dynasm!(a
-        ; ldp X(fptr as u32), X(args as u32), [x29, 16]
+        ; ldp X(fptr), X(args), [x29, 16]
         ; ldp x29, x30, [x29]
         ; add sp, sp, 32 + stack_offset as u32
         ; ret
@@ -3478,7 +2995,7 @@ pub fn gen_std_dynamic_import_trampoline_arm64(
         let mut stack_param_count: usize = 0;
 
         for (i, ty) in sig.params().iter().enumerate() {
-            let source_loc = match argalloc.next(*ty, calling_convention) {
+            let source_loc = match argalloc.next(*ty, calling_convention)? {
                 Some(ARM64Register::GPR(gpr)) => Location::GPR(gpr),
                 Some(ARM64Register::NEON(neon)) => Location::SIMD(neon),
                 None => {
@@ -3672,7 +3189,7 @@ pub fn gen_import_call_trampoline_arm64(
                 argalloc.next(Type::I64, calling_convention).unwrap(); // skip VMContext
                 for (i, ty) in sig.params().iter().enumerate() {
                     let prev_loc = param_locations[i];
-                    let targ = match argalloc.next(*ty, calling_convention) {
+                    let targ = match argalloc.next(*ty, calling_convention)? {
                         Some(ARM64Register::GPR(gpr)) => Location::GPR(gpr),
                         Some(ARM64Register::NEON(neon)) => Location::SIMD(neon),
                         None => {
@@ -3770,6 +3287,7 @@ pub fn gen_import_call_trampoline_arm64(
 
     Ok(CustomSection {
         protection: CustomSectionProtection::ReadExecute,
+        alignment: None,
         bytes: section_body,
         relocations: vec![],
     })
diff --git a/lib/compiler-singlepass/src/emitter_x64.rs b/lib/compiler-singlepass/src/emitter_x64.rs
index 13ac3b4daf..4624525f37 100644
--- a/lib/compiler-singlepass/src/emitter_x64.rs
+++ b/lib/compiler-singlepass/src/emitter_x64.rs
@@ -1,13 +1,15 @@
-use crate::codegen_error;
-use crate::common_decl::Size;
-use crate::location::Location as AbstractLocation;
-pub use crate::location::Multiplier;
-pub use crate::machine::{Label, Offset};
-use crate::machine_x64::AssemblerX64;
-pub use crate::x64_decl::{GPR, XMM};
+use crate::{
+    codegen_error, common_decl::Size, location::Location as AbstractLocation,
+    machine_x64::AssemblerX64,
+};
+pub use crate::{
+    location::Multiplier,
+    machine::{Label, Offset},
+    x64_decl::{GPR, XMM},
+};
 use dynasm::dynasm;
 use dynasmrt::{AssemblyOffset, DynamicLabel, DynasmApi, DynasmLabelApi};
-use wasmer_types::{CompileError, CpuFeature};
+use wasmer_types::{target::CpuFeature, CompileError};
 
 /// Force `dynasm!` to use the correct arch (x64) when cross-compiling.
 /// `dynasm!` proc-macro tries to auto-detect it by default by looking at the
@@ -61,6 +63,7 @@ pub enum Precision {
     Double,
 }
 
+#[allow(unused)]
 pub trait EmitterX64 {
     fn get_simd_arch(&self) -> Option<&CpuFeature>;
     fn get_label(&mut self) -> Label;
@@ -473,10 +476,10 @@ macro_rules! unop_gpr {
     ($ins:ident, $assembler:tt, $sz:expr, $loc:expr, $otherwise:block) => {
         match ($sz, $loc) {
             (Size::S32, Location::GPR(loc)) => {
-                dynasm!($assembler ; $ins Rd(loc as u8));
+                dynasm!($assembler ; $ins Rd(loc));
             },
             (Size::S64, Location::GPR(loc)) => {
-                dynasm!($assembler ; $ins Rq(loc as u8));
+                dynasm!($assembler ; $ins Rq(loc));
             },
             _ => $otherwise
         }
@@ -487,10 +490,10 @@ macro_rules! unop_mem {
     ($ins:ident, $assembler:tt, $sz:expr, $loc:expr, $otherwise:block) => {
         match ($sz, $loc) {
             (Size::S32, Location::Memory(loc, disp)) => {
-                dynasm!($assembler ; $ins DWORD [Rq(loc as u8) + disp] );
+                dynasm!($assembler ; $ins DWORD [Rq(loc) + disp] );
             },
             (Size::S64, Location::Memory(loc, disp)) => {
-                dynasm!($assembler ; $ins QWORD [Rq(loc as u8) + disp] );
+                dynasm!($assembler ; $ins QWORD [Rq(loc) + disp] );
             },
             _ => $otherwise
         }
@@ -509,10 +512,10 @@ macro_rules! binop_imm32_gpr {
     ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
         match ($sz, $src, $dst) {
             (Size::S32, Location::Imm32(src), Location::GPR(dst)) => {
-                dynasm!($assembler ; $ins Rd(dst as u8), src as i32); // IMM32_2GPR
+                dynasm!($assembler ; $ins Rd(dst), src as i32); // IMM32_2GPR
             },
             (Size::S64, Location::Imm32(src), Location::GPR(dst)) => {
-                dynasm!($assembler ; $ins Rq(dst as u8), src as i32); // IMM32_2GPR
+                dynasm!($assembler ; $ins Rq(dst), src as i32); // IMM32_2GPR
             },
             _ => $otherwise
         }
@@ -523,10 +526,10 @@ macro_rules! binop_imm32_mem {
     ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
         match ($sz, $src, $dst) {
             (Size::S32, Location::Imm32(src), Location::Memory(dst, disp)) => {
-                dynasm!($assembler ; $ins DWORD [Rq(dst as u8) + disp], src as i32);
+                dynasm!($assembler ; $ins DWORD [Rq(dst) + disp], src as i32);
             },
             (Size::S64, Location::Imm32(src), Location::Memory(dst, disp)) => {
-                dynasm!($assembler ; $ins QWORD [Rq(dst as u8) + disp], src as i32);
+                dynasm!($assembler ; $ins QWORD [Rq(dst) + disp], src as i32);
             },
             _ => $otherwise
         }
@@ -537,7 +540,7 @@ macro_rules! binop_imm64_gpr {
     ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
         match ($sz, $src, $dst) {
             (Size::S64, Location::Imm64(src), Location::GPR(dst)) => {
-                dynasm!($assembler ; $ins Rq(dst as u8), QWORD src as i64); // IMM32_2GPR
+                dynasm!($assembler ; $ins Rq(dst), QWORD src as i64); // IMM32_2GPR
             },
             _ => $otherwise
         }
@@ -548,10 +551,10 @@ macro_rules! binop_gpr_gpr {
     ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
         match ($sz, $src, $dst) {
             (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
-                dynasm!($assembler ; $ins Rd(dst as u8), Rd(src as u8)); // GPR2GPR
+                dynasm!($assembler ; $ins Rd(dst), Rd(src)); // GPR2GPR
             },
             (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
-                dynasm!($assembler ; $ins Rq(dst as u8), Rq(src as u8)); // GPR2GPR
+                dynasm!($assembler ; $ins Rq(dst), Rq(src)); // GPR2GPR
             },
             _ => $otherwise
         }
@@ -562,10 +565,10 @@ macro_rules! binop_gpr_mem {
     ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
         match ($sz, $src, $dst) {
             (Size::S32, Location::GPR(src), Location::Memory(dst, disp)) => {
-                dynasm!($assembler ; $ins [Rq(dst as u8) + disp], Rd(src as u8)); // GPR2MEM
+                dynasm!($assembler ; $ins [Rq(dst) + disp], Rd(src)); // GPR2MEM
             },
             (Size::S64, Location::GPR(src), Location::Memory(dst, disp)) => {
-                dynasm!($assembler ; $ins [Rq(dst as u8) + disp], Rq(src as u8)); // GPR2MEM
+                dynasm!($assembler ; $ins [Rq(dst) + disp], Rq(src)); // GPR2MEM
             },
             _ => $otherwise
         }
@@ -576,10 +579,10 @@ macro_rules! binop_mem_gpr {
     ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
         match ($sz, $src, $dst) {
             (Size::S32, Location::Memory(src, disp), Location::GPR(dst)) => {
-                dynasm!($assembler ; $ins Rd(dst as u8), [Rq(src as u8) + disp]); // MEM2GPR
+                dynasm!($assembler ; $ins Rd(dst), [Rq(src) + disp]); // MEM2GPR
             },
             (Size::S64, Location::Memory(src, disp), Location::GPR(dst)) => {
-                dynasm!($assembler ; $ins Rq(dst as u8), [Rq(src as u8) + disp]); // MEM2GPR
+                dynasm!($assembler ; $ins Rq(dst), [Rq(src) + disp]); // MEM2GPR
             },
             _ => $otherwise
         }
@@ -604,28 +607,28 @@ macro_rules! binop_shift {
     ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
         match ($sz, $src, $dst) {
             (Size::S32, Location::GPR(GPR::RCX), Location::GPR(dst)) => {
-                dynasm!($assembler ; $ins Rd(dst as u8), cl);
+                dynasm!($assembler ; $ins Rd(dst), cl);
             },
             (Size::S32, Location::GPR(GPR::RCX), Location::Memory(dst, disp)) => {
-                dynasm!($assembler ; $ins DWORD [Rq(dst as u8) + disp], cl);
+                dynasm!($assembler ; $ins DWORD [Rq(dst) + disp], cl);
             },
             (Size::S32, Location::Imm8(imm), Location::GPR(dst)) => {
-                dynasm!($assembler ; $ins Rd(dst as u8), imm as i8);
+                dynasm!($assembler ; $ins Rd(dst), imm as i8);
             },
             (Size::S32, Location::Imm8(imm), Location::Memory(dst, disp)) => {
-                dynasm!($assembler ; $ins DWORD [Rq(dst as u8) + disp], imm as i8);
+                dynasm!($assembler ; $ins DWORD [Rq(dst) + disp], imm as i8);
             },
             (Size::S64, Location::GPR(GPR::RCX), Location::GPR(dst)) => {
-                dynasm!($assembler ; $ins Rq(dst as u8), cl);
+                dynasm!($assembler ; $ins Rq(dst), cl);
             },
             (Size::S64, Location::GPR(GPR::RCX), Location::Memory(dst, disp)) => {
-                dynasm!($assembler ; $ins QWORD [Rq(dst as u8) + disp], cl);
+                dynasm!($assembler ; $ins QWORD [Rq(dst) + disp], cl);
             },
             (Size::S64, Location::Imm8(imm), Location::GPR(dst)) => {
-                dynasm!($assembler ; $ins Rq(dst as u8), imm as i8);
+                dynasm!($assembler ; $ins Rq(dst), imm as i8);
             },
             (Size::S64, Location::Imm8(imm), Location::Memory(dst, disp)) => {
-                dynasm!($assembler ; $ins QWORD [Rq(dst as u8) + disp], imm as i8);
+                dynasm!($assembler ; $ins QWORD [Rq(dst) + disp], imm as i8);
             },
             _ => $otherwise
         }
@@ -650,40 +653,40 @@ fn move_src_to_dst(emitter: &mut AssemblerX64, precision: Precision, src: XMM, d
     }
     match precision {
         Precision::Single => match src {
-            XMM::XMM0 => dynasm!(emitter ; movss Rx((dst as u8)), xmm0),
-            XMM::XMM1 => dynasm!(emitter ; movss Rx((dst as u8)), xmm1),
-            XMM::XMM2 => dynasm!(emitter ; movss Rx((dst as u8)), xmm2),
-            XMM::XMM3 => dynasm!(emitter ; movss Rx((dst as u8)), xmm3),
-            XMM::XMM4 => dynasm!(emitter ; movss Rx((dst as u8)), xmm4),
-            XMM::XMM5 => dynasm!(emitter ; movss Rx((dst as u8)), xmm5),
-            XMM::XMM6 => dynasm!(emitter ; movss Rx((dst as u8)), xmm6),
-            XMM::XMM7 => dynasm!(emitter ; movss Rx((dst as u8)), xmm7),
-            XMM::XMM8 => dynasm!(emitter ; movss Rx((dst as u8)), xmm8),
-            XMM::XMM9 => dynasm!(emitter ; movss Rx((dst as u8)), xmm9),
-            XMM::XMM10 => dynasm!(emitter ; movss Rx((dst as u8)), xmm10),
-            XMM::XMM11 => dynasm!(emitter ; movss Rx((dst as u8)), xmm11),
-            XMM::XMM12 => dynasm!(emitter ; movss Rx((dst as u8)), xmm12),
-            XMM::XMM13 => dynasm!(emitter ; movss Rx((dst as u8)), xmm13),
-            XMM::XMM14 => dynasm!(emitter ; movss Rx((dst as u8)), xmm14),
-            XMM::XMM15 => dynasm!(emitter ; movss Rx((dst as u8)), xmm15),
+            XMM::XMM0 => dynasm!(emitter ; movss Rx(dst), xmm0),
+            XMM::XMM1 => dynasm!(emitter ; movss Rx(dst), xmm1),
+            XMM::XMM2 => dynasm!(emitter ; movss Rx(dst), xmm2),
+            XMM::XMM3 => dynasm!(emitter ; movss Rx(dst), xmm3),
+            XMM::XMM4 => dynasm!(emitter ; movss Rx(dst), xmm4),
+            XMM::XMM5 => dynasm!(emitter ; movss Rx(dst), xmm5),
+            XMM::XMM6 => dynasm!(emitter ; movss Rx(dst), xmm6),
+            XMM::XMM7 => dynasm!(emitter ; movss Rx(dst), xmm7),
+            XMM::XMM8 => dynasm!(emitter ; movss Rx(dst), xmm8),
+            XMM::XMM9 => dynasm!(emitter ; movss Rx(dst), xmm9),
+            XMM::XMM10 => dynasm!(emitter ; movss Rx(dst), xmm10),
+            XMM::XMM11 => dynasm!(emitter ; movss Rx(dst), xmm11),
+            XMM::XMM12 => dynasm!(emitter ; movss Rx(dst), xmm12),
+            XMM::XMM13 => dynasm!(emitter ; movss Rx(dst), xmm13),
+            XMM::XMM14 => dynasm!(emitter ; movss Rx(dst), xmm14),
+            XMM::XMM15 => dynasm!(emitter ; movss Rx(dst), xmm15),
         },
         Precision::Double => match src {
-            XMM::XMM0 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm0),
-            XMM::XMM1 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm1),
-            XMM::XMM2 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm2),
-            XMM::XMM3 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm3),
-            XMM::XMM4 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm4),
-            XMM::XMM5 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm5),
-            XMM::XMM6 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm6),
-            XMM::XMM7 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm7),
-            XMM::XMM8 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm8),
-            XMM::XMM9 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm9),
-            XMM::XMM10 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm10),
-            XMM::XMM11 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm11),
-            XMM::XMM12 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm12),
-            XMM::XMM13 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm13),
-            XMM::XMM14 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm14),
-            XMM::XMM15 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm15),
+            XMM::XMM0 => dynasm!(emitter ; movsd Rx(dst), xmm0),
+            XMM::XMM1 => dynasm!(emitter ; movsd Rx(dst), xmm1),
+            XMM::XMM2 => dynasm!(emitter ; movsd Rx(dst), xmm2),
+            XMM::XMM3 => dynasm!(emitter ; movsd Rx(dst), xmm3),
+            XMM::XMM4 => dynasm!(emitter ; movsd Rx(dst), xmm4),
+            XMM::XMM5 => dynasm!(emitter ; movsd Rx(dst), xmm5),
+            XMM::XMM6 => dynasm!(emitter ; movsd Rx(dst), xmm6),
+            XMM::XMM7 => dynasm!(emitter ; movsd Rx(dst), xmm7),
+            XMM::XMM8 => dynasm!(emitter ; movsd Rx(dst), xmm8),
+            XMM::XMM9 => dynasm!(emitter ; movsd Rx(dst), xmm9),
+            XMM::XMM10 => dynasm!(emitter ; movsd Rx(dst), xmm10),
+            XMM::XMM11 => dynasm!(emitter ; movsd Rx(dst), xmm11),
+            XMM::XMM12 => dynasm!(emitter ; movsd Rx(dst), xmm12),
+            XMM::XMM13 => dynasm!(emitter ; movsd Rx(dst), xmm13),
+            XMM::XMM14 => dynasm!(emitter ; movsd Rx(dst), xmm14),
+            XMM::XMM15 => dynasm!(emitter ; movsd Rx(dst), xmm15),
         },
     }
 }
@@ -693,40 +696,40 @@ macro_rules! avx_fn {
         // Dynasm bug: AVX instructions are not encoded correctly.
         match $src2 {
             XMMOrMemory::XMM(x) => match $src1 {
-                XMM::XMM0 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm0, Rx((x as u8))),
-                XMM::XMM1 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm1, Rx((x as u8))),
-                XMM::XMM2 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm2, Rx((x as u8))),
-                XMM::XMM4 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm4, Rx((x as u8))),
-                XMM::XMM3 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm3, Rx((x as u8))),
-                XMM::XMM5 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm5, Rx((x as u8))),
-                XMM::XMM6 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm6, Rx((x as u8))),
-                XMM::XMM7 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm7, Rx((x as u8))),
-                XMM::XMM8 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm8, Rx((x as u8))),
-                XMM::XMM9 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm9, Rx((x as u8))),
-                XMM::XMM10 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm10, Rx((x as u8))),
-                XMM::XMM11 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm11, Rx((x as u8))),
-                XMM::XMM12 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm12, Rx((x as u8))),
-                XMM::XMM13 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm13, Rx((x as u8))),
-                XMM::XMM14 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm14, Rx((x as u8))),
-                XMM::XMM15 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm15, Rx((x as u8))),
+                XMM::XMM0 => dynasm!($emitter ; $ins Rx($dst), xmm0, Rx(x)),
+                XMM::XMM1 => dynasm!($emitter ; $ins Rx($dst), xmm1, Rx(x)),
+                XMM::XMM2 => dynasm!($emitter ; $ins Rx($dst), xmm2, Rx(x)),
+                XMM::XMM4 => dynasm!($emitter ; $ins Rx($dst), xmm4, Rx(x)),
+                XMM::XMM3 => dynasm!($emitter ; $ins Rx($dst), xmm3, Rx(x)),
+                XMM::XMM5 => dynasm!($emitter ; $ins Rx($dst), xmm5, Rx(x)),
+                XMM::XMM6 => dynasm!($emitter ; $ins Rx($dst), xmm6, Rx(x)),
+                XMM::XMM7 => dynasm!($emitter ; $ins Rx($dst), xmm7, Rx(x)),
+                XMM::XMM8 => dynasm!($emitter ; $ins Rx($dst), xmm8, Rx(x)),
+                XMM::XMM9 => dynasm!($emitter ; $ins Rx($dst), xmm9, Rx(x)),
+                XMM::XMM10 => dynasm!($emitter ; $ins Rx($dst), xmm10, Rx(x)),
+                XMM::XMM11 => dynasm!($emitter ; $ins Rx($dst), xmm11, Rx(x)),
+                XMM::XMM12 => dynasm!($emitter ; $ins Rx($dst), xmm12, Rx(x)),
+                XMM::XMM13 => dynasm!($emitter ; $ins Rx($dst), xmm13, Rx(x)),
+                XMM::XMM14 => dynasm!($emitter ; $ins Rx($dst), xmm14, Rx(x)),
+                XMM::XMM15 => dynasm!($emitter ; $ins Rx($dst), xmm15, Rx(x)),
             },
             XMMOrMemory::Memory(base, disp) => match $src1 {
-                XMM::XMM0 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm0, [Rq((base as u8)) + disp]),
-                XMM::XMM1 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm1, [Rq((base as u8)) + disp]),
-                XMM::XMM2 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm2, [Rq((base as u8)) + disp]),
-                XMM::XMM3 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm3, [Rq((base as u8)) + disp]),
-                XMM::XMM4 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm4, [Rq((base as u8)) + disp]),
-                XMM::XMM5 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm5, [Rq((base as u8)) + disp]),
-                XMM::XMM6 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm6, [Rq((base as u8)) + disp]),
-                XMM::XMM7 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm7, [Rq((base as u8)) + disp]),
-                XMM::XMM8 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm8, [Rq((base as u8)) + disp]),
-                XMM::XMM9 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm9, [Rq((base as u8)) + disp]),
-                XMM::XMM10 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm10, [Rq((base as u8)) + disp]),
-                XMM::XMM11 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm11, [Rq((base as u8)) + disp]),
-                XMM::XMM12 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm12, [Rq((base as u8)) + disp]),
-                XMM::XMM13 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm13, [Rq((base as u8)) + disp]),
-                XMM::XMM14 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm14, [Rq((base as u8)) + disp]),
-                XMM::XMM15 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm15, [Rq((base as u8)) + disp]),
+                XMM::XMM0 => dynasm!($emitter ; $ins Rx($dst), xmm0, [Rq(base) + disp]),
+                XMM::XMM1 => dynasm!($emitter ; $ins Rx($dst), xmm1, [Rq(base) + disp]),
+                XMM::XMM2 => dynasm!($emitter ; $ins Rx($dst), xmm2, [Rq(base) + disp]),
+                XMM::XMM3 => dynasm!($emitter ; $ins Rx($dst), xmm3, [Rq(base) + disp]),
+                XMM::XMM4 => dynasm!($emitter ; $ins Rx($dst), xmm4, [Rq(base) + disp]),
+                XMM::XMM5 => dynasm!($emitter ; $ins Rx($dst), xmm5, [Rq(base) + disp]),
+                XMM::XMM6 => dynasm!($emitter ; $ins Rx($dst), xmm6, [Rq(base) + disp]),
+                XMM::XMM7 => dynasm!($emitter ; $ins Rx($dst), xmm7, [Rq(base) + disp]),
+                XMM::XMM8 => dynasm!($emitter ; $ins Rx($dst), xmm8, [Rq(base) + disp]),
+                XMM::XMM9 => dynasm!($emitter ; $ins Rx($dst), xmm9, [Rq(base) + disp]),
+                XMM::XMM10 => dynasm!($emitter ; $ins Rx($dst), xmm10, [Rq(base) + disp]),
+                XMM::XMM11 => dynasm!($emitter ; $ins Rx($dst), xmm11, [Rq(base) + disp]),
+                XMM::XMM12 => dynasm!($emitter ; $ins Rx($dst), xmm12, [Rq(base) + disp]),
+                XMM::XMM13 => dynasm!($emitter ; $ins Rx($dst), xmm13, [Rq(base) + disp]),
+                XMM::XMM14 => dynasm!($emitter ; $ins Rx($dst), xmm14, [Rq(base) + disp]),
+                XMM::XMM15 => dynasm!($emitter ; $ins Rx($dst), xmm15, [Rq(base) + disp]),
             },
         }
     }
@@ -737,15 +740,15 @@ macro_rules! sse_fn {
         match $src2 {
             XMMOrMemory::XMM(x) => {
                 if x == $dst {
-                    dynasm!($emitter ; $ins Rx(($dst as u8)), Rx(($src1 as u8)))
+                    dynasm!($emitter ; $ins Rx($dst), Rx($src1))
                 } else {
                     move_src_to_dst($emitter, $precision, $src1, $dst);
-                    dynasm!($emitter ; $ins Rx(($dst as u8)), Rx((x as u8)))
+                    dynasm!($emitter ; $ins Rx($dst), Rx(x))
                 }
             }
             XMMOrMemory::Memory(base, disp) => {
                 move_src_to_dst($emitter, $precision, $src1, $dst);
-                dynasm!($emitter ; $ins Rx(($dst as u8)), [Rq((base as u8)) + disp])
+                dynasm!($emitter ; $ins Rx($dst), [Rq(base) + disp])
             }
         }
     };
@@ -753,11 +756,11 @@ macro_rules! sse_fn {
         match $src2 {
             XMMOrMemory::XMM(x) => {
                 move_src_to_dst($emitter, $precision, $src1, $dst);
-                dynasm!($emitter ; $ins Rx(($dst as u8)), Rx((x as u8)), $mode)
+                dynasm!($emitter ; $ins Rx($dst), Rx(x), $mode)
             }
             XMMOrMemory::Memory(base, disp) => {
                 move_src_to_dst($emitter, $precision, $src1, $dst);
-                dynasm!($emitter ; $ins Rx(($dst as u8)), [Rq((base as u8)) + disp], $mode)
+                dynasm!($emitter ; $ins Rx($dst), [Rq(base) + disp], $mode)
             }
         }
     };
@@ -767,40 +770,40 @@ macro_rules! avx_i2f_64_fn {
     ($ins:ident, $emitter:ident, $src1:ident, $src2:ident, $dst:ident) => {
         match $src2 {
             GPROrMemory::GPR(x) => match $src1 {
-                XMM::XMM0 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm0, Rq((x as u8))),
-                XMM::XMM1 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm1, Rq((x as u8))),
-                XMM::XMM2 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm2, Rq((x as u8))),
-                XMM::XMM3 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm3, Rq((x as u8))),
-                XMM::XMM4 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm4, Rq((x as u8))),
-                XMM::XMM5 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm5, Rq((x as u8))),
-                XMM::XMM6 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm6, Rq((x as u8))),
-                XMM::XMM7 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm7, Rq((x as u8))),
-                XMM::XMM8 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm8, Rq((x as u8))),
-                XMM::XMM9 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm9, Rq((x as u8))),
-                XMM::XMM10 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm10, Rq((x as u8))),
-                XMM::XMM11 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm11, Rq((x as u8))),
-                XMM::XMM12 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm12, Rq((x as u8))),
-                XMM::XMM13 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm13, Rq((x as u8))),
-                XMM::XMM14 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm14, Rq((x as u8))),
-                XMM::XMM15 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm15, Rq((x as u8))),
+                XMM::XMM0 => dynasm!($emitter ; $ins Rx($dst), xmm0, Rq(x)),
+                XMM::XMM1 => dynasm!($emitter ; $ins Rx($dst), xmm1, Rq(x)),
+                XMM::XMM2 => dynasm!($emitter ; $ins Rx($dst), xmm2, Rq(x)),
+                XMM::XMM3 => dynasm!($emitter ; $ins Rx($dst), xmm3, Rq(x)),
+                XMM::XMM4 => dynasm!($emitter ; $ins Rx($dst), xmm4, Rq(x)),
+                XMM::XMM5 => dynasm!($emitter ; $ins Rx($dst), xmm5, Rq(x)),
+                XMM::XMM6 => dynasm!($emitter ; $ins Rx($dst), xmm6, Rq(x)),
+                XMM::XMM7 => dynasm!($emitter ; $ins Rx($dst), xmm7, Rq(x)),
+                XMM::XMM8 => dynasm!($emitter ; $ins Rx($dst), xmm8, Rq(x)),
+                XMM::XMM9 => dynasm!($emitter ; $ins Rx($dst), xmm9, Rq(x)),
+                XMM::XMM10 => dynasm!($emitter ; $ins Rx($dst), xmm10, Rq(x)),
+                XMM::XMM11 => dynasm!($emitter ; $ins Rx($dst), xmm11, Rq(x)),
+                XMM::XMM12 => dynasm!($emitter ; $ins Rx($dst), xmm12, Rq(x)),
+                XMM::XMM13 => dynasm!($emitter ; $ins Rx($dst), xmm13, Rq(x)),
+                XMM::XMM14 => dynasm!($emitter ; $ins Rx($dst), xmm14, Rq(x)),
+                XMM::XMM15 => dynasm!($emitter ; $ins Rx($dst), xmm15, Rq(x)),
             },
             GPROrMemory::Memory(base, disp) => match $src1 {
-                XMM::XMM0 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm0, QWORD [Rq((base as u8)) + disp]),
-                XMM::XMM1 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm1, QWORD [Rq((base as u8)) + disp]),
-                XMM::XMM2 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm2, QWORD [Rq((base as u8)) + disp]),
-                XMM::XMM3 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm3, QWORD [Rq((base as u8)) + disp]),
-                XMM::XMM4 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm4, QWORD [Rq((base as u8)) + disp]),
-                XMM::XMM5 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm5, QWORD [Rq((base as u8)) + disp]),
-                XMM::XMM6 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm6, QWORD [Rq((base as u8)) + disp]),
-                XMM::XMM7 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm7, QWORD [Rq((base as u8)) + disp]),
-                XMM::XMM8 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm8, QWORD [Rq((base as u8)) + disp]),
-                XMM::XMM9 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm9, QWORD [Rq((base as u8)) + disp]),
-                XMM::XMM10 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm10, QWORD [Rq((base as u8)) + disp]),
-                XMM::XMM11 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm11, QWORD [Rq((base as u8)) + disp]),
-                XMM::XMM12 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm12, QWORD [Rq((base as u8)) + disp]),
-                XMM::XMM13 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm13, QWORD [Rq((base as u8)) + disp]),
-                XMM::XMM14 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm14, QWORD [Rq((base as u8)) + disp]),
-                XMM::XMM15 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm15, QWORD [Rq((base as u8)) + disp]),
+                XMM::XMM0 => dynasm!($emitter ; $ins Rx($dst), xmm0, QWORD [Rq(base) + disp]),
+                XMM::XMM1 => dynasm!($emitter ; $ins Rx($dst), xmm1, QWORD [Rq(base) + disp]),
+                XMM::XMM2 => dynasm!($emitter ; $ins Rx($dst), xmm2, QWORD [Rq(base) + disp]),
+                XMM::XMM3 => dynasm!($emitter ; $ins Rx($dst), xmm3, QWORD [Rq(base) + disp]),
+                XMM::XMM4 => dynasm!($emitter ; $ins Rx($dst), xmm4, QWORD [Rq(base) + disp]),
+                XMM::XMM5 => dynasm!($emitter ; $ins Rx($dst), xmm5, QWORD [Rq(base) + disp]),
+                XMM::XMM6 => dynasm!($emitter ; $ins Rx($dst), xmm6, QWORD [Rq(base) + disp]),
+                XMM::XMM7 => dynasm!($emitter ; $ins Rx($dst), xmm7, QWORD [Rq(base) + disp]),
+                XMM::XMM8 => dynasm!($emitter ; $ins Rx($dst), xmm8, QWORD [Rq(base) + disp]),
+                XMM::XMM9 => dynasm!($emitter ; $ins Rx($dst), xmm9, QWORD [Rq(base) + disp]),
+                XMM::XMM10 => dynasm!($emitter ; $ins Rx($dst), xmm10, QWORD [Rq(base) + disp]),
+                XMM::XMM11 => dynasm!($emitter ; $ins Rx($dst), xmm11, QWORD [Rq(base) + disp]),
+                XMM::XMM12 => dynasm!($emitter ; $ins Rx($dst), xmm12, QWORD [Rq(base) + disp]),
+                XMM::XMM13 => dynasm!($emitter ; $ins Rx($dst), xmm13, QWORD [Rq(base) + disp]),
+                XMM::XMM14 => dynasm!($emitter ; $ins Rx($dst), xmm14, QWORD [Rq(base) + disp]),
+                XMM::XMM15 => dynasm!($emitter ; $ins Rx($dst), xmm15, QWORD [Rq(base) + disp]),
             },
         }
     }
@@ -811,11 +814,11 @@ macro_rules! sse_i2f_64_fn {
         match $src2 {
             GPROrMemory::GPR(x) => {
                 move_src_to_dst($emitter, $precision, $src1, $dst);
-                dynasm!($emitter ; $ins Rx(($dst as u8)), Rq((x as u8)))
+                dynasm!($emitter ; $ins Rx($dst), Rq(x))
             },
             GPROrMemory::Memory(base, disp) => {
                 move_src_to_dst($emitter, $precision, $src1, $dst);
-                dynasm!($emitter ; $ins Rx(($dst as u8)), QWORD [Rq((base as u8)) + disp])
+                dynasm!($emitter ; $ins Rx($dst), QWORD [Rq(base) + disp])
             }
         }
     }
@@ -825,40 +828,40 @@ macro_rules! avx_i2f_32_fn {
     ($ins:ident, $emitter:ident, $src1:ident, $src2:ident, $dst:ident) => {
         match $src2 {
             GPROrMemory::GPR(x) => match $src1 {
-                XMM::XMM0 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm0, Rd((x as u8))),
-                XMM::XMM1 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm1, Rd((x as u8))),
-                XMM::XMM2 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm2, Rd((x as u8))),
-                XMM::XMM3 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm3, Rd((x as u8))),
-                XMM::XMM4 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm4, Rd((x as u8))),
-                XMM::XMM5 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm5, Rd((x as u8))),
-                XMM::XMM6 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm6, Rd((x as u8))),
-                XMM::XMM7 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm7, Rd((x as u8))),
-                XMM::XMM8 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm8, Rd((x as u8))),
-                XMM::XMM9 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm9, Rd((x as u8))),
-                XMM::XMM10 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm10, Rd((x as u8))),
-                XMM::XMM11 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm11, Rd((x as u8))),
-                XMM::XMM12 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm12, Rd((x as u8))),
-                XMM::XMM13 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm13, Rd((x as u8))),
-                XMM::XMM14 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm14, Rd((x as u8))),
-                XMM::XMM15 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm15, Rd((x as u8))),
+                XMM::XMM0 => dynasm!($emitter ; $ins Rx($dst), xmm0, Rd(x)),
+                XMM::XMM1 => dynasm!($emitter ; $ins Rx($dst), xmm1, Rd(x)),
+                XMM::XMM2 => dynasm!($emitter ; $ins Rx($dst), xmm2, Rd(x)),
+                XMM::XMM3 => dynasm!($emitter ; $ins Rx($dst), xmm3, Rd(x)),
+                XMM::XMM4 => dynasm!($emitter ; $ins Rx($dst), xmm4, Rd(x)),
+                XMM::XMM5 => dynasm!($emitter ; $ins Rx($dst), xmm5, Rd(x)),
+                XMM::XMM6 => dynasm!($emitter ; $ins Rx($dst), xmm6, Rd(x)),
+                XMM::XMM7 => dynasm!($emitter ; $ins Rx($dst), xmm7, Rd(x)),
+                XMM::XMM8 => dynasm!($emitter ; $ins Rx($dst), xmm8, Rd(x)),
+                XMM::XMM9 => dynasm!($emitter ; $ins Rx($dst), xmm9, Rd(x)),
+                XMM::XMM10 => dynasm!($emitter ; $ins Rx($dst), xmm10, Rd(x)),
+                XMM::XMM11 => dynasm!($emitter ; $ins Rx($dst), xmm11, Rd(x)),
+                XMM::XMM12 => dynasm!($emitter ; $ins Rx($dst), xmm12, Rd(x)),
+                XMM::XMM13 => dynasm!($emitter ; $ins Rx($dst), xmm13, Rd(x)),
+                XMM::XMM14 => dynasm!($emitter ; $ins Rx($dst), xmm14, Rd(x)),
+                XMM::XMM15 => dynasm!($emitter ; $ins Rx($dst), xmm15, Rd(x)),
             },
             GPROrMemory::Memory(base, disp) => match $src1 {
-                XMM::XMM0 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm0, DWORD [Rq((base as u8)) + disp]),
-                XMM::XMM1 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm1, DWORD [Rq((base as u8)) + disp]),
-                XMM::XMM2 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm2, DWORD [Rq((base as u8)) + disp]),
-                XMM::XMM3 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm3, DWORD [Rq((base as u8)) + disp]),
-                XMM::XMM4 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm4, DWORD [Rq((base as u8)) + disp]),
-                XMM::XMM5 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm5, DWORD [Rq((base as u8)) + disp]),
-                XMM::XMM6 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm6, DWORD [Rq((base as u8)) + disp]),
-                XMM::XMM7 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm7, DWORD [Rq((base as u8)) + disp]),
-                XMM::XMM8 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm8, DWORD [Rq((base as u8)) + disp]),
-                XMM::XMM9 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm9, DWORD [Rq((base as u8)) + disp]),
-                XMM::XMM10 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm10, DWORD [Rq((base as u8)) + disp]),
-                XMM::XMM11 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm11, DWORD [Rq((base as u8)) + disp]),
-                XMM::XMM12 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm12, DWORD [Rq((base as u8)) + disp]),
-                XMM::XMM13 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm13, DWORD [Rq((base as u8)) + disp]),
-                XMM::XMM14 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm14, DWORD [Rq((base as u8)) + disp]),
-                XMM::XMM15 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm15, DWORD [Rq((base as u8)) + disp]),
+                XMM::XMM0 => dynasm!($emitter ; $ins Rx($dst), xmm0, DWORD [Rq(base) + disp]),
+                XMM::XMM1 => dynasm!($emitter ; $ins Rx($dst), xmm1, DWORD [Rq(base) + disp]),
+                XMM::XMM2 => dynasm!($emitter ; $ins Rx($dst), xmm2, DWORD [Rq(base) + disp]),
+                XMM::XMM3 => dynasm!($emitter ; $ins Rx($dst), xmm3, DWORD [Rq(base) + disp]),
+                XMM::XMM4 => dynasm!($emitter ; $ins Rx($dst), xmm4, DWORD [Rq(base) + disp]),
+                XMM::XMM5 => dynasm!($emitter ; $ins Rx($dst), xmm5, DWORD [Rq(base) + disp]),
+                XMM::XMM6 => dynasm!($emitter ; $ins Rx($dst), xmm6, DWORD [Rq(base) + disp]),
+                XMM::XMM7 => dynasm!($emitter ; $ins Rx($dst), xmm7, DWORD [Rq(base) + disp]),
+                XMM::XMM8 => dynasm!($emitter ; $ins Rx($dst), xmm8, DWORD [Rq(base) + disp]),
+                XMM::XMM9 => dynasm!($emitter ; $ins Rx($dst), xmm9, DWORD [Rq(base) + disp]),
+                XMM::XMM10 => dynasm!($emitter ; $ins Rx($dst), xmm10, DWORD [Rq(base) + disp]),
+                XMM::XMM11 => dynasm!($emitter ; $ins Rx($dst), xmm11, DWORD [Rq(base) + disp]),
+                XMM::XMM12 => dynasm!($emitter ; $ins Rx($dst), xmm12, DWORD [Rq(base) + disp]),
+                XMM::XMM13 => dynasm!($emitter ; $ins Rx($dst), xmm13, DWORD [Rq(base) + disp]),
+                XMM::XMM14 => dynasm!($emitter ; $ins Rx($dst), xmm14, DWORD [Rq(base) + disp]),
+                XMM::XMM15 => dynasm!($emitter ; $ins Rx($dst), xmm15, DWORD [Rq(base) + disp]),
             },
         }
     }
@@ -869,11 +872,11 @@ macro_rules! sse_i2f_32_fn {
         match $src2 {
             GPROrMemory::GPR(x) => {
                 move_src_to_dst($emitter, $precision, $src1, $dst);
-                dynasm!($emitter; $ins Rx(($src1 as u8)), Rd((x as u8)))
+                dynasm!($emitter; $ins Rx($src1), Rd(x))
             },
             GPROrMemory::Memory(base, disp) => {
                 move_src_to_dst($emitter, $precision, $src1, $dst);
-                dynasm!($emitter; $ins Rx(($dst as u8)), DWORD [Rq((base as u8)) + disp])
+                dynasm!($emitter; $ins Rx($dst), DWORD [Rq(base) + disp])
             }
         }
     }
@@ -882,8 +885,8 @@ macro_rules! sse_i2f_32_fn {
 macro_rules! avx_round_fn {
     ($ins:ident, $mode:expr, $emitter:ident, $src1:ident, $src2:ident, $dst:ident) => {
         match $src2 {
-            XMMOrMemory::XMM(x) => dynasm!($emitter ; $ins Rx(($dst as u8)), Rx(($src1 as u8)), Rx((x as u8)), $mode),
-            XMMOrMemory::Memory(base, disp) => dynasm!($emitter ; $ins Rx(($dst as u8)), Rx(($src1 as u8)), [Rq((base as u8)) + disp], $mode),
+            XMMOrMemory::XMM(x) => dynasm!($emitter ; $ins Rx($dst), Rx($src1), Rx(x), $mode),
+            XMMOrMemory::Memory(base, disp) => dynasm!($emitter ; $ins Rx($dst), Rx($src1), [Rq(base) + disp], $mode),
         }
     }
 }
@@ -895,10 +898,10 @@ macro_rules! sse_round_fn {
                 if x != $dst {
                     move_src_to_dst($emitter, $precision, $src1, $dst);
                 }
-                dynasm!($emitter ; $ins Rx((x as u8)), Rx(($dst as u8)), $mode)
+                dynasm!($emitter ; $ins Rx(x), Rx($dst), $mode)
             }
             XMMOrMemory::Memory(base, disp) => {
-                dynasm!($emitter ; $ins Rx(($dst as u8)), [Rq((base as u8)) + disp], $mode)
+                dynasm!($emitter ; $ins Rx($dst), [Rq(base) + disp], $mode)
             },
         }
     }
@@ -925,11 +928,11 @@ impl EmitterX64 for AssemblerX64 {
         dynasm!(
             self
             ; const_neg_one_32:
-            ; .dword -1
+            ; .i32 -1
             ; const_zero_32:
-            ; .dword 0
+            ; .i32  0
             ; const_pos_one_32:
-            ; .dword 1
+            ; .i32 1
         );
         Ok(())
     }
@@ -1029,7 +1032,7 @@ impl EmitterX64 for AssemblerX64 {
     fn emit_mov(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
         // fast path
         if let (Location::Imm32(0), Location::GPR(x)) = (src, dst) {
-            dynasm!(self ; xor Rd(x as u8), Rd(x as u8));
+            dynasm!(self ; xor Rd(x), Rd(x));
             return Ok(());
         }
 
@@ -1037,83 +1040,83 @@ impl EmitterX64 for AssemblerX64 {
             binop_imm64_gpr!(mov, self, sz, src, dst, {
                 match (sz, src, dst) {
                     (Size::S8, Location::GPR(src), Location::Memory(dst, disp)) => {
-                        dynasm!(self ; mov [Rq(dst as u8) + disp], Rb(src as u8));
+                        dynasm!(self ; mov [Rq(dst) + disp], Rb(src));
                     }
                     (Size::S8, Location::Memory(src, disp), Location::GPR(dst)) => {
-                        dynasm!(self ; mov Rb(dst as u8), [Rq(src as u8) + disp]);
+                        dynasm!(self ; mov Rb(dst), [Rq(src) + disp]);
                     }
                     (Size::S8, Location::Imm32(src), Location::GPR(dst)) => {
-                        dynasm!(self ; mov Rb(dst as u8), src as i8);
+                        dynasm!(self ; mov Rb(dst), src as i8);
                     }
                     (Size::S8, Location::Imm64(src), Location::GPR(dst)) => {
-                        dynasm!(self ; mov Rb(dst as u8), src as i8);
+                        dynasm!(self ; mov Rb(dst), src as i8);
                     }
                     (Size::S8, Location::Imm32(src), Location::Memory(dst, disp)) => {
-                        dynasm!(self ; mov BYTE [Rq(dst as u8) + disp], src as i8);
+                        dynasm!(self ; mov BYTE [Rq(dst) + disp], src as i8);
                     }
                     (Size::S8, Location::Imm64(src), Location::Memory(dst, disp)) => {
-                        dynasm!(self ; mov BYTE [Rq(dst as u8) + disp], src as i8);
+                        dynasm!(self ; mov BYTE [Rq(dst) + disp], src as i8);
                     }
                     (Size::S16, Location::GPR(src), Location::Memory(dst, disp)) => {
-                        dynasm!(self ; mov [Rq(dst as u8) + disp], Rw(src as u8));
+                        dynasm!(self ; mov [Rq(dst) + disp], Rw(src));
                     }
                     (Size::S16, Location::Memory(src, disp), Location::GPR(dst)) => {
-                        dynasm!(self ; mov Rw(dst as u8), [Rq(src as u8) + disp]);
+                        dynasm!(self ; mov Rw(dst), [Rq(src) + disp]);
                     }
                     (Size::S16, Location::Imm32(src), Location::GPR(dst)) => {
-                        dynasm!(self ; mov Rw(dst as u8), src as i16);
+                        dynasm!(self ; mov Rw(dst), src as i16);
                     }
                     (Size::S16, Location::Imm64(src), Location::GPR(dst)) => {
-                        dynasm!(self ; mov Rw(dst as u8), src as i16);
+                        dynasm!(self ; mov Rw(dst), src as i16);
                     }
                     (Size::S16, Location::Imm32(src), Location::Memory(dst, disp)) => {
-                        dynasm!(self ; mov WORD [Rq(dst as u8) + disp], src as i16);
+                        dynasm!(self ; mov WORD [Rq(dst) + disp], src as i16);
                     }
                     (Size::S16, Location::Imm64(src), Location::Memory(dst, disp)) => {
-                        dynasm!(self ; mov WORD [Rq(dst as u8) + disp], src as i16);
+                        dynasm!(self ; mov WORD [Rq(dst) + disp], src as i16);
                     }
                     (Size::S32, Location::Imm64(src), Location::GPR(dst)) => {
-                        dynasm!(self ; mov Rd(dst as u8), src as i32);
+                        dynasm!(self ; mov Rd(dst), src as i32);
                     }
                     (Size::S32, Location::Imm64(src), Location::Memory(dst, disp)) => {
-                        dynasm!(self ; mov DWORD [Rq(dst as u8) + disp], src as i32);
+                        dynasm!(self ; mov DWORD [Rq(dst) + disp], src as i32);
                     }
                     (Size::S32, Location::GPR(src), Location::SIMD(dst)) => {
-                        dynasm!(self ; movd Rx(dst as u8), Rd(src as u8));
+                        dynasm!(self ; movd Rx(dst), Rd(src));
                     }
                     (Size::S32, Location::SIMD(src), Location::GPR(dst)) => {
-                        dynasm!(self ; movd Rd(dst as u8), Rx(src as u8));
+                        dynasm!(self ; movd Rd(dst), Rx(src));
                     }
                     (Size::S32, Location::Memory(src, disp), Location::SIMD(dst)) => {
-                        dynasm!(self ; movd Rx(dst as u8), [Rq(src as u8) + disp]);
+                        dynasm!(self ; movd Rx(dst), [Rq(src) + disp]);
                     }
                     (Size::S32, Location::SIMD(src), Location::Memory(dst, disp)) => {
-                        dynasm!(self ; movd [Rq(dst as u8) + disp], Rx(src as u8));
+                        dynasm!(self ; movd [Rq(dst) + disp], Rx(src));
                     }
                     (Size::S64, Location::Imm64(src), Location::GPR(dst)) => {
-                        dynasm!(self ; mov Rd(dst as u8), src as i32);
+                        dynasm!(self ; mov Rd(dst), src as i32);
                     }
                     (Size::S64, Location::Imm32(src), Location::GPR(dst)) => {
-                        dynasm!(self ; mov Rd(dst as u8), src as i32);
+                        dynasm!(self ; mov Rd(dst), src as i32);
                     }
                     (Size::S64, Location::Imm8(src), Location::GPR(dst)) => {
-                        dynasm!(self ; mov Rd(dst as u8), src as i32);
+                        dynasm!(self ; mov Rd(dst), src as i32);
                     }
 
                     (Size::S64, Location::GPR(src), Location::SIMD(dst)) => {
-                        dynasm!(self ; movq Rx(dst as u8), Rq(src as u8));
+                        dynasm!(self ; movq Rx(dst), Rq(src));
                     }
                     (Size::S64, Location::SIMD(src), Location::GPR(dst)) => {
-                        dynasm!(self ; movq Rq(dst as u8), Rx(src as u8));
+                        dynasm!(self ; movq Rq(dst), Rx(src));
                     }
                     (Size::S64, Location::Memory(src, disp), Location::SIMD(dst)) => {
-                        dynasm!(self ; movq Rx(dst as u8), [Rq(src as u8) + disp]);
+                        dynasm!(self ; movq Rx(dst), [Rq(src) + disp]);
                     }
                     (Size::S64, Location::SIMD(src), Location::Memory(dst, disp)) => {
-                        dynasm!(self ; movq [Rq(dst as u8) + disp], Rx(src as u8));
+                        dynasm!(self ; movq [Rq(dst) + disp], Rx(src));
                     }
                     (_, Location::SIMD(src), Location::SIMD(dst)) => {
-                        dynasm!(self ; movq Rx(dst as u8), Rx(src as u8));
+                        dynasm!(self ; movq Rx(dst), Rx(src));
                     }
 
                     _ => codegen_error!("singlepass can't emit MOV {:?} {:?} {:?}", sz, src, dst),
@@ -1125,42 +1128,42 @@ impl EmitterX64 for AssemblerX64 {
     fn emit_lea(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
         match (sz, src, dst) {
             (Size::S32, Location::Memory(src, disp), Location::GPR(dst)) => {
-                dynasm!(self ; lea Rd(dst as u8), [Rq(src as u8) + disp]);
+                dynasm!(self ; lea Rd(dst), [Rq(src) + disp]);
             }
             (Size::S64, Location::Memory(src, disp), Location::GPR(dst)) => {
-                dynasm!(self ; lea Rq(dst as u8), [Rq(src as u8) + disp]);
+                dynasm!(self ; lea Rq(dst), [Rq(src) + disp]);
             }
             (Size::S32, Location::Memory2(src1, src2, mult, disp), Location::GPR(dst)) => {
                 match mult {
-                    Multiplier::Zero => dynasm!(self ; lea Rd(dst as u8), [Rq(src1 as u8) + disp]),
+                    Multiplier::Zero => dynasm!(self ; lea Rd(dst), [Rq(src1) + disp]),
                     Multiplier::One => {
-                        dynasm!(self ; lea Rd(dst as u8), [Rq(src1 as u8) + Rq(src2 as u8) + disp])
+                        dynasm!(self ; lea Rd(dst), [Rq(src1) + Rq(src2) + disp])
                     }
                     Multiplier::Two => {
-                        dynasm!(self ; lea Rd(dst as u8), [Rq(src1 as u8) + Rq(src2 as u8) * 2 + disp])
+                        dynasm!(self ; lea Rd(dst), [Rq(src1) + Rq(src2) * 2 + disp])
                     }
                     Multiplier::Four => {
-                        dynasm!(self ; lea Rd(dst as u8), [Rq(src1 as u8) + Rq(src2 as u8) * 4 + disp])
+                        dynasm!(self ; lea Rd(dst), [Rq(src1) + Rq(src2) * 4 + disp])
                     }
                     Multiplier::Height => {
-                        dynasm!(self ; lea Rd(dst as u8), [Rq(src1 as u8) + Rq(src2 as u8) * 8 + disp])
+                        dynasm!(self ; lea Rd(dst), [Rq(src1) + Rq(src2) * 8 + disp])
                     }
                 };
             }
             (Size::S64, Location::Memory2(src1, src2, mult, disp), Location::GPR(dst)) => {
                 match mult {
-                    Multiplier::Zero => dynasm!(self ; lea Rq(dst as u8), [Rq(src1 as u8) + disp]),
+                    Multiplier::Zero => dynasm!(self ; lea Rq(dst), [Rq(src1) + disp]),
                     Multiplier::One => {
-                        dynasm!(self ; lea Rq(dst as u8), [Rq(src1 as u8) + Rq(src2 as u8) + disp])
+                        dynasm!(self ; lea Rq(dst), [Rq(src1) + Rq(src2) + disp])
                     }
                     Multiplier::Two => {
-                        dynasm!(self ; lea Rq(dst as u8), [Rq(src1 as u8) + Rq(src2 as u8) * 2 + disp])
+                        dynasm!(self ; lea Rq(dst), [Rq(src1) + Rq(src2) * 2 + disp])
                     }
                     Multiplier::Four => {
-                        dynasm!(self ; lea Rq(dst as u8), [Rq(src1 as u8) + Rq(src2 as u8) * 4 + disp])
+                        dynasm!(self ; lea Rq(dst), [Rq(src1) + Rq(src2) * 4 + disp])
                     }
                     Multiplier::Height => {
-                        dynasm!(self ; lea Rq(dst as u8), [Rq(src1 as u8) + Rq(src2 as u8) * 8 + disp])
+                        dynasm!(self ; lea Rq(dst), [Rq(src1) + Rq(src2) * 8 + disp])
                     }
                 };
             }
@@ -1171,7 +1174,7 @@ impl EmitterX64 for AssemblerX64 {
     fn emit_lea_label(&mut self, label: Label, dst: Location) -> Result<(), CompileError> {
         match dst {
             Location::GPR(x) => {
-                dynasm!(self ; lea Rq(x as u8), [=>label]);
+                dynasm!(self ; lea Rq(x), [=>label]);
             }
             _ => codegen_error!("singlepass can't emit LEA label={:?} {:?}", label, dst),
         }
@@ -1211,26 +1214,26 @@ impl EmitterX64 for AssemblerX64 {
     }
     fn emit_jmp_location(&mut self, loc: Location) -> Result<(), CompileError> {
         match loc {
-            Location::GPR(x) => dynasm!(self ; jmp Rq(x as u8)),
-            Location::Memory(base, disp) => dynasm!(self ; jmp QWORD [Rq(base as u8) + disp]),
+            Location::GPR(x) => dynasm!(self ; jmp Rq(x)),
+            Location::Memory(base, disp) => dynasm!(self ; jmp QWORD [Rq(base) + disp]),
             _ => codegen_error!("singlepass can't emit JMP {:?}", loc),
         }
         Ok(())
     }
     fn emit_set(&mut self, condition: Condition, dst: GPR) -> Result<(), CompileError> {
         match condition {
-            Condition::Above => dynasm!(self ; seta Rb(dst as u8)),
-            Condition::AboveEqual => dynasm!(self ; setae Rb(dst as u8)),
-            Condition::Below => dynasm!(self ; setb Rb(dst as u8)),
-            Condition::BelowEqual => dynasm!(self ; setbe Rb(dst as u8)),
-            Condition::Greater => dynasm!(self ; setg Rb(dst as u8)),
-            Condition::GreaterEqual => dynasm!(self ; setge Rb(dst as u8)),
-            Condition::Less => dynasm!(self ; setl Rb(dst as u8)),
-            Condition::LessEqual => dynasm!(self ; setle Rb(dst as u8)),
-            Condition::Equal => dynasm!(self ; sete Rb(dst as u8)),
-            Condition::NotEqual => dynasm!(self ; setne Rb(dst as u8)),
-            Condition::Signed => dynasm!(self ; sets Rb(dst as u8)),
-            Condition::Carry => dynasm!(self ; setc Rb(dst as u8)),
+            Condition::Above => dynasm!(self ; seta Rb(dst)),
+            Condition::AboveEqual => dynasm!(self ; setae Rb(dst)),
+            Condition::Below => dynasm!(self ; setb Rb(dst)),
+            Condition::BelowEqual => dynasm!(self ; setbe Rb(dst)),
+            Condition::Greater => dynasm!(self ; setg Rb(dst)),
+            Condition::GreaterEqual => dynasm!(self ; setge Rb(dst)),
+            Condition::Less => dynasm!(self ; setl Rb(dst)),
+            Condition::LessEqual => dynasm!(self ; setle Rb(dst)),
+            Condition::Equal => dynasm!(self ; sete Rb(dst)),
+            Condition::NotEqual => dynasm!(self ; setne Rb(dst)),
+            Condition::Signed => dynasm!(self ; sets Rb(dst)),
+            Condition::Carry => dynasm!(self ; setc Rb(dst)),
             _ => codegen_error!("singlepass can't emit SET {:?} {:?}", condition, dst),
         }
         Ok(())
@@ -1238,9 +1241,9 @@ impl EmitterX64 for AssemblerX64 {
     fn emit_push(&mut self, sz: Size, src: Location) -> Result<(), CompileError> {
         match (sz, src) {
             (Size::S64, Location::Imm32(src)) => dynasm!(self ; push src as i32),
-            (Size::S64, Location::GPR(src)) => dynasm!(self ; push Rq(src as u8)),
+            (Size::S64, Location::GPR(src)) => dynasm!(self ; push Rq(src)),
             (Size::S64, Location::Memory(src, disp)) => {
-                dynasm!(self ; push QWORD [Rq(src as u8) + disp])
+                dynasm!(self ; push QWORD [Rq(src) + disp])
             }
             _ => codegen_error!("singlepass can't emit PUSH {:?} {:?}", sz, src),
         }
@@ -1248,9 +1251,9 @@ impl EmitterX64 for AssemblerX64 {
     }
     fn emit_pop(&mut self, sz: Size, dst: Location) -> Result<(), CompileError> {
         match (sz, dst) {
-            (Size::S64, Location::GPR(dst)) => dynasm!(self ; pop Rq(dst as u8)),
+            (Size::S64, Location::GPR(dst)) => dynasm!(self ; pop Rq(dst)),
             (Size::S64, Location::Memory(dst, disp)) => {
-                dynasm!(self ; pop QWORD [Rq(dst as u8) + disp])
+                dynasm!(self ; pop QWORD [Rq(dst) + disp])
             }
             _ => codegen_error!("singlepass can't emit POP {:?} {:?}", sz, dst),
         }
@@ -1303,21 +1306,21 @@ impl EmitterX64 for AssemblerX64 {
     }
     fn emit_neg(&mut self, sz: Size, value: Location) -> Result<(), CompileError> {
         match (sz, value) {
-            (Size::S8, Location::GPR(value)) => dynasm!(self ; neg Rb(value as u8)),
+            (Size::S8, Location::GPR(value)) => dynasm!(self ; neg Rb(value)),
             (Size::S8, Location::Memory(value, disp)) => {
-                dynasm!(self ; neg [Rq(value as u8) + disp])
+                dynasm!(self ; neg [Rq(value) + disp])
             }
-            (Size::S16, Location::GPR(value)) => dynasm!(self ; neg Rw(value as u8)),
+            (Size::S16, Location::GPR(value)) => dynasm!(self ; neg Rw(value)),
             (Size::S16, Location::Memory(value, disp)) => {
-                dynasm!(self ; neg [Rq(value as u8) + disp])
+                dynasm!(self ; neg [Rq(value) + disp])
             }
-            (Size::S32, Location::GPR(value)) => dynasm!(self ; neg Rd(value as u8)),
+            (Size::S32, Location::GPR(value)) => dynasm!(self ; neg Rd(value)),
             (Size::S32, Location::Memory(value, disp)) => {
-                dynasm!(self ; neg [Rq(value as u8) + disp])
+                dynasm!(self ; neg [Rq(value) + disp])
             }
-            (Size::S64, Location::GPR(value)) => dynasm!(self ; neg Rq(value as u8)),
+            (Size::S64, Location::GPR(value)) => dynasm!(self ; neg Rq(value)),
             (Size::S64, Location::Memory(value, disp)) => {
-                dynasm!(self ; neg [Rq(value as u8) + disp])
+                dynasm!(self ; neg [Rq(value) + disp])
             }
             _ => codegen_error!("singlepass can't emit NEG {:?} {:?}", sz, value),
         }
@@ -1332,7 +1335,7 @@ impl EmitterX64 for AssemblerX64 {
         Ok(())
     }
     fn emit_imul_imm32_gpr64(&mut self, src: u32, dst: GPR) -> Result<(), CompileError> {
-        dynasm!(self ; imul Rq(dst as u8), Rq(dst as u8), src as i32);
+        dynasm!(self ; imul Rq(dst), Rq(dst), src as i32);
         Ok(())
     }
     fn emit_div(&mut self, sz: Size, divisor: Location) -> Result<(), CompileError> {
@@ -1428,57 +1431,57 @@ impl EmitterX64 for AssemblerX64 {
     ) -> Result<(), CompileError> {
         match (sz_src, src, sz_dst, dst) {
             (Size::S8, Location::GPR(src), Size::S32, Location::GPR(dst)) => {
-                dynasm!(self ; movzx Rd(dst as u8), Rb(src as u8));
+                dynasm!(self ; movzx Rd(dst), Rb(src));
             }
             (Size::S16, Location::GPR(src), Size::S32, Location::GPR(dst)) => {
-                dynasm!(self ; movzx Rd(dst as u8), Rw(src as u8));
+                dynasm!(self ; movzx Rd(dst), Rw(src));
             }
             (Size::S8, Location::Memory(src, disp), Size::S32, Location::GPR(dst)) => {
-                dynasm!(self ; movzx Rd(dst as u8), BYTE [Rq(src as u8) + disp]);
+                dynasm!(self ; movzx Rd(dst), BYTE [Rq(src) + disp]);
             }
             (Size::S16, Location::Memory(src, disp), Size::S32, Location::GPR(dst)) => {
-                dynasm!(self ; movzx Rd(dst as u8), WORD [Rq(src as u8) + disp]);
+                dynasm!(self ; movzx Rd(dst), WORD [Rq(src) + disp]);
             }
             (Size::S16, Location::Imm32(imm), Size::S32, Location::GPR(dst)) => {
-                dynasm!(self ; mov Rd(dst as u8), imm as i32);
+                dynasm!(self ; mov Rd(dst), imm as i32);
             }
             (Size::S8, Location::GPR(src), Size::S64, Location::GPR(dst)) => {
-                dynasm!(self ; movzx Rq(dst as u8), Rb(src as u8));
+                dynasm!(self ; movzx Rq(dst), Rb(src));
             }
             (Size::S16, Location::GPR(src), Size::S64, Location::GPR(dst)) => {
-                dynasm!(self ; movzx Rq(dst as u8), Rw(src as u8));
+                dynasm!(self ; movzx Rq(dst), Rw(src));
             }
             (Size::S8, Location::Memory(src, disp), Size::S64, Location::GPR(dst)) => {
-                dynasm!(self ; movzx Rq(dst as u8), BYTE [Rq(src as u8) + disp]);
+                dynasm!(self ; movzx Rq(dst), BYTE [Rq(src) + disp]);
             }
             (Size::S16, Location::Memory(src, disp), Size::S64, Location::GPR(dst)) => {
-                dynasm!(self ; movzx Rq(dst as u8), WORD [Rq(src as u8) + disp]);
+                dynasm!(self ; movzx Rq(dst), WORD [Rq(src) + disp]);
             }
             (Size::S32, Location::GPR(src), Size::S64, Location::GPR(dst)) => {
                 if src != dst {
-                    dynasm!(self ; mov Rd(dst as u8), Rd(src as u8));
+                    dynasm!(self ; mov Rd(dst), Rd(src));
                 }
             }
             (Size::S32, Location::Memory(src, disp), Size::S64, Location::GPR(dst)) => {
-                dynasm!(self ; mov Rd(dst as u8), DWORD [Rq(src as u8) + disp]);
+                dynasm!(self ; mov Rd(dst), DWORD [Rq(src) + disp]);
             }
             (Size::S8, Location::Imm32(imm), Size::S32, Location::GPR(dst)) => {
-                dynasm!(self ; mov Rq(dst as u8), imm as i32);
+                dynasm!(self ; mov Rq(dst), imm as i32);
             }
             (Size::S16, Location::Imm32(imm), Size::S64, Location::GPR(dst)) => {
-                dynasm!(self ; mov Rq(dst as u8), imm as i32);
+                dynasm!(self ; mov Rq(dst), imm as i32);
             }
             (Size::S32, Location::Imm32(imm), Size::S64, Location::GPR(dst)) => {
-                dynasm!(self ; mov Rq(dst as u8), imm as i32);
+                dynasm!(self ; mov Rq(dst), imm as i32);
             }
             (Size::S8, Location::Imm64(imm), Size::S32, Location::GPR(dst)) => {
-                dynasm!(self ; mov Rq(dst as u8), imm as i32);
+                dynasm!(self ; mov Rq(dst), imm as i32);
             }
             (Size::S16, Location::Imm64(imm), Size::S64, Location::GPR(dst)) => {
-                dynasm!(self ; mov Rq(dst as u8), imm as i32);
+                dynasm!(self ; mov Rq(dst), imm as i32);
             }
             (Size::S32, Location::Imm64(imm), Size::S64, Location::GPR(dst)) => {
-                dynasm!(self ; mov Rq(dst as u8), imm as i32);
+                dynasm!(self ; mov Rq(dst), imm as i32);
             }
             _ => {
                 codegen_error!(
@@ -1501,34 +1504,34 @@ impl EmitterX64 for AssemblerX64 {
     ) -> Result<(), CompileError> {
         match (sz_src, src, sz_dst, dst) {
             (Size::S8, Location::GPR(src), Size::S32, Location::GPR(dst)) => {
-                dynasm!(self ; movsx Rd(dst as u8), Rb(src as u8));
+                dynasm!(self ; movsx Rd(dst), Rb(src));
             }
             (Size::S16, Location::GPR(src), Size::S32, Location::GPR(dst)) => {
-                dynasm!(self ; movsx Rd(dst as u8), Rw(src as u8));
+                dynasm!(self ; movsx Rd(dst), Rw(src));
             }
             (Size::S8, Location::Memory(src, disp), Size::S32, Location::GPR(dst)) => {
-                dynasm!(self ; movsx Rd(dst as u8), BYTE [Rq(src as u8) + disp]);
+                dynasm!(self ; movsx Rd(dst), BYTE [Rq(src) + disp]);
             }
             (Size::S16, Location::Memory(src, disp), Size::S32, Location::GPR(dst)) => {
-                dynasm!(self ; movsx Rd(dst as u8), WORD [Rq(src as u8) + disp]);
+                dynasm!(self ; movsx Rd(dst), WORD [Rq(src) + disp]);
             }
             (Size::S8, Location::GPR(src), Size::S64, Location::GPR(dst)) => {
-                dynasm!(self ; movsx Rq(dst as u8), Rb(src as u8));
+                dynasm!(self ; movsx Rq(dst), Rb(src));
             }
             (Size::S16, Location::GPR(src), Size::S64, Location::GPR(dst)) => {
-                dynasm!(self ; movsx Rq(dst as u8), Rw(src as u8));
+                dynasm!(self ; movsx Rq(dst), Rw(src));
             }
             (Size::S32, Location::GPR(src), Size::S64, Location::GPR(dst)) => {
-                dynasm!(self ; movsx Rq(dst as u8), Rd(src as u8));
+                dynasm!(self ; movsx Rq(dst), Rd(src));
             }
             (Size::S8, Location::Memory(src, disp), Size::S64, Location::GPR(dst)) => {
-                dynasm!(self ; movsx Rq(dst as u8), BYTE [Rq(src as u8) + disp]);
+                dynasm!(self ; movsx Rq(dst), BYTE [Rq(src) + disp]);
             }
             (Size::S16, Location::Memory(src, disp), Size::S64, Location::GPR(dst)) => {
-                dynasm!(self ; movsx Rq(dst as u8), WORD [Rq(src as u8) + disp]);
+                dynasm!(self ; movsx Rq(dst), WORD [Rq(src) + disp]);
             }
             (Size::S32, Location::Memory(src, disp), Size::S64, Location::GPR(dst)) => {
-                dynasm!(self ; movsx Rq(dst as u8), DWORD [Rq(src as u8) + disp]);
+                dynasm!(self ; movsx Rq(dst), DWORD [Rq(src) + disp]);
             }
             _ => {
                 codegen_error!(
@@ -1546,40 +1549,40 @@ impl EmitterX64 for AssemblerX64 {
     fn emit_xchg(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
         match (sz, src, dst) {
             (Size::S8, Location::GPR(src), Location::GPR(dst)) => {
-                dynasm!(self ; xchg Rb(dst as u8), Rb(src as u8));
+                dynasm!(self ; xchg Rb(dst), Rb(src));
             }
             (Size::S16, Location::GPR(src), Location::GPR(dst)) => {
-                dynasm!(self ; xchg Rw(dst as u8), Rw(src as u8));
+                dynasm!(self ; xchg Rw(dst), Rw(src));
             }
             (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
-                dynasm!(self ; xchg Rd(dst as u8), Rd(src as u8));
+                dynasm!(self ; xchg Rd(dst), Rd(src));
             }
             (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
-                dynasm!(self ; xchg Rq(dst as u8), Rq(src as u8));
+                dynasm!(self ; xchg Rq(dst), Rq(src));
             }
             (Size::S8, Location::Memory(src, disp), Location::GPR(dst)) => {
-                dynasm!(self ; xchg Rb(dst as u8), [Rq(src as u8) + disp]);
+                dynasm!(self ; xchg Rb(dst), [Rq(src) + disp]);
             }
             (Size::S8, Location::GPR(src), Location::Memory(dst, disp)) => {
-                dynasm!(self ; xchg [Rq(dst as u8) + disp], Rb(src as u8));
+                dynasm!(self ; xchg [Rq(dst) + disp], Rb(src));
             }
             (Size::S16, Location::Memory(src, disp), Location::GPR(dst)) => {
-                dynasm!(self ; xchg Rw(dst as u8), [Rq(src as u8) + disp]);
+                dynasm!(self ; xchg Rw(dst), [Rq(src) + disp]);
             }
             (Size::S16, Location::GPR(src), Location::Memory(dst, disp)) => {
-                dynasm!(self ; xchg [Rq(dst as u8) + disp], Rw(src as u8));
+                dynasm!(self ; xchg [Rq(dst) + disp], Rw(src));
             }
             (Size::S32, Location::Memory(src, disp), Location::GPR(dst)) => {
-                dynasm!(self ; xchg Rd(dst as u8), [Rq(src as u8) + disp]);
+                dynasm!(self ; xchg Rd(dst), [Rq(src) + disp]);
             }
             (Size::S32, Location::GPR(src), Location::Memory(dst, disp)) => {
-                dynasm!(self ; xchg [Rq(dst as u8) + disp], Rd(src as u8));
+                dynasm!(self ; xchg [Rq(dst) + disp], Rd(src));
             }
             (Size::S64, Location::Memory(src, disp), Location::GPR(dst)) => {
-                dynasm!(self ; xchg Rq(dst as u8), [Rq(src as u8) + disp]);
+                dynasm!(self ; xchg Rq(dst), [Rq(src) + disp]);
             }
             (Size::S64, Location::GPR(src), Location::Memory(dst, disp)) => {
-                dynasm!(self ; xchg [Rq(dst as u8) + disp], Rq(src as u8));
+                dynasm!(self ; xchg [Rq(dst) + disp], Rq(src));
             }
             _ => codegen_error!("singlepass can't emit XCHG {:?} {:?} {:?}", sz, src, dst),
         }
@@ -1594,16 +1597,16 @@ impl EmitterX64 for AssemblerX64 {
     ) -> Result<(), CompileError> {
         match (sz, src, dst) {
             (Size::S8, Location::GPR(src), Location::Memory(dst, disp)) => {
-                dynasm!(self ; lock xadd [Rq(dst as u8) + disp], Rb(src as u8));
+                dynasm!(self ; lock xadd [Rq(dst) + disp], Rb(src));
             }
             (Size::S16, Location::GPR(src), Location::Memory(dst, disp)) => {
-                dynasm!(self ; lock xadd [Rq(dst as u8) + disp], Rw(src as u8));
+                dynasm!(self ; lock xadd [Rq(dst) + disp], Rw(src));
             }
             (Size::S32, Location::GPR(src), Location::Memory(dst, disp)) => {
-                dynasm!(self ; lock xadd [Rq(dst as u8) + disp], Rd(src as u8));
+                dynasm!(self ; lock xadd [Rq(dst) + disp], Rd(src));
             }
             (Size::S64, Location::GPR(src), Location::Memory(dst, disp)) => {
-                dynasm!(self ; lock xadd [Rq(dst as u8) + disp], Rq(src as u8));
+                dynasm!(self ; lock xadd [Rq(dst) + disp], Rq(src));
             }
             _ => codegen_error!(
                 "singlepass can't emit LOCK XADD {:?} {:?} {:?}",
@@ -1623,16 +1626,16 @@ impl EmitterX64 for AssemblerX64 {
     ) -> Result<(), CompileError> {
         match (sz, src, dst) {
             (Size::S8, Location::GPR(src), Location::Memory(dst, disp)) => {
-                dynasm!(self ; lock cmpxchg [Rq(dst as u8) + disp], Rb(src as u8));
+                dynasm!(self ; lock cmpxchg [Rq(dst) + disp], Rb(src));
             }
             (Size::S16, Location::GPR(src), Location::Memory(dst, disp)) => {
-                dynasm!(self ; lock cmpxchg [Rq(dst as u8) + disp], Rw(src as u8));
+                dynasm!(self ; lock cmpxchg [Rq(dst) + disp], Rw(src));
             }
             (Size::S32, Location::GPR(src), Location::Memory(dst, disp)) => {
-                dynasm!(self ; lock cmpxchg [Rq(dst as u8) + disp], Rd(src as u8));
+                dynasm!(self ; lock cmpxchg [Rq(dst) + disp], Rd(src));
             }
             (Size::S64, Location::GPR(src), Location::Memory(dst, disp)) => {
-                dynasm!(self ; lock cmpxchg [Rq(dst as u8) + disp], Rq(src as u8));
+                dynasm!(self ; lock cmpxchg [Rq(dst) + disp], Rq(src));
             }
             _ => codegen_error!(
                 "singlepass can't emit LOCK CMPXCHG {:?} {:?} {:?}",
@@ -1649,35 +1652,35 @@ impl EmitterX64 for AssemblerX64 {
         Ok(())
     }
     fn emit_btc_gpr_imm8_32(&mut self, src: u8, dst: GPR) -> Result<(), CompileError> {
-        dynasm!(self ; btc Rd(dst as u8), BYTE src as i8);
+        dynasm!(self ; btc Rd(dst), BYTE src as i8);
         Ok(())
     }
 
     fn emit_btc_gpr_imm8_64(&mut self, src: u8, dst: GPR) -> Result<(), CompileError> {
-        dynasm!(self ; btc Rq(dst as u8), BYTE src as i8);
+        dynasm!(self ; btc Rq(dst), BYTE src as i8);
         Ok(())
     }
 
     fn emit_cmovae_gpr_32(&mut self, src: GPR, dst: GPR) -> Result<(), CompileError> {
-        dynasm!(self ; cmovae Rd(dst as u8), Rd(src as u8));
+        dynasm!(self ; cmovae Rd(dst), Rd(src));
         Ok(())
     }
 
     fn emit_cmovae_gpr_64(&mut self, src: GPR, dst: GPR) -> Result<(), CompileError> {
-        dynasm!(self ; cmovae Rq(dst as u8), Rq(src as u8));
+        dynasm!(self ; cmovae Rq(dst), Rq(src));
         Ok(())
     }
 
     fn emit_vmovaps(&mut self, src: XMMOrMemory, dst: XMMOrMemory) -> Result<(), CompileError> {
         match (src, dst) {
             (XMMOrMemory::XMM(src), XMMOrMemory::XMM(dst)) => {
-                dynasm!(self ; movaps Rx(dst as u8), Rx(src as u8))
+                dynasm!(self ; movaps Rx(dst), Rx(src))
             }
             (XMMOrMemory::Memory(base, disp), XMMOrMemory::XMM(dst)) => {
-                dynasm!(self ; movaps Rx(dst as u8), [Rq(base as u8) + disp])
+                dynasm!(self ; movaps Rx(dst), [Rq(base) + disp])
             }
             (XMMOrMemory::XMM(src), XMMOrMemory::Memory(base, disp)) => {
-                dynasm!(self ; movaps [Rq(base as u8) + disp], Rx(src as u8))
+                dynasm!(self ; movaps [Rq(base) + disp], Rx(src))
             }
             _ => codegen_error!("singlepass can't emit VMOVAPS {:?} {:?}", src, dst),
         };
@@ -1687,13 +1690,13 @@ impl EmitterX64 for AssemblerX64 {
     fn emit_vmovapd(&mut self, src: XMMOrMemory, dst: XMMOrMemory) -> Result<(), CompileError> {
         match (src, dst) {
             (XMMOrMemory::XMM(src), XMMOrMemory::XMM(dst)) => {
-                dynasm!(self ; movapd Rx(dst as u8), Rx(src as u8))
+                dynasm!(self ; movapd Rx(dst), Rx(src))
             }
             (XMMOrMemory::Memory(base, disp), XMMOrMemory::XMM(dst)) => {
-                dynasm!(self ; movapd Rx(dst as u8), [Rq(base as u8) + disp])
+                dynasm!(self ; movapd Rx(dst), [Rq(base) + disp])
             }
             (XMMOrMemory::XMM(src), XMMOrMemory::Memory(base, disp)) => {
-                dynasm!(self ; movapd [Rq(base as u8) + disp], Rx(src as u8))
+                dynasm!(self ; movapd [Rq(base) + disp], Rx(src))
             }
             _ => codegen_error!("singlepass can't emit VMOVAPD {:?} {:?}", src, dst),
         };
@@ -2254,20 +2257,20 @@ impl EmitterX64 for AssemblerX64 {
             Some(CpuFeature::AVX) => match src2 {
                 XMMOrMemory::XMM(src2) => {
                     // TODO: this argument order does not match the documentation??
-                    dynasm!( self; vblendvps Rx(dst as u8), Rx(mask as u8), Rx(src2 as u8), Rx(src1 as u8))
+                    dynasm!( self; vblendvps Rx(dst), Rx(mask), Rx(src2), Rx(src1))
                 }
                 XMMOrMemory::Memory(base, disp) => {
-                    dynasm!( self; vblendvps Rx(dst as u8), Rx(mask as u8), [Rq(base as u8) + disp], Rx(src1 as u8))
+                    dynasm!( self; vblendvps Rx(dst), Rx(mask), [Rq(base) + disp], Rx(src1))
                 }
             },
             Some(CpuFeature::SSE42) => match src2 {
                 XMMOrMemory::XMM(src2) => {
                     move_src_to_dst(self, Precision::Single, src1, dst);
-                    dynasm!( self; blendvps Rx(dst as u8), Rx(src2 as u8))
+                    dynasm!( self; blendvps Rx(dst), Rx(src2))
                 }
                 XMMOrMemory::Memory(base, disp) => {
                     move_src_to_dst(self, Precision::Single, src1, dst);
-                    dynasm!( self; blendvps Rx(dst as u8), [Rq(base as u8) + disp])
+                    dynasm!( self; blendvps Rx(dst), [Rq(base) + disp])
                 }
             },
             _ => {}
@@ -2287,20 +2290,20 @@ impl EmitterX64 for AssemblerX64 {
             Some(CpuFeature::AVX) => match src2 {
                 XMMOrMemory::XMM(src2) => {
                     // TODO: this argument order does not match the documentation??
-                    dynasm!( self; vblendvpd Rx(dst as u8), Rx(mask as u8), Rx(src2 as u8), Rx(src1 as u8))
+                    dynasm!( self; vblendvpd Rx(dst), Rx(mask), Rx(src2), Rx(src1))
                 }
                 XMMOrMemory::Memory(base, disp) => {
-                    dynasm!( self; vblendvpd Rx(dst as u8), Rx(mask as u8), [Rq(base as u8) + disp], Rx(src1 as u8))
+                    dynasm!( self; vblendvpd Rx(dst), Rx(mask), [Rq(base) + disp], Rx(src1))
                 }
             },
             Some(CpuFeature::SSE42) => match src2 {
                 XMMOrMemory::XMM(src2) => {
                     move_src_to_dst(self, Precision::Double, src1, dst);
-                    dynasm!( self; blendvpd Rx(dst as u8), Rx(src2 as u8))
+                    dynasm!( self; blendvpd Rx(dst), Rx(src2))
                 }
                 XMMOrMemory::Memory(base, disp) => {
                     move_src_to_dst(self, Precision::Double, src1, dst);
-                    dynasm!( self; blendvpd Rx(dst as u8), [Rq(base as u8) + disp])
+                    dynasm!( self; blendvpd Rx(dst), [Rq(base) + disp])
                 }
             },
             _ => {}
@@ -2310,9 +2313,9 @@ impl EmitterX64 for AssemblerX64 {
 
     fn emit_ucomiss(&mut self, src: XMMOrMemory, dst: XMM) -> Result<(), CompileError> {
         match src {
-            XMMOrMemory::XMM(x) => dynasm!(self ; ucomiss Rx(dst as u8), Rx(x as u8)),
+            XMMOrMemory::XMM(x) => dynasm!(self ; ucomiss Rx(dst), Rx(x)),
             XMMOrMemory::Memory(base, disp) => {
-                dynasm!(self ; ucomiss Rx(dst as u8), [Rq(base as u8) + disp])
+                dynasm!(self ; ucomiss Rx(dst), [Rq(base) + disp])
             }
         }
         Ok(())
@@ -2320,9 +2323,9 @@ impl EmitterX64 for AssemblerX64 {
 
     fn emit_ucomisd(&mut self, src: XMMOrMemory, dst: XMM) -> Result<(), CompileError> {
         match src {
-            XMMOrMemory::XMM(x) => dynasm!(self ; ucomisd Rx(dst as u8), Rx(x as u8)),
+            XMMOrMemory::XMM(x) => dynasm!(self ; ucomisd Rx(dst), Rx(x)),
             XMMOrMemory::Memory(base, disp) => {
-                dynasm!(self ; ucomisd Rx(dst as u8), [Rq(base as u8) + disp])
+                dynasm!(self ; ucomisd Rx(dst), [Rq(base) + disp])
             }
         }
         Ok(())
@@ -2330,9 +2333,9 @@ impl EmitterX64 for AssemblerX64 {
 
     fn emit_cvttss2si_32(&mut self, src: XMMOrMemory, dst: GPR) -> Result<(), CompileError> {
         match src {
-            XMMOrMemory::XMM(x) => dynasm!(self ; cvttss2si Rd(dst as u8), Rx(x as u8)),
+            XMMOrMemory::XMM(x) => dynasm!(self ; cvttss2si Rd(dst), Rx(x)),
             XMMOrMemory::Memory(base, disp) => {
-                dynasm!(self ; cvttss2si Rd(dst as u8), [Rq(base as u8) + disp])
+                dynasm!(self ; cvttss2si Rd(dst), [Rq(base) + disp])
             }
         }
         Ok(())
@@ -2340,9 +2343,9 @@ impl EmitterX64 for AssemblerX64 {
 
     fn emit_cvttss2si_64(&mut self, src: XMMOrMemory, dst: GPR) -> Result<(), CompileError> {
         match src {
-            XMMOrMemory::XMM(x) => dynasm!(self ; cvttss2si Rq(dst as u8), Rx(x as u8)),
+            XMMOrMemory::XMM(x) => dynasm!(self ; cvttss2si Rq(dst), Rx(x)),
             XMMOrMemory::Memory(base, disp) => {
-                dynasm!(self ; cvttss2si Rq(dst as u8), [Rq(base as u8) + disp])
+                dynasm!(self ; cvttss2si Rq(dst), [Rq(base) + disp])
             }
         }
         Ok(())
@@ -2350,9 +2353,9 @@ impl EmitterX64 for AssemblerX64 {
 
     fn emit_cvttsd2si_32(&mut self, src: XMMOrMemory, dst: GPR) -> Result<(), CompileError> {
         match src {
-            XMMOrMemory::XMM(x) => dynasm!(self ; cvttsd2si Rd(dst as u8), Rx(x as u8)),
+            XMMOrMemory::XMM(x) => dynasm!(self ; cvttsd2si Rd(dst), Rx(x)),
             XMMOrMemory::Memory(base, disp) => {
-                dynasm!(self ; cvttsd2si Rd(dst as u8), [Rq(base as u8) + disp])
+                dynasm!(self ; cvttsd2si Rd(dst), [Rq(base) + disp])
             }
         }
         Ok(())
@@ -2360,16 +2363,16 @@ impl EmitterX64 for AssemblerX64 {
 
     fn emit_cvttsd2si_64(&mut self, src: XMMOrMemory, dst: GPR) -> Result<(), CompileError> {
         match src {
-            XMMOrMemory::XMM(x) => dynasm!(self ; cvttsd2si Rq(dst as u8), Rx(x as u8)),
+            XMMOrMemory::XMM(x) => dynasm!(self ; cvttsd2si Rq(dst), Rx(x)),
             XMMOrMemory::Memory(base, disp) => {
-                dynasm!(self ; cvttsd2si Rq(dst as u8), [Rq(base as u8) + disp])
+                dynasm!(self ; cvttsd2si Rq(dst), [Rq(base) + disp])
             }
         }
         Ok(())
     }
 
     fn emit_test_gpr_64(&mut self, reg: GPR) -> Result<(), CompileError> {
-        dynasm!(self ; test Rq(reg as u8), Rq(reg as u8));
+        dynasm!(self ; test Rq(reg), Rq(reg));
         Ok(())
     }
 
@@ -2377,9 +2380,13 @@ impl EmitterX64 for AssemblerX64 {
         dynasm!(self ; ud2);
         Ok(())
     }
+    #[allow(clippy::useless_conversion)]
     fn emit_ud1_payload(&mut self, payload: u8) -> Result<(), CompileError> {
         assert!(payload & 0xf0 == 0);
-        dynasm!(self ; ud1 Rd((payload>>3)&1), Rd(payload&7));
+        let reg1 = (payload >> 3) & 1;
+        let reg2 = payload & 7;
+
+        dynasm!(self ; ud1 Rd(reg1), Rd(reg2));
         Ok(())
     }
     fn emit_ret(&mut self) -> Result<(), CompileError> {
@@ -2393,15 +2400,15 @@ impl EmitterX64 for AssemblerX64 {
     }
     fn emit_call_location(&mut self, loc: Location) -> Result<(), CompileError> {
         match loc {
-            Location::GPR(x) => dynasm!(self ; call Rq(x as u8)),
-            Location::Memory(base, disp) => dynasm!(self ; call QWORD [Rq(base as u8) + disp]),
+            Location::GPR(x) => dynasm!(self ; call Rq(x)),
+            Location::Memory(base, disp) => dynasm!(self ; call QWORD [Rq(base) + disp]),
             _ => codegen_error!("singlepass can't emit CALL {:?}", loc),
         }
         Ok(())
     }
 
     fn emit_call_register(&mut self, reg: GPR) -> Result<(), CompileError> {
-        dynasm!(self ; call Rq(reg as u8));
+        dynasm!(self ; call Rq(reg));
         Ok(())
     }
 
diff --git a/lib/compiler-singlepass/src/location.rs b/lib/compiler-singlepass/src/location.rs
index ba8addfd6b..b1e10fd45e 100644
--- a/lib/compiler-singlepass/src/location.rs
+++ b/lib/compiler-singlepass/src/location.rs
@@ -38,6 +38,7 @@ impl<R, S> MaybeImmediate for Location<R, S> {
     }
 }
 
+#[allow(unused)]
 pub trait Reg: Copy + Clone + Eq + PartialEq + Debug + Hash + Ord {
     fn is_callee_save(self) -> bool;
     fn is_reserved(self) -> bool;
@@ -47,6 +48,7 @@ pub trait Reg: Copy + Clone + Eq + PartialEq + Debug + Hash + Ord {
     fn to_dwarf(self) -> u16;
 }
 
+#[allow(unused)]
 pub trait Descriptor<R: Reg, S: Reg> {
     const FP: R;
     const VMCTX: R;
@@ -65,6 +67,7 @@ pub trait Descriptor<R: Reg, S: Reg> {
     fn return_location() -> Location<R, S>;
 }
 
+#[allow(unused)]
 pub trait CombinedRegister: Copy + Clone + Eq + PartialEq + Debug {
     /// Returns the index of the register.
     fn to_index(&self) -> RegisterIndex;
diff --git a/lib/compiler-singlepass/src/machine.rs b/lib/compiler-singlepass/src/machine.rs
index e3ca24ba30..1207c5568e 100644
--- a/lib/compiler-singlepass/src/machine.rs
+++ b/lib/compiler-singlepass/src/machine.rs
@@ -1,19 +1,25 @@
-use crate::common_decl::*;
-use crate::location::{Location, Reg};
-use crate::machine_arm64::MachineARM64;
-use crate::machine_x64::MachineX86_64;
-use crate::unwind::UnwindInstructions;
+use crate::{
+    common_decl::*,
+    location::{Location, Reg},
+    machine_arm64::MachineARM64,
+    machine_x64::MachineX86_64,
+    unwind::UnwindInstructions,
+};
 use dynasmrt::{AssemblyOffset, DynamicLabel};
-use std::collections::BTreeMap;
-use std::fmt::Debug;
-pub use wasmer_compiler::wasmparser::MemArg;
-use wasmer_compiler::wasmparser::ValType as WpType;
+use std::{collections::BTreeMap, fmt::Debug};
+use wasmer_compiler::{
+    types::{
+        address_map::InstructionAddressMap,
+        function::FunctionBody,
+        relocation::{Relocation, RelocationTarget},
+        section::CustomSection,
+    },
+    wasmparser::{MemArg, ValType as WpType},
+};
 use wasmer_types::{
-    Architecture, CallingConvention, CompileError, CustomSection, FunctionBody, FunctionIndex,
-    FunctionType, InstructionAddressMap, Relocation, RelocationTarget, Target, TrapCode,
-    TrapInformation, VMOffsets,
+    target::{Architecture, CallingConvention, Target},
+    CompileError, FunctionIndex, FunctionType, TrapCode, TrapInformation, VMOffsets,
 };
-
 pub type Label = DynamicLabel;
 pub type Offset = AssemblyOffset;
 
@@ -32,6 +38,7 @@ macro_rules! codegen_error {
     ($($arg:tt)*) => {return Err(CompileError::Codegen(format!($($arg)*)))}
 }
 
+#[allow(unused)]
 pub trait MaybeImmediate {
     fn imm_value(&self) -> Option<Value>;
     fn is_imm(&self) -> bool {
@@ -51,6 +58,7 @@ pub const NATIVE_PAGE_SIZE: usize = 4096;
 
 pub struct MachineStackOffset(pub usize);
 
+#[allow(unused)]
 pub trait Machine {
     type GPR: Copy + Eq + Debug + Reg;
     type SIMD: Copy + Eq + Debug + Reg;
diff --git a/lib/compiler-singlepass/src/machine_arm64.rs b/lib/compiler-singlepass/src/machine_arm64.rs
index a5341dd512..e3b42c9360 100644
--- a/lib/compiler-singlepass/src/machine_arm64.rs
+++ b/lib/compiler-singlepass/src/machine_arm64.rs
@@ -2,22 +2,29 @@ use dynasmrt::{aarch64::Aarch64Relocation, VecAssembler};
 #[cfg(feature = "unwind")]
 use gimli::{write::CallFrameInstruction, AArch64};
 
-use wasmer_compiler::wasmparser::ValType as WpType;
+use wasmer_compiler::{
+    types::{
+        address_map::InstructionAddressMap,
+        function::FunctionBody,
+        relocation::{Relocation, RelocationKind, RelocationTarget},
+        section::CustomSection,
+    },
+    wasmparser::{MemArg, ValType as WpType},
+};
 use wasmer_types::{
-    CallingConvention, CompileError, CpuFeature, CustomSection, FunctionBody, FunctionIndex,
-    FunctionType, InstructionAddressMap, Relocation, RelocationKind, RelocationTarget, SourceLoc,
-    Target, TrapCode, TrapInformation, VMOffsets,
+    target::{CallingConvention, CpuFeature, Target},
+    CompileError, FunctionIndex, FunctionType, SourceLoc, TrapCode, TrapInformation, VMOffsets,
 };
 
-use crate::arm64_decl::new_machine_state;
-use crate::arm64_decl::{GPR, NEON};
-use crate::codegen_error;
-use crate::common_decl::*;
-use crate::emitter_arm64::*;
-use crate::location::Location as AbstractLocation;
-use crate::location::Reg;
-use crate::machine::*;
-use crate::unwind::{UnwindInstructions, UnwindOps};
+use crate::{
+    arm64_decl::{new_machine_state, GPR, NEON},
+    codegen_error,
+    common_decl::*,
+    emitter_arm64::*,
+    location::{Location as AbstractLocation, Reg},
+    machine::*,
+    unwind::{UnwindInstructions, UnwindOps},
+};
 
 type Assembler = VecAssembler<Aarch64Relocation>;
 type Location = AbstractLocation<GPR, NEON>;
@@ -95,7 +102,7 @@ fn dwarf_index(reg: u16) -> gimli::Register {
     match reg {
         0..=31 => DWARF_GPR[reg as usize],
         64..=95 => DWARF_NEON[reg as usize - 64],
-        _ => panic!("Unknown register index {}", reg),
+        _ => panic!("Unknown register index {reg}"),
     }
 }
 
@@ -2302,7 +2309,7 @@ impl Machine for MachineARM64 {
     // assembler finalize
     fn assembler_finalize(self) -> Result<Vec<u8>, CompileError> {
         self.assembler.finalize().map_err(|e| {
-            CompileError::Codegen(format!("Assembler failed finalization with: {:?}", e))
+            CompileError::Codegen(format!("Assembler failed finalization with: {e:?}"))
         })
     }
 
@@ -5033,7 +5040,7 @@ impl Machine for MachineARM64 {
             dest
         };
         self.assembler
-            .emit_cbz_label(Size::S64, src2, integer_division_by_zero)?;
+            .emit_cbz_label_far(Size::S64, src2, integer_division_by_zero)?;
         let offset = self.mark_instruction_with_trap_code(TrapCode::IntegerOverflow);
         self.assembler.emit_udiv(Size::S64, src1, src2, dest)?;
         // unsigned remainder : src1 - (src1/src2)*src2
@@ -5071,7 +5078,7 @@ impl Machine for MachineARM64 {
             dest
         };
         self.assembler
-            .emit_cbz_label(Size::S64, src2, integer_division_by_zero)?;
+            .emit_cbz_label_far(Size::S64, src2, integer_division_by_zero)?;
         let offset = self.mark_instruction_with_trap_code(TrapCode::IntegerOverflow);
         self.assembler.emit_sdiv(Size::S64, src1, src2, dest)?;
         // unsigned remainder : src1 - (src1/src2)*src2
diff --git a/lib/compiler-singlepass/src/machine_x64.rs b/lib/compiler-singlepass/src/machine_x64.rs
index 5bb3655d37..1c7530607c 100644
--- a/lib/compiler-singlepass/src/machine_x64.rs
+++ b/lib/compiler-singlepass/src/machine_x64.rs
@@ -1,25 +1,32 @@
-use crate::codegen_error;
-use crate::common_decl::*;
-use crate::emitter_x64::*;
-use crate::location::Location as AbstractLocation;
-use crate::location::Reg;
-use crate::machine::*;
-use crate::unwind::{UnwindInstructions, UnwindOps};
 #[cfg(feature = "unwind")]
 use crate::unwind_winx64::create_unwind_info_from_insts;
-use crate::x64_decl::new_machine_state;
-use crate::x64_decl::{ArgumentRegisterAllocator, X64Register, GPR, XMM};
+use crate::{
+    codegen_error,
+    common_decl::*,
+    emitter_x64::*,
+    location::{Location as AbstractLocation, Reg},
+    machine::*,
+    unwind::{UnwindInstructions, UnwindOps},
+    x64_decl::{new_machine_state, ArgumentRegisterAllocator, X64Register, GPR, XMM},
+};
 use dynasmrt::{x64::X64Relocation, DynasmError, VecAssembler};
 #[cfg(feature = "unwind")]
 use gimli::{write::CallFrameInstruction, X86_64};
 use std::ops::{Deref, DerefMut};
-use wasmer_compiler::wasmparser::ValType as WpType;
+use wasmer_compiler::{
+    types::{
+        address_map::InstructionAddressMap,
+        function::FunctionBody,
+        relocation::{Relocation, RelocationKind, RelocationTarget},
+        section::{CustomSection, CustomSectionProtection, SectionBody},
+    },
+    wasmparser::{MemArg, ValType as WpType},
+};
 use wasmer_types::{
-    CallingConvention, CompileError, CpuFeature, CustomSection, CustomSectionProtection,
-    Relocation, RelocationKind, RelocationTarget, SectionBody, Target,
+    target::{CallingConvention, CpuFeature, Target},
+    CompileError, FunctionIndex, FunctionType, SourceLoc, TrapCode, TrapInformation, Type,
+    VMOffsets,
 };
-use wasmer_types::{FunctionBody, InstructionAddressMap, SourceLoc, TrapInformation};
-use wasmer_types::{FunctionIndex, FunctionType, TrapCode, Type, VMOffsets};
 
 type Assembler = VecAssembler<X64Relocation>;
 
@@ -119,7 +126,7 @@ fn dwarf_index(reg: u16) -> gimli::Register {
     match reg {
         0..=15 => DWARF_GPR[reg as usize],
         17..=24 => DWARF_XMM[reg as usize - 17],
-        _ => panic!("Unknown register index {}", reg),
+        _ => panic!("Unknown register index {reg}"),
     }
 }
 
@@ -1105,7 +1112,7 @@ impl MachineX86_64 {
             |this| {
                 this.assembler.emit_mov(
                     Size::S64,
-                    Location::Imm64(std::u64::MAX),
+                    Location::Imm64(u64::MAX),
                     Location::GPR(tmp_out),
                 )
             },
@@ -1256,14 +1263,14 @@ impl MachineX86_64 {
             |this| {
                 this.assembler.emit_mov(
                     Size::S64,
-                    Location::Imm64(std::i64::MIN as u64),
+                    Location::Imm64(i64::MIN as u64),
                     Location::GPR(tmp_out),
                 )
             },
             |this| {
                 this.assembler.emit_mov(
                     Size::S64,
-                    Location::Imm64(std::i64::MAX as u64),
+                    Location::Imm64(i64::MAX as u64),
                     Location::GPR(tmp_out),
                 )
             },
@@ -1348,14 +1355,14 @@ impl MachineX86_64 {
             |this| {
                 this.assembler.emit_mov(
                     Size::S32,
-                    Location::Imm32(std::i32::MIN as u32),
+                    Location::Imm32(i32::MIN as u32),
                     Location::GPR(tmp_out),
                 )
             },
             |this| {
                 this.assembler.emit_mov(
                     Size::S32,
-                    Location::Imm32(std::i32::MAX as u32),
+                    Location::Imm32(i32::MAX as u32),
                     Location::GPR(tmp_out),
                 )
             },
@@ -1444,7 +1451,7 @@ impl MachineX86_64 {
             |this| {
                 this.assembler.emit_mov(
                     Size::S32,
-                    Location::Imm32(std::u32::MAX),
+                    Location::Imm32(u32::MAX),
                     Location::GPR(tmp_out),
                 )
             },
@@ -1518,7 +1525,7 @@ impl MachineX86_64 {
             |this| {
                 this.assembler.emit_mov(
                     Size::S64,
-                    Location::Imm64(std::u64::MAX),
+                    Location::Imm64(u64::MAX),
                     Location::GPR(tmp_out),
                 )
             },
@@ -1669,14 +1676,14 @@ impl MachineX86_64 {
             |this| {
                 this.assembler.emit_mov(
                     Size::S64,
-                    Location::Imm64(std::i64::MIN as u64),
+                    Location::Imm64(i64::MIN as u64),
                     Location::GPR(tmp_out),
                 )
             },
             |this| {
                 this.assembler.emit_mov(
                     Size::S64,
-                    Location::Imm64(std::i64::MAX as u64),
+                    Location::Imm64(i64::MAX as u64),
                     Location::GPR(tmp_out),
                 )
             },
@@ -1748,14 +1755,14 @@ impl MachineX86_64 {
             |this| {
                 this.assembler.emit_mov(
                     Size::S32,
-                    Location::Imm32(std::i32::MIN as u32),
+                    Location::Imm32(i32::MIN as u32),
                     Location::GPR(tmp_out),
                 )
             },
             |this| {
                 this.assembler.emit_mov(
                     Size::S32,
-                    Location::Imm32(std::i32::MAX as u32),
+                    Location::Imm32(i32::MAX as u32),
                     Location::GPR(tmp_out),
                 )
             },
@@ -1831,7 +1838,7 @@ impl MachineX86_64 {
             |this| {
                 this.assembler.emit_mov(
                     Size::S32,
-                    Location::Imm32(std::u32::MAX),
+                    Location::Imm32(u32::MAX),
                     Location::GPR(tmp_out),
                 )
             },
@@ -2426,10 +2433,7 @@ impl Machine for MachineX86_64 {
                     }
                 }
             },
-            _ => panic!(
-                "unimplemented move_location_extend({:?}, {}, {:?}, {:?}, {:?}",
-                size_val, signed, source, size_op, dest
-            ),
+            _ => panic!(                "unimplemented move_location_extend({size_val:?}, {signed}, {source:?}, {size_op:?}, {dest:?}"            ),
         }?;
         if dst != dest {
             self.assembler.emit_mov(size_op, dst, dest)?;
@@ -2501,7 +2505,7 @@ impl Machine for MachineX86_64 {
     // assembler finalize
     fn assembler_finalize(self) -> Result<Vec<u8>, CompileError> {
         self.assembler.finalize().map_err(|e| {
-            CompileError::Codegen(format!("Assembler failed finalization with: {:?}", e))
+            CompileError::Codegen(format!("Assembler failed finalization with: {e:?}"))
         })
     }
 
@@ -7970,7 +7974,7 @@ impl Machine for MachineX86_64 {
             let mut stack_param_count: usize = 0;
 
             for (i, ty) in sig.params().iter().enumerate() {
-                let source_loc = match argalloc.next(*ty, calling_convention) {
+                let source_loc = match argalloc.next(*ty, calling_convention)? {
                     Some(X64Register::GPR(gpr)) => Location::GPR(gpr),
                     Some(X64Register::XMM(xmm)) => Location::SIMD(xmm),
                     None => {
@@ -8106,7 +8110,7 @@ impl Machine for MachineX86_64 {
                     let mut argalloc = ArgumentRegisterAllocator::default();
                     for (i, ty) in sig.params().iter().enumerate() {
                         let prev_loc = param_locations[i];
-                        match argalloc.next(*ty, calling_convention) {
+                        match argalloc.next(*ty, calling_convention)? {
                             Some(X64Register::GPR(_gpr)) => continue,
                             Some(X64Register::XMM(xmm)) => {
                                 a.emit_mov(Size::S64, prev_loc, Location::SIMD(xmm))?
@@ -8151,11 +8155,11 @@ impl Machine for MachineX86_64 {
 
                     // Copy arguments.
                     let mut argalloc = ArgumentRegisterAllocator::default();
-                    argalloc.next(Type::I64, calling_convention).unwrap(); // skip VMContext
+                    argalloc.next(Type::I64, calling_convention)?.unwrap(); // skip VMContext
                     let mut caller_stack_offset: i32 = 0;
                     for (i, ty) in sig.params().iter().enumerate() {
                         let prev_loc = param_locations[i];
-                        let targ = match argalloc.next(*ty, calling_convention) {
+                        let targ = match argalloc.next(*ty, calling_convention)? {
                             Some(X64Register::GPR(gpr)) => Location::GPR(gpr),
                             Some(X64Register::XMM(xmm)) => Location::SIMD(xmm),
                             None => {
@@ -8231,6 +8235,7 @@ impl Machine for MachineX86_64 {
 
         Ok(CustomSection {
             protection: CustomSectionProtection::ReadExecute,
+            alignment: None,
             bytes: section_body,
             relocations: vec![],
         })
@@ -8298,7 +8303,7 @@ mod test {
     use super::*;
     use enumset::enum_set;
     use std::str::FromStr;
-    use wasmer_types::{CpuFeature, Target, Triple};
+    use wasmer_types::target::{CpuFeature, Target, Triple};
 
     fn test_move_location(machine: &mut MachineX86_64) -> Result<(), CompileError> {
         machine.move_location_for_native(
diff --git a/lib/compiler-singlepass/src/unwind.rs b/lib/compiler-singlepass/src/unwind.rs
index ffda4500a9..babff85afb 100644
--- a/lib/compiler-singlepass/src/unwind.rs
+++ b/lib/compiler-singlepass/src/unwind.rs
@@ -4,7 +4,7 @@ use gimli::write::{Address, CallFrameInstruction, CommonInformationEntry, FrameD
 use gimli::{AArch64, Encoding, Format, X86_64};
 use std::fmt::Debug;
 #[cfg(feature = "unwind")]
-use wasmer_types::Architecture;
+use wasmer_types::target::Architecture;
 
 #[derive(Clone, Debug)]
 pub enum UnwindOps {
diff --git a/lib/compiler-singlepass/src/unwind_winx64.rs b/lib/compiler-singlepass/src/unwind_winx64.rs
index 389cba3c92..979e740644 100644
--- a/lib/compiler-singlepass/src/unwind_winx64.rs
+++ b/lib/compiler-singlepass/src/unwind_winx64.rs
@@ -106,7 +106,7 @@ impl UnwindCode {
                 };
                 writer.write_u8(*instruction_offset);
                 let scaled_stack_offset = stack_offset / 16;
-                if scaled_stack_offset <= core::u16::MAX as u32 {
+                if scaled_stack_offset <= u16::MAX as u32 {
                     writer.write_u8((*reg << 4) | (op_small as u8));
                     writer.write_u16_le(scaled_stack_offset as u16);
                 } else {
@@ -155,7 +155,7 @@ impl UnwindCode {
                 }
             }
             Self::SaveXmm { stack_offset, .. } | Self::SaveReg { stack_offset, .. } => {
-                if *stack_offset <= core::u16::MAX as u32 {
+                if *stack_offset <= u16::MAX as u32 {
                     2
                 } else {
                     3
diff --git a/lib/compiler-singlepass/src/x64_decl.rs b/lib/compiler-singlepass/src/x64_decl.rs
index 6178a17015..9edd43a86e 100644
--- a/lib/compiler-singlepass/src/x64_decl.rs
+++ b/lib/compiler-singlepass/src/x64_decl.rs
@@ -6,7 +6,7 @@ use crate::location::CombinedRegister;
 use crate::location::Reg as AbstractReg;
 use std::collections::BTreeMap;
 use std::slice::Iter;
-use wasmer_types::{CallingConvention, Type};
+use wasmer_types::{target::CallingConvention, CompileError, Type};
 
 /// General-purpose registers.
 #[repr(u8)]
@@ -30,6 +30,12 @@ pub enum GPR {
     R15 = 15,
 }
 
+impl From<GPR> for u8 {
+    fn from(val: GPR) -> Self {
+        val as u8
+    }
+}
+
 /// XMM registers.
 #[repr(u8)]
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
@@ -53,6 +59,12 @@ pub enum XMM {
     XMM15 = 15,
 }
 
+impl From<XMM> for u8 {
+    fn from(val: XMM) -> Self {
+        val as u8
+    }
+}
+
 impl AbstractReg for GPR {
     fn is_callee_save(self) -> bool {
         const IS_CALLEE_SAVE: [bool; 16] = [
@@ -257,8 +269,12 @@ pub struct ArgumentRegisterAllocator {
 
 impl ArgumentRegisterAllocator {
     /// Allocates a register for argument type `ty`. Returns `None` if no register is available for this type.
-    pub fn next(&mut self, ty: Type, calling_convention: CallingConvention) -> Option<X64Register> {
-        match calling_convention {
+    pub fn next(
+        &mut self,
+        ty: Type,
+        calling_convention: CallingConvention,
+    ) -> Result<Option<X64Register>, CompileError> {
+        let ret = match calling_convention {
             CallingConvention::WindowsFastcall => {
                 static GPR_SEQ: &[GPR] = &[GPR::RCX, GPR::RDX, GPR::R8, GPR::R9];
                 static XMM_SEQ: &[XMM] = &[XMM::XMM0, XMM::XMM1, XMM::XMM2, XMM::XMM3];
@@ -282,10 +298,11 @@ impl ArgumentRegisterAllocator {
                             None
                         }
                     }
-                    _ => todo!(
-                        "ArgumentRegisterAllocator::next: Unsupported type: {:?}",
-                        ty
-                    ),
+                    _ => {
+                        return Err(CompileError::Codegen(format!(
+                            "No register available for {calling_convention:?} and type {ty}"
+                        )))
+                    }
                 }
             }
             _ => {
@@ -320,13 +337,16 @@ impl ArgumentRegisterAllocator {
                             None
                         }
                     }
-                    _ => todo!(
-                        "ArgumentRegisterAllocator::next: Unsupported type: {:?}",
-                        ty
-                    ),
+                    _ => {
+                        return Err(CompileError::Codegen(format!(
+                            "No register available for {calling_convention:?} and type {ty}"
+                        )))
+                    }
                 }
             }
-        }
+        };
+
+        Ok(ret)
     }
 }
 
@@ -337,6 +357,6 @@ pub fn new_machine_state() -> MachineState {
         register_values: vec![MachineValue::Undefined; 16 + 8],
         prev_frame: BTreeMap::new(),
         wasm_stack: vec![],
-        wasm_inst_offset: std::usize::MAX,
+        wasm_inst_offset: usize::MAX,
     }
 }
diff --git a/lib/compiler/Cargo.toml b/lib/compiler/Cargo.toml
index abed0d3132..391bf8b9e3 100644
--- a/lib/compiler/Cargo.toml
+++ b/lib/compiler/Cargo.toml
@@ -13,38 +13,47 @@ rust-version.workspace = true
 version.workspace = true
 
 [dependencies]
-wasmer-types = { path = "../types", version = "=4.3.7", default-features = false }
-wasmer-object = { path = "../object", version = "=4.3.7", optional = true }
+wasmer-types = { path = "../types", version = "=6.1.0", default-features = false }
 wasmparser = { workspace = true, optional = true, default-features = false }
 enumset.workspace = true
-hashbrown = { version = "0.11", optional = true }
-serde = { version = "1.0", features = ["derive"], optional = true }
-thiserror = "1.0"
-serde_bytes = { version = "0.11", optional = true }
-smallvec = "1.6"
+hashbrown = { workspace = true, optional = true }
+serde = { workspace = true, optional = true }
+thiserror.workspace = true
+serde_bytes = { workspace = true, optional = true }
+smallvec.workspace = true
 xxhash-rust = { version = "0.8.10", features = ["xxh64"] }
+loupe = { workspace = true, optional = true, features = [
+	"indexmap",
+	"enable-indexmap",
+] }
 
-backtrace = "0.3"
-memmap2 = "0.5"
-more-asserts = "0.2"
-lazy_static = "1.4"
+backtrace.workspace = true
+memmap2.workspace = true
+more-asserts.workspace = true
 
-cfg-if = "1.0"
+cfg-if.workspace = true
 leb128 = "0.2"
-enum-iterator = "0.7.0"
+enum-iterator.workspace = true
 
-bytes = "1.0"
+bytes.workspace = true
 self_cell = "1.0"
-rkyv = { workspace = true }
-shared-buffer = { workspace = true }
+rkyv.workspace = true
+shared-buffer.workspace = true
 libc.workspace = true
+target-lexicon.workspace = true
+object = { workspace = true, features = ["write"] }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-wasmer-vm = { path = "../vm", version = "=4.3.7" }
-region = { version = "3.0" }
+wasmer-vm = { path = "../vm", version = "=6.1.0" }
+region.workspace = true
 
 [target.'cfg(target_os = "windows")'.dependencies]
-windows-sys = { version = "0.59", features = ["Win32_System_Diagnostics_Debug"] }
+windows-sys = { version = "0.59", features = [
+	"Win32_System_Diagnostics_Debug",
+] }
+
+[target.'cfg(all(target_os = "macos", target_arch = "aarch64"))'.dependencies]
+macho-unwind-info = "0.5.0"
 
 [features]
 default = ["std"]
@@ -56,19 +65,20 @@ compiler = ["translator"]
 wasmer-artifact-load = []
 wasmer-artifact-create = []
 static-artifact-load = []
-static-artifact-create = ["wasmer-object"]
+static-artifact-create = ["translator", "compiler"]
 std = ["wasmer-types/std"]
 core = ["hashbrown", "wasmer-types/core"]
 enable-serde = ["serde", "serde_bytes", "wasmer-types/enable-serde"]
+artifact-size = ["dep:loupe"]
 
 [badges]
 maintenance = { status = "experimental" }
 
 [package.metadata.docs.rs]
 features = [
-    "static-artifact-create",
-    "static-artifact-load",
-    "wasmer-artifact-create",
-    "wasmer-artifact-load",
+	"static-artifact-create",
+	"static-artifact-load",
+	"wasmer-artifact-create",
+	"wasmer-artifact-load",
 ]
 rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/compiler/README.md b/lib/compiler/README.md
index d15b26695f..a6bbf5953b 100644
--- a/lib/compiler/README.md
+++ b/lib/compiler/README.md
@@ -1,4 +1,4 @@
-# `wasmer-compiler` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE)
+# `wasmer-compiler` [![Build Status](https://github.com/wasmerio/wasmer/actions/workflows/build.yml/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE)
 
 This crate is the base for Compiler implementations.
 
diff --git a/lib/compiler/src/artifact_builders/artifact_builder.rs b/lib/compiler/src/artifact_builders/artifact_builder.rs
index 03ecc47b7c..20470eeb53 100644
--- a/lib/compiler/src/artifact_builders/artifact_builder.rs
+++ b/lib/compiler/src/artifact_builders/artifact_builder.rs
@@ -3,37 +3,45 @@
 
 #[cfg(feature = "compiler")]
 use super::trampoline::{libcall_trampoline_len, make_libcall_trampolines};
-use crate::ArtifactCreate;
+
 #[cfg(feature = "compiler")]
-use crate::EngineInner;
-use crate::Features;
+use crate::{
+    serialize::SerializableCompilation, EngineInner, ModuleEnvironment, ModuleMiddlewareChain,
+};
+use crate::{
+    serialize::{
+        ArchivedSerializableCompilation, ArchivedSerializableModule, MetadataHeader,
+        SerializableModule,
+    },
+    types::{
+        function::{CompiledFunctionFrameInfo, FunctionBody, UnwindInfo, GOT},
+        module::CompileModuleInfo,
+        relocation::Relocation,
+        section::{CustomSection, SectionIndex},
+    },
+    ArtifactCreate, Features,
+};
 #[cfg(feature = "compiler")]
-use crate::{ModuleEnvironment, ModuleMiddlewareChain};
+use wasmer_types::target::Target;
+
 use core::mem::MaybeUninit;
 use enumset::EnumSet;
-use rkyv::de::deserializers::SharedDeserializeMap;
-use rkyv::option::ArchivedOption;
+use rkyv::rancor::Error as RkyvError;
 use self_cell::self_cell;
 use shared_buffer::OwnedBuffer;
 use std::sync::Arc;
-use wasmer_types::entity::{ArchivedPrimaryMap, PrimaryMap};
-use wasmer_types::ArchivedOwnedDataInitializer;
-use wasmer_types::ArchivedSerializableCompilation;
-use wasmer_types::ArchivedSerializableModule;
-use wasmer_types::CompileModuleInfo;
-use wasmer_types::DeserializeError;
 use wasmer_types::{
-    CompileError, CpuFeature, CustomSection, Dwarf, FunctionIndex, LocalFunctionIndex, MemoryIndex,
-    MemoryStyle, ModuleHash, ModuleInfo, OwnedDataInitializer, Relocation, SectionIndex,
-    SignatureIndex, TableIndex, TableStyle, Target,
+    entity::{ArchivedPrimaryMap, PrimaryMap},
+    target::CpuFeature,
+    DeserializeError,
 };
-use wasmer_types::{
-    CompiledFunctionFrameInfo, FunctionBody, HashAlgorithm, SerializableCompilation,
-    SerializableModule,
-};
-use wasmer_types::{MetadataHeader, SerializeError};
+
+// Not every compiler backend uses these.
+#[allow(unused)]
+use wasmer_types::*;
 
 /// A compiled wasm module, ready to be instantiated.
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 pub struct ArtifactBuild {
     serializable: SerializableModule,
 }
@@ -134,9 +142,10 @@ impl ArtifactBuild {
             dynamic_function_trampolines: compilation.dynamic_function_trampolines,
             custom_sections,
             custom_section_relocations,
-            debug: compilation.debug,
+            unwind_info: compilation.unwind_info,
             libcall_trampolines,
             libcall_trampoline_len,
+            got: compilation.got,
         };
         let serializable = SerializableModule {
             compilation: serializable_compilation,
@@ -192,9 +201,14 @@ impl ArtifactBuild {
         self.serializable.compilation.libcall_trampoline_len as usize
     }
 
-    /// Get Debug optional Dwarf ref
-    pub fn get_debug_ref(&self) -> Option<&Dwarf> {
-        self.serializable.compilation.debug.as_ref()
+    /// Get a reference to the [`UnwindInfo`].
+    pub fn get_unwind_info(&self) -> &UnwindInfo {
+        &self.serializable.compilation.unwind_info
+    }
+
+    /// Get a reference to the [`GOT`].
+    pub fn get_got_ref(&self) -> &GOT {
+        &self.serializable.compilation.got
     }
 
     /// Get Function Relocations ref
@@ -212,7 +226,7 @@ impl<'a> ArtifactCreate<'a> for ArtifactBuild {
     }
 
     fn set_module_info_name(&mut self, name: String) -> bool {
-        Arc::get_mut(&mut self.serializable.compile_info.module).map_or(false, |module_info| {
+        Arc::get_mut(&mut self.serializable.compile_info.module).is_some_and(|module_info| {
             module_info.name = Some(name.to_string());
             true
         })
@@ -270,7 +284,7 @@ impl<'a> ModuleFromArchive<'a> {
         Ok(Self {
             compilation: &module.compilation,
             data_initializers: &module.data_initializers,
-            cpu_features: module.cpu_features,
+            cpu_features: module.cpu_features.to_native(),
             original_module: module,
         })
     }
@@ -287,8 +301,16 @@ self_cell!(
     impl {Debug}
 );
 
+#[cfg(feature = "artifact-size")]
+impl loupe::MemoryUsage for ArtifactBuildFromArchiveCell {
+    fn size_of_val(&self, _tracker: &mut dyn loupe::MemoryUsageTracker) -> usize {
+        std::mem::size_of_val(self.borrow_owner()) + std::mem::size_of_val(self.borrow_dependent())
+    }
+}
+
 /// A compiled wasm module that was loaded from a serialized archive.
 #[derive(Clone, Debug)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 pub struct ArtifactBuildFromArchive {
     cell: Arc<ArtifactBuildFromArchiveCell>,
 
@@ -297,6 +319,7 @@ pub struct ArtifactBuildFromArchive {
 }
 
 impl ArtifactBuildFromArchive {
+    #[allow(unused)]
     pub(crate) fn try_new(
         buffer: OwnedBuffer,
         module_builder: impl FnOnce(
@@ -307,10 +330,9 @@ impl ArtifactBuildFromArchive {
 
         let cell = ArtifactBuildFromArchiveCell::try_new(buffer, |buffer| {
             let module = module_builder(buffer)?;
-            let mut deserializer = SharedDeserializeMap::new();
             compile_info = MaybeUninit::new(
-                rkyv::Deserialize::deserialize(&module.compile_info, &mut deserializer)
-                    .map_err(|e| DeserializeError::CorruptedBinary(format!("{:?}", e)))?,
+                rkyv::deserialize::<_, RkyvError>(&module.compile_info)
+                    .map_err(|e| DeserializeError::CorruptedBinary(format!("{e:?}")))?,
             );
             ModuleFromArchive::from_serializable_module(module)
         })?;
@@ -384,7 +406,10 @@ impl ArtifactBuildFromArchive {
 
     /// Get LibCall Trampoline Section Index
     pub fn get_libcall_trampolines(&self) -> SectionIndex {
-        self.cell.borrow_dependent().compilation.libcall_trampolines
+        rkyv::deserialize::<_, RkyvError>(
+            &self.cell.borrow_dependent().compilation.libcall_trampolines,
+        )
+        .unwrap()
     }
 
     /// Get LibCall Trampoline Length
@@ -392,15 +417,22 @@ impl ArtifactBuildFromArchive {
         self.cell
             .borrow_dependent()
             .compilation
-            .libcall_trampoline_len as usize
+            .libcall_trampoline_len
+            .to_native() as usize
     }
 
-    /// Get Debug optional Dwarf ref
-    pub fn get_debug_ref(&self) -> Option<&Dwarf> {
-        match self.cell.borrow_dependent().compilation.debug {
-            ArchivedOption::Some(ref x) => Some(x),
-            ArchivedOption::None => None,
-        }
+    /// Get an unarchived [`UnwindInfo`].
+    pub fn get_unwind_info(&self) -> UnwindInfo {
+        rkyv::deserialize::<_, rkyv::rancor::Error>(
+            &self.cell.borrow_dependent().compilation.unwind_info,
+        )
+        .unwrap()
+    }
+
+    /// Get an unarchived [`GOT`].
+    pub fn get_got_ref(&self) -> GOT {
+        rkyv::deserialize::<_, rkyv::rancor::Error>(&self.cell.borrow_dependent().compilation.got)
+            .unwrap()
     }
 
     /// Get Function Relocations ref
@@ -414,12 +446,10 @@ impl ArtifactBuildFromArchive {
     pub fn deserialize_frame_info_ref(
         &self,
     ) -> Result<PrimaryMap<LocalFunctionIndex, CompiledFunctionFrameInfo>, DeserializeError> {
-        let mut deserializer = SharedDeserializeMap::new();
-        rkyv::Deserialize::deserialize(
+        rkyv::deserialize::<_, RkyvError>(
             &self.cell.borrow_dependent().compilation.function_frame_info,
-            &mut deserializer,
         )
-        .map_err(|e| DeserializeError::CorruptedBinary(format!("{:?}", e)))
+        .map_err(|e| DeserializeError::CorruptedBinary(format!("{e:?}")))
     }
 }
 
@@ -432,7 +462,7 @@ impl<'a> ArtifactCreate<'a> for ArtifactBuildFromArchive {
     }
 
     fn set_module_info_name(&mut self, name: String) -> bool {
-        Arc::get_mut(&mut self.compile_info.module).map_or(false, |module_info| {
+        Arc::get_mut(&mut self.compile_info.module).is_some_and(|module_info| {
             module_info.name = Some(name.to_string());
             true
         })
@@ -470,12 +500,9 @@ impl<'a> ArtifactCreate<'a> for ArtifactBuildFromArchive {
         // deserialized from a file makes little sense, so hopefully, this is not a
         // common use-case.
 
-        let mut deserializer = SharedDeserializeMap::new();
-        let mut module: SerializableModule = rkyv::Deserialize::deserialize(
-            self.cell.borrow_dependent().original_module,
-            &mut deserializer,
-        )
-        .map_err(|e| SerializeError::Generic(e.to_string()))?;
+        let mut module: SerializableModule =
+            rkyv::deserialize::<_, RkyvError>(self.cell.borrow_dependent().original_module)
+                .map_err(|e| SerializeError::Generic(e.to_string()))?;
         module.compile_info = self.compile_info.clone();
         serialize_module(&module)
     }
diff --git a/lib/compiler/src/artifact_builders/mod.rs b/lib/compiler/src/artifact_builders/mod.rs
index b7373c8d43..acadda9137 100644
--- a/lib/compiler/src/artifact_builders/mod.rs
+++ b/lib/compiler/src/artifact_builders/mod.rs
@@ -1,9 +1,9 @@
 //! Generic Artifact abstraction for Wasmer Engines.
 
 mod artifact_builder;
-#[cfg(feature = "compiler")]
 mod trampoline;
 
 pub use self::artifact_builder::{ArtifactBuild, ArtifactBuildFromArchive, ModuleFromArchive};
+pub use self::trampoline::get_libcall_trampoline;
 #[cfg(feature = "compiler")]
 pub use self::trampoline::*;
diff --git a/lib/compiler/src/artifact_builders/trampoline.rs b/lib/compiler/src/artifact_builders/trampoline.rs
index 387b62608a..39d021bb68 100644
--- a/lib/compiler/src/artifact_builders/trampoline.rs
+++ b/lib/compiler/src/artifact_builders/trampoline.rs
@@ -3,10 +3,15 @@
 //! This is needed because the target of libcall relocations are not reachable
 //! through normal branch instructions.
 
+#![cfg_attr(not(feature = "compiler"), allow(dead_code))]
+
 use enum_iterator::IntoEnumIterator;
-use wasmer_types::{
-    Architecture, CustomSection, CustomSectionProtection, LibCall, Relocation, RelocationKind,
-    RelocationTarget, SectionBody, Target,
+use wasmer_types::target::{Architecture, Target};
+use wasmer_types::LibCall;
+
+use crate::types::{
+    relocation::{Relocation, RelocationKind, RelocationTarget},
+    section::{CustomSection, CustomSectionProtection, SectionBody},
 };
 
 // SystemV says that both x16 and x17 are available as intra-procedural scratch
@@ -36,6 +41,15 @@ const RISCV64_TRAMPOLINE: [u8; 24] = [
     0, 0, 0, 0,
 ];
 
+// PCADDI r12, 0      0c 00 00 18
+// LD.D r12, r12, 16  8c 41 c0 28
+// JR r12             80 01 00 4c [00 00 00 00]
+// JMPADDR            00 00 00 00 00 00 00 00
+const LOONGARCH64_TRAMPOLINE: [u8; 24] = [
+    0x0c, 0x00, 0x00, 0x18, 0x8c, 0x41, 0xc0, 0x28, 0x80, 0x01, 0x00, 0x4c, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0,
+];
+
 fn make_trampoline(
     target: &Target,
     libcall: LibCall,
@@ -70,7 +84,16 @@ fn make_trampoline(
                 addend: 0,
             });
         }
-        arch => panic!("Unsupported architecture: {}", arch),
+        Architecture::LoongArch64 => {
+            code.extend(LOONGARCH64_TRAMPOLINE);
+            relocations.push(Relocation {
+                kind: RelocationKind::Abs8,
+                reloc_target: RelocationTarget::LibCall(libcall),
+                offset: code.len() as u32 - 8,
+                addend: 0,
+            });
+        }
+        arch => panic!("Unsupported architecture: {arch}"),
     };
 }
 
@@ -80,7 +103,8 @@ pub fn libcall_trampoline_len(target: &Target) -> usize {
         Architecture::Aarch64(_) => AARCH64_TRAMPOLINE.len(),
         Architecture::X86_64 => X86_64_TRAMPOLINE.len(),
         Architecture::Riscv64(_) => RISCV64_TRAMPOLINE.len(),
-        arch => panic!("Unsupported architecture: {}", arch),
+        Architecture::LoongArch64 => LOONGARCH64_TRAMPOLINE.len(),
+        arch => panic!("Unsupported architecture: {arch}"),
     }
 }
 
@@ -93,6 +117,7 @@ pub fn make_libcall_trampolines(target: &Target) -> CustomSection {
     }
     CustomSection {
         protection: CustomSectionProtection::ReadExecute,
+        alignment: None,
         bytes: SectionBody::new_with_vec(code),
         relocations,
     }
diff --git a/lib/compiler/src/compiler.rs b/lib/compiler/src/compiler.rs
index e65494822e..82d3976c7d 100644
--- a/lib/compiler/src/compiler.rs
+++ b/lib/compiler/src/compiler.rs
@@ -1,19 +1,21 @@
 //! This module mainly outputs the `Compiler` trait that custom
 //! compilers will need to implement.
 
-use crate::lib::std::boxed::Box;
-use crate::lib::std::sync::Arc;
-use crate::translator::ModuleMiddleware;
-use crate::FunctionBodyData;
-use crate::ModuleTranslationState;
+use crate::types::{module::CompileModuleInfo, symbols::SymbolRegistry};
+use crate::{
+    lib::std::{boxed::Box, sync::Arc},
+    translator::ModuleMiddleware,
+    types::function::Compilation,
+    FunctionBodyData, ModuleTranslationState,
+};
 use enumset::EnumSet;
-use wasmer_types::compilation::function::Compilation;
-use wasmer_types::compilation::module::CompileModuleInfo;
-use wasmer_types::compilation::symbols::SymbolRegistry;
-use wasmer_types::compilation::target::Target;
-use wasmer_types::entity::PrimaryMap;
-use wasmer_types::error::CompileError;
-use wasmer_types::{CpuFeature, Features, LocalFunctionIndex};
+use wasmer_types::{
+    entity::PrimaryMap,
+    error::CompileError,
+    target::{CpuFeature, Target, UserCompilerOptimizations},
+    Features, LocalFunctionIndex,
+};
+#[cfg(feature = "translator")]
 use wasmparser::{Validator, WasmFeatures};
 
 /// The compiler configuration options.
@@ -37,6 +39,12 @@ pub trait CompilerConfig {
         // in case they create an IR that they can verify.
     }
 
+    /// Enable generation of perfmaps to sample the JIT compiled frames.
+    fn enable_perfmap(&mut self) {
+        // By default we do nothing, each backend will need to customize this
+        // in case they create an IR that they can verify.
+    }
+
     /// Enable NaN canonicalization.
     ///
     /// NaN canonicalization is useful when trying to run WebAssembly
@@ -50,7 +58,12 @@ pub trait CompilerConfig {
     fn compiler(self: Box<Self>) -> Box<dyn Compiler>;
 
     /// Gets the default features for this compiler in the given target
-    fn default_features_for_target(&self, _target: &Target) -> Features {
+    fn default_features_for_target(&self, target: &Target) -> Features {
+        self.supported_features_for_target(target)
+    }
+
+    /// Gets the supported features for this compiler in the given target
+    fn supported_features_for_target(&self, _target: &Target) -> Features {
         Features::default()
     }
 
@@ -68,45 +81,66 @@ where
 }
 
 /// An implementation of a Compiler from parsed WebAssembly module to Compiled native code.
-pub trait Compiler: Send {
+pub trait Compiler: Send + std::fmt::Debug {
     /// Returns a descriptive name for this compiler.
     ///
     /// Note that this is an API breaking change since 3.0
     fn name(&self) -> &str;
 
+    /// Returns the deterministic id of this compiler. Same compilers with different
+    /// optimizations map to different deterministic IDs.
+    fn deterministic_id(&self) -> String;
+
+    /// Add suggested optimizations to this compiler.
+    ///
+    /// # Note
+    ///
+    /// Not every compiler supports every optimization. This function may fail (i.e. not set the
+    /// suggested optimizations) silently if the underlying compiler does not support one or
+    /// more optimizations.
+    fn with_opts(
+        &mut self,
+        suggested_compiler_opts: &UserCompilerOptimizations,
+    ) -> Result<(), CompileError> {
+        _ = suggested_compiler_opts;
+        Ok(())
+    }
+
     /// Validates a module.
     ///
     /// It returns the a succesful Result in case is valid, `CompileError` in case is not.
+    #[cfg(feature = "translator")]
     fn validate_module(&self, features: &Features, data: &[u8]) -> Result<(), CompileError> {
-        let wasm_features = WasmFeatures {
-            bulk_memory: features.bulk_memory,
-            threads: features.threads,
-            reference_types: features.reference_types,
-            multi_value: features.multi_value,
-            simd: features.simd,
-            tail_call: features.tail_call,
-            multi_memory: features.multi_memory,
-            memory64: features.memory64,
-            exceptions: features.exceptions,
-            extended_const: features.extended_const,
-            relaxed_simd: features.relaxed_simd,
-            mutable_global: true,
-            saturating_float_to_int: true,
-            floats: true,
-            sign_extension: true,
-
-            // Not supported
-            component_model: false,
-            function_references: false,
-            memory_control: false,
-            gc: false,
-            component_model_values: false,
-            component_model_nested_names: false,
-        };
+        let mut wasm_features = WasmFeatures::default();
+        wasm_features.set(WasmFeatures::BULK_MEMORY, features.bulk_memory);
+        wasm_features.set(WasmFeatures::THREADS, features.threads);
+        wasm_features.set(WasmFeatures::REFERENCE_TYPES, features.reference_types);
+        wasm_features.set(WasmFeatures::MULTI_VALUE, features.multi_value);
+        wasm_features.set(WasmFeatures::SIMD, features.simd);
+        wasm_features.set(WasmFeatures::TAIL_CALL, features.tail_call);
+        wasm_features.set(WasmFeatures::MULTI_MEMORY, features.multi_memory);
+        wasm_features.set(WasmFeatures::MEMORY64, features.memory64);
+        wasm_features.set(WasmFeatures::EXCEPTIONS, features.exceptions);
+        wasm_features.set(WasmFeatures::EXTENDED_CONST, features.extended_const);
+        wasm_features.set(WasmFeatures::RELAXED_SIMD, features.relaxed_simd);
+        wasm_features.set(WasmFeatures::MUTABLE_GLOBAL, true);
+        wasm_features.set(WasmFeatures::SATURATING_FLOAT_TO_INT, true);
+        wasm_features.set(WasmFeatures::FLOATS, true);
+        wasm_features.set(WasmFeatures::SIGN_EXTENSION, true);
+        wasm_features.set(WasmFeatures::GC_TYPES, true);
+
+        // Not supported
+        wasm_features.set(WasmFeatures::COMPONENT_MODEL, false);
+        wasm_features.set(WasmFeatures::FUNCTION_REFERENCES, false);
+        wasm_features.set(WasmFeatures::MEMORY_CONTROL, false);
+        wasm_features.set(WasmFeatures::GC, false);
+        wasm_features.set(WasmFeatures::COMPONENT_MODEL_VALUES, false);
+        wasm_features.set(WasmFeatures::COMPONENT_MODEL_NESTED_NAMES, false);
+
         let mut validator = Validator::new_with_features(wasm_features);
         validator
             .validate_all(data)
-            .map_err(|e| CompileError::Validate(format!("{}", e)))?;
+            .map_err(|e| CompileError::Validate(format!("{e}")))?;
         Ok(())
     }
 
@@ -146,4 +180,9 @@ pub trait Compiler: Send {
     fn get_cpu_features_used(&self, cpu_features: &EnumSet<CpuFeature>) -> EnumSet<CpuFeature> {
         *cpu_features
     }
+
+    /// Get whether `perfmap` is enabled or not.
+    fn get_perfmap_enabled(&self) -> bool {
+        false
+    }
 }
diff --git a/lib/compiler/src/engine/artifact.rs b/lib/compiler/src/engine/artifact.rs
index 0864abf46c..faeeaea2fe 100644
--- a/lib/compiler/src/engine/artifact.rs
+++ b/lib/compiler/src/engine/artifact.rs
@@ -1,49 +1,55 @@
 //! Define `Artifact`, based on `ArtifactBuild`
 //! to allow compiling and instantiating to be done as separate steps.
 
-use crate::engine::link::link_module;
-use crate::lib::std::vec::IntoIter;
-use crate::ArtifactBuild;
-use crate::ArtifactBuildFromArchive;
-use crate::ArtifactCreate;
-use crate::Features;
-use crate::FrameInfosVariant;
+use std::sync::{
+    atomic::{AtomicUsize, Ordering::SeqCst},
+    Arc,
+};
+
+#[cfg(feature = "compiler")]
 use crate::ModuleEnvironment;
 use crate::{
-    register_frame_info, resolve_imports, FunctionExtent, GlobalFrameInfoRegistration,
-    InstantiationError, Tunables,
+    engine::{link::link_module, resolver::resolve_tags},
+    lib::std::vec::IntoIter,
+    register_frame_info, resolve_imports,
+    serialize::{MetadataHeader, SerializableModule},
+    types::relocation::{RelocationLike, RelocationTarget},
+    ArtifactBuild, ArtifactBuildFromArchive, ArtifactCreate, Engine, EngineInner, Features,
+    FrameInfosVariant, FunctionExtent, GlobalFrameInfoRegistration, InstantiationError, Tunables,
 };
+#[cfg(any(feature = "static-artifact-create", feature = "static-artifact-load"))]
+use crate::{serialize::SerializableCompilation, types::symbols::ModuleMetadata};
 #[cfg(feature = "static-artifact-create")]
-use crate::{Compiler, FunctionBodyData, ModuleTranslationState};
-use crate::{Engine, EngineInner};
+use crate::{types::module::CompileModuleInfo, Compiler, FunctionBodyData, ModuleTranslationState};
+
 use enumset::EnumSet;
 use shared_buffer::OwnedBuffer;
+
 #[cfg(any(feature = "static-artifact-create", feature = "static-artifact-load"))]
 use std::mem;
-use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
-use std::sync::Arc;
-#[cfg(feature = "static-artifact-create")]
-use wasmer_object::{emit_compilation, emit_data, get_object_for_target, Object};
-#[cfg(any(feature = "static-artifact-create", feature = "static-artifact-load"))]
-use wasmer_types::compilation::symbols::ModuleMetadata;
-use wasmer_types::entity::{BoxedSlice, PrimaryMap};
-use wasmer_types::ArchivedDataInitializerLocation;
-use wasmer_types::ArchivedOwnedDataInitializer;
+
 #[cfg(feature = "static-artifact-create")]
-use wasmer_types::CompileModuleInfo;
-use wasmer_types::DataInitializerLike;
-use wasmer_types::DataInitializerLocation;
-use wasmer_types::DataInitializerLocationLike;
-use wasmer_types::MetadataHeader;
+use crate::object::{
+    emit_compilation, emit_data, get_object_for_target, Object, ObjectMetadataBuilder,
+};
+
+#[cfg(feature = "compiler")]
+use wasmer_types::HashAlgorithm;
 use wasmer_types::{
-    CompileError, CpuFeature, DataInitializer, DeserializeError, FunctionIndex, HashAlgorithm,
-    LocalFunctionIndex, MemoryIndex, ModuleInfo, OwnedDataInitializer, SignatureIndex, TableIndex,
-    Target,
+    entity::{BoxedSlice, PrimaryMap},
+    target::{CpuFeature, Target},
+    ArchivedDataInitializerLocation, ArchivedOwnedDataInitializer, CompileError, DataInitializer,
+    DataInitializerLike, DataInitializerLocation, DataInitializerLocationLike, DeserializeError,
+    FunctionIndex, LocalFunctionIndex, MemoryIndex, ModuleInfo, OwnedDataInitializer,
+    SerializeError, SignatureIndex, TableIndex,
+};
+
+use wasmer_vm::{
+    FunctionBodyPtr, InstanceAllocator, MemoryStyle, StoreObjects, TableStyle, TrapHandlerFn,
+    VMConfig, VMExtern, VMInstance, VMSharedSignatureIndex, VMTrampoline,
 };
-use wasmer_types::{SerializableModule, SerializeError};
-use wasmer_vm::{FunctionBodyPtr, MemoryStyle, TableStyle, VMSharedSignatureIndex, VMTrampoline};
-use wasmer_vm::{InstanceAllocator, StoreObjects, TrapHandlerFn, VMConfig, VMExtern, VMInstance};
 
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 pub struct AllocatedArtifact {
     // This shows if the frame info has been regestered already or not.
     // Because the 'GlobalFrameInfoRegistration' ownership can be transfered to EngineInner
@@ -55,6 +61,8 @@ pub struct AllocatedArtifact {
     // so the GloabelFrameInfo and MMap stays in sync and get dropped at the same time
     frame_info_registration: Option<GlobalFrameInfoRegistration>,
     finished_functions: BoxedSlice<LocalFunctionIndex, FunctionBodyPtr>,
+
+    #[cfg_attr(feature = "artifact-size", loupe(skip))]
     finished_function_call_trampolines: BoxedSlice<SignatureIndex, VMTrampoline>,
     finished_dynamic_function_trampolines: BoxedSlice<FunctionIndex, FunctionBodyPtr>,
     signatures: BoxedSlice<SignatureIndex, VMSharedSignatureIndex>,
@@ -62,6 +70,7 @@ pub struct AllocatedArtifact {
 }
 
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[repr(transparent)]
 /// A unique identifier for an Artifact.
 pub struct ArtifactId {
@@ -91,6 +100,7 @@ impl Default for ArtifactId {
 }
 
 /// A compiled wasm module, ready to be instantiated.
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 pub struct Artifact {
     id: ArtifactId,
     artifact: ArtifactBuildVariant,
@@ -102,6 +112,8 @@ pub struct Artifact {
 /// Artifacts may be created as the result of the compilation of a wasm
 /// module, corresponding to `ArtifactBuildVariant::Plain`, or loaded
 /// from an archive, corresponding to `ArtifactBuildVariant::Archived`.
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[allow(clippy::large_enum_variant)]
 pub enum ArtifactBuildVariant {
     Plain(ArtifactBuild),
     Archived(ArtifactBuildFromArchive),
@@ -202,10 +214,10 @@ impl Artifact {
                 Ok(v) => {
                     return Ok(v);
                 }
-                Err(_) => {
-                    return Err(DeserializeError::Incompatible(
-                        "The provided bytes are not wasmer-universal".to_string(),
-                    ));
+                Err(e) => {
+                    return Err(DeserializeError::Incompatible(format!(
+                        "The provided bytes are not wasmer-universal: {e}"
+                    )));
                 }
             }
         }
@@ -247,10 +259,10 @@ impl Artifact {
                 Ok(v) => {
                     return Ok(v);
                 }
-                Err(_) => {
-                    return Err(DeserializeError::Incompatible(
-                        "The provided bytes are not wasmer-universal".to_string(),
-                    ));
+                Err(e) => {
+                    return Err(DeserializeError::Incompatible(format!(
+                        "The provided bytes are not wasmer-universal: {e}"
+                    )));
                 }
             }
         }
@@ -319,6 +331,44 @@ impl Artifact {
             )?,
         };
 
+        let get_got_address: Box<dyn Fn(RelocationTarget) -> Option<usize>> = match &artifact {
+            ArtifactBuildVariant::Plain(ref p) => {
+                if let Some(got) = p.get_got_ref().index {
+                    let relocs: Vec<_> = p.get_custom_section_relocations_ref()[got]
+                        .iter()
+                        .map(|v| (v.reloc_target, v.offset))
+                        .collect();
+                    let got_base = custom_sections[got].0 as usize;
+                    Box::new(move |t: RelocationTarget| {
+                        relocs
+                            .iter()
+                            .find(|(v, _)| v == &t)
+                            .map(|(_, o)| got_base + (*o as usize))
+                    })
+                } else {
+                    Box::new(|_: RelocationTarget| None)
+                }
+            }
+
+            ArtifactBuildVariant::Archived(ref p) => {
+                if let Some(got) = p.get_got_ref().index {
+                    let relocs: Vec<_> = p.get_custom_section_relocations_ref()[got]
+                        .iter()
+                        .map(|v| (v.reloc_target(), v.offset))
+                        .collect();
+                    let got_base = custom_sections[got].0 as usize;
+                    Box::new(move |t: RelocationTarget| {
+                        relocs
+                            .iter()
+                            .find(|(v, _)| v == &t)
+                            .map(|(_, o)| got_base + (o.to_native() as usize))
+                    })
+                } else {
+                    Box::new(|_: RelocationTarget| None)
+                }
+            }
+        };
+
         match &artifact {
             ArtifactBuildVariant::Plain(p) => link_module(
                 module_info,
@@ -332,6 +382,7 @@ impl Artifact {
                     .map(|(k, v)| (k, v.iter())),
                 p.get_libcall_trampolines(),
                 p.get_libcall_trampoline_len(),
+                &get_got_address,
             ),
             ArtifactBuildVariant::Archived(a) => link_module(
                 module_info,
@@ -345,6 +396,7 @@ impl Artifact {
                     .map(|(k, v)| (k, v.iter())),
                 a.get_libcall_trampolines(),
                 a.get_libcall_trampoline_len(),
+                &get_got_address,
             ),
         };
 
@@ -358,33 +410,56 @@ impl Artifact {
                 .collect::<PrimaryMap<_, _>>()
         };
 
-        let debug_ref = match &artifact {
-            ArtifactBuildVariant::Plain(p) => p.get_debug_ref(),
-            ArtifactBuildVariant::Archived(a) => a.get_debug_ref(),
+        let eh_frame = match &artifact {
+            ArtifactBuildVariant::Plain(p) => p.get_unwind_info().eh_frame.map(|v| unsafe {
+                std::slice::from_raw_parts(
+                    *custom_sections[v],
+                    p.get_custom_sections_ref()[v].bytes.len(),
+                )
+            }),
+            ArtifactBuildVariant::Archived(a) => a.get_unwind_info().eh_frame.map(|v| unsafe {
+                std::slice::from_raw_parts(
+                    *custom_sections[v],
+                    a.get_custom_sections_ref()[v].bytes.len(),
+                )
+            }),
         };
-        let eh_frame = match debug_ref {
-            Some(debug) => {
-                let eh_frame_section_size = match &artifact {
-                    ArtifactBuildVariant::Plain(p) => {
-                        p.get_custom_sections_ref()[debug.eh_frame].bytes.len()
-                    }
-                    ArtifactBuildVariant::Archived(a) => {
-                        a.get_custom_sections_ref()[debug.eh_frame].bytes.len()
-                    }
-                };
-                let eh_frame_section_pointer = custom_sections[debug.eh_frame];
-                Some(unsafe {
-                    std::slice::from_raw_parts(*eh_frame_section_pointer, eh_frame_section_size)
+
+        let compact_unwind = match &artifact {
+            ArtifactBuildVariant::Plain(p) => p.get_unwind_info().compact_unwind.map(|v| unsafe {
+                std::slice::from_raw_parts(
+                    *custom_sections[v],
+                    p.get_custom_sections_ref()[v].bytes.len(),
+                )
+            }),
+            ArtifactBuildVariant::Archived(a) => {
+                a.get_unwind_info().compact_unwind.map(|v| unsafe {
+                    std::slice::from_raw_parts(
+                        *custom_sections[v],
+                        a.get_custom_sections_ref()[v].bytes.len(),
+                    )
                 })
             }
-            None => None,
         };
 
+        // This needs to be called before publishing the `eh_frame`.
+        engine_inner.register_compact_unwind(
+            compact_unwind,
+            get_got_address(RelocationTarget::LibCall(wasmer_vm::LibCall::EHPersonality)),
+        )?;
+
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            engine_inner.register_perfmap(&finished_functions, module_info)?;
+        }
+
         // Make all code compiled thus far executable.
         engine_inner.publish_compiled_code();
 
         engine_inner.publish_eh_frame(eh_frame)?;
 
+        drop(get_got_address);
+
         let finished_function_lengths = finished_functions
             .values()
             .map(|extent| extent.length)
@@ -417,7 +492,7 @@ impl Artifact {
 
         artifact
             .internal_register_frame_info()
-            .map_err(|e| DeserializeError::CorruptedBinary(format!("{:?}", e)))?;
+            .map_err(|e| DeserializeError::CorruptedBinary(format!("{e:?}")))?;
         if let Some(frame_info) = artifact.internal_take_frame_info_registration() {
             engine_inner.register_frame_info(frame_info);
         }
@@ -597,7 +672,7 @@ pub enum DataInitializerLocationVariant<'a> {
     Archived(&'a ArchivedDataInitializerLocation),
 }
 
-impl<'a> DataInitializerLocationVariant<'a> {
+impl DataInitializerLocationVariant<'_> {
     pub fn clone_to_plain(&self) -> DataInitializerLocation {
         match self {
             Self::Plain(p) => (*p).clone(),
@@ -610,7 +685,7 @@ impl<'a> DataInitializerLocationVariant<'a> {
     }
 }
 
-impl<'a> DataInitializerLocationLike for DataInitializerLocationVariant<'a> {
+impl DataInitializerLocationLike for DataInitializerLocationVariant<'_> {
     fn memory_index(&self) -> MemoryIndex {
         match self {
             Self::Plain(plain) => plain.memory_index(),
@@ -634,17 +709,6 @@ impl<'a> DataInitializerLocationLike for DataInitializerLocationVariant<'a> {
 }
 
 impl Artifact {
-    /// Register thie `Artifact` stack frame information into the global scope.
-    ///
-    /// This is not required anymore as it's done automaticaly when creating by 'Artifact::from_parts'
-    #[deprecated(
-        since = "4.0.0",
-        note = "done automaticaly by Artifact::from_parts, use 'take_frame_info_registration' if you use this method"
-    )]
-    pub fn register_frame_info(&mut self) -> Result<(), DeserializeError> {
-        self.internal_register_frame_info()
-    }
-
     fn internal_register_frame_info(&mut self) -> Result<(), DeserializeError> {
         if self
             .allocated
@@ -699,13 +763,6 @@ impl Artifact {
         Ok(())
     }
 
-    /// The GlobalFrameInfoRegistration needs to be transfered to EngineInner if
-    /// register_frame_info has been used.
-    #[deprecated(since = "4.0.0", note = "done automaticaly by Artifact::from_parts.")]
-    pub fn take_frame_info_registration(&mut self) -> Option<GlobalFrameInfoRegistration> {
-        self.internal_take_frame_info_registration()
-    }
-
     fn internal_take_frame_info_registration(&mut self) -> Option<GlobalFrameInfoRegistration> {
         let frame_info_registration = &mut self
             .allocated
@@ -788,6 +845,9 @@ impl Artifact {
         self.preinstantiate()?;
 
         let module = self.create_module_info();
+
+        let tags = resolve_tags(&module, imports, context).map_err(InstantiationError::Link)?;
+
         let imports = resolve_imports(
             &module,
             imports,
@@ -835,6 +895,7 @@ impl Artifact {
             finished_memories,
             finished_tables,
             finished_globals,
+            tags,
             imports,
             self.signatures().clone(),
         )
@@ -986,14 +1047,14 @@ impl Artifact {
             ModuleInfo,
             Object<'data>,
             usize,
-            Box<dyn wasmer_types::SymbolRegistry>,
+            Box<dyn crate::types::symbols::SymbolRegistry>,
         ),
         CompileError,
     > {
-        use wasmer_types::{compilation::symbols::ModuleMetadataSymbolRegistry, SymbolRegistry};
+        use crate::types::symbols::{ModuleMetadataSymbolRegistry, SymbolRegistry};
 
         fn to_compile_error(err: impl std::error::Error) -> CompileError {
-            CompileError::Codegen(format!("{}", err))
+            CompileError::Codegen(format!("{err}"))
         }
 
         let target_triple = target.triple();
@@ -1018,36 +1079,59 @@ impl Artifact {
         - SignatureIndex -> VMSharedSignatureindextureIndex // signatures
          */
 
-        let serialized_data = metadata.serialize().map_err(to_compile_error)?;
-        let mut metadata_binary = vec![];
-        metadata_binary.extend(MetadataHeader::new(serialized_data.len()).into_bytes());
-        metadata_binary.extend(serialized_data);
+        let mut metadata_builder =
+            ObjectMetadataBuilder::new(&metadata, target_triple).map_err(to_compile_error)?;
 
         let (_compile_info, symbol_registry) = metadata.split();
 
-        let compilation: wasmer_types::compilation::function::Compilation = compiler
-            .compile_module(
-                target,
-                &metadata.compile_info,
-                module_translation.as_ref().unwrap(),
-                function_body_inputs,
-            )?;
+        let compilation: crate::types::function::Compilation = compiler.compile_module(
+            target,
+            &metadata.compile_info,
+            module_translation.as_ref().unwrap(),
+            function_body_inputs,
+        )?;
         let mut obj = get_object_for_target(target_triple).map_err(to_compile_error)?;
 
         let object_name = ModuleMetadataSymbolRegistry {
             prefix: metadata_prefix.unwrap_or_default().to_string(),
         }
-        .symbol_to_name(wasmer_types::Symbol::Metadata);
-
-        emit_data(&mut obj, object_name.as_bytes(), &metadata_binary, 1)
-            .map_err(to_compile_error)?;
+        .symbol_to_name(crate::types::symbols::Symbol::Metadata);
+
+        let default_align = match target_triple.architecture {
+            target_lexicon::Architecture::Aarch64(_) => {
+                if matches!(
+                    target_triple.operating_system,
+                    target_lexicon::OperatingSystem::Darwin
+                ) {
+                    8
+                } else {
+                    4
+                }
+            }
+            _ => 1,
+        };
 
-        emit_compilation(&mut obj, compilation, &symbol_registry, target_triple)
-            .map_err(to_compile_error)?;
+        let offset = emit_data(
+            &mut obj,
+            object_name.as_bytes(),
+            metadata_builder.placeholder_data(),
+            default_align,
+        )
+        .map_err(to_compile_error)?;
+        metadata_builder.set_section_offset(offset);
+
+        emit_compilation(
+            &mut obj,
+            compilation,
+            &symbol_registry,
+            target_triple,
+            &metadata_builder,
+        )
+        .map_err(to_compile_error)?;
         Ok((
             Arc::try_unwrap(metadata.compile_info.module).unwrap(),
             obj,
-            metadata_binary.len(),
+            metadata_builder.placeholder_data().len(),
             Box::new(symbol_registry),
         ))
     }
@@ -1088,8 +1172,6 @@ impl Artifact {
         engine: &Engine,
         bytes: OwnedBuffer,
     ) -> Result<Self, DeserializeError> {
-        use wasmer_types::SerializableCompilation;
-
         let bytes = bytes.as_slice();
         let metadata_len = MetadataHeader::parse(bytes)?;
         let metadata_slice = Self::get_byte_slice(bytes, MetadataHeader::LEN, bytes.len())?;
diff --git a/lib/compiler/src/engine/builder.rs b/lib/compiler/src/engine/builder.rs
index 5cb356526b..c4d56c0a20 100644
--- a/lib/compiler/src/engine/builder.rs
+++ b/lib/compiler/src/engine/builder.rs
@@ -1,10 +1,12 @@
 use super::Engine;
+#[cfg(feature = "compiler")]
 use crate::CompilerConfig;
-use wasmer_types::{Features, HashAlgorithm, Target};
+use wasmer_types::{target::Target, Features, HashAlgorithm};
 
 /// The Builder contents of `Engine`
 pub struct EngineBuilder {
     /// The compiler
+    #[cfg(feature = "compiler")]
     compiler_config: Option<Box<dyn CompilerConfig>>,
     /// The machine target
     target: Option<Target>,
@@ -16,6 +18,7 @@ pub struct EngineBuilder {
 
 impl EngineBuilder {
     /// Create a new builder with pre-made components
+    #[cfg(feature = "compiler")]
     pub fn new<T>(compiler_config: T) -> Self
     where
         T: Into<Box<dyn CompilerConfig>>,
@@ -31,6 +34,7 @@ impl EngineBuilder {
     /// Create a new headless Backend
     pub fn headless() -> Self {
         Self {
+            #[cfg(feature = "compiler")]
             compiler_config: None,
             target: None,
             features: None,
diff --git a/lib/compiler/src/engine/code_memory.rs b/lib/compiler/src/engine/code_memory.rs
index 99e413243e..a4ab625d9d 100644
--- a/lib/compiler/src/engine/code_memory.rs
+++ b/lib/compiler/src/engine/code_memory.rs
@@ -3,10 +3,13 @@
 
 //! Memory management for executable code.
 use super::unwind::UnwindRegistry;
-use crate::GlobalFrameInfoRegistration;
-use wasmer_types::{
-    compilation::unwind::CompiledFunctionUnwindInfoLike, CompiledFunctionUnwindInfoReference,
-    CustomSectionLike, FunctionBodyLike,
+use crate::{
+    types::{
+        function::FunctionBodyLike,
+        section::CustomSectionLike,
+        unwind::{CompiledFunctionUnwindInfoLike, CompiledFunctionUnwindInfoReference},
+    },
+    GlobalFrameInfoRegistration,
 };
 use wasmer_vm::{Mmap, VMFunctionBody};
 
diff --git a/lib/compiler/src/engine/inner.rs b/lib/compiler/src/engine/inner.rs
index 3957c8fe1d..8d1637fbad 100644
--- a/lib/compiler/src/engine/inner.rs
+++ b/lib/compiler/src/engine/inner.rs
@@ -2,32 +2,36 @@
 
 use crate::engine::builder::EngineBuilder;
 #[cfg(not(target_arch = "wasm32"))]
-use crate::Artifact;
-#[cfg(not(target_arch = "wasm32"))]
-use crate::BaseTunables;
-#[cfg(not(target_arch = "wasm32"))]
-use crate::CodeMemory;
-#[cfg(not(target_arch = "wasm32"))]
-use crate::GlobalFrameInfoRegistration;
+use crate::{
+    types::{
+        function::FunctionBodyLike,
+        section::{CustomSectionLike, CustomSectionProtection, SectionIndex},
+    },
+    Artifact, BaseTunables, CodeMemory, FunctionExtent, GlobalFrameInfoRegistration, Tunables,
+};
 #[cfg(feature = "compiler")]
 use crate::{Compiler, CompilerConfig};
-#[cfg(not(target_arch = "wasm32"))]
-use crate::{FunctionExtent, Tunables};
+
 #[cfg(not(target_arch = "wasm32"))]
 use shared_buffer::OwnedBuffer;
+
 #[cfg(not(target_arch = "wasm32"))]
 use std::path::Path;
-use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
 use std::sync::{Arc, Mutex};
-use wasmer_types::HashAlgorithm;
+use std::{
+    io::Write,
+    sync::atomic::{AtomicUsize, Ordering::SeqCst},
+};
+
+#[cfg(feature = "compiler")]
+use wasmer_types::Features;
 #[cfg(not(target_arch = "wasm32"))]
 use wasmer_types::{
-    entity::PrimaryMap, DeserializeError, FunctionBodyLike, FunctionIndex, FunctionType,
-    LocalFunctionIndex, SignatureIndex,
+    entity::PrimaryMap, DeserializeError, FunctionIndex, FunctionType, LocalFunctionIndex,
+    SignatureIndex,
 };
-use wasmer_types::{CompileError, Features, ModuleInfo, Target};
-#[cfg(not(target_arch = "wasm32"))]
-use wasmer_types::{CustomSectionLike, CustomSectionProtection, SectionIndex};
+use wasmer_types::{target::Target, CompileError, HashAlgorithm, ModuleInfo};
+
 #[cfg(not(target_arch = "wasm32"))]
 use wasmer_vm::{
     FunctionBodyPtr, SectionBodyPtr, SignatureRegistry, VMFunctionBody, VMSharedSignatureIndex,
@@ -77,15 +81,6 @@ impl Engine {
         }
     }
 
-    #[cfg(not(feature = "compiler"))]
-    pub fn new(
-        compiler_config: Box<dyn CompilerConfig>,
-        target: Target,
-        features: Features,
-    ) -> Self {
-        panic!("The engine is not compiled with any compiler support")
-    }
-
     /// Returns the name of this engine
     pub fn name(&self) -> &str {
         self.name.as_str()
@@ -102,12 +97,21 @@ impl Engine {
     }
 
     /// Returns the deterministic id of this engine
-    pub fn deterministic_id(&self) -> &str {
-        // TODO: add a `deterministic_id` to the Compiler, so two
-        // compilers can actually serialize into a different deterministic_id
-        // if their configuration is different (eg. LLVM with optimizations vs LLVM
-        // without optimizations)
-        self.name.as_str()
+    pub fn deterministic_id(&self) -> String {
+        let i = self.inner();
+        #[cfg(feature = "compiler")]
+        {
+            if let Some(ref c) = i.compiler {
+                return c.deterministic_id();
+            } else {
+                return self.name.clone();
+            }
+        }
+
+        #[allow(unreachable_code)]
+        {
+            self.name.to_string()
+        }
     }
 
     /// Create a headless `Engine`
@@ -291,15 +295,33 @@ impl Engine {
     pub fn tunables(&self) -> &dyn Tunables {
         self.tunables.as_ref()
     }
+
+    /// Add suggested optimizations to this engine.
+    ///
+    /// # Note
+    ///
+    /// Not every backend supports every optimization. This function may fail (i.e. not set the
+    /// suggested optimizations) silently if the underlying engine backend does not support one or
+    /// more optimizations.
+    pub fn with_opts(
+        &mut self,
+        suggested_opts: &wasmer_types::target::UserCompilerOptimizations,
+    ) -> Result<(), CompileError> {
+        #[cfg(feature = "compiler")]
+        {
+            let mut i = self.inner_mut();
+            if let Some(ref mut c) = i.compiler {
+                c.with_opts(suggested_opts)?;
+            }
+        }
+
+        Ok(())
+    }
 }
 
 impl std::fmt::Debug for Engine {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        f.debug_struct("Engine")
-            .field("target", &self.target)
-            .field("engine_id", &self.engine_id)
-            .field("name", &self.name)
-            .finish()
+        write!(f, "{}", self.deterministic_id())
     }
 }
 
@@ -321,6 +343,24 @@ pub struct EngineInner {
     signatures: SignatureRegistry,
 }
 
+impl std::fmt::Debug for EngineInner {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let mut formatter = f.debug_struct("EngineInner");
+        #[cfg(feature = "compiler")]
+        {
+            formatter.field("compiler", &self.compiler);
+            formatter.field("features", &self.features);
+        }
+
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            formatter.field("signatures", &self.signatures);
+        }
+
+        formatter.finish()
+    }
+}
+
 impl EngineInner {
     /// Gets the compiler associated to this engine.
     #[cfg(feature = "compiler")]
@@ -351,7 +391,7 @@ impl EngineInner {
     #[allow(clippy::type_complexity)]
     pub(crate) fn allocate<'a, FunctionBody, CustomSection>(
         &'a mut self,
-        _module: &ModuleInfo,
+        _module: &wasmer_types::ModuleInfo,
         functions: impl ExactSizeIterator<Item = &'a FunctionBody> + 'a,
         function_call_trampolines: impl ExactSizeIterator<Item = &'a FunctionBody> + 'a,
         dynamic_function_trampolines: impl ExactSizeIterator<Item = &'a FunctionBody> + 'a,
@@ -378,7 +418,7 @@ impl EngineInner {
             .collect::<Vec<_>>();
         let (executable_sections, data_sections): (Vec<_>, _) = custom_sections
             .clone()
-            .partition(|section| *section.protection() == CustomSectionProtection::ReadExecute);
+            .partition(|section| section.protection() == CustomSectionProtection::ReadExecute);
         self.code_memory.push(CodeMemory::new());
 
         let (mut allocated_functions, allocated_executable_sections, allocated_data_sections) =
@@ -392,8 +432,7 @@ impl EngineInner {
                 )
                 .map_err(|message| {
                     CompileError::Resource(format!(
-                        "failed to allocate memory for functions: {}",
-                        message
+                        "failed to allocate memory for functions: {message}",
                     ))
                 })?;
 
@@ -426,7 +465,7 @@ impl EngineInner {
         let allocated_custom_sections = custom_sections
             .map(|section| {
                 SectionBodyPtr(
-                    if *section.protection() == CustomSectionProtection::ReadExecute {
+                    if section.protection() == CustomSectionProtection::ReadExecute {
                         exec_iter.next()
                     } else {
                         data_iter.next()
@@ -436,7 +475,6 @@ impl EngineInner {
                 )
             })
             .collect::<PrimaryMap<SectionIndex, _>>();
-
         Ok((
             allocated_functions_result,
             allocated_function_call_trampolines,
@@ -460,7 +498,25 @@ impl EngineInner {
             .unwind_registry_mut()
             .publish(eh_frame)
             .map_err(|e| {
-                CompileError::Resource(format!("Error while publishing the unwind code: {}", e))
+                CompileError::Resource(format!("Error while publishing the unwind code: {e}"))
+            })?;
+        Ok(())
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    /// Register macos-specific exception handling information associated with the code.
+    pub(crate) fn register_compact_unwind(
+        &mut self,
+        compact_unwind: Option<&[u8]>,
+        eh_personality_addr_in_got: Option<usize>,
+    ) -> Result<(), CompileError> {
+        self.code_memory
+            .last_mut()
+            .unwrap()
+            .unwind_registry_mut()
+            .register_compact_unwind(compact_unwind, eh_personality_addr_in_got)
+            .map_err(|e| {
+                CompileError::Resource(format!("Error while publishing the unwind code: {e}"))
             })?;
         Ok(())
     }
@@ -479,6 +535,42 @@ impl EngineInner {
             .unwrap()
             .register_frame_info(frame_info);
     }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    pub(crate) fn register_perfmap(
+        &self,
+        finished_functions: &PrimaryMap<LocalFunctionIndex, FunctionExtent>,
+        module_info: &ModuleInfo,
+    ) -> Result<(), CompileError> {
+        if self
+            .compiler
+            .as_ref()
+            .is_some_and(|v| v.get_perfmap_enabled())
+        {
+            let filename = format!("/tmp/perf-{}.map", std::process::id());
+            let mut file = std::io::BufWriter::new(std::fs::File::create(filename).unwrap());
+
+            for (func_index, code) in finished_functions.iter() {
+                let func_index = module_info.func_index(func_index);
+                let name = if let Some(func_name) = module_info.function_names.get(&func_index) {
+                    func_name.clone()
+                } else {
+                    format!("{:p}", code.ptr.0)
+                };
+
+                let sanitized_name = name.replace(['\n', '\r'], "_");
+                let line = format!(
+                    "{:p} {:x} {}\n",
+                    code.ptr.0 as *const _, code.length, sanitized_name
+                );
+                write!(file, "{line}").map_err(|e| CompileError::Codegen(e.to_string()))?;
+                file.flush()
+                    .map_err(|e| CompileError::Codegen(e.to_string()))?;
+            }
+        }
+
+        Ok(())
+    }
 }
 
 #[cfg(feature = "compiler")]
diff --git a/lib/compiler/src/engine/link.rs b/lib/compiler/src/engine/link.rs
index 92a0357be9..fd6c7ae63d 100644
--- a/lib/compiler/src/engine/link.rs
+++ b/lib/compiler/src/engine/link.rs
@@ -1,45 +1,75 @@
 //! Linking for Universal-compiled code.
 
-use crate::get_libcall_trampoline;
-use crate::FunctionExtent;
-use std::collections::HashMap;
-use std::ptr::{read_unaligned, write_unaligned};
-use wasmer_types::entity::PrimaryMap;
-use wasmer_types::RelocationLike;
-use wasmer_types::{LocalFunctionIndex, ModuleInfo};
-use wasmer_types::{RelocationKind, RelocationTarget, SectionIndex};
-use wasmer_vm::libcalls::function_pointer;
-use wasmer_vm::SectionBodyPtr;
+use crate::{
+    get_libcall_trampoline,
+    types::{
+        relocation::{RelocationKind, RelocationLike, RelocationTarget},
+        section::SectionIndex,
+    },
+    FunctionExtent,
+};
+use std::{
+    collections::{HashMap, HashSet},
+    ptr::{read_unaligned, write_unaligned},
+};
 
+use wasmer_types::{entity::PrimaryMap, LocalFunctionIndex, ModuleInfo};
+use wasmer_vm::{libcalls::function_pointer, SectionBodyPtr};
+
+#[allow(clippy::too_many_arguments)]
 fn apply_relocation(
     body: usize,
     r: &impl RelocationLike,
     allocated_functions: &PrimaryMap<LocalFunctionIndex, FunctionExtent>,
     allocated_sections: &PrimaryMap<SectionIndex, SectionBodyPtr>,
-    libcall_trampolines: SectionIndex,
+    libcall_trampolines_sec_idx: SectionIndex,
     libcall_trampoline_len: usize,
     riscv_pcrel_hi20s: &mut HashMap<usize, u32>,
+    get_got_address: &dyn Fn(RelocationTarget) -> Option<usize>,
 ) {
-    let target_func_address: usize = match r.reloc_target() {
-        RelocationTarget::LocalFunc(index) => *allocated_functions[index].ptr as usize,
-        RelocationTarget::LibCall(libcall) => {
-            // Use the direct target of the libcall if the relocation supports
-            // a full 64-bit address. Otherwise use a trampoline.
-            if r.kind() == RelocationKind::Abs8 || r.kind() == RelocationKind::X86PCRel8 {
-                function_pointer(libcall)
-            } else {
-                get_libcall_trampoline(
-                    libcall,
-                    allocated_sections[libcall_trampolines].0 as usize,
-                    libcall_trampoline_len,
-                )
-            }
+    let reloc_target = r.reloc_target();
+
+    // Note: if the relocation needs GOT and its addend is not zero we will relax the
+    // relocation and, instead of making it use the GOT entry, we will fixup the assembly to
+    // use the final pointer directly, without any indirection. Also, see the comment in
+    // compiler-llvm/src/object_file.rs:288.
+    let target_func_address: usize = if r.kind().needs_got() && r.addend() == 0 {
+        if let Some(got_address) = get_got_address(reloc_target) {
+            got_address
+        } else {
+            panic!("No GOT entry for reloc target {reloc_target:?}")
         }
-        RelocationTarget::CustomSection(custom_section) => {
-            *allocated_sections[custom_section] as usize
+    } else {
+        match reloc_target {
+            RelocationTarget::LocalFunc(index) => *allocated_functions[index].ptr as usize,
+            RelocationTarget::LibCall(libcall) => {
+                // Use the direct target of the libcall if the relocation supports
+                // a full 64-bit address. Otherwise use a trampoline.
+                if matches!(
+                    r.kind(),
+                    RelocationKind::Abs8
+                        | RelocationKind::X86PCRel8
+                        | RelocationKind::MachoArm64RelocUnsigned
+                        | RelocationKind::MachoX86_64RelocUnsigned
+                ) {
+                    function_pointer(libcall)
+                } else {
+                    get_libcall_trampoline(
+                        libcall,
+                        allocated_sections[libcall_trampolines_sec_idx].0 as usize,
+                        libcall_trampoline_len,
+                    )
+                }
+            }
+            RelocationTarget::CustomSection(custom_section) => {
+                *allocated_sections[custom_section] as usize
+            }
         }
     };
 
+    // A set of addresses at which a SUBTRACTOR relocation was applied.
+    let mut macho_aarch64_subtractor_addresses = HashSet::new();
+
     match r.kind() {
         RelocationKind::Abs8 => unsafe {
             let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64);
@@ -122,15 +152,259 @@ fn apply_relocation(
                 | read_unaligned(reloc_address as *mut u64);
             write_unaligned(reloc_address as *mut u64, reloc_delta);
         },
-        kind => panic!(
-            "Relocation kind unsupported in the current architecture {}",
-            kind
-        ),
+        RelocationKind::LArchAbsHi20 | RelocationKind::LArchPCAlaHi20 => unsafe {
+            let (reloc_address, reloc_abs) = r.for_address(body, target_func_address as u64);
+            let reloc_abs = ((((reloc_abs >> 12) & 0xfffff) as u32) << 5)
+                | read_unaligned(reloc_address as *mut u32);
+            write_unaligned(reloc_address as *mut u32, reloc_abs);
+        },
+        RelocationKind::LArchAbsLo12 | RelocationKind::LArchPCAlaLo12 => unsafe {
+            let (reloc_address, reloc_abs) = r.for_address(body, target_func_address as u64);
+            let reloc_abs =
+                (((reloc_abs & 0xfff) as u32) << 10) | read_unaligned(reloc_address as *mut u32);
+            write_unaligned(reloc_address as *mut u32, reloc_abs);
+        },
+        RelocationKind::LArchAbs64Hi12 | RelocationKind::LArchPCAla64Hi12 => unsafe {
+            let (reloc_address, reloc_abs) = r.for_address(body, target_func_address as u64);
+            let reloc_abs = ((((reloc_abs >> 52) & 0xfff) as u32) << 10)
+                | read_unaligned(reloc_address as *mut u32);
+            write_unaligned(reloc_address as *mut u32, reloc_abs);
+        },
+        RelocationKind::LArchAbs64Lo20 | RelocationKind::LArchPCAla64Lo20 => unsafe {
+            let (reloc_address, reloc_abs) = r.for_address(body, target_func_address as u64);
+            let reloc_abs = ((((reloc_abs >> 32) & 0xfffff) as u32) << 5)
+                | read_unaligned(reloc_address as *mut u32);
+            write_unaligned(reloc_address as *mut u32, reloc_abs);
+        },
+        RelocationKind::LArchCall36 => unsafe {
+            let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64);
+            let reloc_delta1 = ((((reloc_delta >> 18) & 0xfffff) as u32) << 5)
+                | read_unaligned(reloc_address as *mut u32);
+            write_unaligned(reloc_address as *mut u32, reloc_delta1);
+            let reloc_delta2 = ((((reloc_delta >> 2) & 0xffff) as u32) << 10)
+                | read_unaligned((reloc_address + 4) as *mut u32);
+            write_unaligned((reloc_address + 4) as *mut u32, reloc_delta2);
+        },
+        RelocationKind::Aarch64AdrPrelPgHi21 => unsafe {
+            let (reloc_address, delta) = r.for_address(body, target_func_address as u64);
+
+            let delta = delta as isize;
+            assert!(
+                ((-1 << 32)..(1 << 32)).contains(&delta),
+                "can't generate page-relative relocation with ±4GB `adrp` instruction"
+            );
+
+            let op = read_unaligned(reloc_address as *mut u32);
+            let delta = delta >> 12;
+            let immlo = ((delta as u32) & 0b11) << 29;
+            let immhi = (((delta as u32) >> 2) & 0x7ffff) << 5;
+            let mask = !((0x7ffff << 5) | (0b11 << 29));
+            let op = (op & mask) | immlo | immhi;
+
+            write_unaligned(reloc_address as *mut u32, op);
+        },
+        RelocationKind::Aarch64AdrPrelLo21 => unsafe {
+            let (reloc_address, delta) = r.for_address(body, target_func_address as u64);
+
+            let delta = delta as isize;
+            assert!(
+                ((-1 << 20)..(1 << 20)).contains(&delta),
+                "can't generate an ADR_PREL_LO21 relocation with an immediate larger than 20 bits"
+            );
+
+            let op = read_unaligned(reloc_address as *mut u32);
+            let immlo = ((delta as u32) & 0b11) << 29;
+            let immhi = (((delta as u32) >> 2) & 0x7ffff) << 5;
+            let mask = !((0x7ffff << 5) | (0b11 << 29));
+            let op = (op & mask) | immlo | immhi;
+
+            write_unaligned(reloc_address as *mut u32, op);
+        },
+        RelocationKind::Aarch64AddAbsLo12Nc => unsafe {
+            let (reloc_address, delta) = r.for_address(body, target_func_address as u64);
+
+            let delta = delta as isize;
+            let op = read_unaligned(reloc_address as *mut u32);
+            let imm = ((delta as u32) & 0xfff) << 10;
+            let mask = !((0xfff) << 10);
+            let op = (op & mask) | imm;
+
+            write_unaligned(reloc_address as *mut u32, op);
+        },
+        RelocationKind::Aarch64Ldst128AbsLo12Nc => unsafe {
+            let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64);
+            let reloc_delta = ((reloc_delta as u32 & 0xfff) >> 4) << 10
+                | (read_unaligned(reloc_address as *mut u32) & 0xFFC003FF);
+            write_unaligned(reloc_address as *mut u32, reloc_delta);
+        },
+        RelocationKind::Aarch64Ldst64AbsLo12Nc => unsafe {
+            let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64);
+            let reloc_delta = ((reloc_delta as u32 & 0xfff) >> 3) << 10
+                | (read_unaligned(reloc_address as *mut u32) & 0xFFC003FF);
+            write_unaligned(reloc_address as *mut u32, reloc_delta);
+        },
+        RelocationKind::MachoArm64RelocSubtractor | RelocationKind::MachoX86_64RelocSubtractor => unsafe {
+            let (reloc_address, reloc_sub) = r.for_address(body, target_func_address as u64);
+            macho_aarch64_subtractor_addresses.insert(reloc_address);
+            write_unaligned(reloc_address as *mut u64, reloc_sub);
+        },
+        RelocationKind::MachoArm64RelocGotLoadPage21
+        | RelocationKind::MachoArm64RelocTlvpLoadPage21 => unsafe {
+            let (reloc_address, _) = r.for_address(body, target_func_address as u64);
+            let target_func_page = target_func_address & !0xfff;
+            let reloc_at_page = reloc_address & !0xfff;
+            let pcrel = (target_func_page as isize)
+                .checked_sub(reloc_at_page as isize)
+                .unwrap();
+            assert!(
+                (-1 << 32) <= (pcrel as i64) && (pcrel as i64) < (1 << 32),
+                "can't reach GOT page with ±4GB `adrp` instruction"
+            );
+            let val = pcrel >> 12;
+
+            let immlo = ((val as u32) & 0b11) << 29;
+            let immhi = (((val as u32) >> 2) & 0x7ffff) << 5;
+            let mask = !((0x7ffff << 5) | (0b11 << 29));
+            let op = read_unaligned(reloc_address as *mut u32);
+            write_unaligned(reloc_address as *mut u32, (op & mask) | immlo | immhi);
+        },
+
+        RelocationKind::MachoArm64RelocPage21 => unsafe {
+            let target_page: u64 =
+                ((target_func_address.wrapping_add(r.addend() as _)) & !0xfff) as u64;
+            let reloc_address = body.wrapping_add(r.offset() as _);
+            let pc_page: u64 = (reloc_address & !0xfff) as u64;
+            let page_delta = target_page - pc_page;
+            let raw_instr = read_unaligned(reloc_address as *mut u32);
+            assert_eq!(
+                (raw_instr & 0xffffffe0),
+                0x90000000,
+                "raw_instr isn't an ADRP instruction"
+            );
+
+            let immlo: u32 = ((page_delta >> 12) & 0x3) as _;
+            let immhi: u32 = ((page_delta >> 14) & 0x7ffff) as _;
+            let fixed_instr = raw_instr | (immlo << 29) | (immhi << 5);
+            write_unaligned(reloc_address as *mut u32, fixed_instr);
+        },
+        RelocationKind::MachoArm64RelocPageoff12 => unsafe {
+            let target_offset: u64 =
+                ((target_func_address.wrapping_add(r.addend() as _)) & 0xfff) as u64;
+
+            let reloc_address = body.wrapping_add(r.offset() as _);
+            let raw_instr = read_unaligned(reloc_address as *mut u32);
+            let imm_shift = {
+                const VEC128_MASK: u32 = 0x04800000;
+
+                const LOAD_STORE_IMM12_MASK: u32 = 0x3b000000;
+                let is_load_store_imm12 = (raw_instr & LOAD_STORE_IMM12_MASK) == 0x39000000;
+
+                if is_load_store_imm12 {
+                    let mut implicit_shift = raw_instr >> 30;
+
+                    if implicit_shift == 0 && (raw_instr & VEC128_MASK) == VEC128_MASK {
+                        implicit_shift = 4;
+                    }
+
+                    implicit_shift
+                } else {
+                    0
+                }
+            };
+
+            assert_eq!(
+                target_offset & ((1 << imm_shift) - 1),
+                0,
+                "PAGEOFF12 target is not aligned"
+            );
+
+            let encoded_imm: u32 = ((target_offset as u32) >> imm_shift) << 10;
+            let fixed_instr: u32 = raw_instr | encoded_imm;
+            write_unaligned(reloc_address as *mut u32, fixed_instr);
+        },
+
+        RelocationKind::MachoArm64RelocGotLoadPageoff12 => unsafe {
+            // See comment at the top of the function. TLDR: if addend != 0 we can't really use the
+            // GOT entry. We fixup this relocation to use a `add` rather than a `ldr` instruction,
+            // skipping the indirection from the GOT.
+            if r.addend() == 0 {
+                let (reloc_address, _) = r.for_address(body, target_func_address as u64);
+                assert_eq!(target_func_address & 0b111, 0);
+                let val = target_func_address >> 3;
+                let imm9 = ((val & 0x1ff) << 10) as u32;
+                let mask = !(0x1ff << 10);
+                let op = read_unaligned(reloc_address as *mut u32);
+                write_unaligned(reloc_address as *mut u32, (op & mask) | imm9);
+            } else {
+                let fixup_ptr = body + r.offset() as usize;
+                let target_address: usize = target_func_address + r.addend() as usize;
+
+                let raw_instr = read_unaligned(fixup_ptr as *mut u32);
+
+                assert_eq!(
+                    raw_instr & 0xfffffc00, 0xf9400000,
+                    "raw_instr isn't a 64-bit LDR immediate (bits: {raw_instr:032b}, hex: {raw_instr:x})"
+                );
+
+                let reg: u32 = raw_instr & 0b11111;
+
+                let mut fixup_ldr = 0x91000000 | (reg << 5) | reg;
+                fixup_ldr |= ((target_address & 0xfff) as u32) << 10;
+
+                write_unaligned(fixup_ptr as *mut u32, fixup_ldr);
+            }
+        },
+        RelocationKind::MachoArm64RelocUnsigned | RelocationKind::MachoX86_64RelocUnsigned => unsafe {
+            let (reloc_address, mut reloc_delta) = r.for_address(body, target_func_address as u64);
+
+            if macho_aarch64_subtractor_addresses.contains(&reloc_address) {
+                reloc_delta -= read_unaligned(reloc_address as *mut u64);
+            }
+
+            write_unaligned(reloc_address as *mut u64, reloc_delta);
+        },
+
+        RelocationKind::MachoArm64RelocPointerToGot => unsafe {
+            let at = body + r.offset() as usize;
+            let pcrel = i32::try_from((target_func_address as isize) - (at as isize)).unwrap();
+            write_unaligned(at as *mut i32, pcrel);
+        },
+
+        RelocationKind::MachoArm64RelocBranch26 => unsafe {
+            let fixup_ptr = body + r.offset() as usize;
+            assert_eq!(fixup_ptr & 0x3, 0, "Branch-inst is not 32-bit aligned");
+            let value = i32::try_from((target_func_address as isize) - (fixup_ptr as isize))
+                .unwrap()
+                .wrapping_add(r.addend() as _);
+            assert!(
+                value & 0x3 == 0,
+                "BranchPCRel26 target is not 32-bit aligned"
+            );
+
+            assert!(
+                (-(1 << 27)..=((1 << 27) - 1)).contains(&value),
+                "out of range BranchPCRel26 target"
+            );
+
+            let raw_instr = read_unaligned(fixup_ptr as *mut u32);
+
+            assert_eq!(
+                raw_instr & 0x7fffffff,
+                0x14000000,
+                "RawInstr isn't a B or BR immediate instruction"
+            );
+            let imm: u32 = ((value as u32) & ((1 << 28) - 1)) >> 2;
+            let fixed_instr: u32 = raw_instr | imm;
+
+            write_unaligned(fixup_ptr as *mut u32, fixed_instr);
+        },
+        kind => panic!("Relocation kind unsupported in the current architecture: {kind}"),
     }
 }
 
 /// Links a module, patching the allocated functions with the
 /// required relocations and jump tables.
+#[allow(clippy::too_many_arguments)]
 pub fn link_module<'a>(
     _module: &ModuleInfo,
     allocated_functions: &PrimaryMap<LocalFunctionIndex, FunctionExtent>,
@@ -149,6 +423,7 @@ pub fn link_module<'a>(
     >,
     libcall_trampolines: SectionIndex,
     trampoline_len: usize,
+    get_got_address: &'a dyn Fn(RelocationTarget) -> Option<usize>,
 ) {
     let mut riscv_pcrel_hi20s: HashMap<usize, u32> = HashMap::new();
 
@@ -163,6 +438,7 @@ pub fn link_module<'a>(
                 libcall_trampolines,
                 trampoline_len,
                 &mut riscv_pcrel_hi20s,
+                get_got_address,
             );
         }
     }
@@ -177,6 +453,7 @@ pub fn link_module<'a>(
                 libcall_trampolines,
                 trampoline_len,
                 &mut riscv_pcrel_hi20s,
+                get_got_address,
             );
         }
     }
diff --git a/lib/compiler/src/engine/mod.rs b/lib/compiler/src/engine/mod.rs
index 75b4db3b2f..ab19cc7f3e 100644
--- a/lib/compiler/src/engine/mod.rs
+++ b/lib/compiler/src/engine/mod.rs
@@ -8,20 +8,14 @@ mod trap;
 #[cfg(not(target_arch = "wasm32"))]
 mod tunables;
 
-#[cfg(feature = "translator")]
 #[cfg(not(target_arch = "wasm32"))]
 mod artifact;
-#[cfg(feature = "translator")]
 mod builder;
-#[cfg(feature = "translator")]
 #[cfg(not(target_arch = "wasm32"))]
 mod code_memory;
-#[cfg(feature = "translator")]
 mod inner;
-#[cfg(feature = "translator")]
 #[cfg(not(target_arch = "wasm32"))]
 mod link;
-#[cfg(feature = "translator")]
 #[cfg(not(target_arch = "wasm32"))]
 mod unwind;
 
@@ -33,16 +27,11 @@ pub use self::trap::*;
 #[cfg(not(target_arch = "wasm32"))]
 pub use self::tunables::{BaseTunables, Tunables};
 
-#[cfg(feature = "translator")]
 #[cfg(not(target_arch = "wasm32"))]
 pub use self::artifact::Artifact;
-#[cfg(feature = "translator")]
 pub use self::builder::EngineBuilder;
-#[cfg(feature = "translator")]
 #[cfg(not(target_arch = "wasm32"))]
 pub use self::code_memory::CodeMemory;
-#[cfg(feature = "translator")]
 pub use self::inner::{Engine, EngineInner};
-#[cfg(feature = "translator")]
 #[cfg(not(target_arch = "wasm32"))]
 pub use self::link::link_module;
diff --git a/lib/compiler/src/engine/resolver.rs b/lib/compiler/src/engine/resolver.rs
index 58b595075c..0630cbe0df 100644
--- a/lib/compiler/src/engine/resolver.rs
+++ b/lib/compiler/src/engine/resolver.rs
@@ -2,15 +2,19 @@
 
 use crate::LinkError;
 use more_asserts::assert_ge;
-use wasmer_types::entity::{BoxedSlice, EntityRef, PrimaryMap};
+use wasmer_types::{
+    entity::{BoxedSlice, EntityRef, PrimaryMap},
+    TagIndex, TagKind,
+};
 use wasmer_types::{
     ExternType, FunctionIndex, ImportError, ImportIndex, MemoryIndex, ModuleInfo, TableIndex,
+    TagType,
 };
 
 use wasmer_vm::{
-    FunctionBodyPtr, Imports, LinearMemory, MemoryStyle, StoreObjects, TableStyle, VMExtern,
-    VMFunctionBody, VMFunctionImport, VMFunctionKind, VMGlobalImport, VMMemoryImport,
-    VMTableImport,
+    FunctionBodyPtr, Imports, InternalStoreHandle, LinearMemory, MemoryStyle, StoreObjects,
+    TableStyle, VMExtern, VMFunctionBody, VMFunctionImport, VMFunctionKind, VMGlobalImport,
+    VMMemoryImport, VMTableImport, VMTag,
 };
 
 /// Get an `ExternType` given a import index.
@@ -32,12 +36,23 @@ fn get_extern_from_import(module: &ModuleInfo, import_index: &ImportIndex) -> Ex
             let global = module.globals[*index];
             ExternType::Global(global)
         }
+        ImportIndex::Tag(index) => {
+            let func = module.signatures[module.tags[*index]].clone();
+            ExternType::Tag(TagType::from_fn_type(
+                wasmer_types::TagKind::Exception,
+                func,
+            ))
+        }
     }
 }
 
 /// Get an `ExternType` given an export (and Engine signatures in case is a function).
 fn get_extern_type(context: &StoreObjects, extern_: &VMExtern) -> ExternType {
     match extern_ {
+        VMExtern::Tag(f) => ExternType::Tag(wasmer_types::TagType::from_fn_type(
+            wasmer_types::TagKind::Exception,
+            f.get(context).signature.clone(),
+        )),
         VMExtern::Function(f) => ExternType::Function(f.get(context).signature.clone()),
         VMExtern::Table(t) => ExternType::Table(*t.get(context).ty()),
         VMExtern::Memory(m) => ExternType::Memory(m.get(context).ty()),
@@ -57,7 +72,7 @@ fn get_runtime_size(context: &StoreObjects, extern_: &VMExtern) -> Option<u32> {
 }
 
 /// This function allows to match all imports of a `ModuleInfo` with concrete definitions provided by
-/// a `Resolver`.
+/// a `Resolver`, except for tags which are resolved separately through `resolve_tags`.
 ///
 /// If all imports are satisfied returns an `Imports` instance required for a module instantiation.
 #[allow(clippy::result_large_err)]
@@ -74,34 +89,16 @@ pub fn resolve_imports(
     let mut memory_imports = PrimaryMap::with_capacity(module.num_imported_memories);
     let mut global_imports = PrimaryMap::with_capacity(module.num_imported_globals);
 
-    for (
-        wasmer_types::ImportKey {
-            module: module_name,
-            field,
-            import_idx,
-        },
-        import_index,
-    ) in module.imports.iter()
+    for (import_key, import_index) in module
+        .imports
+        .iter()
+        .filter(|(_, import_index)| !matches!(import_index, ImportIndex::Tag(_)))
     {
-        let import_extern = get_extern_from_import(module, import_index);
-        let resolved = if let Some(r) = imports.get(*import_idx as usize) {
-            r
-        } else {
-            return Err(LinkError::Import(
-                module_name.to_string(),
-                field.to_string(),
-                ImportError::UnknownImport(import_extern),
-            ));
-        };
-        let extern_type = get_extern_type(context, resolved);
-        let runtime_size = get_runtime_size(context, resolved);
-        if !extern_type.is_compatible_with(&import_extern, runtime_size) {
-            return Err(LinkError::Import(
-                module_name.to_string(),
-                field.to_string(),
-                ImportError::IncompatibleType(import_extern, extern_type),
-            ));
-        }
+        let ResolvedImport {
+            resolved,
+            import_extern,
+            extern_type,
+        } = resolve_import(module, imports, context, import_key, import_index)?;
         match *resolved {
             VMExtern::Function(handle) => {
                 let f = handle.get_mut(context);
@@ -138,8 +135,8 @@ pub fn resolve_imports(
                         let expected_table_ty = &module.tables[*index];
                         if import_table_ty.ty != expected_table_ty.ty {
                             return Err(LinkError::Import(
-                                module_name.to_string(),
-                                field.to_string(),
+                                import_key.module.to_string(),
+                                import_key.field.to_string(),
                                 ImportError::IncompatibleType(import_extern, extern_type),
                             ));
                         }
@@ -197,6 +194,8 @@ pub fn resolve_imports(
                     handle,
                 });
             }
+
+            VMExtern::Tag(_) => unreachable!("We already filtered tags out"),
         }
     }
 
@@ -207,3 +206,125 @@ pub fn resolve_imports(
         global_imports,
     ))
 }
+
+/// This function resolves all tags of a `ModuleInfo`. Imported tags are resolved from
+/// the `StoreObjects`, whereas local tags are created and pushed to it. This is because
+/// we need every tag to have a unique `VMSharedTagIndex` in the `StoreObjects`, regardless
+/// of whether it's local or imported, so that exception handling can correctly resolve
+/// cross-module exceptions.
+// TODO: I feel this code can be cleaned up. Maybe we can handle tag indices better, so we don't have to search through the imports again?
+// TODO: don't we create store handles for everything else as well? Should tags get special handling here?
+#[allow(clippy::result_large_err)]
+pub fn resolve_tags(
+    module: &ModuleInfo,
+    imports: &[VMExtern],
+    context: &mut StoreObjects,
+) -> Result<BoxedSlice<TagIndex, InternalStoreHandle<VMTag>>, LinkError> {
+    let mut tags = PrimaryMap::with_capacity(module.tags.len());
+
+    for (import_key, import_index) in module
+        .imports
+        .iter()
+        .filter(|(_, import_index)| matches!(import_index, ImportIndex::Tag(_)))
+    {
+        let ResolvedImport {
+            resolved,
+            import_extern,
+            extern_type,
+        } = resolve_import(module, imports, context, import_key, import_index)?;
+        match *resolved {
+            VMExtern::Tag(handle) => {
+                let t = handle.get(context);
+                match import_index {
+                    ImportIndex::Tag(index) => {
+                        let import_tag_ty = &t.signature;
+                        let expected_tag_ty = if let Some(expected_tag_ty) =
+                            module.signatures.get(module.tags[*index])
+                        {
+                            expected_tag_ty
+                        } else {
+                            return Err(LinkError::Resource(format!(
+                                "Could not find matching signature for tag index {index:?}"
+                            )));
+                        };
+                        if *import_tag_ty != *expected_tag_ty {
+                            return Err(LinkError::Import(
+                                import_key.module.to_string(),
+                                import_key.field.to_string(),
+                                ImportError::IncompatibleType(import_extern, extern_type),
+                            ));
+                        }
+
+                        tags.push(handle);
+                    }
+                    _ => {
+                        unreachable!("Tag resolution did not match");
+                    }
+                }
+            }
+            _ => unreachable!("We already filtered everything else out"),
+        }
+    }
+
+    // Now, create local tags.
+    // Local tags are created in the StoreObjects once per instance, so that
+    // when two instances of the same module are executing, they don't end
+    // up catching each other's exceptions.
+    for (tag_index, signature_index) in module.tags.iter() {
+        if module.is_imported_tag(tag_index) {
+            continue;
+        }
+        let sig_ty = if let Some(sig_ty) = module.signatures.get(*signature_index) {
+            sig_ty
+        } else {
+            return Err(LinkError::Resource(format!(
+                "Could not find matching signature for tag index {tag_index:?}"
+            )));
+        };
+        let handle =
+            InternalStoreHandle::new(context, VMTag::new(TagKind::Exception, sig_ty.clone()));
+        tags.push(handle);
+    }
+
+    Ok(tags.into_boxed_slice())
+}
+
+struct ResolvedImport<'a> {
+    resolved: &'a VMExtern,
+    import_extern: ExternType,
+    extern_type: ExternType,
+}
+
+#[allow(clippy::result_large_err)]
+fn resolve_import<'a>(
+    module: &ModuleInfo,
+    imports: &'a [VMExtern],
+    context: &mut StoreObjects,
+    import: &wasmer_types::ImportKey,
+    import_index: &ImportIndex,
+) -> Result<ResolvedImport<'a>, LinkError> {
+    let import_extern = get_extern_from_import(module, import_index);
+    let resolved = if let Some(r) = imports.get(import.import_idx as usize) {
+        r
+    } else {
+        return Err(LinkError::Import(
+            import.module.to_string(),
+            import.field.to_string(),
+            ImportError::UnknownImport(import_extern),
+        ));
+    };
+    let extern_type = get_extern_type(context, resolved);
+    let runtime_size = get_runtime_size(context, resolved);
+    if !extern_type.is_compatible_with(&import_extern, runtime_size) {
+        return Err(LinkError::Import(
+            import.module.to_string(),
+            import.field.to_string(),
+            ImportError::IncompatibleType(import_extern, extern_type),
+        ));
+    }
+    Ok(ResolvedImport {
+        resolved,
+        import_extern,
+        extern_type,
+    })
+}
diff --git a/lib/compiler/src/engine/trap/frame_info.rs b/lib/compiler/src/engine/trap/frame_info.rs
index f09dae724a..2edfbf28dd 100644
--- a/lib/compiler/src/engine/trap/frame_info.rs
+++ b/lib/compiler/src/engine/trap/frame_info.rs
@@ -11,32 +11,29 @@
 //! let module: ModuleInfo = ...;
 //! FRAME_INFO.register(module, compiled_functions);
 //! ```
-use core::ops::Deref;
+
+use crate::types::address_map::{
+    ArchivedFunctionAddressMap, ArchivedInstructionAddressMap, FunctionAddressMap,
+    InstructionAddressMap,
+};
+use crate::types::function::{ArchivedCompiledFunctionFrameInfo, CompiledFunctionFrameInfo};
+use crate::ArtifactBuildFromArchive;
 use rkyv::vec::ArchivedVec;
-use std::cmp;
 use std::collections::BTreeMap;
-use std::sync::{Arc, RwLock};
-use wasmer_types::compilation::address_map::{
-    ArchivedFunctionAddressMap, ArchivedInstructionAddressMap,
-};
-use wasmer_types::compilation::function::ArchivedCompiledFunctionFrameInfo;
-use wasmer_types::entity::{BoxedSlice, EntityRef, PrimaryMap};
+use std::sync::{Arc, LazyLock, RwLock};
+use wasmer_types::lib::std::{cmp, ops::Deref};
 use wasmer_types::{
-    CompiledFunctionFrameInfo, FrameInfo, FunctionAddressMap, InstructionAddressMap,
-    LocalFunctionIndex, ModuleInfo, SourceLoc, TrapInformation,
+    entity::{BoxedSlice, EntityRef, PrimaryMap},
+    FrameInfo, LocalFunctionIndex, ModuleInfo, SourceLoc, TrapInformation,
 };
 use wasmer_vm::FunctionBodyPtr;
 
-use crate::ArtifactBuildFromArchive;
-
-lazy_static::lazy_static! {
-    /// This is a global cache of backtrace frame information for all active
-    ///
-    /// This global cache is used during `Trap` creation to symbolicate frames.
-    /// This is populated on module compilation, and it is cleared out whenever
-    /// all references to a module are dropped.
-    pub static ref FRAME_INFO: RwLock<GlobalFrameInfo> = Default::default();
-}
+/// This is a global cache of backtrace frame information for all active
+///
+/// This global cache is used during `Trap` creation to symbolicate frames.
+/// This is populated on module compilation, and it is cleared out whenever
+/// all references to a module are dropped.
+pub static FRAME_INFO: LazyLock<RwLock<GlobalFrameInfo>> = LazyLock::new(RwLock::default);
 
 #[derive(Default)]
 pub struct GlobalFrameInfo {
@@ -54,6 +51,7 @@ pub struct GlobalFrameInfo {
 
 /// An RAII structure used to unregister a module's frame information when the
 /// module is destroyed.
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 pub struct GlobalFrameInfoRegistration {
     /// The key that will be removed from the global `ranges` map when this is
     /// dropped.
@@ -244,7 +242,8 @@ impl CompiledFunctionFrameInfoVariant<'_> {
                 VecTrapInformationVariant::Ref(&info.traps)
             }
             CompiledFunctionFrameInfoVariant::Archived(info) => {
-                VecTrapInformationVariant::Archived(&info.traps)
+                let traps = rkyv::deserialize::<_, rkyv::rancor::Error>(&info.traps).unwrap();
+                VecTrapInformationVariant::Owned(traps)
             }
         }
     }
@@ -254,16 +253,17 @@ impl CompiledFunctionFrameInfoVariant<'_> {
 #[derive(Debug)]
 pub enum VecTrapInformationVariant<'a> {
     Ref(&'a Vec<TrapInformation>),
-    Archived(&'a ArchivedVec<TrapInformation>),
+    Owned(Vec<TrapInformation>),
 }
 
+// We need to implement it for the `Deref` in `wasmer_types` to support both `core` and `std`.
 impl Deref for VecTrapInformationVariant<'_> {
     type Target = [TrapInformation];
 
     fn deref(&self) -> &Self::Target {
         match self {
             VecTrapInformationVariant::Ref(traps) => traps,
-            VecTrapInformationVariant::Archived(traps) => traps,
+            VecTrapInformationVariant::Owned(traps) => traps,
         }
     }
 }
@@ -289,28 +289,32 @@ impl FunctionAddressMapVariant<'_> {
     pub fn start_srcloc(&self) -> SourceLoc {
         match self {
             FunctionAddressMapVariant::Ref(map) => map.start_srcloc,
-            FunctionAddressMapVariant::Archived(map) => map.start_srcloc,
+            FunctionAddressMapVariant::Archived(map) => {
+                rkyv::deserialize::<_, rkyv::rancor::Error>(&map.start_srcloc).unwrap()
+            }
         }
     }
 
     pub fn end_srcloc(&self) -> SourceLoc {
         match self {
             FunctionAddressMapVariant::Ref(map) => map.end_srcloc,
-            FunctionAddressMapVariant::Archived(map) => map.end_srcloc,
+            FunctionAddressMapVariant::Archived(map) => {
+                rkyv::deserialize::<_, rkyv::rancor::Error>(&map.end_srcloc).unwrap()
+            }
         }
     }
 
     pub fn body_offset(&self) -> usize {
         match self {
             FunctionAddressMapVariant::Ref(map) => map.body_offset,
-            FunctionAddressMapVariant::Archived(map) => map.body_offset as usize,
+            FunctionAddressMapVariant::Archived(map) => map.body_offset.to_native() as usize,
         }
     }
 
     pub fn body_len(&self) -> usize {
         match self {
             FunctionAddressMapVariant::Ref(map) => map.body_len,
-            FunctionAddressMapVariant::Archived(map) => map.body_len as usize,
+            FunctionAddressMapVariant::Archived(map) => map.body_len.to_native() as usize,
         }
     }
 }
@@ -328,7 +332,7 @@ impl FunctionAddressMapInstructionVariant<'_> {
                 instructions.binary_search_by_key(&key, |map| map.code_offset)
             }
             FunctionAddressMapInstructionVariant::Archived(instructions) => {
-                instructions.binary_search_by_key(&key, |map| map.code_offset as usize)
+                instructions.binary_search_by_key(&key, |map| map.code_offset.to_native() as usize)
             }
         }
     }
@@ -339,9 +343,9 @@ impl FunctionAddressMapInstructionVariant<'_> {
             FunctionAddressMapInstructionVariant::Archived(instructions) => instructions
                 .get(index)
                 .map(|map| InstructionAddressMap {
-                    srcloc: map.srcloc,
-                    code_offset: map.code_offset as usize,
-                    code_len: map.code_len as usize,
+                    srcloc: rkyv::deserialize::<_, rkyv::rancor::Error>(&map.srcloc).unwrap(),
+                    code_offset: map.code_offset.to_native() as usize,
+                    code_len: map.code_len.to_native() as usize,
                 })
                 .unwrap(),
         }
@@ -359,7 +363,7 @@ pub fn register(
     finished_functions: &BoxedSlice<LocalFunctionIndex, FunctionExtent>,
     frame_infos: FrameInfosVariant,
 ) -> Option<GlobalFrameInfoRegistration> {
-    let mut min = usize::max_value();
+    let mut min = usize::MAX;
     let mut max = 0;
     let mut functions = BTreeMap::new();
     for (
diff --git a/lib/compiler/src/engine/tunables.rs b/lib/compiler/src/engine/tunables.rs
index 266c3bdaf8..3fc102316d 100644
--- a/lib/compiler/src/engine/tunables.rs
+++ b/lib/compiler/src/engine/tunables.rs
@@ -1,11 +1,12 @@
 use crate::engine::error::LinkError;
 use std::ptr::NonNull;
-use wasmer_types::entity::{EntityRef, PrimaryMap};
 use wasmer_types::{
-    GlobalType, LocalGlobalIndex, LocalMemoryIndex, LocalTableIndex, MemoryIndex, MemoryType,
-    ModuleInfo, Pages, PointerWidth, TableIndex, TableType, Target,
+    entity::{EntityRef, PrimaryMap},
+    target::{PointerWidth, Target},
+    FunctionType, GlobalType, LocalGlobalIndex, LocalMemoryIndex, LocalTableIndex, MemoryIndex,
+    MemoryType, ModuleInfo, Pages, TableIndex, TableType, TagKind,
 };
-use wasmer_vm::{InternalStoreHandle, MemoryError, StoreObjects};
+use wasmer_vm::{InternalStoreHandle, MemoryError, StoreObjects, VMTag};
 use wasmer_vm::{MemoryStyle, TableStyle};
 use wasmer_vm::{VMConfig, VMGlobal, VMMemory, VMTable};
 use wasmer_vm::{VMMemoryDefinition, VMTableDefinition};
@@ -56,6 +57,11 @@ pub trait Tunables {
         Ok(VMGlobal::new(ty))
     }
 
+    /// Create a new tag.
+    fn create_tag(&self, kind: TagKind, ty: FunctionType) -> Result<VMTag, String> {
+        Ok(VMTag::new(kind, ty))
+    }
+
     /// Allocate memory for just the memories of the current module.
     ///
     /// # Safety
@@ -83,7 +89,7 @@ pub trait Tunables {
             memories.push(InternalStoreHandle::new(
                 context,
                 self.create_vm_memory(ty, style, *mdl)
-                    .map_err(|e| LinkError::Resource(format!("Failed to create memory: {}", e)))?,
+                    .map_err(|e| LinkError::Resource(format!("Failed to create memory: {e}")))?,
             ));
         }
         Ok(memories)
diff --git a/lib/compiler/src/engine/unwind/systemv.rs b/lib/compiler/src/engine/unwind/systemv.rs
index 3b0f06a5ce..d7a5add4d9 100644
--- a/lib/compiler/src/engine/unwind/systemv.rs
+++ b/lib/compiler/src/engine/unwind/systemv.rs
@@ -5,12 +5,14 @@
 
 use core::sync::atomic::{AtomicUsize, Ordering::Relaxed};
 
-use wasmer_types::CompiledFunctionUnwindInfoReference;
+use crate::types::unwind::CompiledFunctionUnwindInfoReference;
 
 /// Represents a registry of function unwind information for System V ABI.
 pub struct UnwindRegistry {
     registrations: Vec<usize>,
     published: bool,
+    #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
+    compact_unwind_mgr: compact_unwind::CompactUnwindManager,
 }
 
 extern "C" {
@@ -19,6 +21,10 @@ extern "C" {
     fn __deregister_frame(fde: *const u8);
 }
 
+// Apple-specific unwind functions - the following is taken from LLVM's libunwind itself.
+#[cfg(all(target_os = "macos", target_arch = "aarch64"))]
+mod compact_unwind;
+
 /// There are two primary unwinders on Unix platforms: libunwind and libgcc.
 ///
 /// Unfortunately their interface to `__register_frame` is different. The
@@ -61,7 +67,7 @@ fn using_libunwind() -> bool {
             let looks_like_libunwind = unsafe {
                 !libc::dlsym(
                     std::ptr::null_mut(),
-                    "__unw_add_dynamic_fde\0".as_ptr().cast(),
+                    c"__unw_add_dynamic_fde".as_ptr().cast(),
                 )
                 .is_null()
             };
@@ -85,6 +91,8 @@ impl UnwindRegistry {
         Self {
             registrations: Vec::new(),
             published: false,
+            #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
+            compact_unwind_mgr: Default::default(),
         }
     }
 
@@ -115,6 +123,14 @@ impl UnwindRegistry {
             }
         }
 
+        #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
+        {
+            self.compact_unwind_mgr
+                .finalize()
+                .map_err(|v| v.to_string())?;
+            self.compact_unwind_mgr.register();
+        }
+
         self.published = true;
 
         Ok(())
@@ -122,43 +138,95 @@ impl UnwindRegistry {
 
     #[allow(clippy::cast_ptr_alignment)]
     unsafe fn register_frames(&mut self, eh_frame: &[u8]) {
-        if !using_libunwind() {
-            // Registering an empty `eh_frame` (i.e. which
-            // contains empty FDEs) cause problems on Linux when
-            // deregistering it. We must avoid this
-            // scenario. Usually, this is handled upstream by the
-            // compilers.
-            debug_assert_ne!(
-                eh_frame,
-                &[0, 0, 0, 0],
-                "`eh_frame` seems to contain empty FDEs"
-            );
+        #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
+        {
+            // Special call for macOS on aarch64 to register the `.eh_frame` section.
+            // TODO: I am not 100% sure if it's correct to never deregister the `.eh_frame` section. It was this way before
+            // I started working on this, so I kept it that way.
+            compact_unwind::__unw_add_dynamic_eh_frame_section(eh_frame.as_ptr() as usize);
+            return;
+        }
+
+        // Validate that the `.eh_frame` is well-formed before registering it.
+        // See https://refspecs.linuxfoundation.org/LSB_3.0.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html for more details.
+        // We put the frame records into a vector before registering them, because
+        // calling `__register_frame` with invalid data can cause segfaults.
 
-            // On gnu (libgcc), `__register_frame` will walk the FDEs until an entry of length 0
-            let ptr = eh_frame.as_ptr();
-            __register_frame(ptr);
-            self.registrations.push(ptr as usize);
-        } else {
-            // For libunwind, `__register_frame` takes a pointer to a single FDE
-            let start = eh_frame.as_ptr();
-            let end = start.add(eh_frame.len());
-            let mut current = start;
-
-            // Walk all of the entries in the frame table and register them
-            while current < end {
-                let len = std::ptr::read::<u32>(current as *const u32) as usize;
-
-                // Skip over the CIE and zero-length FDEs.
-                // LLVM's libunwind emits a warning on zero-length FDEs.
-                if current != start && len != 0 {
-                    __register_frame(current);
-                    self.registrations.push(current as usize);
+        // Pointers to the registrations that will be registered with `__register_frame`.
+        // For libgcc based systems, these are CIEs.
+        // For libunwind based systems, these are FDEs.
+        let mut records_to_register = Vec::new();
+
+        let mut current = 0;
+        let mut last_len = 0;
+        while current <= (eh_frame.len() - size_of::<u32>()) {
+            // If a CFI or a FDE starts with 0u32 it is a terminator.
+            let len = u32::from_ne_bytes(eh_frame[current..(current + 4)].try_into().unwrap());
+            if len == 0 {
+                current += size_of::<u32>();
+                last_len = 0;
+                continue;
+            }
+            // The first record after a terminator is always a CIE.
+            let is_cie = last_len == 0;
+            last_len = len;
+            let record = eh_frame.as_ptr() as usize + current;
+            current = current + len as usize + 4;
+
+            if using_libunwind() {
+                // For libunwind based systems, `__register_frame` takes a pointer to an FDE.
+                if !is_cie {
+                    // Every record that's not a CIE is an FDE.
+                    records_to_register.push(record);
                 }
+                continue;
+            }
 
-                // Move to the next table entry (+4 because the length itself is not inclusive)
-                current = current.add(len + 4);
+            // For libgcc based systems, `__register_frame` takes a pointer to a CIE.
+            if is_cie {
+                records_to_register.push(record);
             }
         }
+
+        assert_eq!(
+            last_len, 0,
+            "The last record in the `.eh_frame` must be a terminator (but it actually has length {last_len})"
+        );
+        assert_eq!(
+            current,
+            eh_frame.len(),
+            "The `.eh_frame` must be finished after the last record",
+        );
+
+        for record in records_to_register {
+            // Register the CFI with libgcc
+            __register_frame(record as *const u8);
+            self.registrations.push(record);
+        }
+    }
+
+    pub(crate) fn register_compact_unwind(
+        &mut self,
+        compact_unwind: Option<&[u8]>,
+        eh_personality_addr_in_got: Option<usize>,
+    ) -> Result<(), String> {
+        #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
+        unsafe {
+            if let Some(slice) = compact_unwind {
+                self.compact_unwind_mgr.read_compact_unwind_section(
+                    slice.as_ptr() as _,
+                    slice.len(),
+                    eh_personality_addr_in_got,
+                )?;
+            }
+        }
+
+        #[cfg(not(all(target_os = "macos", target_arch = "aarch64")))]
+        {
+            _ = compact_unwind;
+            _ = eh_personality_addr_in_got;
+        }
+        Ok(())
     }
 }
 
@@ -174,8 +242,17 @@ impl Drop for UnwindRegistry {
                 //
                 // To ensure that we just pop off the first element in the list upon every
                 // deregistration, walk our list of registrations backwards.
-                for fde in self.registrations.iter().rev() {
-                    __deregister_frame(*fde as *const _);
+                for registration in self.registrations.iter().rev() {
+                    #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
+                    {
+                        compact_unwind::__unw_remove_dynamic_eh_frame_section(*registration);
+                        self.compact_unwind_mgr.deregister();
+                    }
+
+                    #[cfg(not(all(target_os = "macos", target_arch = "aarch64")))]
+                    {
+                        __deregister_frame(*registration as *const _);
+                    }
                 }
             }
         }
diff --git a/lib/compiler/src/engine/unwind/systemv/compact_unwind/cu_entry.rs b/lib/compiler/src/engine/unwind/systemv/compact_unwind/cu_entry.rs
new file mode 100644
index 0000000000..5967a7bdaf
--- /dev/null
+++ b/lib/compiler/src/engine/unwind/systemv/compact_unwind/cu_entry.rs
@@ -0,0 +1,76 @@
+#[derive(Clone)]
+pub struct CompactUnwindEntryReader {
+    pub ptr: *const u8,
+    pub len: usize,
+}
+
+impl CompactUnwindEntryReader {
+    pub fn new(ptr: *const u8, len: usize) -> Self {
+        Self { ptr, len }
+    }
+
+    pub unsafe fn read<T: Copy>(&mut self) -> T {
+        unsafe {
+            if self.len == 0 {
+                panic!("Trying to read after the CompactUnwind section!");
+            }
+            let result = self.ptr.cast::<T>().read_unaligned();
+            let size = std::mem::size_of::<T>();
+            self.ptr = self.ptr.byte_add(size);
+            self.len -= size;
+            result
+        }
+    }
+}
+
+/// An entry in the `__compact_unwind` section.
+#[derive(Clone)]
+pub struct CompactUnwindEntry {
+    pub function_addr: usize,
+    pub length: u32,
+    pub compact_encoding: u32,
+    pub personality_addr: usize,
+    pub lsda_addr: usize,
+}
+
+impl std::fmt::Debug for CompactUnwindEntry {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("CompactUnwindEntry")
+            .field("function_addr", &(self.function_addr as *const u8))
+            .field("length", &self.length)
+            .field("compact_encoding", &self.compact_encoding)
+            .field("personality_addr", &(self.personality_addr as *const u8))
+            .field("lsda_addr", &(self.lsda_addr as *const u8))
+            .finish()
+    }
+}
+
+impl CompactUnwindEntry {
+    const ENCODING_MODE_MASK: u32 = 0x0f000000;
+
+    pub unsafe fn from_ptr_and_len(ptr: *const u8, len: usize) -> Self {
+        let mut reader = CompactUnwindEntryReader::new(ptr, len);
+        let function_addr = reader.read::<usize>();
+        let length = reader.read::<u32>();
+        let compact_encoding = reader.read::<u32>();
+        let personality_addr = reader.read::<usize>();
+        let lsda_addr = reader.read::<usize>();
+        Self {
+            function_addr,
+            length,
+            compact_encoding,
+            personality_addr,
+            lsda_addr,
+        }
+    }
+
+    pub fn is_dwarf(&self) -> bool {
+        const DWARFMODE: u32 = 0x04000000;
+        (self.compact_encoding & Self::ENCODING_MODE_MASK) == DWARFMODE
+    }
+
+    pub fn cannot_be_merged(&self) -> bool {
+        const STACK_INDIRECT_MODE: u32 = 0x03000000;
+        (self.compact_encoding & Self::ENCODING_MODE_MASK) == STACK_INDIRECT_MODE
+    }
+}
diff --git a/lib/compiler/src/engine/unwind/systemv/compact_unwind/mod.rs b/lib/compiler/src/engine/unwind/systemv/compact_unwind/mod.rs
new file mode 100644
index 0000000000..22805b1254
--- /dev/null
+++ b/lib/compiler/src/engine/unwind/systemv/compact_unwind/mod.rs
@@ -0,0 +1,566 @@
+/// Data types and functions to read and represent entries in the `__compact_unwind` section.
+mod cu_entry;
+
+use core::ops::Range;
+pub(crate) use cu_entry::CompactUnwindEntry;
+use std::{
+    collections::HashMap,
+    sync::{LazyLock, Mutex},
+};
+use wasmer_types::CompileError;
+
+type CUResult<T> = Result<T, CompileError>;
+
+#[repr(C)]
+/// Holds a description of the object-format-header (if any) and unwind info
+/// sections for a given address:
+///
+/// * dso_base should point to a header for the JIT'd object containing the
+///   given address. The header's type should match the format type that
+///   libunwind was compiled for (so a mach_header or mach_header_64 on Darwin).
+///   A value of zero indicates that no such header exists.
+///
+/// * dwarf_section and dwarf_section_length hold the address range of a DWARF
+///   eh-frame section associated with the given address, if any. If the
+///   dwarf_section_length field is zero it indicates that no such section
+///   exists (and in this case dwarf_section should also be set to zero).
+///
+/// * compact_unwind_section and compact_unwind_section_length hold the address
+///   range of a compact-unwind info section associated with the given address,
+///   if any. If the compact_unwind_section_length field is zero it indicates
+///   that no such section exists (and in this case compact_unwind_section
+///   should also be set to zero).
+#[derive(Debug)]
+pub struct UnwDynamicUnwindSections {
+    dso_base: u64,
+    dwarf_section: u64,
+    dwarf_section_length: u64,
+    compact_unwind_section: u64,
+    compact_unwind_section_length: u64,
+}
+
+// Typedef for unwind-info lookup callbacks. Functions of this type can be
+// registered and deregistered using __unw_add_find_dynamic_unwind_sections
+// and __unw_remove_find_dynamic_unwind_sections respectively.
+//
+// An unwind-info lookup callback should return 1 to indicate that it found
+// unwind-info for the given address, or 0 to indicate that it did not find
+// unwind-info for the given address. If found, the callback should populate
+// some or all of the fields of the info argument (which is guaranteed to be
+// non-null with all fields zero-initialized):
+type UnwFindDynamicUnwindSections =
+    unsafe extern "C" fn(addr: usize, info: *mut UnwDynamicUnwindSections) -> u32;
+
+extern "C" {
+    // Register a dynamic unwind-info lookup callback. If libunwind does not find
+    // unwind info for a given frame in the executable program or normal dynamic
+    // shared objects then it will call all registered dynamic lookup functions
+    // in registration order until either one of them returns true, or the end
+    // of the list is reached. This lookup will happen before libunwind searches
+    // any eh-frames registered via __register_frame or
+    // __unw_add_dynamic_eh_frame_section.
+    //
+    // Returns UNW_ESUCCESS for successful registrations. If the given callback
+    // has already been registered then UNW_EINVAL will be returned. If all
+    // available callback entries are in use then UNW_ENOMEM will be returned.
+    pub fn __unw_add_find_dynamic_unwind_sections(
+        find_dynamic_unwind_sections: UnwFindDynamicUnwindSections,
+    ) -> u32;
+
+    // Deregister a dynacim unwind-info lookup callback.
+    //
+    // Returns UNW_ESUCCESS for successful deregistrations. If the given callback
+    // has already been registered then UNW_EINVAL will be returned.
+    pub fn __unw_remove_find_dynamic_unwind_sections(
+        find_dynamic_unwind_sections: UnwFindDynamicUnwindSections,
+    ) -> u32;
+
+    pub fn __unw_add_dynamic_eh_frame_section(eh_frame_start: usize);
+    pub fn __unw_remove_dynamic_eh_frame_section(eh_frame_start: usize);
+
+}
+
+trait ToBytes {
+    fn to_bytes(&self) -> Vec<u8>;
+}
+
+impl ToBytes for u32 {
+    fn to_bytes(&self) -> Vec<u8> {
+        self.to_ne_bytes().into()
+    }
+}
+
+impl ToBytes for u16 {
+    fn to_bytes(&self) -> Vec<u8> {
+        self.to_ne_bytes().into()
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct CompactUnwindManager {
+    unwind_info_section: Vec<u8>,
+    compact_unwind_entries: Vec<CompactUnwindEntry>,
+    num_second_level_pages: usize,
+    num_lsdas: usize,
+    personalities: Vec<usize>,
+    dso_base: usize,
+    maybe_eh_personality_addr_in_got: Option<usize>,
+}
+
+static mut UNWIND_INFO: LazyLock<Mutex<Option<UnwindInfo>>> = LazyLock::new(|| Mutex::new(None));
+
+type UnwindInfo = HashMap<Range<usize>, UnwindInfoEntry>;
+
+#[derive(Debug)]
+struct UnwindInfoEntry {
+    dso_base: usize,
+    section_ptr: usize,
+    section_len: usize,
+}
+
+unsafe extern "C" fn find_dynamic_unwind_sections(
+    addr: usize,
+    info: *mut UnwDynamicUnwindSections,
+) -> u32 {
+    unsafe {
+        if let Ok(uw_info) = UNWIND_INFO.try_lock() {
+            if uw_info.is_none() {
+                (*info).compact_unwind_section = 0;
+                (*info).compact_unwind_section_length = 0;
+                (*info).dwarf_section = 0;
+                (*info).dwarf_section_length = 0;
+                (*info).dso_base = 0;
+
+                return 0;
+            }
+
+            let uw_info = uw_info.as_ref().unwrap();
+
+            for (range, u) in uw_info.iter() {
+                if range.contains(&addr) {
+                    (*info).compact_unwind_section = u.section_ptr as _;
+                    (*info).compact_unwind_section_length = u.section_len as _;
+                    (*info).dwarf_section = 0;
+                    (*info).dwarf_section_length = 0;
+                    (*info).dso_base = u.dso_base as u64;
+
+                    return 1;
+                }
+            }
+        }
+    }
+
+    (*info).compact_unwind_section = 0;
+    (*info).compact_unwind_section_length = 0;
+    (*info).dwarf_section = 0;
+    (*info).dwarf_section_length = 0;
+    (*info).dso_base = 0;
+
+    0
+}
+
+impl CompactUnwindManager {
+    const UNWIND_SECTION_VERSION: u32 = 1;
+    const UNWIND_INFO_SECTION_HEADER_SIZE: usize = 4 * 7;
+    const PERSONALITY_SHIFT: usize = 28;
+    const PERSONALITY_ENTRY_SIZE: usize = 4;
+    const INDEX_ENTRY_SIZE: usize = 3 * 4;
+    const LSDA_ENTRY_SIZE: usize = 2 * 4;
+    const SECOND_LEVEL_PAGE_SIZE: usize = 4096;
+    const SECOND_LEVEL_PAGE_HEADER_SIZE: usize = 8;
+    const SECOND_LEVEL_PAGE_ENTRY_SIZE: usize = 8;
+    const NUM_RECORDS_PER_SECOND_LEVEL_PAGE: usize = (Self::SECOND_LEVEL_PAGE_SIZE
+        - Self::SECOND_LEVEL_PAGE_HEADER_SIZE)
+        / Self::SECOND_LEVEL_PAGE_ENTRY_SIZE;
+
+    /// Analyze a `__compact_unwind` section, adding its entries to the manager.
+    pub unsafe fn read_compact_unwind_section(
+        &mut self,
+        compact_unwind_section_ptr: *const u8,
+        len: usize,
+        eh_personality_addr_in_got: Option<usize>,
+    ) -> Result<(), String> {
+        if eh_personality_addr_in_got.is_none() {
+            return Err(
+                "Cannot register compact_unwind entries without a personality function!".into(),
+            );
+        }
+        let mut offset = 0;
+        while offset < len {
+            let entry = CompactUnwindEntry::from_ptr_and_len(
+                compact_unwind_section_ptr.wrapping_add(offset),
+                len,
+            );
+            self.compact_unwind_entries.push(entry);
+            offset += size_of::<CompactUnwindEntry>();
+        }
+
+        self.maybe_eh_personality_addr_in_got = eh_personality_addr_in_got;
+
+        Ok(())
+    }
+
+    /// Create the `__unwind_info` section from a list of `__compact_unwind` entries.
+    pub fn finalize(&mut self) -> CUResult<()> {
+        // At this point, users will have registered the relocated `__compact_unwind` entries. We
+        // can re-analyse the entries applying the modifications we need to operate, now that we
+        // know the actual addresses.
+        self.process_compact_unwind_entries()?;
+        self.merge_records();
+
+        if self.compact_unwind_entries.is_empty() {
+            return Ok(());
+        }
+
+        let mut info = libc::Dl_info {
+            dli_fname: core::ptr::null(),
+            dli_fbase: core::ptr::null_mut(),
+            dli_sname: core::ptr::null(),
+            dli_saddr: core::ptr::null_mut(),
+        };
+
+        unsafe {
+            /* xxx: Must find a better way to find a dso_base */
+            if let Some(personality) = self.personalities.first() {
+                _ = libc::dladdr(*personality as *const _, &mut info as *mut _);
+            }
+
+            if info.dli_fbase.is_null() {
+                _ = libc::dladdr(
+                    wasmer_vm::libcalls::wasmer_eh_personality as *const _,
+                    &mut info as *mut _,
+                );
+            }
+        }
+        self.dso_base = info.dli_fbase as usize;
+
+        unsafe {
+            self.write_unwind_info()?;
+        }
+
+        let ranges: Vec<Range<usize>> = self
+            .compact_unwind_entries
+            .iter()
+            .map(|v| v.function_addr..v.function_addr + (v.length as usize))
+            .collect();
+
+        let data: &'static mut [u8] = self.unwind_info_section.clone().leak();
+        let section_ptr = data.as_ptr() as usize;
+        let section_len = data.len();
+        let dso_base = self.dso_base;
+
+        unsafe {
+            let mut uw_info = UNWIND_INFO.lock().map_err(|_| {
+                CompileError::Codegen("Failed to acquire lock for UnwindInfo!".into())
+            })?;
+
+            match uw_info.as_mut() {
+                Some(r) => {
+                    for range in ranges {
+                        r.insert(
+                            range,
+                            UnwindInfoEntry {
+                                dso_base,
+                                section_ptr,
+                                section_len,
+                            },
+                        );
+                    }
+                }
+                None => {
+                    let mut map = HashMap::new();
+                    for range in ranges {
+                        map.insert(
+                            range,
+                            UnwindInfoEntry {
+                                dso_base,
+                                section_ptr,
+                                section_len,
+                            },
+                        );
+                    }
+                    _ = uw_info.insert(map);
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn process_compact_unwind_entries(&mut self) -> CUResult<()> {
+        for entry in self.compact_unwind_entries.iter_mut() {
+            if entry.personality_addr != 0 {
+                let p_idx: u32 = if let Some(p_idx) = self
+                    .personalities
+                    .iter()
+                    .position(|v| *v == entry.personality_addr)
+                {
+                    p_idx
+                } else {
+                    self.personalities.push(entry.personality_addr);
+                    self.personalities.len() - 1
+                } as u32;
+
+                entry.compact_encoding |= (p_idx + 1) << Self::PERSONALITY_SHIFT;
+            }
+
+            if entry.lsda_addr != 0 {
+                self.num_lsdas += 1;
+            }
+        }
+
+        self.num_second_level_pages = self
+            .compact_unwind_entries
+            .len()
+            .div_ceil(Self::NUM_RECORDS_PER_SECOND_LEVEL_PAGE);
+
+        self.compact_unwind_entries
+            .sort_by(|l, r| l.function_addr.cmp(&r.function_addr));
+
+        let unwind_info_section_len = Self::UNWIND_INFO_SECTION_HEADER_SIZE
+            + (self.personalities.len() * Self::PERSONALITY_ENTRY_SIZE)
+            + ((self.num_second_level_pages + 1) * Self::INDEX_ENTRY_SIZE)
+            + (self.num_lsdas * Self::LSDA_ENTRY_SIZE)
+            + (self.num_second_level_pages * Self::SECOND_LEVEL_PAGE_HEADER_SIZE)
+            + (self.compact_unwind_entries.len() * Self::SECOND_LEVEL_PAGE_ENTRY_SIZE);
+
+        self.unwind_info_section = Vec::with_capacity(unwind_info_section_len);
+
+        Ok(())
+    }
+
+    unsafe fn write_unwind_info(&mut self) -> CUResult<()> {
+        self.write_header()?;
+        self.write_personalities()?;
+        self.write_indices()?;
+        self.write_lsdas()?;
+        self.write_second_level_pages()?;
+
+        Ok(())
+    }
+
+    fn merge_records(&mut self) {
+        if self.compact_unwind_entries.len() <= 1 {
+            self.num_second_level_pages = 1;
+            return;
+        }
+
+        let non_unique: Vec<CompactUnwindEntry> = self.compact_unwind_entries.drain(1..).collect();
+        for next in non_unique.into_iter() {
+            let last = self.compact_unwind_entries.last().unwrap();
+            if next.is_dwarf()
+                || (next.compact_encoding != last.compact_encoding)
+                || next.cannot_be_merged()
+                || next.lsda_addr != 0
+                || last.lsda_addr != 0
+            {
+                self.compact_unwind_entries.push(next);
+            }
+        }
+
+        self.num_second_level_pages = self
+            .compact_unwind_entries
+            .len()
+            .div_ceil(Self::NUM_RECORDS_PER_SECOND_LEVEL_PAGE);
+    }
+
+    #[inline(always)]
+    fn write<T: ToBytes>(&mut self, value: T) -> CUResult<()> {
+        let bytes = value.to_bytes();
+        let capacity = self.unwind_info_section.capacity();
+        let len = self.unwind_info_section.len();
+
+        if len + bytes.len() > capacity {
+            return Err(CompileError::Codegen(
+                "writing the unwind_info after the allocated bytes".into(),
+            ));
+        }
+
+        for byte in bytes {
+            self.unwind_info_section.push(byte);
+        }
+
+        Ok(())
+    }
+
+    unsafe fn write_header(&mut self) -> CUResult<()> {
+        //#[derive(Debug, Default)]
+        //#[repr(C)]
+        //#[allow(non_snake_case, non_camel_case_types)]
+        //struct unwind_info_section_header {
+        //    pub version: u32,
+        //    pub commonEncodingsArraySectionOffset: u32,
+        //    pub commonEncodingsArrayCount: u32,
+        //    pub personalityArraySectionOffset: u32,
+        //    pub personalityArrayCount: u32,
+        //    pub indexSectionOffset: u32,
+        //    pub indexCount: u32,
+        //    // compact_unwind_encoding_t[]           <-- We don't use it;;
+        //    // uint32_t personalities[]
+        //    // unwind_info_section_header_index_entry[]
+        //    // unwind_info_section_header_lsda_index_entry[]
+        //}
+
+        //let mut header = unwind_info_section_header::default();
+        let num_personalities = self.personalities.len() as u32;
+        let index_section_offset: u32 = (Self::UNWIND_INFO_SECTION_HEADER_SIZE
+            + self.personalities.len() * Self::PERSONALITY_ENTRY_SIZE)
+            as u32;
+
+        let index_count = (self.num_second_level_pages + 1) as u32;
+
+        // The unwind section version.
+        self.write(Self::UNWIND_SECTION_VERSION)?;
+
+        // The offset from the base pointer at which the `commonEncodingsArraySection` can be found. We don't use it,
+        // therefore...
+        self.write(Self::UNWIND_INFO_SECTION_HEADER_SIZE as u32)?;
+
+        // Its size is zero.
+        self.write(0u32)?;
+
+        // The offset from the base pointer at which the `personalityArraySection` can be found. It is right after the
+        // header.
+        self.write(Self::UNWIND_INFO_SECTION_HEADER_SIZE as u32)?;
+
+        // Its size corresponds to the number of personality functions we've seen. Should,
+        // in fact, be 0 or 1.
+        self.write(num_personalities)?;
+
+        // The offset from the base pointer at which the `indexSection` can be found. It is right after the
+        // header.
+        self.write(index_section_offset)?;
+        self.write(index_count + 1)?;
+
+        Ok(())
+    }
+
+    fn write_personalities(&mut self) -> CUResult<()> {
+        let personalities = self.personalities.len();
+        for _ in 0..personalities {
+            let personality_pointer =
+                if let Some(personality) = self.maybe_eh_personality_addr_in_got {
+                    personality
+                } else {
+                    return Err(CompileError::Codegen(
+                        "Personality function does not appear in GOT table!".into(),
+                    ));
+                };
+            let delta = (personality_pointer - self.dso_base) as u32;
+
+            self.write(delta)?;
+        }
+
+        Ok(())
+    }
+
+    fn write_indices(&mut self) -> CUResult<()> {
+        let section_offset_to_lsdas: usize = self.unwind_info_section.len()
+            + ((self.num_second_level_pages + 1) * Self::INDEX_ENTRY_SIZE);
+
+        // Calculate the offset to the first second-level page.
+        let section_offset_to_second_level_pages =
+            section_offset_to_lsdas + (self.num_lsdas * Self::LSDA_ENTRY_SIZE);
+
+        let mut num_previous_lsdas = 0;
+        let num_entries = self.compact_unwind_entries.len();
+
+        for entry_idx in 0..num_entries {
+            let entry = &self.compact_unwind_entries[entry_idx];
+            let lsda_addr = entry.lsda_addr;
+
+            if entry_idx % Self::NUM_RECORDS_PER_SECOND_LEVEL_PAGE == 0 {
+                let fn_delta = entry.function_addr.wrapping_sub(self.dso_base);
+                let num_second_level_page = entry_idx / Self::NUM_RECORDS_PER_SECOND_LEVEL_PAGE;
+                let mut second_level_page_offset = section_offset_to_second_level_pages;
+                // How many entries have we seen before?
+                if num_second_level_page != 0 {
+                    second_level_page_offset += num_second_level_page
+                        * (Self::NUM_RECORDS_PER_SECOND_LEVEL_PAGE
+                            * Self::SECOND_LEVEL_PAGE_ENTRY_SIZE);
+                    // How many page headers have we seen before?
+                    second_level_page_offset +=
+                        num_second_level_page * Self::SECOND_LEVEL_PAGE_HEADER_SIZE;
+                }
+
+                let lsda_offset =
+                    section_offset_to_lsdas + num_previous_lsdas * Self::LSDA_ENTRY_SIZE;
+                self.write(fn_delta as u32)?;
+                self.write(second_level_page_offset as u32)?;
+                self.write(lsda_offset as u32)?;
+            }
+
+            if lsda_addr != 0 {
+                num_previous_lsdas += 1;
+            }
+        }
+
+        if let Some(last_entry) = self.compact_unwind_entries.last() {
+            let fn_end_delta = (last_entry.function_addr + (last_entry.length as usize))
+                .wrapping_sub(self.dso_base) as u32;
+
+            self.write(fn_end_delta)?;
+            self.write(0u32)?;
+            self.write(section_offset_to_second_level_pages as u32)?;
+        }
+
+        Ok(())
+    }
+
+    fn write_lsdas(&mut self) -> CUResult<()> {
+        let num_entries = self.compact_unwind_entries.len();
+        for entry_idx in 0..num_entries {
+            let entry = &self.compact_unwind_entries[entry_idx];
+            if entry.lsda_addr != 0 {
+                let fn_delta = entry.function_addr.wrapping_sub(self.dso_base);
+                let lsda_delta = entry.lsda_addr.wrapping_sub(self.dso_base);
+                self.write(fn_delta as u32)?;
+                self.write(lsda_delta as u32)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    fn write_second_level_pages(&mut self) -> CUResult<()> {
+        let num_entries = self.compact_unwind_entries.len();
+
+        for entry_idx in 0..num_entries {
+            let entry = &self.compact_unwind_entries[entry_idx];
+            let fn_delta = entry.function_addr.wrapping_sub(self.dso_base) as u32;
+            let encoding = entry.compact_encoding;
+
+            if entry_idx % Self::NUM_RECORDS_PER_SECOND_LEVEL_PAGE == 0 {
+                const SECOND_LEVEL_PAGE_HEADER_KIND: u32 = 2;
+                const SECOND_LEVEL_PAGE_HEADER_SIZE: u16 = 8;
+                let second_level_page_num_entries: u16 = std::cmp::min(
+                    num_entries - entry_idx,
+                    Self::NUM_RECORDS_PER_SECOND_LEVEL_PAGE,
+                ) as u16;
+
+                self.write(SECOND_LEVEL_PAGE_HEADER_KIND)?;
+                self.write(SECOND_LEVEL_PAGE_HEADER_SIZE)?;
+                self.write(second_level_page_num_entries)?;
+            }
+
+            self.write(fn_delta)?;
+            self.write(encoding)?;
+        }
+
+        Ok(())
+    }
+
+    pub(crate) fn deregister(&self) {
+        if self.dso_base != 0 {
+            unsafe { __unw_remove_find_dynamic_unwind_sections(find_dynamic_unwind_sections) };
+        }
+    }
+
+    pub(crate) fn register(&self) {
+        unsafe {
+            if self.dso_base != 0 {
+                __unw_add_find_dynamic_unwind_sections(find_dynamic_unwind_sections);
+            }
+        }
+    }
+}
diff --git a/lib/compiler/src/engine/unwind/windows_x64.rs b/lib/compiler/src/engine/unwind/windows_x64.rs
index 9ef4a9840e..7d7acf356e 100644
--- a/lib/compiler/src/engine/unwind/windows_x64.rs
+++ b/lib/compiler/src/engine/unwind/windows_x64.rs
@@ -2,8 +2,8 @@
 // Attributions: https://github.com/wasmerio/wasmer/blob/main/docs/ATTRIBUTIONS.md
 
 //! Module for Windows x64 ABI unwind registry.
+use crate::types::unwind::CompiledFunctionUnwindInfoReference;
 use std::collections::HashMap;
-use wasmer_types::CompiledFunctionUnwindInfoReference;
 use windows_sys::Win32::System::Diagnostics::Debug::{
     RtlAddFunctionTable, RtlDeleteFunctionTable, IMAGE_RUNTIME_FUNCTION_ENTRY,
 };
@@ -87,6 +87,18 @@ impl UnwindRegistry {
 
         Ok(())
     }
+
+    pub(crate) fn register_compact_unwind(
+        &mut self,
+        compact_unwind: Option<&[u8]>,
+        _eh_personality_addr_in_got: Option<usize>,
+    ) -> Result<(), String> {
+        if compact_unwind.is_some() {
+            return Err("Cannot register compact_unwind frames on Windows platforms".to_string());
+        }
+
+        Ok(())
+    }
 }
 
 impl Drop for UnwindRegistry {
diff --git a/lib/compiler/src/lib.rs b/lib/compiler/src/lib.rs
index 0afb951435..e949a4329a 100644
--- a/lib/compiler/src/lib.rs
+++ b/lib/compiler/src/lib.rs
@@ -49,6 +49,10 @@ mod lib {
 mod engine;
 mod traits;
 
+pub mod object;
+pub mod serialize;
+pub mod types;
+
 pub use crate::engine::*;
 pub use crate::traits::*;
 
@@ -56,15 +60,15 @@ mod artifact_builders;
 
 pub use self::artifact_builders::*;
 
-#[cfg(feature = "translator")]
+#[cfg(feature = "compiler")]
 mod compiler;
+#[cfg(feature = "compiler")]
+pub use crate::compiler::{Compiler, CompilerConfig};
 
 #[cfg(feature = "translator")]
 #[macro_use]
 mod translator;
 #[cfg(feature = "translator")]
-pub use crate::compiler::{Compiler, CompilerConfig};
-#[cfg(feature = "translator")]
 pub use crate::translator::{
     from_binaryreadererror_wasmerror, translate_module, wpheaptype_to_type, wptype_to_type,
     FunctionBinaryReader, FunctionBodyData, FunctionMiddleware, MiddlewareBinaryReader,
diff --git a/lib/object/src/error.rs b/lib/compiler/src/object/error.rs
similarity index 100%
rename from lib/object/src/error.rs
rename to lib/compiler/src/object/error.rs
diff --git a/lib/object/src/lib.rs b/lib/compiler/src/object/mod.rs
similarity index 80%
rename from lib/object/src/lib.rs
rename to lib/compiler/src/object/mod.rs
index 946101e966..dccbf84521 100644
--- a/lib/object/src/lib.rs
+++ b/lib/compiler/src/object/mod.rs
@@ -20,6 +20,8 @@
 mod error;
 mod module;
 
-pub use crate::error::ObjectError;
-pub use crate::module::{emit_compilation, emit_data, emit_serialized, get_object_for_target};
+pub use self::error::ObjectError;
+pub use self::module::{
+    emit_compilation, emit_data, emit_serialized, get_object_for_target, ObjectMetadataBuilder,
+};
 pub use object::{self, write::Object};
diff --git a/lib/object/src/module.rs b/lib/compiler/src/object/module.rs
similarity index 53%
rename from lib/object/src/module.rs
rename to lib/compiler/src/object/module.rs
index 333980e30d..692a890723 100644
--- a/lib/object/src/module.rs
+++ b/lib/compiler/src/object/module.rs
@@ -1,18 +1,25 @@
-use crate::error::ObjectError;
-use object::write::{
-    Object, Relocation, StandardSection, StandardSegment, Symbol as ObjSymbol, SymbolSection,
+use super::error::ObjectError;
+use crate::{
+    serialize::MetadataHeader,
+    types::{
+        function::Compilation,
+        relocation::{RelocationKind as Reloc, RelocationTarget},
+        section::{CustomSectionProtection, SectionIndex},
+        symbols::{ModuleMetadata, Symbol, SymbolRegistry},
+    },
 };
 use object::{
-    elf, macho, FileFlags, RelocationEncoding, RelocationKind, SectionKind, SymbolFlags,
-    SymbolKind, SymbolScope,
+    elf, macho,
+    write::{
+        Object, Relocation, StandardSection, StandardSegment, Symbol as ObjSymbol, SymbolId,
+        SymbolSection,
+    },
+    FileFlags, RelocationEncoding, RelocationKind, SectionKind, SymbolFlags, SymbolKind,
+    SymbolScope,
 };
-use wasmer_types::entity::PrimaryMap;
+use wasmer_types::entity::{EntityRef, PrimaryMap};
+use wasmer_types::target::{Architecture, BinaryFormat, Endianness, PointerWidth, Triple};
 use wasmer_types::LocalFunctionIndex;
-use wasmer_types::{
-    Architecture, BinaryFormat, Compilation, CustomSectionProtection, Endianness,
-    RelocationKind as Reloc, RelocationTarget, SectionIndex, Triple,
-};
-use wasmer_types::{Symbol, SymbolRegistry};
 
 const DWARF_SECTION_NAME: &[u8] = b".eh_frame";
 
@@ -21,9 +28,8 @@ const DWARF_SECTION_NAME: &[u8] = b".eh_frame";
 /// # Usage
 ///
 /// ```rust
-/// # use wasmer_types::Triple;
-/// # use wasmer_object::ObjectError;
-/// use wasmer_object::get_object_for_target;
+/// # use wasmer_types::target::Triple;
+/// # use wasmer_compiler::object::{ObjectError, get_object_for_target};
 ///
 /// # fn generate_object_for_target(triple: &Triple) -> Result<(), ObjectError> {
 /// let mut object = get_object_for_target(&triple)?;
@@ -38,8 +44,7 @@ pub fn get_object_for_target(triple: &Triple) -> Result<Object, ObjectError> {
         BinaryFormat::Coff => object::BinaryFormat::Coff,
         binary_format => {
             return Err(ObjectError::UnsupportedBinaryFormat(format!(
-                "{}",
-                binary_format
+                "{binary_format}"
             )));
         }
     };
@@ -47,10 +52,10 @@ pub fn get_object_for_target(triple: &Triple) -> Result<Object, ObjectError> {
         Architecture::X86_64 => object::Architecture::X86_64,
         Architecture::Aarch64(_) => object::Architecture::Aarch64,
         Architecture::Riscv64(_) => object::Architecture::Riscv64,
+        Architecture::LoongArch64 => object::Architecture::LoongArch64,
         architecture => {
             return Err(ObjectError::UnsupportedArchitecture(format!(
-                "{}",
-                architecture
+                "{architecture}"
             )));
         }
     };
@@ -80,9 +85,8 @@ pub fn get_object_for_target(triple: &Triple) -> Result<Object, ObjectError> {
 /// # Usage
 ///
 /// ```rust
-/// # use wasmer_types::Triple;
-/// # use wasmer_object::ObjectError;
-/// use wasmer_object::{get_object_for_target, emit_data};
+/// # use wasmer_types::target::Triple;
+/// # use wasmer_compiler::object::{ObjectError, get_object_for_target, emit_data};
 ///
 /// # fn emit_data_into_object(triple: &Triple) -> Result<(), ObjectError> {
 /// let mut object = get_object_for_target(&triple)?;
@@ -96,7 +100,7 @@ pub fn emit_data(
     name: &[u8],
     data: &[u8],
     align: u64,
-) -> Result<(), ObjectError> {
+) -> Result<u64, ObjectError> {
     let symbol_id = obj.add_symbol(ObjSymbol {
         name: name.to_vec(),
         value: 0,
@@ -108,9 +112,9 @@ pub fn emit_data(
         flags: SymbolFlags::None,
     });
     let section_id = obj.section_id(StandardSection::Data);
-    obj.add_symbol_data(symbol_id, section_id, data, align);
+    let offset = obj.add_symbol_data(symbol_id, section_id, data, align);
 
-    Ok(())
+    Ok(offset)
 }
 
 /// Emit the compilation result into an existing object.
@@ -118,18 +122,18 @@ pub fn emit_data(
 /// # Usage
 ///
 /// ```rust
-/// # use wasmer_types::SymbolRegistry;
-/// # use wasmer_types::{Compilation, Triple};
-/// # use wasmer_object::ObjectError;
-/// use wasmer_object::{get_object_for_target, emit_compilation};
+/// # use wasmer_compiler::types::{ symbols::SymbolRegistry, function::{Compilation} };
+/// # use wasmer_types::target::Triple;
+/// # use wasmer_compiler::object::{ObjectError, ObjectMetadataBuilder, get_object_for_target, emit_compilation};
 ///
 /// # fn emit_compilation_into_object(
 /// #     triple: &Triple,
 /// #     compilation: Compilation,
+/// #     builder: ObjectMetadataBuilder,
 /// #     symbol_registry: impl SymbolRegistry,
 /// # ) -> Result<(), ObjectError> {
 /// let mut object = get_object_for_target(&triple)?;
-/// emit_compilation(&mut object, compilation, &symbol_registry, &triple)?;
+/// emit_compilation(&mut object, compilation, &symbol_registry, &triple, &builder)?;
 /// # Ok(())
 /// # }
 /// ```
@@ -138,6 +142,7 @@ pub fn emit_compilation(
     compilation: Compilation,
     symbol_registry: &impl SymbolRegistry,
     triple: &Triple,
+    relocs_builder: &ObjectMetadataBuilder,
 ) -> Result<(), ObjectError> {
     let mut function_bodies = PrimaryMap::with_capacity(compilation.functions.len());
     let mut function_relocations = PrimaryMap::with_capacity(compilation.functions.len());
@@ -151,12 +156,19 @@ pub fn emit_compilation(
         .map(|(_, section)| section.relocations.clone())
         .collect::<PrimaryMap<SectionIndex, _>>();
 
-    let debug_index = compilation.debug.map(|d| d.eh_frame);
+    let debug_index = compilation.unwind_info.eh_frame;
 
-    let align = match triple.architecture {
-        Architecture::X86_64 => 1,
-        // In Arm64 is recommended a 4-byte alignment
-        Architecture::Aarch64(_) => 4,
+    let default_align = match triple.architecture {
+        target_lexicon::Architecture::Aarch64(_) => {
+            if matches!(
+                triple.operating_system,
+                target_lexicon::OperatingSystem::Darwin
+            ) {
+                8
+            } else {
+                4
+            }
+        }
         _ => 1,
     };
 
@@ -165,12 +177,12 @@ pub fn emit_compilation(
         .custom_sections
         .into_iter()
         .map(|(section_index, custom_section)| {
-            if debug_index.map_or(false, |d| d == section_index) {
+            if debug_index == Some(section_index) {
                 // If this is the debug section
                 let segment = obj.segment_name(StandardSegment::Debug).to_vec();
                 let section_id =
                     obj.add_section(segment, DWARF_SECTION_NAME.to_vec(), SectionKind::Debug);
-                obj.append_section_data(section_id, custom_section.bytes.as_slice(), align);
+                obj.append_section_data(section_id, custom_section.bytes.as_slice(), default_align);
                 let section_name = symbol_registry.symbol_to_name(Symbol::Section(section_index));
                 let symbol_id = obj.add_symbol(ObjSymbol {
                     name: section_name.into_bytes(),
@@ -206,7 +218,7 @@ pub fn emit_compilation(
                     symbol_id,
                     section_id,
                     custom_section.bytes.as_slice(),
-                    align,
+                    custom_section.alignment.unwrap_or(default_align),
                 );
                 (section_id, symbol_id)
             }
@@ -230,10 +242,13 @@ pub fn emit_compilation(
                 section: SymbolSection::Section(section_id),
                 flags: SymbolFlags::None,
             });
-            obj.add_symbol_data(symbol_id, section_id, &function.body, align);
+            obj.add_symbol_data(symbol_id, section_id, &function.body, default_align);
             (section_id, symbol_id)
         })
         .collect::<PrimaryMap<LocalFunctionIndex, _>>();
+    for (i, (_, symbol_id)) in function_symbol_ids.iter() {
+        relocs_builder.setup_function_pointer(obj, i.index(), *symbol_id)?;
+    }
 
     // Add function call trampolines
     for (signature_index, function) in compilation.function_call_trampolines.into_iter() {
@@ -250,7 +265,9 @@ pub fn emit_compilation(
             section: SymbolSection::Section(section_id),
             flags: SymbolFlags::None,
         });
-        obj.add_symbol_data(symbol_id, section_id, &function.body, align);
+        obj.add_symbol_data(symbol_id, section_id, &function.body, default_align);
+
+        relocs_builder.setup_trampoline(obj, signature_index.index(), symbol_id)?;
     }
 
     // Add dynamic function trampolines
@@ -268,7 +285,13 @@ pub fn emit_compilation(
             section: SymbolSection::Section(section_id),
             flags: SymbolFlags::None,
         });
-        obj.add_symbol_data(symbol_id, section_id, &function.body, align);
+        obj.add_symbol_data(symbol_id, section_id, &function.body, default_align);
+
+        relocs_builder.setup_dynamic_function_trampoline_pointer(
+            obj,
+            func_index.index(),
+            symbol_id,
+        )?;
     }
 
     let mut all_relocations = Vec::new();
@@ -279,7 +302,7 @@ pub fn emit_compilation(
     }
 
     for (section_index, relocations) in custom_section_relocations.into_iter() {
-        if !debug_index.map_or(false, |d| d == section_index) {
+        if debug_index != Some(section_index) {
             // Skip DWARF relocations just yet
             let (section_id, symbol_id) = custom_section_ids.get(section_index).unwrap();
             all_relocations.push((*section_id, *symbol_id, relocations));
@@ -314,7 +337,7 @@ pub fn emit_compilation(
                             value: macho::ARM64_RELOC_BRANCH26,
                             relative: true,
                         },
-                        fmt => panic!("unsupported binary format {:?}", fmt),
+                        fmt => panic!("unsupported binary format {fmt:?}"),
                     },
                     RelocationEncoding::Generic,
                     32,
@@ -324,9 +347,99 @@ pub fn emit_compilation(
                     RelocationEncoding::Generic,
                     32,
                 ),
+                Reloc::MachoArm64RelocBranch26 => (
+                    RelocationKind::MachO {
+                        value: macho::ARM64_RELOC_BRANCH26,
+                        relative: true,
+                    },
+                    RelocationEncoding::Generic,
+                    32,
+                ),
+                Reloc::MachoArm64RelocUnsigned => (
+                    RelocationKind::MachO {
+                        value: object::macho::ARM64_RELOC_UNSIGNED,
+                        relative: true,
+                    },
+                    RelocationEncoding::Generic,
+                    32,
+                ),
+                Reloc::MachoArm64RelocSubtractor => (
+                    RelocationKind::MachO {
+                        value: object::macho::ARM64_RELOC_SUBTRACTOR,
+                        relative: false,
+                    },
+                    RelocationEncoding::Generic,
+                    64,
+                ),
+                Reloc::MachoArm64RelocPage21 => (
+                    RelocationKind::MachO {
+                        value: object::macho::ARM64_RELOC_PAGE21,
+                        relative: true,
+                    },
+                    RelocationEncoding::Generic,
+                    32,
+                ),
+
+                Reloc::MachoArm64RelocPageoff12 => (
+                    RelocationKind::MachO {
+                        value: object::macho::ARM64_RELOC_PAGEOFF12,
+                        relative: false,
+                    },
+                    RelocationEncoding::Generic,
+                    32,
+                ),
+                Reloc::MachoArm64RelocGotLoadPage21 => (
+                    RelocationKind::MachO {
+                        value: object::macho::ARM64_RELOC_GOT_LOAD_PAGE21,
+                        relative: true,
+                    },
+                    RelocationEncoding::Generic,
+                    32,
+                ),
+                Reloc::MachoArm64RelocGotLoadPageoff12 => (
+                    RelocationKind::MachO {
+                        value: object::macho::ARM64_RELOC_GOT_LOAD_PAGEOFF12,
+                        relative: true,
+                    },
+                    RelocationEncoding::Generic,
+                    32,
+                ),
+                Reloc::MachoArm64RelocPointerToGot => (
+                    RelocationKind::MachO {
+                        value: object::macho::ARM64_RELOC_POINTER_TO_GOT,
+                        relative: true,
+                    },
+                    RelocationEncoding::Generic,
+                    32,
+                ),
+                Reloc::MachoArm64RelocTlvpLoadPage21 => (
+                    RelocationKind::MachO {
+                        value: object::macho::ARM64_RELOC_TLVP_LOAD_PAGE21,
+                        relative: true,
+                    },
+                    RelocationEncoding::Generic,
+                    32,
+                ),
+                Reloc::MachoArm64RelocTlvpLoadPageoff12 => (
+                    RelocationKind::MachO {
+                        value: object::macho::ARM64_RELOC_TLVP_LOAD_PAGEOFF12,
+                        relative: true,
+                    },
+                    RelocationEncoding::Generic,
+                    32,
+                ),
+                Reloc::MachoArm64RelocAddend => (
+                    RelocationKind::MachO {
+                        value: object::macho::ARM64_RELOC_ADDEND,
+                        relative: false,
+                    },
+                    RelocationEncoding::Generic,
+                    32,
+                ),
+
                 other => {
                     return Err(ObjectError::UnsupportedArchitecture(format!(
-                        "{} (relocation: {}",
+                        "{} (relocation: {})",
                         triple.architecture, other
                     )))
                 }
@@ -349,7 +462,13 @@ pub fn emit_compilation(
                     .map_err(ObjectError::Write)?;
                 }
                 RelocationTarget::LibCall(libcall) => {
-                    let libcall_fn_name = libcall.to_function_name().as_bytes();
+                    let mut libcall_fn_name = libcall.to_function_name().to_string();
+                    if matches!(triple.binary_format, BinaryFormat::Macho) {
+                        libcall_fn_name = format!("_{libcall_fn_name}");
+                    }
+
+                    let libcall_fn_name = libcall_fn_name.as_bytes();
+
                     // We add the symols lazily as we see them
                     let target_symbol = obj.symbol_id(libcall_fn_name).unwrap_or_else(|| {
                         obj.add_symbol(ObjSymbol {
@@ -403,10 +522,9 @@ pub fn emit_compilation(
 /// # Usage
 ///
 /// ```rust
-/// # use wasmer_types::SymbolRegistry;
-/// # use wasmer_types::{Compilation, Triple};
-/// # use wasmer_object::{ObjectError, emit_serialized};
-/// use wasmer_object::{get_object_for_target, emit_compilation};
+/// # use wasmer_compiler::types::{ symbols::SymbolRegistry, function::{Compilation} };
+/// # use wasmer_types::target::Triple;
+/// # use wasmer_compiler::object::{ObjectError, get_object_for_target, emit_serialized};
 ///
 /// # fn emit_compilation_into_object(
 /// #     triple: &Triple,
@@ -427,8 +545,8 @@ pub fn emit_serialized(
 ) -> Result<(), ObjectError> {
     obj.set_mangling(object::write::Mangling::None);
     //let module_name = module.compile_info.module.name.clone();
-    let len_name = format!("{}_LENGTH", object_name);
-    let data_name = format!("{}_DATA", object_name);
+    let len_name = format!("{object_name}_LENGTH");
+    let data_name = format!("{object_name}_DATA");
     //let metadata_name = "WASMER_MODULE_METADATA";
 
     let align = match triple.architecture {
@@ -467,3 +585,194 @@ pub fn emit_serialized(
 
     Ok(())
 }
+
+/// ObjectMetadataBuilder builds serialized module metadata include in
+/// an object. In addition, it also relies on information from ModuleInfo
+/// to build a table of function pointers, trmampolines and dynamic function
+/// trampoline pointers. ObjectMetadataBuilder takes care of setting up
+/// relocations, so a linker can automatically fill in actuall addesses of
+/// all relavant functions. There is no need to piece the information together
+/// in the glue C file.
+pub struct ObjectMetadataBuilder {
+    placeholder_data: Vec<u8>,
+    metadata_length: u64,
+    section_offset: u64,
+    num_function_pointers: u64,
+    num_trampolines: u64,
+    num_dynamic_function_trampoline_pointers: u64,
+    endianness: Endianness,
+    pointer_width: PointerWidth,
+}
+
+impl ObjectMetadataBuilder {
+    /// Creates a new FunctionRelocsBuilder
+    pub fn new(metadata: &ModuleMetadata, triple: &Triple) -> Result<Self, ObjectError> {
+        let serialized_data = metadata.serialize()?;
+        let mut metadata_binary = vec![];
+        metadata_binary.extend(MetadataHeader::new(serialized_data.len()).into_bytes());
+        metadata_binary.extend(serialized_data);
+        let metadata_length = metadata_binary.len() as u64;
+
+        let pointer_width = triple.pointer_width().unwrap();
+        let endianness = triple
+            .endianness()
+            .map_err(|_| ObjectError::UnknownEndianness)?;
+
+        let module = &metadata.compile_info.module;
+        let num_function_pointers = module
+            .functions
+            .iter()
+            .filter(|(f_index, _)| module.local_func_index(*f_index).is_some())
+            .count() as u64;
+        let num_trampolines = module.signatures.len() as u64;
+        let num_dynamic_function_trampoline_pointers = module.num_imported_functions as u64;
+
+        let mut aself = Self {
+            placeholder_data: metadata_binary,
+            metadata_length,
+            section_offset: 0,
+            num_function_pointers,
+            num_trampolines,
+            num_dynamic_function_trampoline_pointers,
+            endianness,
+            pointer_width,
+        };
+
+        aself
+            .placeholder_data
+            .extend_from_slice(&aself.serialize_value(aself.num_function_pointers));
+        aself.placeholder_data.extend_from_slice(&vec![
+            0u8;
+            (aself.pointer_bytes() * aself.num_function_pointers)
+                as usize
+        ]);
+        aself
+            .placeholder_data
+            .extend_from_slice(&aself.serialize_value(aself.num_trampolines));
+        aself.placeholder_data.extend_from_slice(&vec![
+            0u8;
+            (aself.pointer_bytes() * aself.num_trampolines)
+                as usize
+        ]);
+        aself.placeholder_data.extend_from_slice(
+            &aself.serialize_value(aself.num_dynamic_function_trampoline_pointers),
+        );
+        aself.placeholder_data.extend_from_slice(&vec![
+            0u8;
+            (aself.pointer_bytes() * aself.num_dynamic_function_trampoline_pointers)
+                as usize
+        ]);
+
+        Ok(aself)
+    }
+
+    /// Sets section offset used in relocations
+    pub fn set_section_offset(&mut self, offset: u64) {
+        self.section_offset = offset;
+    }
+
+    /// Placeholder data for emit_data call
+    pub fn placeholder_data(&self) -> &[u8] {
+        &self.placeholder_data
+    }
+
+    /// Bytes of a pointer for target architecture
+    pub fn pointer_bytes(&self) -> u64 {
+        self.pointer_width.bytes() as u64
+    }
+
+    /// Sets up relocation for a function pointer
+    pub fn setup_function_pointer(
+        &self,
+        obj: &mut Object,
+        index: usize,
+        symbol_id: SymbolId,
+    ) -> Result<(), ObjectError> {
+        let section_id = obj.section_id(StandardSection::Data);
+        obj.add_relocation(
+            section_id,
+            Relocation {
+                offset: self.function_pointers_start_offset()
+                    + self.pointer_bytes() * (index as u64),
+                size: self.pointer_width.bits(),
+                kind: RelocationKind::Absolute,
+                encoding: RelocationEncoding::Generic,
+                symbol: symbol_id,
+                addend: 0,
+            },
+        )
+        .map_err(ObjectError::Write)
+    }
+
+    /// Sets up relocation for a trampoline
+    pub fn setup_trampoline(
+        &self,
+        obj: &mut Object,
+        index: usize,
+        symbol_id: SymbolId,
+    ) -> Result<(), ObjectError> {
+        let section_id = obj.section_id(StandardSection::Data);
+        obj.add_relocation(
+            section_id,
+            Relocation {
+                offset: self.trampolines_start_offset() + self.pointer_bytes() * (index as u64),
+                size: self.pointer_width.bits(),
+                kind: RelocationKind::Absolute,
+                encoding: RelocationEncoding::Generic,
+                symbol: symbol_id,
+                addend: 0,
+            },
+        )
+        .map_err(ObjectError::Write)
+    }
+
+    /// Sets up relocation for a dynamic function trampoline pointer
+    pub fn setup_dynamic_function_trampoline_pointer(
+        &self,
+        obj: &mut Object,
+        index: usize,
+        symbol_id: SymbolId,
+    ) -> Result<(), ObjectError> {
+        let section_id = obj.section_id(StandardSection::Data);
+        obj.add_relocation(
+            section_id,
+            Relocation {
+                offset: self.dynamic_function_trampoline_pointers_start_offset()
+                    + self.pointer_bytes() * (index as u64),
+                size: self.pointer_width.bits(),
+                kind: RelocationKind::Absolute,
+                encoding: RelocationEncoding::Generic,
+                symbol: symbol_id,
+                addend: 0,
+            },
+        )
+        .map_err(ObjectError::Write)
+    }
+
+    fn function_pointers_start_offset(&self) -> u64 {
+        self.section_offset + self.metadata_length + self.pointer_bytes()
+    }
+
+    fn trampolines_start_offset(&self) -> u64 {
+        self.function_pointers_start_offset()
+            + self.pointer_bytes() * self.num_function_pointers
+            + self.pointer_bytes()
+    }
+
+    fn dynamic_function_trampoline_pointers_start_offset(&self) -> u64 {
+        self.trampolines_start_offset()
+            + self.pointer_bytes() * self.num_trampolines
+            + self.pointer_bytes()
+    }
+
+    fn serialize_value(&self, value: u64) -> Vec<u8> {
+        match (self.endianness, self.pointer_width) {
+            (Endianness::Little, PointerWidth::U16) => (value as u16).to_le_bytes().to_vec(),
+            (Endianness::Big, PointerWidth::U16) => (value as u16).to_be_bytes().to_vec(),
+            (Endianness::Little, PointerWidth::U32) => (value as u32).to_le_bytes().to_vec(),
+            (Endianness::Big, PointerWidth::U32) => (value as u32).to_be_bytes().to_vec(),
+            (Endianness::Little, PointerWidth::U64) => value.to_le_bytes().to_vec(),
+            (Endianness::Big, PointerWidth::U64) => value.to_be_bytes().to_vec(),
+        }
+    }
+}
diff --git a/lib/compiler/src/serialize.rs b/lib/compiler/src/serialize.rs
new file mode 100644
index 0000000000..1071d700c4
--- /dev/null
+++ b/lib/compiler/src/serialize.rs
@@ -0,0 +1,175 @@
+/*
+ * ! Remove me once rkyv generates doc-comments for fields or generates an #[allow(missing_docs)]
+ * on their own.
+ */
+#![allow(missing_docs)]
+
+use crate::types::{
+    function::{CompiledFunctionFrameInfo, FunctionBody, UnwindInfo, GOT},
+    module::CompileModuleInfo,
+    relocation::Relocation,
+    section::{CustomSection, SectionIndex},
+};
+use enumset::EnumSet;
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+use wasmer_types::{
+    entity::PrimaryMap, target::CpuFeature, DeserializeError, Features, FunctionIndex,
+    LocalFunctionIndex, MemoryIndex, MemoryStyle, ModuleInfo, OwnedDataInitializer, SerializeError,
+    SignatureIndex, TableIndex, TableStyle,
+};
+
+pub use wasmer_types::MetadataHeader;
+
+/// The compilation related data for a serialized modules
+#[derive(Archive, Default, RkyvDeserialize, RkyvSerialize)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[allow(missing_docs)]
+#[rkyv(derive(Debug))]
+pub struct SerializableCompilation {
+    pub function_bodies: PrimaryMap<LocalFunctionIndex, FunctionBody>,
+    pub function_relocations: PrimaryMap<LocalFunctionIndex, Vec<Relocation>>,
+    pub function_frame_info: PrimaryMap<LocalFunctionIndex, CompiledFunctionFrameInfo>,
+    pub function_call_trampolines: PrimaryMap<SignatureIndex, FunctionBody>,
+    pub dynamic_function_trampolines: PrimaryMap<FunctionIndex, FunctionBody>,
+    pub custom_sections: PrimaryMap<SectionIndex, CustomSection>,
+    pub custom_section_relocations: PrimaryMap<SectionIndex, Vec<Relocation>>,
+    // The section indices corresponding to the Dwarf debug info
+    pub unwind_info: UnwindInfo,
+    pub got: GOT,
+    // Custom section containing libcall trampolines.
+    pub libcall_trampolines: SectionIndex,
+    // Length of each libcall trampoline.
+    pub libcall_trampoline_len: u32,
+}
+
+impl SerializableCompilation {
+    /// Serialize a Compilation into bytes
+    /// The bytes will have the following format:
+    /// RKYV serialization (any length) + POS (8 bytes)
+    pub fn serialize(&self) -> Result<Vec<u8>, SerializeError> {
+        rkyv::to_bytes::<rkyv::rancor::Error>(self)
+            .map(|v| v.into_vec())
+            .map_err(|e| SerializeError::Generic(e.to_string()))
+    }
+}
+
+/// Serializable struct that is able to serialize from and to a `ArtifactInfo`.
+#[derive(Archive, RkyvDeserialize, RkyvSerialize)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[allow(missing_docs)]
+#[rkyv(derive(Debug))]
+pub struct SerializableModule {
+    /// The main serializable compilation object
+    pub compilation: SerializableCompilation,
+    /// Compilation informations
+    pub compile_info: CompileModuleInfo,
+    /// Datas initializers
+    pub data_initializers: Box<[OwnedDataInitializer]>,
+    /// CPU Feature flags for this compilation
+    pub cpu_features: u64,
+}
+
+impl SerializableModule {
+    /// Serialize a Module into bytes
+    /// The bytes will have the following format:
+    /// RKYV serialization (any length) + POS (8 bytes)
+    pub fn serialize(&self) -> Result<Vec<u8>, SerializeError> {
+        rkyv::to_bytes::<rkyv::rancor::Error>(self)
+            .map(|v| v.into_vec())
+            .map_err(|e| SerializeError::Generic(e.to_string()))
+    }
+
+    /// Deserialize a Module from a slice.
+    /// The slice must have the following format:
+    /// RKYV serialization (any length) + POS (8 bytes)
+    ///
+    /// # Safety
+    ///
+    /// This method is unsafe since it deserializes data directly
+    /// from memory.
+    /// Right now we are not doing any extra work for validation, but
+    /// `rkyv` has an option to do bytecheck on the serialized data before
+    /// serializing (via `rkyv::check_archived_value`).
+    pub unsafe fn deserialize_unchecked(metadata_slice: &[u8]) -> Result<Self, DeserializeError> {
+        let archived = Self::archive_from_slice(metadata_slice)?;
+        Self::deserialize_from_archive(archived)
+    }
+
+    /// Deserialize a Module from a slice.
+    /// The slice must have the following format:
+    /// RKYV serialization (any length) + POS (8 bytes)
+    ///
+    /// Unlike [`Self::deserialize`], this function will validate the data.
+    ///
+    /// # Safety
+    /// Unsafe because it loads executable code into memory.
+    /// The loaded bytes must be trusted.
+    pub unsafe fn deserialize(metadata_slice: &[u8]) -> Result<Self, DeserializeError> {
+        let archived = Self::archive_from_slice_checked(metadata_slice)?;
+        Self::deserialize_from_archive(archived)
+    }
+
+    /// # Safety
+    ///
+    /// This method is unsafe.
+    /// Please check `SerializableModule::deserialize` for more details.
+    pub unsafe fn archive_from_slice(
+        metadata_slice: &[u8],
+    ) -> Result<&ArchivedSerializableModule, DeserializeError> {
+        Ok(rkyv::access_unchecked(metadata_slice))
+    }
+
+    /// Deserialize an archived module.
+    ///
+    /// In contrast to [`Self::deserialize`], this method performs validation
+    /// and is not unsafe.
+    pub fn archive_from_slice_checked(
+        metadata_slice: &[u8],
+    ) -> Result<&ArchivedSerializableModule, DeserializeError> {
+        rkyv::access::<_, rkyv::rancor::Error>(metadata_slice)
+            .map_err(|e| DeserializeError::CorruptedBinary(e.to_string()))
+    }
+
+    /// Deserialize a compilation module from an archive
+    pub fn deserialize_from_archive(
+        archived: &ArchivedSerializableModule,
+    ) -> Result<Self, DeserializeError> {
+        rkyv::deserialize::<_, rkyv::rancor::Error>(archived)
+            .map_err(|e| DeserializeError::CorruptedBinary(e.to_string()))
+    }
+
+    /// Create a `ModuleInfo` for instantiation
+    pub fn create_module_info(&self) -> ModuleInfo {
+        self.compile_info.module.as_ref().clone()
+    }
+
+    /// Returns the `ModuleInfo` for instantiation
+    pub fn module_info(&self) -> &ModuleInfo {
+        &self.compile_info.module
+    }
+
+    /// Returns the features for this Artifact
+    pub fn features(&self) -> &Features {
+        &self.compile_info.features
+    }
+
+    /// Returns the CPU features for this Artifact
+    pub fn cpu_features(&self) -> EnumSet<CpuFeature> {
+        EnumSet::from_u64(self.cpu_features)
+    }
+
+    /// Returns data initializers to pass to `VMInstance::initialize`
+    pub fn data_initializers(&self) -> &[OwnedDataInitializer] {
+        &self.data_initializers
+    }
+
+    /// Returns the memory styles associated with this `Artifact`.
+    pub fn memory_styles(&self) -> &PrimaryMap<MemoryIndex, MemoryStyle> {
+        &self.compile_info.memory_styles
+    }
+
+    /// Returns the table plans associated with this `Artifact`.
+    pub fn table_styles(&self) -> &PrimaryMap<TableIndex, TableStyle> {
+        &self.compile_info.table_styles
+    }
+}
diff --git a/lib/compiler/src/traits.rs b/lib/compiler/src/traits.rs
index 308a29f942..60fd56eade 100644
--- a/lib/compiler/src/traits.rs
+++ b/lib/compiler/src/traits.rs
@@ -7,7 +7,8 @@ use std::sync::Arc;
 use wasmer_types::entity::PrimaryMap;
 use wasmer_types::SerializeError;
 use wasmer_types::{
-    CpuFeature, DataInitializerLike, MemoryIndex, MemoryStyle, ModuleInfo, TableIndex, TableStyle,
+    target::CpuFeature, DataInitializerLike, MemoryIndex, MemoryStyle, ModuleInfo, TableIndex,
+    TableStyle,
 };
 
 /// An `Artifact` is the product that the `Engine`
@@ -29,19 +30,19 @@ pub trait ArtifactCreate<'a>: Send + Sync + Upcastable {
     fn set_module_info_name(&'a mut self, name: String) -> bool;
 
     /// Returns the `ModuleInfo` for instantiation
-    fn module_info(&'a self) -> &ModuleInfo;
+    fn module_info(&'a self) -> &'a ModuleInfo;
 
     /// Returns the features for this Artifact
-    fn features(&'a self) -> &Features;
+    fn features(&'a self) -> &'a Features;
 
     /// Returns the CPU features for this Artifact
     fn cpu_features(&'a self) -> EnumSet<CpuFeature>;
 
     /// Returns the memory styles associated with this `Artifact`.
-    fn memory_styles(&'a self) -> &PrimaryMap<MemoryIndex, MemoryStyle>;
+    fn memory_styles(&'a self) -> &'a PrimaryMap<MemoryIndex, MemoryStyle>;
 
     /// Returns the table plans associated with this `Artifact`.
-    fn table_styles(&'a self) -> &PrimaryMap<TableIndex, TableStyle>;
+    fn table_styles(&'a self) -> &'a PrimaryMap<TableIndex, TableStyle>;
 
     /// Returns data initializers to pass to `VMInstance::initialize`
     fn data_initializers(&'a self) -> Self::OwnedDataInitializerIterator;
diff --git a/lib/compiler/src/translator/environ.rs b/lib/compiler/src/translator/environ.rs
index c0b376b02c..5e7b823cb6 100644
--- a/lib/compiler/src/translator/environ.rs
+++ b/lib/compiler/src/translator/environ.rs
@@ -9,13 +9,13 @@ use std::convert::{TryFrom, TryInto};
 use std::ops::Range;
 use wasmer_types::entity::PrimaryMap;
 use wasmer_types::FunctionType;
-use wasmer_types::WasmResult;
 use wasmer_types::{
     CustomSectionIndex, DataIndex, DataInitializer, DataInitializerLocation, ElemIndex,
     ExportIndex, FunctionIndex, GlobalIndex, GlobalInit, GlobalType, ImportIndex,
     LocalFunctionIndex, MemoryIndex, MemoryType, ModuleInfo, SignatureIndex, TableIndex,
     TableInitializer, TableType,
 };
+use wasmer_types::{TagIndex, WasmResult};
 
 /// Contains function data: bytecode and its offset in the module.
 #[derive(Hash)]
@@ -85,7 +85,7 @@ impl<'data> ModuleEnvironment<'data> {
 
     /// Translate a wasm module using this environment. This consumes the
     /// `ModuleEnvironment` and produces a `ModuleInfoTranslation`.
-    pub fn translate(mut self, data: &'data [u8]) -> WasmResult<ModuleEnvironment<'data>> {
+    pub fn translate(mut self, data: &'data [u8]) -> WasmResult<Self> {
         assert!(self.module_translation_state.is_none());
         let module_translation_state = translate_module(data, &mut self)?;
         self.module_translation_state = Some(module_translation_state);
@@ -152,6 +152,39 @@ impl<'data> ModuleEnvironment<'data> {
         Ok(())
     }
 
+    pub(crate) fn declare_tag_import(
+        &mut self,
+        t: wasmparser::TagType,
+        module_name: &str,
+        field_name: &str,
+    ) -> WasmResult<()> {
+        debug_assert_eq!(
+            self.module.tags.len(),
+            self.module.num_imported_tags,
+            "Imported tags must be declared first"
+        );
+
+        let tag = SignatureIndex::from_u32(t.func_type_idx);
+        debug_assert!(
+            self.module
+                .signatures
+                .get(SignatureIndex::from_u32(t.func_type_idx))
+                .is_some(),
+            "Imported tags must mach a declared signature!"
+        );
+
+        self.declare_import(
+            ImportIndex::Tag(TagIndex::from_u32(self.module.num_imported_tags as _)),
+            module_name,
+            field_name,
+        )?;
+
+        self.module.num_imported_tags += 1;
+        self.module.tags.push(tag);
+
+        Ok(())
+    }
+
     pub(crate) fn declare_table_import(
         &mut self,
         table: TableType,
@@ -259,6 +292,18 @@ impl<'data> ModuleEnvironment<'data> {
         Ok(())
     }
 
+    pub(crate) fn reserve_tags(&mut self, num: u32) -> WasmResult<()> {
+        self.module
+            .tags
+            .reserve_exact(usize::try_from(num).unwrap());
+        Ok(())
+    }
+
+    pub(crate) fn declare_tag(&mut self, tag: SignatureIndex) -> WasmResult<()> {
+        self.module.tags.push(tag);
+        Ok(())
+    }
+
     pub(crate) fn reserve_globals(&mut self, num: u32) -> WasmResult<()> {
         self.module
             .globals
@@ -305,6 +350,10 @@ impl<'data> ModuleEnvironment<'data> {
         self.declare_export(ExportIndex::Memory(memory_index), name)
     }
 
+    pub(crate) fn declare_tag_export(&mut self, tag_index: TagIndex, name: &str) -> WasmResult<()> {
+        self.declare_export(ExportIndex::Tag(tag_index), name)
+    }
+
     pub(crate) fn declare_global_export(
         &mut self,
         global_index: GlobalIndex,
diff --git a/lib/compiler/src/translator/error.rs b/lib/compiler/src/translator/error.rs
index d562353ce7..1b21a7f6cf 100644
--- a/lib/compiler/src/translator/error.rs
+++ b/lib/compiler/src/translator/error.rs
@@ -8,7 +8,7 @@ macro_rules! wasm_unsupported {
     ($($arg:tt)*) => { wasmer_types::WasmError::Unsupported(format!($($arg)*)) }
 }
 
-///
+/// Make a [`WasmError`] out of a [`BinaryReaderError`].
 pub fn from_binaryreadererror_wasmerror(original: BinaryReaderError) -> WasmError {
     WasmError::InvalidWebAssembly {
         message: original.message().into(),
@@ -16,7 +16,7 @@ pub fn from_binaryreadererror_wasmerror(original: BinaryReaderError) -> WasmErro
     }
 }
 
-///
+/// Make a [`CompileError`] out of a [`BinaryReaderError`].
 #[allow(dead_code)]
 pub fn from_binaryreadererror_compileerror(original: BinaryReaderError) -> CompileError {
     // BinaryReaderError -> WasmError -> CompileError
@@ -30,27 +30,27 @@ mod tests {
 
     #[test]
     fn can_convert_binary_reader_error_to_wasm_error() {
-        let mut reader = BinaryReader::new(b"\0\0\0\0");
+        let mut reader = BinaryReader::new(b"\0\0\0\0", 0);
         let binary_reader_error = reader.read_bytes(10).unwrap_err();
         match from_binaryreadererror_wasmerror(binary_reader_error) {
             WasmError::InvalidWebAssembly { message, offset } => {
                 assert_eq!(message, "unexpected end-of-file");
                 assert_eq!(offset, 0);
             }
-            err => panic!("Unexpected error: {:?}", err),
+            err => panic!("Unexpected error: {err:?}"),
         }
     }
 
     #[test]
     fn can_convert_binary_reader_error_to_compile_error() {
-        let mut reader = BinaryReader::new(b"\0\0\0\0");
+        let mut reader = BinaryReader::new(b"\0\0\0\0", 0);
         let binary_reader_error = reader.read_bytes(10).unwrap_err();
         match from_binaryreadererror_compileerror(binary_reader_error) {
             CompileError::Wasm(WasmError::InvalidWebAssembly { message, offset }) => {
                 assert_eq!(message, "unexpected end-of-file");
                 assert_eq!(offset, 0);
             }
-            err => panic!("Unexpected error: {:?}", err),
+            err => panic!("Unexpected error: {err:?}"),
         }
     }
 }
diff --git a/lib/compiler/src/translator/middleware.rs b/lib/compiler/src/translator/middleware.rs
index 5d60cf04f5..8664b22115 100644
--- a/lib/compiler/src/translator/middleware.rs
+++ b/lib/compiler/src/translator/middleware.rs
@@ -128,7 +128,7 @@ impl<'a: 'b, 'b> Extend<&'b Operator<'a>> for MiddlewareReaderState<'a> {
 impl<'a> MiddlewareBinaryReader<'a> {
     /// Constructs a `MiddlewareBinaryReader` with an explicit starting offset.
     pub fn new_with_offset(data: &'a [u8], original_offset: usize) -> Self {
-        let inner = BinaryReader::new_with_offset(data, original_offset);
+        let inner = BinaryReader::new(data, original_offset);
         Self {
             state: MiddlewareReaderState {
                 inner,
diff --git a/lib/compiler/src/translator/module.rs b/lib/compiler/src/translator/module.rs
index 68c67f807c..f460c2689d 100644
--- a/lib/compiler/src/translator/module.rs
+++ b/lib/compiler/src/translator/module.rs
@@ -8,11 +8,11 @@ use super::error::from_binaryreadererror_wasmerror;
 use super::sections::{
     parse_data_section, parse_element_section, parse_export_section, parse_function_section,
     parse_global_section, parse_import_section, parse_memory_section, parse_name_section,
-    parse_start_section, parse_table_section, parse_type_section,
+    parse_start_section, parse_table_section, parse_tag_section, parse_type_section,
 };
 use super::state::ModuleTranslationState;
-use wasmer_types::WasmResult;
-use wasmparser::{NameSectionReader, Parser, Payload};
+use wasmer_types::{WasmError, WasmResult};
+use wasmparser::{BinaryReader, NameSectionReader, Parser, Payload};
 
 /// Translate a sequence of bytes forming a valid Wasm binary into a
 /// parsed ModuleInfo `ModuleTranslationState`.
@@ -83,23 +83,7 @@ pub fn translate_module<'data>(
                 environ.reserve_passive_data(count)?;
             }
 
-            Payload::InstanceSection(_)
-            | Payload::ComponentSection { .. }
-            | Payload::CoreTypeSection(_)
-            | Payload::ComponentTypeSection(_)
-            | Payload::ComponentInstanceSection(_)
-            | Payload::ComponentAliasSection(_)
-            | Payload::ComponentCanonicalSection(_)
-            | Payload::ComponentStartSection { .. }
-            | Payload::ComponentImportSection(_)
-            | Payload::ComponentExportSection(_)
-            | Payload::ModuleSection { .. } => {
-                unimplemented!("module linking not implemented. It will only be implemented if/when browsers support it")
-            }
-
-            Payload::TagSection(_) => {
-                unimplemented!("exception handling not implemented yet")
-            }
+            Payload::TagSection(t) => parse_tag_section(t, environ)?,
 
             Payload::CustomSection(sectionreader) => {
                 // We still add the custom section data, but also read it as name section reader
@@ -107,13 +91,21 @@ pub fn translate_module<'data>(
                 environ.custom_section(name, sectionreader.data())?;
                 if name == "name" {
                     parse_name_section(
-                        NameSectionReader::new(sectionreader.data(), sectionreader.data_offset()),
+                        NameSectionReader::new(BinaryReader::new(
+                            sectionreader.data(),
+                            sectionreader.data_offset(),
+                        )),
                         environ,
                     )?;
                 }
             }
 
             Payload::UnknownSection { .. } => unreachable!(),
+            k => {
+                return Err(WasmError::Unsupported(format!(
+                    "Unsupported paylod kind: {k:?}"
+                )))
+            }
         }
     }
 
diff --git a/lib/compiler/src/translator/sections.rs b/lib/compiler/src/translator/sections.rs
index c317184db0..291e325b4c 100644
--- a/lib/compiler/src/translator/sections.rs
+++ b/lib/compiler/src/translator/sections.rs
@@ -21,15 +21,15 @@ use wasmer_types::entity::packed_option::ReservedValue;
 use wasmer_types::entity::EntityRef;
 use wasmer_types::{
     DataIndex, ElemIndex, FunctionIndex, FunctionType, GlobalIndex, GlobalInit, GlobalType,
-    MemoryIndex, MemoryType, Pages, SignatureIndex, TableIndex, TableType, Type, V128,
+    MemoryIndex, MemoryType, Pages, SignatureIndex, TableIndex, TableType, TagIndex, Type, V128,
 };
 use wasmer_types::{WasmError, WasmResult};
 use wasmparser::{
     self, Data, DataKind, DataSectionReader, Element, ElementItems, ElementKind,
     ElementSectionReader, Export, ExportSectionReader, ExternalKind, FunctionSectionReader,
     GlobalSectionReader, GlobalType as WPGlobalType, ImportSectionReader, MemorySectionReader,
-    MemoryType as WPMemoryType, NameSectionReader, Operator, TableSectionReader, TypeRef,
-    TypeSectionReader,
+    MemoryType as WPMemoryType, NameSectionReader, Operator, TableSectionReader,
+    TagType as WPTagType, TypeRef, TypeSectionReader,
 };
 
 /// Helper function translating wasmparser types to Wasm Type.
@@ -50,6 +50,9 @@ pub fn wpreftype_to_type(ty: wasmparser::RefType) -> WasmResult<Type> {
         Ok(Type::ExternRef)
     } else if ty.is_func_ref() {
         Ok(Type::FuncRef)
+    } else if ty == wasmparser::RefType::EXNREF || ty == wasmparser::RefType::EXN {
+        // no `.is_exnref` yet
+        Ok(Type::ExceptionRef)
     } else {
         Err(wasm_unsupported!("unsupported reference type: {:?}", ty))
     }
@@ -58,8 +61,12 @@ pub fn wpreftype_to_type(ty: wasmparser::RefType) -> WasmResult<Type> {
 /// Converts a wasmparser heap type to a Wasm Type.
 pub fn wpheaptype_to_type(ty: wasmparser::HeapType) -> WasmResult<Type> {
     match ty {
-        wasmparser::HeapType::Func => Ok(Type::FuncRef),
-        wasmparser::HeapType::Extern => Ok(Type::ExternRef),
+        wasmparser::HeapType::Abstract { ty, .. } => match ty {
+            wasmparser::AbstractHeapType::Func => Ok(Type::FuncRef),
+            wasmparser::AbstractHeapType::Extern => Ok(Type::ExternRef),
+            wasmparser::AbstractHeapType::Exn => Ok(Type::ExceptionRef),
+            other => Err(wasm_unsupported!("unsupported reference type: {other:?}")),
+        },
         other => Err(wasm_unsupported!("unsupported reference type: {other:?}")),
     }
 }
@@ -122,14 +129,15 @@ pub fn parse_import_section<'data>(
                     field_name,
                 )?;
             }
-            TypeRef::Tag(_) => {
-                unimplemented!("exception handling not implemented yet")
+            TypeRef::Tag(t) => {
+                environ.declare_tag_import(t, module_name, field_name)?;
             }
             TypeRef::Memory(WPMemoryType {
                 shared,
                 memory64,
                 initial,
                 maximum,
+                ..
             }) => {
                 if memory64 {
                     unimplemented!("64bit memory not implemented yet");
@@ -158,8 +166,8 @@ pub fn parse_import_section<'data>(
                 environ.declare_table_import(
                     TableType {
                         ty: wpreftype_to_type(tab.element_type)?,
-                        minimum: tab.initial,
-                        maximum: tab.maximum,
+                        minimum: tab.initial as u32,
+                        maximum: tab.maximum.map(|v| v as u32),
                     },
                     module_name,
                     field_name,
@@ -178,7 +186,7 @@ pub fn parse_function_section(
     environ: &mut ModuleEnvironment,
 ) -> WasmResult<()> {
     let num_functions = functions.count();
-    if num_functions == std::u32::MAX {
+    if num_functions == u32::MAX {
         // We reserve `u32::MAX` for our own use.
         return Err(WasmError::ImplLimitExceeded);
     }
@@ -204,8 +212,8 @@ pub fn parse_table_section(
         let table = entry.map_err(from_binaryreadererror_wasmerror)?;
         environ.declare_table(TableType {
             ty: wpreftype_to_type(table.ty.element_type).unwrap(),
-            minimum: table.ty.initial,
-            maximum: table.ty.maximum,
+            minimum: table.ty.initial as u32,
+            maximum: table.ty.maximum.map(|v| v as u32),
         })?;
     }
 
@@ -225,6 +233,7 @@ pub fn parse_memory_section(
             memory64,
             initial,
             maximum,
+            ..
         } = entry.map_err(from_binaryreadererror_wasmerror)?;
         if memory64 {
             unimplemented!("64bit memory not implemented yet");
@@ -239,6 +248,21 @@ pub fn parse_memory_section(
     Ok(())
 }
 
+/// Parser the Tag section of the wasm module.
+pub fn parse_tag_section(
+    tags: wasmparser::SectionLimited<wasmparser::TagType>,
+    environ: &mut ModuleEnvironment,
+) -> WasmResult<()> {
+    environ.reserve_tags(tags.count())?;
+
+    for entry in tags {
+        let WPTagType { func_type_idx, .. } = entry.map_err(from_binaryreadererror_wasmerror)?;
+        environ.declare_tag(SignatureIndex::from_u32(func_type_idx))?;
+    }
+
+    Ok(())
+}
+
 /// Parses the Global section of the wasm module.
 pub fn parse_global_section(
     globals: GlobalSectionReader,
@@ -248,10 +272,12 @@ pub fn parse_global_section(
 
     for entry in globals {
         let wasmparser::Global {
-            ty: WPGlobalType {
-                content_type,
-                mutable,
-            },
+            ty:
+                WPGlobalType {
+                    content_type,
+                    mutable,
+                    ..
+                },
             init_expr,
         } = entry.map_err(from_binaryreadererror_wasmerror)?;
         let mut init_expr_reader = init_expr.get_binary_reader();
@@ -318,9 +344,7 @@ pub fn parse_export_section<'data>(
             ExternalKind::Global => {
                 environ.declare_global_export(GlobalIndex::new(index), field)?
             }
-            ExternalKind::Tag => {
-                unimplemented!("exception handling not implemented yet")
-            }
+            ExternalKind::Tag => environ.declare_tag_export(TagIndex::new(index), field)?,
         }
     }
 
@@ -494,7 +518,7 @@ pub fn parse_name_section<'data>(
         match subsection {
             wasmparser::Name::Function(function_subsection) => {
                 for naming in function_subsection.into_iter().flatten() {
-                    if naming.index != std::u32::MAX {
+                    if naming.index != u32::MAX {
                         environ.declare_function_name(
                             FunctionIndex::from_u32(naming.index),
                             naming.name,
@@ -517,6 +541,7 @@ pub fn parse_name_section<'data>(
             | wasmparser::Name::Element(_)
             | wasmparser::Name::Data(_)
             | wasmparser::Name::Unknown { .. }
+            | wasmparser::Name::Field(_)
             | wasmparser::Name::Tag(..) => {}
         }
     }
diff --git a/lib/compiler/src/translator/state.rs b/lib/compiler/src/translator/state.rs
index a074a30c30..0425f6fd48 100644
--- a/lib/compiler/src/translator/state.rs
+++ b/lib/compiler/src/translator/state.rs
@@ -50,6 +50,7 @@ impl ModuleTranslationState {
 }
 
 /// A helper enum for representing either a single or multiple values.
+#[derive(Clone)]
 pub enum SingleOrMultiValue<'a> {
     /// A single value.
     Single(&'a wasmparser::ValType),
@@ -57,7 +58,7 @@ pub enum SingleOrMultiValue<'a> {
     Multi(&'a [wasmparser::ValType]),
 }
 
-impl<'a> SingleOrMultiValue<'a> {
+impl SingleOrMultiValue<'_> {
     /// True if empty.
     pub fn is_empty(&self) -> bool {
         match self {
@@ -119,7 +120,7 @@ impl<'a> Iterator for SingleOrMultiValueIterator<'a> {
     }
 }
 
-impl<'a> PartialEq<[wasmparser::ValType]> for SingleOrMultiValue<'a> {
+impl PartialEq<[wasmparser::ValType]> for SingleOrMultiValue<'_> {
     fn eq(&self, other: &[wasmparser::ValType]) -> bool {
         match self {
             SingleOrMultiValue::Single(ty) => other.len() == 1 && &other[0] == *ty,
diff --git a/lib/types/src/compilation/address_map.rs b/lib/compiler/src/types/address_map.rs
similarity index 80%
rename from lib/types/src/compilation/address_map.rs
rename to lib/compiler/src/types/address_map.rs
index 0fee3ccd21..48a0ecf220 100644
--- a/lib/types/src/compilation/address_map.rs
+++ b/lib/compiler/src/types/address_map.rs
@@ -1,16 +1,23 @@
+/*
+ * ! Remove me once rkyv generates doc-comments for fields or generates an #[allow(missing_docs)]
+ * on their own.
+ */
+#![allow(missing_docs)]
+
 //! Data structures to provide transformation of the source
 // addresses of a WebAssembly module into the native code.
 
 use crate::lib::std::vec::Vec;
-use crate::SourceLoc;
 use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
 #[cfg(feature = "enable-serde")]
 use serde::{Deserialize, Serialize};
+use wasmer_types::SourceLoc;
 
 /// Single source location to generated address mapping.
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, Clone, Copy, PartialEq, Eq)]
-#[archive_attr(derive(rkyv::CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub struct InstructionAddressMap {
     /// Original source location.
     pub srcloc: SourceLoc,
@@ -23,9 +30,10 @@ pub struct InstructionAddressMap {
 }
 
 /// Function and its instructions addresses mappings.
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 #[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, Clone, PartialEq, Eq, Default)]
-#[archive_attr(derive(rkyv::CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub struct FunctionAddressMap {
     /// Instructions maps.
     /// The array is sorted by the InstructionAddressMap::code_offset field.
diff --git a/lib/types/src/compilation/function.rs b/lib/compiler/src/types/function.rs
similarity index 67%
rename from lib/types/src/compilation/function.rs
rename to lib/compiler/src/types/function.rs
index aabf119567..c0abc08e77 100644
--- a/lib/types/src/compilation/function.rs
+++ b/lib/compiler/src/types/function.rs
@@ -1,30 +1,40 @@
+/*
+ * ! Remove me once rkyv generates doc-comments for fields or generates an #[allow(missing_docs)]
+ * on their own.
+ */
+#![allow(missing_docs)]
 // This file contains code from external sources.
 // Attributions: https://github.com/wasmerio/wasmer/blob/main/docs/ATTRIBUTIONS.md
 
 //! A `Compilation` contains the compiled function bodies for a WebAssembly
 //! module (`CompiledFunction`).
 
-use crate::entity::PrimaryMap;
-use crate::lib::std::vec::Vec;
-use crate::{ArchivedCompiledFunctionUnwindInfo, TrapInformation};
-use crate::{CompiledFunctionUnwindInfo, FunctionAddressMap};
-use crate::{
-    CustomSection, FunctionIndex, LocalFunctionIndex, Relocation, SectionIndex, SignatureIndex,
+use super::{
+    address_map::FunctionAddressMap,
+    relocation::Relocation,
+    section::{CustomSection, SectionIndex},
+    unwind::{
+        ArchivedCompiledFunctionUnwindInfo, CompiledFunctionUnwindInfo,
+        CompiledFunctionUnwindInfoLike,
+    },
+};
+use rkyv::{
+    option::ArchivedOption, Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize,
 };
-use rkyv::option::ArchivedOption;
-use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
 #[cfg(feature = "enable-serde")]
 use serde::{Deserialize, Serialize};
-
-use super::unwind::CompiledFunctionUnwindInfoLike;
+use wasmer_types::{
+    entity::PrimaryMap, FunctionIndex, LocalFunctionIndex, SignatureIndex, TrapInformation,
+};
 
 /// The frame info for a Compiled function.
 ///
 /// This structure is only used for reconstructing
 /// the frame information after a `Trap`.
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[cfg_attr(feature = "enable-serde", derive(Deserialize, Serialize))]
 #[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, Clone, PartialEq, Eq, Default)]
-#[archive_attr(derive(rkyv::CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub struct CompiledFunctionFrameInfo {
     /// The traps (in the function body).
     ///
@@ -37,8 +47,9 @@ pub struct CompiledFunctionFrameInfo {
 
 /// The function body.
 #[cfg_attr(feature = "enable-serde", derive(Deserialize, Serialize))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, Clone, PartialEq, Eq)]
-#[archive_attr(derive(rkyv::CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub struct FunctionBody {
     /// The function body bytes.
     #[cfg_attr(feature = "enable-serde", serde(with = "serde_bytes"))]
@@ -54,7 +65,7 @@ pub trait FunctionBodyLike<'a> {
     type UnwindInfo: CompiledFunctionUnwindInfoLike<'a>;
 
     fn body(&'a self) -> &'a [u8];
-    fn unwind_info(&'a self) -> Option<&Self::UnwindInfo>;
+    fn unwind_info(&'a self) -> Option<&'a Self::UnwindInfo>;
 }
 
 impl<'a> FunctionBodyLike<'a> for FunctionBody {
@@ -64,7 +75,7 @@ impl<'a> FunctionBodyLike<'a> for FunctionBody {
         self.body.as_ref()
     }
 
-    fn unwind_info(&'a self) -> Option<&Self::UnwindInfo> {
+    fn unwind_info(&'a self) -> Option<&'a Self::UnwindInfo> {
         self.unwind_info.as_ref()
     }
 }
@@ -76,7 +87,7 @@ impl<'a> FunctionBodyLike<'a> for ArchivedFunctionBody {
         self.body.as_ref()
     }
 
-    fn unwind_info(&'a self) -> Option<&Self::UnwindInfo> {
+    fn unwind_info(&'a self) -> Option<&'a Self::UnwindInfo> {
         match self.unwind_info {
             ArchivedOption::Some(ref x) => Some(x),
             ArchivedOption::None => None,
@@ -91,7 +102,7 @@ impl<'a> FunctionBodyLike<'a> for ArchivedFunctionBody {
 /// and unwind information).
 #[cfg_attr(feature = "enable-serde", derive(Deserialize, Serialize))]
 #[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, Clone, PartialEq, Eq)]
-#[archive_attr(derive(rkyv::CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub struct CompiledFunction {
     /// The function body.
     pub body: FunctionBody,
@@ -109,31 +120,59 @@ pub type Functions = PrimaryMap<LocalFunctionIndex, CompiledFunction>;
 /// The custom sections for a Compilation.
 pub type CustomSections = PrimaryMap<SectionIndex, CustomSection>;
 
-/// The DWARF information for this Compilation.
+/// The unwinding information for this Compilation.
 ///
 /// It is used for retrieving the unwind information once an exception
 /// happens.
 /// In the future this structure may also hold other information useful
 /// for debugging.
 #[cfg_attr(feature = "enable-serde", derive(Deserialize, Serialize))]
-#[derive(
-    RkyvSerialize, RkyvDeserialize, Archive, rkyv::CheckBytes, Debug, PartialEq, Eq, Clone,
-)]
-#[archive(as = "Self")]
-pub struct Dwarf {
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, PartialEq, Eq, Clone, Default)]
+#[rkyv(derive(Debug), compare(PartialEq))]
+pub struct UnwindInfo {
     /// The section index in the [`Compilation`] that corresponds to the exception frames.
     /// [Learn
     /// more](https://refspecs.linuxfoundation.org/LSB_3.0.0/LSB-PDA/LSB-PDA/ehframechpt.html).
-    pub eh_frame: SectionIndex,
+    pub eh_frame: Option<SectionIndex>,
+    pub compact_unwind: Option<SectionIndex>,
 }
 
-impl Dwarf {
+impl UnwindInfo {
     /// Creates a `Dwarf` struct with the corresponding indices for its sections
     pub fn new(eh_frame: SectionIndex) -> Self {
-        Self { eh_frame }
+        Self {
+            eh_frame: Some(eh_frame),
+            compact_unwind: None,
+        }
+    }
+
+    pub fn new_cu(compact_unwind: SectionIndex) -> Self {
+        Self {
+            eh_frame: None,
+            compact_unwind: Some(compact_unwind),
+        }
     }
 }
 
+/// The GOT - Global Offset Table - for this Compilation.
+///
+/// The GOT is but a list of pointers to objects (functions, data, sections..); in our context the
+/// GOT is represented simply as a custom section.
+#[cfg_attr(feature = "enable-serde", derive(Deserialize, Serialize))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, PartialEq, Eq, Clone, Default)]
+#[rkyv(derive(Debug))]
+pub struct GOT {
+    /// The section index in the [`Compilation`] that corresponds to the GOT.
+    pub index: Option<SectionIndex>,
+}
+
+impl GOT {
+    pub fn empty() -> Self {
+        Self { index: None }
+    }
+}
 /// The result of compiling a WebAssembly module's functions.
 #[cfg_attr(feature = "enable-serde", derive(Deserialize, Serialize))]
 #[derive(Debug, PartialEq, Eq)]
@@ -178,6 +217,9 @@ pub struct Compilation {
     /// Note: Dynamic function trampolines are only compiled for imported function types.
     pub dynamic_function_trampolines: PrimaryMap<FunctionIndex, FunctionBody>,
 
-    /// Section ids corresponding to the Dwarf debug info
-    pub debug: Option<Dwarf>,
+    /// Section ids corresponding to the unwind information.
+    pub unwind_info: UnwindInfo,
+
+    /// A reference to the [`GOT`] instance for the compilation.
+    pub got: GOT,
 }
diff --git a/lib/types/src/compilation/mod.rs b/lib/compiler/src/types/mod.rs
similarity index 90%
rename from lib/types/src/compilation/mod.rs
rename to lib/compiler/src/types/mod.rs
index 624cd2de15..cbd531b359 100644
--- a/lib/types/src/compilation/mod.rs
+++ b/lib/compiler/src/types/mod.rs
@@ -6,5 +6,4 @@ pub mod module;
 pub mod relocation;
 pub mod section;
 pub mod symbols;
-pub mod target;
 pub mod unwind;
diff --git a/lib/types/src/compilation/module.rs b/lib/compiler/src/types/module.rs
similarity index 75%
rename from lib/types/src/compilation/module.rs
rename to lib/compiler/src/types/module.rs
index 43be092d27..5b0a851a14 100644
--- a/lib/types/src/compilation/module.rs
+++ b/lib/compiler/src/types/module.rs
@@ -1,10 +1,17 @@
+/*
+ * ! Remove me once rkyv generates doc-comments for fields or generates an #[allow(missing_docs)]
+ * on their own.
+ */
+#![allow(missing_docs)]
+
 //! Types for modules.
-use crate::entity::PrimaryMap;
-use crate::{Features, MemoryIndex, MemoryStyle, ModuleInfo, TableIndex, TableStyle};
 use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
 #[cfg(feature = "enable-serde")]
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
+use wasmer_types::{
+    entity::PrimaryMap, Features, MemoryIndex, MemoryStyle, ModuleInfo, TableIndex, TableStyle,
+};
 
 /// The required info for compiling a module.
 ///
@@ -12,8 +19,9 @@ use std::sync::Arc;
 /// possible after translation (such as the features used for compiling,
 /// or the `MemoryStyle` and `TableStyle`).
 #[cfg_attr(feature = "enable-serde", derive(Deserialize, Serialize))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[derive(Debug, Clone, PartialEq, Eq, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(rkyv::CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub struct CompileModuleInfo {
     /// The features used for compiling the module
     pub features: Features,
diff --git a/lib/compiler/src/types/relocation.rs b/lib/compiler/src/types/relocation.rs
new file mode 100644
index 0000000000..58272f7c14
--- /dev/null
+++ b/lib/compiler/src/types/relocation.rs
@@ -0,0 +1,459 @@
+/*
+ * ! Remove me once rkyv generates doc-comments for fields or generates an #[allow(missing_docs)]
+ * on their own.
+ */
+#![allow(missing_docs)]
+
+//! Relocation is the process of assigning load addresses for position-dependent
+//! code and data of a program and adjusting the code and data to reflect the
+//! assigned addresses.
+//!
+//! [Learn more](https://en.wikipedia.org/wiki/Relocation_(computing)).
+//!
+//! Each time a `Compiler` compiles a WebAssembly function (into machine code),
+//! it also attaches if there are any relocations that need to be patched into
+//! the generated machine code, so a given frontend (JIT or native) can
+//! do the corresponding work to run it.
+
+use super::section::SectionIndex;
+use crate::{Addend, CodeOffset};
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+use wasmer_types::{entity::PrimaryMap, lib::std::fmt, LibCall, LocalFunctionIndex};
+
+/// Relocation kinds for every ISA.
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive, Copy, Clone, Debug, PartialEq, Eq)]
+#[rkyv(derive(Debug), compare(PartialEq))]
+#[repr(u8)]
+pub enum RelocationKind {
+    /// absolute 4-byte
+    Abs4,
+    /// absolute 8-byte
+    Abs8,
+    /// x86 PC-relative 4-byte
+    X86PCRel4,
+    /// x86 PC-relative 8-byte
+    X86PCRel8,
+    /// x86 call to PC-relative 4-byte
+    X86CallPCRel4,
+    /// x86 call to PLT-relative 4-byte
+    X86CallPLTRel4,
+    /// x86 GOT PC-relative 4-byte
+    X86GOTPCRel4,
+
+    /// R_AARCH64_ADR_PREL_LO21
+    Aarch64AdrPrelLo21,
+
+    /// R_AARCH64_ADR_PREL_PG_HI21
+    Aarch64AdrPrelPgHi21,
+
+    /// R_AARCH64_ADD_ABS_LO12_NC
+    Aarch64AddAbsLo12Nc,
+
+    /// R_AARCH64_LDST128_ABS_LO12_NC
+    Aarch64Ldst128AbsLo12Nc,
+
+    /// R_AARCH64_LDST64_ABS_LO12_NC
+    Aarch64Ldst64AbsLo12Nc,
+
+    /// Arm32 call target
+    Arm32Call,
+    /// Arm64 call target
+    Arm64Call,
+    /// Arm64 movk/z part 0
+    Arm64Movw0,
+    /// Arm64 movk/z part 1
+    Arm64Movw1,
+    /// Arm64 movk/z part 2
+    Arm64Movw2,
+    /// Arm64 movk/z part 3
+    Arm64Movw3,
+    /// RISC-V PC-relative high 20bit
+    RiscvPCRelHi20,
+    /// RISC-V PC-relative low 12bit, I-type
+    RiscvPCRelLo12I,
+    /// RISC-V call target
+    RiscvCall,
+    /// LoongArch absolute high 20bit
+    LArchAbsHi20,
+    /// LoongArch absolute low 12bit
+    LArchAbsLo12,
+    /// LoongArch absolute high 12bit
+    LArchAbs64Hi12,
+    /// LoongArch absolute low 20bit
+    LArchAbs64Lo20,
+    /// LoongArch PC-relative call 38bit
+    LArchCall36,
+    /// LoongArch PC-relative high 20bit
+    LArchPCAlaHi20,
+    /// LoongArch PC-relative low 12bit
+    LArchPCAlaLo12,
+    /// LoongArch PC64-relative high 12bit
+    LArchPCAla64Hi12,
+    /// LoongArch PC64-relative low 20bit
+    LArchPCAla64Lo20,
+    /// Elf x86_64 32 bit signed PC relative offset to two GOT entries for GD symbol.
+    ElfX86_64TlsGd,
+    // /// Mach-O x86_64 32 bit signed PC relative offset to a `__thread_vars` entry.
+    // MachOX86_64Tlv,
+
+    // -- Mach-O-specific relocations
+    //
+    // --- Arm64
+    // (MACHO_ARM64_RELOC_UNSIGNED) for pointers
+    MachoArm64RelocUnsigned,
+    // (MACHO_ARM64_RELOC_SUBTRACTOR) must be followed by a ARM64_RELOC_UNSIGNED
+    MachoArm64RelocSubtractor,
+    // (MACHO_ARM64_RELOC_BRANCH26) a B/BL instruction with 26-bit displacement
+    MachoArm64RelocBranch26,
+    // (MACHO_ARM64_RELOC_PAGE21) pc-rel distance to page of target
+    MachoArm64RelocPage21,
+    // (MACHO_ARM64_RELOC_PAGEOFF12) offset within page, scaled by r_length
+    MachoArm64RelocPageoff12,
+    // (MACHO_ARM64_RELOC_GOT_LOAD_PAGE21) pc-rel distance to page of GOT slot
+    MachoArm64RelocGotLoadPage21,
+    // (MACHO_ARM64_RELOC_GOT_LOAD_PAGEOFF12) offset within page of GOT slot, scaled by r_length
+    MachoArm64RelocGotLoadPageoff12,
+    // (MACHO_ARM64_RELOC_POINTER_TO_GOT) for pointers to GOT slots
+    MachoArm64RelocPointerToGot,
+    // (MACHO_ARM64_RELOC_TLVP_LOAD_PAGE21) pc-rel distance to page of TLVP slot
+    MachoArm64RelocTlvpLoadPage21,
+    // (MACHO_ARM64_RELOC_TLVP_LOAD_PAGEOFF12) offset within page of TLVP slot, scaled by r_length
+    MachoArm64RelocTlvpLoadPageoff12,
+    // (MACHO_ARM64_RELOC_ADDEND) must be followed by PAGE21 or PAGEOFF12
+    MachoArm64RelocAddend,
+
+    // --- X86_64
+    // (MACHO_X86_64_RELOC_UNSIGNED) for absolute addresses
+    MachoX86_64RelocUnsigned,
+    // (MACHO_X86_64_RELOC_SIGNED) for signed 32-bit displacement
+    MachoX86_64RelocSigned,
+    // (MACHO_X86_64_RELOC_BRANCH) a CALL/JMP instruction with 32-bit displacement
+    MachoX86_64RelocBranch,
+    // (MACHO_X86_64_RELOC_GOT_LOAD) a MOVQ load of a GOT entry
+    MachoX86_64RelocGotLoad,
+    // (MACHO_X86_64_RELOC_GOT) other GOT references
+    MachoX86_64RelocGot,
+    // (MACHO_X86_64_RELOC_SUBTRACTOR) must be followed by a X86_64_RELOC_UNSIGNED
+    MachoX86_64RelocSubtractor,
+    // (MACHO_X86_64_RELOC_SIGNED_1) for signed 32-bit displacement with a -1 addend
+    MachoX86_64RelocSigned1,
+    // (MACHO_X86_64_RELOC_SIGNED_2) for signed 32-bit displacement with a -2 addend
+    MachoX86_64RelocSigned2,
+    // (MACHO_X86_64_RELOC_SIGNED_4) for signed 32-bit displacement with a -4 addend
+    MachoX86_64RelocSigned4,
+    // (MACHO_X86_64_RELOC_TLV) for thread local variables
+    MachoX86_64RelocTlv,
+}
+
+impl RelocationKind {
+    pub fn needs_got(&self) -> bool {
+        matches!(
+            self,
+            Self::MachoArm64RelocGotLoadPage21
+                | Self::MachoArm64RelocGotLoadPageoff12
+                | Self::MachoArm64RelocPointerToGot
+                | Self::MachoX86_64RelocGotLoad
+                | Self::MachoX86_64RelocGot
+        )
+    }
+}
+
+impl fmt::Display for RelocationKind {
+    /// Display trait implementation drops the arch, since its used in contexts where the arch is
+    /// already unambiguous, e.g. clif syntax with isa specified. In other contexts, use Debug.
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Self::Abs4 => write!(f, "Abs4"),
+            Self::Abs8 => write!(f, "Abs8"),
+            Self::X86PCRel4 => write!(f, "PCRel4"),
+            Self::X86PCRel8 => write!(f, "PCRel8"),
+            Self::X86CallPCRel4 => write!(f, "CallPCRel4"),
+            Self::X86CallPLTRel4 => write!(f, "CallPLTRel4"),
+            Self::X86GOTPCRel4 => write!(f, "GOTPCRel4"),
+            Self::Arm32Call | Self::Arm64Call | Self::RiscvCall => write!(f, "Call"),
+            Self::Arm64Movw0 => write!(f, "Arm64MovwG0"),
+            Self::Arm64Movw1 => write!(f, "Arm64MovwG1"),
+            Self::Arm64Movw2 => write!(f, "Arm64MovwG2"),
+            Self::Arm64Movw3 => write!(f, "Arm64MovwG3"),
+            Self::ElfX86_64TlsGd => write!(f, "ElfX86_64TlsGd"),
+            Self::RiscvPCRelHi20 => write!(f, "RiscvPCRelHi20"),
+            Self::RiscvPCRelLo12I => write!(f, "RiscvPCRelLo12I"),
+            Self::LArchAbsHi20 => write!(f, "LArchAbsHi20"),
+            Self::LArchAbsLo12 => write!(f, "LArchAbsLo12"),
+            Self::LArchAbs64Hi12 => write!(f, "LArchAbs64Hi12"),
+            Self::LArchAbs64Lo20 => write!(f, "LArchAbs64Lo20"),
+            Self::LArchCall36 => write!(f, "LArchCall36"),
+            Self::LArchPCAlaHi20 => write!(f, "LArchPCAlaHi20"),
+            Self::LArchPCAlaLo12 => write!(f, "LArchPCAlaLo12"),
+            Self::LArchPCAla64Hi12 => write!(f, "LArchPCAla64Hi12"),
+            Self::LArchPCAla64Lo20 => write!(f, "LArchPCAla64Lo20"),
+            Self::Aarch64AdrPrelLo21 => write!(f, "Aarch64AdrPrelLo21"),
+            Self::Aarch64AdrPrelPgHi21 => write!(f, "Aarch64AdrPrelPgHi21"),
+            Self::Aarch64AddAbsLo12Nc => write!(f, "Aarch64AddAbsLo12Nc"),
+            Self::Aarch64Ldst128AbsLo12Nc => write!(f, "Aarch64Ldst128AbsLo12Nc"),
+            Self::Aarch64Ldst64AbsLo12Nc => write!(f, "Aarch64Ldst64AbsLo12Nc"),
+            Self::MachoArm64RelocUnsigned => write!(f, "MachoArm64RelocUnsigned"),
+            Self::MachoArm64RelocSubtractor => write!(f, "MachoArm64RelocSubtractor"),
+            Self::MachoArm64RelocBranch26 => write!(f, "MachoArm64RelocBranch26"),
+            Self::MachoArm64RelocPage21 => write!(f, "MachoArm64RelocPage21"),
+            Self::MachoArm64RelocPageoff12 => write!(f, "MachoArm64RelocPageoff12"),
+            Self::MachoArm64RelocGotLoadPage21 => write!(f, "MachoArm64RelocGotLoadPage21"),
+            Self::MachoArm64RelocGotLoadPageoff12 => write!(f, "MachoArm64RelocGotLoadPageoff12"),
+            Self::MachoArm64RelocPointerToGot => write!(f, "MachoArm64RelocPointerToGot"),
+            Self::MachoArm64RelocTlvpLoadPage21 => write!(f, "MachoArm64RelocTlvpLoadPage21"),
+            Self::MachoArm64RelocTlvpLoadPageoff12 => write!(f, "MachoArm64RelocTlvpLoadPageoff12"),
+            Self::MachoArm64RelocAddend => write!(f, "MachoArm64RelocAddend"),
+            Self::MachoX86_64RelocUnsigned => write!(f, "MachoX86_64RelocUnsigned"),
+            Self::MachoX86_64RelocSigned => write!(f, "MachoX86_64RelocSigned"),
+            Self::MachoX86_64RelocBranch => write!(f, "MachoX86_64RelocBranch"),
+            Self::MachoX86_64RelocGotLoad => write!(f, "MachoX86_64RelocGotLoad"),
+            Self::MachoX86_64RelocGot => write!(f, "MachoX86_64RelocGot"),
+            Self::MachoX86_64RelocSubtractor => write!(f, "MachoX86_64RelocSubtractor"),
+            Self::MachoX86_64RelocSigned1 => write!(f, "MachoX86_64RelocSigned1"),
+            Self::MachoX86_64RelocSigned2 => write!(f, "MachoX86_64RelocSigned2"),
+            Self::MachoX86_64RelocSigned4 => write!(f, "MachoX86_64RelocSigned4"),
+            Self::MachoX86_64RelocTlv => write!(f, "MachoX86_64RelocTlv"),
+        }
+    }
+}
+
+/// A record of a relocation to perform.
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, Clone, PartialEq, Eq)]
+#[rkyv(derive(Debug), compare(PartialEq))]
+pub struct Relocation {
+    /// The relocation kind.
+    pub kind: RelocationKind,
+    /// Relocation target.
+    pub reloc_target: RelocationTarget,
+    /// The offset where to apply the relocation.
+    pub offset: CodeOffset,
+    /// The addend to add to the relocation value.
+    pub addend: Addend,
+}
+
+/// Any struct that acts like a `Relocation`.
+#[allow(missing_docs)]
+pub trait RelocationLike {
+    fn kind(&self) -> RelocationKind;
+    fn reloc_target(&self) -> RelocationTarget;
+    fn offset(&self) -> CodeOffset;
+    fn addend(&self) -> Addend;
+
+    /// Given a function start address, provide the relocation relative
+    /// to that address.
+    ///
+    /// The function returns the relocation address and the delta.
+    ///
+    // # Nomenclature (from [1]@5.7.3.3)
+    //
+    // * S (when used on its own) is the address of the symbol.
+    // * A is the addend for the relocation.
+    // * P is the address of the place being relocated (derived from r_offset).
+    // * X is the result of a relocation operation, before any masking or bit-selection operation is applied
+    // * Page(expr) is the page address of the expression expr, defined as (expr & ~0xFFF). (This applies even if the machine page size supported by the platform has a different value.)
+    //
+    // [1]: https://github.com/ARM-software/abi-aa/blob/main/aaelf64/aaelf64.rst
+    fn for_address(&self, start: usize, target_func_address: u64) -> (usize, u64) {
+        match self.kind() {
+            RelocationKind::Abs8
+            | RelocationKind::Arm64Movw0
+            | RelocationKind::Arm64Movw1
+            | RelocationKind::Arm64Movw2
+            | RelocationKind::Arm64Movw3
+            | RelocationKind::RiscvPCRelLo12I
+            | RelocationKind::Aarch64Ldst128AbsLo12Nc
+            | RelocationKind::Aarch64Ldst64AbsLo12Nc
+            | RelocationKind::MachoArm64RelocUnsigned
+            | RelocationKind::MachoX86_64RelocUnsigned
+            | RelocationKind::MachoArm64RelocSubtractor
+            | RelocationKind::MachoX86_64RelocSubtractor
+            | RelocationKind::LArchAbsHi20
+            | RelocationKind::LArchAbsLo12
+            | RelocationKind::LArchAbs64Lo20
+            | RelocationKind::LArchAbs64Hi12
+            | RelocationKind::LArchPCAlaLo12 => {
+                let reloc_address = start + self.offset() as usize;
+                let reloc_addend = self.addend() as isize;
+                let reloc_abs = target_func_address
+                    .checked_add(reloc_addend as u64)
+                    .unwrap();
+                (reloc_address, reloc_abs)
+            }
+            RelocationKind::X86PCRel4 => {
+                let reloc_address = start + self.offset() as usize;
+                let reloc_addend = self.addend() as isize;
+                let reloc_delta_u32 = (target_func_address as u32)
+                    .wrapping_sub(reloc_address as u32)
+                    .checked_add(reloc_addend as u32)
+                    .unwrap();
+                (reloc_address, reloc_delta_u32 as u64)
+            }
+            RelocationKind::X86PCRel8 => {
+                let reloc_address = start + self.offset() as usize;
+                let reloc_addend = self.addend() as isize;
+                let reloc_delta = target_func_address
+                    .wrapping_sub(reloc_address as u64)
+                    .checked_add(reloc_addend as u64)
+                    .unwrap();
+                (reloc_address, reloc_delta)
+            }
+            RelocationKind::X86CallPCRel4 | RelocationKind::X86CallPLTRel4 => {
+                let reloc_address = start + self.offset() as usize;
+                let reloc_addend = self.addend() as isize;
+                let reloc_delta_u32 = (target_func_address as u32)
+                    .wrapping_sub(reloc_address as u32)
+                    .wrapping_add(reloc_addend as u32);
+                (reloc_address, reloc_delta_u32 as u64)
+            }
+            RelocationKind::Aarch64AdrPrelLo21 => {
+                let s = target_func_address;
+                let p = start + self.offset() as usize;
+                let a = self.addend() as u64;
+
+                (p, s.wrapping_add(a).wrapping_sub(p as u64))
+            }
+
+            RelocationKind::Aarch64AddAbsLo12Nc => {
+                let s = target_func_address;
+                let p = start + self.offset() as usize;
+                let a = self.addend() as u64;
+
+                (p, s.wrapping_add(a))
+            }
+            RelocationKind::Arm64Call
+            | RelocationKind::RiscvCall
+            | RelocationKind::RiscvPCRelHi20 => {
+                let reloc_address = start + self.offset() as usize;
+                let reloc_addend = self.addend() as isize;
+                let reloc_delta_u32 = target_func_address
+                    .wrapping_sub(reloc_address as u64)
+                    .wrapping_add(reloc_addend as u64);
+                (reloc_address, reloc_delta_u32)
+            }
+            RelocationKind::Aarch64AdrPrelPgHi21
+            | RelocationKind::MachoArm64RelocGotLoadPage21
+            | RelocationKind::MachoArm64RelocPage21 => {
+                let reloc_address = start + self.offset() as usize;
+                let reloc_addend = self.addend() as isize;
+                let target_page =
+                    (target_func_address.wrapping_add(reloc_addend as u64) & !(0xFFF)) as usize;
+                let pc_page = reloc_address & !(0xFFF);
+                (reloc_address, target_page.wrapping_sub(pc_page) as u64)
+            }
+            RelocationKind::MachoArm64RelocGotLoadPageoff12
+            | RelocationKind::MachoArm64RelocPageoff12 => {
+                let reloc_address = start + self.offset() as usize;
+                let reloc_addend = self.addend() as isize;
+                let target_offset =
+                    (target_func_address.wrapping_add(reloc_addend as u64) & (0xFFF)) as usize;
+                (reloc_address, target_offset as u64)
+            }
+            RelocationKind::LArchCall36 => {
+                let reloc_address = start + self.offset() as usize;
+                let reloc_addend = self.addend() as isize;
+                let reloc_delta = target_func_address
+                    .wrapping_sub(reloc_address as u64)
+                    .wrapping_add(reloc_addend as u64);
+                (
+                    reloc_address,
+                    reloc_delta.wrapping_add((reloc_delta & 0x20000) << 1),
+                )
+            }
+            RelocationKind::LArchPCAlaHi20 => {
+                let reloc_address = start + self.offset() as usize;
+                let reloc_addend = self.addend() as isize;
+                let target_page = (target_func_address
+                    .wrapping_add(reloc_addend as u64)
+                    .wrapping_add(0x800)
+                    & !(0xFFF)) as usize;
+                let pc_page = reloc_address & !(0xFFF);
+                (reloc_address, target_page.wrapping_sub(pc_page) as u64)
+            }
+            RelocationKind::LArchPCAla64Hi12 | RelocationKind::LArchPCAla64Lo20 => {
+                let reloc_address = start + self.offset() as usize;
+                let reloc_addend = self.addend() as isize;
+                let reloc_offset = match self.kind() {
+                    RelocationKind::LArchPCAla64Lo20 => 8,
+                    RelocationKind::LArchPCAla64Hi12 => 12,
+                    _ => 0,
+                };
+                let target_func_address = target_func_address.wrapping_add(reloc_addend as u64);
+                let target_page = (target_func_address & !(0xFFF)) as usize;
+                let pc_page = (reloc_address - reloc_offset) & !(0xFFF);
+                let mut reloc_delta = target_page.wrapping_sub(pc_page) as u64;
+                reloc_delta = reloc_delta
+                    .wrapping_add((target_func_address & 0x800) << 1)
+                    .wrapping_sub((target_func_address & 0x800) << 21);
+                reloc_delta = reloc_delta.wrapping_add((reloc_delta & 0x80000000) << 1);
+                (reloc_address, reloc_delta)
+            }
+            RelocationKind::MachoArm64RelocPointerToGot => {
+                let reloc_address = start + self.offset() as usize;
+                let reloc_delta =
+                    (target_func_address as isize).wrapping_sub(reloc_address as isize);
+                (reloc_address, reloc_delta as u64)
+            }
+            _ => panic!("Relocation kind unsupported"),
+        }
+    }
+}
+
+impl RelocationLike for Relocation {
+    fn kind(&self) -> RelocationKind {
+        self.kind
+    }
+
+    fn reloc_target(&self) -> RelocationTarget {
+        self.reloc_target
+    }
+
+    fn offset(&self) -> CodeOffset {
+        self.offset
+    }
+
+    fn addend(&self) -> Addend {
+        self.addend
+    }
+}
+
+impl RelocationLike for ArchivedRelocation {
+    fn kind(&self) -> RelocationKind {
+        rkyv::deserialize::<_, String>(&self.kind).unwrap()
+    }
+
+    fn reloc_target(&self) -> RelocationTarget {
+        rkyv::deserialize::<_, String>(&self.reloc_target).unwrap()
+    }
+
+    fn offset(&self) -> CodeOffset {
+        self.offset.into()
+    }
+
+    fn addend(&self) -> Addend {
+        self.addend.into()
+    }
+}
+
+/// Destination function. Can be either user function or some special one, like `memory.grow`.
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[rkyv(derive(Debug, Hash, PartialEq, Eq), compare(PartialEq))]
+#[repr(u8)]
+pub enum RelocationTarget {
+    /// A relocation to a function defined locally in the wasm (not an imported one).
+    LocalFunc(LocalFunctionIndex),
+    /// A compiler-generated libcall.
+    LibCall(LibCall),
+    /// Custom sections generated by the compiler
+    CustomSection(SectionIndex),
+}
+
+/// Relocations to apply to function bodies.
+pub type Relocations = PrimaryMap<LocalFunctionIndex, Vec<Relocation>>;
diff --git a/lib/types/src/compilation/section.rs b/lib/compiler/src/types/section.rs
similarity index 70%
rename from lib/types/src/compilation/section.rs
rename to lib/compiler/src/types/section.rs
index 14d97f3460..941a6877dc 100644
--- a/lib/types/src/compilation/section.rs
+++ b/lib/compiler/src/types/section.rs
@@ -1,3 +1,9 @@
+/*
+ * ! Remove me once rkyv generates doc-comments for fields or generates an #[allow(missing_docs)]
+ * on their own.
+ */
+#![allow(missing_docs)]
+
 //! This module define the required structures to emit custom
 //! Sections in a `Compilation`.
 //!
@@ -6,18 +12,17 @@
 //! it can be patched later by the engine (native or JIT).
 
 use super::relocation::{ArchivedRelocation, Relocation, RelocationLike};
-use crate::entity::entity_impl;
 use crate::lib::std::vec::Vec;
 use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
 #[cfg(feature = "enable-serde")]
 use serde::{Deserialize, Serialize};
+use wasmer_types::entity_impl;
 
 /// Index type of a Section defined inside a WebAssembly `Compilation`.
 #[derive(
     RkyvSerialize,
     RkyvDeserialize,
     Archive,
-    rkyv::CheckBytes,
     Copy,
     Clone,
     PartialEq,
@@ -29,7 +34,8 @@ use serde::{Deserialize, Serialize};
     Default,
 )]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive(as = "Self")]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(derive(Debug, Hash, PartialEq, Eq), compare(PartialEq, PartialOrd))]
 pub struct SectionIndex(u32);
 
 entity_impl!(SectionIndex);
@@ -37,11 +43,10 @@ entity_impl!(SectionIndex);
 /// Custom section Protection.
 ///
 /// Determines how a custom section may be used.
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[derive(
-    RkyvSerialize, RkyvDeserialize, Archive, rkyv::CheckBytes, Debug, Clone, PartialEq, Eq,
-)]
-#[archive(as = "Self")]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, Clone, PartialEq, Eq)]
+#[rkyv(derive(Debug), compare(PartialEq, PartialOrd))]
 #[repr(u8)]
 pub enum CustomSectionProtection {
     /// A custom section with read permission.
@@ -56,12 +61,17 @@ pub enum CustomSectionProtection {
 /// This is used so compilers can store arbitrary information
 /// in the emitted module.
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, Clone, PartialEq, Eq)]
-#[archive_attr(derive(rkyv::CheckBytes, Debug))]
+#[rkyv(derive(Debug), compare(PartialEq))]
 pub struct CustomSection {
     /// Memory protection that applies to this section.
     pub protection: CustomSectionProtection,
 
+    /// Alignment of this section. When missing, the default value for
+    /// each platform shall be used.
+    pub alignment: Option<u64>,
+
     /// The bytes corresponding to this section.
     ///
     /// > Note: These bytes have to be at-least 8-byte aligned
@@ -79,23 +89,28 @@ pub struct CustomSection {
 pub trait CustomSectionLike<'a> {
     type Relocations: RelocationLike;
 
-    fn protection(&self) -> &CustomSectionProtection;
+    fn protection(&self) -> CustomSectionProtection;
+    fn alignment(&self) -> Option<u64>;
     fn bytes(&self) -> &[u8];
-    fn relocations(&'a self) -> &[Self::Relocations];
+    fn relocations(&'a self) -> &'a [Self::Relocations];
 }
 
 impl<'a> CustomSectionLike<'a> for CustomSection {
     type Relocations = Relocation;
 
-    fn protection(&self) -> &CustomSectionProtection {
-        &self.protection
+    fn protection(&self) -> CustomSectionProtection {
+        self.protection.clone()
+    }
+
+    fn alignment(&self) -> Option<u64> {
+        self.alignment
     }
 
     fn bytes(&self) -> &[u8] {
         self.bytes.0.as_ref()
     }
 
-    fn relocations(&'a self) -> &[Self::Relocations] {
+    fn relocations(&'a self) -> &'a [Self::Relocations] {
         self.relocations.as_slice()
     }
 }
@@ -103,23 +118,30 @@ impl<'a> CustomSectionLike<'a> for CustomSection {
 impl<'a> CustomSectionLike<'a> for ArchivedCustomSection {
     type Relocations = ArchivedRelocation;
 
-    fn protection(&self) -> &CustomSectionProtection {
-        &self.protection
+    fn protection(&self) -> CustomSectionProtection {
+        let protection = rkyv::deserialize::<CustomSectionProtection, ()>(&self.protection);
+        protection.unwrap()
+    }
+
+    fn alignment(&self) -> Option<u64> {
+        let alignment = rkyv::deserialize::<Option<u64>, ()>(&self.alignment);
+        alignment.unwrap()
     }
 
     fn bytes(&self) -> &[u8] {
         self.bytes.0.as_ref()
     }
 
-    fn relocations(&'a self) -> &[Self::Relocations] {
+    fn relocations(&'a self) -> &'a [Self::Relocations] {
         self.relocations.as_slice()
     }
 }
 
 /// The bytes in the section.
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, Clone, PartialEq, Eq, Default)]
-#[archive_attr(derive(rkyv::CheckBytes, Debug))]
+#[rkyv(derive(Debug), compare(PartialEq, PartialOrd))]
 pub struct SectionBody(#[cfg_attr(feature = "enable-serde", serde(with = "serde_bytes"))] Vec<u8>);
 
 impl SectionBody {
diff --git a/lib/types/src/compilation/symbols.rs b/lib/compiler/src/types/symbols.rs
similarity index 78%
rename from lib/types/src/compilation/symbols.rs
rename to lib/compiler/src/types/symbols.rs
index 239034159c..00a4366d4c 100644
--- a/lib/types/src/compilation/symbols.rs
+++ b/lib/compiler/src/types/symbols.rs
@@ -1,23 +1,27 @@
+/*
+ * ! Remove me once rkyv generates doc-comments for fields or generates an #[allow(missing_docs)]
+ * on their own.
+ */
+#![allow(missing_docs)]
+
 //! This module define the required structures for compilation symbols.
-use crate::{
-    entity::{EntityRef, PrimaryMap},
-    CompileModuleInfo, DeserializeError, FunctionIndex, LocalFunctionIndex, OwnedDataInitializer,
-    SectionIndex, SerializeError, SignatureIndex,
-};
-use rkyv::{
-    archived_value, check_archived_value, de::deserializers::SharedDeserializeMap,
-    ser::serializers::AllocSerializer, ser::Serializer as RkyvSerializer, Archive,
-    Deserialize as RkyvDeserialize, Serialize as RkyvSerialize,
-};
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
 #[cfg(feature = "enable-serde")]
 use serde::{Deserialize, Serialize};
+use wasmer_types::{
+    entity::{EntityRef, PrimaryMap},
+    DeserializeError, FunctionIndex, LocalFunctionIndex, OwnedDataInitializer, SerializeError,
+    SignatureIndex,
+};
+
+use super::{module::CompileModuleInfo, section::SectionIndex};
 
 /// The kinds of wasmer_types objects that might be found in a native object file.
 #[derive(
     RkyvSerialize, RkyvDeserialize, Archive, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug,
 )]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive(as = "Self")]
+#[rkyv(derive(Debug), compare(PartialEq, PartialOrd))]
 pub enum Symbol {
     /// A metadata section, indexed by a unique prefix
     /// (usually the wasm file SHA256 hash)
@@ -50,7 +54,7 @@ pub trait SymbolRegistry: Send + Sync {
 /// Serializable struct that represents the compiled metadata.
 #[derive(Debug, RkyvSerialize, RkyvDeserialize, Archive)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive_attr(derive(rkyv::CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub struct ModuleMetadata {
     /// Compile info
     pub compile_info: CompileModuleInfo,
@@ -90,13 +94,9 @@ impl ModuleMetadata {
     /// The bytes will have the following format:
     /// RKYV serialization (any length) + POS (8 bytes)
     pub fn serialize(&self) -> Result<Vec<u8>, SerializeError> {
-        let mut serializer = AllocSerializer::<4096>::default();
-        let pos = serializer
-            .serialize_value(self)
-            .map_err(|err| SerializeError::Generic(format!("{}", err)))? as u64;
-        let mut serialized_data = serializer.into_serializer().into_inner();
-        serialized_data.extend_from_slice(&pos.to_le_bytes());
-        Ok(serialized_data.to_vec())
+        rkyv::to_bytes::<rkyv::rancor::Error>(self)
+            .map(|v| v.into_vec())
+            .map_err(|e| SerializeError::Generic(e.to_string()))
     }
 
     /// Deserialize a Module from a slice.
@@ -130,18 +130,7 @@ impl ModuleMetadata {
     unsafe fn archive_from_slice(
         metadata_slice: &[u8],
     ) -> Result<&ArchivedModuleMetadata, DeserializeError> {
-        if metadata_slice.len() < 8 {
-            return Err(DeserializeError::Incompatible(
-                "invalid serialized ModuleMetadata".into(),
-            ));
-        }
-        let mut pos: [u8; 8] = Default::default();
-        pos.copy_from_slice(&metadata_slice[metadata_slice.len() - 8..metadata_slice.len()]);
-        let pos: u64 = u64::from_le_bytes(pos);
-        Ok(archived_value::<Self>(
-            &metadata_slice[..metadata_slice.len() - 8],
-            pos as usize,
-        ))
+        Ok(rkyv::access_unchecked(metadata_slice))
     }
 
     /// # Safety
@@ -151,15 +140,7 @@ impl ModuleMetadata {
     fn archive_from_slice_checked(
         metadata_slice: &[u8],
     ) -> Result<&ArchivedModuleMetadata, DeserializeError> {
-        if metadata_slice.len() < 8 {
-            return Err(DeserializeError::Incompatible(
-                "invalid serialized ModuleMetadata".into(),
-            ));
-        }
-        let mut pos: [u8; 8] = Default::default();
-        pos.copy_from_slice(&metadata_slice[metadata_slice.len() - 8..metadata_slice.len()]);
-        let pos: u64 = u64::from_le_bytes(pos);
-        check_archived_value::<Self>(&metadata_slice[..metadata_slice.len() - 8], pos as usize)
+        rkyv::access::<_, rkyv::rancor::Error>(metadata_slice)
             .map_err(|e| DeserializeError::CorruptedBinary(e.to_string()))
     }
 
@@ -167,9 +148,8 @@ impl ModuleMetadata {
     pub fn deserialize_from_archive(
         archived: &ArchivedModuleMetadata,
     ) -> Result<Self, DeserializeError> {
-        let mut deserializer = SharedDeserializeMap::new();
-        RkyvDeserialize::deserialize(archived, &mut deserializer)
-            .map_err(|e| DeserializeError::CorruptedBinary(format!("{:?}", e)))
+        rkyv::deserialize::<_, rkyv::rancor::Error>(archived)
+            .map_err(|e| DeserializeError::CorruptedBinary(format!("{e:?}")))
     }
 }
 
diff --git a/lib/types/src/compilation/unwind.rs b/lib/compiler/src/types/unwind.rs
similarity index 95%
rename from lib/types/src/compilation/unwind.rs
rename to lib/compiler/src/types/unwind.rs
index 0dae88d9cb..819a86ad7e 100644
--- a/lib/types/src/compilation/unwind.rs
+++ b/lib/compiler/src/types/unwind.rs
@@ -18,8 +18,9 @@ use serde::{Deserialize, Serialize};
 ///
 /// [unwind info]: https://docs.microsoft.com/en-us/cpp/build/exception-handling-x64?view=vs-2019
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, Clone, PartialEq, Eq)]
-#[archive_attr(derive(rkyv::CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub enum CompiledFunctionUnwindInfo {
     /// Windows UNWIND_INFO.
     WindowsX64(Vec<u8>),
@@ -34,6 +35,7 @@ pub enum CompiledFunctionUnwindInfo {
 pub enum CompiledFunctionUnwindInfoReference<'a> {
     WindowsX64(&'a [u8]),
     Dwarf,
+    CompactUnwind,
 }
 
 /// Any struct that acts like a `CompiledFunctionUnwindInfo`.
diff --git a/lib/config/Cargo.toml b/lib/config/Cargo.toml
index 6475abb967..445a0aed6f 100644
--- a/lib/config/Cargo.toml
+++ b/lib/config/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "wasmer-config"
-version = "0.8.0"
+version = "0.601.0"
 description = "Configuration types for Wasmer."
 edition.workspace = true
 license.workspace = true
@@ -13,22 +13,23 @@ categories = ["parser-implementations", "wasm"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-serde = { version = "1.0", features = ["derive"] }
-anyhow = "1"
-toml = "0.8"
-thiserror = "1"
-semver = { version = "1", features = ["serde"] }
-serde_json = "1"
+serde.workspace = true
+serde_json.workspace = true
 serde_yaml.workspace = true
+anyhow.workspace = true
+toml.workspace = true
+thiserror.workspace = true
+semver = { workspace = true, features = ["serde"] }
 indexmap = { workspace = true, features = ["serde"] }
 derive_builder = "0.12.0"
-bytesize = { version = "1.3.0", features = ["serde"] }
-schemars = { version = "0.8.16", features = ["url"] }
-url = { version = "2.5.0", features = ["serde"] }
-hex = "0.4.3"
-ciborium = "0.2.2"
+bytesize = { workspace = true, features = ["serde"] }
+schemars = { version = "0.8.16", features = ["url", "indexmap2"] }
+url = { workspace = true, features = ["serde"] }
+hex.workspace = true
+ciborium.workspace = true
+saffron = { version = "0.1.0", features = ["std"] }
 
 [dev-dependencies]
-pretty_assertions = "1.4.0"
-serde_json = "1.0.116"
-tempfile = "3.3.0"
+pretty_assertions.workspace = true
+serde_json.workspace = true
+tempfile.workspace = true
diff --git a/lib/config/rust-toolchain.toml b/lib/config/rust-toolchain.toml
deleted file mode 100644
index 0538cafabc..0000000000
--- a/lib/config/rust-toolchain.toml
+++ /dev/null
@@ -1,3 +0,0 @@
-[toolchain]
-channel = "1.70"
-components = ["rustfmt", "clippy"]
diff --git a/lib/config/src/app/http.rs b/lib/config/src/app/http.rs
index b3d9adc4b9..ad29b1ba9f 100644
--- a/lib/config/src/app/http.rs
+++ b/lib/config/src/app/http.rs
@@ -1,3 +1,5 @@
+use super::pretty_duration::PrettyDuration;
+
 /// Defines an HTTP request.
 #[derive(
     schemars::JsonSchema, serde::Serialize, serde::Deserialize, PartialEq, Eq, Clone, Debug,
@@ -24,7 +26,7 @@ pub struct HttpRequest {
     ///
     /// Format: 1s, 5m, 11h, ...
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub timeout: Option<String>,
+    pub timeout: Option<PrettyDuration>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     pub expect: Option<HttpRequestExpect>,
diff --git a/lib/config/src/app/job.rs b/lib/config/src/app/job.rs
new file mode 100644
index 0000000000..ea478d7b77
--- /dev/null
+++ b/lib/config/src/app/job.rs
@@ -0,0 +1,386 @@
+use std::{borrow::Cow, fmt::Display, str::FromStr};
+
+use anyhow::anyhow;
+use serde::{de::Error, Deserialize, Serialize};
+
+use indexmap::IndexMap;
+
+use crate::package::PackageSource;
+
+use super::{pretty_duration::PrettyDuration, AppConfigCapabilityMemoryV1, AppVolume, HttpRequest};
+
+/// Job configuration.
+#[derive(
+    serde::Serialize, serde::Deserialize, schemars::JsonSchema, Clone, Debug, PartialEq, Eq,
+)]
+pub struct Job {
+    name: String,
+    trigger: JobTrigger,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub timeout: Option<PrettyDuration>,
+
+    /// Don't start job if past the due time by this amount,
+    /// instead opting to wait for the next instance of it
+    /// to be triggered.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub max_schedule_drift: Option<PrettyDuration>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub retries: Option<u32>,
+
+    /// Maximum percent of "jitter" to introduce between invocations.
+    ///
+    /// Value range: 0-100
+    ///
+    /// Jitter is used to spread out jobs over time.
+    /// The calculation works by multiplying the time between invocations
+    /// by a random amount, and taking the percentage of that random amount.
+    ///
+    /// See also [`Self::jitter_percent_min`] to set a minimum jitter.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub jitter_percent_max: Option<u8>,
+
+    /// Minimum "jitter" to introduce between invocations.
+    ///
+    /// Value range: 0-100
+    ///
+    /// Jitter is used to spread out jobs over time.
+    /// The calculation works by multiplying the time between invocations
+    /// by a random amount, and taking the percentage of that random amount.
+    ///
+    /// If not specified while `jitter_percent_max` is, it will default to 10%.
+    ///
+    /// See also [`Self::jitter_percent_max`] to set a maximum jitter.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub jitter_percent_min: Option<u8>,
+
+    action: JobAction,
+
+    /// Additional unknown fields.
+    ///
+    /// Exists for forward compatibility for newly added fields.
+    #[serde(flatten)]
+    pub other: IndexMap<String, serde_json::Value>,
+}
+
+// We need this wrapper struct to enable this formatting:
+// job:
+//   action:
+//     execute: ...
+#[derive(
+    serde::Serialize, serde::Deserialize, schemars::JsonSchema, Clone, Debug, PartialEq, Eq,
+)]
+pub struct JobAction {
+    #[serde(flatten)]
+    action: JobActionCase,
+}
+
+#[derive(
+    serde::Serialize, serde::Deserialize, schemars::JsonSchema, Clone, Debug, PartialEq, Eq,
+)]
+#[serde(rename_all = "lowercase")]
+pub enum JobActionCase {
+    Fetch(HttpRequest),
+    Execute(ExecutableJob),
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CronExpression {
+    pub cron: saffron::parse::CronExpr,
+    // Keep the original string form around for serialization purposes.
+    pub parsed_from: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum JobTrigger {
+    PreDeployment,
+    PostDeployment,
+    Cron(CronExpression),
+    Duration(PrettyDuration),
+}
+
+#[derive(
+    serde::Serialize, serde::Deserialize, schemars::JsonSchema, Clone, Debug, PartialEq, Eq,
+)]
+pub struct ExecutableJob {
+    /// The package that contains the command to run. Defaults to the app config's package.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    package: Option<PackageSource>,
+
+    /// The command to run. Defaults to the package's entrypoint.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    command: Option<String>,
+
+    /// CLI arguments passed to the runner.
+    /// Only applicable for runners that accept CLI arguments.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    cli_args: Option<Vec<String>>,
+
+    /// Environment variables.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub env: Option<IndexMap<String, String>>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub capabilities: Option<ExecutableJobCompatibilityMapV1>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub volumes: Option<Vec<AppVolume>>,
+}
+
+#[derive(
+    serde::Serialize, serde::Deserialize, schemars::JsonSchema, Clone, Debug, PartialEq, Eq,
+)]
+pub struct ExecutableJobCompatibilityMapV1 {
+    /// Instance memory settings.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub memory: Option<AppConfigCapabilityMemoryV1>,
+
+    /// Additional unknown capabilities.
+    ///
+    /// This provides a small bit of forwards compatibility for newly added
+    /// capabilities.
+    #[serde(flatten)]
+    pub other: IndexMap<String, serde_json::Value>,
+}
+
+impl Serialize for JobTrigger {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        self.to_string().serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for JobTrigger {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let repr: Cow<'de, str> = Cow::deserialize(deserializer)?;
+        repr.parse().map_err(D::Error::custom)
+    }
+}
+
+impl Display for JobTrigger {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::PreDeployment => write!(f, "pre-deployment"),
+            Self::PostDeployment => write!(f, "post-deployment"),
+            Self::Cron(cron) => write!(f, "{}", cron.parsed_from),
+            Self::Duration(duration) => write!(f, "{duration}"),
+        }
+    }
+}
+
+impl FromStr for JobTrigger {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if s == "pre-deployment" {
+            Ok(Self::PreDeployment)
+        } else if s == "post-deployment" {
+            Ok(Self::PostDeployment)
+        } else if let Ok(expr) = s.parse::<CronExpression>() {
+            Ok(Self::Cron(expr))
+        } else if let Ok(duration) = s.parse::<PrettyDuration>() {
+            Ok(Self::Duration(duration))
+        } else {
+            Err(anyhow!(
+                "Invalid job trigger '{s}'. Must be 'pre-deployment', 'post-deployment', \
+                a valid cron expression such as '0 */5 * * *' or a duration such as '15m'.",
+            ))
+        }
+    }
+}
+
+impl FromStr for CronExpression {
+    type Err = Box<dyn std::error::Error + Send + Sync>;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if let Some(predefined_sched) = s.strip_prefix('@') {
+            match predefined_sched {
+                "hourly" => Ok(Self {
+                    cron: "0 * * * *".parse().unwrap(),
+                    parsed_from: s.to_owned(),
+                }),
+                "daily" => Ok(Self {
+                    cron: "0 0 * * *".parse().unwrap(),
+                    parsed_from: s.to_owned(),
+                }),
+                "weekly" => Ok(Self {
+                    cron: "0 0 * * 1".parse().unwrap(),
+                    parsed_from: s.to_owned(),
+                }),
+                "monthly" => Ok(Self {
+                    cron: "0 0 1 * *".parse().unwrap(),
+                    parsed_from: s.to_owned(),
+                }),
+                "yearly" => Ok(Self {
+                    cron: "0 0 1 1 *".parse().unwrap(),
+                    parsed_from: s.to_owned(),
+                }),
+                _ => Err(format!("Invalid cron expression {s}").into()),
+            }
+        } else {
+            // Let's make sure the input string is valid...
+            match s.parse() {
+                Ok(expr) => Ok(Self {
+                    cron: expr,
+                    parsed_from: s.to_owned(),
+                }),
+                Err(_) => Err(format!("Invalid cron expression {s}").into()),
+            }
+        }
+    }
+}
+
+impl schemars::JsonSchema for JobTrigger {
+    fn schema_name() -> String {
+        "JobTrigger".to_owned()
+    }
+
+    fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+        String::json_schema(gen)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::time::Duration;
+
+    use super::*;
+
+    #[test]
+    pub fn job_trigger_serialization_roundtrip() {
+        fn assert_roundtrip(
+            serialized: &str,
+            description: Option<&str>,
+            duration: Option<Duration>,
+        ) {
+            let parsed = serialized.parse::<JobTrigger>().unwrap();
+            assert_eq!(&parsed.to_string(), serialized);
+
+            if let JobTrigger::Cron(expr) = &parsed {
+                assert_eq!(
+                    &expr
+                        .cron
+                        .describe(saffron::parse::English::default())
+                        .to_string(),
+                    description.unwrap()
+                );
+            } else {
+                assert!(description.is_none());
+            }
+
+            if let JobTrigger::Duration(d) = &parsed {
+                assert_eq!(d.as_duration(), duration.unwrap());
+            } else {
+                assert!(duration.is_none());
+            }
+        }
+
+        assert_roundtrip("pre-deployment", None, None);
+        assert_roundtrip("post-deployment", None, None);
+
+        assert_roundtrip("@hourly", Some("Every hour"), None);
+        assert_roundtrip("@daily", Some("At 12:00 AM"), None);
+        assert_roundtrip("@weekly", Some("At 12:00 AM on Sunday"), None);
+        assert_roundtrip(
+            "@monthly",
+            Some("At 12:00 AM on the 1st of every month"),
+            None,
+        );
+        assert_roundtrip("@yearly", Some("At 12:00 AM on the 1st of January"), None);
+
+        // Note: the parsing code should keep the formatting of the source string.
+        // This is tested in assert_roundtrip.
+        assert_roundtrip(
+            "0/2 12 * JAN-APR 2",
+            Some(
+                "At every 2nd minute from 0 through 59 minutes past the hour, \
+                between 12:00 PM and 12:59 PM on Monday of January to April",
+            ),
+            None,
+        );
+
+        assert_roundtrip("10s", None, Some(Duration::from_secs(10)));
+        assert_roundtrip("15m", None, Some(Duration::from_secs(15 * 60)));
+        assert_roundtrip("20h", None, Some(Duration::from_secs(20 * 60 * 60)));
+        assert_roundtrip("2d", None, Some(Duration::from_secs(2 * 60 * 60 * 24)));
+    }
+
+    #[test]
+    pub fn job_serialization_roundtrip() {
+        fn parse_cron(expr: &str) -> CronExpression {
+            CronExpression {
+                cron: expr.parse().unwrap(),
+                parsed_from: expr.to_owned(),
+            }
+        }
+
+        let job = Job {
+            name: "my-job".to_owned(),
+            trigger: JobTrigger::Cron(parse_cron("0/2 12 * JAN-APR 2")),
+            timeout: Some("1m".parse().unwrap()),
+            max_schedule_drift: Some("2h".parse().unwrap()),
+            jitter_percent_max: None,
+            jitter_percent_min: None,
+            retries: None,
+            action: JobAction {
+                action: JobActionCase::Execute(super::ExecutableJob {
+                    package: Some(crate::package::PackageSource::Ident(
+                        crate::package::PackageIdent::Named(crate::package::NamedPackageIdent {
+                            registry: None,
+                            namespace: Some("ns".to_owned()),
+                            name: "pkg".to_owned(),
+                            tag: None,
+                        }),
+                    )),
+                    command: Some("cmd".to_owned()),
+                    cli_args: Some(vec!["arg-1".to_owned(), "arg-2".to_owned()]),
+                    env: Some([("VAR1".to_owned(), "Value".to_owned())].into()),
+                    capabilities: Some(super::ExecutableJobCompatibilityMapV1 {
+                        memory: Some(crate::app::AppConfigCapabilityMemoryV1 {
+                            limit: Some(bytesize::ByteSize::gb(1)),
+                        }),
+                        other: Default::default(),
+                    }),
+                    volumes: Some(vec![crate::app::AppVolume {
+                        name: "vol".to_owned(),
+                        mount: "/path/to/volume".to_owned(),
+                    }]),
+                }),
+            },
+            other: Default::default(),
+        };
+
+        let serialized = r#"
+name: my-job
+trigger: 0/2 12 * JAN-APR 2
+timeout: 1m
+max_schedule_drift: 2h
+action:
+  execute:
+    package: ns/pkg
+    command: cmd
+    cli_args:
+    - arg-1
+    - arg-2
+    env:
+      VAR1: Value
+    capabilities:
+      memory:
+        limit: 1000.0 MB
+    volumes:
+    - name: vol
+      mount: /path/to/volume"#;
+
+        assert_eq!(
+            serialized.trim(),
+            serde_yaml::to_string(&job).unwrap().trim()
+        );
+        assert_eq!(job, serde_yaml::from_str(serialized).unwrap());
+    }
+}
diff --git a/lib/config/src/app/mod.rs b/lib/config/src/app/mod.rs
index a4e8d93a61..714cbf95b6 100644
--- a/lib/config/src/app/mod.rs
+++ b/lib/config/src/app/mod.rs
@@ -2,16 +2,16 @@
 
 mod healthcheck;
 mod http;
+mod job;
+mod pretty_duration;
+mod snapshot_trigger;
+mod ssh;
 
-pub use self::{
-    healthcheck::{HealthCheckHttpV1, HealthCheckV1},
-    http::HttpRequest,
-};
-
-use std::collections::HashMap;
+pub use self::{healthcheck::*, http::*, job::*, pretty_duration::*, snapshot_trigger::*, ssh::*};
 
 use anyhow::{bail, Context};
 use bytesize::ByteSize;
+use indexmap::IndexMap;
 
 use crate::package::PackageSource;
 
@@ -32,7 +32,7 @@ pub const HEADER_APP_VERSION_ID: &str = "x-edge-app-version-id";
 )]
 pub struct AppConfigV1 {
     /// Name of the app.
-    pub name: String,
+    pub name: Option<String>,
 
     /// App id assigned by the backend.
     ///
@@ -65,8 +65,8 @@ pub struct AppConfigV1 {
     pub locality: Option<Locality>,
 
     /// Environment variables.
-    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
-    pub env: HashMap<String, String>,
+    #[serde(default, skip_serializing_if = "IndexMap::is_empty")]
+    pub env: IndexMap<String, String>,
 
     // CLI arguments passed to the runner.
     /// Only applicable for runners that accept CLI arguments.
@@ -95,9 +95,12 @@ pub struct AppConfigV1 {
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub redirect: Option<Redirect>,
 
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub jobs: Option<Vec<Job>>,
+
     /// Capture extra fields for forwards compatibility.
     #[serde(flatten)]
-    pub extra: HashMap<String, serde_json::Value>,
+    pub extra: IndexMap<String, serde_json::Value>,
 }
 
 #[derive(
@@ -196,16 +199,23 @@ pub struct AppConfigCapabilityMapV1 {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub memory: Option<AppConfigCapabilityMemoryV1>,
 
+    /// Runtime settings.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub runtime: Option<AppConfigCapabilityRuntimeV1>,
+
     /// Enables app bootstrapping with startup snapshots.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub instaboot: Option<AppConfigCapabilityInstaBootV1>,
 
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ssh: Option<CapabilitySshServerV1>,
+
     /// Additional unknown capabilities.
     ///
     /// This provides a small bit of forwards compatibility for newly added
     /// capabilities.
     #[serde(flatten)]
-    pub other: HashMap<String, serde_json::Value>,
+    pub other: IndexMap<String, serde_json::Value>,
 }
 
 /// Memory capability settings.
@@ -225,6 +235,19 @@ pub struct AppConfigCapabilityMemoryV1 {
     pub limit: Option<ByteSize>,
 }
 
+/// Runtime capability settings.
+#[derive(
+    serde::Serialize, serde::Deserialize, schemars::JsonSchema, Clone, Debug, PartialEq, Eq,
+)]
+pub struct AppConfigCapabilityRuntimeV1 {
+    /// Engine to use for an instance, e.g. wasmer_cranelift, wasmer_llvm, etc.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub engine: Option<String>,
+    /// Whether to enable asynchronous threads/deep sleeping.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub async_threads: Option<bool>,
+}
+
 /// Enables accelerated instance boot times with startup snapshots.
 ///
 /// How it works:
@@ -240,6 +263,10 @@ pub struct AppConfigCapabilityMemoryV1 {
     serde::Serialize, serde::Deserialize, schemars::JsonSchema, Clone, Debug, PartialEq, Eq,
 )]
 pub struct AppConfigCapabilityInstaBootV1 {
+    /// The method to use to generate the instaboot snapshot for the instance.
+    #[serde(default)]
+    pub mode: Option<InstabootSnapshotModeV1>,
+
     /// HTTP requests to perform during startup snapshot creation.
     /// Apps can perform all the appropriate warmup logic in these requests.
     ///
@@ -255,7 +282,34 @@ pub struct AppConfigCapabilityInstaBootV1 {
     /// After the specified time new snapshots will be created, and the old
     /// ones discarded.
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub max_age: Option<String>,
+    pub max_age: Option<PrettyDuration>,
+}
+
+/// How will an instance be bootstrapped?
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    PartialEq,
+    Eq,
+    Hash,
+    Clone,
+    Debug,
+    schemars::JsonSchema,
+    Default,
+)]
+#[serde(rename_all = "snake_case")]
+pub enum InstabootSnapshotModeV1 {
+    /// Start the instance without any snapshot triggers. Once the requests are done,
+    /// use [`snapshot_and_stop`](wasmer_wasix::WasiProcess::snapshot_and_stop) to
+    /// capture a snapshot and shut the instance down.
+    #[default]
+    Bootstrap,
+
+    /// Explicitly enable the given snapshot triggers before starting the instance.
+    /// The instance's process will have its stop_running_after_checkpoint flag set,
+    /// so the first snapshot will cause the instance to shut down.
+    // FIXME: make this strongly typed
+    Triggers(Vec<SnapshotTrigger>),
 }
 
 /// App redirect configuration.
@@ -310,7 +364,7 @@ scheduled_tasks:
         assert_eq!(
             parsed,
             AppConfigV1 {
-                name: "test".to_string(),
+                name: Some("test".to_string()),
                 app_id: None,
                 package: "ns/name@0.1.0".parse().unwrap(),
                 owner: None,
@@ -341,7 +395,8 @@ scheduled_tasks:
                 }),
                 locality: Some(Locality {
                     regions: vec!["eu-rome".to_string()]
-                })
+                }),
+                jobs: None,
             }
         );
     }
@@ -374,10 +429,7 @@ volumes:
         if let Some(actual_volumes) = parsed.volumes {
             assert_eq!(actual_volumes, expected_volumes);
         } else {
-            panic!(
-                "Parsed volumes are None, expected Some({:?})",
-                expected_volumes
-            );
+            panic!("Parsed volumes are None, expected Some({expected_volumes:?})");
         }
     }
 }
diff --git a/lib/config/src/app/pretty_duration.rs b/lib/config/src/app/pretty_duration.rs
new file mode 100644
index 0000000000..fcbeaf6bed
--- /dev/null
+++ b/lib/config/src/app/pretty_duration.rs
@@ -0,0 +1,195 @@
+use std::{
+    borrow::Cow,
+    fmt::{Debug, Display},
+    str::FromStr,
+    time::Duration,
+};
+
+use schemars::JsonSchema;
+use serde::{de::Error, Deserialize, Serialize};
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+pub struct PrettyDuration {
+    unit: DurationUnit,
+    amount: u64,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+pub enum DurationUnit {
+    Seconds,
+    Minutes,
+    Hours,
+    Days,
+}
+
+impl PrettyDuration {
+    pub fn as_duration(&self) -> Duration {
+        match self.unit {
+            DurationUnit::Seconds => Duration::from_secs(self.amount),
+            DurationUnit::Minutes => Duration::from_secs(self.amount * 60),
+            DurationUnit::Hours => Duration::from_secs(self.amount * 60 * 60),
+            DurationUnit::Days => Duration::from_secs(self.amount * 60 * 60 * 24),
+        }
+    }
+}
+
+impl Default for PrettyDuration {
+    fn default() -> Self {
+        Self {
+            unit: DurationUnit::Seconds,
+            amount: 0,
+        }
+    }
+}
+
+impl PartialOrd for PrettyDuration {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for PrettyDuration {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.as_duration().cmp(&other.as_duration())
+    }
+}
+
+impl JsonSchema for PrettyDuration {
+    fn schema_name() -> String {
+        "PrettyDuration".to_owned()
+    }
+
+    fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+        String::json_schema(gen)
+    }
+}
+
+impl Display for DurationUnit {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            DurationUnit::Seconds => write!(f, "s"),
+            DurationUnit::Minutes => write!(f, "m"),
+            DurationUnit::Hours => write!(f, "h"),
+            DurationUnit::Days => write!(f, "d"),
+        }
+    }
+}
+
+impl FromStr for DurationUnit {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "s" | "S" => Ok(Self::Seconds),
+            "m" | "M" => Ok(Self::Minutes),
+            "h" | "H" => Ok(Self::Hours),
+            "d" | "D" => Ok(Self::Days),
+            _ => Err(()),
+        }
+    }
+}
+
+impl Display for PrettyDuration {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}{}", self.amount, self.unit)
+    }
+}
+
+impl Debug for PrettyDuration {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        <Self as Display>::fmt(self, f)
+    }
+}
+
+impl FromStr for PrettyDuration {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let (amount_str, unit_str) = s.split_at_checked(s.len() - 1).ok_or(())?;
+        Ok(Self {
+            unit: unit_str.parse()?,
+            amount: amount_str.parse().map_err(|_| ())?,
+        })
+    }
+}
+
+impl Serialize for PrettyDuration {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(&self.to_string())
+    }
+}
+
+impl<'de> Deserialize<'de> for PrettyDuration {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let repr: Cow<'de, str> = Cow::deserialize(deserializer)?;
+        repr.parse()
+            .map_err(|()| D::Error::custom("Failed to parse value as a duration"))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    pub fn pretty_duration_serialize() {
+        assert_eq!(
+            PrettyDuration {
+                unit: DurationUnit::Seconds,
+                amount: 1234
+            }
+            .to_string(),
+            "1234s"
+        );
+        assert_eq!(
+            PrettyDuration {
+                unit: DurationUnit::Minutes,
+                amount: 345
+            }
+            .to_string(),
+            "345m"
+        );
+        assert_eq!(
+            PrettyDuration {
+                unit: DurationUnit::Hours,
+                amount: 56
+            }
+            .to_string(),
+            "56h"
+        );
+        assert_eq!(
+            PrettyDuration {
+                unit: DurationUnit::Days,
+                amount: 7
+            }
+            .to_string(),
+            "7d"
+        );
+    }
+
+    #[test]
+    pub fn pretty_duration_deserialize() {
+        fn assert_deserializes_to(repr1: &str, repr2: &str, unit: DurationUnit, amount: u64) {
+            let duration = PrettyDuration { unit, amount };
+            assert_eq!(duration, repr1.parse().unwrap());
+            assert_eq!(duration, repr2.parse().unwrap());
+        }
+
+        assert_deserializes_to("12s", "12S", DurationUnit::Seconds, 12);
+        assert_deserializes_to("34m", "34M", DurationUnit::Minutes, 34);
+        assert_deserializes_to("56h", "56H", DurationUnit::Hours, 56);
+        assert_deserializes_to("7d", "7D", DurationUnit::Days, 7);
+    }
+
+    #[test]
+    #[should_panic]
+    pub fn cant_parse_nagative_duration() {
+        _ = "-12s".parse::<PrettyDuration>().unwrap();
+    }
+}
diff --git a/lib/config/src/app/snapshot_trigger.rs b/lib/config/src/app/snapshot_trigger.rs
new file mode 100644
index 0000000000..9759ffa0b7
--- /dev/null
+++ b/lib/config/src/app/snapshot_trigger.rs
@@ -0,0 +1,117 @@
+use std::{fmt::Display, str::FromStr};
+
+use schemars::JsonSchema;
+use serde::{de::Error, Deserialize, Serialize};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum SnapshotTrigger {
+    /// Triggered when all the threads in the process goes idle
+    Idle,
+    /// Triggered when a listen syscall is invoked on a socket for the first time
+    FirstListen,
+    /// Triggered on reading the environment variables for the first time
+    FirstEnviron,
+    /// Triggered when the process reads stdin for the first time
+    FirstStdin,
+    /// Issued on the first interrupt signal (Ctrl + C) the process receives, after that normal CTRL-C will apply.
+    FirstSigint,
+    /// Triggered periodically based on a interval (default 10 seconds) which can be specified using the `snapshot-interval` option
+    PeriodicInterval,
+    /// Issued if the user sends an interrupt signal (Ctrl + C).
+    Sigint,
+    /// Alarm clock signal (used for timers)
+    Sigalrm,
+    /// The SIGTSTP signal is sent to a process by its controlling terminal to request it to stop temporarily. It is commonly initiated by the user pressing Ctrl-Z.
+    Sigtstp,
+    /// The SIGSTOP signal instructs the operating system to stop a process for later resumption.
+    Sigstop,
+    /// When a non-determinstic call is made
+    NonDeterministicCall,
+    /// Bootstrapping process
+    Bootstrap,
+    /// Transaction
+    Transaction,
+    /// Explicitly requested by the guest module
+    Explicit,
+}
+
+impl SnapshotTrigger {
+    pub fn to_str(&self) -> &'static str {
+        match self {
+            Self::Bootstrap => "bootstrap",
+            Self::Explicit => "explicit",
+            Self::FirstEnviron => "first-environ",
+            Self::FirstListen => "first-listen",
+            Self::FirstSigint => "first-sigint",
+            Self::FirstStdin => "first-stdin",
+            Self::Idle => "idle",
+            Self::NonDeterministicCall => "non-deterministic-call",
+            Self::PeriodicInterval => "periodic-interval",
+            Self::Sigalrm => "sigalrm",
+            Self::Sigint => "sigint",
+            Self::Sigtstp => "sigtstp",
+            Self::Sigstop => "sigstop",
+            Self::Transaction => "transaction",
+        }
+    }
+}
+
+impl FromStr for SnapshotTrigger {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        let s = s.trim().to_lowercase();
+        Ok(match s.as_str() {
+            "idle" => Self::Idle,
+            "first-listen" => Self::FirstListen,
+            "first-stdin" => Self::FirstStdin,
+            "first-environ" => Self::FirstEnviron,
+            "first-intr" | "first-sigint" | "first-ctrlc" | "first-ctrl-c" => Self::FirstSigint,
+            "periodic-interval" => Self::PeriodicInterval,
+            "intr" | "sigint" | "ctrlc" | "ctrl-c" => Self::Sigint,
+            "alarm" | "timer" | "sigalrm" => Self::Sigalrm,
+            "sigtstp" | "ctrlz" | "ctrl-z" => Self::Sigtstp,
+            "stop" | "sigstop" => Self::Sigstop,
+            "non-deterministic-call" => Self::NonDeterministicCall,
+            "bootstrap" => Self::Bootstrap,
+            "transaction" => Self::Transaction,
+            "explicit" => Self::Explicit,
+            a => return Err(anyhow::format_err!("invalid or unknown trigger ({a})")),
+        })
+    }
+}
+
+impl Display for SnapshotTrigger {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.to_str())
+    }
+}
+
+impl Serialize for SnapshotTrigger {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(self.to_str())
+    }
+}
+
+impl<'de> Deserialize<'de> for SnapshotTrigger {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        <&str as Deserialize>::deserialize(deserializer)
+            .and_then(|s| s.parse::<SnapshotTrigger>().map_err(D::Error::custom))
+    }
+}
+
+impl JsonSchema for SnapshotTrigger {
+    fn schema_name() -> String {
+        "SnapshotTrigger".to_owned()
+    }
+
+    fn json_schema(generator: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+        <String as JsonSchema>::json_schema(generator)
+    }
+}
diff --git a/lib/config/src/app/ssh.rs b/lib/config/src/app/ssh.rs
new file mode 100644
index 0000000000..5f639ce96d
--- /dev/null
+++ b/lib/config/src/app/ssh.rs
@@ -0,0 +1,47 @@
+use indexmap::IndexMap;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+/// Configure SSH server credentials and settings.
+#[derive(Serialize, Deserialize, JsonSchema, Clone, Debug, PartialEq, Eq)]
+pub struct CapabilitySshServerV1 {
+    /// Enable an SSH server.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<bool>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub users: Option<Vec<SshUserV1>>,
+
+    /// Additional unknown fields.
+    /// This provides a small bit of forwards compatibility.
+    #[serde(flatten)]
+    pub other: IndexMap<String, serde_json::Value>,
+}
+
+#[derive(Serialize, Deserialize, JsonSchema, PartialEq, Eq, Clone, Debug)]
+pub struct SshUserV1 {
+    /// The username used for SSH login.
+    pub username: String,
+
+    /// Passwords for this user.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub passwords: Option<Vec<PasswordV1>>,
+
+    /// SSH public keys for this user.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub authorized_keys: Option<Vec<String>>,
+
+    /// Additional unknown fields.
+    /// This provides a small bit of forwards compatibility.
+    #[serde(flatten)]
+    pub other: IndexMap<String, serde_json::Value>,
+}
+
+#[derive(Serialize, Deserialize, JsonSchema, PartialEq, Eq, Clone, Debug)]
+#[serde(rename_all = "snake_case", tag = "type")]
+pub enum PasswordV1 {
+    /// Plain text password.
+    Plain { password: String },
+    /// Bcrypt password hash.
+    Bcrypt { hash: String },
+}
diff --git a/lib/config/src/bin/generate-core-schemas.rs b/lib/config/src/bin/generate-core-schemas.rs
index b2af49b402..0fe8e4aad3 100644
--- a/lib/config/src/bin/generate-core-schemas.rs
+++ b/lib/config/src/bin/generate-core-schemas.rs
@@ -5,7 +5,9 @@ fn main() {
 }
 
 mod codegen {
-    use std::{collections::HashMap, path::Path};
+    use indexmap::IndexMap;
+
+    use std::path::Path;
 
     pub fn generate_schemas() {
         eprintln!("Generating schemas...");
@@ -37,10 +39,10 @@ mod codegen {
     }
 
     /// Returns a map of filename to serialized JSON schema.
-    fn build_jsonschema_map() -> HashMap<String, String> {
-        let mut map = HashMap::new();
+    fn build_jsonschema_map() -> IndexMap<String, String> {
+        let mut map = IndexMap::new();
 
-        fn add_schema<T: schemars::JsonSchema>(map: &mut HashMap<String, String>, name: &str) {
+        fn add_schema<T: schemars::JsonSchema>(map: &mut IndexMap<String, String>, name: &str) {
             let gen =
                 schemars::gen::SchemaGenerator::new(schemars::gen::SchemaSettings::draft2019_09());
             map.insert(
diff --git a/lib/config/src/cargo_annotations.rs b/lib/config/src/cargo_annotations.rs
index 33b4b3e59b..6e4ad8aed3 100644
--- a/lib/config/src/cargo_annotations.rs
+++ b/lib/config/src/cargo_annotations.rs
@@ -1,6 +1,8 @@
 //! Rust and cargo specific annotations used to interoperate with external tools.
 
-use std::{collections::HashMap, path::PathBuf};
+use std::path::PathBuf;
+
+use indexmap::IndexMap;
 
 use crate::package::{Abi, Bindings};
 
@@ -20,7 +22,7 @@ pub struct CargoWasmerPackageAnnotation {
     pub abi: Abi,
     /// Filesystem mappings.
     #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub fs: Option<HashMap<String, PathBuf>>,
+    pub fs: Option<IndexMap<String, PathBuf>>,
     /// Binding declarations for the crate.
     pub bindings: Option<Bindings>,
 }
diff --git a/lib/config/src/package/mod.rs b/lib/config/src/package/mod.rs
index 9f3ce2e743..3345de0d76 100644
--- a/lib/config/src/package/mod.rs
+++ b/lib/config/src/package/mod.rs
@@ -22,7 +22,7 @@ pub use self::{
 
 use std::{
     borrow::Cow,
-    collections::{hash_map::HashMap, BTreeMap, BTreeSet},
+    collections::{BTreeMap, BTreeSet},
     fmt::{self, Display},
     path::{Path, PathBuf},
     str::FromStr,
@@ -40,8 +40,6 @@ use thiserror::Error;
 #[derive(Clone, Copy, Default, Debug, Deserialize, Serialize, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum Abi {
-    #[serde(rename = "emscripten")]
-    Emscripten,
     #[default]
     #[serde(rename = "none")]
     None,
@@ -55,7 +53,6 @@ impl Abi {
     /// Get the ABI's human-friendly name.
     pub fn to_str(&self) -> &str {
         match self {
-            Abi::Emscripten => "emscripten",
             Abi::Wasi => "wasi",
             Abi::WASM4 => "wasm4",
             Abi::None => "generic",
@@ -84,7 +81,6 @@ impl FromStr for Abi {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s.to_lowercase().as_str() {
-            "emscripten" => Ok(Abi::Emscripten),
             "wasi" => Ok(Abi::Wasi),
             "wasm4" => Ok(Abi::WASM4),
             "generic" => Ok(Abi::None),
@@ -185,6 +181,10 @@ pub struct Package {
 }
 
 impl Package {
+    pub fn new_empty() -> Self {
+        PackageBuilder::default().build().unwrap()
+    }
+
     /// Create a [`PackageBuilder`] populated with all mandatory fields.
     pub fn builder(
         name: impl Into<String>,
@@ -254,8 +254,7 @@ pub struct CommandV2 {
     pub module: ModuleReference,
     /// The runner to use when running this command.
     ///
-    /// This may be a URL, or the well-known runners `wasi`, `wcgi`, or
-    /// `emscripten`.
+    /// This may be a URL, or the well-known runners `wasi` or `wcgi`
     pub runner: String,
     /// Extra annotations that will be consumed by the runner.
     pub annotations: Option<CommandAnnotations>,
@@ -386,7 +385,7 @@ fn toml_to_cbor_value(val: &toml::Value) -> ciborium::Value {
         toml::Value::Integer(i) => ciborium::Value::Integer(ciborium::value::Integer::from(*i)),
         toml::Value::Float(f) => ciborium::Value::Float(*f),
         toml::Value::Boolean(b) => ciborium::Value::Bool(*b),
-        toml::Value::Datetime(d) => ciborium::Value::Text(format!("{}", d)),
+        toml::Value::Datetime(d) => ciborium::Value::Text(format!("{d}")),
         toml::Value::Array(sq) => {
             ciborium::Value::Array(sq.iter().map(toml_to_cbor_value).collect())
         }
@@ -500,10 +499,30 @@ pub struct Module {
     pub kind: Option<String>,
     /// WebAssembly interfaces this module requires.
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub interfaces: Option<HashMap<String, String>>,
+    pub interfaces: Option<IndexMap<String, String>>,
     /// Interface definitions that can be used to generate bindings to this
     /// module.
     pub bindings: Option<Bindings>,
+    /// Miscellaneous annotations from the user.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub annotations: Option<UserAnnotations>,
+}
+
+/// Miscellaneous annotations specified by the user.
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize, Default)]
+pub struct UserAnnotations {
+    pub suggested_compiler_optimizations: SuggestedCompilerOptimizations,
+}
+
+/// Suggested optimization that might be operated on the module when (and if) compiled.
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize, Default)]
+pub struct SuggestedCompilerOptimizations {
+    pub pass_params: Option<bool>,
+}
+
+impl SuggestedCompilerOptimizations {
+    pub const KEY: &'static str = "suggested_compiler_optimizations";
+    pub const PASS_PARAMS_KEY: &'static str = "pass_params";
 }
 
 /// The interface exposed by a [`Module`].
@@ -713,9 +732,9 @@ pub struct Manifest {
     /// Metadata about the package itself.
     pub package: Option<Package>,
     /// The package's dependencies.
-    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
+    #[serde(default, skip_serializing_if = "IndexMap::is_empty")]
     #[builder(default)]
-    pub dependencies: HashMap<String, VersionReq>,
+    pub dependencies: IndexMap<String, VersionReq>,
     /// The mappings used when making bundled assets available to WebAssembly
     /// instances, in the form guest -> host.
     #[serde(default, skip_serializing_if = "IndexMap::is_empty")]
@@ -732,6 +751,16 @@ pub struct Manifest {
 }
 
 impl Manifest {
+    pub fn new_empty() -> Self {
+        Self {
+            package: None,
+            dependencies: IndexMap::new(),
+            fs: IndexMap::new(),
+            modules: Vec::new(),
+            commands: Vec::new(),
+        }
+    }
+
     /// Create a [`ManifestBuilder`] populated with all mandatory fields.
     pub fn builder(package: Package) -> ManifestBuilder {
         ManifestBuilder::new(package)
@@ -901,7 +930,7 @@ impl ManifestBuilder {
     /// Add a dependency to the [`Manifest`].
     pub fn with_dependency(&mut self, name: impl Into<String>, version: VersionReq) -> &mut Self {
         self.dependencies
-            .get_or_insert_with(HashMap::new)
+            .get_or_insert_with(IndexMap::new)
             .insert(name.into(), version);
         self
     }
@@ -938,7 +967,7 @@ pub enum ManifestError {
 #[non_exhaustive]
 pub enum ValidationError {
     #[error(
-        "missing ABI field on module, \"{module}\", used by command, \"{command}\"; an ABI of `wasi` or `emscripten` is required",
+        "missing ABI field on module, \"{module}\", used by command, \"{command}\"; an ABI of `wasi` is required",
     )]
     MissingABI { command: String, module: String },
     #[error("missing module, \"{module}\", in manifest used by command, \"{command}\"")]
@@ -990,7 +1019,7 @@ mod tests {
                 entrypoint: None,
                 private: false,
             }),
-            dependencies: HashMap::new(),
+            dependencies: IndexMap::new(),
             modules: vec![Module {
                 name: "test".to_string(),
                 abi: Abi::Wasi,
@@ -998,6 +1027,7 @@ mod tests {
                 interfaces: None,
                 kind: Some("https://webc.org/kind/wasi".to_string()),
                 source: Path::new("test.wasm").to_path_buf(),
+                annotations: None,
             }],
             commands: Vec::new(),
             fs: vec![
@@ -1022,12 +1052,12 @@ license = "MIT"
 
 [[module]]
 name = "mod"
-source = "target/wasm32-wasi/release/mod.wasm"
+source = "target/wasm32-wasip1/release/mod.wasm"
 interfaces = {"wasi" = "0.0.0-unstable"}
 
 [[module]]
 name = "mod-with-exports"
-source = "target/wasm32-wasi/release/mod-with-exports.wasm"
+source = "target/wasm32-wasip1/release/mod-with-exports.wasm"
 bindings = { wit-exports = "exports.wit", wit-bindgen = "0.0.0" }
 
 [[command]]
@@ -1045,7 +1075,7 @@ module = "mod"
             modules[1],
             Module {
                 name: "mod-with-exports".to_string(),
-                source: PathBuf::from("target/wasm32-wasi/release/mod-with-exports.wasm"),
+                source: PathBuf::from("target/wasm32-wasip1/release/mod-with-exports.wasm"),
                 abi: Abi::None,
                 kind: None,
                 interfaces: None,
@@ -1053,6 +1083,7 @@ module = "mod"
                     wit_exports: PathBuf::from("exports.wit"),
                     wit_bindgen: "0.0.0".parse().unwrap()
                 })),
+                annotations: None
             },
         );
     }
diff --git a/lib/config/src/package/named_package_ident.rs b/lib/config/src/package/named_package_ident.rs
index d1c9fa6e2d..9c43476047 100644
--- a/lib/config/src/package/named_package_ident.rs
+++ b/lib/config/src/package/named_package_ident.rs
@@ -121,7 +121,7 @@ impl NamedPackageIdent {
         };
 
         let reg = if !reg.starts_with("http://") && !reg.starts_with("https://") {
-            format!("https://{}", reg)
+            format!("https://{reg}")
         } else {
             reg.clone()
         };
@@ -144,7 +144,7 @@ impl NamedPackageIdent {
         if let Some(tag) = &self.tag {
             ident.push('@');
             // Writing to a string only fails on memory allocation errors.
-            write!(&mut ident, "{}", tag).unwrap();
+            write!(&mut ident, "{tag}").unwrap();
         }
         ident
     }
@@ -153,7 +153,7 @@ impl NamedPackageIdent {
         let mut out = String::new();
         if let Some(url) = &self.registry {
             // NOTE: writing to a String can only fail on allocation errors.
-            write!(&mut out, "{}", url).unwrap();
+            write!(&mut out, "{url}").unwrap();
 
             if !out.ends_with('/') {
                 out.push(':');
@@ -167,11 +167,29 @@ impl NamedPackageIdent {
         if let Some(tag) = &self.tag {
             out.push('@');
             // Writing to a string only fails on memory allocation errors.
-            write!(&mut out, "{}", tag).unwrap();
+            write!(&mut out, "{tag}").unwrap();
         }
 
         out
     }
+
+    /// Returns true if this ident matches the given package id.
+    ///
+    /// Semver constraints are matched against the package id's version.
+    pub fn matches_id(&self, id: &NamedPackageId) -> bool {
+        if self.full_name() == id.full_name {
+            if let Some(tag) = &self.tag {
+                match tag {
+                    Tag::Named(n) => n == &id.version.to_string(),
+                    Tag::VersionReq(v) => v.matches(&id.version),
+                }
+            } else {
+                true
+            }
+        } else {
+            false
+        }
+    }
 }
 
 impl From<NamedPackageId> for NamedPackageIdent {
@@ -443,4 +461,23 @@ mod tests {
         let ident2 = serde_json::from_str::<NamedPackageIdent>(&raw).unwrap();
         assert_eq!(ident, ident2);
     }
+
+    #[test]
+    fn test_named_package_ident_matches_id() {
+        assert!(NamedPackageIdent::from_str("ns/name")
+            .unwrap()
+            .matches_id(&NamedPackageId::try_new("ns/name", "0.1.0").unwrap()));
+
+        assert!(NamedPackageIdent::from_str("ns/name")
+            .unwrap()
+            .matches_id(&NamedPackageId::try_new("ns/name", "1.0.1").unwrap()));
+
+        assert!(NamedPackageIdent::from_str("ns/name@1")
+            .unwrap()
+            .matches_id(&NamedPackageId::try_new("ns/name", "1.0.1").unwrap()));
+
+        assert!(!NamedPackageIdent::from_str("ns/name@2")
+            .unwrap()
+            .matches_id(&NamedPackageId::try_new("ns/name", "1.0.1").unwrap()));
+    }
 }
diff --git a/lib/config/src/package/package_hash.rs b/lib/config/src/package/package_hash.rs
index 9e9e1e1931..2bd6442183 100644
--- a/lib/config/src/package/package_hash.rs
+++ b/lib/config/src/package/package_hash.rs
@@ -32,7 +32,7 @@ impl From<Sha256Hash> for PackageHash {
 impl std::fmt::Display for PackageHash {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::Sha256(hash) => write!(f, "sha256:{}", hash),
+            Self::Sha256(hash) => write!(f, "sha256:{hash}"),
         }
     }
 }
diff --git a/lib/config/src/package/package_ident.rs b/lib/config/src/package/package_ident.rs
index 5b03d6ef81..0e6a5544a7 100644
--- a/lib/config/src/package/package_ident.rs
+++ b/lib/config/src/package/package_ident.rs
@@ -1,6 +1,6 @@
 use std::str::FromStr;
 
-use super::{NamedPackageIdent, PackageHash, PackageParseError};
+use super::{NamedPackageIdent, PackageHash, PackageId, PackageParseError};
 
 #[derive(PartialEq, Eq, Clone, Debug, Hash)]
 pub enum PackageIdent {
@@ -24,6 +24,17 @@ impl PackageIdent {
             None
         }
     }
+
+    /// Returns true if this ident matches the given package id.
+    ///
+    /// Semver constraints are matched against the package id's version.
+    pub fn matches_id(&self, id: &PackageId) -> bool {
+        match (self, id) {
+            (Self::Named(a), PackageId::Named(b)) => a.matches_id(b),
+            (Self::Hash(a), PackageId::Hash(b)) => a == b,
+            _ => false,
+        }
+    }
 }
 
 impl From<NamedPackageIdent> for PackageIdent {
@@ -92,3 +103,23 @@ impl schemars::JsonSchema for PackageIdent {
         String::json_schema(gen)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_package_ident_matches_id() {
+        assert!(PackageIdent::from_str("ns/pkg")
+            .unwrap()
+            .matches_id(&PackageId::new_named("ns/pkg", "1.0.0".parse().unwrap())));
+
+        assert!(PackageIdent::from_str("ns/pkg@2")
+            .unwrap()
+            .matches_id(&PackageId::new_named("ns/pkg", "2.3.7".parse().unwrap())));
+
+        assert!(!PackageIdent::from_str("ns/pkg@3")
+            .unwrap()
+            .matches_id(&PackageId::new_named("ns/pkg", "2.3.7".parse().unwrap())));
+    }
+}
diff --git a/lib/derive/Cargo.toml b/lib/derive/Cargo.toml
index 7576910511..57f873fa98 100644
--- a/lib/derive/Cargo.toml
+++ b/lib/derive/Cargo.toml
@@ -16,8 +16,10 @@ proc-macro = true
 syn = { version = "1.0.72", features = ["full", "extra-traits"] }
 quote = "1"
 proc-macro2 = "1"
-proc-macro-error = "1.0.0"
+proc-macro-error2 = "2.0.1"
 
 [dev-dependencies]
-wasmer-types = { path = "../types", default-features=false, features = ["std"] }
+wasmer-types = { path = "../types", default-features = false, features = [
+	"std",
+] }
 compiletest_rs = "0.6"
diff --git a/lib/derive/src/lib.rs b/lib/derive/src/lib.rs
index fe781efff8..6ec42cc237 100644
--- a/lib/derive/src/lib.rs
+++ b/lib/derive/src/lib.rs
@@ -1,6 +1,6 @@
 extern crate proc_macro;
 
-use proc_macro_error::proc_macro_error;
+use proc_macro_error2::proc_macro_error;
 use syn::{parse_macro_input, DeriveInput};
 
 mod value_type;
diff --git a/lib/derive/src/value_type.rs b/lib/derive/src/value_type.rs
index 3ba535e5d3..3d3c2c7693 100644
--- a/lib/derive/src/value_type.rs
+++ b/lib/derive/src/value_type.rs
@@ -1,5 +1,5 @@
 use proc_macro2::TokenStream;
-use proc_macro_error::abort;
+use proc_macro_error2::abort;
 use quote::quote;
 use syn::{Data, DeriveInput, Fields, Member, Meta, MetaList, NestedMeta};
 
diff --git a/lib/derive/tests/compiletest.rs b/lib/derive/tests/compiletest.rs
index 7cda93820a..771bdfe884 100644
--- a/lib/derive/tests/compiletest.rs
+++ b/lib/derive/tests/compiletest.rs
@@ -20,7 +20,7 @@ fn run_mode(src: &'static str, mode: &'static str) {
     let mut config = ct::Config {
         mode: mode.parse().expect("invalid mode"),
         target_rustcflags: Some("-L ../../target/debug/deps".to_owned()),
-        src_base: format!("tests/{}", src).into(),
+        src_base: format!("tests/{src}").into(),
         ..Default::default()
     };
 
diff --git a/lib/emscripten/Cargo.toml b/lib/emscripten/Cargo.toml
deleted file mode 100644
index 8500c5ab60..0000000000
--- a/lib/emscripten/Cargo.toml
+++ /dev/null
@@ -1,29 +0,0 @@
-[package]
-name = "wasmer-emscripten"
-description = "Emscripten implementation library for Wasmer WebAssembly runtime"
-categories = ["wasm", "os"]
-keywords = ["wasm", "webassembly", "abi", "emscripten", "posix"]
-readme = "README.md"
-authors.workspace = true
-edition.workspace = true
-homepage.workspace = true
-license.workspace = true
-repository.workspace = true
-rust-version.workspace = true
-version.workspace = true
-
-[dependencies]
-byteorder = "1.3"
-lazy_static = "1.4"
-libc = { workspace = true, default-features = true }
-log = "0.4"
-time = { version = "0.3", features = ["std", "formatting"] }
-wasmer = { path = "../api", version = "=4.3.7", default-features = false }
-wasmer-types = { path = "../types", version = "=4.3.7" }
-
-[target.'cfg(windows)'.dependencies]
-getrandom = "0.2"
-
-[package.metadata.docs.rs]
-features = ["wasmer/sys"]
-rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/emscripten/README.md b/lib/emscripten/README.md
deleted file mode 100644
index 057112e850..0000000000
--- a/lib/emscripten/README.md
+++ /dev/null
@@ -1,5 +0,0 @@
-# `wasmer-emscripten` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE)
-
-This crate provides the necessary imports to use [Emscripten] WebAssembly generated files easily from Wasmer.
-
-[Emscripten]: https://emscripten.org/
diff --git a/lib/emscripten/src/README.md b/lib/emscripten/src/README.md
deleted file mode 100644
index 801a0f55e8..0000000000
--- a/lib/emscripten/src/README.md
+++ /dev/null
@@ -1,544 +0,0 @@
-## HOST APIS
-
-#### EMSCRIPTEN APIS
-
-###### PROCESS
-
-- **\_abort** ✅ &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-  fn _abort()
-  ```
-- **abort** ✅ 🔥 &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-  fn abort(ctx: &mut Ctx, message: u32, )
-  ```
-- **abort_on_cannot_grow_memory** ✅ &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-  fn abort_on_cannot_grow_memory()
-  ```
-
-###### TIMING
-
-- **\_clock_gettime** &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-
-###### ENVIRONMENT
-
-- **\_getenv** ✅ &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-  fn _getenv(ctx: &mut Ctx, name: c_int, )
-  ```
-- **\_putenv** ✅ &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-  fn _putenv(ctx: &mut Ctx, name: c_int, )
-  ```
-- **\_setenv** ✅ &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-  fn _setenv(name: c_int, value: c_int, overwrite: c_int, instance: &mut Instance
-  ```
-- **\_unsetenv** ✅ &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-  fn _unsetenv(ctx: &mut Ctx, name: c_int, )
-  ```
-
-###### THREAD
-
-- **\_pthread_getspecific** &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **\_pthread_key_create** &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **\_pthread_rwlock_destroy** &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **\_pthread_rwlock_init** &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **\_pthread_rwlock_wrlock** &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **\_pthread_setspecific** &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **\_\_\_lock** &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **\_\_\_unlock** &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-
-###### MEMORY
-
-- **\_emscripten_memcpy_big** ✅ 🔥 &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-  fn _emscripten_memcpy_big(ctx: &mut Ctx, dest: u32, src: u32, len: u32, ) -> u32
-  ```
-- **enlarge_memory** ✅ &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-  fn enlarge_memory()
-  ```
-- **get_total_memory** ✅ &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-  fn get_total_memory(ctx: &mut Ctx, ) -> u32
-  ```
-
-###### TIMING
-
-- **\_clock_gettime** &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-
-###### STATUS
-
-- **\_\_\_set_err_no** &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-
----
-
-#### EMSCRIPTEN SYSCALLS
-
-- **access** (\_\_\_syscall33) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **acct** (\_\_\_syscall51) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **chdir** (\_\_\_syscall12) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **chmod** (\_\_\_syscall15) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **chown** (\_\_\_syscall212) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **clock_nanosleep** (\_\_\_syscall265) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **close** (\_\_\_syscall6) ✅ ❗️ &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-  fn close(fd: c_int) -> c_int
-  ```
-- **dup** (\_\_\_syscall330) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **dup** (\_\_\_syscall41) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **dup2** (\_\_\_syscall63) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **exit** (\_\_\_syscall1) ✅ &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-  fn exit(status: c_int)
-  ```
-- **faccessat** (\_\_\_syscall307) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **fadvise** (\_\_\_syscall272) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **fallocate** (\_\_\_syscall324) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **fchdir** (\_\_\_syscall133) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **fchmod** (\_\_\_syscall94) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **fchmodat** (\_\_\_syscall306) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **fchown** (\_\_\_syscall207) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **fchownat** (\_\_\_syscall298) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **fcntl** (\_\_\_syscall221) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **fdatasync** (\_\_\_syscall148) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **fstat** (\_\_\_syscall197) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **fstatat** (\_\_\_syscall300) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **fstatfs** (\_\_\_syscall269) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **fsync** (\_\_\_syscall118) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **ftruncate** (\_\_\_syscall194) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **futimesat** (\_\_\_syscall299) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **getcwd** (\_\_\_syscall183) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **getdents** (\_\_\_syscall220) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **getgid** (\_\_\_syscall202) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **getgroups** (\_\_\_syscall205) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **getpgid** (\_\_\_syscall132) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **getpgrp** (\_\_\_syscall65) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **getpid** (\_\_\_syscall20) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **getppid** (\_\_\_syscall64) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **getpriority** (\_\_\_syscall96) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **getresgid** (\_\_\_syscall211) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **getrusage** (\_\_\_syscall77) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **getsid** (\_\_\_syscall147) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **ioctl** (\_\_\_syscall54) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **lchown** (\_\_\_syscall198) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **link** (\_\_\_syscall9) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **linkat** (\_\_\_syscall303) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **llseek** (\_\_\_syscall140) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **lstat** (\_\_\_syscall196) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **madvise** (\_\_\_syscall219) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **mincore** (\_\_\_syscall218) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **mkdir** (\_\_\_syscall39) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **mkdirat** (\_\_\_syscall296) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **mknod** (\_\_\_syscall14) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **mknodat** (\_\_\_syscall297) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **mmap** (\_\_\_syscall192) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **mprotect** (\_\_\_syscall125) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **mremap** (\_\_\_syscall163) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **msync** (\_\_\_syscall144) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **munlockall** (\_\_\_syscall153) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **munmap** (\_\_\_syscall91) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **newselect** (\_\_\_syscall142) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **nice** (\_\_\_syscall34) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **open** (\_\_\_syscall5) ✅ ❗️ 🔥 &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-  fn open(ctx: &mut Ctx, path: u32, flags: c_int, mode: c_int, ) -> c_int
-  ```
-- **openat** (\_\_\_syscall295) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **pause** (\_\_\_syscall29) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **pipe** (\_\_\_syscall331) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **pipe** (\_\_\_syscall42) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **poll** (\_\_\_syscall168) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **pread** (\_\_\_syscall180) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **preadv** (\_\_\_syscall333) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **prlimit** (\_\_\_syscall340) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **pselect** (\_\_\_syscall308) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **pwrite** (\_\_\_syscall181) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **pwritev** (\_\_\_syscall334) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **read** (\_\_\_syscall3) ✅ ❗️ &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-  fn read(ctx: &mut Ctx, fd: c_int, buf: u32, count: size_t, ) -> ssize_t
-  ```
-- **readlink** (\_\_\_syscall85) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **readlinkat** (\_\_\_syscall305) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **readv** (\_\_\_syscall145) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **recvmmsg** (\_\_\_syscall337) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **rename** (\_\_\_syscall38) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **renameat** (\_\_\_syscall302) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **rmdir** (\_\_\_syscall40) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **rt_sigqueueinfo** (\_\_\_syscall178) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **sendmmsg** (\_\_\_syscall345) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **setdomainname** (\_\_\_syscall121) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **setgid** (\_\_\_syscall214) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **setitimer** (\_\_\_syscall104) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **setpgid** (\_\_\_syscall57) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **setpriority** (\_\_\_syscall97) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **setresgid** (\_\_\_syscall210) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **setrlimit** (\_\_\_syscall75) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **setsid** (\_\_\_syscall66) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **socketcall** (\_\_\_syscall102) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **stat** (\_\_\_syscall195) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **statfs** (\_\_\_syscall268) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **symlink** (\_\_\_syscall83) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **symlinkat** (\_\_\_syscall304) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **sync** (\_\_\_syscall36) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **truncate** (\_\_\_syscall193) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **ugetrlimit** (\_\_\_syscall191) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **umask** (\_\_\_syscall60) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **uname** (\_\_\_syscall122) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **unlink** (\_\_\_syscall10) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **unlinkat** (\_\_\_syscall301) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **utimensat** (\_\_\_syscall320) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **wait** (\_\_\_syscall114) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **write** (\_\_\_syscall4) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-- **writev** (\_\_\_syscall146) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-  ```rust
-
-  ```
-
-### LEGEND &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
-✅ - Implemented
-
-❗️ - Elevated privilege
-
-🔥 - Possible memory access violation
-
-📥 - Access to external memory
-
-📝 - External write to internal memory
diff --git a/lib/emscripten/src/bitwise.rs b/lib/emscripten/src/bitwise.rs
deleted file mode 100644
index d912fda7da..0000000000
--- a/lib/emscripten/src/bitwise.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-use crate::emscripten_target;
-use crate::EmEnv;
-use wasmer::FunctionEnvMut;
-
-///emscripten: _llvm_bswap_i64
-pub fn _llvm_bswap_i64(ctx: FunctionEnvMut<EmEnv>, _low: i32, high: i32) -> i32 {
-    debug!("emscripten::_llvm_bswap_i64");
-    emscripten_target::setTempRet0(ctx, _low.swap_bytes());
-    high.swap_bytes()
-}
diff --git a/lib/emscripten/src/emscripten_target.rs b/lib/emscripten/src/emscripten_target.rs
deleted file mode 100644
index 736313d638..0000000000
--- a/lib/emscripten/src/emscripten_target.rs
+++ /dev/null
@@ -1,1015 +0,0 @@
-#![allow(non_snake_case)]
-
-use crate::env::{get_emscripten_data, get_emscripten_funcs};
-use crate::EmEnv;
-#[cfg(target_os = "linux")]
-use libc::getdtablesize;
-use wasmer::FunctionEnvMut;
-
-pub fn asm_const_i(_ctx: FunctionEnvMut<EmEnv>, _val: i32) -> i32 {
-    debug!("emscripten::asm_const_i: {}", _val);
-    0
-}
-
-pub fn exit_with_live_runtime(_ctx: FunctionEnvMut<EmEnv>) {
-    debug!("emscripten::exit_with_live_runtime");
-}
-
-pub fn setTempRet0(ctx: FunctionEnvMut<EmEnv>, val: i32) {
-    trace!("emscripten::setTempRet0: {}", val);
-    get_emscripten_data(&ctx).as_mut().unwrap().temp_ret_0 = val;
-}
-
-pub fn getTempRet0(ctx: FunctionEnvMut<EmEnv>) -> i32 {
-    trace!("emscripten::getTempRet0");
-    get_emscripten_data(&ctx).as_ref().unwrap().temp_ret_0
-}
-
-pub fn _alarm(_ctx: FunctionEnvMut<EmEnv>, _seconds: u32) -> i32 {
-    debug!("emscripten::_alarm({})", _seconds);
-    0
-}
-
-pub fn _atexit(_ctx: FunctionEnvMut<EmEnv>, _func: i32) -> i32 {
-    debug!("emscripten::_atexit");
-    // TODO: implement atexit properly
-    // __ATEXIT__.unshift({
-    //     func: func,
-    //     arg: arg
-    // });
-    0
-}
-pub fn __Unwind_Backtrace(_ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
-    debug!("emscripten::__Unwind_Backtrace");
-    0
-}
-pub fn __Unwind_FindEnclosingFunction(_ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
-    debug!("emscripten::__Unwind_FindEnclosingFunction");
-    0
-}
-pub fn __Unwind_GetIPInfo(_ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
-    debug!("emscripten::__Unwind_GetIPInfo");
-    0
-}
-pub fn ___cxa_find_matching_catch_2(_ctx: FunctionEnvMut<EmEnv>) -> i32 {
-    debug!("emscripten::___cxa_find_matching_catch_2");
-    0
-}
-pub fn ___cxa_find_matching_catch_3(_ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
-    debug!("emscripten::___cxa_find_matching_catch_3");
-    0
-}
-pub fn ___cxa_free_exception(_ctx: FunctionEnvMut<EmEnv>, _a: i32) {
-    debug!("emscripten::___cxa_free_exception");
-}
-pub fn ___resumeException(_ctx: FunctionEnvMut<EmEnv>, _a: i32) {
-    debug!("emscripten::___resumeException");
-}
-pub fn _dladdr(_ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
-    debug!("emscripten::_dladdr");
-    0
-}
-pub fn ___gxx_personality_v0(
-    _ctx: FunctionEnvMut<EmEnv>,
-    _a: i32,
-    _b: i32,
-    _c: i32,
-    _d: i32,
-    _e: i32,
-    _f: i32,
-) -> i32 {
-    debug!("emscripten::___gxx_personality_v0");
-    0
-}
-
-#[cfg(target_os = "linux")]
-pub fn _getdtablesize(_ctx: FunctionEnvMut<EmEnv>) -> i32 {
-    debug!("emscripten::getdtablesize");
-    unsafe { getdtablesize() }
-}
-#[cfg(not(target_os = "linux"))]
-pub fn _getdtablesize(_ctx: FunctionEnvMut<EmEnv>) -> i32 {
-    debug!("emscripten::getdtablesize");
-    -1
-}
-pub fn _gethostbyaddr(_ctx: FunctionEnvMut<EmEnv>, _addr: i32, _addrlen: i32, _atype: i32) -> i32 {
-    debug!("emscripten::gethostbyaddr");
-    0
-}
-pub fn _gethostbyname(_ctx: FunctionEnvMut<EmEnv>, _name: i32) -> i32 {
-    debug!("emscripten::gethostbyname_r");
-    0
-}
-pub fn _gethostbyname_r(
-    _ctx: FunctionEnvMut<EmEnv>,
-    _name: i32,
-    _ret: i32,
-    _buf: i32,
-    _buflen: i32,
-    _out: i32,
-    _err: i32,
-) -> i32 {
-    debug!("emscripten::gethostbyname_r");
-    0
-}
-// NOTE: php.js has proper impl; libc has proper impl for linux
-pub fn _getloadavg(_ctx: FunctionEnvMut<EmEnv>, _loadavg: i32, _nelem: i32) -> i32 {
-    debug!("emscripten::getloadavg");
-    0
-}
-#[allow(clippy::too_many_arguments)]
-pub fn _getnameinfo(
-    _ctx: FunctionEnvMut<EmEnv>,
-    _addr: i32,
-    _addrlen: i32,
-    _host: i32,
-    _hostlen: i32,
-    _serv: i32,
-    _servlen: i32,
-    _flags: i32,
-) -> i32 {
-    debug!(
-        "emscripten::_getnameinfo({}, {}, {}, {}, {}, {}, {})",
-        _addr, _addrlen, _host, _hostlen, _serv, _servlen, _flags
-    );
-    0
-}
-
-// Invoke functions
-// They save the stack to allow unwinding
-
-// Macro definitions
-macro_rules! invoke {
-    ($ctx: ident, $name:ident, $name_ref:ident, $( $arg:ident ),*) => {{
-        let funcs = get_emscripten_funcs(&$ctx).clone();
-        let sp = funcs.stack_save_ref().expect("stack_save is None").call(&mut $ctx).expect("stack_save call failed");
-        let call = funcs.$name_ref().expect(concat!("Dynamic call is None: ", stringify!($name))).clone();
-        match call.call(&mut $ctx, $($arg),*) {
-            Ok(v) => v,
-            Err(_e) => {
-                let stack = funcs.stack_restore_ref().expect("stack_restore is None");
-                stack.call(&mut $ctx, sp).expect("stack_restore call failed");
-                // TODO: We should check if _e != "longjmp" and if that's the case, re-throw the error
-                // JS version is: if (e !== e+0 && e !== 'longjmp') throw e;
-                let threw = funcs.set_threw_ref().expect("set_threw is None");
-                threw.call(&mut $ctx, 1, 0).expect("set_threw call failed");
-                0 as _
-            }
-        }
-    }};
-}
-macro_rules! invoke_no_return {
-    ($ctx: ident, $name:ident, $name_ref:ident, $( $arg:ident ),*) => {{
-        let funcs = get_emscripten_funcs(&$ctx).clone();
-        let stack = funcs.stack_save_ref().expect("stack_save is None");
-        let sp = stack.call(&mut $ctx).expect("stack_save call failed");
-        let call = funcs.$name_ref().expect(concat!("Dynamic call is None: ", stringify!($name))).clone();
-        match call.call(&mut $ctx, $($arg),*) {
-            Ok(v) => v,
-            Err(_e) => {
-                let stack = funcs.stack_restore_ref().expect("stack_restore is None");
-                stack.call(&mut $ctx, sp).expect("stack_restore call failed");
-                // TODO: We should check if _e != "longjmp" and if that's the case, re-throw the error
-                // JS version is: if (e !== e+0 && e !== 'longjmp') throw e;
-                let threw = funcs.set_threw_ref().expect("set_threw is None");
-                threw.call(&mut $ctx, 1, 0).expect("set_threw call failed");
-            }
-        }
-    }};
-}
-// The invoke_j functions do not save the stack
-macro_rules! invoke_no_stack_save {
-    ($ctx: ident, $name:ident, $name_ref:ident, $( $arg:ident ),*) => {{
-        let funcs = get_emscripten_funcs(&$ctx).clone();
-        let call = funcs.$name_ref().expect(concat!(stringify!($name), " is set to None")).clone();
-
-        call.call(&mut $ctx, $($arg),*).unwrap()
-    }}
-}
-
-// Invoke functions
-pub fn invoke_i(mut ctx: FunctionEnvMut<EmEnv>, index: i32) -> i32 {
-    debug!("emscripten::invoke_i");
-    invoke!(ctx, dyn_call_i, dyn_call_i_ref, index)
-}
-pub fn invoke_ii(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32) -> i32 {
-    debug!("emscripten::invoke_ii");
-    invoke!(ctx, dyn_call_ii, dyn_call_ii_ref, index, a1)
-}
-pub fn invoke_iii(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32) -> i32 {
-    debug!("emscripten::invoke_iii");
-    invoke!(ctx, dyn_call_iii, dyn_call_iii_ref, index, a1, a2)
-}
-pub fn invoke_iiii(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32, a3: i32) -> i32 {
-    debug!("emscripten::invoke_iiii");
-    invoke!(ctx, dyn_call_iiii, dyn_call_iiii_ref, index, a1, a2, a3)
-}
-pub fn invoke_iifi(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: f64, a3: i32) -> i32 {
-    debug!("emscripten::invoke_iifi");
-    invoke!(ctx, dyn_call_iifi, dyn_call_iifi_ref, index, a1, a2, a3)
-}
-pub fn invoke_v(mut ctx: FunctionEnvMut<EmEnv>, index: i32) {
-    debug!("emscripten::invoke_v");
-    invoke_no_return!(ctx, dyn_call_v, dyn_call_v_ref, index);
-}
-pub fn invoke_vi(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32) {
-    debug!("emscripten::invoke_vi");
-    invoke_no_return!(ctx, dyn_call_vi, dyn_call_vi_ref, index, a1);
-}
-pub fn invoke_vii(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32) {
-    debug!("emscripten::invoke_vii");
-    invoke_no_return!(ctx, dyn_call_vii, dyn_call_vii_ref, index, a1, a2);
-}
-
-pub fn invoke_viii(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32, a3: i32) {
-    debug!("emscripten::invoke_viii");
-    invoke_no_return!(ctx, dyn_call_viii, dyn_call_viii_ref, index, a1, a2, a3);
-}
-pub fn invoke_viiii(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-) {
-    debug!("emscripten::invoke_viiii");
-    invoke_no_return!(
-        ctx,
-        dyn_call_viiii,
-        dyn_call_viiii_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4
-    );
-}
-pub fn invoke_dii(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32) -> f64 {
-    debug!("emscripten::invoke_dii");
-    invoke!(ctx, dyn_call_dii, dyn_call_dii_ref, index, a1, a2)
-}
-pub fn invoke_diiii(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-) -> f64 {
-    debug!("emscripten::invoke_diiii");
-    invoke!(
-        ctx,
-        dyn_call_diiii,
-        dyn_call_diiii_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4
-    )
-}
-pub fn invoke_iiiii(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-) -> i32 {
-    debug!("emscripten::invoke_iiiii");
-    invoke!(
-        ctx,
-        dyn_call_iiiii,
-        dyn_call_iiiii_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4
-    )
-}
-pub fn invoke_iiiiii(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-    a5: i32,
-) -> i32 {
-    debug!("emscripten::invoke_iiiiii");
-    invoke!(
-        ctx,
-        dyn_call_iiiiii,
-        dyn_call_iiiiii_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5
-    )
-}
-#[allow(clippy::too_many_arguments)]
-pub fn invoke_iiiiiii(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-    a5: i32,
-    a6: i32,
-) -> i32 {
-    debug!("emscripten::invoke_iiiiiii");
-    invoke!(
-        ctx,
-        dyn_call_iiiiiii,
-        dyn_call_iiiiiii_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5,
-        a6
-    )
-}
-#[allow(clippy::too_many_arguments)]
-pub fn invoke_iiiiiiii(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-    a5: i32,
-    a6: i32,
-    a7: i32,
-) -> i32 {
-    debug!("emscripten::invoke_iiiiiiii");
-    invoke!(
-        ctx,
-        dyn_call_iiiiiiii,
-        dyn_call_iiiiiiii_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5,
-        a6,
-        a7
-    )
-}
-#[allow(clippy::too_many_arguments)]
-pub fn invoke_iiiiiiiii(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-    a5: i32,
-    a6: i32,
-    a7: i32,
-    a8: i32,
-) -> i32 {
-    debug!("emscripten::invoke_iiiiiiiii");
-    invoke!(
-        ctx,
-        dyn_call_iiiiiiiii,
-        dyn_call_iiiiiiiii_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5,
-        a6,
-        a7,
-        a8
-    )
-}
-#[allow(clippy::too_many_arguments)]
-pub fn invoke_iiiiiiiiii(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-    a5: i32,
-    a6: i32,
-    a7: i32,
-    a8: i32,
-    a9: i32,
-) -> i32 {
-    debug!("emscripten::invoke_iiiiiiiiii");
-    invoke!(
-        ctx,
-        dyn_call_iiiiiiiiii,
-        dyn_call_iiiiiiiiii_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5,
-        a6,
-        a7,
-        a8,
-        a9
-    )
-}
-#[allow(clippy::too_many_arguments)]
-pub fn invoke_iiiiiiiiiii(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-    a5: i32,
-    a6: i32,
-    a7: i32,
-    a8: i32,
-    a9: i32,
-    a10: i32,
-) -> i32 {
-    debug!("emscripten::invoke_iiiiiiiiiii");
-    invoke!(
-        ctx,
-        dyn_call_iiiiiiiiiii,
-        dyn_call_iiiiiiiiiii_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5,
-        a6,
-        a7,
-        a8,
-        a9,
-        a10
-    )
-}
-pub fn invoke_vd(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: f64) {
-    debug!("emscripten::invoke_vd");
-    invoke_no_return!(ctx, dyn_call_vd, dyn_call_vd_ref, index, a1)
-}
-pub fn invoke_viiiii(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-    a5: i32,
-) {
-    debug!("emscripten::invoke_viiiii");
-    invoke_no_return!(
-        ctx,
-        dyn_call_viiiii,
-        dyn_call_viiiii_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5
-    )
-}
-#[allow(clippy::too_many_arguments)]
-pub fn invoke_viiiiii(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-    a5: i32,
-    a6: i32,
-) {
-    debug!("emscripten::invoke_viiiiii");
-    invoke_no_return!(
-        ctx,
-        dyn_call_viiiiii,
-        dyn_call_viiiiii_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5,
-        a6
-    )
-}
-#[allow(clippy::too_many_arguments)]
-pub fn invoke_viiiiiii(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-    a5: i32,
-    a6: i32,
-    a7: i32,
-) {
-    debug!("emscripten::invoke_viiiiiii");
-    invoke_no_return!(
-        ctx,
-        dyn_call_viiiiiii,
-        dyn_call_viiiiiii_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5,
-        a6,
-        a7
-    )
-}
-#[allow(clippy::too_many_arguments)]
-pub fn invoke_viiiiiiii(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-    a5: i32,
-    a6: i32,
-    a7: i32,
-    a8: i32,
-) {
-    debug!("emscripten::invoke_viiiiiiii");
-    invoke_no_return!(
-        ctx,
-        dyn_call_viiiiiiii,
-        dyn_call_viiiiiiii_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5,
-        a6,
-        a7,
-        a8
-    )
-}
-#[allow(clippy::too_many_arguments)]
-pub fn invoke_viiiiiiiii(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-    a5: i32,
-    a6: i32,
-    a7: i32,
-    a8: i32,
-    a9: i32,
-) {
-    debug!("emscripten::invoke_viiiiiiiii");
-    invoke_no_return!(
-        ctx,
-        dyn_call_viiiiiiiii,
-        dyn_call_viiiiiiiii_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5,
-        a6,
-        a7,
-        a8,
-        a9
-    )
-}
-#[allow(clippy::too_many_arguments)]
-pub fn invoke_viiiiiiiiii(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-    a5: i32,
-    a6: i32,
-    a7: i32,
-    a8: i32,
-    a9: i32,
-    a10: i32,
-) {
-    debug!("emscripten::invoke_viiiiiiiiii");
-    invoke_no_return!(
-        ctx,
-        dyn_call_viiiiiiiiii,
-        dyn_call_viiiiiiiiii_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5,
-        a6,
-        a7,
-        a8,
-        a9,
-        a10
-    )
-}
-
-pub fn invoke_iij(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32, a3: i32) -> i32 {
-    debug!("emscripten::invoke_iij");
-    invoke!(ctx, dyn_call_iij, dyn_call_iij_ref, index, a1, a2, a3)
-}
-
-pub fn invoke_iji(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32, a3: i32) -> i32 {
-    debug!("emscripten::invoke_iji");
-    invoke!(ctx, dyn_call_iji, dyn_call_iji_ref, index, a1, a2, a3)
-}
-
-pub fn invoke_iiji(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-) -> i32 {
-    debug!("emscripten::invoke_iiji");
-    invoke!(ctx, dyn_call_iiji, dyn_call_iiji_ref, index, a1, a2, a3, a4)
-}
-
-#[allow(clippy::too_many_arguments)]
-pub fn invoke_iiijj(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-    a5: i32,
-    a6: i32,
-) -> i32 {
-    debug!("emscripten::invoke_iiijj");
-    invoke!(
-        ctx,
-        dyn_call_iiijj,
-        dyn_call_iiijj_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5,
-        a6
-    )
-}
-pub fn invoke_j(mut ctx: FunctionEnvMut<EmEnv>, index: i32) -> i32 {
-    debug!("emscripten::invoke_j");
-    invoke_no_stack_save!(ctx, dyn_call_j, dyn_call_j_ref, index)
-}
-pub fn invoke_ji(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32) -> i32 {
-    debug!("emscripten::invoke_ji");
-    invoke_no_stack_save!(ctx, dyn_call_ji, dyn_call_ji_ref, index, a1)
-}
-pub fn invoke_jii(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32) -> i32 {
-    debug!("emscripten::invoke_jii");
-    invoke_no_stack_save!(ctx, dyn_call_jii, dyn_call_jii_ref, index, a1, a2)
-}
-
-pub fn invoke_jij(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32, a3: i32) -> i32 {
-    debug!("emscripten::invoke_jij");
-    invoke_no_stack_save!(ctx, dyn_call_jij, dyn_call_jij_ref, index, a1, a2, a3)
-}
-pub fn invoke_jjj(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-) -> i32 {
-    debug!("emscripten::invoke_jjj");
-    invoke_no_stack_save!(ctx, dyn_call_jjj, dyn_call_jjj_ref, index, a1, a2, a3, a4)
-}
-pub fn invoke_viiij(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-    a5: i32,
-) {
-    debug!("emscripten::invoke_viiij");
-    invoke_no_stack_save!(
-        ctx,
-        dyn_call_viiij,
-        dyn_call_viiij_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5
-    )
-}
-#[allow(clippy::too_many_arguments)]
-pub fn invoke_viiijiiii(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-    a5: i32,
-    a6: i32,
-    a7: i32,
-    a8: i32,
-    a9: i32,
-) {
-    debug!("emscripten::invoke_viiijiiii");
-    invoke_no_stack_save!(
-        ctx,
-        dyn_call_viiijiiii,
-        dyn_call_viiijiiii_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5,
-        a6,
-        a7,
-        a8,
-        a9
-    )
-}
-#[allow(clippy::too_many_arguments)]
-pub fn invoke_viiijiiiiii(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-    a5: i32,
-    a6: i32,
-    a7: i32,
-    a8: i32,
-    a9: i32,
-    a10: i32,
-    a11: i32,
-) {
-    debug!("emscripten::invoke_viiijiiiiii");
-    invoke_no_stack_save!(
-        ctx,
-        dyn_call_viiijiiiiii,
-        dyn_call_viiijiiiiii_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5,
-        a6,
-        a7,
-        a8,
-        a9,
-        a10,
-        a11
-    )
-}
-pub fn invoke_viij(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32, a3: i32, a4: i32) {
-    debug!("emscripten::invoke_viij");
-    invoke_no_stack_save!(ctx, dyn_call_viij, dyn_call_viij_ref, index, a1, a2, a3, a4)
-}
-pub fn invoke_viiji(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-    a5: i32,
-) {
-    debug!("emscripten::invoke_viiji");
-    invoke_no_stack_save!(
-        ctx,
-        dyn_call_viiji,
-        dyn_call_viiji_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5
-    )
-}
-#[allow(clippy::too_many_arguments)]
-pub fn invoke_viijiii(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-    a5: i32,
-    a6: i32,
-    a7: i32,
-) {
-    debug!("emscripten::invoke_viijiii");
-    invoke_no_stack_save!(
-        ctx,
-        dyn_call_viijiii,
-        dyn_call_viijiii_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5,
-        a6,
-        a7
-    )
-}
-#[allow(clippy::too_many_arguments)]
-pub fn invoke_viijj(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-    a5: i32,
-    a6: i32,
-) {
-    debug!("emscripten::invoke_viijj");
-    invoke_no_stack_save!(
-        ctx,
-        dyn_call_viijj,
-        dyn_call_viijj_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5,
-        a6
-    )
-}
-pub fn invoke_vj(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32) {
-    debug!("emscripten::invoke_vj");
-    invoke_no_stack_save!(ctx, dyn_call_vj, dyn_call_vj_ref, index, a1, a2)
-}
-pub fn invoke_vjji(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-    a5: i32,
-) {
-    debug!("emscripten::invoke_vjji");
-    invoke_no_return!(
-        ctx,
-        dyn_call_vjji,
-        dyn_call_vjji_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5
-    )
-}
-pub fn invoke_vij(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32, a3: i32) {
-    debug!("emscripten::invoke_vij");
-    invoke_no_stack_save!(ctx, dyn_call_vij, dyn_call_vij_ref, index, a1, a2, a3)
-}
-pub fn invoke_viji(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32, a3: i32, a4: i32) {
-    debug!("emscripten::invoke_viji");
-    invoke_no_stack_save!(ctx, dyn_call_viji, dyn_call_viji_ref, index, a1, a2, a3, a4)
-}
-#[allow(clippy::too_many_arguments)]
-pub fn invoke_vijiii(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-    a5: i32,
-    a6: i32,
-) {
-    debug!("emscripten::invoke_vijiii");
-    invoke_no_stack_save!(
-        ctx,
-        dyn_call_vijiii,
-        dyn_call_vijiii_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5,
-        a6
-    )
-}
-pub fn invoke_vijj(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: i32,
-    a4: i32,
-    a5: i32,
-) {
-    debug!("emscripten::invoke_vijj");
-    invoke_no_stack_save!(
-        ctx,
-        dyn_call_vijj,
-        dyn_call_vijj_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5
-    )
-}
-pub fn invoke_vidd(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: f64, a3: f64) {
-    debug!("emscripten::invoke_viid");
-    invoke_no_return!(ctx, dyn_call_vidd, dyn_call_vidd_ref, index, a1, a2, a3);
-}
-pub fn invoke_viid(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32, a3: f64) {
-    debug!("emscripten::invoke_viid");
-    invoke_no_return!(ctx, dyn_call_viid, dyn_call_viid_ref, index, a1, a2, a3);
-}
-pub fn invoke_viidii(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: f64,
-    a4: i32,
-    a5: i32,
-) {
-    debug!("emscripten::invoke_viidii");
-    invoke_no_return!(
-        ctx,
-        dyn_call_viidii,
-        dyn_call_viidii_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5
-    );
-}
-#[allow(clippy::too_many_arguments)]
-pub fn invoke_viidddddddd(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    index: i32,
-    a1: i32,
-    a2: i32,
-    a3: f64,
-    a4: f64,
-    a5: f64,
-    a6: f64,
-    a7: f64,
-    a8: f64,
-    a9: f64,
-    a10: f64,
-) {
-    debug!("emscripten::invoke_viidddddddd");
-    invoke_no_return!(
-        ctx,
-        dyn_call_viidddddddd,
-        dyn_call_viidddddddd_ref,
-        index,
-        a1,
-        a2,
-        a3,
-        a4,
-        a5,
-        a6,
-        a7,
-        a8,
-        a9,
-        a10
-    );
-}
diff --git a/lib/emscripten/src/env/mod.rs b/lib/emscripten/src/env/mod.rs
deleted file mode 100644
index 6482a80f0a..0000000000
--- a/lib/emscripten/src/env/mod.rs
+++ /dev/null
@@ -1,200 +0,0 @@
-#[cfg(unix)]
-mod unix;
-
-#[cfg(windows)]
-mod windows;
-
-#[cfg(unix)]
-pub use self::unix::*;
-
-#[cfg(windows)]
-pub use self::windows::*;
-
-use libc::c_char;
-
-use crate::{allocate_on_stack, EmscriptenData, EmscriptenFunctions};
-
-use std::os::raw::c_int;
-use std::sync::MutexGuard;
-
-use crate::EmEnv;
-use wasmer::ValueType;
-use wasmer::{FunctionEnvMut, WasmPtr};
-
-pub fn call_malloc(mut ctx: &mut FunctionEnvMut<EmEnv>, size: u32) -> u32 {
-    let malloc_ref = get_emscripten_funcs(ctx).malloc_ref().unwrap().clone();
-    malloc_ref.call(&mut ctx, size).unwrap()
-}
-
-#[allow(dead_code)]
-pub fn call_malloc_with_cast<T: Copy>(ctx: &mut FunctionEnvMut<EmEnv>, size: u32) -> WasmPtr<T> {
-    WasmPtr::new(call_malloc(ctx, size))
-}
-
-pub fn call_memalign(mut ctx: &mut FunctionEnvMut<EmEnv>, alignment: u32, size: u32) -> u32 {
-    let memalign_ref = get_emscripten_funcs(ctx).memalign_ref().unwrap().clone();
-    memalign_ref.call(&mut ctx, alignment, size).unwrap()
-}
-
-pub fn call_memset(
-    mut ctx: &mut FunctionEnvMut<EmEnv>,
-    pointer: u32,
-    value: u32,
-    size: u32,
-) -> u32 {
-    let memset_ref = get_emscripten_funcs(ctx).memset_ref().unwrap().clone();
-    memset_ref.call(&mut ctx, pointer, value, size).unwrap()
-}
-
-pub(crate) fn get_emscripten_data<'a>(
-    ctx: &'a FunctionEnvMut<EmEnv>,
-) -> MutexGuard<'a, Option<EmscriptenData>> {
-    ctx.data().data.lock().unwrap()
-}
-
-pub(crate) fn get_emscripten_funcs<'a>(
-    ctx: &'a FunctionEnvMut<EmEnv>,
-) -> MutexGuard<'a, EmscriptenFunctions> {
-    ctx.data().funcs.lock().unwrap()
-}
-
-pub fn _getpagesize(_ctx: FunctionEnvMut<EmEnv>) -> u32 {
-    debug!("emscripten::_getpagesize");
-    16384
-}
-
-pub fn _times(mut ctx: FunctionEnvMut<EmEnv>, buffer: u32) -> u32 {
-    if buffer != 0 {
-        call_memset(&mut ctx, buffer, 0, 16);
-    }
-    0
-}
-
-#[allow(clippy::cast_ptr_alignment)]
-pub fn ___build_environment(mut ctx: FunctionEnvMut<EmEnv>, environ: c_int) {
-    debug!("emscripten::___build_environment {}", environ);
-    const MAX_ENV_VALUES: u32 = 64;
-    const TOTAL_ENV_SIZE: u32 = 1024;
-    let memory = ctx.data().memory(0);
-    let environment = emscripten_memory_pointer!(memory.view(&ctx), environ) as *mut c_int;
-    let (mut pool_offset, env_ptr, mut pool_ptr) = unsafe {
-        let (pool_offset, _pool_slice): (u32, &mut [u8]) =
-            allocate_on_stack(&mut ctx, TOTAL_ENV_SIZE as u32);
-        let (env_offset, _env_slice): (u32, &mut [u8]) =
-            allocate_on_stack(&mut ctx, (MAX_ENV_VALUES * 4) as u32);
-        let env_ptr = emscripten_memory_pointer!(memory.view(&ctx), env_offset) as *mut c_int;
-        let pool_ptr = emscripten_memory_pointer!(memory.view(&ctx), pool_offset) as *mut u8;
-        *env_ptr = pool_offset as i32;
-        *environment = env_offset as i32;
-
-        (pool_offset, env_ptr, pool_ptr)
-    };
-
-    // *env_ptr = 0;
-    let default_vars = vec![
-        ["USER", "web_user"],
-        ["LOGNAME", "web_user"],
-        ["PATH", "/"],
-        ["PWD", "/"],
-        ["HOME", "/home/web_user"],
-        ["LANG", "C.UTF-8"],
-        ["_", "thisProgram"],
-    ];
-    let mut strings = vec![];
-    let mut total_size = 0;
-    for [key, val] in &default_vars {
-        let line = key.to_string() + "=" + val;
-        total_size += line.len();
-        strings.push(line);
-    }
-    if total_size as u32 > TOTAL_ENV_SIZE {
-        panic!("Environment size exceeded TOTAL_ENV_SIZE!");
-    }
-    unsafe {
-        for (i, s) in strings.iter().enumerate() {
-            for (j, c) in s.chars().enumerate() {
-                debug_assert!(c < u8::max_value() as char);
-                *pool_ptr.add(j) = c as u8;
-            }
-            *env_ptr.add(i * 4) = pool_offset as i32;
-            pool_offset += s.len() as u32 + 1;
-            pool_ptr = pool_ptr.add(s.len() + 1);
-        }
-        *env_ptr.add(strings.len() * 4) = 0;
-    }
-}
-
-pub fn ___assert_fail(_ctx: FunctionEnvMut<EmEnv>, _a: c_int, _b: c_int, _c: c_int, _d: c_int) {
-    debug!("emscripten::___assert_fail {} {} {} {}", _a, _b, _c, _d);
-    // TODO: Implement like emscripten expects regarding memory/page size
-    // TODO raise an error
-}
-
-pub fn _pathconf(ctx: FunctionEnvMut<EmEnv>, path_addr: c_int, name: c_int) -> c_int {
-    debug!(
-        "emscripten::_pathconf {} {} - UNIMPLEMENTED",
-        path_addr, name
-    );
-    let memory = ctx.data().memory(0);
-    let _path = emscripten_memory_pointer!(memory.view(&ctx), path_addr) as *const c_char;
-    match name {
-        0 => 32000,
-        1..=3 => 255,
-        4 | 5 | 16 | 17 | 18 => 4096,
-        6 | 7 | 20 => 1,
-        8 => 0,
-        9 | 10 | 11 | 12 | 14 | 15 | 19 => -1,
-        13 => 64,
-        _ => {
-            // ___setErrNo(22);
-            -1
-        }
-    }
-}
-
-pub fn _fpathconf(_ctx: FunctionEnvMut<EmEnv>, _fildes: c_int, name: c_int) -> c_int {
-    debug!("emscripten::_fpathconf {} {}", _fildes, name);
-    match name {
-        0 => 32000,
-        1..=3 => 255,
-        4 | 5 | 16 | 17 | 18 => 4096,
-        6 | 7 | 20 => 1,
-        8 => 0,
-        9 | 10 | 11 | 12 | 14 | 15 | 19 => -1,
-        13 => 64,
-        _ => {
-            // ___setErrNo(22);
-            -1
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, ValueType)]
-#[repr(C)]
-pub struct EmAddrInfo {
-    // int
-    pub ai_flags: i32,
-    // int
-    pub ai_family: i32,
-    // int
-    pub ai_socktype: i32,
-    // int
-    pub ai_protocol: i32,
-    // socklen_t
-    pub ai_addrlen: u32,
-    // struct sockaddr*
-    pub ai_addr: WasmPtr<EmSockAddr>,
-    // char*
-    pub ai_canonname: WasmPtr<c_char>,
-    // struct addrinfo*
-    pub ai_next: WasmPtr<EmAddrInfo>,
-}
-
-// NOTE: from looking at emscripten JS, this should be a union
-// TODO: review this, highly likely to have bugs
-#[derive(Debug, Clone, Copy, ValueType)]
-#[repr(C)]
-pub struct EmSockAddr {
-    pub sa_family: i16,
-    pub sa_data: [c_char; 14],
-}
diff --git a/lib/emscripten/src/env/unix/mod.rs b/lib/emscripten/src/env/unix/mod.rs
deleted file mode 100644
index a638d31be2..0000000000
--- a/lib/emscripten/src/env/unix/mod.rs
+++ /dev/null
@@ -1,364 +0,0 @@
-/// NOTE: These syscalls only support wasm_32 for now because they take u32 offset
-use libc::{c_int, getgrnam as libc_getgrnam, getpwnam as libc_getpwnam, sysconf};
-use std::ffi::{CStr, CString};
-use std::mem;
-use std::os::raw::c_char;
-
-use crate::env::{call_malloc, call_malloc_with_cast, EmAddrInfo, EmSockAddr};
-use crate::utils::{copy_cstr_into_wasm, copy_terminated_array_of_cstrs};
-use crate::EmEnv;
-use wasmer::{FunctionEnvMut, WasmPtr};
-
-// #[no_mangle]
-/// emscripten: _getenv // (name: *const char) -> *const c_char;
-pub fn _getenv(mut ctx: FunctionEnvMut<EmEnv>, name: i32) -> u32 {
-    debug!("emscripten::_getenv");
-
-    let em_env = ctx.data();
-    let memory = em_env.memory(0);
-    let name_addr = emscripten_memory_pointer!(memory.view(&ctx), name) as *const c_char;
-
-    debug!("=> name({:?})", unsafe { CStr::from_ptr(name_addr) });
-
-    let c_string = unsafe { CStr::from_ptr(name_addr) };
-    let c_string = c_string.to_string_lossy();
-    let env_var = em_env.get_env_var(c_string.as_ref());
-    let env_var = match env_var {
-        Some(s) => s,
-        None => return 0,
-    };
-    let new_env_var = match CString::new(env_var) {
-        Ok(s) => s,
-        Err(_) => return 0,
-    };
-    unsafe { copy_cstr_into_wasm(&mut ctx, new_env_var.as_ptr()) }
-}
-
-/// emscripten: _setenv // (name: *const char, name: *const value, overwrite: int);
-pub fn _setenv(ctx: FunctionEnvMut<EmEnv>, name: c_int, value: c_int, overwrite: c_int) -> c_int {
-    debug!("emscripten::_setenv");
-
-    let em_env = ctx.data();
-    let memory = em_env.memory(0);
-    let name_addr = emscripten_memory_pointer!(memory.view(&ctx), name) as *const c_char;
-    let value_addr = emscripten_memory_pointer!(memory.view(&ctx), value) as *const c_char;
-
-    let name = unsafe { CStr::from_ptr(name_addr) }.to_string_lossy();
-    let value = unsafe { CStr::from_ptr(value_addr) }.to_string_lossy();
-
-    debug!("=> name({:?})", name);
-    debug!("=> value({:?})", value);
-
-    let previous_entry = em_env.set_env_var(name.as_ref(), value.as_ref());
-
-    if let (0, Some(prev)) = (overwrite, previous_entry) {
-        let _ = em_env.set_env_var(name.as_ref(), prev.as_ref());
-    }
-
-    0
-}
-
-/// emscripten: _putenv // (name: *const char);
-pub fn _putenv(ctx: FunctionEnvMut<EmEnv>, name: c_int) -> c_int {
-    debug!("emscripten::_putenv");
-
-    let em_env = ctx.data();
-    let memory = em_env.memory(0);
-    let name_addr = emscripten_memory_pointer!(memory.view(&ctx), name) as *const c_char;
-
-    let name = unsafe { CStr::from_ptr(name_addr) }.to_string_lossy();
-    debug!("=> name({:?})", name);
-
-    em_env.set_env_var(name.as_ref(), "");
-
-    0
-}
-
-/// emscripten: _unsetenv // (name: *const char);
-pub fn _unsetenv(mut ctx: FunctionEnvMut<EmEnv>, name: c_int) -> c_int {
-    debug!("emscripten::_unsetenv");
-
-    let name = {
-        let em_env = ctx.data();
-        let memory = em_env.memory(0);
-        let name_addr = emscripten_memory_pointer!(memory.view(&ctx), name) as *const c_char;
-        unsafe { CStr::from_ptr(name_addr) }
-            .to_string_lossy()
-            .to_string()
-    };
-
-    debug!("=> name({:?})", name);
-    let em_env = ctx.data_mut();
-    em_env.remove_env_var(name.as_ref());
-
-    0
-}
-
-#[allow(clippy::cast_ptr_alignment)]
-pub fn _getpwnam(mut ctx: FunctionEnvMut<EmEnv>, name_ptr: c_int) -> c_int {
-    debug!("emscripten::_getpwnam {}", name_ptr);
-    #[cfg(feature = "debug")]
-    let _ = name_ptr;
-
-    #[repr(C)]
-    struct GuestPasswd {
-        pw_name: u32,
-        pw_passwd: u32,
-        pw_uid: u32,
-        pw_gid: u32,
-        pw_gecos: u32,
-        pw_dir: u32,
-        pw_shell: u32,
-    }
-
-    let memory = ctx.data().memory(0);
-    let name = unsafe {
-        let memory = memory.view(&ctx);
-        let memory_name_ptr = emscripten_memory_pointer!(&memory, name_ptr) as *const c_char;
-        CStr::from_ptr(memory_name_ptr)
-    };
-
-    unsafe {
-        let passwd = &*libc_getpwnam(name.as_ptr());
-        let passwd_struct_offset = call_malloc(&mut ctx, mem::size_of::<GuestPasswd>() as _);
-
-        let memory = memory.view(&ctx);
-        let passwd_struct_ptr =
-            emscripten_memory_pointer!(&memory, passwd_struct_offset) as *mut GuestPasswd;
-        (*passwd_struct_ptr).pw_name = copy_cstr_into_wasm(&mut ctx, passwd.pw_name);
-        (*passwd_struct_ptr).pw_passwd = copy_cstr_into_wasm(&mut ctx, passwd.pw_passwd);
-        (*passwd_struct_ptr).pw_gecos = copy_cstr_into_wasm(&mut ctx, passwd.pw_gecos);
-        (*passwd_struct_ptr).pw_dir = copy_cstr_into_wasm(&mut ctx, passwd.pw_dir);
-        (*passwd_struct_ptr).pw_shell = copy_cstr_into_wasm(&mut ctx, passwd.pw_shell);
-        (*passwd_struct_ptr).pw_uid = passwd.pw_uid;
-        (*passwd_struct_ptr).pw_gid = passwd.pw_gid;
-
-        passwd_struct_offset as c_int
-    }
-}
-
-#[allow(clippy::cast_ptr_alignment)]
-pub fn _getgrnam(mut ctx: FunctionEnvMut<EmEnv>, name_ptr: c_int) -> c_int {
-    debug!("emscripten::_getgrnam {}", name_ptr);
-
-    #[repr(C)]
-    struct GuestGroup {
-        gr_name: u32,
-        gr_passwd: u32,
-        gr_gid: u32,
-        gr_mem: u32,
-    }
-
-    let memory = ctx.data().memory(0);
-    let name = unsafe {
-        let memory_name_ptr =
-            emscripten_memory_pointer!(memory.view(&ctx), name_ptr) as *const c_char;
-        CStr::from_ptr(memory_name_ptr)
-    };
-
-    unsafe {
-        let group = &*libc_getgrnam(name.as_ptr());
-        let group_struct_offset = call_malloc(&mut ctx, mem::size_of::<GuestGroup>() as _);
-
-        let group_struct_ptr =
-            emscripten_memory_pointer!(memory.view(&ctx), group_struct_offset) as *mut GuestGroup;
-        (*group_struct_ptr).gr_name = copy_cstr_into_wasm(&mut ctx, group.gr_name);
-        (*group_struct_ptr).gr_passwd = copy_cstr_into_wasm(&mut ctx, group.gr_passwd);
-        (*group_struct_ptr).gr_gid = group.gr_gid;
-        (*group_struct_ptr).gr_mem = copy_terminated_array_of_cstrs(ctx, group.gr_mem);
-
-        group_struct_offset as c_int
-    }
-}
-
-pub fn _sysconf(_ctx: FunctionEnvMut<EmEnv>, name: c_int) -> i32 {
-    debug!("emscripten::_sysconf {}", name);
-    // TODO: Implement like emscripten expects regarding memory/page size
-    unsafe { sysconf(name) as i32 } // TODO review i64
-}
-
-// this may be a memory leak, probably not though because emscripten does the same thing
-pub fn _gai_strerror(mut ctx: FunctionEnvMut<EmEnv>, ecode: i32) -> i32 {
-    debug!("emscripten::_gai_strerror({})", ecode);
-
-    let cstr = unsafe { std::ffi::CStr::from_ptr(libc::gai_strerror(ecode)) };
-    let bytes = cstr.to_bytes_with_nul();
-    let string_on_guest: WasmPtr<c_char> = call_malloc_with_cast(&mut ctx, bytes.len() as _);
-    let memory = ctx.data().memory(0);
-    let memory = memory.view(&ctx);
-
-    let writer = string_on_guest.slice(&memory, bytes.len() as _).unwrap();
-    for (i, byte) in bytes.iter().enumerate() {
-        writer.index(i as u64).write(*byte as _).unwrap();
-    }
-
-    string_on_guest.offset() as _
-}
-
-pub fn _getaddrinfo(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    node_ptr: WasmPtr<c_char>,
-    service_str_ptr: WasmPtr<c_char>,
-    hints_ptr: WasmPtr<EmAddrInfo>,
-    res_val_ptr: WasmPtr<WasmPtr<EmAddrInfo>>,
-) -> i32 {
-    use libc::{addrinfo, freeaddrinfo};
-    debug!("emscripten::_getaddrinfo");
-    debug!(" => node = {}", {
-        if node_ptr.is_null() {
-            std::borrow::Cow::Borrowed("null")
-        } else {
-            unimplemented!()
-        }
-    });
-    debug!(" => server_str = {}", {
-        if service_str_ptr.is_null() {
-            std::borrow::Cow::Borrowed("null")
-        } else {
-            unimplemented!()
-        }
-    });
-
-    let hints = if hints_ptr.is_null() {
-        None
-    } else {
-        let memory = ctx.data().memory(0);
-        let hints_guest = hints_ptr.deref(&memory.view(&ctx)).read().unwrap();
-        Some(addrinfo {
-            ai_flags: hints_guest.ai_flags,
-            ai_family: hints_guest.ai_family,
-            ai_socktype: hints_guest.ai_socktype,
-            ai_protocol: hints_guest.ai_protocol,
-            ai_addrlen: 0,
-            ai_addr: std::ptr::null_mut(),
-            ai_canonname: std::ptr::null_mut(),
-            ai_next: std::ptr::null_mut(),
-        })
-    };
-
-    let mut out_ptr: *mut addrinfo = std::ptr::null_mut();
-
-    // allocate equivalent memory for res_val_ptr
-    let result = unsafe {
-        libc::getaddrinfo(
-            if node_ptr.is_null() {
-                std::ptr::null()
-            } else {
-                unimplemented!()
-            },
-            if service_str_ptr.is_null() {
-                std::ptr::null()
-            } else {
-                unimplemented!()
-            },
-            hints
-                .as_ref()
-                .map(|h| h as *const addrinfo)
-                .unwrap_or(std::ptr::null()),
-            &mut out_ptr as *mut *mut addrinfo,
-        )
-    };
-    if result != 0 {
-        return result;
-    }
-
-    // walk linked list and copy over, freeing them from the kernel
-    let head_of_list = unsafe {
-        let mut current_host_node = out_ptr;
-        let mut head_of_list = None;
-        let mut previous_guest_node: Option<WasmPtr<EmAddrInfo>> = None;
-
-        while !current_host_node.is_null() {
-            let current_guest_node_ptr: WasmPtr<EmAddrInfo> =
-                call_malloc_with_cast(&mut ctx, std::mem::size_of::<EmAddrInfo>() as _);
-            if head_of_list.is_none() {
-                head_of_list = Some(current_guest_node_ptr);
-            }
-
-            // connect list
-            if let Some(prev_guest) = previous_guest_node {
-                let memory = ctx.data().memory(0);
-                let memory = memory.view(&ctx);
-                let derefed_prev_guest = prev_guest.deref(&memory);
-                let mut pg = derefed_prev_guest.read().unwrap();
-                pg.ai_next = current_guest_node_ptr;
-                derefed_prev_guest.write(pg).unwrap();
-            }
-
-            // update values
-
-            let host_addrlen = (*current_host_node).ai_addrlen;
-            // allocate addr and copy data
-            let guest_sockaddr_ptr = {
-                let host_sockaddr_ptr = (*current_host_node).ai_addr;
-                let guest_sockaddr_ptr: WasmPtr<EmSockAddr> =
-                    call_malloc_with_cast(&mut ctx, host_addrlen as _);
-
-                let memory = ctx.data().memory(0);
-                let memory = memory.view(&ctx);
-                let derefed_guest_sockaddr = guest_sockaddr_ptr.deref(&memory);
-                let mut gs = derefed_guest_sockaddr.read().unwrap();
-                gs.sa_family = (*host_sockaddr_ptr).sa_family as i16;
-                gs.sa_data = (*host_sockaddr_ptr).sa_data;
-                derefed_guest_sockaddr.write(gs).unwrap();
-
-                guest_sockaddr_ptr
-            };
-
-            // allocate canon name on guest and copy data over
-            let guest_canonname_ptr = {
-                let str_ptr = (*current_host_node).ai_canonname;
-                if !str_ptr.is_null() {
-                    let canonname_cstr = std::ffi::CStr::from_ptr(str_ptr);
-                    let canonname_bytes = canonname_cstr.to_bytes_with_nul();
-                    let str_size = canonname_bytes.len();
-                    let guest_canonname: WasmPtr<c_char> =
-                        call_malloc_with_cast(&mut ctx, str_size as _);
-
-                    let memory = ctx.data().memory(0);
-                    let memory = memory.view(&ctx);
-                    let guest_canonname_writer =
-                        guest_canonname.slice(&memory, str_size as _).unwrap();
-                    for (i, b) in canonname_bytes.iter().enumerate() {
-                        guest_canonname_writer
-                            .index(i as u64)
-                            .write(*b as _)
-                            .unwrap();
-                    }
-
-                    guest_canonname
-                } else {
-                    WasmPtr::new(0)
-                }
-            };
-
-            let memory = ctx.data().memory(0);
-            let memory = memory.view(&ctx);
-            let derefed_current_guest_node = current_guest_node_ptr.deref(&memory);
-            let mut cgn = derefed_current_guest_node.read().unwrap();
-            cgn.ai_flags = (*current_host_node).ai_flags;
-            cgn.ai_family = (*current_host_node).ai_family;
-            cgn.ai_socktype = (*current_host_node).ai_socktype;
-            cgn.ai_protocol = (*current_host_node).ai_protocol;
-            cgn.ai_addrlen = host_addrlen;
-            cgn.ai_addr = guest_sockaddr_ptr;
-            cgn.ai_canonname = guest_canonname_ptr;
-            cgn.ai_next = WasmPtr::new(0);
-            derefed_current_guest_node.write(cgn).unwrap();
-
-            previous_guest_node = Some(current_guest_node_ptr);
-            current_host_node = (*current_host_node).ai_next;
-        }
-        // this frees all connected nodes on the linked list
-        freeaddrinfo(out_ptr);
-        head_of_list.unwrap_or_else(|| WasmPtr::new(0))
-    };
-
-    let memory = ctx.data().memory(0);
-    res_val_ptr
-        .deref(&memory.view(&ctx))
-        .write(head_of_list)
-        .unwrap();
-
-    0
-}
diff --git a/lib/emscripten/src/env/windows/mod.rs b/lib/emscripten/src/env/windows/mod.rs
deleted file mode 100644
index b342bd962e..0000000000
--- a/lib/emscripten/src/env/windows/mod.rs
+++ /dev/null
@@ -1,162 +0,0 @@
-/// NOTE: These syscalls only support wasm_32 for now because they take u32 offset
-use libc::{c_int, c_long, getenv};
-
-use std::ffi::CString;
-use std::mem;
-use std::os::raw::c_char;
-
-use crate::env::{call_malloc, EmAddrInfo};
-use crate::utils::{copy_cstr_into_wasm, read_string_from_wasm};
-use crate::EmEnv;
-use wasmer::{FunctionEnvMut, WasmPtr};
-
-extern "C" {
-    #[link_name = "_putenv"]
-    pub fn putenv(s: *const c_char) -> c_int;
-}
-
-// #[no_mangle]
-/// emscripten: _getenv // (name: *const char) -> *const c_char;
-pub fn _getenv(mut ctx: FunctionEnvMut<EmEnv>, name: u32) -> u32 {
-    debug!("emscripten::_getenv");
-    let memory = ctx.data().memory(0);
-    let view = memory.view(&ctx);
-    let name_string = read_string_from_wasm(&view, name);
-    debug!("=> name({:?})", name_string);
-    let c_str = unsafe { getenv(name_string.as_ptr() as *const libc::c_char) };
-    if c_str.is_null() {
-        return 0;
-    }
-    unsafe { copy_cstr_into_wasm(&mut ctx, c_str as *const c_char) }
-}
-
-/// emscripten: _setenv // (name: *const char, name: *const value, overwrite: int);
-pub fn _setenv(ctx: FunctionEnvMut<EmEnv>, name: u32, value: u32, _overwrite: u32) -> c_int {
-    debug!("emscripten::_setenv");
-    let memory = ctx.data().memory(0);
-    let view = memory.view(&ctx);
-    // setenv does not exist on windows, so we hack it with _putenv
-    let name = read_string_from_wasm(&view, name);
-    let value = read_string_from_wasm(&view, value);
-    let putenv_string = format!("{}={}", name, value);
-    let putenv_cstring = CString::new(putenv_string).unwrap();
-    let putenv_raw_ptr = putenv_cstring.as_ptr();
-    debug!("=> name({:?})", name);
-    debug!("=> value({:?})", value);
-    unsafe { putenv(putenv_raw_ptr) }
-}
-
-/// emscripten: _putenv // (name: *const char);
-pub fn _putenv(ctx: FunctionEnvMut<EmEnv>, name: c_int) -> c_int {
-    debug!("emscripten::_putenv");
-    let memory = ctx.data().memory(0);
-    let view = memory.view(&ctx);
-    let name_addr = emscripten_memory_pointer!(&view, name) as *const c_char;
-    debug!("=> name({:?})", unsafe {
-        std::ffi::CStr::from_ptr(name_addr)
-    });
-    unsafe { putenv(name_addr) }
-}
-
-/// emscripten: _unsetenv // (name: *const char);
-pub fn _unsetenv(ctx: FunctionEnvMut<EmEnv>, name: u32) -> c_int {
-    debug!("emscripten::_unsetenv");
-    let memory = ctx.data().memory(0);
-    let view = memory.view(&ctx);
-    let name = read_string_from_wasm(&view, name);
-    // no unsetenv on windows, so use putenv with an empty value
-    let unsetenv_string = format!("{}=", name);
-    let unsetenv_cstring = CString::new(unsetenv_string).unwrap();
-    let unsetenv_raw_ptr = unsetenv_cstring.as_ptr();
-    debug!("=> name({:?})", name);
-    unsafe { putenv(unsetenv_raw_ptr) }
-}
-
-#[allow(clippy::cast_ptr_alignment)]
-pub fn _getpwnam(mut ctx: FunctionEnvMut<EmEnv>, name_ptr: c_int) -> c_int {
-    debug!("emscripten::_getpwnam {}", name_ptr);
-    #[cfg(not(feature = "debug"))]
-    let _ = name_ptr;
-
-    #[repr(C)]
-    struct GuestPasswd {
-        pw_name: u32,
-        pw_passwd: u32,
-        pw_uid: u32,
-        pw_gid: u32,
-        pw_gecos: u32,
-        pw_dir: u32,
-        pw_shell: u32,
-    }
-
-    // stub this in windows as it is not valid
-    unsafe {
-        let passwd_struct_offset = call_malloc(&mut ctx, mem::size_of::<GuestPasswd>() as _);
-        let memory = ctx.data().memory(0);
-        let view = memory.view(&ctx);
-        let passwd_struct_ptr =
-            emscripten_memory_pointer!(&view, passwd_struct_offset) as *mut GuestPasswd;
-        (*passwd_struct_ptr).pw_name = 0;
-        (*passwd_struct_ptr).pw_passwd = 0;
-        (*passwd_struct_ptr).pw_gecos = 0;
-        (*passwd_struct_ptr).pw_dir = 0;
-        (*passwd_struct_ptr).pw_shell = 0;
-        (*passwd_struct_ptr).pw_uid = 0;
-        (*passwd_struct_ptr).pw_gid = 0;
-
-        passwd_struct_offset as c_int
-    }
-}
-
-#[allow(clippy::cast_ptr_alignment)]
-pub fn _getgrnam(mut ctx: FunctionEnvMut<EmEnv>, name_ptr: c_int) -> c_int {
-    debug!("emscripten::_getgrnam {}", name_ptr);
-    #[cfg(not(feature = "debug"))]
-    let _ = name_ptr;
-
-    #[repr(C)]
-    struct GuestGroup {
-        gr_name: u32,
-        gr_passwd: u32,
-        gr_gid: u32,
-        gr_mem: u32,
-    }
-
-    // stub the group struct as it is not supported on windows
-    unsafe {
-        let group_struct_offset = call_malloc(&mut ctx, mem::size_of::<GuestGroup>() as _);
-        let memory = ctx.data().memory(0);
-        let view = memory.view(&ctx);
-        let group_struct_ptr =
-            emscripten_memory_pointer!(&view, group_struct_offset) as *mut GuestGroup;
-        (*group_struct_ptr).gr_name = 0;
-        (*group_struct_ptr).gr_passwd = 0;
-        (*group_struct_ptr).gr_gid = 0;
-        (*group_struct_ptr).gr_mem = 0;
-        group_struct_offset as c_int
-    }
-}
-
-pub fn _sysconf(_ctx: FunctionEnvMut<EmEnv>, name: c_int) -> c_long {
-    debug!("emscripten::_sysconf {}", name);
-    #[cfg(not(feature = "debug"))]
-    let _ = name;
-    // stub because sysconf is not valid on windows
-    0
-}
-
-pub fn _gai_strerror(_ctx: FunctionEnvMut<EmEnv>, _ecode: i32) -> i32 {
-    debug!("emscripten::_gai_strerror({}) - stub", _ecode);
-    -1
-}
-
-pub fn _getaddrinfo(
-    _ctx: FunctionEnvMut<EmEnv>,
-    _node_ptr: WasmPtr<c_char>,
-    _service_str_ptr: WasmPtr<c_char>,
-    _hints_ptr: WasmPtr<EmAddrInfo>,
-    _res_val_ptr: WasmPtr<WasmPtr<EmAddrInfo>>,
-) -> i32 {
-    debug!("emscripten::_getaddrinfo -- stub");
-    -1
-}
diff --git a/lib/emscripten/src/errno.rs b/lib/emscripten/src/errno.rs
deleted file mode 100644
index 99c78bf8c1..0000000000
--- a/lib/emscripten/src/errno.rs
+++ /dev/null
@@ -1,267 +0,0 @@
-// use std::collections::HashMap;
-use crate::EmEnv;
-use wasmer::FunctionEnvMut;
-
-pub fn ___seterrno(mut _ctx: FunctionEnvMut<EmEnv>, _value: i32) {
-    debug!("emscripten::___seterrno {}", _value);
-    // TODO: Incomplete impl
-    eprintln!("failed to set errno!");
-    // value
-}
-
-// pub enum ErrnoCodes {
-//     EPERM = 1,
-//     ENOENT = 2,
-//     ESRCH = 3,
-//     EINTR = 4,
-//     EIO = 5,
-//     ENXIO = 6,
-//     E2BIG = 7,
-//     ENOEXEC = 8,
-//     EBADF = 9,
-//     ECHILD = 10,
-//     EAGAIN = 11,
-//     EWOULDBLOCK = 11,
-//     ENOMEM = 12,
-//     EACCES = 13,
-//     EFAULT = 14,
-//     ENOTBLK = 15,
-//     EBUSY = 16,
-//     EEXIST = 17,
-//     EXDEV = 18,
-//     ENODEV = 19,
-//     ENOTDIR = 20,
-//     EISDIR = 21,
-//     EINVAL = 22,
-//     ENFILE = 23,
-//     EMFILE = 24,
-//     ENOTTY = 25,
-//     ETXTBSY = 26,
-//     EFBIG = 27,
-//     ENOSPC = 28,
-//     ESPIPE = 29,
-//     EROFS = 30,
-//     EMLINK = 31,
-//     EPIPE = 32,
-//     EDOM = 33,
-//     ERANGE = 34,
-//     ENOMSG = 42,
-//     EIDRM = 43,
-//     ECHRNG = 44,
-//     EL2NSYNC = 45,
-//     EL3HLT = 46,
-//     EL3RST = 47,
-//     ELNRNG = 48,
-//     EUNATCH = 49,
-//     ENOCSI = 50,
-//     EL2HLT = 51,
-//     EDEADLK = 35,
-//     ENOLCK = 37,
-//     EBADE = 52,
-//     EBADR = 53,
-//     EXFULL = 54,
-//     ENOANO = 55,
-//     EBADRQC = 56,
-//     EBADSLT = 57,
-//     EDEADLOCK = 35,
-//     EBFONT = 59,
-//     ENOSTR = 60,
-//     ENODATA = 61,
-//     ETIME = 62,
-//     ENOSR = 63,
-//     ENONET = 64,
-//     ENOPKG = 65,
-//     EREMOTE = 66,
-//     ENOLINK = 67,
-//     EADV = 68,
-//     ESRMNT = 69,
-//     ECOMM = 70,
-//     EPROTO = 71,
-//     EMULTIHOP = 72,
-//     EDOTDOT = 73,
-//     EBADMSG = 74,
-//     ENOTUNIQ = 76,
-//     EBADFD = 77,
-//     EREMCHG = 78,
-//     ELIBACC = 79,
-//     ELIBBAD = 80,
-//     ELIBSCN = 81,
-//     ELIBMAX = 82,
-//     ELIBEXEC = 83,
-//     ENOSYS = 38,
-//     ENOTEMPTY = 39,
-//     ENAMETOOLONG = 36,
-//     ELOOP = 40,
-//     EOPNOTSUPP = 95,
-//     EPFNOSUPPORT = 96,
-//     ECONNRESET = 104,
-//     ENOBUFS = 105,
-//     EAFNOSUPPORT = 97,
-//     EPROTOTYPE = 91,
-//     ENOTSOCK = 88,
-//     ENOPROTOOPT = 92,
-//     ESHUTDOWN = 108,
-//     ECONNREFUSED = 111,
-//     EADDRINUSE = 98,
-//     ECONNABORTED = 103,
-//     ENETUNREACH = 101,
-//     ENETDOWN = 100,
-//     ETIMEDOUT = 110,
-//     EHOSTDOWN = 112,
-//     EHOSTUNREACH = 113,
-//     EINPROGRESS = 115,
-//     EALREADY = 114,
-//     EDESTADDRREQ = 89,
-//     EMSGSIZE = 90,
-//     EPROTONOSUPPORT = 93,
-//     ESOCKTNOSUPPORT = 94,
-//     EADDRNOTAVAIL = 99,
-//     ENETRESET = 102,
-//     EISCONN = 106,
-//     ENOTCONN = 107,
-//     ETOOMANYREFS = 109,
-//     EUSERS = 87,
-//     EDQUOT = 122,
-//     ESTALE = 116,
-//     ENOTSUP = 95,
-//     ENOMEDIUM = 123,
-//     EILSEQ = 84,
-//     EOVERFLOW = 75,
-//     ECANCELED = 125,
-//     ENOTRECOVERABLE = 131,
-//     EOWNERDEAD = 130,
-//     ESTRPIPE = 86,
-// }
-
-// pub struct ErrnoMessages<'a> {
-//     message_map: HashMap<u32, &'a str>
-// }
-
-// impl<'a> ErrnoMessages<'a> {
-//     fn new() -> Self {
-//         let mut message_map = HashMap::new();
-//         message_map.insert(0, "Success");
-//         message_map.insert(1, "Not super-user");
-//         message_map.insert(2, "No such file or directory");
-//         message_map.insert(3, "No such process");
-//         message_map.insert(4, "Interrupted system call");
-//         message_map.insert(5, "I/O error");
-//         message_map.insert(6, "No such device or address");
-//         message_map.insert(7, "Arg list too long");
-//         message_map.insert(8, "Exec format error");
-//         message_map.insert(9, "Bad file number");
-//         message_map.insert(10, "No children");
-//         message_map.insert(11, "No more processes");
-//         message_map.insert(12, "Not enough core");
-//         message_map.insert(13, "Permission denied");
-//         message_map.insert(14, "Bad address");
-//         message_map.insert(15, "Block device required");
-//         message_map.insert(16, "Mount device busy");
-//         message_map.insert(17, "File exists");
-//         message_map.insert(18, "Cross-device link");
-//         message_map.insert(19, "No such device");
-//         message_map.insert(20, "Not a directory");
-//         message_map.insert(21, "Is a directory");
-//         message_map.insert(22, "Invalid argument");
-//         message_map.insert(23, "Too many open files in system");
-//         message_map.insert(24, "Too many open files");
-//         message_map.insert(25, "Not a typewriter");
-//         message_map.insert(26, "Text file busy");
-//         message_map.insert(27, "File too large");
-//         message_map.insert(28, "No space left on device");
-//         message_map.insert(29, "Illegal seek");
-//         message_map.insert(30, "Read only file system");
-//         message_map.insert(31, "Too many links");
-//         message_map.insert(32, "Broken pipe");
-//         message_map.insert(33, "Math arg out of domain of func");
-//         message_map.insert(34, "Math result not representable");
-//         message_map.insert(35, "File locking deadlock error");
-//         message_map.insert(36, "File or path name too long");
-//         message_map.insert(37, "No record locks available");
-//         message_map.insert(38, "Function not implemented");
-//         message_map.insert(39, "Directory not empty");
-//         message_map.insert(40, "Too many symbolic links");
-//         message_map.insert(42, "No message of desired type");
-//         message_map.insert(43, "Identifier removed");
-//         message_map.insert(44, "Channel number out of range");
-//         message_map.insert(45, "Level 2 not synchronized");
-//         message_map.insert(46, "Level 3 halted");
-//         message_map.insert(47, "Level 3 reset");
-//         message_map.insert(48, "Link number out of range");
-//         message_map.insert(49, "Protocol driver not attached");
-//         message_map.insert(50, "No CSI structure available");
-//         message_map.insert(51, "Level 2 halted");
-//         message_map.insert(52, "Invalid exchange");
-//         message_map.insert(53, "Invalid request descriptor");
-//         message_map.insert(54, "Exchange full");
-//         message_map.insert(55, "No anode");
-//         message_map.insert(56, "Invalid request code");
-//         message_map.insert(57, "Invalid slot");
-//         message_map.insert(59, "Bad font file fmt");
-//         message_map.insert(60, "Device not a stream");
-//         message_map.insert(61, "No data (for no delay io)");
-//         message_map.insert(62, "Timer expired");
-//         message_map.insert(63, "Out of streams resources");
-//         message_map.insert(64, "Machine is not on the network");
-//         message_map.insert(65, "Package not installed");
-//         message_map.insert(66, "The object is remote");
-//         message_map.insert(67, "The link has been severed");
-//         message_map.insert(68, "Advertise error");
-//         message_map.insert(69, "Srmount error");
-//         message_map.insert(70, "Communication error on send");
-//         message_map.insert(71, "Protocol error");
-//         message_map.insert(72, "Multihop attempted");
-//         message_map.insert(73, "Cross mount point (not really error)");
-//         message_map.insert(74, "Trying to read unreadable message");
-//         message_map.insert(75, "Value too large for defined data type");
-//         message_map.insert(76, "Given log. name not unique");
-//         message_map.insert(77, "f.d. invalid for this operation");
-//         message_map.insert(78, "Remote address changed");
-//         message_map.insert(79, "Can   access a needed shared lib");
-//         message_map.insert(80, "Accessing a corrupted shared lib");
-//         message_map.insert(81, ".lib section in a.out corrupted");
-//         message_map.insert(82, "Attempting to link in too many libs");
-//         message_map.insert(83, "Attempting to exec a shared library");
-//         message_map.insert(84, "Illegal byte sequence");
-//         message_map.insert(86, "Streams pipe error");
-//         message_map.insert(87, "Too many users");
-//         message_map.insert(88, "Socket operation on non-socket");
-//         message_map.insert(89, "Destination address required");
-//         message_map.insert(90, "Message too long");
-//         message_map.insert(91, "Protocol wrong type for socket");
-//         message_map.insert(92, "Protocol not available");
-//         message_map.insert(93, "Unknown protocol");
-//         message_map.insert(94, "Socket type not supported");
-//         message_map.insert(95, "Not supported");
-//         message_map.insert(96, "Protocol family not supported");
-//         message_map.insert(97, "Address family not supported by protocol family");
-//         message_map.insert(98, "Address already in use");
-//         message_map.insert(99, "Address not available");
-//         message_map.insert(100, "Network interface is not configured");
-//         message_map.insert(101, "Network is unreachable");
-//         message_map.insert(102, "Connection reset by network");
-//         message_map.insert(103, "Connection aborted");
-//         message_map.insert(104, "Connection reset by peer");
-//         message_map.insert(105, "No buffer space available");
-//         message_map.insert(106, "Socket is already connected");
-//         message_map.insert(107, "Socket is not connected");
-//         message_map.insert(108, "Can't send after socket shutdown");
-//         message_map.insert(109, "Too many references");
-//         message_map.insert(110, "Connection timed out");
-//         message_map.insert(111, "Connection refused");
-//         message_map.insert(112, "Host is down");
-//         message_map.insert(113, "Host is unreachable");
-//         message_map.insert(114, "Socket already connected");
-//         message_map.insert(115, "Connection already in progress");
-//         message_map.insert(116, "Stale file handle");
-//         message_map.insert(122, "Quota exceeded");
-//         message_map.insert(123, "No medium (in tape drive)");
-//         message_map.insert(125, "Operation canceled");
-//         message_map.insert(130, "Previous owner died");
-//         message_map.insert(131, "State not recoverable");
-
-//         ErrnoMessages {
-//             message_map,
-//         }
-//     }
-// }
diff --git a/lib/emscripten/src/exception.rs b/lib/emscripten/src/exception.rs
deleted file mode 100644
index c3c8353d4a..0000000000
--- a/lib/emscripten/src/exception.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-use super::env;
-use super::process::_abort;
-use crate::EmEnv;
-use wasmer::FunctionEnvMut;
-
-/// emscripten: ___cxa_allocate_exception
-pub fn ___cxa_allocate_exception(mut ctx: FunctionEnvMut<EmEnv>, size: u32) -> u32 {
-    debug!("emscripten::___cxa_allocate_exception");
-    env::call_malloc(&mut ctx.as_mut(), size as _)
-}
-
-pub fn ___cxa_current_primary_exception(_ctx: FunctionEnvMut<EmEnv>) -> u32 {
-    debug!("emscripten::___cxa_current_primary_exception");
-    unimplemented!("emscripten::___cxa_current_primary_exception")
-}
-
-pub fn ___cxa_decrement_exception_refcount(_ctx: FunctionEnvMut<EmEnv>, _a: u32) {
-    debug!("emscripten::___cxa_decrement_exception_refcount({})", _a);
-    unimplemented!("emscripten::___cxa_decrement_exception_refcount({})", _a)
-}
-
-pub fn ___cxa_increment_exception_refcount(_ctx: FunctionEnvMut<EmEnv>, _a: u32) {
-    debug!("emscripten::___cxa_increment_exception_refcount({})", _a);
-    unimplemented!("emscripten::___cxa_increment_exception_refcount({})", _a)
-}
-
-pub fn ___cxa_rethrow_primary_exception(_ctx: FunctionEnvMut<EmEnv>, _a: u32) {
-    debug!("emscripten::___cxa_rethrow_primary_exception({})", _a);
-    unimplemented!("emscripten::___cxa_rethrow_primary_exception({})", _a)
-}
-
-/// emscripten: ___cxa_throw
-/// TODO: We don't have support for exceptions yet
-pub fn ___cxa_throw(ctx: FunctionEnvMut<EmEnv>, _ptr: u32, _ty: u32, _destructor: u32) {
-    debug!("emscripten::___cxa_throw");
-    eprintln!("Throwing exceptions not yet implemented: aborting!");
-    _abort(ctx);
-}
-
-pub fn ___cxa_begin_catch(_ctx: FunctionEnvMut<EmEnv>, _exception_object_ptr: u32) -> i32 {
-    debug!("emscripten::___cxa_begin_catch");
-    -1
-}
-
-pub fn ___cxa_end_catch(_ctx: FunctionEnvMut<EmEnv>) {
-    debug!("emscripten::___cxa_end_catch");
-}
-
-pub fn ___cxa_uncaught_exception(_ctx: FunctionEnvMut<EmEnv>) -> i32 {
-    debug!("emscripten::___cxa_uncaught_exception");
-    -1
-}
-
-pub fn ___cxa_pure_virtual(_ctx: FunctionEnvMut<EmEnv>) {
-    debug!("emscripten::___cxa_pure_virtual");
-    // ABORT = true
-    panic!("Pure virtual function called!");
-}
diff --git a/lib/emscripten/src/exec.rs b/lib/emscripten/src/exec.rs
deleted file mode 100644
index 8fe4486315..0000000000
--- a/lib/emscripten/src/exec.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-use crate::varargs::VarArgs;
-use crate::EmEnv;
-use libc::c_char;
-use libc::execvp as libc_execvp;
-use std::ffi::CString;
-use wasmer::{FunctionEnvMut, WasmPtr};
-
-pub fn execvp(ctx: FunctionEnvMut<EmEnv>, command_name_offset: u32, argv_offset: u32) -> i32 {
-    // a single reference to re-use
-    let memory = ctx.data().memory(0);
-    let emscripten_memory = memory.view(&ctx);
-
-    // read command name as string
-    let command_name_string_vec = WasmPtr::<u8>::new(command_name_offset)
-        .read_until(&emscripten_memory, |&byte| byte == 0)
-        .unwrap();
-    let command_name_string = CString::new(command_name_string_vec).unwrap();
-
-    // get the array of args
-    let argv = WasmPtr::<WasmPtr<u8>>::new(argv_offset)
-        .read_until(&emscripten_memory, |&ptr| ptr.is_null())
-        .unwrap();
-    let arg_strings: Vec<CString> = argv
-        .into_iter()
-        .map(|ptr| {
-            let vec = ptr
-                .read_until(&emscripten_memory, |&byte| byte == 0)
-                .unwrap();
-            CString::new(vec).unwrap()
-        })
-        .collect();
-    let mut argv: Vec<*const c_char> = arg_strings.iter().map(|s| s.as_ptr()).collect();
-
-    // push a nullptr on to the end of the args array
-    argv.push(std::ptr::null());
-
-    // construct raw pointers and hand them to `execvp`
-    let command_pointer = command_name_string.as_ptr() as *const i8;
-    let args_pointer = argv.as_ptr();
-    unsafe { libc_execvp(command_pointer as *const _, args_pointer as *const *const _) }
-}
-
-/// execl
-pub fn execl(
-    _ctx: FunctionEnvMut<EmEnv>,
-    _path_ptr: i32,
-    _arg0_ptr: i32,
-    _varargs: VarArgs,
-) -> i32 {
-    debug!("emscripten::execl");
-    -1
-}
-
-/// execle
-pub fn execle(
-    _ctx: FunctionEnvMut<EmEnv>,
-    _path_ptr: i32,
-    _arg0_ptr: i32,
-    _varargs: VarArgs,
-) -> i32 {
-    debug!("emscripten::execle");
-    -1
-}
diff --git a/lib/emscripten/src/exit.rs b/lib/emscripten/src/exit.rs
deleted file mode 100644
index 907bb66c3c..0000000000
--- a/lib/emscripten/src/exit.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-use crate::EmEnv;
-use wasmer::FunctionEnvMut;
-
-// __exit
-pub fn exit(mut _ctx: FunctionEnvMut<EmEnv>, value: i32) {
-    debug!("emscripten::exit {}", value);
-    ::std::process::exit(value);
-}
diff --git a/lib/emscripten/src/inet.rs b/lib/emscripten/src/inet.rs
deleted file mode 100644
index 863a6bc2c8..0000000000
--- a/lib/emscripten/src/inet.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-use crate::EmEnv;
-use wasmer::FunctionEnvMut;
-
-pub fn addr(mut _ctx: FunctionEnvMut<EmEnv>, _cp: i32) -> i32 {
-    debug!("inet::addr({})", _cp);
-    0
-}
diff --git a/lib/emscripten/src/io/mod.rs b/lib/emscripten/src/io/mod.rs
deleted file mode 100644
index 36828428da..0000000000
--- a/lib/emscripten/src/io/mod.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-#[cfg(unix)]
-mod unix;
-
-#[cfg(windows)]
-mod windows;
-
-#[cfg(unix)]
-pub use self::unix::*;
-
-#[cfg(windows)]
-pub use self::windows::*;
-
-use crate::EmEnv;
-use wasmer::FunctionEnvMut;
-
-/// getprotobyname
-pub fn getprotobyname(_ctx: FunctionEnvMut<EmEnv>, _name_ptr: i32) -> i32 {
-    debug!("emscripten::getprotobyname");
-    unimplemented!("emscripten::getprotobyname")
-}
-
-/// getprotobynumber
-pub fn getprotobynumber(_ctx: FunctionEnvMut<EmEnv>, _one: i32) -> i32 {
-    debug!("emscripten::getprotobynumber");
-    unimplemented!("emscripten::getprotobynumber")
-}
-
-/// sigdelset
-pub fn sigdelset(ctx: FunctionEnvMut<EmEnv>, set: i32, signum: i32) -> i32 {
-    debug!("emscripten::sigdelset");
-    let memory = ctx.data().memory(0);
-    let view = memory.view(&ctx);
-    #[allow(clippy::cast_ptr_alignment)]
-    let ptr = emscripten_memory_pointer!(&view, set) as *mut i32;
-
-    unsafe { *ptr &= !(1 << (signum - 1)) }
-
-    0
-}
-
-/// sigfillset
-pub fn sigfillset(ctx: FunctionEnvMut<EmEnv>, set: i32) -> i32 {
-    debug!("emscripten::sigfillset");
-    let memory = ctx.data().memory(0);
-    let view = memory.view(&ctx);
-    #[allow(clippy::cast_ptr_alignment)]
-    let ptr = emscripten_memory_pointer!(&view, set) as *mut i32;
-
-    unsafe {
-        *ptr = -1;
-    }
-
-    0
-}
-
-/// tzset
-pub fn tzset(_ctx: FunctionEnvMut<EmEnv>) {
-    debug!("emscripten::tzset - stub");
-    //unimplemented!("emscripten::tzset - stub")
-}
-
-/// strptime
-pub fn strptime(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32, _three: i32) -> i32 {
-    debug!("emscripten::strptime");
-    unimplemented!("emscripten::strptime")
-}
diff --git a/lib/emscripten/src/io/unix.rs b/lib/emscripten/src/io/unix.rs
deleted file mode 100644
index 52d13d2038..0000000000
--- a/lib/emscripten/src/io/unix.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-use super::super::env::call_malloc;
-use super::super::utils::copy_cstr_into_wasm;
-use libc::{chroot as _chroot, getpwuid as _getpwuid, printf as _printf};
-use std::mem;
-
-use crate::EmEnv;
-use wasmer::FunctionEnvMut;
-
-/// putchar
-pub fn putchar(_ctx: FunctionEnvMut<EmEnv>, chr: i32) {
-    unsafe { libc::putchar(chr) };
-}
-
-/// printf
-pub fn printf(ctx: FunctionEnvMut<EmEnv>, memory_offset: i32, extra: i32) -> i32 {
-    debug!("emscripten::printf {}, {}", memory_offset, extra);
-    unsafe {
-        let addr = emscripten_memory_pointer!(ctx.data().memory(0).view(&ctx), memory_offset) as _;
-        _printf(addr, extra)
-    }
-}
-
-/// chroot
-pub fn chroot(ctx: FunctionEnvMut<EmEnv>, name_ptr: i32) -> i32 {
-    debug!("emscripten::chroot");
-    let name = emscripten_memory_pointer!(ctx.data().memory(0).view(&ctx), name_ptr) as *const i8;
-    unsafe { _chroot(name as *const _) }
-}
-
-/// getpwuid
-#[allow(clippy::cast_ptr_alignment)]
-pub fn getpwuid(mut ctx: FunctionEnvMut<EmEnv>, uid: i32) -> i32 {
-    debug!("emscripten::getpwuid {}", uid);
-
-    #[repr(C)]
-    struct GuestPasswd {
-        pw_name: u32,
-        pw_passwd: u32,
-        pw_uid: u32,
-        pw_gid: u32,
-        pw_gecos: u32,
-        pw_dir: u32,
-        pw_shell: u32,
-    }
-
-    unsafe {
-        let passwd = &*_getpwuid(uid as _);
-        let passwd_struct_offset = call_malloc(&mut ctx, mem::size_of::<GuestPasswd>() as _);
-        let passwd_struct_ptr =
-            emscripten_memory_pointer!(ctx.data().memory(0).view(&ctx), passwd_struct_offset)
-                as *mut GuestPasswd;
-        assert_eq!(
-            passwd_struct_ptr as usize % std::mem::align_of::<GuestPasswd>(),
-            0
-        );
-        (*passwd_struct_ptr).pw_name = copy_cstr_into_wasm(&mut ctx, passwd.pw_name);
-        (*passwd_struct_ptr).pw_passwd = copy_cstr_into_wasm(&mut ctx, passwd.pw_passwd);
-        (*passwd_struct_ptr).pw_gecos = copy_cstr_into_wasm(&mut ctx, passwd.pw_gecos);
-        (*passwd_struct_ptr).pw_dir = copy_cstr_into_wasm(&mut ctx, passwd.pw_dir);
-        (*passwd_struct_ptr).pw_shell = copy_cstr_into_wasm(&mut ctx, passwd.pw_shell);
-        (*passwd_struct_ptr).pw_uid = passwd.pw_uid;
-        (*passwd_struct_ptr).pw_gid = passwd.pw_gid;
-
-        passwd_struct_offset as _
-    }
-    // unsafe { _getpwuid(uid as _) as _}
-    // 0
-}
diff --git a/lib/emscripten/src/io/windows.rs b/lib/emscripten/src/io/windows.rs
deleted file mode 100644
index c9b00e575d..0000000000
--- a/lib/emscripten/src/io/windows.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-use crate::EmEnv;
-use wasmer::FunctionEnvMut;
-
-// This may be problematic for msvc which uses inline functions for the printf family
-// this cfg_attr will try to link with the legacy lib that does not inline printf
-// this will allow for compiliation, but will produce a linker error if there is a problem
-// finding printf.
-//#[cfg_attr(
-//    all(windows, target_env = "msvc"),
-//    link(name = "legacy_stdio_definitions", kind = "static-nobundle")
-//)]
-//extern "C" {
-//    #[link_name = "printf"]
-//    pub fn _printf(s: *const c_char, ...) -> c_int;
-//}
-
-/// putchar
-pub fn putchar(_ctx: FunctionEnvMut<EmEnv>, chr: i32) {
-    unsafe { libc::putchar(chr) };
-}
-
-/// printf
-pub fn printf(_ctx: FunctionEnvMut<EmEnv>, memory_offset: i32, extra: i32) -> i32 {
-    debug!("emscripten::printf {}, {}", memory_offset, extra);
-    #[cfg(not(feature = "debug"))]
-    {
-        let _ = memory_offset;
-        let _ = extra;
-    }
-    //    unsafe {
-    //        let addr = emscripten_memory_pointer!(ctx.memory(0), memory_offset) as _;
-    //        _printf(addr, extra)
-    //    }
-    -1
-}
-
-/// chroot
-pub fn chroot(_ctx: FunctionEnvMut<EmEnv>, _name_ptr: i32) -> i32 {
-    debug!("emscripten::chroot");
-    unimplemented!("emscripten::chroot")
-}
-
-/// getpwuid
-pub fn getpwuid(_ctx: FunctionEnvMut<EmEnv>, _uid: i32) -> i32 {
-    debug!("emscripten::getpwuid");
-    unimplemented!("emscripten::getpwuid")
-}
diff --git a/lib/emscripten/src/jmp.rs b/lib/emscripten/src/jmp.rs
deleted file mode 100644
index 903a472078..0000000000
--- a/lib/emscripten/src/jmp.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-use super::env::get_emscripten_funcs;
-use super::process::abort_with_message;
-use libc::c_int;
-// use std::cell::UnsafeCell;
-use crate::EmEnv;
-use std::error::Error;
-use std::fmt;
-use wasmer::FunctionEnvMut;
-
-/// setjmp
-pub fn __setjmp(ctx: FunctionEnvMut<EmEnv>, _env_addr: u32) -> c_int {
-    debug!("emscripten::__setjmp (setjmp)");
-    abort_with_message(ctx, "missing function: _setjmp");
-    unreachable!()
-    // unsafe {
-    //     // Rather than using the env as the holder of the jump buffer pointer,
-    //     // we use the environment address to store the index relative to jumps
-    //     // so the address of the jump it's outside the wasm memory itself.
-    //     let jump_index = emscripten_memory_pointer!(ctx.memory(0), env_addr) as *mut i8;
-    //     // We create the jump buffer outside of the wasm memory
-    //     let jump_buf: UnsafeCell<[u32; 27]> = UnsafeCell::new([0; 27]);
-    //     let jumps = &mut get_emscripten_data(&ctx).jumps;
-    //     let result = setjmp(jump_buf.get() as _);
-    //     // We set the jump index to be the last 3value of jumps
-    //     *jump_index = jumps.len() as _;
-    //     // We hold the reference of the jump buffer
-    //     jumps.push(jump_buf);
-    //     result
-    // }
-}
-
-/// longjmp
-#[allow(unreachable_code)]
-pub fn __longjmp(ctx: FunctionEnvMut<EmEnv>, _env_addr: u32, _val: c_int) {
-    debug!("emscripten::__longjmp (longmp)");
-    abort_with_message(ctx, "missing function: _longjmp");
-    // unsafe {
-    //     // We retrieve the jump index from the env address
-    //     let jump_index = emscripten_memory_pointer!(ctx.memory(0), env_addr) as *mut i8;
-    //     let jumps = &mut get_emscripten_data(&ctx).jumps;
-    //     // We get the real jump buffer from the jumps vector, using the retrieved index
-    //     let jump_buf = &jumps[*jump_index as usize];
-    //     longjmp(jump_buf.get() as _, val)
-    // };
-}
-
-#[derive(Copy, Clone, Debug)]
-pub struct LongJumpRet;
-
-impl fmt::Display for LongJumpRet {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "LongJumpRet")
-    }
-}
-
-impl Error for LongJumpRet {}
-
-/// _longjmp
-// This function differs from the js implementation, it should return Result<(), &'static str>
-#[allow(unreachable_code)]
-pub fn _longjmp(
-    mut ctx: FunctionEnvMut<EmEnv>,
-    env_addr: i32,
-    val: c_int,
-) -> Result<(), LongJumpRet> {
-    let val = if val == 0 { 1 } else { val };
-    let threw = get_emscripten_funcs(&ctx)
-        .set_threw_ref()
-        .expect("set_threw is None")
-        .clone();
-    threw
-        .call(&mut ctx, env_addr, val)
-        .expect("set_threw failed to call");
-    Err(LongJumpRet)
-}
-
-// extern "C" {
-//     fn setjmp(env: *mut c_void) -> c_int;
-//     fn longjmp(env: *mut c_void, val: c_int) -> !;
-// }
diff --git a/lib/emscripten/src/lib.rs b/lib/emscripten/src/lib.rs
deleted file mode 100644
index 3a3e644623..0000000000
--- a/lib/emscripten/src/lib.rs
+++ /dev/null
@@ -1,1570 +0,0 @@
-#![deny(
-    dead_code,
-    nonstandard_style,
-    unused_imports,
-    unused_mut,
-    unused_variables,
-    unused_unsafe,
-    unreachable_patterns
-)]
-// This allow attribute is ignored when placed directly on fields that also
-// have a #[wasmer(...)] attribute. As a dirty workaround it is for now
-// allowed for the whole library.
-#![allow(clippy::type_complexity, clippy::unnecessary_cast)]
-#![doc(html_favicon_url = "https://wasmer.io/images/icons/favicon-32x32.png")]
-#![doc(html_logo_url = "https://github.com/wasmerio.png?size=200")]
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
-
-#[macro_use]
-extern crate log;
-
-use lazy_static::lazy_static;
-use std::collections::HashMap;
-use std::f64;
-use std::path::PathBuf;
-use std::sync::{Arc, Mutex, RwLock};
-use wasmer::{
-    imports, namespace, AsStoreMut, AsStoreRef, ExportError, Exports, Function, FunctionEnv,
-    FunctionEnvMut, FunctionType, Global, Imports, Instance, Memory, MemoryType, Module, Pages,
-    RuntimeError, Table, TableType, TypedFunction, Value, WasmPtr,
-};
-use wasmer_types::Type as ValType;
-
-#[cfg(unix)]
-extern crate libc as libc_crate;
-#[cfg(unix)]
-use libc_crate::DIR as LibcDir;
-
-// We use a placeholder for windows
-#[cfg(not(unix))]
-type LibcDir = u8;
-
-#[macro_use]
-mod macros;
-
-// EMSCRIPTEN APIS
-mod bitwise;
-mod emscripten_target;
-mod env;
-mod errno;
-mod exception;
-mod exec;
-mod exit;
-mod inet;
-mod io;
-mod jmp;
-mod libc;
-mod linking;
-mod lock;
-mod math;
-mod memory;
-mod process;
-mod pthread;
-mod signal;
-mod storage;
-mod syscalls;
-mod time;
-mod ucontext;
-mod unistd;
-mod utils;
-mod varargs;
-
-pub use self::storage::{align_memory, static_alloc};
-pub use self::utils::{
-    allocate_cstr_on_stack, allocate_on_stack, get_emscripten_memory_size, get_emscripten_metadata,
-    get_emscripten_table_size, is_emscripten_module,
-};
-
-/// State of the emscripten environment (environment variables, CLI args)
-#[derive(Debug, Clone)]
-pub struct EmscriptenState {
-    /// Environment variables in a [key -> value] mapping
-    pub env_vars: HashMap<String, String>,
-    /// Command line arguments that this module received
-    pub cli_args: Vec<String>,
-}
-
-impl Default for EmscriptenState {
-    fn default() -> Self {
-        Self {
-            env_vars: std::env::vars_os()
-                .filter_map(|(k, v)| Some((k.to_str()?.to_string(), v.to_str()?.to_string())))
-                .collect(),
-            cli_args: Vec::new(),
-        }
-    }
-}
-
-#[derive(Clone)]
-/// The environment provided to the Emscripten imports.
-pub struct EmEnv {
-    memory: Arc<RwLock<Option<Memory>>>,
-    data: Arc<Mutex<Option<EmscriptenData>>>,
-    funcs: Arc<Mutex<EmscriptenFunctions>>,
-    // State that is passed to the wasm module (environment variables, CLI args, ...)
-    #[allow(dead_code)]
-    state: Arc<Mutex<EmscriptenState>>,
-}
-
-impl Default for EmEnv {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl EmEnv {
-    /// Create a new EmEnv, with default value to be set later (set_memory, set_functions and set_data)
-    pub fn new() -> Self {
-        Self {
-            memory: Arc::new(RwLock::new(None)),
-            data: Arc::new(Mutex::new(None)),
-            funcs: Arc::new(Mutex::new(EmscriptenFunctions::new())),
-            state: Arc::new(Mutex::new(EmscriptenState::default())),
-        }
-    }
-
-    pub fn new_with_state(emstate: EmscriptenState) -> Self {
-        Self {
-            memory: Arc::new(RwLock::new(None)),
-            data: Arc::new(Mutex::new(None)),
-            funcs: Arc::new(Mutex::new(EmscriptenFunctions::new())),
-            state: Arc::new(Mutex::new(emstate)),
-        }
-    }
-
-    pub fn set_memory(&self, memory: Memory) {
-        let mut w = self.memory.write().unwrap();
-        *w = Some(memory);
-    }
-
-    /// Get a reference to the memory
-    pub fn memory(&self, _mem_idx: u32) -> Memory {
-        (*self.memory.read().unwrap()).as_ref().cloned().unwrap()
-    }
-
-    pub fn set_functions(&self, funcs: EmscriptenFunctions) {
-        let mut w = self.funcs.lock().unwrap();
-        *w = funcs;
-    }
-
-    pub fn set_data(&self, data: &EmscriptenGlobalsData, mapped_dirs: HashMap<String, PathBuf>) {
-        let mut w = self.data.lock().unwrap();
-        *w = Some(EmscriptenData::new(data.clone(), mapped_dirs));
-    }
-
-    pub fn get_env_var(&self, key: &str) -> Option<String> {
-        let w = self.state.lock().ok()?;
-        let result = w.env_vars.get(key).cloned();
-        result
-    }
-
-    pub fn get_env_vars_len(&self) -> usize {
-        let w = self.state.lock().unwrap();
-        w.env_vars.len()
-    }
-
-    pub fn set_env_var(&self, key: &str, value: &str) -> Option<String> {
-        let mut w = self.state.lock().ok()?;
-        w.env_vars.insert(key.to_string(), value.to_string())
-    }
-
-    pub fn remove_env_var(&self, key: &str) -> Option<String> {
-        let mut w = self.state.lock().ok()?;
-        w.env_vars.remove(key)
-    }
-
-    pub fn get_args_size(&self) -> usize {
-        let w = self.state.lock().unwrap();
-        w.cli_args.len()
-    }
-
-    pub fn get_args(&self) -> Vec<String> {
-        let w = self.state.lock().unwrap();
-        w.cli_args.clone()
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct LibcDirWrapper(pub *mut LibcDir);
-
-impl std::ops::Deref for LibcDirWrapper {
-    type Target = *mut LibcDir;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-unsafe impl Send for LibcDirWrapper {}
-unsafe impl Sync for LibcDirWrapper {}
-
-// TODO: Magic number - how is this calculated?
-const TOTAL_STACK: u32 = 5_242_880;
-// TODO: make this variable
-const STATIC_BUMP: u32 = 215_536;
-
-lazy_static! {
-    static ref OLD_ABORT_ON_CANNOT_GROW_MEMORY_SIG: FunctionType =
-        FunctionType::new(vec![], vec![ValType::I32]);
-}
-
-// The address globals begin at. Very low in memory, for code size and optimization opportunities.
-// Above 0 is static memory, starting with globals.
-// Then the stack.
-// Then 'dynamic' memory for sbrk.
-const GLOBAL_BASE: u32 = 1024;
-const STATIC_BASE: u32 = GLOBAL_BASE;
-
-#[derive(Clone, Default)]
-pub struct EmscriptenFunctions {
-    pub malloc: Option<TypedFunction<u32, u32>>,
-    pub free: Option<TypedFunction<u32, ()>>,
-    pub memalign: Option<TypedFunction<(u32, u32), u32>>,
-    pub memset: Option<TypedFunction<(u32, u32, u32), u32>>,
-    pub stack_alloc: Option<TypedFunction<u32, u32>>,
-
-    pub dyn_call_i: Option<TypedFunction<i32, i32>>,
-    pub dyn_call_ii: Option<TypedFunction<(i32, i32), i32>>,
-    pub dyn_call_iii: Option<TypedFunction<(i32, i32, i32), i32>>,
-    pub dyn_call_iiii: Option<TypedFunction<(i32, i32, i32, i32), i32>>,
-    pub dyn_call_iifi: Option<TypedFunction<(i32, i32, f64, i32), i32>>,
-    pub dyn_call_v: Option<TypedFunction<i32, ()>>,
-    pub dyn_call_vi: Option<TypedFunction<(i32, i32), ()>>,
-    pub dyn_call_vii: Option<TypedFunction<(i32, i32, i32), ()>>,
-    pub dyn_call_viii: Option<TypedFunction<(i32, i32, i32, i32), ()>>,
-    pub dyn_call_viiii: Option<TypedFunction<(i32, i32, i32, i32, i32), ()>>,
-
-    // round 2
-    pub dyn_call_dii: Option<TypedFunction<(i32, i32, i32), f64>>,
-    pub dyn_call_diiii: Option<TypedFunction<(i32, i32, i32, i32, i32), f64>>,
-    pub dyn_call_iiiii: Option<TypedFunction<(i32, i32, i32, i32, i32), i32>>,
-    pub dyn_call_iiiiii: Option<TypedFunction<(i32, i32, i32, i32, i32, i32), i32>>,
-    pub dyn_call_iiiiiii: Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32), i32>>,
-    pub dyn_call_iiiiiiii: Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32), i32>>,
-    pub dyn_call_iiiiiiiii:
-        Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32), i32>>,
-    pub dyn_call_iiiiiiiiii:
-        Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), i32>>,
-    pub dyn_call_iiiiiiiiiii:
-        Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), i32>>,
-    pub dyn_call_vd: Option<TypedFunction<(i32, f64), ()>>,
-    pub dyn_call_viiiii: Option<TypedFunction<(i32, i32, i32, i32, i32, i32), ()>>,
-    pub dyn_call_viiiiii: Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32), ()>>,
-    pub dyn_call_viiiiiii: Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32), ()>>,
-    pub dyn_call_viiiiiiii:
-        Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32), ()>>,
-    pub dyn_call_viiiiiiiii:
-        Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), ()>>,
-    pub dyn_call_viiiiiiiiii:
-        Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), ()>>,
-    pub dyn_call_iij: Option<TypedFunction<(i32, i32, i32, i32), i32>>,
-    pub dyn_call_iji: Option<TypedFunction<(i32, i32, i32, i32), i32>>,
-    pub dyn_call_iiji: Option<TypedFunction<(i32, i32, i32, i32, i32), i32>>,
-    pub dyn_call_iiijj: Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32), i32>>,
-    pub dyn_call_j: Option<TypedFunction<i32, i32>>,
-    pub dyn_call_ji: Option<TypedFunction<(i32, i32), i32>>,
-    pub dyn_call_jii: Option<TypedFunction<(i32, i32, i32), i32>>,
-    pub dyn_call_jij: Option<TypedFunction<(i32, i32, i32, i32), i32>>,
-    pub dyn_call_jjj: Option<TypedFunction<(i32, i32, i32, i32, i32), i32>>,
-    pub dyn_call_viiij: Option<TypedFunction<(i32, i32, i32, i32, i32, i32), ()>>,
-    pub dyn_call_viiijiiii:
-        Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), ()>>,
-    pub dyn_call_viiijiiiiii:
-        Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), ()>>,
-    pub dyn_call_viij: Option<TypedFunction<(i32, i32, i32, i32, i32), ()>>,
-    pub dyn_call_viiji: Option<TypedFunction<(i32, i32, i32, i32, i32, i32), ()>>,
-    pub dyn_call_viijiii: Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32), ()>>,
-    pub dyn_call_viijj: Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32), ()>>,
-    pub dyn_call_vj: Option<TypedFunction<(i32, i32, i32), ()>>,
-    pub dyn_call_vjji: Option<TypedFunction<(i32, i32, i32, i32, i32, i32), ()>>,
-    pub dyn_call_vij: Option<TypedFunction<(i32, i32, i32, i32), ()>>,
-    pub dyn_call_viji: Option<TypedFunction<(i32, i32, i32, i32, i32), ()>>,
-    pub dyn_call_vijiii: Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32), ()>>,
-    pub dyn_call_vijj: Option<TypedFunction<(i32, i32, i32, i32, i32, i32), ()>>,
-    pub dyn_call_viid: Option<TypedFunction<(i32, i32, i32, f64), ()>>,
-    pub dyn_call_vidd: Option<TypedFunction<(i32, i32, f64, f64), ()>>,
-    pub dyn_call_viidii: Option<TypedFunction<(i32, i32, i32, f64, i32, i32), ()>>,
-    pub dyn_call_viidddddddd:
-        Option<TypedFunction<(i32, i32, i32, f64, f64, f64, f64, f64, f64, f64, f64), ()>>,
-
-    pub stack_save: Option<TypedFunction<(), i32>>,
-    pub stack_restore: Option<TypedFunction<i32, ()>>,
-    pub set_threw: Option<TypedFunction<(i32, i32), ()>>,
-}
-
-#[derive(Clone, Default)]
-pub struct EmscriptenData {
-    pub globals: EmscriptenGlobalsData,
-
-    pub jumps: Arc<Mutex<Vec<[u32; 27]>>>,
-    pub opened_dirs: HashMap<i32, Box<LibcDirWrapper>>,
-
-    pub temp_ret_0: i32,
-
-    pub mapped_dirs: HashMap<String, PathBuf>,
-}
-
-impl EmscriptenData {
-    pub fn new(
-        globals: EmscriptenGlobalsData,
-        mapped_dirs: HashMap<String, PathBuf>,
-    ) -> EmscriptenData {
-        EmscriptenData {
-            globals,
-            temp_ret_0: 0,
-            mapped_dirs,
-            ..Default::default()
-        }
-    }
-}
-
-impl EmscriptenFunctions {
-    pub fn new() -> EmscriptenFunctions {
-        EmscriptenFunctions {
-            ..Default::default()
-        }
-    }
-    pub fn malloc_ref(&self) -> Option<&TypedFunction<u32, u32>> {
-        self.malloc.as_ref()
-    }
-    pub fn free_ref(&self) -> Option<&TypedFunction<u32, ()>> {
-        self.free.as_ref()
-    }
-    pub fn memalign_ref(&self) -> Option<&TypedFunction<(u32, u32), u32>> {
-        self.memalign.as_ref()
-    }
-    pub fn memset_ref(&self) -> Option<&TypedFunction<(u32, u32, u32), u32>> {
-        self.memset.as_ref()
-    }
-    pub fn stack_alloc_ref(&self) -> Option<&TypedFunction<u32, u32>> {
-        self.stack_alloc.as_ref()
-    }
-
-    pub fn dyn_call_i_ref(&self) -> Option<&TypedFunction<i32, i32>> {
-        self.dyn_call_i.as_ref()
-    }
-    pub fn dyn_call_ii_ref(&self) -> Option<&TypedFunction<(i32, i32), i32>> {
-        self.dyn_call_ii.as_ref()
-    }
-    pub fn dyn_call_iii_ref(&self) -> Option<&TypedFunction<(i32, i32, i32), i32>> {
-        self.dyn_call_iii.as_ref()
-    }
-    pub fn dyn_call_iiii_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32), i32>> {
-        self.dyn_call_iiii.as_ref()
-    }
-    pub fn dyn_call_iifi_ref(&self) -> Option<&TypedFunction<(i32, i32, f64, i32), i32>> {
-        self.dyn_call_iifi.as_ref()
-    }
-    pub fn dyn_call_v_ref(&self) -> Option<&TypedFunction<i32, ()>> {
-        self.dyn_call_v.as_ref()
-    }
-    pub fn dyn_call_vi_ref(&self) -> Option<&TypedFunction<(i32, i32), ()>> {
-        self.dyn_call_vi.as_ref()
-    }
-    pub fn dyn_call_vii_ref(&self) -> Option<&TypedFunction<(i32, i32, i32), ()>> {
-        self.dyn_call_vii.as_ref()
-    }
-    pub fn dyn_call_viii_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32), ()>> {
-        self.dyn_call_viii.as_ref()
-    }
-    pub fn dyn_call_viiii_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32, i32), ()>> {
-        self.dyn_call_viiii.as_ref()
-    }
-    pub fn dyn_call_dii_ref(&self) -> Option<&TypedFunction<(i32, i32, i32), f64>> {
-        self.dyn_call_dii.as_ref()
-    }
-    pub fn dyn_call_diiii_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32, i32), f64>> {
-        self.dyn_call_diiii.as_ref()
-    }
-    pub fn dyn_call_iiiii_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32, i32), i32>> {
-        self.dyn_call_iiiii.as_ref()
-    }
-    pub fn dyn_call_iiiiii_ref(
-        &self,
-    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32), i32>> {
-        self.dyn_call_iiiiii.as_ref()
-    }
-    pub fn dyn_call_iiiiiii_ref(
-        &self,
-    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32), i32>> {
-        self.dyn_call_iiiiiii.as_ref()
-    }
-    pub fn dyn_call_iiiiiiii_ref(
-        &self,
-    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32), i32>> {
-        self.dyn_call_iiiiiiii.as_ref()
-    }
-    pub fn dyn_call_iiiiiiiii_ref(
-        &self,
-    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32), i32>> {
-        self.dyn_call_iiiiiiiii.as_ref()
-    }
-    pub fn dyn_call_iiiiiiiiii_ref(
-        &self,
-    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), i32>> {
-        self.dyn_call_iiiiiiiiii.as_ref()
-    }
-    pub fn dyn_call_iiiiiiiiiii_ref(
-        &self,
-    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), i32>> {
-        self.dyn_call_iiiiiiiiiii.as_ref()
-    }
-    pub fn dyn_call_vd_ref(&self) -> Option<&TypedFunction<(i32, f64), ()>> {
-        self.dyn_call_vd.as_ref()
-    }
-    pub fn dyn_call_viiiii_ref(
-        &self,
-    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32), ()>> {
-        self.dyn_call_viiiii.as_ref()
-    }
-    pub fn dyn_call_viiiiii_ref(
-        &self,
-    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32), ()>> {
-        self.dyn_call_viiiiii.as_ref()
-    }
-    pub fn dyn_call_viiiiiii_ref(
-        &self,
-    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32), ()>> {
-        self.dyn_call_viiiiiii.as_ref()
-    }
-    pub fn dyn_call_viiiiiiii_ref(
-        &self,
-    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32), ()>> {
-        self.dyn_call_viiiiiiii.as_ref()
-    }
-    pub fn dyn_call_viiiiiiiii_ref(
-        &self,
-    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), ()>> {
-        self.dyn_call_viiiiiiiii.as_ref()
-    }
-    pub fn dyn_call_viiiiiiiiii_ref(
-        &self,
-    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), ()>> {
-        self.dyn_call_viiiiiiiiii.as_ref()
-    }
-    pub fn dyn_call_iij_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32), i32>> {
-        self.dyn_call_iij.as_ref()
-    }
-    pub fn dyn_call_iji_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32), i32>> {
-        self.dyn_call_iji.as_ref()
-    }
-    pub fn dyn_call_iiji_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32, i32), i32>> {
-        self.dyn_call_iiji.as_ref()
-    }
-    pub fn dyn_call_iiijj_ref(
-        &self,
-    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32), i32>> {
-        self.dyn_call_iiijj.as_ref()
-    }
-    pub fn dyn_call_j_ref(&self) -> Option<&TypedFunction<i32, i32>> {
-        self.dyn_call_j.as_ref()
-    }
-    pub fn dyn_call_ji_ref(&self) -> Option<&TypedFunction<(i32, i32), i32>> {
-        self.dyn_call_ji.as_ref()
-    }
-    pub fn dyn_call_jii_ref(&self) -> Option<&TypedFunction<(i32, i32, i32), i32>> {
-        self.dyn_call_jii.as_ref()
-    }
-    pub fn dyn_call_jij_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32), i32>> {
-        self.dyn_call_jij.as_ref()
-    }
-    pub fn dyn_call_jjj_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32, i32), i32>> {
-        self.dyn_call_jjj.as_ref()
-    }
-    pub fn dyn_call_viiij_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32), ()>> {
-        self.dyn_call_viiij.as_ref()
-    }
-    pub fn dyn_call_viiijiiii_ref(
-        &self,
-    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), ()>> {
-        self.dyn_call_viiijiiii.as_ref()
-    }
-    pub fn dyn_call_viiijiiiiii_ref(
-        &self,
-    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), ()>>
-    {
-        self.dyn_call_viiijiiiiii.as_ref()
-    }
-    pub fn dyn_call_viij_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32, i32), ()>> {
-        self.dyn_call_viij.as_ref()
-    }
-    pub fn dyn_call_viiji_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32), ()>> {
-        self.dyn_call_viiji.as_ref()
-    }
-    pub fn dyn_call_viijiii_ref(
-        &self,
-    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32), ()>> {
-        self.dyn_call_viijiii.as_ref()
-    }
-    pub fn dyn_call_viijj_ref(
-        &self,
-    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32), ()>> {
-        self.dyn_call_viijj.as_ref()
-    }
-    pub fn dyn_call_vj_ref(&self) -> Option<&TypedFunction<(i32, i32, i32), ()>> {
-        self.dyn_call_vj.as_ref()
-    }
-    pub fn dyn_call_vjji_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32), ()>> {
-        self.dyn_call_vjji.as_ref()
-    }
-    pub fn dyn_call_vij_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32), ()>> {
-        self.dyn_call_vij.as_ref()
-    }
-    pub fn dyn_call_viji_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32, i32), ()>> {
-        self.dyn_call_viji.as_ref()
-    }
-    pub fn dyn_call_vijiii_ref(
-        &self,
-    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32), ()>> {
-        self.dyn_call_vijiii.as_ref()
-    }
-    pub fn dyn_call_vijj_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32), ()>> {
-        self.dyn_call_vijj.as_ref()
-    }
-    pub fn dyn_call_viid_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, f64), ()>> {
-        self.dyn_call_viid.as_ref()
-    }
-    pub fn dyn_call_vidd_ref(&self) -> Option<&TypedFunction<(i32, i32, f64, f64), ()>> {
-        self.dyn_call_vidd.as_ref()
-    }
-    pub fn dyn_call_viidii_ref(
-        &self,
-    ) -> Option<&TypedFunction<(i32, i32, i32, f64, i32, i32), ()>> {
-        self.dyn_call_viidii.as_ref()
-    }
-    pub fn dyn_call_viidddddddd_ref(
-        &self,
-    ) -> Option<&TypedFunction<(i32, i32, i32, f64, f64, f64, f64, f64, f64, f64, f64), ()>> {
-        self.dyn_call_viidddddddd.as_ref()
-    }
-
-    pub fn stack_save_ref(&self) -> Option<&TypedFunction<(), i32>> {
-        self.stack_save.as_ref()
-    }
-    pub fn stack_restore_ref(&self) -> Option<&TypedFunction<i32, ()>> {
-        self.stack_restore.as_ref()
-    }
-    pub fn set_threw_ref(&self) -> Option<&TypedFunction<(i32, i32), ()>> {
-        self.set_threw.as_ref()
-    }
-}
-
-/// Call the global constructors for C++ and set up the emscripten environment.
-///
-/// Note that this function does not completely set up Emscripten to be called.
-/// before calling this function, please initialize `Ctx::data` with a pointer
-/// to [`EmscriptenData`].
-pub fn set_up_emscripten(
-    store: &mut impl AsStoreMut,
-    instance: &mut Instance,
-) -> Result<(), RuntimeError> {
-    // ATINIT
-    // (used by C++)
-    if let Ok(func) = instance.exports.get_function("globalCtors") {
-        func.call(store, &[])?;
-    }
-
-    if let Ok(func) = instance
-        .exports
-        .get_function("___emscripten_environ_constructor")
-    {
-        func.call(store, &[])?;
-    }
-    Ok(())
-}
-
-/// Looks for variations of the main function (usually
-/// `["_main", "main"])`, then returns a reference to
-/// the name of the first found function. Useful for
-/// determining whether a module is executable.
-///
-/// Returns `ExportError` if none of the `main_func_names`
-/// were found.
-pub fn emscripten_get_main_func_name<'a>(
-    instance: &Instance,
-    main_func_names: &[&'a str],
-) -> Result<&'a str, ExportError> {
-    let mut last_err = None;
-
-    for func_name in main_func_names.iter() {
-        match instance.exports.get::<Function>(func_name) {
-            Ok(_) => {
-                return Ok(func_name);
-            }
-            Err(e) => {
-                last_err = Some(e);
-            }
-        }
-    }
-
-    match last_err {
-        None => Err(ExportError::Missing(format!("{main_func_names:?}"))),
-        Some(e) => Err(e),
-    }
-}
-
-/// Call the main function in emscripten, assumes that the emscripten state is
-/// set up.
-///
-/// If you don't want to set it up yourself, consider using [`run_emscripten_instance`].
-pub fn emscripten_call_main(
-    instance: &mut Instance,
-    function_name: &str,
-    mut env: FunctionEnvMut<EmEnv>,
-    path: &str,
-    args: &[&str],
-) -> Result<(), RuntimeError> {
-    let main_func = instance
-        .exports
-        .get::<Function>(function_name)
-        .map_err(|e| RuntimeError::new(e.to_string()))?;
-    let num_params = main_func.ty(&env).params().len();
-    match num_params {
-        2 => {
-            let mut new_args = vec![path];
-            new_args.extend(args);
-            let (argc, argv) = store_module_arguments(&mut env, new_args);
-            let func: &Function = instance
-                .exports
-                .get(function_name)
-                .map_err(|e| RuntimeError::new(e.to_string()))?;
-            func.call(
-                &mut env,
-                &[Value::I32(argc as i32), Value::I32(argv as i32)],
-            )?;
-        }
-        0 => {
-            let func: &Function = instance
-                .exports
-                .get(function_name)
-                .map_err(|e| RuntimeError::new(e.to_string()))?;
-            func.call(&mut env, &[])?;
-        }
-        _ => {
-            todo!("Update error type to be able to express this");
-            /*return Err(RuntimeError:: CallError::Resolve(ResolveError::ExportWrongType {
-                name: "main".to_string(),
-            }))*/
-        }
-    };
-
-    Ok(())
-}
-
-/// Top level function to execute emscripten
-pub fn run_emscripten_instance(
-    instance: &mut Instance,
-    mut env: FunctionEnvMut<EmEnv>,
-    globals: &mut EmscriptenGlobals,
-    path: &str,
-    args: Vec<&str>,
-    entrypoint: Option<String>,
-) -> Result<(), RuntimeError> {
-    env.data_mut().set_memory(globals.memory.clone());
-
-    // get emscripten export
-    let mut emfuncs = EmscriptenFunctions::new();
-    if let Ok(func) = instance.exports.get_typed_function(&env, "malloc") {
-        emfuncs.malloc = Some(func);
-    } else if let Ok(func) = instance.exports.get_typed_function(&env, "_malloc") {
-        emfuncs.malloc = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "free") {
-        emfuncs.free = Some(func);
-    } else if let Ok(func) = instance.exports.get_typed_function(&env, "_free") {
-        emfuncs.free = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "memalign") {
-        emfuncs.memalign = Some(func);
-    } else if let Ok(func) = instance.exports.get_typed_function(&env, "_memalign") {
-        emfuncs.memalign = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "memset") {
-        emfuncs.memset = Some(func);
-    } else if let Ok(func) = instance.exports.get_typed_function(&env, "_memset") {
-        emfuncs.memset = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "stackAlloc") {
-        emfuncs.stack_alloc = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_i") {
-        emfuncs.dyn_call_i = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_ii") {
-        emfuncs.dyn_call_ii = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_iii") {
-        emfuncs.dyn_call_iii = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_iiii") {
-        emfuncs.dyn_call_iiii = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_iifi") {
-        emfuncs.dyn_call_iifi = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_v") {
-        emfuncs.dyn_call_v = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_vi") {
-        emfuncs.dyn_call_vi = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_vii") {
-        emfuncs.dyn_call_vii = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viii") {
-        emfuncs.dyn_call_viii = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viiii") {
-        emfuncs.dyn_call_viiii = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_dii") {
-        emfuncs.dyn_call_dii = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_diiii") {
-        emfuncs.dyn_call_diiii = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_iiiii") {
-        emfuncs.dyn_call_iiiii = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_iiiiii") {
-        emfuncs.dyn_call_iiiiii = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_iiiiiii") {
-        emfuncs.dyn_call_iiiiiii = Some(func);
-    }
-    if let Ok(func) = instance
-        .exports
-        .get_typed_function(&env, "dynCall_iiiiiiii")
-    {
-        emfuncs.dyn_call_iiiiiiii = Some(func);
-    }
-    if let Ok(func) = instance
-        .exports
-        .get_typed_function(&env, "dynCall_iiiiiiiii")
-    {
-        emfuncs.dyn_call_iiiiiiiii = Some(func);
-    }
-    if let Ok(func) = instance
-        .exports
-        .get_typed_function(&env, "dynCall_iiiiiiiiii")
-    {
-        emfuncs.dyn_call_iiiiiiiiii = Some(func);
-    }
-    if let Ok(func) = instance
-        .exports
-        .get_typed_function(&env, "dynCall_iiiiiiiiiii")
-    {
-        emfuncs.dyn_call_iiiiiiiiiii = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_vd") {
-        emfuncs.dyn_call_vd = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viiiii") {
-        emfuncs.dyn_call_viiiii = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viiiiii") {
-        emfuncs.dyn_call_viiiiii = Some(func);
-    }
-    if let Ok(func) = instance
-        .exports
-        .get_typed_function(&env, "dynCall_viiiiiii")
-    {
-        emfuncs.dyn_call_viiiiiii = Some(func);
-    }
-    if let Ok(func) = instance
-        .exports
-        .get_typed_function(&env, "dynCall_viiiiiiii")
-    {
-        emfuncs.dyn_call_viiiiiiii = Some(func);
-    }
-    if let Ok(func) = instance
-        .exports
-        .get_typed_function(&env, "dynCall_viiiiiiiii")
-    {
-        emfuncs.dyn_call_viiiiiiiii = Some(func);
-    }
-    if let Ok(func) = instance
-        .exports
-        .get_typed_function(&env, "dynCall_viiiiiiiiii")
-    {
-        emfuncs.dyn_call_viiiiiiiiii = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_iij") {
-        emfuncs.dyn_call_iij = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_iji") {
-        emfuncs.dyn_call_iji = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_iiji") {
-        emfuncs.dyn_call_iiji = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_iiijj") {
-        emfuncs.dyn_call_iiijj = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_j") {
-        emfuncs.dyn_call_j = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_ji") {
-        emfuncs.dyn_call_ji = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_jii") {
-        emfuncs.dyn_call_jii = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_jij") {
-        emfuncs.dyn_call_jij = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_jjj") {
-        emfuncs.dyn_call_jjj = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viiij") {
-        emfuncs.dyn_call_viiij = Some(func);
-    }
-    if let Ok(func) = instance
-        .exports
-        .get_typed_function(&env, "dynCall_viiijiiii")
-    {
-        emfuncs.dyn_call_viiijiiii = Some(func);
-    }
-    if let Ok(func) = instance
-        .exports
-        .get_typed_function(&env, "dynCall_viiijiiiiii")
-    {
-        emfuncs.dyn_call_viiijiiiiii = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viij") {
-        emfuncs.dyn_call_viij = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viiji") {
-        emfuncs.dyn_call_viiji = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viijiii") {
-        emfuncs.dyn_call_viijiii = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viijj") {
-        emfuncs.dyn_call_viijj = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_vj") {
-        emfuncs.dyn_call_vj = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_vjji") {
-        emfuncs.dyn_call_vjji = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_vij") {
-        emfuncs.dyn_call_vij = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viji") {
-        emfuncs.dyn_call_viji = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_vijiii") {
-        emfuncs.dyn_call_vijiii = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_vijj") {
-        emfuncs.dyn_call_vijj = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viid") {
-        emfuncs.dyn_call_viid = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_vidd") {
-        emfuncs.dyn_call_vidd = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viidii") {
-        emfuncs.dyn_call_viidii = Some(func);
-    }
-    if let Ok(func) = instance
-        .exports
-        .get_typed_function(&env, "dynCall_viidddddddd")
-    {
-        emfuncs.dyn_call_viidddddddd = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "stackSave") {
-        emfuncs.stack_save = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "stackRestore") {
-        emfuncs.stack_restore = Some(func);
-    }
-    if let Ok(func) = instance.exports.get_typed_function(&env, "setThrew") {
-        emfuncs.set_threw = Some(func);
-    }
-    env.data().set_functions(emfuncs);
-
-    set_up_emscripten(&mut env, instance)?;
-
-    let main_func_names = ["_main", "main"];
-    if let Some(ep) = entrypoint.as_ref() {
-        debug!("Running entry point: {}", ep);
-        emscripten_call_main(instance, ep, env, path, &args)?;
-    } else if let Ok(name) = emscripten_get_main_func_name(instance, &main_func_names) {
-        emscripten_call_main(instance, name, env, path, &args)?;
-    } else {
-        return Err(RuntimeError::new(format!(
-            "No main function found (searched: {main_func_names:?}) and no entrypoint specified"
-        )));
-    }
-
-    // TODO atexit for emscripten
-    // println!("{:?}", data);
-    Ok(())
-}
-
-fn store_module_arguments(env: &mut FunctionEnvMut<EmEnv>, args: Vec<&str>) -> (u32, u32) {
-    let argc = args.len() + 1;
-
-    let mut args_slice = vec![0; argc];
-    for (slot, arg) in args_slice[0..argc].iter_mut().zip(args.iter()) {
-        *slot = unsafe { allocate_cstr_on_stack(&mut env.as_mut(), arg).0 };
-    }
-
-    let (argv_offset, argv_slice): (_, &mut [u32]) =
-        unsafe { allocate_on_stack(&mut env.as_mut(), ((argc) * 4) as u32) };
-    assert!(!argv_slice.is_empty());
-    for (slot, arg) in argv_slice[0..argc].iter_mut().zip(args_slice.iter()) {
-        *slot = *arg
-    }
-    argv_slice[argc] = 0;
-
-    (argc as u32 - 1, argv_offset)
-}
-
-pub fn emscripten_set_up_memory(
-    store: &impl AsStoreRef,
-    env: &FunctionEnv<EmEnv>,
-    memory: &Memory,
-    globals: &EmscriptenGlobalsData,
-) -> Result<(), String> {
-    env.as_ref(store).set_memory(memory.clone());
-    let memory = memory.view(store);
-    let dynamictop_ptr = WasmPtr::<i32>::new(globals.dynamictop_ptr).deref(&memory);
-    let dynamic_base = globals.dynamic_base;
-
-    if dynamictop_ptr.offset() >= memory.data_size() {
-        return Err("dynamictop_ptr beyond memory len".to_string());
-    }
-    dynamictop_ptr.write(dynamic_base as i32).unwrap();
-    Ok(())
-}
-
-#[derive(Debug, Clone, Default)]
-pub struct EmscriptenGlobalsData {
-    abort: u64,
-    // Env namespace
-    stacktop: u32,
-    stack_max: u32,
-    dynamictop_ptr: u32,
-    dynamic_base: u32,
-    memory_base: u32,
-    table_base: u32,
-    temp_double_ptr: u32,
-    use_old_abort_on_cannot_grow_memory: bool,
-}
-
-pub struct EmscriptenGlobals {
-    // The emscripten data
-    pub data: EmscriptenGlobalsData,
-    // The emscripten memory
-    pub memory: Memory,
-    pub table: Table,
-    pub memory_min: Pages,
-    pub memory_max: Option<Pages>,
-    pub null_function_names: Vec<String>,
-}
-
-impl EmscriptenGlobals {
-    pub fn new(
-        mut store: &mut impl AsStoreMut,
-        env: &FunctionEnv<EmEnv>,
-        module: &Module, /*, static_bump: u32 */
-    ) -> Result<Self, String> {
-        let mut use_old_abort_on_cannot_grow_memory = false;
-        for import in module.imports().functions() {
-            if import.name() == "abortOnCannotGrowMemory" && import.module() == "env" {
-                if import.ty() == &*OLD_ABORT_ON_CANNOT_GROW_MEMORY_SIG {
-                    use_old_abort_on_cannot_grow_memory = true;
-                }
-                break;
-            }
-        }
-
-        let (table_min, table_max) = get_emscripten_table_size(module)?;
-        let (memory_min, memory_max, shared) = get_emscripten_memory_size(module)?;
-
-        // Memory initialization
-        let memory_type = MemoryType::new(memory_min, memory_max, shared);
-        let memory = Memory::new(&mut store, memory_type).unwrap();
-
-        let table_type = TableType {
-            ty: ValType::FuncRef,
-            minimum: table_min,
-            maximum: table_max,
-        };
-        let table = Table::new(&mut store, table_type, Value::FuncRef(None)).unwrap();
-
-        let data = {
-            let static_bump = STATIC_BUMP;
-
-            let mut static_top = STATIC_BASE + static_bump;
-
-            let memory_base = STATIC_BASE;
-            let table_base = 0;
-
-            let temp_double_ptr = static_top;
-            static_top += 16;
-
-            let (dynamic_base, dynamictop_ptr) =
-                get_emscripten_metadata(module)?.unwrap_or_else(|| {
-                    let dynamictop_ptr = static_alloc(&mut static_top, 4);
-                    (
-                        align_memory(align_memory(static_top) + TOTAL_STACK),
-                        dynamictop_ptr,
-                    )
-                });
-
-            let stacktop = align_memory(static_top);
-            let stack_max = stacktop + TOTAL_STACK;
-
-            EmscriptenGlobalsData {
-                abort: 0,
-                stacktop,
-                stack_max,
-                dynamictop_ptr,
-                dynamic_base,
-                memory_base,
-                table_base,
-                temp_double_ptr,
-                use_old_abort_on_cannot_grow_memory,
-            }
-        };
-
-        emscripten_set_up_memory(store, env, &memory, &data)?;
-
-        let mut null_function_names = vec![];
-        for import in module.imports().functions() {
-            if import.module() == "env"
-                && (import.name().starts_with("nullFunction_")
-                    || import.name().starts_with("nullFunc_"))
-            {
-                null_function_names.push(import.name().to_string())
-            }
-        }
-
-        Ok(Self {
-            data,
-            memory,
-            table,
-            memory_min,
-            memory_max,
-            null_function_names,
-        })
-    }
-}
-
-pub fn generate_emscripten_env(
-    mut store: &mut impl AsStoreMut,
-    env: &FunctionEnv<EmEnv>,
-    globals: &mut EmscriptenGlobals,
-) -> Imports {
-    let abort_on_cannot_grow_memory_export = if globals.data.use_old_abort_on_cannot_grow_memory {
-        Function::new_typed_with_env(
-            &mut store,
-            env,
-            crate::memory::abort_on_cannot_grow_memory_old,
-        )
-    } else {
-        Function::new_typed_with_env(&mut store, env, crate::memory::abort_on_cannot_grow_memory)
-    };
-
-    let mut env_ns: Exports = namespace! {
-        "memory" => globals.memory.clone(),
-        "table" => globals.table.clone(),
-
-        // Globals
-        "STACKTOP" => Global::new(&mut store, Value::I32(globals.data.stacktop as i32)),
-        "STACK_MAX" => Global::new(&mut store, Value::I32(globals.data.stack_max as i32)),
-        "DYNAMICTOP_PTR" => Global::new(&mut store, Value::I32(globals.data.dynamictop_ptr as i32)),
-        "fb" => Global::new(&mut store, Value::I32(globals.data.table_base as i32)),
-        "tableBase" => Global::new(&mut store, Value::I32(globals.data.table_base as i32)),
-        "__table_base" => Global::new(&mut store, Value::I32(globals.data.table_base as i32)),
-        "ABORT" => Global::new(&mut store, Value::I32(globals.data.abort as i32)),
-        "gb" => Global::new(&mut store, Value::I32(globals.data.memory_base as i32)),
-        "memoryBase" => Global::new(&mut store, Value::I32(globals.data.memory_base as i32)),
-        "__memory_base" => Global::new(&mut store, Value::I32(globals.data.memory_base as i32)),
-        "tempDoublePtr" => Global::new(&mut store, Value::I32(globals.data.temp_double_ptr as i32)),
-
-        // inet
-        "_inet_addr" => Function::new_typed_with_env(&mut store, env, crate::inet::addr),
-
-        // IO
-        "printf" => Function::new_typed_with_env(&mut store, env, crate::io::printf),
-        "putchar" => Function::new_typed_with_env(&mut store, env, crate::io::putchar),
-        "___lock" => Function::new_typed_with_env(&mut store, env, crate::lock::___lock),
-        "___unlock" => Function::new_typed_with_env(&mut store, env, crate::lock::___unlock),
-        "___wait" => Function::new_typed_with_env(&mut store, env, crate::lock::___wait),
-        "_flock" => Function::new_typed_with_env(&mut store, env, crate::lock::_flock),
-        "_chroot" => Function::new_typed_with_env(&mut store, env, crate::io::chroot),
-        "_getprotobyname" => Function::new_typed_with_env(&mut store, env, crate::io::getprotobyname),
-        "_getprotobynumber" => Function::new_typed_with_env(&mut store, env, crate::io::getprotobynumber),
-        "_getpwuid" => Function::new_typed_with_env(&mut store, env, crate::io::getpwuid),
-        "_sigdelset" => Function::new_typed_with_env(&mut store, env, crate::io::sigdelset),
-        "_sigfillset" => Function::new_typed_with_env(&mut store, env, crate::io::sigfillset),
-        "_tzset" => Function::new_typed_with_env(&mut store, env, crate::io::tzset),
-        "_strptime" => Function::new_typed_with_env(&mut store, env, crate::io::strptime),
-
-        // exec
-        "_execvp" => Function::new_typed_with_env(&mut store, env, crate::exec::execvp),
-        "_execl" => Function::new_typed_with_env(&mut store, env, crate::exec::execl),
-        "_execle" => Function::new_typed_with_env(&mut store, env, crate::exec::execle),
-
-        // exit
-        "__exit" => Function::new_typed_with_env(&mut store, env, crate::exit::exit),
-
-        // Env
-        "___assert_fail" => Function::new_typed_with_env(&mut store, env, crate::env::___assert_fail),
-        "_getenv" => Function::new_typed_with_env(&mut store, env, crate::env::_getenv),
-        "_setenv" => Function::new_typed_with_env(&mut store, env, crate::env::_setenv),
-        "_putenv" => Function::new_typed_with_env(&mut store, env, crate::env::_putenv),
-        "_unsetenv" => Function::new_typed_with_env(&mut store, env, crate::env::_unsetenv),
-        "_getpwnam" => Function::new_typed_with_env(&mut store, env, crate::env::_getpwnam),
-        "_getgrnam" => Function::new_typed_with_env(&mut store, env, crate::env::_getgrnam),
-        "___buildEnvironment" => Function::new_typed_with_env(&mut store, env, crate::env::___build_environment),
-        "___setErrNo" => Function::new_typed_with_env(&mut store, env, crate::errno::___seterrno),
-        "_getpagesize" => Function::new_typed_with_env(&mut store, env, crate::env::_getpagesize),
-        "_sysconf" => Function::new_typed_with_env(&mut store, env, crate::env::_sysconf),
-        "_getaddrinfo" => Function::new_typed_with_env(&mut store, env, crate::env::_getaddrinfo),
-        "_times" => Function::new_typed_with_env(&mut store, env, crate::env::_times),
-        "_pathconf" => Function::new_typed_with_env(&mut store, env, crate::env::_pathconf),
-        "_fpathconf" => Function::new_typed_with_env(&mut store, env, crate::env::_fpathconf),
-
-        // Syscalls
-        "___syscall1" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall1),
-        "___syscall3" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall3),
-        "___syscall4" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall4),
-        "___syscall5" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall5),
-        "___syscall6" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall6),
-        "___syscall9" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall9),
-        "___syscall10" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall10),
-        "___syscall12" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall12),
-        "___syscall14" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall14),
-        "___syscall15" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall15),
-        "___syscall20" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall20),
-        "___syscall21" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall21),
-        "___syscall25" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall25),
-        "___syscall29" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall29),
-        "___syscall32" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall32),
-        "___syscall33" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall33),
-        "___syscall34" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall34),
-        "___syscall36" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall36),
-        "___syscall39" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall39),
-        "___syscall38" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall38),
-        "___syscall40" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall40),
-        "___syscall41" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall41),
-        "___syscall42" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall42),
-        "___syscall51" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall51),
-        "___syscall52" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall52),
-        "___syscall53" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall53),
-        "___syscall54" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall54),
-        "___syscall57" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall57),
-        "___syscall60" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall60),
-        "___syscall63" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall63),
-        "___syscall64" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall64),
-        "___syscall66" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall66),
-        "___syscall75" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall75),
-        "___syscall77" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall77),
-        "___syscall83" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall83),
-        "___syscall85" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall85),
-        "___syscall91" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall91),
-        "___syscall94" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall94),
-        "___syscall96" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall96),
-        "___syscall97" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall97),
-        "___syscall102" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall102),
-        "___syscall110" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall110),
-        "___syscall114" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall114),
-        "___syscall118" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall118),
-        "___syscall121" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall121),
-        "___syscall122" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall122),
-        "___syscall125" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall125),
-        "___syscall132" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall132),
-        "___syscall133" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall133),
-        "___syscall140" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall140),
-        "___syscall142" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall142),
-        "___syscall144" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall144),
-        "___syscall145" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall145),
-        "___syscall146" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall146),
-        "___syscall147" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall147),
-        "___syscall148" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall148),
-        "___syscall150" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall150),
-        "___syscall151" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall151),
-        "___syscall152" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall152),
-        "___syscall153" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall153),
-        "___syscall163" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall163),
-        "___syscall168" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall168),
-        "___syscall180" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall180),
-        "___syscall181" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall181),
-        "___syscall183" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall183),
-        "___syscall191" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall191),
-        "___syscall192" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall192),
-        "___syscall193" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall193),
-        "___syscall194" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall194),
-        "___syscall195" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall195),
-        "___syscall196" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall196),
-        "___syscall197" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall197),
-        "___syscall198" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall198),
-        "___syscall199" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall199),
-        "___syscall200" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall200),
-        "___syscall201" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall201),
-        "___syscall202" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall202),
-        "___syscall205" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall205),
-        "___syscall207" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall207),
-        "___syscall209" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall209),
-        "___syscall211" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall211),
-        "___syscall212" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall212),
-        "___syscall218" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall218),
-        "___syscall219" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall219),
-        "___syscall220" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall220),
-        "___syscall221" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall221),
-        "___syscall268" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall268),
-        "___syscall269" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall269),
-        "___syscall272" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall272),
-        "___syscall295" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall295),
-        "___syscall296" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall296),
-        "___syscall297" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall297),
-        "___syscall298" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall298),
-        "___syscall300" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall300),
-        "___syscall301" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall301),
-        "___syscall302" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall302),
-        "___syscall303" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall303),
-        "___syscall304" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall304),
-        "___syscall305" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall305),
-        "___syscall306" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall306),
-        "___syscall307" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall307),
-        "___syscall308" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall308),
-        "___syscall320" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall320),
-        "___syscall324" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall324),
-        "___syscall330" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall330),
-        "___syscall331" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall331),
-        "___syscall333" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall333),
-        "___syscall334" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall334),
-        "___syscall337" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall337),
-        "___syscall340" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall340),
-        "___syscall345" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall345),
-
-        // Process
-        "abort" => Function::new_typed_with_env(&mut store, env, crate::process::em_abort),
-        "_abort" => Function::new_typed_with_env(&mut store, env, crate::process::_abort),
-        "_prctl" => Function::new_typed_with_env(&mut store, env, crate::process::_prctl),
-        "abortStackOverflow" => Function::new_typed_with_env(&mut store, env, crate::process::abort_stack_overflow),
-        "_llvm_trap" => Function::new_typed_with_env(&mut store, env, crate::process::_llvm_trap),
-        "_fork" => Function::new_typed_with_env(&mut store, env, crate::process::_fork),
-        "_exit" => Function::new_typed_with_env(&mut store, env, crate::process::_exit),
-        "_system" => Function::new_typed_with_env(&mut store, env, crate::process::_system),
-        "_popen" => Function::new_typed_with_env(&mut store, env, crate::process::_popen),
-        "_endgrent" => Function::new_typed_with_env(&mut store, env, crate::process::_endgrent),
-        "_execve" => Function::new_typed_with_env(&mut store, env, crate::process::_execve),
-        "_kill" => Function::new_typed_with_env(&mut store, env, crate::process::_kill),
-        "_llvm_stackrestore" => Function::new_typed_with_env(&mut store, env, crate::process::_llvm_stackrestore),
-        "_llvm_stacksave" => Function::new_typed_with_env(&mut store, env, crate::process::_llvm_stacksave),
-        "_llvm_eh_typeid_for" => Function::new_typed_with_env(&mut store, env, crate::process::_llvm_eh_typeid_for),
-        "_raise" => Function::new_typed_with_env(&mut store, env, crate::process::_raise),
-        "_sem_init" => Function::new_typed_with_env(&mut store, env, crate::process::_sem_init),
-        "_sem_destroy" => Function::new_typed_with_env(&mut store, env, crate::process::_sem_destroy),
-        "_sem_post" => Function::new_typed_with_env(&mut store, env, crate::process::_sem_post),
-        "_sem_wait" => Function::new_typed_with_env(&mut store, env, crate::process::_sem_wait),
-        "_getgrent" => Function::new_typed_with_env(&mut store, env, crate::process::_getgrent),
-        "_sched_yield" => Function::new_typed_with_env(&mut store, env, crate::process::_sched_yield),
-        "_setgrent" => Function::new_typed_with_env(&mut store, env, crate::process::_setgrent),
-        "_setgroups" => Function::new_typed_with_env(&mut store, env, crate::process::_setgroups),
-        "_setitimer" => Function::new_typed_with_env(&mut store, env, crate::process::_setitimer),
-        "_usleep" => Function::new_typed_with_env(&mut store, env, crate::process::_usleep),
-        "_nanosleep" => Function::new_typed_with_env(&mut store, env, crate::process::_nanosleep),
-        "_utime" => Function::new_typed_with_env(&mut store, env, crate::process::_utime),
-        "_utimes" => Function::new_typed_with_env(&mut store, env, crate::process::_utimes),
-        "_wait" => Function::new_typed_with_env(&mut store, env, crate::process::_wait),
-        "_wait3" => Function::new_typed_with_env(&mut store, env, crate::process::_wait3),
-        "_wait4" => Function::new_typed_with_env(&mut store, env, crate::process::_wait4),
-        "_waitid" => Function::new_typed_with_env(&mut store, env, crate::process::_waitid),
-        "_waitpid" => Function::new_typed_with_env(&mut store, env, crate::process::_waitpid),
-
-        // Emscripten
-        "_emscripten_asm_const_i" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::asm_const_i),
-        "_emscripten_exit_with_live_runtime" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::exit_with_live_runtime),
-
-        // Signal
-        "_sigemptyset" => Function::new_typed_with_env(&mut store, env, crate::signal::_sigemptyset),
-        "_sigaddset" => Function::new_typed_with_env(&mut store, env, crate::signal::_sigaddset),
-        "_sigprocmask" => Function::new_typed_with_env(&mut store, env, crate::signal::_sigprocmask),
-        "_sigaction" => Function::new_typed_with_env(&mut store, env, crate::signal::_sigaction),
-        "_signal" => Function::new_typed_with_env(&mut store, env, crate::signal::_signal),
-        "_sigsuspend" => Function::new_typed_with_env(&mut store, env, crate::signal::_sigsuspend),
-
-        // Memory
-        "abortOnCannotGrowMemory" => abort_on_cannot_grow_memory_export,
-        "_emscripten_memcpy_big" => Function::new_typed_with_env(&mut store, env, crate::memory::_emscripten_memcpy_big),
-        "_emscripten_get_heap_size" => Function::new_typed_with_env(&mut store, env, crate::memory::_emscripten_get_heap_size),
-        "_emscripten_resize_heap" => Function::new_typed_with_env(&mut store, env, crate::memory::_emscripten_resize_heap),
-        "enlargeMemory" => Function::new_typed_with_env(&mut store, env, crate::memory::enlarge_memory),
-        "segfault" => Function::new_typed_with_env(&mut store, env, crate::memory::segfault),
-        "alignfault" => Function::new_typed_with_env(&mut store, env, crate::memory::alignfault),
-        "ftfault" => Function::new_typed_with_env(&mut store, env, crate::memory::ftfault),
-        "getTotalMemory" => Function::new_typed_with_env(&mut store, env, crate::memory::get_total_memory),
-        "_sbrk" => Function::new_typed_with_env(&mut store, env, crate::memory::sbrk),
-        "___map_file" => Function::new_typed_with_env(&mut store, env, crate::memory::___map_file),
-
-        // Exception
-        "___cxa_allocate_exception" => Function::new_typed_with_env(&mut store, env, crate::exception::___cxa_allocate_exception),
-        "___cxa_current_primary_exception" => Function::new_typed_with_env(&mut store, env, crate::exception::___cxa_current_primary_exception),
-        "___cxa_decrement_exception_refcount" => Function::new_typed_with_env(&mut store, env, crate::exception::___cxa_decrement_exception_refcount),
-        "___cxa_increment_exception_refcount" => Function::new_typed_with_env(&mut store, env, crate::exception::___cxa_increment_exception_refcount),
-        "___cxa_rethrow_primary_exception" => Function::new_typed_with_env(&mut store, env, crate::exception::___cxa_rethrow_primary_exception),
-        "___cxa_throw" => Function::new_typed_with_env(&mut store, env, crate::exception::___cxa_throw),
-        "___cxa_begin_catch" => Function::new_typed_with_env(&mut store, env, crate::exception::___cxa_begin_catch),
-        "___cxa_end_catch" => Function::new_typed_with_env(&mut store, env, crate::exception::___cxa_end_catch),
-        "___cxa_uncaught_exception" => Function::new_typed_with_env(&mut store, env, crate::exception::___cxa_uncaught_exception),
-        "___cxa_pure_virtual" => Function::new_typed_with_env(&mut store, env, crate::exception::___cxa_pure_virtual),
-
-        // Time
-        "_gettimeofday" => Function::new_typed_with_env(&mut store, env, crate::time::_gettimeofday),
-        "_clock_getres" => Function::new_typed_with_env(&mut store, env, crate::time::_clock_getres),
-        "_clock_gettime" => Function::new_typed_with_env(&mut store, env, crate::time::_clock_gettime),
-        "_clock_settime" => Function::new_typed_with_env(&mut store, env, crate::time::_clock_settime),
-        "___clock_gettime" => Function::new_typed_with_env(&mut store, env, crate::time::_clock_gettime),
-        "_clock" => Function::new_typed_with_env(&mut store, env, crate::time::_clock),
-        "_difftime" => Function::new_typed_with_env(&mut store, env, crate::time::_difftime),
-        "_asctime" => Function::new_typed_with_env(&mut store, env, crate::time::_asctime),
-        "_asctime_r" => Function::new_typed_with_env(&mut store, env, crate::time::_asctime_r),
-        "_localtime" => Function::new_typed_with_env(&mut store, env, crate::time::_localtime),
-        "_time" => Function::new_typed_with_env(&mut store, env, crate::time::_time),
-        "_timegm" => Function::new_typed_with_env(&mut store, env, crate::time::_timegm),
-        "_strftime" => Function::new_typed_with_env(&mut store, env, crate::time::_strftime),
-        "_strftime_l" => Function::new_typed_with_env(&mut store, env, crate::time::_strftime_l),
-        "_localtime_r" => Function::new_typed_with_env(&mut store, env, crate::time::_localtime_r),
-        "_gmtime_r" => Function::new_typed_with_env(&mut store, env, crate::time::_gmtime_r),
-        "_ctime" => Function::new_typed_with_env(&mut store, env, crate::time::_ctime),
-        "_ctime_r" => Function::new_typed_with_env(&mut store, env, crate::time::_ctime_r),
-        "_mktime" => Function::new_typed_with_env(&mut store, env, crate::time::_mktime),
-        "_gmtime" => Function::new_typed_with_env(&mut store, env, crate::time::_gmtime),
-
-        // Math
-        "sqrt" => Function::new_typed_with_env(&mut store, env, crate::math::sqrt),
-        "floor" => Function::new_typed_with_env(&mut store, env, crate::math::floor),
-        "fabs" => Function::new_typed_with_env(&mut store, env, crate::math::fabs),
-        "f64-rem" => Function::new_typed_with_env(&mut store, env, crate::math::f64_rem),
-        "_llvm_copysign_f32" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_copysign_f32),
-        "_llvm_copysign_f64" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_copysign_f64),
-        "_llvm_log10_f64" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_log10_f64),
-        "_llvm_log2_f64" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_log2_f64),
-        "_llvm_log10_f32" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_log10_f32),
-        "_llvm_log2_f32" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_log2_f64),
-        "_llvm_sin_f64" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_sin_f64),
-        "_llvm_cos_f64" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_cos_f64),
-        "_llvm_exp2_f32" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_exp2_f32),
-        "_llvm_exp2_f64" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_exp2_f64),
-        "_llvm_trunc_f64" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_trunc_f64),
-        "_llvm_fma_f64" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_fma_f64),
-        "_emscripten_random" => Function::new_typed_with_env(&mut store, env, crate::math::_emscripten_random),
-
-        // Jump
-        "__setjmp" => Function::new_typed_with_env(&mut store, env, crate::jmp::__setjmp),
-        "__longjmp" => Function::new_typed_with_env(&mut store, env, crate::jmp::__longjmp),
-        "_longjmp" => Function::new_typed_with_env(&mut store, env, crate::jmp::_longjmp),
-        "_emscripten_longjmp" => Function::new_typed_with_env(&mut store, env, crate::jmp::_longjmp),
-
-        // Bitwise
-        "_llvm_bswap_i64" => Function::new_typed_with_env(&mut store, env, crate::bitwise::_llvm_bswap_i64),
-
-        // libc
-        "_execv" => Function::new_typed_with_env(&mut store, env, crate::libc::execv),
-        "_endpwent" => Function::new_typed_with_env(&mut store, env, crate::libc::endpwent),
-        "_fexecve" => Function::new_typed_with_env(&mut store, env, crate::libc::fexecve),
-        "_fpathconf" => Function::new_typed_with_env(&mut store, env, crate::libc::fpathconf),
-        "_getitimer" => Function::new_typed_with_env(&mut store, env, crate::libc::getitimer),
-        "_getpwent" => Function::new_typed_with_env(&mut store, env, crate::libc::getpwent),
-        "_killpg" => Function::new_typed_with_env(&mut store, env, crate::libc::killpg),
-        "_pathconf" => Function::new_typed_with_env(&mut store, env, crate::libc::pathconf),
-        "_siginterrupt" => Function::new_typed_with_env(&mut store, env, crate::signal::_siginterrupt),
-        "_setpwent" => Function::new_typed_with_env(&mut store, env, crate::libc::setpwent),
-        "_sigismember" => Function::new_typed_with_env(&mut store, env, crate::libc::sigismember),
-        "_sigpending" => Function::new_typed_with_env(&mut store, env, crate::libc::sigpending),
-        "___libc_current_sigrtmax" => Function::new_typed_with_env(&mut store, env, crate::libc::current_sigrtmax),
-        "___libc_current_sigrtmin" => Function::new_typed_with_env(&mut store, env, crate::libc::current_sigrtmin),
-
-        // Linking
-        "_dlclose" => Function::new_typed_with_env(&mut store, env, crate::linking::_dlclose),
-        "_dlerror" => Function::new_typed_with_env(&mut store, env, crate::linking::_dlerror),
-        "_dlopen" => Function::new_typed_with_env(&mut store, env, crate::linking::_dlopen),
-        "_dlsym" => Function::new_typed_with_env(&mut store, env, crate::linking::_dlsym),
-
-        // wasm32-unknown-emscripten
-        "_alarm" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::_alarm),
-        "_atexit" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::_atexit),
-        "setTempRet0" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::setTempRet0),
-        "getTempRet0" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::getTempRet0),
-        "invoke_i" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_i),
-        "invoke_ii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_ii),
-        "invoke_iii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iii),
-        "invoke_iiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iiii),
-        "invoke_iifi" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iifi),
-        "invoke_v" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_v),
-        "invoke_vi" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_vi),
-        "invoke_vj" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_vj),
-        "invoke_vjji" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_vjji),
-        "invoke_vii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_vii),
-        "invoke_viii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viii),
-        "invoke_viiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiii),
-        "__Unwind_Backtrace" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::__Unwind_Backtrace),
-        "__Unwind_FindEnclosingFunction" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::__Unwind_FindEnclosingFunction),
-        "__Unwind_GetIPInfo" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::__Unwind_GetIPInfo),
-        "___cxa_find_matching_catch_2" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::___cxa_find_matching_catch_2),
-        "___cxa_find_matching_catch_3" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::___cxa_find_matching_catch_3),
-        "___cxa_free_exception" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::___cxa_free_exception),
-        "___resumeException" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::___resumeException),
-        "_dladdr" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::_dladdr),
-        "_pthread_attr_destroy" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_attr_destroy),
-        "_pthread_attr_getstack" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_attr_getstack),
-        "_pthread_attr_init" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_attr_init),
-        "_pthread_attr_setstacksize" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_attr_setstacksize),
-        "_pthread_cleanup_pop" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_cleanup_pop),
-        "_pthread_cleanup_push" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_cleanup_push),
-        "_pthread_cond_destroy" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_cond_destroy),
-        "_pthread_cond_init" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_cond_init),
-        "_pthread_cond_signal" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_cond_signal),
-        "_pthread_cond_timedwait" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_cond_timedwait),
-        "_pthread_cond_wait" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_cond_wait),
-        "_pthread_condattr_destroy" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_condattr_destroy),
-        "_pthread_condattr_init" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_condattr_init),
-        "_pthread_condattr_setclock" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_condattr_setclock),
-        "_pthread_create" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_create),
-        "_pthread_detach" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_detach),
-        "_pthread_equal" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_equal),
-        "_pthread_exit" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_exit),
-        "_pthread_self" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_self),
-        "_pthread_getattr_np" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_getattr_np),
-        "_pthread_getspecific" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_getspecific),
-        "_pthread_join" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_join),
-        "_pthread_key_create" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_key_create),
-        "_pthread_mutex_destroy" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_mutex_destroy),
-        "_pthread_mutex_init" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_mutex_init),
-        "_pthread_mutexattr_destroy" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_mutexattr_destroy),
-        "_pthread_mutexattr_init" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_mutexattr_init),
-        "_pthread_mutexattr_settype" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_mutexattr_settype),
-        "_pthread_once" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_once),
-        "_pthread_rwlock_destroy" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_rwlock_destroy),
-        "_pthread_rwlock_init" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_rwlock_init),
-        "_pthread_rwlock_rdlock" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_rwlock_rdlock),
-        "_pthread_rwlock_unlock" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_rwlock_unlock),
-        "_pthread_rwlock_wrlock" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_rwlock_wrlock),
-        "_pthread_setcancelstate" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_setcancelstate),
-        "_pthread_setspecific" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_setspecific),
-        "_pthread_sigmask" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_sigmask),
-        "___gxx_personality_v0" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::___gxx_personality_v0),
-        "_gai_strerror" => Function::new_typed_with_env(&mut store, env, crate::env::_gai_strerror),
-        "_getdtablesize" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::_getdtablesize),
-        "_gethostbyaddr" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::_gethostbyaddr),
-        "_gethostbyname" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::_gethostbyname),
-        "_gethostbyname_r" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::_gethostbyname_r),
-        "_getloadavg" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::_getloadavg),
-        "_getnameinfo" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::_getnameinfo),
-        "invoke_dii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_dii),
-        "invoke_diiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_diiii),
-        "invoke_iiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iiiii),
-        "invoke_iiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iiiiii),
-        "invoke_iiiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iiiiiii),
-        "invoke_iiiiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iiiiiiii),
-        "invoke_iiiiiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iiiiiiiii),
-        "invoke_iiiiiiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iiiiiiiiii),
-        "invoke_iiiiiiiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iiiiiiiiiii),
-        "invoke_vd" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_vd),
-        "invoke_viiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiiii),
-        "invoke_viiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiiiii),
-        "invoke_viiiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiiiiii),
-        "invoke_viiiiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiiiiiii),
-        "invoke_viiiiiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiiiiiiii),
-        "invoke_viiiiiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiiiiiiii),
-        "invoke_viiiiiiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiiiiiiiii),
-        "invoke_iij" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iij),
-        "invoke_iji" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iji),
-        "invoke_iiji" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iiji),
-        "invoke_iiijj" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iiijj),
-        "invoke_j" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_j),
-        "invoke_ji" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_ji),
-        "invoke_jii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_jii),
-        "invoke_jij" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_jij),
-        "invoke_jjj" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_jjj),
-        "invoke_viiij" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiij),
-        "invoke_viiijiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiijiiii),
-        "invoke_viiijiiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiijiiiiii),
-        "invoke_viij" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viij),
-        "invoke_viiji" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiji),
-        "invoke_viijiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viijiii),
-        "invoke_viijj" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viijj),
-        "invoke_vij" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_vij),
-        "invoke_viji" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viji),
-        "invoke_vijiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_vijiii),
-        "invoke_vijj" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_vijj),
-        "invoke_vidd" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_vidd),
-        "invoke_viid" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viid),
-        "invoke_viidii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viidii),
-        "invoke_viidddddddd" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viidddddddd),
-
-        // ucontext
-        "_getcontext" => Function::new_typed_with_env(&mut store, env, crate::ucontext::_getcontext),
-        "_makecontext" => Function::new_typed_with_env(&mut store, env, crate::ucontext::_makecontext),
-        "_setcontext" => Function::new_typed_with_env(&mut store, env, crate::ucontext::_setcontext),
-        "_swapcontext" => Function::new_typed_with_env(&mut store, env, crate::ucontext::_swapcontext),
-
-        // unistd
-        "_confstr" => Function::new_typed_with_env(&mut store, env, crate::unistd::confstr),
-    };
-
-    // Compatibility with newer versions of Emscripten
-    let mut to_insert: Vec<(String, _)> = vec![];
-    for (k, v) in env_ns.iter() {
-        if let Some(k) = k.strip_prefix('_') {
-            if !env_ns.contains(k) {
-                to_insert.push((k.to_string(), v.clone()));
-            }
-        }
-    }
-
-    for (k, v) in to_insert {
-        env_ns.insert(k, v);
-    }
-
-    for null_function_name in globals.null_function_names.iter() {
-        env_ns.insert(
-            null_function_name.as_str(),
-            Function::new_typed_with_env(&mut store, env, nullfunc),
-        );
-    }
-
-    let import_object: Imports = imports! {
-        "env" => env_ns,
-        "global" => {
-          "NaN" => Global::new(&mut store, Value::F64(f64::NAN)),
-          "Infinity" => Global::new(&mut store, Value::F64(f64::INFINITY)),
-        },
-        "global.Math" => {
-            "pow" => Function::new_typed_with_env(&mut store, env, crate::math::pow),
-            "exp" => Function::new_typed_with_env(&mut store, env, crate::math::exp),
-            "log" => Function::new_typed_with_env(&mut store, env, crate::math::log),
-        },
-        "asm2wasm" => {
-            "f64-rem" => Function::new_typed_with_env(&mut store, env, crate::math::f64_rem),
-            "f64-to-int" => Function::new_typed_with_env(&mut store, env, crate::math::f64_to_int),
-        },
-    };
-
-    import_object
-}
-
-pub fn nullfunc(env: FunctionEnvMut<EmEnv>, _x: u32) {
-    use crate::process::abort_with_message;
-    debug!("emscripten::nullfunc_i {}", _x);
-    abort_with_message(
-        env,
-        "Invalid function pointer. Perhaps this is an invalid value \
-    (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an \
-    incorrect type, which will fail? (it is worth building your source files with -Werror (\
-    warnings are errors), as warnings can indicate undefined behavior which can cause this)",
-    );
-}
-
-/// The current version of this crate
-pub const VERSION: &str = env!("CARGO_PKG_VERSION");
diff --git a/lib/emscripten/src/libc.rs b/lib/emscripten/src/libc.rs
deleted file mode 100644
index 99414c2b00..0000000000
--- a/lib/emscripten/src/libc.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-extern crate libc;
-use crate::EmEnv;
-use wasmer::FunctionEnvMut;
-
-#[cfg(unix)]
-use std::convert::TryInto;
-
-pub fn current_sigrtmax(_ctx: FunctionEnvMut<EmEnv>) -> i32 {
-    debug!("emscripten::current_sigrtmax");
-    0
-}
-
-pub fn current_sigrtmin(_ctx: FunctionEnvMut<EmEnv>) -> i32 {
-    debug!("emscripten::current_sigrtmin");
-    0
-}
-
-pub fn endpwent(_ctx: FunctionEnvMut<EmEnv>) {
-    debug!("emscripten::endpwent");
-}
-
-pub fn execv(_ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
-    debug!("emscripten::execv");
-    0
-}
-
-pub fn fexecve(_ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32, _c: i32) -> i32 {
-    debug!("emscripten::fexecve");
-    0
-}
-
-pub fn fpathconf(_ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
-    debug!("emscripten::fpathconf");
-    0
-}
-
-pub fn getitimer(_ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
-    debug!("emscripten::getitimer");
-    0
-}
-
-pub fn getpwent(_ctx: FunctionEnvMut<EmEnv>) -> i32 {
-    debug!("emscripten::getpwent");
-    0
-}
-
-pub fn killpg(_ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
-    debug!("emscripten::killpg");
-    0
-}
-
-#[cfg(unix)]
-pub fn pathconf(ctx: FunctionEnvMut<EmEnv>, path_ptr: i32, name: i32) -> i32 {
-    debug!("emscripten::pathconf");
-    let memory = ctx.data().memory(0);
-    let path = emscripten_memory_pointer!(memory.view(&ctx), path_ptr) as *const i8;
-    unsafe { libc::pathconf(path as *const _, name).try_into().unwrap() }
-}
-
-#[cfg(not(unix))]
-pub fn pathconf(_ctx: FunctionEnvMut<EmEnv>, _path_ptr: i32, _name: i32) -> i32 {
-    debug!("emscripten::pathconf");
-    0
-}
-
-pub fn setpwent(_ctx: FunctionEnvMut<EmEnv>) {
-    debug!("emscripten::setpwent");
-}
-
-pub fn sigismember(_ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
-    debug!("emscripten::sigismember");
-    0
-}
-
-pub fn sigpending(_ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
-    debug!("emscripten::sigpending");
-    0
-}
diff --git a/lib/emscripten/src/linking.rs b/lib/emscripten/src/linking.rs
deleted file mode 100644
index 83e39c4404..0000000000
--- a/lib/emscripten/src/linking.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-use crate::EmEnv;
-use wasmer::FunctionEnvMut;
-
-// TODO: Need to implement.
-
-/// emscripten: dlopen(filename: *const c_char, flag: c_int) -> *mut c_void
-pub fn _dlopen(mut _ctx: FunctionEnvMut<EmEnv>, _filename: u32, _flag: u32) -> i32 {
-    debug!("emscripten::_dlopen");
-    -1
-}
-
-/// emscripten: dlclose(handle: *mut c_void) -> c_int
-pub fn _dlclose(mut _ctx: FunctionEnvMut<EmEnv>, _filename: u32) -> i32 {
-    debug!("emscripten::_dlclose");
-    -1
-}
-
-/// emscripten: dlsym(handle: *mut c_void, symbol: *const c_char) -> *mut c_void
-pub fn _dlsym(mut _ctx: FunctionEnvMut<EmEnv>, _filepath: u32, _symbol: u32) -> i32 {
-    debug!("emscripten::_dlsym");
-    -1
-}
-
-/// emscripten: dlerror() -> *mut c_char
-pub fn _dlerror(mut _ctx: FunctionEnvMut<EmEnv>) -> i32 {
-    debug!("emscripten::_dlerror");
-    -1
-}
diff --git a/lib/emscripten/src/lock.rs b/lib/emscripten/src/lock.rs
deleted file mode 100644
index ce905d3e75..0000000000
--- a/lib/emscripten/src/lock.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-use crate::EmEnv;
-use libc::c_int;
-use wasmer::FunctionEnvMut;
-
-// NOTE: Not implemented by Emscripten
-pub fn ___lock(mut _ctx: FunctionEnvMut<EmEnv>, _what: c_int) {
-    debug!("emscripten::___lock {}", _what);
-}
-
-// NOTE: Not implemented by Emscripten
-pub fn ___unlock(mut _ctx: FunctionEnvMut<EmEnv>, _what: c_int) {
-    debug!("emscripten::___unlock {}", _what);
-}
-
-// NOTE: Not implemented by Emscripten
-pub fn ___wait(
-    mut _ctx: FunctionEnvMut<EmEnv>,
-    _which: u32,
-    _varargs: u32,
-    _three: u32,
-    _four: u32,
-) {
-    debug!("emscripten::___wait");
-}
-
-pub fn _flock(mut _ctx: FunctionEnvMut<EmEnv>, _fd: u32, _op: u32) -> u32 {
-    debug!("emscripten::_flock");
-    0
-}
diff --git a/lib/emscripten/src/macros.rs b/lib/emscripten/src/macros.rs
deleted file mode 100644
index 4cd2550b17..0000000000
--- a/lib/emscripten/src/macros.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-macro_rules! emscripten_memory_pointer {
-    ($memory:expr, $pointer:expr) => {
-        $memory.data_ptr().wrapping_add($pointer as usize)
-    };
-}
diff --git a/lib/emscripten/src/math.rs b/lib/emscripten/src/math.rs
deleted file mode 100644
index 1940b7edbe..0000000000
--- a/lib/emscripten/src/math.rs
+++ /dev/null
@@ -1,111 +0,0 @@
-use crate::EmEnv;
-use wasmer::FunctionEnvMut;
-
-pub fn _llvm_copysign_f32(mut _ctx: FunctionEnvMut<EmEnv>, x: f64, y: f64) -> f64 {
-    x.copysign(y)
-}
-
-pub fn _llvm_copysign_f64(mut _ctx: FunctionEnvMut<EmEnv>, x: f64, y: f64) -> f64 {
-    x.copysign(y)
-}
-
-/// emscripten: _llvm_log10_f64
-pub fn _llvm_log10_f64(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> f64 {
-    debug!("emscripten::_llvm_log10_f64");
-    value.log10()
-}
-
-/// emscripten: _llvm_log2_f64
-pub fn _llvm_log2_f64(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> f64 {
-    debug!("emscripten::_llvm_log2_f64");
-    value.log2()
-}
-
-/// emscripten: _llvm_sin_f64
-pub fn _llvm_sin_f64(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> f64 {
-    debug!("emscripten::_llvm_sin_f64");
-    value.sin()
-}
-
-/// emscripten: _llvm_cos_f64
-pub fn _llvm_cos_f64(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> f64 {
-    debug!("emscripten::_llvm_cos_f64");
-    value.cos()
-}
-
-pub fn _llvm_log10_f32(mut _ctx: FunctionEnvMut<EmEnv>, _value: f64) -> f64 {
-    debug!("emscripten::_llvm_log10_f32");
-    -1.0
-}
-
-pub fn _llvm_log2_f32(mut _ctx: FunctionEnvMut<EmEnv>, _value: f64) -> f64 {
-    debug!("emscripten::_llvm_log10_f32");
-    -1.0
-}
-
-pub fn _llvm_exp2_f32(mut _ctx: FunctionEnvMut<EmEnv>, value: f32) -> f32 {
-    debug!("emscripten::_llvm_exp2_f32");
-    2f32.powf(value)
-}
-
-pub fn _llvm_exp2_f64(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> f64 {
-    debug!("emscripten::_llvm_exp2_f64");
-    2f64.powf(value)
-}
-
-pub fn _llvm_trunc_f64(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> f64 {
-    debug!("emscripten::_llvm_trunc_f64");
-    value.trunc()
-}
-
-pub fn _llvm_fma_f64(mut _ctx: FunctionEnvMut<EmEnv>, value: f64, a: f64, b: f64) -> f64 {
-    debug!("emscripten::_llvm_fma_f64");
-    value.mul_add(a, b)
-}
-
-pub fn _emscripten_random(mut _ctx: FunctionEnvMut<EmEnv>) -> f64 {
-    debug!("emscripten::_emscripten_random");
-    -1.0
-}
-
-// emscripten: asm2wasm.f64-rem
-pub fn f64_rem(mut _ctx: FunctionEnvMut<EmEnv>, x: f64, y: f64) -> f64 {
-    debug!("emscripten::f64-rem");
-    x % y
-}
-
-// emscripten: global.Math pow
-pub fn pow(mut _ctx: FunctionEnvMut<EmEnv>, x: f64, y: f64) -> f64 {
-    x.powf(y)
-}
-
-// emscripten: global.Math exp
-pub fn exp(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> f64 {
-    value.exp()
-}
-
-// emscripten: global.Math log
-pub fn log(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> f64 {
-    value.ln()
-}
-
-// emscripten: global.Math sqrt
-pub fn sqrt(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> f64 {
-    value.sqrt()
-}
-
-// emscripten: global.Math floor
-pub fn floor(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> f64 {
-    value.floor()
-}
-
-// emscripten: global.Math fabs
-pub fn fabs(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> f64 {
-    value.abs()
-}
-
-// emscripten: asm2wasm.f64-to-int
-pub fn f64_to_int(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> i32 {
-    debug!("emscripten::f64_to_int {}", value);
-    value as i32
-}
diff --git a/lib/emscripten/src/memory.rs b/lib/emscripten/src/memory.rs
deleted file mode 100644
index 2c905e30c8..0000000000
--- a/lib/emscripten/src/memory.rs
+++ /dev/null
@@ -1,188 +0,0 @@
-use super::env::get_emscripten_data;
-use super::process::abort_with_message;
-use crate::EmEnv;
-use libc::{c_int, c_void, memcpy, size_t};
-// TODO: investigate max pages etc. probably in Wasm Common, maybe reexport
-use wasmer::{FunctionEnvMut, Pages, WasmPtr, WASM_MAX_PAGES, WASM_MIN_PAGES, WASM_PAGE_SIZE};
-
-/// emscripten: _emscripten_memcpy_big
-pub fn _emscripten_memcpy_big(ctx: FunctionEnvMut<EmEnv>, dest: u32, src: u32, len: u32) -> u32 {
-    debug!(
-        "emscripten::_emscripten_memcpy_big {}, {}, {}",
-        dest, src, len
-    );
-    let memory = ctx.data().memory(0);
-    let dest_addr = emscripten_memory_pointer!(memory.view(&ctx), dest) as *mut c_void;
-    let src_addr = emscripten_memory_pointer!(memory.view(&ctx), src) as *mut c_void;
-    unsafe {
-        memcpy(dest_addr, src_addr, len as size_t);
-    }
-    dest
-}
-
-fn get_heap_size(ctx: &FunctionEnvMut<EmEnv>) -> u32 {
-    let memory = ctx.data().memory(0);
-    memory.view(&ctx).size().bytes().0 as u32
-}
-
-/// emscripten: _emscripten_get_heap_size
-pub fn _emscripten_get_heap_size(ctx: FunctionEnvMut<EmEnv>) -> u32 {
-    trace!("emscripten::_emscripten_get_heap_size");
-    let result = get_heap_size(&ctx);
-    trace!("=> {}", result);
-
-    result
-}
-
-// From emscripten implementation
-fn align_up(mut val: usize, multiple: usize) -> usize {
-    if val % multiple > 0 {
-        val += multiple - val % multiple;
-    }
-    val
-}
-
-fn resize_heap(ctx: &mut FunctionEnvMut<EmEnv>, requested_size: u32) -> u32 {
-    debug!("emscripten::_emscripten_resize_heap {}", requested_size);
-    let memory = ctx.data().memory(0);
-    let current_memory_pages = memory.view(&ctx).size();
-    let current_memory = current_memory_pages.bytes().0 as u32;
-
-    // implementation from emscripten
-    let mut new_size = usize::max(
-        current_memory as usize,
-        WASM_MIN_PAGES as usize * WASM_PAGE_SIZE,
-    );
-    while new_size < requested_size as usize {
-        if new_size <= 0x2000_0000 {
-            new_size = align_up(new_size * 2, WASM_PAGE_SIZE);
-        } else {
-            new_size = usize::min(
-                align_up((3 * new_size + 0x8000_0000) / 4, WASM_PAGE_SIZE),
-                WASM_PAGE_SIZE * WASM_MAX_PAGES as usize,
-            );
-        }
-    }
-
-    let amount_to_grow = (new_size - current_memory as usize) / WASM_PAGE_SIZE;
-    if let Ok(_pages_allocated) = ctx
-        .data()
-        .memory(0)
-        .grow(&mut ctx.as_mut(), Pages(amount_to_grow as u32))
-    {
-        debug!("{} pages allocated", _pages_allocated.0);
-        1
-    } else {
-        0
-    }
-}
-
-/// emscripten: _emscripten_resize_heap
-/// Note: this function only allows growing the size of heap
-pub fn _emscripten_resize_heap(mut ctx: FunctionEnvMut<EmEnv>, requested_size: u32) -> u32 {
-    resize_heap(&mut ctx, requested_size)
-}
-
-/// emscripten: sbrk
-pub fn sbrk(mut ctx: FunctionEnvMut<EmEnv>, increment: i32) -> i32 {
-    debug!("emscripten::sbrk");
-    // let old_dynamic_top = 0;
-    // let new_dynamic_top = 0;
-    let top_ptr = get_emscripten_data(&ctx)
-        .as_ref()
-        .unwrap()
-        .globals
-        .dynamictop_ptr;
-
-    let dynamictop_ptr = WasmPtr::<i32>::new(top_ptr);
-    let old_dynamic_top = {
-        let memory = ctx.data().memory(0);
-        let memory = memory.view(&ctx);
-        dynamictop_ptr.deref(&memory).read().unwrap()
-    };
-    let new_dynamic_top: i32 = old_dynamic_top + increment;
-    let total_memory = get_heap_size(&ctx) as i32;
-    debug!(
-        " => PTR {}, old: {}, new: {}, increment: {}, total: {}",
-        dynamictop_ptr.offset(),
-        old_dynamic_top,
-        new_dynamic_top,
-        increment,
-        total_memory
-    );
-    if increment > 0 && new_dynamic_top < old_dynamic_top || new_dynamic_top < 0 {
-        abort_on_cannot_grow_memory_old(ctx);
-        return -1;
-    }
-    if new_dynamic_top > total_memory {
-        let resized = resize_heap(&mut ctx, new_dynamic_top as u32);
-        if resized == 0 {
-            return -1;
-        }
-    }
-    // re-borrow the top ptr
-    let memory = ctx.data().memory(0);
-    let memory = memory.view(&ctx);
-    let dynamictop_ptr = WasmPtr::<i32>::new(top_ptr).deref(&memory);
-    dynamictop_ptr.write(new_dynamic_top).unwrap();
-    old_dynamic_top as _
-}
-
-/// emscripten: getTotalMemory
-pub fn get_total_memory(ctx: FunctionEnvMut<EmEnv>) -> u32 {
-    debug!("emscripten::get_total_memory");
-    // instance.memories[0].current_pages()
-    // TODO: Fix implementation
-    let memory = ctx.data().memory(0);
-    memory.view(&ctx).size().bytes().0 as u32
-}
-
-/// emscripten: enlargeMemory
-pub fn enlarge_memory(_ctx: FunctionEnvMut<EmEnv>) -> u32 {
-    debug!("emscripten::enlarge_memory");
-    // instance.memories[0].grow(100);
-    // TODO: Fix implementation
-    0
-}
-
-/// emscripten: abortOnCannotGrowMemory
-pub fn abort_on_cannot_grow_memory(ctx: FunctionEnvMut<EmEnv>, _requested_size: u32) -> u32 {
-    debug!(
-        "emscripten::abort_on_cannot_grow_memory {}",
-        _requested_size
-    );
-    abort_with_message(ctx, "Cannot enlarge memory arrays!");
-    0
-}
-
-/// emscripten: abortOnCannotGrowMemory
-pub fn abort_on_cannot_grow_memory_old(ctx: FunctionEnvMut<EmEnv>) -> u32 {
-    debug!("emscripten::abort_on_cannot_grow_memory");
-    abort_with_message(ctx, "Cannot enlarge memory arrays!");
-    0
-}
-
-/// emscripten: segfault
-pub fn segfault(ctx: FunctionEnvMut<EmEnv>) {
-    debug!("emscripten::segfault");
-    abort_with_message(ctx, "segmentation fault");
-}
-
-/// emscripten: alignfault
-pub fn alignfault(ctx: FunctionEnvMut<EmEnv>) {
-    debug!("emscripten::alignfault");
-    abort_with_message(ctx, "alignment fault");
-}
-
-/// emscripten: ftfault
-pub fn ftfault(ctx: FunctionEnvMut<EmEnv>) {
-    debug!("emscripten::ftfault");
-    abort_with_message(ctx, "Function table mask error");
-}
-
-/// emscripten: ___map_file
-pub fn ___map_file(_ctx: FunctionEnvMut<EmEnv>, _one: u32, _two: u32) -> c_int {
-    debug!("emscripten::___map_file");
-    // NOTE: TODO: Em returns -1 here as well. May need to implement properly
-    -1
-}
diff --git a/lib/emscripten/src/process.rs b/lib/emscripten/src/process.rs
deleted file mode 100644
index 9156f2f2c3..0000000000
--- a/lib/emscripten/src/process.rs
+++ /dev/null
@@ -1,203 +0,0 @@
-use libc::{abort, c_int, exit, EAGAIN};
-
-#[cfg(not(target_os = "windows"))]
-type PidT = libc::pid_t;
-#[cfg(target_os = "windows")]
-type PidT = c_int;
-
-use crate::EmEnv;
-use wasmer::FunctionEnvMut;
-
-pub fn abort_with_message(ctx: FunctionEnvMut<EmEnv>, message: &str) {
-    debug!("emscripten::abort_with_message");
-    println!("{}", message);
-    _abort(ctx);
-}
-
-/// The name of this call is `abort` but we want to avoid conflicts with libc::abort
-pub fn em_abort(ctx: FunctionEnvMut<EmEnv>, arg: u32) {
-    debug!("emscripten::abort");
-    eprintln!("Program aborted with value {}", arg);
-    _abort(ctx);
-}
-
-pub fn _abort(_ctx: FunctionEnvMut<EmEnv>) {
-    debug!("emscripten::_abort");
-    unsafe {
-        abort();
-    }
-}
-
-pub fn _prctl(ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
-    debug!("emscripten::_prctl");
-    abort_with_message(ctx, "missing function: prctl");
-    -1
-}
-
-pub fn _fork(_ctx: FunctionEnvMut<EmEnv>) -> PidT {
-    debug!("emscripten::_fork");
-    // unsafe {
-    //     fork()
-    // }
-    -1
-}
-
-pub fn _endgrent(_ctx: FunctionEnvMut<EmEnv>) {
-    debug!("emscripten::_endgrent");
-}
-
-pub fn _execve(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32, _three: i32) -> i32 {
-    debug!("emscripten::_execve");
-    -1
-}
-
-#[allow(unreachable_code)]
-pub fn _exit(_ctx: FunctionEnvMut<EmEnv>, status: c_int) {
-    // -> !
-    debug!("emscripten::_exit {}", status);
-    unsafe { exit(status) }
-}
-
-pub fn _kill(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::_kill");
-    -1
-}
-
-pub fn _sched_yield(_ctx: FunctionEnvMut<EmEnv>) -> i32 {
-    debug!("emscripten::_sched_yield");
-    -1
-}
-
-pub fn _llvm_stacksave(_ctx: FunctionEnvMut<EmEnv>) -> i32 {
-    debug!("emscripten::_llvm_stacksave");
-    -1
-}
-
-pub fn _llvm_stackrestore(_ctx: FunctionEnvMut<EmEnv>, _one: i32) {
-    debug!("emscripten::_llvm_stackrestore");
-}
-
-pub fn _raise(_ctx: FunctionEnvMut<EmEnv>, _one: i32) -> i32 {
-    debug!("emscripten::_raise");
-    -1
-}
-
-pub fn _sem_init(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32, _three: i32) -> i32 {
-    debug!("emscripten::_sem_init: {}, {}, {}", _one, _two, _three);
-    0
-}
-
-pub fn _sem_destroy(_ctx: FunctionEnvMut<EmEnv>, _one: i32) -> i32 {
-    debug!("emscripten::_sem_destroy");
-    0
-}
-
-pub fn _sem_post(_ctx: FunctionEnvMut<EmEnv>, _one: i32) -> i32 {
-    debug!("emscripten::_sem_post");
-    -1
-}
-
-pub fn _sem_wait(_ctx: FunctionEnvMut<EmEnv>, _one: i32) -> i32 {
-    debug!("emscripten::_sem_post");
-    -1
-}
-
-#[allow(clippy::cast_ptr_alignment)]
-pub fn _getgrent(_ctx: FunctionEnvMut<EmEnv>) -> c_int {
-    debug!("emscripten::_getgrent");
-    -1
-}
-
-pub fn _setgrent(_ctx: FunctionEnvMut<EmEnv>) {
-    debug!("emscripten::_setgrent");
-}
-
-pub fn _setgroups(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::_setgroups");
-    -1
-}
-
-pub fn _setitimer(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32, _three: i32) -> i32 {
-    debug!("emscripten::_setitimer");
-    -1
-}
-
-pub fn _usleep(_ctx: FunctionEnvMut<EmEnv>, _one: i32) -> i32 {
-    debug!("emscripten::_usleep");
-    -1
-}
-
-pub fn _nanosleep(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::_nanosleep");
-    -1
-}
-
-pub fn _utime(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::_utime");
-    -1
-}
-
-pub fn _utimes(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::_utimes");
-    -1
-}
-
-pub fn _wait(_ctx: FunctionEnvMut<EmEnv>, _one: i32) -> i32 {
-    debug!("emscripten::_wait");
-    -1
-}
-
-pub fn _wait3(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32, _three: i32) -> i32 {
-    debug!("emscripten::_wait3");
-    -1
-}
-
-pub fn _wait4(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32, _three: i32, _d: i32) -> i32 {
-    debug!("emscripten::_wait4");
-    -1
-}
-
-pub fn _waitid(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32, _three: i32, _d: i32) -> i32 {
-    debug!("emscripten::_waitid");
-    -1
-}
-
-pub fn _waitpid(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32, _three: i32) -> i32 {
-    debug!("emscripten::_waitpid");
-    -1
-}
-
-pub fn abort_stack_overflow(ctx: FunctionEnvMut<EmEnv>, _what: c_int) {
-    debug!("emscripten::abort_stack_overflow");
-    // TODO: Message incomplete. Need to finish em runtime data first
-    abort_with_message(
-        ctx,
-        "Stack overflow! Attempted to allocate some bytes on the stack",
-    );
-}
-
-pub fn _llvm_trap(ctx: FunctionEnvMut<EmEnv>) {
-    debug!("emscripten::_llvm_trap");
-    abort_with_message(ctx, "abort!");
-}
-
-pub fn _llvm_eh_typeid_for(_ctx: FunctionEnvMut<EmEnv>, _type_info_addr: u32) -> i32 {
-    debug!("emscripten::_llvm_eh_typeid_for");
-    -1
-}
-
-pub fn _system(_ctx: FunctionEnvMut<EmEnv>, _one: i32) -> c_int {
-    debug!("emscripten::_system");
-    // TODO: May need to change this Em impl to a working version
-    eprintln!("Can't call external programs");
-    EAGAIN
-}
-
-pub fn _popen(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> c_int {
-    debug!("emscripten::_popen");
-    // TODO: May need to change this Em impl to a working version
-    eprintln!("Missing function: popen");
-    unsafe {
-        abort();
-    }
-}
diff --git a/lib/emscripten/src/pthread.rs b/lib/emscripten/src/pthread.rs
deleted file mode 100644
index 322a1b0326..0000000000
--- a/lib/emscripten/src/pthread.rs
+++ /dev/null
@@ -1,198 +0,0 @@
-use crate::EmEnv;
-use wasmer::FunctionEnvMut;
-
-pub fn _pthread_attr_destroy(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
-    trace!("emscripten::_pthread_attr_destroy");
-    0
-}
-
-pub fn _pthread_attr_getstack(
-    mut _ctx: FunctionEnvMut<EmEnv>,
-    _stackaddr: i32,
-    _stacksize: i32,
-    _other: i32,
-) -> i32 {
-    trace!(
-        "emscripten::_pthread_attr_getstack({}, {}, {})",
-        _stackaddr,
-        _stacksize,
-        _other
-    );
-    // TODO: Translate from Emscripten
-    // HEAP32[stackaddr >> 2] = STACK_BASE;
-    // HEAP32[stacksize >> 2] = TOTAL_STACK;
-    0
-}
-
-pub fn _pthread_attr_init(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
-    trace!("emscripten::_pthread_attr_init({})", _a);
-    0
-}
-
-pub fn _pthread_attr_setstacksize(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
-    trace!("emscripten::_pthread_attr_setstacksize");
-    0
-}
-
-pub fn _pthread_cleanup_pop(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) {
-    trace!("emscripten::_pthread_cleanup_pop");
-}
-
-pub fn _pthread_cleanup_push(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) {
-    trace!("emscripten::_pthread_cleanup_push");
-}
-
-pub fn _pthread_cond_destroy(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
-    trace!("emscripten::_pthread_cond_destroy");
-    0
-}
-
-pub fn _pthread_cond_init(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
-    trace!("emscripten::_pthread_cond_init");
-    0
-}
-
-pub fn _pthread_cond_signal(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
-    trace!("emscripten::_pthread_cond_signal");
-    0
-}
-
-pub fn _pthread_cond_timedwait(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32, _c: i32) -> i32 {
-    trace!("emscripten::_pthread_cond_timedwait");
-    0
-}
-
-pub fn _pthread_cond_wait(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
-    trace!("emscripten::_pthread_cond_wait");
-    0
-}
-
-pub fn _pthread_condattr_destroy(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
-    trace!("emscripten::_pthread_condattr_destroy");
-    0
-}
-
-pub fn _pthread_condattr_init(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
-    trace!("emscripten::_pthread_condattr_init");
-    0
-}
-
-pub fn _pthread_condattr_setclock(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
-    trace!("emscripten::_pthread_condattr_setclock");
-    0
-}
-
-pub fn _pthread_create(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32, _c: i32, _d: i32) -> i32 {
-    trace!("emscripten::_pthread_create");
-    // 11 seems to mean "no"
-    11
-}
-
-pub fn _pthread_detach(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
-    trace!("emscripten::_pthread_detach");
-    0
-}
-
-pub fn _pthread_equal(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
-    trace!("emscripten::_pthread_equal");
-    0
-}
-
-pub fn _pthread_exit(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) {
-    trace!("emscripten::_pthread_exit");
-}
-
-pub fn _pthread_getattr_np(mut _ctx: FunctionEnvMut<EmEnv>, _thread: i32, _attr: i32) -> i32 {
-    trace!("emscripten::_pthread_getattr_np({}, {})", _thread, _attr);
-    0
-}
-
-pub fn _pthread_getspecific(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
-    trace!("emscripten::_pthread_getspecific");
-    0
-}
-
-pub fn _pthread_join(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
-    trace!("emscripten::_pthread_join");
-    0
-}
-
-pub fn _pthread_self(mut _ctx: FunctionEnvMut<EmEnv>) -> i32 {
-    trace!("emscripten::_pthread_self");
-    0
-}
-
-pub fn _pthread_key_create(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
-    trace!("emscripten::_pthread_key_create");
-    0
-}
-
-pub fn _pthread_mutex_destroy(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
-    trace!("emscripten::_pthread_mutex_destroy");
-    0
-}
-
-pub fn _pthread_mutex_init(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
-    trace!("emscripten::_pthread_mutex_init");
-    0
-}
-
-pub fn _pthread_mutexattr_destroy(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
-    trace!("emscripten::_pthread_mutexattr_destroy");
-    0
-}
-
-pub fn _pthread_mutexattr_init(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
-    trace!("emscripten::_pthread_mutexattr_init");
-    0
-}
-
-pub fn _pthread_mutexattr_settype(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
-    trace!("emscripten::_pthread_mutexattr_settype");
-    0
-}
-
-pub fn _pthread_once(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
-    trace!("emscripten::_pthread_once");
-    0
-}
-
-pub fn _pthread_rwlock_destroy(mut _ctx: FunctionEnvMut<EmEnv>, _rwlock: i32) -> i32 {
-    trace!("emscripten::_pthread_rwlock_destroy({})", _rwlock);
-    0
-}
-
-pub fn _pthread_rwlock_init(mut _ctx: FunctionEnvMut<EmEnv>, _rwlock: i32, _attr: i32) -> i32 {
-    trace!("emscripten::_pthread_rwlock_init({}, {})", _rwlock, _attr);
-    0
-}
-
-pub fn _pthread_rwlock_rdlock(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
-    trace!("emscripten::_pthread_rwlock_rdlock");
-    0
-}
-
-pub fn _pthread_rwlock_unlock(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
-    trace!("emscripten::_pthread_rwlock_unlock");
-    0
-}
-
-pub fn _pthread_rwlock_wrlock(mut _ctx: FunctionEnvMut<EmEnv>, _rwlock: i32) -> i32 {
-    trace!("emscripten::_pthread_rwlock_wrlock({})", _rwlock);
-    0
-}
-
-pub fn _pthread_setcancelstate(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
-    trace!("emscripten::_pthread_setcancelstate");
-    0
-}
-
-pub fn _pthread_setspecific(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
-    trace!("emscripten::_pthread_setspecific");
-    0
-}
-
-pub fn _pthread_sigmask(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32, _c: i32) -> i32 {
-    trace!("emscripten::_pthread_sigmask");
-    0
-}
diff --git a/lib/emscripten/src/signal.rs b/lib/emscripten/src/signal.rs
deleted file mode 100644
index 52386cd31c..0000000000
--- a/lib/emscripten/src/signal.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-// use super::varargs::VarArgs;
-use crate::EmEnv;
-use wasmer::FunctionEnvMut;
-
-#[allow(clippy::cast_ptr_alignment)]
-pub fn _sigemptyset(ctx: FunctionEnvMut<EmEnv>, set: u32) -> i32 {
-    debug!("emscripten::_sigemptyset");
-    let memory = ctx.data().memory(0);
-    let set_addr = emscripten_memory_pointer!(memory.view(&ctx), set) as *mut u32;
-    unsafe {
-        *set_addr = 0;
-    }
-    0
-}
-
-pub fn _sigaction(_ctx: FunctionEnvMut<EmEnv>, _signum: u32, _act: u32, _oldact: u32) -> i32 {
-    debug!("emscripten::_sigaction {}, {}, {}", _signum, _act, _oldact);
-    0
-}
-
-pub fn _siginterrupt(_ctx: FunctionEnvMut<EmEnv>, _a: u32, _b: u32) -> i32 {
-    debug!("emscripten::_siginterrupt {}, {}", _a, _b);
-    0
-}
-
-#[allow(clippy::cast_ptr_alignment)]
-pub fn _sigaddset(ctx: FunctionEnvMut<EmEnv>, set: u32, signum: u32) -> i32 {
-    debug!("emscripten::_sigaddset {}, {}", set, signum);
-    let memory = ctx.data().memory(0);
-    let set_addr = emscripten_memory_pointer!(memory.view(&ctx), set) as *mut u32;
-    unsafe {
-        *set_addr |= 1 << (signum - 1);
-    }
-    0
-}
-
-pub fn _sigsuspend(_ctx: FunctionEnvMut<EmEnv>, _one: i32) -> i32 {
-    debug!("emscripten::_sigsuspend");
-    -1
-}
-
-pub fn _sigprocmask(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32, _three: i32) -> i32 {
-    debug!("emscripten::_sigprocmask");
-    0
-}
-
-pub fn _signal(_ctx: FunctionEnvMut<EmEnv>, _sig: u32, _two: i32) -> i32 {
-    debug!("emscripten::_signal ({})", _sig);
-    0
-}
diff --git a/lib/emscripten/src/storage.rs b/lib/emscripten/src/storage.rs
deleted file mode 100644
index 394b15c7e7..0000000000
--- a/lib/emscripten/src/storage.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-// use crate::webassembly::Memory;
-
-pub fn align_memory(ptr: u32) -> u32 {
-    (ptr + 15) & !15
-}
-
-pub fn static_alloc(static_top: &mut u32, size: u32) -> u32 {
-    let old_static_top = *static_top;
-    // NOTE: The `4294967280` is a u32 conversion of -16 as gotten from emscripten.
-    *static_top = (*static_top + size + 15) & 4294967280;
-    old_static_top
-}
diff --git a/lib/emscripten/src/syscalls/mod.rs b/lib/emscripten/src/syscalls/mod.rs
deleted file mode 100644
index 42ce7b1ece..0000000000
--- a/lib/emscripten/src/syscalls/mod.rs
+++ /dev/null
@@ -1,744 +0,0 @@
-#[cfg(unix)]
-mod unix;
-
-#[cfg(windows)]
-mod windows;
-
-#[cfg(unix)]
-pub use self::unix::*;
-
-#[cfg(windows)]
-pub use self::windows::*;
-
-use crate::{
-    utils::{copy_stat_into_wasm, get_cstr_path, get_current_directory},
-    EmEnv,
-};
-
-use super::varargs::VarArgs;
-use byteorder::{ByteOrder, LittleEndian};
-/// NOTE: TODO: These syscalls only support wasm_32 for now because they assume offsets are u32
-/// Syscall list: https://www.cs.utexas.edu/~bismith/test/syscalls/syscalls32.html
-use libc::{
-    c_int,
-    c_void,
-    chdir,
-    // setsockopt, getppid
-    close,
-    dup2,
-    exit,
-    fstat,
-    getpid,
-    // readlink,
-    // iovec,
-    lseek,
-    //    open,
-    read,
-    rename,
-    // sockaddr_in,
-    // readv,
-    rmdir,
-    // writev,
-    stat,
-    write,
-    // ENOTTY,
-};
-
-use super::env;
-#[allow(unused_imports)]
-use std::io::Error;
-use std::slice;
-use wasmer::{FunctionEnvMut, WasmPtr};
-
-/// exit
-pub fn ___syscall1(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) {
-    debug!("emscripten::___syscall1 (exit) {}", _which);
-    let status: i32 = varargs.get(&ctx);
-    unsafe {
-        exit(status);
-    }
-}
-
-/// read
-pub fn ___syscall3(ctx: FunctionEnvMut<EmEnv>, _which: i32, mut varargs: VarArgs) -> i32 {
-    // -> ssize_t
-    debug!("emscripten::___syscall3 (read) {}", _which);
-    let fd: i32 = varargs.get(&ctx);
-    let buf: u32 = varargs.get(&ctx);
-    let count: i32 = varargs.get(&ctx);
-    debug!("=> fd: {}, buf_offset: {}, count: {}", fd, buf, count);
-    let memory = ctx.data().memory(0);
-    let buf_addr = emscripten_memory_pointer!(memory.view(&ctx), buf) as *mut c_void;
-    let ret = unsafe { read(fd, buf_addr, count as _) };
-    debug!("=> ret: {}", ret);
-    ret as _
-}
-
-/// write
-pub fn ___syscall4(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall4 (write) {}", _which);
-    let fd: i32 = varargs.get(&ctx);
-    let buf: i32 = varargs.get(&ctx);
-    let count: i32 = varargs.get(&ctx);
-    debug!("=> fd: {}, buf: {}, count: {}", fd, buf, count);
-    let memory = ctx.data().memory(0);
-    let buf_addr = emscripten_memory_pointer!(memory.view(&ctx), buf) as *const c_void;
-    unsafe { write(fd, buf_addr, count as _) as i32 }
-}
-
-/// close
-pub fn ___syscall6(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall6 (close) {}", _which);
-    let fd: i32 = varargs.get(&ctx);
-    debug!("fd: {}", fd);
-    unsafe { close(fd) }
-}
-
-// chdir
-pub fn ___syscall12(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall12 (chdir) {}", _which);
-    let path_ptr = varargs.get_str(&ctx);
-    let real_path_owned = get_cstr_path(ctx, path_ptr as *const _);
-    let real_path = if let Some(ref rp) = real_path_owned {
-        rp.as_c_str().as_ptr()
-    } else {
-        path_ptr
-    };
-    let ret = unsafe { chdir(real_path) };
-    debug!(
-        "=> path: {:?}, ret: {}",
-        unsafe { std::ffi::CStr::from_ptr(real_path) },
-        ret
-    );
-    ret
-}
-
-pub fn ___syscall10(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall10");
-    -1
-}
-
-pub fn ___syscall14(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall14");
-    -1
-}
-
-pub fn ___syscall15(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall15");
-    -1
-}
-
-// getpid
-pub fn ___syscall20(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall20 (getpid)");
-    unsafe { getpid() }
-}
-
-pub fn ___syscall21(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall21");
-    -1
-}
-
-pub fn ___syscall25(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall25");
-    -1
-}
-
-pub fn ___syscall29(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall29");
-    -1
-}
-
-pub fn ___syscall32(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall32");
-    -1
-}
-
-pub fn ___syscall33(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall33");
-    -1
-}
-
-pub fn ___syscall36(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall36");
-    -1
-}
-
-// rename
-pub fn ___syscall38(mut ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> i32 {
-    debug!("emscripten::___syscall38 (rename)");
-    let old_path = varargs.get_str(&ctx);
-    let new_path = varargs.get_str(&ctx);
-    let real_old_path_owned = get_cstr_path(ctx.as_mut(), old_path as *const _);
-    let real_old_path = if let Some(ref rp) = real_old_path_owned {
-        rp.as_c_str().as_ptr()
-    } else {
-        old_path
-    };
-    let real_new_path_owned = get_cstr_path(ctx, new_path as *const _);
-    let real_new_path = if let Some(ref rp) = real_new_path_owned {
-        rp.as_c_str().as_ptr()
-    } else {
-        new_path
-    };
-    let result = unsafe { rename(real_old_path, real_new_path) };
-    debug!(
-        "=> old_path: {}, new_path: {}, result: {}",
-        unsafe { std::ffi::CStr::from_ptr(real_old_path).to_str().unwrap() },
-        unsafe { std::ffi::CStr::from_ptr(real_new_path).to_str().unwrap() },
-        result
-    );
-    result
-}
-
-// rmdir
-pub fn ___syscall40(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall40 (rmdir)");
-    let pathname_addr = varargs.get_str(&ctx);
-    let real_path_owned = get_cstr_path(ctx, pathname_addr as *const _);
-    let real_path = if let Some(ref rp) = real_path_owned {
-        rp.as_c_str().as_ptr()
-    } else {
-        pathname_addr
-    };
-    unsafe { rmdir(real_path) }
-}
-
-// pipe
-pub fn ___syscall42(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall42 (pipe)");
-    // offset to a file descriptor, which contains a read end and write end, 2 integers
-    let fd_offset: u32 = varargs.get(&ctx);
-
-    let memory = ctx.data().memory(0);
-    let emscripten_memory = memory.view(&ctx);
-
-    // convert the file descriptor into a vec with two slots
-    let mut fd_vec: [c_int; 2] = WasmPtr::<[c_int; 2]>::new(fd_offset)
-        .deref(&emscripten_memory)
-        .read()
-        .unwrap();
-
-    // get it as a mutable pointer
-    let fd_ptr = fd_vec.as_mut_ptr();
-
-    // call pipe and store the pointers in this array
-    #[cfg(target_os = "windows")]
-    let result: c_int = unsafe { libc::pipe(fd_ptr, 2048, 0) };
-    #[cfg(not(target_os = "windows"))]
-    let result: c_int = unsafe { libc::pipe(fd_ptr) };
-    if result == -1 {
-        debug!("=> os error: {}", Error::last_os_error());
-    }
-    result
-}
-
-pub fn ___syscall51(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall51");
-    -1
-}
-
-pub fn ___syscall52(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall52");
-    -1
-}
-
-pub fn ___syscall53(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall53");
-    -1
-}
-
-pub fn ___syscall60(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall60");
-    -1
-}
-
-// dup2
-pub fn ___syscall63(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall63 (dup2) {}", _which);
-
-    let src: i32 = varargs.get(&ctx);
-    let dst: i32 = varargs.get(&ctx);
-
-    unsafe { dup2(src, dst) }
-}
-
-// getppid
-pub fn ___syscall64(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall64 (getppid)");
-    unsafe { getpid() }
-}
-
-pub fn ___syscall66(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall66");
-    -1
-}
-
-pub fn ___syscall75(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall75");
-    -1
-}
-
-pub fn ___syscall91(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall91 - stub");
-    0
-}
-
-pub fn ___syscall96(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall96");
-    -1
-}
-
-pub fn ___syscall97(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall97");
-    -1
-}
-
-pub fn ___syscall110(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall110");
-    -1
-}
-
-pub fn ___syscall121(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall121");
-    -1
-}
-
-pub fn ___syscall125(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall125");
-    -1
-}
-
-pub fn ___syscall133(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall133");
-    -1
-}
-
-pub fn ___syscall144(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall144");
-    -1
-}
-
-pub fn ___syscall147(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall147");
-    -1
-}
-
-pub fn ___syscall150(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall150");
-    -1
-}
-
-pub fn ___syscall151(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall151");
-    -1
-}
-
-pub fn ___syscall152(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall152");
-    -1
-}
-
-pub fn ___syscall153(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall153");
-    -1
-}
-
-pub fn ___syscall163(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall163");
-    -1
-}
-
-// getcwd
-pub fn ___syscall183(mut ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> i32 {
-    debug!("emscripten::___syscall183");
-    let buf_offset: WasmPtr<libc::c_char> = varargs.get(&ctx);
-    let _size: c_int = varargs.get(&ctx);
-    let path = get_current_directory(ctx.as_mut());
-    let path_string = path.unwrap().display().to_string();
-    let len = path_string.len();
-    let memory = ctx.data().memory(0);
-    let memory = memory.view(&ctx);
-
-    let buf_writer = buf_offset.slice(&memory, len as u32 + 1).unwrap();
-    for (i, byte) in path_string.bytes().enumerate() {
-        buf_writer.index(i as u64).write(byte as _).unwrap();
-    }
-    buf_writer.index(len as u64).write(0).unwrap();
-    buf_offset.offset() as i32
-}
-
-// mmap2
-pub fn ___syscall192(mut ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall192 (mmap2) {}", _which);
-    let _addr: i32 = varargs.get(&ctx);
-    let len: u32 = varargs.get(&ctx);
-    let _prot: i32 = varargs.get(&ctx);
-    let _flags: i32 = varargs.get(&ctx);
-    let fd: i32 = varargs.get(&ctx);
-    let _off: i32 = varargs.get(&ctx);
-    debug!(
-        "=> addr: {}, len: {}, prot: {}, flags: {}, fd: {}, off: {}",
-        _addr, len, _prot, _flags, fd, _off
-    );
-
-    if fd == -1 {
-        let ptr = env::call_memalign(&mut ctx, 16384, len);
-        if ptr == 0 {
-            // ENOMEM
-            return -12;
-        }
-        let memory = ctx.data().memory(0);
-        let real_ptr = emscripten_memory_pointer!(memory.view(&ctx), ptr) as *const u8;
-        env::call_memset(&mut ctx, ptr, 0, len);
-        for i in 0..(len as usize) {
-            unsafe {
-                assert_eq!(*real_ptr.add(i), 0);
-            }
-        }
-        debug!("=> ptr: {}", ptr);
-        ptr as i32
-    } else {
-        // return ENODEV
-        -19
-    }
-}
-
-/// lseek
-pub fn ___syscall140(ctx: FunctionEnvMut<EmEnv>, _which: i32, mut varargs: VarArgs) -> i32 {
-    // -> c_int
-    debug!("emscripten::___syscall140 (lseek) {}", _which);
-    let fd: i32 = varargs.get(&ctx);
-    let _offset_high: u32 = varargs.get(&ctx); // We don't use the offset high as emscripten skips it
-    let offset_low: u32 = varargs.get(&ctx);
-    let result_ptr_value: WasmPtr<i64> = varargs.get(&ctx);
-    let whence: i32 = varargs.get(&ctx);
-    let offset = offset_low;
-    let ret = unsafe { lseek(fd, offset as _, whence) as i64 };
-    let memory = ctx.data().memory(0);
-    let memory = memory.view(&ctx);
-
-    let result_ptr = result_ptr_value.deref(&memory);
-    result_ptr.write(ret).unwrap();
-
-    debug!(
-        "=> fd: {}, offset: {}, result: {}, whence: {} = {}\nlast os error: {}",
-        fd,
-        offset,
-        ret,
-        whence,
-        0,
-        Error::last_os_error(),
-    );
-    0
-}
-
-/// readv
-#[allow(clippy::cast_ptr_alignment)]
-pub fn ___syscall145(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> i32 {
-    // -> ssize_t
-    debug!("emscripten::___syscall145 (readv) {}", _which);
-
-    let fd: i32 = varargs.get(&ctx);
-    let iov: i32 = varargs.get(&ctx);
-    let iovcnt: i32 = varargs.get(&ctx);
-
-    #[repr(C)]
-    struct GuestIovec {
-        iov_base: i32,
-        iov_len: i32,
-    }
-
-    debug!("=> fd: {}, iov: {}, iovcnt = {}", fd, iov, iovcnt);
-    let mut ret = 0;
-    unsafe {
-        for i in 0..iovcnt {
-            let memory = ctx.data().memory(0);
-            let guest_iov_addr =
-                emscripten_memory_pointer!(memory.view(&ctx), (iov + i * 8)) as *mut GuestIovec;
-            let iov_base = emscripten_memory_pointer!(memory.view(&ctx), (*guest_iov_addr).iov_base)
-                as *mut c_void;
-            let iov_len = (*guest_iov_addr).iov_len as _;
-            // debug!("=> iov_addr: {:?}, {:?}", iov_base, iov_len);
-            let curr = read(fd, iov_base, iov_len);
-            if curr < 0 {
-                return -1;
-            }
-            ret += curr;
-        }
-        // debug!(" => ret: {}", ret);
-        ret as _
-    }
-}
-
-// writev
-#[allow(clippy::cast_ptr_alignment)]
-pub fn ___syscall146(ctx: FunctionEnvMut<EmEnv>, _which: i32, mut varargs: VarArgs) -> i32 {
-    // -> ssize_t
-    debug!("emscripten::___syscall146 (writev) {}", _which);
-    let fd: i32 = varargs.get(&ctx);
-    let iov: i32 = varargs.get(&ctx);
-    let iovcnt: i32 = varargs.get(&ctx);
-
-    #[repr(C)]
-    struct GuestIovec {
-        iov_base: i32,
-        iov_len: i32,
-    }
-
-    debug!("=> fd: {}, iov: {}, iovcnt = {}", fd, iov, iovcnt);
-    let mut ret = 0;
-    for i in 0..iovcnt {
-        unsafe {
-            let memory = ctx.data().memory(0);
-            let guest_iov_addr =
-                emscripten_memory_pointer!(memory.view(&ctx), (iov + i * 8)) as *mut GuestIovec;
-            let iov_base = emscripten_memory_pointer!(memory.view(&ctx), (*guest_iov_addr).iov_base)
-                as *const c_void;
-            let iov_len = (*guest_iov_addr).iov_len as _;
-            // debug!("=> iov_addr: {:?}, {:?}", iov_base, iov_len);
-            let curr = write(fd, iov_base, iov_len);
-            debug!(
-                "=> iov_base: {}, iov_len: {}, curr = {}",
-                (*guest_iov_addr).iov_base,
-                iov_len,
-                curr
-            );
-            if curr < 0 {
-                debug!("=> os error: {}", Error::last_os_error());
-                return -1;
-            }
-            ret += curr;
-        }
-    }
-    debug!(" => ret: {}", ret);
-    ret as _
-}
-
-pub fn ___syscall191(ctx: FunctionEnvMut<EmEnv>, _which: i32, mut varargs: VarArgs) -> i32 {
-    let _resource: i32 = varargs.get(&ctx);
-    debug!(
-        "emscripten::___syscall191 - mostly stub, resource: {}",
-        _resource
-    );
-    let rlim_emptr: i32 = varargs.get(&ctx);
-    let memory = ctx.data().memory(0);
-    let rlim_ptr = emscripten_memory_pointer!(memory.view(&ctx), rlim_emptr) as *mut u8;
-    let rlim = unsafe { slice::from_raw_parts_mut(rlim_ptr, 16) };
-
-    // set all to RLIM_INIFINTY
-    LittleEndian::write_i64(&mut *rlim, -1);
-    LittleEndian::write_i64(&mut rlim[8..], -1);
-
-    0
-}
-
-pub fn ___syscall193(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall193");
-    -1
-}
-
-// stat64
-pub fn ___syscall195(mut ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall195 (stat64) {}", _which);
-    let pathname_addr = varargs.get_str(&ctx);
-    let buf: u32 = varargs.get(&ctx);
-
-    let real_path_owned = get_cstr_path(ctx.as_mut(), pathname_addr as *const _);
-    let real_path = if let Some(ref rp) = real_path_owned {
-        rp.as_c_str().as_ptr()
-    } else {
-        pathname_addr
-    };
-
-    unsafe {
-        let mut _stat: stat = std::mem::zeroed();
-        let ret = stat(real_path, &mut _stat);
-        debug!(
-            "=> pathname: {}, buf: {} = {}",
-            std::ffi::CStr::from_ptr(real_path).to_str().unwrap(),
-            buf,
-            ret
-        );
-        if ret != 0 {
-            debug!("=> os error: {}", Error::last_os_error());
-            return ret;
-        }
-        copy_stat_into_wasm(ctx, buf, &_stat);
-    }
-    0
-}
-
-// fstat64
-pub fn ___syscall197(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall197 (fstat64) {}", _which);
-
-    let fd: c_int = varargs.get(&ctx);
-    let buf: u32 = varargs.get(&ctx);
-
-    unsafe {
-        let mut stat = std::mem::zeroed();
-        let ret = fstat(fd, &mut stat);
-        debug!("=> fd: {}, buf: {} = {}", fd, buf, ret);
-        if ret != 0 {
-            debug!("=> os error: {}", Error::last_os_error());
-            return ret;
-        }
-        copy_stat_into_wasm(ctx, buf, &stat);
-    }
-    0
-}
-
-pub fn ___syscall209(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall209");
-    -1
-}
-
-pub fn ___syscall211(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall211");
-    -1
-}
-
-pub fn ___syscall218(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall218");
-    -1
-}
-
-pub fn ___syscall268(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall268");
-    -1
-}
-
-pub fn ___syscall269(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall269");
-    -1
-}
-
-pub fn ___syscall272(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall272");
-    -1
-}
-
-pub fn ___syscall295(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall295");
-    -1
-}
-
-pub fn ___syscall296(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall296");
-    -1
-}
-
-pub fn ___syscall297(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall297");
-    -1
-}
-
-pub fn ___syscall298(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall298");
-    -1
-}
-
-pub fn ___syscall300(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall300");
-    -1
-}
-
-pub fn ___syscall301(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall301");
-    -1
-}
-
-pub fn ___syscall302(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall302");
-    -1
-}
-
-pub fn ___syscall303(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall303");
-    -1
-}
-
-pub fn ___syscall304(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall304");
-    -1
-}
-
-pub fn ___syscall305(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall305");
-    -1
-}
-
-pub fn ___syscall306(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall306");
-    -1
-}
-
-pub fn ___syscall307(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall307");
-    -1
-}
-
-pub fn ___syscall308(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall308");
-    -1
-}
-
-// utimensat
-pub fn ___syscall320(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall320 (utimensat), {}", _which);
-    0
-}
-
-pub fn ___syscall331(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall331");
-    -1
-}
-
-pub fn ___syscall333(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall333");
-    -1
-}
-
-pub fn ___syscall334(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall334");
-    -1
-}
-
-pub fn ___syscall337(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall337");
-    -1
-}
-
-// prlimit64
-pub fn ___syscall340(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall340 (prlimit64), {}", _which);
-    // NOTE: Doesn't really matter. Wasm modules cannot exceed WASM_PAGE_SIZE anyway.
-    let _pid: i32 = varargs.get(&ctx);
-    let resource: i32 = varargs.get(&ctx);
-    let _new_limit: u32 = varargs.get(&ctx);
-    let old_limit: u32 = varargs.get(&ctx);
-
-    let val = match resource {
-        // RLIMIT_NOFILE
-        7 => 1024,
-        _ => -1, // RLIM_INFINITY
-    };
-
-    if old_limit != 0 {
-        // just report no limits
-        let memory = ctx.data().memory(0);
-        let buf_ptr = emscripten_memory_pointer!(memory.view(&ctx), old_limit) as *mut u8;
-        let buf = unsafe { slice::from_raw_parts_mut(buf_ptr, 16) };
-
-        LittleEndian::write_i64(&mut *buf, val);
-        LittleEndian::write_i64(&mut buf[8..], val);
-    }
-
-    0
-}
-
-pub fn ___syscall345(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall345");
-    -1
-}
diff --git a/lib/emscripten/src/syscalls/unix.rs b/lib/emscripten/src/syscalls/unix.rs
deleted file mode 100644
index 74a90588fc..0000000000
--- a/lib/emscripten/src/syscalls/unix.rs
+++ /dev/null
@@ -1,1150 +0,0 @@
-use crate::{varargs::VarArgs, LibcDirWrapper};
-#[cfg(target_vendor = "apple")]
-use libc::size_t;
-/// NOTE: TODO: These syscalls only support wasm_32 for now because they assume offsets are u32
-/// Syscall list: https://www.cs.utexas.edu/~bismith/test/syscalls/syscalls32.html
-use libc::{
-    accept,
-    access,
-    bind,
-    c_char,
-    c_int,
-    c_ulong,
-    c_void,
-    chown,
-    // fcntl, setsockopt, getppid
-    connect,
-    dup,
-    dup2,
-    fchmod,
-    fchown,
-    fcntl,
-    // ENOTTY,
-    fsync,
-    getegid,
-    geteuid,
-    getgid,
-    getgroups,
-    getpeername,
-    getpgid,
-    getrusage,
-    getsockname,
-    getsockopt,
-    getuid,
-    gid_t,
-    in_addr_t,
-    in_port_t,
-    ioctl,
-    lchown,
-    link,
-    // iovec,
-    listen,
-    mkdir,
-    mode_t,
-    msghdr,
-    nice,
-    off_t,
-    open,
-    pid_t,
-    pread,
-    pwrite,
-    readdir,
-    // readv,
-    recvfrom,
-    recvmsg,
-    // ENOTTY,
-    rusage,
-    sa_family_t,
-    // writev,
-    select,
-    sendmsg,
-    sendto,
-    setpgid,
-    setsockopt,
-    sockaddr,
-    socket,
-    socklen_t,
-    stat,
-    symlink,
-    uid_t,
-    uname,
-    utsname,
-    EINVAL,
-    // sockaddr_in,
-    FIOCLEX,
-    FIONBIO,
-    F_GETFD,
-    F_SETFD,
-    SOL_SOCKET,
-    TIOCGWINSZ,
-    TIOCSPGRP,
-    // TCGETS,
-    // TCSETSW,
-};
-use wasmer::{FunctionEnvMut, ValueType, WasmPtr};
-
-// They are not exposed in in Rust libc in macOS
-const TCGETS: u64 = 0x5401;
-const TCSETSW: u64 = 0x5403;
-
-// `libc` constants as provided by `emscripten`. Maybe move to own file?
-const WASM_FIONBIO: u32 = 0x5421;
-const WASM_FIOCLEX: u32 = 0x5451;
-const WASM_TIOCSPGRP: u32 = 0x5410;
-const WASM_TIOCGWINSZ: u32 = 0x5413;
-const WASM_TCGETS: u32 = 0x5401;
-const WASM_TCSETSW: u32 = 0x5403;
-
-// Based on @syrusakbary sugerence at
-// https://github.com/wasmerio/wasmer/pull/532#discussion_r300837800
-fn translate_ioctl(wasm_ioctl: u32) -> c_ulong {
-    match wasm_ioctl {
-        WASM_FIOCLEX => FIOCLEX as _,
-        WASM_TIOCGWINSZ => TIOCGWINSZ as _,
-        WASM_TIOCSPGRP => TIOCSPGRP as _,
-        WASM_FIONBIO => FIONBIO as _,
-        WASM_TCGETS => TCGETS as _,
-        WASM_TCSETSW => TCSETSW as _,
-        _otherwise => {
-            unimplemented!("The ioctl {} is not yet implemented", wasm_ioctl);
-        }
-    }
-}
-
-#[allow(unused_imports)]
-use std::ffi::CStr;
-
-use crate::env::EmSockAddr;
-use crate::utils::{self, get_cstr_path};
-use crate::EmEnv;
-#[allow(unused_imports)]
-use std::io::Error;
-use std::mem;
-
-// Linking to functions that are not provided by rust libc
-#[cfg(target_vendor = "apple")]
-#[link(name = "c")]
-extern "C" {
-    pub fn wait4(pid: pid_t, status: *mut c_int, options: c_int, rusage: *mut rusage) -> pid_t;
-    pub fn madvise(addr: *mut c_void, len: size_t, advice: c_int) -> c_int;
-    pub fn fdatasync(fd: c_int) -> c_int;
-    pub fn lstat64(path: *const libc::c_char, buf: *mut c_void) -> c_int;
-}
-
-// Linking to functions that are not provided by rust libc
-#[cfg(target_os = "freebsd")]
-#[link(name = "c")]
-extern "C" {
-    pub fn wait4(pid: pid_t, status: *mut c_int, options: c_int, rusage: *mut rusage) -> pid_t;
-    pub fn fdatasync(fd: c_int) -> c_int;
-    pub fn ftruncate(fd: c_int, length: i64) -> c_int;
-    pub fn lstat(path: *const libc::c_char, buf: *mut stat) -> c_int;
-}
-
-#[cfg(not(any(target_os = "freebsd", target_vendor = "apple", target_os = "android")))]
-use libc::fallocate;
-#[cfg(target_os = "freebsd")]
-use libc::madvise;
-#[cfg(not(any(target_os = "freebsd", target_vendor = "apple")))]
-use libc::{fdatasync, ftruncate64, lstat, madvise, wait4};
-
-// Another conditional constant for name resolution: Macos et iOS use
-// SO_NOSIGPIPE as a setsockopt flag to disable SIGPIPE emission on socket.
-// Other platforms do otherwise.
-#[cfg(target_vendor = "apple")]
-use libc::SO_NOSIGPIPE;
-#[cfg(not(target_vendor = "apple"))]
-const SO_NOSIGPIPE: c_int = 0;
-
-/// open
-pub fn ___syscall5(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall5 (open) {}", _which);
-    let pathname_addr = varargs.get_str(&ctx);
-    let flags: i32 = varargs.get(&ctx);
-    let mode: u32 = varargs.get(&ctx);
-    let real_path_owned = utils::get_cstr_path(ctx, pathname_addr as *const _);
-    let real_path = if let Some(ref rp) = real_path_owned {
-        rp.as_c_str().as_ptr()
-    } else {
-        pathname_addr
-    };
-    let _path_str = unsafe { std::ffi::CStr::from_ptr(real_path).to_str().unwrap() };
-    let fd = unsafe { open(real_path, flags, mode) };
-    debug!(
-        "=> path: {}, flags: {}, mode: {} = fd: {}",
-        _path_str, flags, mode, fd,
-    );
-    if fd == -1 {
-        debug!("=> last os error: {}", Error::last_os_error(),);
-    }
-    fd
-}
-
-/// link
-pub fn ___syscall9(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall9 (link) {}", _which);
-
-    let oldname_ptr = varargs.get_str(&ctx);
-    let newname_ptr = varargs.get_str(&ctx);
-    let result = unsafe { link(oldname_ptr, newname_ptr) };
-    debug!(
-        "=> oldname: {}, newname: {}, result: {}",
-        unsafe { std::ffi::CStr::from_ptr(oldname_ptr).to_str().unwrap() },
-        unsafe { std::ffi::CStr::from_ptr(newname_ptr).to_str().unwrap() },
-        result,
-    );
-    result
-}
-
-/// getrusage
-pub fn ___syscall77(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall77 (getrusage) {}", _which);
-
-    let resource: c_int = varargs.get(&ctx);
-    let rusage_ptr: c_int = varargs.get(&ctx);
-    let memory = ctx.data().memory(0);
-    #[allow(clippy::cast_ptr_alignment)]
-    let rusage = emscripten_memory_pointer!(memory.view(&ctx), rusage_ptr) as *mut rusage;
-    assert_eq!(8, mem::align_of_val(&rusage));
-    unsafe { getrusage(resource, rusage) }
-}
-
-/// symlink
-pub fn ___syscall83(mut ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall83 (symlink) {}", _which);
-
-    let path1 = varargs.get_str(&ctx);
-    let path2 = varargs.get_str(&ctx);
-    let real_path1_owned = utils::get_cstr_path(ctx.as_mut(), path1 as *const _);
-    let real_path1 = if let Some(ref rp) = real_path1_owned {
-        rp.as_c_str().as_ptr()
-    } else {
-        path1
-    };
-    let real_path2_owned = utils::get_cstr_path(ctx, path2 as *const _);
-    let real_path2 = if let Some(ref rp) = real_path2_owned {
-        rp.as_c_str().as_ptr()
-    } else {
-        path2
-    };
-    let result = unsafe { symlink(real_path1, real_path2) };
-    debug!(
-        "=> path1: {}, path2: {}, result: {}",
-        unsafe { std::ffi::CStr::from_ptr(real_path1).to_str().unwrap() },
-        unsafe { std::ffi::CStr::from_ptr(real_path2).to_str().unwrap() },
-        result,
-    );
-    result
-}
-
-/// readlink
-pub fn ___syscall85(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> i32 {
-    debug!("emscripten::___syscall85 (readlink)");
-    let pathname_addr = varargs.get_str(&ctx);
-    let buf = varargs.get_str(&ctx);
-    // let buf_addr: i32 = varargs.get(&ctx);
-    let buf_size: i32 = varargs.get(&ctx);
-    let real_path_owned = get_cstr_path(ctx, pathname_addr as *const _);
-    let real_path = if let Some(ref rp) = real_path_owned {
-        rp.as_c_str().as_ptr()
-    } else {
-        pathname_addr
-    };
-
-    let ret = unsafe { libc::readlink(real_path, buf as _, buf_size as _) as i32 };
-    if ret == -1 {
-        debug!("readlink failed");
-        return ret;
-    }
-    debug!(
-        "=> path: {}, buf: {}, buf_size: {}, return: {} ",
-        unsafe { std::ffi::CStr::from_ptr(real_path).to_str().unwrap() },
-        unsafe { std::ffi::CStr::from_ptr(buf as _).to_str().unwrap() },
-        buf_size,
-        ret
-    );
-    ret
-}
-
-/// ftruncate64
-pub fn ___syscall194(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall194 (ftruncate64) {}", _which);
-    let _fd: c_int = varargs.get(&ctx);
-    let _length: i64 = varargs.get(&ctx);
-    #[cfg(not(any(target_os = "freebsd", target_vendor = "apple")))]
-    unsafe {
-        ftruncate64(_fd, _length)
-    }
-    #[cfg(target_os = "freebsd")]
-    unsafe {
-        ftruncate(_fd, _length)
-    }
-    #[cfg(target_vendor = "apple")]
-    unimplemented!("emscripten::___syscall194 (ftruncate64) {}", _which)
-}
-
-/// lchown
-pub fn ___syscall198(mut ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall198 (lchown) {}", _which);
-    let path_ptr = varargs.get_str(&ctx);
-    let real_path_owned = utils::get_cstr_path(ctx.as_mut(), path_ptr as *const _);
-    let real_path = if let Some(ref rp) = real_path_owned {
-        rp.as_c_str().as_ptr()
-    } else {
-        path_ptr
-    };
-    let uid: uid_t = varargs.get(&ctx);
-    let gid: gid_t = varargs.get(&ctx);
-    let result = unsafe { lchown(real_path, uid, gid) };
-    debug!(
-        "=> path: {}, uid: {}, gid: {}, result: {}",
-        unsafe { std::ffi::CStr::from_ptr(real_path).to_str().unwrap() },
-        uid,
-        gid,
-        result,
-    );
-    result
-}
-
-/// getgroups
-pub fn ___syscall205(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall205 (getgroups) {}", _which);
-    let ngroups_max: c_int = varargs.get(&ctx);
-    let groups: c_int = varargs.get(&ctx);
-
-    let memory = ctx.data().memory(0);
-    #[allow(clippy::cast_ptr_alignment)]
-    let gid_ptr = emscripten_memory_pointer!(memory.view(&ctx), groups) as *mut gid_t;
-    assert_eq!(4, mem::align_of_val(&gid_ptr));
-    let result = unsafe { getgroups(ngroups_max, gid_ptr) };
-    debug!(
-        "=> ngroups_max: {}, gid_ptr: {:?}, result: {}",
-        ngroups_max, gid_ptr, result,
-    );
-    result
-}
-
-// chown
-pub fn ___syscall212(mut ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall212 (chown) {}", _which);
-
-    let pathname_addr = varargs.get_str(&ctx);
-    let real_path_owned = utils::get_cstr_path(ctx.as_mut(), pathname_addr as *const _);
-    let real_path = if let Some(ref rp) = real_path_owned {
-        rp.as_c_str().as_ptr()
-    } else {
-        pathname_addr
-    };
-    let owner: u32 = varargs.get(&ctx);
-    let group: u32 = varargs.get(&ctx);
-
-    unsafe { chown(real_path, owner, group) }
-}
-
-/// madvise
-pub fn ___syscall219(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall212 (chown) {}", _which);
-
-    let addr_ptr: c_int = varargs.get(&ctx);
-    let len: usize = varargs.get(&ctx);
-    let advice: c_int = varargs.get(&ctx);
-
-    let memory = ctx.data().memory(0);
-    let addr = emscripten_memory_pointer!(memory.view(&ctx), addr_ptr) as *mut c_void;
-
-    unsafe { madvise(addr, len, advice) }
-}
-
-/// access
-pub fn ___syscall33(mut ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall33 (access) {}", _which);
-    let path = varargs.get_str(&ctx);
-    let real_path_owned = utils::get_cstr_path(ctx.as_mut(), path as *const _);
-    let real_path = if let Some(ref rp) = real_path_owned {
-        rp.as_c_str().as_ptr()
-    } else {
-        path
-    };
-    let amode: c_int = varargs.get(&ctx);
-    let result = unsafe { access(real_path, amode) };
-    debug!(
-        "=> path: {}, amode: {}, result: {}",
-        unsafe { std::ffi::CStr::from_ptr(real_path).to_str().unwrap() },
-        amode,
-        result
-    );
-    result
-}
-
-/// nice
-pub fn ___syscall34(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall34 (nice) {}", _which);
-    let inc_r: c_int = varargs.get(&ctx);
-    unsafe { nice(inc_r) }
-}
-
-// mkdir
-pub fn ___syscall39(mut ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall39 (mkdir) {}", _which);
-    let pathname_addr = varargs.get_str(&ctx);
-    let real_path_owned = utils::get_cstr_path(ctx.as_mut(), pathname_addr as *const _);
-    let real_path = if let Some(ref rp) = real_path_owned {
-        rp.as_c_str().as_ptr()
-    } else {
-        pathname_addr
-    };
-    let mode: u32 = varargs.get(&ctx);
-    unsafe { mkdir(real_path, mode as _) }
-}
-
-/// dup
-pub fn ___syscall41(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall41 (dup) {}", _which);
-    let fd: c_int = varargs.get(&ctx);
-    unsafe { dup(fd) }
-}
-
-/// getgid32
-pub fn ___syscall200(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall200 (getgid32)");
-    unsafe { getgid() as i32 }
-}
-
-// geteuid32
-pub fn ___syscall201(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall201 (geteuid32)");
-    unsafe {
-        // Maybe fix: Emscripten returns 0 always
-        geteuid() as i32
-    }
-}
-
-// getegid32
-pub fn ___syscall202(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    // gid_t
-    debug!("emscripten::___syscall202 (getegid32)");
-    unsafe {
-        // Maybe fix: Emscripten returns 0 always
-        getegid() as _
-    }
-}
-
-/// fchown
-pub fn ___syscall207(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall207 (fchown) {}", _which);
-    let fd: c_int = varargs.get(&ctx);
-    let owner: uid_t = varargs.get(&ctx);
-    let group: gid_t = varargs.get(&ctx);
-    unsafe { fchown(fd, owner, group) }
-}
-
-/// dup3
-pub fn ___syscall330(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> pid_t {
-    // Implementation based on description at https://linux.die.net/man/2/dup3
-    debug!("emscripten::___syscall330 (dup3)");
-    let oldfd: c_int = varargs.get(&ctx);
-    let newfd: c_int = varargs.get(&ctx);
-    let flags: c_int = varargs.get(&ctx);
-
-    if oldfd == newfd {
-        return EINVAL;
-    }
-
-    let res = unsafe { dup2(oldfd, newfd) };
-
-    // Set flags on newfd (https://www.gnu.org/software/libc/manual/html_node/Descriptor-Flags.html)
-    let mut old_flags = unsafe { fcntl(newfd, F_GETFD, 0) };
-
-    match old_flags {
-        f if f > 0 => {
-            old_flags |= flags;
-        }
-        0 => {
-            old_flags &= !flags;
-        }
-        _ => {}
-    }
-
-    unsafe {
-        fcntl(newfd, F_SETFD, old_flags);
-    }
-
-    debug!(
-        "=> oldfd: {}, newfd: {}, flags: {} = pid: {}",
-        oldfd, newfd, flags, res
-    );
-    res
-}
-
-/// ioctl
-pub fn ___syscall54(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall54 (ioctl) {}", _which);
-
-    let fd: i32 = varargs.get(&ctx);
-    let request: u32 = varargs.get(&ctx);
-    debug!("=> fd: {}, op: {}", fd, request);
-
-    // Got the equivalents here: https://code.woboq.org/linux/linux/include/uapi/asm-generic/ioctls.h.html
-    match request {
-        WASM_FIOCLEX | WASM_FIONBIO | WASM_TIOCGWINSZ | WASM_TIOCSPGRP | WASM_TCGETS
-        | WASM_TCSETSW => {
-            let argp: u32 = varargs.get(&ctx);
-            let memory = ctx.data().memory(0);
-            let argp_ptr = emscripten_memory_pointer!(memory.view(&ctx), argp) as *mut c_void;
-            let translated_request = translate_ioctl(request);
-            let ret = unsafe { ioctl(fd, translated_request as _, argp_ptr) };
-            debug!(
-                " => request: {}, translated: {}, return: {}",
-                request, translated_request, ret
-            );
-
-            // TODO: We hardcode the value to have emscripten tests pass, as for some reason
-            // when the capturer is active, ioctl returns -1 instead of 0
-            if request == WASM_TIOCGWINSZ && ret == -1 {
-                return 0;
-            }
-            ret
-        }
-        _ => {
-            debug!(
-                " => not implemented case {} (noop, hardcoded to 0)",
-                request
-            );
-            0
-        }
-    }
-}
-
-const SOCK_NON_BLOCK: i32 = 2048;
-const SOCK_CLOEXC: i32 = 0x80000;
-
-// socketcall
-#[allow(clippy::cast_ptr_alignment)]
-pub fn ___syscall102(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall102 (socketcall) {}", _which);
-    let call: u32 = varargs.get(&ctx);
-    let mut socket_varargs: VarArgs = varargs.get(&ctx);
-    let memory = ctx.data().memory(0);
-    let view = memory.view(&ctx);
-
-    // migrating to EmSockAddr, port being separate here is nice, should update that too
-    #[repr(C)]
-    pub struct GuestSockaddrIn {
-        pub sin_family: sa_family_t, // u16
-        pub sin_port: in_port_t,     // u16
-        pub sin_addr: GuestInAddr,   // u32
-        pub sin_zero: [u8; 8],       // u8 * 8
-                                     // 2 + 2 + 4 + 8 = 16
-    }
-
-    #[repr(C)]
-    pub struct GuestInAddr {
-        pub s_addr: in_addr_t, // u32
-    }
-
-    match call {
-        1 => {
-            debug!("socket: socket");
-            // socket (domain: c_int, ty: c_int, protocol: c_int) -> c_int
-            let domain: i32 = socket_varargs.get(&ctx);
-            let ty_and_flags: i32 = socket_varargs.get(&ctx);
-            let protocol: i32 = socket_varargs.get(&ctx);
-            let ty = ty_and_flags & (!SOCK_NON_BLOCK) & (!SOCK_CLOEXC);
-            let fd = unsafe { socket(domain, ty, protocol) };
-
-            if ty_and_flags & SOCK_CLOEXC != 0 {
-                // set_cloexec
-                unsafe {
-                    ioctl(fd, translate_ioctl(WASM_FIOCLEX) as _);
-                };
-            }
-
-            if ty_and_flags & SOCK_NON_BLOCK != 0 {
-                // do something here
-                unimplemented!("non blocking sockets");
-            }
-
-            // why is this here?
-            type T = u32;
-            let payload = 1 as *const T as _;
-            unsafe {
-                setsockopt(
-                    fd,
-                    SOL_SOCKET,
-                    SO_NOSIGPIPE,
-                    payload,
-                    mem::size_of::<T>() as socklen_t,
-                );
-            };
-
-            debug!(
-                "=> domain: {}, type: {}, protocol: {} = fd: {}",
-                domain, ty, protocol, fd
-            );
-            fd as _
-        }
-        2 => {
-            debug!("socket: bind");
-            // bind (socket: c_int, address: *const sockaddr, address_len: socklen_t) -> c_int
-            // TODO: Emscripten has a different signature.
-            let socket = socket_varargs.get(&ctx);
-            let address: u32 = socket_varargs.get(&ctx);
-            let address_len = socket_varargs.get(&ctx);
-            let address = emscripten_memory_pointer!(&view, address) as *mut sockaddr;
-
-            // Debug received address
-            let _proper_address = address as *const GuestSockaddrIn;
-            debug!(
-                    "=> address.sin_family: {:?}, address.sin_port: {:?}, address.sin_addr.s_addr: {:?}",
-                unsafe { (*_proper_address).sin_family }, unsafe { (*_proper_address).sin_port }, unsafe { (*_proper_address).sin_addr.s_addr }
-                );
-
-            let status = unsafe { bind(socket, address, address_len) };
-            // debug!("=> status: {}", status);
-            debug!(
-                "=> socketfd: {}, address: {:?}, address_len: {} = status: {}",
-                socket, address, address_len, status
-            );
-            status
-            // -1
-        }
-        3 => {
-            debug!("socket: connect");
-            // connect (socket: c_int, address: *const sockaddr, len: socklen_t) -> c_int
-            // TODO: Emscripten has a different signature.
-            let socket = socket_varargs.get(&ctx);
-            let address: u32 = socket_varargs.get(&ctx);
-            let address_len = socket_varargs.get(&ctx);
-            let address = emscripten_memory_pointer!(&view, address) as *mut sockaddr;
-            unsafe { connect(socket, address, address_len) }
-        }
-        4 => {
-            debug!("socket: listen");
-            // listen (socket: c_int, backlog: c_int) -> c_int
-            let socket = socket_varargs.get(&ctx);
-            let backlog: i32 = socket_varargs.get(&ctx);
-            let status = unsafe { listen(socket, backlog) };
-            debug!(
-                "=> socketfd: {}, backlog: {} = status: {}",
-                socket, backlog, status
-            );
-            status
-        }
-        5 => {
-            debug!("socket: accept");
-            // accept (socket: c_int, address: *mut sockaddr, address_len: *mut socklen_t) -> c_int
-            let socket: i32 = socket_varargs.get(&ctx);
-            let address: WasmPtr<EmSockAddr> = socket_varargs.get(&ctx);
-            let address_len: WasmPtr<u32> = socket_varargs.get(&ctx);
-
-            debug!(
-                "=> socket: {}, address: {:?}, address_len: {}",
-                socket,
-                address.deref(&view).read().unwrap(),
-                address_len.deref(&view).read().unwrap()
-            );
-            let mut address_len_addr = address_len.deref(&view).read().unwrap();
-            // let mut address_len_addr: socklen_t = 0;
-
-            let mut host_address: sockaddr = sockaddr {
-                sa_family: Default::default(),
-                sa_data: Default::default(),
-                #[cfg(any(target_os = "freebsd", target_vendor = "apple"))]
-                sa_len: Default::default(),
-            };
-            let fd = unsafe { accept(socket, &mut host_address, &mut address_len_addr) };
-            let mut address_addr = address.deref(&view).read().unwrap();
-
-            address_addr.sa_family = host_address.sa_family as _;
-            address_addr.sa_data = host_address.sa_data;
-
-            // why is this here?
-            // set_cloexec
-            unsafe {
-                ioctl(fd, translate_ioctl(WASM_FIOCLEX) as _);
-            };
-
-            debug!(
-                "address: {:?}, len: {}, result fd = {}",
-                address_addr, address_len_addr, fd
-            );
-
-            fd as _
-        }
-        6 => {
-            debug!("socket: getsockname");
-            // getsockname (socket: c_int, address: *mut sockaddr, address_len: *mut socklen_t) -> c_int
-            let socket: i32 = socket_varargs.get(&ctx);
-            let address: WasmPtr<EmSockAddr> = socket_varargs.get(&ctx);
-            let address_len: WasmPtr<u32> = socket_varargs.get(&ctx);
-            let address_len_addr = address_len.deref(&view).read().unwrap();
-
-            let mut sock_addr_host: sockaddr = sockaddr {
-                sa_family: Default::default(),
-                sa_data: Default::default(),
-                #[cfg(any(target_os = "freebsd", target_vendor = "apple"))]
-                sa_len: Default::default(),
-            };
-            let ret = unsafe {
-                getsockname(
-                    socket,
-                    &mut sock_addr_host as *mut sockaddr,
-                    address_len_addr as *mut u32,
-                )
-            };
-            // translate from host data into emscripten data
-            let mut address_mut = address.deref(&view).read().unwrap();
-            address_mut.sa_family = sock_addr_host.sa_family as _;
-            address_mut.sa_data = sock_addr_host.sa_data;
-
-            debug!(
-                "=> socket: {}, address, {:?}, address_len: {}, result = {}",
-                socket, address_mut, address_len_addr, ret
-            );
-
-            ret
-        }
-        7 => {
-            debug!("socket: getpeername");
-            // getpeername (socket: c_int, address: *mut sockaddr, address_len: *mut socklen_t) -> c_int
-            let socket = socket_varargs.get(&ctx);
-            let address: u32 = socket_varargs.get(&ctx);
-            let address_len: u32 = socket_varargs.get(&ctx);
-            let address = emscripten_memory_pointer!(view, address) as *mut sockaddr;
-            let address_len_addr = emscripten_memory_pointer!(view, address_len) as *mut socklen_t;
-            unsafe { getpeername(socket, address, address_len_addr) }
-        }
-        11 => {
-            debug!("socket: sendto");
-            // sendto (socket: c_int, buf: *const c_void, len: size_t, flags: c_int, addr: *const sockaddr, addrlen: socklen_t) -> ssize_t
-            let socket = socket_varargs.get(&ctx);
-            let buf: u32 = socket_varargs.get(&ctx);
-            let flags = socket_varargs.get(&ctx);
-            let len: i32 = socket_varargs.get(&ctx);
-            let address: u32 = socket_varargs.get(&ctx);
-            let address_len = socket_varargs.get(&ctx);
-            let buf_addr = emscripten_memory_pointer!(view, buf) as _;
-            let address = emscripten_memory_pointer!(view, address) as *mut sockaddr;
-            unsafe { sendto(socket, buf_addr, flags, len, address, address_len) as i32 }
-        }
-        12 => {
-            debug!("socket: recvfrom");
-            // recvfrom (socket: c_int, buf: *const c_void, len: size_t, flags: c_int, addr: *const sockaddr, addrlen: socklen_t) -> ssize_t
-            let socket = socket_varargs.get(&ctx);
-            let buf: u32 = socket_varargs.get(&ctx);
-            let len: i32 = socket_varargs.get(&ctx);
-            let flags: i32 = socket_varargs.get(&ctx);
-            let address: u32 = socket_varargs.get(&ctx);
-            let address_len: u32 = socket_varargs.get(&ctx);
-            let buf_addr = emscripten_memory_pointer!(view, buf) as _;
-            let address = emscripten_memory_pointer!(view, address) as *mut sockaddr;
-            let address_len_addr = emscripten_memory_pointer!(view, address_len) as *mut socklen_t;
-            unsafe {
-                recvfrom(
-                    socket,
-                    buf_addr,
-                    len as usize,
-                    flags,
-                    address,
-                    address_len_addr,
-                ) as i32
-            }
-        }
-        14 => {
-            debug!("socket: setsockopt");
-            // OSX and BSD have completely different values, be very careful here
-            //      https://github.com/openbsd/src/blob/master/sys/sys/socket.h#L156
-            // setsockopt (socket: c_int, level: c_int, name: c_int, value: *const c_void, option_len: socklen_t) -> c_int
-
-            let socket = socket_varargs.get(&ctx);
-            let level: i32 = socket_varargs.get(&ctx);
-            let level = if level == 1 { SOL_SOCKET } else { level };
-            let untranslated_name: i32 = socket_varargs.get(&ctx);
-            let value: u32 = socket_varargs.get(&ctx);
-            let option_len: u32 = socket_varargs.get(&ctx);
-            let value_addr = emscripten_memory_pointer!(view, value) as *const libc::c_void;
-            let name: i32 = translate_socket_name_flag(untranslated_name);
-
-            let ret = unsafe { setsockopt(socket, level, name, value_addr, option_len) };
-
-            debug!("=> socketfd: {}, level: {}, name: {}, value_addr: {:?}, option_len: {} = status: {}", socket, level, untranslated_name, value_addr, option_len, ret);
-            ret
-        }
-        15 => {
-            debug!("socket: getsockopt");
-            // getsockopt (sockfd: c_int, level: c_int, optname: c_int, optval: *mut c_void, optlen: *mut socklen_t) -> c_int
-            let socket = socket_varargs.get(&ctx);
-            let level: i32 = socket_varargs.get(&ctx);
-            let level = if level == 1 { SOL_SOCKET } else { level };
-            let untranslated_name: i32 = socket_varargs.get(&ctx);
-            let name: i32 = translate_socket_name_flag(untranslated_name);
-            let value: u32 = socket_varargs.get(&ctx);
-            let option_len: u32 = socket_varargs.get(&ctx);
-            let value_addr = emscripten_memory_pointer!(view, value) as _;
-            let option_len_addr = emscripten_memory_pointer!(view, option_len) as *mut socklen_t;
-            unsafe { getsockopt(socket, level, name, value_addr, option_len_addr) }
-        }
-        16 => {
-            debug!("socket: sendmsg");
-            // sendmsg (fd: c_int, msg: *const msghdr, flags: c_int) -> ssize_t
-            let socket: i32 = socket_varargs.get(&ctx);
-            let msg: u32 = socket_varargs.get(&ctx);
-            let flags: i32 = socket_varargs.get(&ctx);
-            let msg_addr = emscripten_memory_pointer!(view, msg) as *const msghdr;
-            unsafe { sendmsg(socket, msg_addr, flags) as i32 }
-        }
-        17 => {
-            debug!("socket: recvmsg");
-            // recvmsg (fd: c_int, msg: *mut msghdr, flags: c_int) -> ssize_t
-            let socket: i32 = socket_varargs.get(&ctx);
-            let msg: u32 = socket_varargs.get(&ctx);
-            let flags: i32 = socket_varargs.get(&ctx);
-            let msg_addr = emscripten_memory_pointer!(view, msg) as *mut msghdr;
-            unsafe { recvmsg(socket, msg_addr, flags) as i32 }
-        }
-        _ => {
-            // others
-            -1
-        }
-    }
-}
-
-/// OSX and BSD have completely different values, we must translate from emscripten's Linuxy
-/// value into one that we can pass to native syscalls
-fn translate_socket_name_flag(name: i32) -> i32 {
-    match name {
-        2 => libc::SO_REUSEADDR,
-        3 => libc::SO_TYPE,
-        4 => libc::SO_ERROR,
-        5 => libc::SO_DONTROUTE,
-        6 => libc::SO_BROADCAST,
-        7 => libc::SO_SNDBUF,
-        8 => libc::SO_RCVBUF,
-        9 => libc::SO_KEEPALIVE,
-        10 => libc::SO_OOBINLINE,
-        13 => libc::SO_LINGER,
-        18 => libc::SO_RCVLOWAT,
-        19 => libc::SO_SNDLOWAT,
-        20 => libc::SO_RCVTIMEO,
-        21 => libc::SO_SNDTIMEO,
-        // SO_DEBUG missing
-        30 => libc::SO_ACCEPTCONN,
-        otherwise => otherwise,
-    }
-}
-
-/// getpgid
-pub fn ___syscall132(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall132 (getpgid)");
-
-    let pid: pid_t = varargs.get(&ctx);
-
-    let ret = unsafe { getpgid(pid) };
-    debug!("=> pid: {} = {}", pid, ret);
-    if ret == -1 {
-        debug!("=> last os error: {}", Error::last_os_error(),);
-    }
-    ret
-}
-
-#[derive(Debug, Copy, Clone, ValueType)]
-#[repr(C)]
-pub struct EmPollFd {
-    pub fd: i32,
-    pub events: i16,
-    pub revents: i16,
-}
-
-/// poll
-pub fn ___syscall168(ctx: FunctionEnvMut<EmEnv>, _which: i32, mut varargs: VarArgs) -> i32 {
-    debug!("emscripten::___syscall168(poll)");
-    let fds: WasmPtr<EmPollFd> = varargs.get(&ctx);
-    let nfds: u32 = varargs.get(&ctx);
-    let timeout: i32 = varargs.get(&ctx);
-    let memory = ctx.data().memory(0);
-    let view = memory.view(&ctx);
-
-    let mut fds_mut = fds.deref(&view).read().unwrap();
-
-    unsafe {
-        libc::poll(
-            &mut fds_mut as *mut EmPollFd as *mut libc::pollfd,
-            nfds as _,
-            timeout,
-        )
-    }
-}
-
-// pread
-pub fn ___syscall180(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall180 (pread) {}", _which);
-    let fd: i32 = varargs.get(&ctx);
-    let buf: u32 = varargs.get(&ctx);
-    let count: u32 = varargs.get(&ctx);
-    {
-        let zero: u32 = varargs.get(&ctx);
-        assert_eq!(zero, 0);
-    }
-    let offset: i64 = varargs.get(&ctx);
-
-    let buf_ptr = emscripten_memory_pointer!(ctx.data().memory(0).view(&ctx), buf) as _;
-
-    unsafe { pread(fd, buf_ptr, count as _, offset) as _ }
-}
-
-// pwrite
-pub fn ___syscall181(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall181 (pwrite) {}", _which);
-    let fd: i32 = varargs.get(&ctx);
-    let buf: u32 = varargs.get(&ctx);
-    let count: u32 = varargs.get(&ctx);
-    {
-        let zero: u32 = varargs.get(&ctx);
-        assert_eq!(zero, 0);
-    }
-    let offset: i64 = varargs.get(&ctx);
-
-    let buf_ptr = emscripten_memory_pointer!(ctx.data().memory(0).view(&ctx), buf) as _;
-    let status = unsafe { pwrite(fd, buf_ptr, count as _, offset) as _ };
-    debug!(
-        "=> fd: {}, buf: {}, count: {}, offset: {} = status:{}",
-        fd, buf, count, offset, status
-    );
-    status
-}
-
-/// fchmod
-pub fn ___syscall94(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall118 (fchmod) {}", _which);
-    let fd: c_int = varargs.get(&ctx);
-    let mode: mode_t = varargs.get(&ctx);
-    unsafe { fchmod(fd, mode) }
-}
-
-/// wait4
-#[allow(clippy::cast_ptr_alignment)]
-pub fn ___syscall114(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> pid_t {
-    debug!("emscripten::___syscall114 (wait4)");
-    let pid: pid_t = varargs.get(&ctx);
-    let status: u32 = varargs.get(&ctx);
-    let options: c_int = varargs.get(&ctx);
-    let rusage: u32 = varargs.get(&ctx);
-    let memory = ctx.data().memory(0);
-    let status_addr = emscripten_memory_pointer!(memory.view(&ctx), status) as *mut c_int;
-
-    let rusage_addr = emscripten_memory_pointer!(memory.view(&ctx), rusage) as *mut rusage;
-    let res = unsafe { wait4(pid, status_addr, options, rusage_addr) };
-    debug!(
-        "=> pid: {}, status: {:?}, options: {}, rusage: {:?} = pid: {}",
-        pid, status_addr, options, rusage_addr, res
-    );
-    res
-}
-
-/// fsync
-pub fn ___syscall118(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall118 (fsync) {}", _which);
-    let fd: c_int = varargs.get(&ctx);
-    unsafe { fsync(fd) }
-}
-
-// select
-#[allow(clippy::cast_ptr_alignment)]
-pub fn ___syscall142(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall142 (newselect) {}", _which);
-
-    let nfds: i32 = varargs.get(&ctx);
-    let readfds: u32 = varargs.get(&ctx);
-    let writefds: u32 = varargs.get(&ctx);
-    let exceptfds: u32 = varargs.get(&ctx);
-    let _timeout: i32 = varargs.get(&ctx);
-
-    if nfds > 1024 {
-        // EINVAL
-        return -22;
-    }
-    assert!(exceptfds == 0, "`exceptfds` is not supporrted");
-
-    let memory = ctx.data().memory(0);
-    let readfds_ptr = emscripten_memory_pointer!(memory.view(&ctx), readfds) as _;
-    let writefds_ptr = emscripten_memory_pointer!(memory.view(&ctx), writefds) as _;
-
-    unsafe { select(nfds, readfds_ptr, writefds_ptr, 0 as _, 0 as _) }
-}
-
-/// fdatasync
-pub fn ___syscall148(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall148 (fdatasync) {}", _which);
-
-    let fd: i32 = varargs.get(&ctx);
-
-    unsafe { fdatasync(fd) }
-}
-
-// setpgid
-pub fn ___syscall57(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall57 (setpgid) {}", _which);
-
-    let pid: i32 = varargs.get(&ctx);
-    let pgid: i32 = varargs.get(&ctx);
-
-    let ret = unsafe { setpgid(pid, pgid) };
-    debug!("=> pid: {}, pgid: {} = {}", pid, pgid, ret);
-    if ret == -1 {
-        debug!("=> last os error: {}", Error::last_os_error(),);
-    }
-    ret
-}
-
-/// uname
-// NOTE: Wondering if we should return custom utsname, like Emscripten.
-pub fn ___syscall122(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall122 (uname) {}", _which);
-    let buf: u32 = varargs.get(&ctx);
-    debug!("=> buf: {}", buf);
-    let buf_addr = emscripten_memory_pointer!(ctx.data().memory(0).view(&ctx), buf) as *mut utsname;
-    unsafe { uname(buf_addr) }
-}
-
-/// lstat64
-pub fn ___syscall196(mut ctx: FunctionEnvMut<EmEnv>, _which: i32, mut varargs: VarArgs) -> i32 {
-    debug!("emscripten::___syscall196 (lstat64) {}", _which);
-    let path = varargs.get_str(&ctx);
-    let real_path_owned = utils::get_cstr_path(ctx.as_mut(), path as *const _);
-    let real_path = if let Some(ref rp) = real_path_owned {
-        rp.as_c_str().as_ptr()
-    } else {
-        path
-    };
-    let buf_ptr: u32 = varargs.get(&ctx);
-    unsafe {
-        let mut stat: stat = std::mem::zeroed();
-
-        #[cfg(target_vendor = "apple")]
-        let stat_ptr = &mut stat as *mut stat as *mut c_void;
-        #[cfg(not(target_vendor = "apple"))]
-        let stat_ptr = &mut stat as *mut stat;
-
-        #[cfg(target_vendor = "apple")]
-        let ret = lstat64(real_path, stat_ptr);
-        #[cfg(not(target_vendor = "apple"))]
-        let ret = lstat(real_path, stat_ptr);
-
-        debug!("ret: {}", ret);
-        if ret != 0 {
-            return ret;
-        }
-        utils::copy_stat_into_wasm(ctx, buf_ptr, &stat);
-    }
-    0
-}
-
-// getuid
-pub fn ___syscall199(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall199 (getuid)");
-    let uid = unsafe { getuid() as _ };
-    debug!("  => {}", uid);
-    uid
-}
-
-// getdents
-// dirent structure is
-// i64, i64, u16 (280), i8, [i8; 256]
-pub fn ___syscall220(ctx: FunctionEnvMut<EmEnv>, _which: i32, mut varargs: VarArgs) -> i32 {
-    use super::super::env::get_emscripten_data;
-
-    let fd: i32 = varargs.get(&ctx);
-    let dirp_addr: i32 = varargs.get(&ctx);
-    let count: u32 = varargs.get(&ctx);
-    debug!(
-        "emscripten::___syscall220 (getdents) {} {} {}",
-        fd, dirp_addr, count
-    );
-
-    let dirp = emscripten_memory_pointer!(ctx.data().memory(0).view(&ctx), dirp_addr) as *mut u8;
-
-    let data = &mut get_emscripten_data(&ctx);
-    let opened_dirs = &mut data.as_mut().unwrap().opened_dirs;
-
-    // need to persist stream across calls?
-    // let dir: *mut libc::DIR = unsafe { libc::fdopendir(fd) };
-    let dir = &*opened_dirs
-        .entry(fd)
-        .or_insert_with(|| unsafe { Box::new(LibcDirWrapper(libc::fdopendir(fd))) });
-
-    let mut pos = 0;
-    let offset = 256 + 12;
-    while pos + offset <= count as usize {
-        let dirent = unsafe { readdir(***dir) };
-        if dirent.is_null() {
-            break;
-        }
-        #[allow(clippy::cast_ptr_alignment)]
-        #[cfg(not(target_os = "freebsd"))]
-        unsafe {
-            *(dirp.add(pos) as *mut u32) = (*dirent).d_ino as u32;
-        }
-        #[allow(clippy::cast_ptr_alignment)]
-        #[cfg(target_os = "freebsd")]
-        unsafe {
-            *(dirp.add(pos) as *mut u32) = (*dirent).d_fileno as u32;
-        }
-        #[allow(clippy::cast_ptr_alignment)]
-        unsafe {
-            *(dirp.add(pos + 4) as *mut u32) = pos as u32;
-            *(dirp.add(pos + 8) as *mut u16) = offset as u16;
-            *(dirp.add(pos + 10) as *mut u8) = (*dirent).d_type;
-            let upper_bound = std::cmp::min((*dirent).d_reclen, 255) as usize;
-            let mut i = 0;
-            while i < upper_bound {
-                *(dirp.add(pos + 11 + i) as *mut c_char) = (*dirent).d_name[i] as c_char;
-                i += 1;
-            }
-            // We set the termination string char
-            *(dirp.add(pos + 11 + i) as *mut c_char) = 0;
-            debug!(
-                "  => file {}",
-                CStr::from_ptr(dirp.add(pos + 11) as *const c_char)
-                    .to_str()
-                    .unwrap()
-            );
-        }
-        pos += offset;
-    }
-    pos as i32
-}
-
-// fcntl64
-pub fn ___syscall221(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall221 (fcntl64) {}", _which);
-    let fd: i32 = varargs.get(&ctx);
-    let cmd: i32 = varargs.get(&ctx);
-    let arg: i32 = varargs.get(&ctx);
-    // (FAPPEND   - 0x08
-    // |FASYNC    - 0x40
-    // |FFSYNC    - 0x80
-    // |FNONBLOCK - 0x04
-    let ret = unsafe { fcntl(fd, cmd, arg) };
-    debug!("=> fd: {}, cmd: {} = {}", fd, cmd, ret);
-    if ret == -1 {
-        debug!("=> last os error: {}", Error::last_os_error(),);
-    }
-    ret
-}
-
-/// fallocate
-pub fn ___syscall324(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall324 (fallocate) {}", _which);
-    let _fd: c_int = varargs.get(&ctx);
-    let _mode: c_int = varargs.get(&ctx);
-    let _offset: off_t = varargs.get(&ctx);
-    let _len: off_t = varargs.get(&ctx);
-    #[cfg(not(any(target_os = "freebsd", target_vendor = "apple", target_os = "android")))]
-    unsafe {
-        fallocate(_fd, _mode, _offset, _len)
-    }
-    #[cfg(any(target_os = "freebsd", target_vendor = "apple", target_os = "android"))]
-    {
-        unimplemented!("emscripten::___syscall324 (fallocate) {}", _which)
-    }
-}
diff --git a/lib/emscripten/src/syscalls/windows.rs b/lib/emscripten/src/syscalls/windows.rs
deleted file mode 100644
index 8644a1a6f4..0000000000
--- a/lib/emscripten/src/syscalls/windows.rs
+++ /dev/null
@@ -1,314 +0,0 @@
-use crate::utils::{copy_cstr_into_wasm, get_cstr_path};
-use crate::varargs::VarArgs;
-use crate::EmEnv;
-use libc::mkdir;
-use libc::open;
-use std::env;
-use std::ffi::CString;
-use std::fs::File;
-use std::io::Write;
-use std::os::raw::c_int;
-use wasmer::FunctionEnvMut;
-
-#[allow(non_camel_case_types)]
-type pid_t = c_int;
-
-/// open
-pub fn ___syscall5(mut ctx: FunctionEnvMut<EmEnv>, which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall5 (open) {}", which);
-    #[cfg(not(feature = "debug"))]
-    let _ = which;
-    let pathname_addr = varargs.get_str(&ctx);
-    let real_path_owned = get_cstr_path(ctx.as_mut(), pathname_addr);
-    let real_path = if let Some(ref rp) = real_path_owned {
-        rp.as_c_str().as_ptr()
-    } else {
-        pathname_addr
-    };
-    let flags: i32 = varargs.get(&ctx);
-    let mode: u32 = varargs.get(&ctx);
-    let path_str = unsafe { std::ffi::CStr::from_ptr(real_path).to_str().unwrap() };
-
-    match path_str {
-        "/dev/urandom" => {
-            // create a fake urandom file for windows, super hacky
-            // put it in the temp directory so we can just forget about it
-            let mut tmp_dir = env::temp_dir();
-            tmp_dir.push("urandom");
-            let tmp_dir_str = tmp_dir.to_str().unwrap();
-            let tmp_dir_c_str = CString::new(tmp_dir_str).unwrap();
-            let ptr = tmp_dir_c_str.as_ptr() as *const i8;
-            let mut urandom_file = File::create(tmp_dir).unwrap();
-            // create some random bytes and put them into the file
-            let mut random_bytes = [0u8; 32];
-            getrandom::getrandom(&mut random_bytes).unwrap();
-            let _ = urandom_file.write_all(&random_bytes).unwrap();
-            // put the file path string into wasm memory
-            let urandom_file_offset = unsafe { copy_cstr_into_wasm(&mut ctx, ptr) };
-            let mem = ctx.data().memory(0);
-            let memory = mem.view(&ctx);
-            let raw_pointer_to_urandom_file =
-                emscripten_memory_pointer!(&memory, urandom_file_offset) as *const i8;
-            let fd = unsafe { open(raw_pointer_to_urandom_file, flags, mode) };
-            debug!(
-                "=> pathname: {}, flags: {}, mode: {} = fd: {}",
-                path_str, flags, mode, fd
-            );
-            fd
-        }
-        _ => {
-            let fd = unsafe { open(real_path, flags, mode) };
-            debug!(
-                "=> pathname: {}, flags: {}, mode: {} = fd: {}\npath: {}",
-                path_str, flags, mode, fd, path_str
-            );
-            fd
-        }
-    }
-}
-
-/// link
-pub fn ___syscall9(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall9 (link) {}", _which);
-    unimplemented!("emscripten::___syscall9 (link) {}", _which);
-}
-
-/// ftruncate64
-pub fn ___syscall194(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall194 - stub");
-    unimplemented!("emscripten::___syscall194 - stub")
-}
-
-// chown
-pub fn ___syscall212(_ctx: FunctionEnvMut<EmEnv>, which: c_int, mut _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall212 (chown) {}", which);
-    #[cfg(not(feature = "debug"))]
-    let _ = which;
-    -1
-}
-
-/// access
-pub fn ___syscall33(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall33 (access) {}", _which);
-    unimplemented!("emscripten::___syscall33 (access) {}", _which);
-}
-
-/// nice
-pub fn ___syscall34(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall34 (nice) {}", _which);
-    unimplemented!("emscripten::___syscall34 (nice) {}", _which);
-}
-
-// mkdir
-pub fn ___syscall39(ctx: FunctionEnvMut<EmEnv>, which: c_int, mut varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall39 (mkdir) {}", which);
-    #[cfg(not(feature = "debug"))]
-    let _ = which;
-    let pathname_addr = varargs.get_str(&ctx);
-    let real_path_owned = get_cstr_path(ctx, pathname_addr);
-    let real_path = if let Some(ref rp) = real_path_owned {
-        rp.as_c_str().as_ptr()
-    } else {
-        pathname_addr
-    };
-    unsafe { mkdir(real_path) }
-}
-
-/// dup
-pub fn ___syscall41(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall41 (dup) {}", _which);
-    unimplemented!("emscripten::___syscall41 (dup) {}", _which);
-}
-
-/// getrusage
-pub fn ___syscall77(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall77 (getrusage) {}", _which);
-    unimplemented!("emscripten::___syscall77 (getrusage) {}", _which);
-}
-
-/// symlink
-pub fn ___syscall83(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall83 (symlink) {}", _which);
-    unimplemented!("emscripten::___syscall83 (symlink) {}", _which);
-}
-
-/// readlink
-pub fn ___syscall85(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall85 (readlink) {}", _which);
-    -1
-}
-
-/// getpgid
-pub fn ___syscall132(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall132 (getpgid)");
-    -1
-}
-
-/// lchown
-pub fn ___syscall198(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall198 (lchown) {}", _which);
-    unimplemented!("emscripten::___syscall198 (lchown) {}", _which);
-}
-
-/// getgid32
-pub fn ___syscall200(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall200 (getgid32)");
-    unimplemented!("emscripten::___syscall200 (getgid32)");
-}
-
-// geteuid32
-pub fn ___syscall201(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall201 (geteuid32)");
-    unimplemented!("emscripten::___syscall201 (geteuid32)");
-}
-
-// getegid32
-pub fn ___syscall202(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    // gid_t
-    debug!("emscripten::___syscall202 (getegid32)");
-    unimplemented!("emscripten::___syscall202 (getegid32)");
-}
-
-/// getgroups
-pub fn ___syscall205(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall205 (getgroups) {}", _which);
-    unimplemented!("emscripten::___syscall205 (getgroups) {}", _which);
-}
-
-/// madvise
-pub fn ___syscall219(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall212 (chown) {}", _which);
-    unimplemented!("emscripten::___syscall212 (chown) {}", _which);
-}
-
-/// dup3
-pub fn ___syscall330(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut _varargs: VarArgs) -> pid_t {
-    debug!("emscripten::___syscall330 (dup3)");
-    -1
-}
-
-/// ioctl
-pub fn ___syscall54(_ctx: FunctionEnvMut<EmEnv>, which: c_int, mut _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall54 (ioctl) {}", which);
-    #[cfg(not(feature = "debug"))]
-    let _ = which;
-    -1
-}
-
-/// fchmod
-pub fn ___syscall94(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall118 (fchmod) {}", _which);
-    unimplemented!("emscripten::___syscall118 (fchmod) {}", _which);
-}
-
-// socketcall
-#[allow(clippy::cast_ptr_alignment)]
-pub fn ___syscall102(_ctx: FunctionEnvMut<EmEnv>, which: c_int, mut _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall102 (socketcall) {}", which);
-    #[cfg(not(feature = "debug"))]
-    let _ = which;
-    -1
-}
-
-/// fsync
-pub fn ___syscall118(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall118 (fsync) {}", _which);
-    unimplemented!("emscripten::___syscall118 (fsync) {}", _which);
-}
-
-// pread
-pub fn ___syscall180(_ctx: FunctionEnvMut<EmEnv>, which: c_int, mut _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall180 (pread) {}", which);
-    #[cfg(not(feature = "debug"))]
-    let _ = which;
-    -1
-}
-
-// pwrite
-pub fn ___syscall181(_ctx: FunctionEnvMut<EmEnv>, which: c_int, mut _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall181 (pwrite) {}", which);
-    #[cfg(not(feature = "debug"))]
-    let _ = which;
-    -1
-}
-
-/// wait4
-#[allow(clippy::cast_ptr_alignment)]
-pub fn ___syscall114(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut _varargs: VarArgs) -> pid_t {
-    debug!("emscripten::___syscall114 (wait4)");
-    -1
-}
-
-// select
-#[allow(clippy::cast_ptr_alignment)]
-pub fn ___syscall142(_ctx: FunctionEnvMut<EmEnv>, which: c_int, mut _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall142 (newselect) {}", which);
-    #[cfg(not(feature = "debug"))]
-    let _ = which;
-    -1
-}
-
-/// fdatasync
-pub fn ___syscall148(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall148 (fdatasync) {}", _which);
-    unimplemented!("emscripten::___syscall148 (fdatasync) {}", _which);
-}
-
-// setpgid
-pub fn ___syscall57(_ctx: FunctionEnvMut<EmEnv>, which: c_int, mut _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall57 (setpgid) {}", which);
-    #[cfg(not(feature = "debug"))]
-    let _ = which;
-    -1
-}
-
-/// uname
-// NOTE: Wondering if we should return custom utsname, like Emscripten.
-pub fn ___syscall122(_ctx: FunctionEnvMut<EmEnv>, which: c_int, mut _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall122 (uname) {}", which);
-    #[cfg(not(feature = "debug"))]
-    let _ = which;
-    -1
-}
-
-/// poll
-pub fn ___syscall168(_ctx: FunctionEnvMut<EmEnv>, _which: i32, _varargs: VarArgs) -> i32 {
-    debug!("emscripten::___syscall168(poll) - stub");
-    -1
-}
-
-/// lstat64
-pub fn ___syscall196(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall196 (lstat64) - stub");
-    -1
-}
-
-// getuid
-pub fn ___syscall199(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall199 (getuid)");
-    -1
-}
-
-// getdents
-pub fn ___syscall220(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::___syscall220");
-    -1
-}
-
-// fcntl64
-pub fn ___syscall221(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall221 (fcntl64) {}", _which);
-    -1
-}
-
-/// fchown
-pub fn ___syscall207(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall207 (fchown) {}", _which);
-    unimplemented!("emscripten::___syscall207 (fchown) {}", _which)
-}
-
-/// fallocate
-pub fn ___syscall324(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
-    debug!("emscripten::___syscall324 (fallocate) {}", _which);
-    unimplemented!("emscripten::___syscall324 (fallocate) {}", _which)
-}
diff --git a/lib/emscripten/src/time.rs b/lib/emscripten/src/time.rs
deleted file mode 100644
index 0c832bf65c..0000000000
--- a/lib/emscripten/src/time.rs
+++ /dev/null
@@ -1,471 +0,0 @@
-use super::utils::{copy_cstr_into_wasm, write_to_buf};
-use crate::{allocate_on_stack, lazy_static, EmEnv};
-use libc::{c_char, c_int};
-use time::ext::InstantExt;
-// use libc::{c_char, c_int, clock_getres, clock_settime};
-use std::mem;
-use std::time::SystemTime;
-
-#[cfg(not(target_os = "windows"))]
-use libc::{clockid_t, time as libc_time, timegm as libc_timegm, tm as libc_tm};
-#[cfg(not(target_os = "windows"))]
-use std::ffi::CString;
-
-#[cfg(target_os = "windows")]
-use libc::time_t;
-
-use wasmer::FunctionEnvMut;
-
-#[cfg(target_os = "windows")]
-#[allow(non_camel_case_types)]
-type clockid_t = c_int;
-
-#[cfg(target_os = "windows")]
-extern "C" {
-    #[link_name = "time"]
-    pub fn libc_time(s: *const time_t) -> time_t;
-}
-
-use super::env;
-
-#[cfg(any(target_os = "linux", target_os = "android"))]
-use libc::{CLOCK_MONOTONIC, CLOCK_MONOTONIC_COARSE, CLOCK_REALTIME};
-
-#[cfg(target_os = "freebsd")]
-use libc::{CLOCK_MONOTONIC, CLOCK_REALTIME};
-#[cfg(target_os = "freebsd")]
-const CLOCK_MONOTONIC_COARSE: clockid_t = 6;
-
-#[cfg(target_vendor = "apple")]
-use libc::CLOCK_REALTIME;
-#[cfg(target_vendor = "apple")]
-const CLOCK_MONOTONIC: clockid_t = 1;
-#[cfg(target_vendor = "apple")]
-const CLOCK_MONOTONIC_COARSE: clockid_t = 6;
-
-// some assumptions about the constants when targeting windows
-#[cfg(target_os = "windows")]
-const CLOCK_REALTIME: clockid_t = 0;
-#[cfg(target_os = "windows")]
-const CLOCK_MONOTONIC: clockid_t = 1;
-#[cfg(target_os = "windows")]
-const CLOCK_MONOTONIC_COARSE: clockid_t = 6;
-
-/// emscripten: _gettimeofday
-#[allow(clippy::cast_ptr_alignment)]
-pub fn _gettimeofday(ctx: FunctionEnvMut<EmEnv>, tp: c_int, tz: c_int) -> c_int {
-    debug!("emscripten::_gettimeofday {} {}", tp, tz);
-    #[repr(C)]
-    struct GuestTimeVal {
-        tv_sec: i32,
-        tv_usec: i32,
-    }
-
-    assert!(
-        tz == 0,
-        "the timezone argument of `_gettimeofday` must be null"
-    );
-    unsafe {
-        let now = SystemTime::now();
-        let since_epoch = now.duration_since(SystemTime::UNIX_EPOCH).unwrap();
-        let memory = ctx.data().memory(0);
-        let timeval_struct_ptr =
-            emscripten_memory_pointer!(memory.view(&ctx), tp) as *mut GuestTimeVal;
-
-        (*timeval_struct_ptr).tv_sec = since_epoch.as_secs() as _;
-        (*timeval_struct_ptr).tv_usec = since_epoch.subsec_nanos() as _;
-    }
-    0
-}
-
-pub fn _clock_getres(mut _ctx: FunctionEnvMut<EmEnv>, _clk_id: i32, _tp: i32) -> i32 {
-    debug!("emscripten::_clock_getres");
-    // clock_getres(clk_id, tp)
-    0
-}
-
-/// emscripten: _clock_gettime
-#[allow(clippy::cast_ptr_alignment)]
-pub fn _clock_gettime(ctx: FunctionEnvMut<EmEnv>, clk_id: clockid_t, tp: c_int) -> c_int {
-    debug!("emscripten::_clock_gettime {} {}", clk_id, tp);
-    // debug!("Memory {:?}", ctx.memory(0)[..]);
-    #[repr(C)]
-    struct GuestTimeSpec {
-        tv_sec: i32,
-        tv_nsec: i32,
-    }
-
-    #[allow(unreachable_patterns)]
-    let duration = match clk_id {
-        CLOCK_REALTIME => time::OffsetDateTime::now_utc().unix_timestamp_nanos(),
-
-        CLOCK_MONOTONIC | CLOCK_MONOTONIC_COARSE => {
-            lazy_static! {
-                static ref PRECISE0: std::time::Instant = std::time::Instant::now();
-            };
-            let precise_ns = *PRECISE0;
-            (std::time::Instant::now().signed_duration_since(precise_ns)).whole_nanoseconds()
-        }
-        _ => panic!("Clock with id \"{}\" is not supported.", clk_id),
-    };
-
-    unsafe {
-        let memory = ctx.data().memory(0);
-        let timespec_struct_ptr =
-            emscripten_memory_pointer!(memory.view(&ctx), tp) as *mut GuestTimeSpec;
-        (*timespec_struct_ptr).tv_sec = (duration / 1_000_000_000) as _;
-        (*timespec_struct_ptr).tv_nsec = (duration % 1_000_000_000) as _;
-    }
-    0
-}
-
-pub fn _clock_settime(mut _ctx: FunctionEnvMut<EmEnv>, _clk_id: i32, _tp: i32) -> i32 {
-    debug!("emscripten::_clock_settime");
-    // clock_settime(clk_id, tp)
-    0
-}
-
-/// emscripten: ___clock_gettime
-pub fn ___clock_gettime(ctx: FunctionEnvMut<EmEnv>, clk_id: clockid_t, tp: c_int) -> c_int {
-    debug!("emscripten::___clock_gettime {} {}", clk_id, tp);
-    _clock_gettime(ctx, clk_id, tp)
-}
-
-/// emscripten: _clock
-pub fn _clock(mut _ctx: FunctionEnvMut<EmEnv>) -> c_int {
-    debug!("emscripten::_clock");
-    0 // TODO: unimplemented
-}
-
-/// emscripten: _difftime
-pub fn _difftime(mut _ctx: FunctionEnvMut<EmEnv>, t0: u32, t1: u32) -> f64 {
-    debug!("emscripten::_difftime");
-    (t0 - t1) as _
-}
-
-pub fn _gmtime_r(mut _ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
-    debug!("emscripten::_gmtime_r");
-    -1
-}
-
-pub fn _mktime(mut _ctx: FunctionEnvMut<EmEnv>, _one: i32) -> i32 {
-    debug!("emscripten::_mktime");
-    -1
-}
-
-pub fn _gmtime(mut _ctx: FunctionEnvMut<EmEnv>, _one: i32) -> i32 {
-    debug!("emscripten::_gmtime");
-    -1
-}
-
-#[repr(C)]
-struct guest_tm {
-    pub tm_sec: c_int,    // 0
-    pub tm_min: c_int,    // 4
-    pub tm_hour: c_int,   // 8
-    pub tm_mday: c_int,   // 12
-    pub tm_mon: c_int,    // 16
-    pub tm_year: c_int,   // 20
-    pub tm_wday: c_int,   // 24
-    pub tm_yday: c_int,   // 28
-    pub tm_isdst: c_int,  // 32
-    pub tm_gmtoff: c_int, // 36
-    pub tm_zone: c_int,   // 40
-}
-
-/// emscripten: _tvset
-pub fn _tvset(mut _ctx: FunctionEnvMut<EmEnv>) {
-    debug!("emscripten::_tvset UNIMPLEMENTED");
-}
-
-/// formats time as a C string
-#[allow(clippy::cast_ptr_alignment)]
-unsafe fn fmt_time(ctx: FunctionEnvMut<EmEnv>, time: u32) -> *const c_char {
-    let memory = ctx.data().memory(0);
-    let date = &*(emscripten_memory_pointer!(memory.view(&ctx), time) as *mut guest_tm);
-
-    let days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
-    let months = [
-        "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
-    ];
-    let year = 1900 + date.tm_year;
-
-    let time_str = format!(
-        // NOTE: TODO: Hack! The 14 accompanying chars are needed for some reason
-        "{} {} {:2} {:02}:{:02}:{:02} {:4}\n\0\0\0\0\0\0\0\0\0\0\0\0\0",
-        days[date.tm_wday as usize],
-        months[date.tm_mon as usize],
-        date.tm_mday,
-        date.tm_hour,
-        date.tm_min,
-        date.tm_sec,
-        year
-    );
-
-    time_str[0..26].as_ptr() as _
-}
-
-/// emscripten: _asctime
-pub fn _asctime(mut ctx: FunctionEnvMut<EmEnv>, time: u32) -> u32 {
-    debug!("emscripten::_asctime {}", time);
-
-    unsafe {
-        let time_str_ptr = fmt_time(ctx.as_mut(), time);
-        copy_cstr_into_wasm(&mut ctx, time_str_ptr)
-
-        // let c_str = emscripten_memory_pointer!(ctx, ctx.data().memory(0), res) as *mut i8;
-        // use std::ffi::CStr;
-        // debug!("#### cstr = {:?}", CStr::from_ptr(c_str));
-    }
-}
-
-/// emscripten: _asctime_r
-pub fn _asctime_r(mut ctx: FunctionEnvMut<EmEnv>, time: u32, buf: u32) -> u32 {
-    debug!("emscripten::_asctime_r {}, {}", time, buf);
-
-    unsafe {
-        // NOTE: asctime_r is specced to behave in an undefined manner if the algorithm would attempt
-        //      to write out more than 26 bytes (including the null terminator).
-        //      See http://pubs.opengroup.org/onlinepubs/9699919799/functions/asctime.html
-        //      Our undefined behavior is to truncate the write to at most 26 bytes, including null terminator.
-        let time_str_ptr = fmt_time(ctx.as_mut(), time);
-        write_to_buf(ctx, time_str_ptr, buf, 26)
-
-        // let c_str = emscripten_memory_pointer!(ctx, ctx.data().memory(0), res) as *mut i8;
-        // use std::ffi::CStr;
-        // debug!("#### cstr = {:?}", CStr::from_ptr(c_str));
-    }
-}
-
-/// emscripten: _localtime
-#[allow(clippy::cast_ptr_alignment)]
-pub fn _localtime(mut ctx: FunctionEnvMut<EmEnv>, time_p: u32) -> c_int {
-    debug!("emscripten::_localtime {}", time_p);
-    // NOTE: emscripten seems to want tzset() called in this function
-    //      https://stackoverflow.com/questions/19170721/real-time-awareness-of-timezone-change-in-localtime-vs-localtime-r
-
-    let memory = ctx.data().memory(0);
-    let timespec = unsafe {
-        let time_p_addr = emscripten_memory_pointer!(memory.view(&ctx), time_p) as *mut i64;
-        let seconds = *time_p_addr;
-        time::OffsetDateTime::from_unix_timestamp(seconds).unwrap()
-    };
-
-    unsafe {
-        let tm_struct_offset = env::call_malloc(&mut ctx, mem::size_of::<guest_tm>() as _);
-        let tm_struct_ptr =
-            emscripten_memory_pointer!(memory.view(&ctx), tm_struct_offset) as *mut guest_tm;
-        // debug!(
-        //     ">>>>>>> time = {}, {}, {}, {}, {}, {}, {}, {}",
-        //     result_tm.tm_sec, result_tm.tm_min, result_tm.tm_hour, result_tm.tm_mday,
-        //     result_tm.tm_mon, result_tm.tm_year, result_tm.tm_wday, result_tm.tm_yday,
-        // );
-        (*tm_struct_ptr).tm_sec = timespec.second() as _;
-        (*tm_struct_ptr).tm_min = timespec.minute() as _;
-        (*tm_struct_ptr).tm_hour = timespec.hour() as _;
-        (*tm_struct_ptr).tm_mon = timespec.month() as _;
-        (*tm_struct_ptr).tm_mday = timespec.day() as _;
-        (*tm_struct_ptr).tm_year = timespec.year();
-        (*tm_struct_ptr).tm_wday = timespec.weekday() as _;
-        (*tm_struct_ptr).tm_yday = timespec.ordinal() as _;
-        (*tm_struct_ptr).tm_isdst = -1; // DST information unknown with time 0.2+
-        (*tm_struct_ptr).tm_gmtoff = 0;
-        (*tm_struct_ptr).tm_zone = 0;
-
-        tm_struct_offset as _
-    }
-}
-/// emscripten: _localtime_r
-#[allow(clippy::cast_ptr_alignment)]
-pub fn _localtime_r(ctx: FunctionEnvMut<EmEnv>, time_p: u32, result: u32) -> c_int {
-    debug!("emscripten::_localtime_r {}", time_p);
-
-    // NOTE: emscripten seems to want tzset() called in this function
-    //      https://stackoverflow.com/questions/19170721/real-time-awareness-of-timezone-change-in-localtime-vs-localtime-r
-
-    let memory = ctx.data().memory(0);
-    unsafe {
-        let seconds = emscripten_memory_pointer!(memory.view(&ctx), time_p) as *const i32;
-        let timespec = time::OffsetDateTime::from_unix_timestamp_nanos(*seconds as _).unwrap();
-
-        // debug!(
-        //     ">>>>>>> time = {}, {}, {}, {}, {}, {}, {}, {}",
-        //     result_tm.tm_sec, result_tm.tm_min, result_tm.tm_hour, result_tm.tm_mday,
-        //     result_tm.tm_mon, result_tm.tm_year, result_tm.tm_wday, result_tm.tm_yday,
-        // );
-
-        let result_addr = emscripten_memory_pointer!(memory.view(&ctx), result) as *mut guest_tm;
-
-        (*result_addr).tm_sec = timespec.second() as _;
-        (*result_addr).tm_min = timespec.minute() as _;
-        (*result_addr).tm_hour = timespec.hour() as _;
-        (*result_addr).tm_mon = timespec.month() as _;
-        (*result_addr).tm_mday = timespec.day() as _;
-        (*result_addr).tm_year = timespec.year();
-        (*result_addr).tm_wday = timespec.weekday() as _;
-        (*result_addr).tm_yday = timespec.ordinal() as _;
-        (*result_addr).tm_isdst = -1; // DST information unknown with time 0.2+
-        (*result_addr).tm_gmtoff = 0;
-        (*result_addr).tm_zone = 0;
-
-        result as _
-    }
-}
-
-/// emscripten: _time
-#[allow(clippy::cast_ptr_alignment)]
-pub fn _time(ctx: FunctionEnvMut<EmEnv>, time_p: u32) -> i32 {
-    debug!("emscripten::_time {}", time_p);
-
-    unsafe {
-        let memory = ctx.data().memory(0);
-        let time_p_addr = emscripten_memory_pointer!(memory.view(&ctx), time_p) as *mut i64;
-        libc_time(time_p_addr) as i32 // TODO review i64
-    }
-}
-
-pub fn _ctime_r(mut ctx: FunctionEnvMut<EmEnv>, time_p: u32, buf: u32) -> u32 {
-    debug!("emscripten::_ctime_r {} {}", time_p, buf);
-
-    // var stack = stackSave();
-    let (result_offset, _result_slice): (u32, &mut [u8]) =
-        unsafe { allocate_on_stack(&mut ctx, 44) };
-    let time = _localtime_r(ctx.as_mut(), time_p, result_offset) as u32;
-    _asctime_r(ctx, time, buf)
-    // stackRestore(stack);
-}
-
-pub fn _ctime(ctx: FunctionEnvMut<EmEnv>, time_p: u32) -> u32 {
-    debug!("emscripten::_ctime {}", time_p);
-    let tm_current = 2414544;
-    _ctime_r(ctx, time_p, tm_current)
-}
-
-/// emscripten: _timegm
-#[cfg(not(target_os = "windows"))]
-#[allow(clippy::cast_ptr_alignment)]
-pub fn _timegm(ctx: FunctionEnvMut<EmEnv>, time_ptr: u32) -> i32 {
-    debug!("emscripten::_timegm {}", time_ptr);
-
-    unsafe {
-        let memory = ctx.data().memory(0);
-        let time_p_addr = emscripten_memory_pointer!(memory.view(&ctx), time_ptr) as *mut guest_tm;
-
-        let x: *mut c_char = CString::new("").expect("CString::new failed").into_raw();
-        let mut rust_tm = libc_tm {
-            tm_sec: 0,
-            tm_min: 0,
-            tm_hour: 0,
-            tm_mday: 0,
-            tm_mon: 0,
-            tm_year: 0,
-            tm_wday: 0,
-            tm_yday: 0,
-            tm_isdst: 0,
-            tm_gmtoff: 0,
-            tm_zone: x,
-        };
-
-        let result = libc_timegm(&mut rust_tm) as i32;
-        if result != 0 {
-            (*time_p_addr).tm_sec = rust_tm.tm_sec;
-            (*time_p_addr).tm_min = rust_tm.tm_min;
-            (*time_p_addr).tm_hour = rust_tm.tm_hour;
-            (*time_p_addr).tm_mday = rust_tm.tm_mday;
-            (*time_p_addr).tm_mon = rust_tm.tm_mon;
-            (*time_p_addr).tm_year = rust_tm.tm_year;
-            (*time_p_addr).tm_wday = rust_tm.tm_wday;
-            (*time_p_addr).tm_yday = rust_tm.tm_yday;
-            (*time_p_addr).tm_isdst = rust_tm.tm_isdst;
-            (*time_p_addr).tm_gmtoff = rust_tm.tm_gmtoff as _;
-            (*time_p_addr).tm_zone = 0;
-        }
-        result
-    }
-}
-
-#[cfg(target_os = "windows")]
-pub fn _timegm(mut _ctx: FunctionEnvMut<EmEnv>, _time_ptr: c_int) -> i32 {
-    debug!(
-        "emscripten::_timegm - UNIMPLEMENTED IN WINDOWS {}",
-        _time_ptr
-    );
-    -1
-}
-
-/// emscripten: _strftime
-pub fn _strftime(
-    ctx: FunctionEnvMut<EmEnv>,
-    s_ptr: c_int,
-    maxsize: u32,
-    format_ptr: c_int,
-    tm_ptr: c_int,
-) -> i32 {
-    debug!(
-        "emscripten::_strftime {} {} {} {}",
-        s_ptr, maxsize, format_ptr, tm_ptr
-    );
-
-    let memory = ctx.data().memory(0);
-    #[allow(clippy::cast_ptr_alignment)]
-    let s = emscripten_memory_pointer!(memory.view(&ctx), s_ptr) as *mut c_char;
-    #[allow(clippy::cast_ptr_alignment)]
-    let format = emscripten_memory_pointer!(memory.view(&ctx), format_ptr) as *const c_char;
-    #[allow(clippy::cast_ptr_alignment)]
-    let tm = emscripten_memory_pointer!(memory.view(&ctx), tm_ptr) as *const guest_tm;
-
-    let format_string = unsafe { std::ffi::CStr::from_ptr(format).to_str().unwrap() };
-
-    debug!("=> format_string: {:?}", format_string);
-
-    let tm = unsafe { &*tm };
-
-    let Ok(rust_date) = time::Date::from_calendar_date(
-        tm.tm_year,
-        time::Month::try_from(tm.tm_mon as u8).unwrap(),
-        tm.tm_mday as u8,
-    ) else {
-        return 0;
-    };
-    let Ok(rust_time) = time::Time::from_hms(tm.tm_hour as u8, tm.tm_min as u8, tm.tm_sec as u8)
-    else {
-        return 0;
-    };
-    let rust_datetime = time::PrimitiveDateTime::new(rust_date, rust_time);
-    let rust_odt =
-        rust_datetime.assume_offset(time::UtcOffset::from_whole_seconds(tm.tm_gmtoff).unwrap());
-
-    let result_str = rust_odt
-        .format(&time::format_description::parse(format_string).unwrap())
-        .unwrap();
-
-    // pad for null?
-    let bytes = result_str.chars().count();
-    if bytes as u32 > maxsize {
-        0
-    } else {
-        // write output string
-        for (i, c) in result_str.chars().enumerate() {
-            unsafe { *s.add(i) = c as c_char };
-        }
-        // null terminate?
-        bytes as i32
-    }
-}
-
-/// emscripten: _strftime_l
-pub fn _strftime_l(
-    ctx: FunctionEnvMut<EmEnv>,
-    s_ptr: c_int,
-    maxsize: u32,
-    format_ptr: c_int,
-    tm_ptr: c_int,
-    _last: c_int,
-) -> i32 {
-    debug!(
-        "emscripten::_strftime_l {} {} {} {}",
-        s_ptr, maxsize, format_ptr, tm_ptr
-    );
-
-    _strftime(ctx, s_ptr, maxsize, format_ptr, tm_ptr)
-}
diff --git a/lib/emscripten/src/ucontext.rs b/lib/emscripten/src/ucontext.rs
deleted file mode 100644
index 58c9f929bc..0000000000
--- a/lib/emscripten/src/ucontext.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-use crate::EmEnv;
-use wasmer::FunctionEnvMut;
-
-pub fn _getcontext(mut _ctx: FunctionEnvMut<EmEnv>, _ucp: i32) -> i32 {
-    debug!("emscripten::_getcontext({})", _ucp);
-    0
-}
-pub fn _makecontext(
-    mut _ctx: FunctionEnvMut<EmEnv>,
-    _ucp: i32,
-    _func: i32,
-    _argc: i32,
-    _argv: i32,
-) {
-    debug!(
-        "emscripten::_makecontext({}, {}, {}, {})",
-        _ucp, _func, _argc, _argv
-    );
-}
-pub fn _setcontext(mut _ctx: FunctionEnvMut<EmEnv>, _ucp: i32) -> i32 {
-    debug!("emscripten::_setcontext({})", _ucp);
-    0
-}
-pub fn _swapcontext(mut _ctx: FunctionEnvMut<EmEnv>, _oucp: i32, _ucp: i32) -> i32 {
-    debug!("emscripten::_swapcontext({}, {})", _oucp, _ucp);
-    0
-}
diff --git a/lib/emscripten/src/unistd.rs b/lib/emscripten/src/unistd.rs
deleted file mode 100644
index b6875d055a..0000000000
--- a/lib/emscripten/src/unistd.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-use crate::EmEnv;
-use wasmer::FunctionEnvMut;
-
-pub fn confstr(mut _ctx: FunctionEnvMut<EmEnv>, _name: i32, _buf_pointer: i32, _len: i32) -> i32 {
-    debug!("unistd::confstr({}, {}, {})", _name, _buf_pointer, _len);
-    0
-}
diff --git a/lib/emscripten/src/utils.rs b/lib/emscripten/src/utils.rs
deleted file mode 100644
index 41c23fe5e3..0000000000
--- a/lib/emscripten/src/utils.rs
+++ /dev/null
@@ -1,310 +0,0 @@
-use super::env;
-use super::env::{get_emscripten_data, get_emscripten_funcs};
-use crate::storage::align_memory;
-use crate::EmEnv;
-use libc::stat;
-use std::ffi::CStr;
-use std::mem::size_of;
-use std::os::raw::c_char;
-use std::path::PathBuf;
-use std::slice;
-use wasmer::{FunctionEnvMut, GlobalInit, MemoryView, Module, Pages, WasmPtr};
-
-/// We check if a provided module is an Emscripten generated one
-pub fn is_emscripten_module(module: &Module) -> bool {
-    for import in module.imports().functions() {
-        let name = import.name();
-        let module = import.module();
-        if (name == "_emscripten_memcpy_big"
-            || name == "emscripten_memcpy_big"
-            || name == "__map_file")
-            && module == "env"
-        {
-            return true;
-        }
-    }
-    false
-}
-
-pub fn get_emscripten_table_size(module: &Module) -> Result<(u32, Option<u32>), String> {
-    if let Some(import) = module.imports().tables().next() {
-        let ty = import.ty();
-        Ok((ty.minimum, ty.maximum))
-    } else {
-        Err("Emscripten requires at least one imported table".to_string())
-    }
-}
-
-pub fn get_emscripten_memory_size(module: &Module) -> Result<(Pages, Option<Pages>, bool), String> {
-    if let Some(import) = module.imports().memories().next() {
-        let ty = import.ty();
-        Ok((ty.minimum, ty.maximum, ty.shared))
-    } else {
-        Err("Emscripten requires at least one imported memory".to_string())
-    }
-}
-
-/// Reads values written by `-s EMIT_EMSCRIPTEN_METADATA=1`
-/// Assumes values start from the end in this order:
-/// Last export: Dynamic Base
-/// Second-to-Last export: Dynamic top pointer
-pub fn get_emscripten_metadata(module: &Module) -> Result<Option<(u32, u32)>, String> {
-    let max_idx = match module
-        .info()
-        .global_initializers
-        .iter()
-        .map(|(k, _)| k)
-        .max()
-    {
-        Some(x) => x,
-        None => return Ok(None),
-    };
-
-    let snd_max_idx = match module
-        .info()
-        .global_initializers
-        .iter()
-        .map(|(k, _)| k)
-        .filter(|k| *k != max_idx)
-        .max()
-    {
-        Some(x) => x,
-        None => return Ok(None),
-    };
-
-    if let (GlobalInit::I32Const(dynamic_base), GlobalInit::I32Const(dynamictop_ptr)) = (
-        &module.info().global_initializers[max_idx],
-        &module.info().global_initializers[snd_max_idx],
-    ) {
-        let dynamic_base = (*dynamic_base as u32).checked_sub(32).ok_or_else(|| {
-            format!(
-                "emscripten unexpected dynamic_base {}",
-                *dynamic_base as u32
-            )
-        })?;
-        let dynamictop_ptr = (*dynamictop_ptr as u32).checked_sub(32).ok_or_else(|| {
-            format!(
-                "emscripten unexpected dynamictop_ptr {}",
-                *dynamictop_ptr as u32
-            )
-        })?;
-        Ok(Some((
-            align_memory(dynamic_base),
-            align_memory(dynamictop_ptr),
-        )))
-    } else {
-        Ok(None)
-    }
-}
-
-pub unsafe fn write_to_buf(
-    ctx: FunctionEnvMut<EmEnv>,
-    string: *const c_char,
-    buf: u32,
-    max: u32,
-) -> u32 {
-    let memory = ctx.data().memory(0);
-    let buf_addr = emscripten_memory_pointer!(memory.view(&ctx), buf) as *mut c_char;
-
-    for i in 0..max {
-        *buf_addr.add(i as _) = *string.add(i as _);
-    }
-
-    buf
-}
-
-/// This function expects nullbyte to be appended.
-pub unsafe fn copy_cstr_into_wasm(ctx: &mut FunctionEnvMut<EmEnv>, cstr: *const c_char) -> u32 {
-    let s = CStr::from_ptr(cstr).to_str().unwrap();
-    let cstr_len = s.len();
-    let space_offset = env::call_malloc(ctx, (cstr_len as u32) + 1);
-    let memory = ctx.data().memory(0);
-    let raw_memory = emscripten_memory_pointer!(memory.view(&ctx), space_offset) as *mut c_char;
-    let slice = slice::from_raw_parts_mut(raw_memory, cstr_len);
-
-    for (byte, loc) in s.bytes().zip(slice.iter_mut()) {
-        *loc = byte as _;
-    }
-
-    // TODO: Appending null byte won't work, because there is CStr::from_ptr(cstr)
-    //      at the top that crashes when there is no null byte
-    *raw_memory.add(cstr_len) = 0;
-
-    space_offset
-}
-
-/// # Safety
-/// This method is unsafe because it operates directly with the slice of memory represented by the address
-pub unsafe fn allocate_on_stack<'a, T: Copy>(
-    mut ctx: &mut FunctionEnvMut<'a, EmEnv>,
-    count: u32,
-) -> (u32, &'a mut [T]) {
-    let stack_alloc_ref = get_emscripten_funcs(ctx).stack_alloc_ref().unwrap().clone();
-    let offset = stack_alloc_ref
-        .call(&mut ctx, count * (size_of::<T>() as u32))
-        .unwrap();
-
-    let memory = ctx.data().memory(0);
-    let addr = emscripten_memory_pointer!(memory.view(&ctx), offset) as *mut T;
-    let slice = slice::from_raw_parts_mut(addr, count as usize);
-
-    (offset, slice)
-}
-
-/// # Safety
-/// This method is unsafe because it uses `allocate_on_stack` which is unsafe
-pub unsafe fn allocate_cstr_on_stack<'a>(
-    ctx: &'a mut FunctionEnvMut<'a, EmEnv>,
-    s: &str,
-) -> (u32, &'a [u8]) {
-    let (offset, slice) = allocate_on_stack(ctx, (s.len() + 1) as u32);
-
-    use std::iter;
-    for (byte, loc) in s.bytes().chain(iter::once(0)).zip(slice.iter_mut()) {
-        *loc = byte;
-    }
-
-    (offset, slice)
-}
-
-#[cfg(not(target_os = "windows"))]
-pub unsafe fn copy_terminated_array_of_cstrs(
-    mut _ctx: FunctionEnvMut<EmEnv>,
-    cstrs: *mut *mut c_char,
-) -> u32 {
-    let _total_num = {
-        let mut ptr = cstrs;
-        let mut counter = 0;
-        while !(*ptr).is_null() {
-            counter += 1;
-            ptr = ptr.add(1);
-        }
-        counter
-    };
-    debug!(
-        "emscripten::copy_terminated_array_of_cstrs::total_num: {}",
-        _total_num
-    );
-    0
-}
-
-#[repr(C)]
-pub struct GuestStat {
-    st_dev: u32,
-    __st_dev_padding: u32,
-    __st_ino_truncated: u32,
-    st_mode: u32,
-    st_nlink: u32,
-    st_uid: u32,
-    st_gid: u32,
-    st_rdev: u32,
-    __st_rdev_padding: u32,
-    st_size: u32,
-    st_blksize: u32,
-    st_blocks: u32,
-    st_atime: u64,
-    st_mtime: u64,
-    st_ctime: u64,
-    st_ino: u32,
-}
-
-#[allow(clippy::cast_ptr_alignment)]
-pub unsafe fn copy_stat_into_wasm(ctx: FunctionEnvMut<EmEnv>, buf: u32, stat: &stat) {
-    let memory = ctx.data().memory(0);
-    let stat_ptr = emscripten_memory_pointer!(memory.view(&ctx), buf) as *mut GuestStat;
-    (*stat_ptr).st_dev = stat.st_dev as _;
-    (*stat_ptr).__st_dev_padding = 0;
-    (*stat_ptr).__st_ino_truncated = stat.st_ino as _;
-    (*stat_ptr).st_mode = stat.st_mode as _;
-    (*stat_ptr).st_nlink = stat.st_nlink as _;
-    (*stat_ptr).st_uid = stat.st_uid as _;
-    (*stat_ptr).st_gid = stat.st_gid as _;
-    (*stat_ptr).st_rdev = stat.st_rdev as _;
-    (*stat_ptr).__st_rdev_padding = 0;
-    (*stat_ptr).st_size = stat.st_size as _;
-    (*stat_ptr).st_blksize = 4096;
-    #[cfg(not(target_os = "windows"))]
-    {
-        (*stat_ptr).st_blocks = stat.st_blocks as _;
-    }
-    #[cfg(target_os = "windows")]
-    {
-        (*stat_ptr).st_blocks = 0;
-    }
-    (*stat_ptr).st_atime = stat.st_atime as _;
-    (*stat_ptr).st_mtime = stat.st_mtime as _;
-    (*stat_ptr).st_ctime = stat.st_ctime as _;
-    (*stat_ptr).st_ino = stat.st_ino as _;
-}
-
-#[allow(dead_code)] // it's used in `env/windows/mod.rs`.
-pub fn read_string_from_wasm(memory: &MemoryView, offset: u32) -> String {
-    WasmPtr::<u8>::new(offset)
-        .read_utf8_string_with_nul(memory)
-        .unwrap()
-}
-
-/// This function trys to find an entry in mapdir
-/// translating paths into their correct value
-pub fn get_cstr_path(ctx: FunctionEnvMut<EmEnv>, path: *const i8) -> Option<std::ffi::CString> {
-    use std::collections::VecDeque;
-
-    let path_str =
-        unsafe { std::ffi::CStr::from_ptr(path as *const _).to_str().unwrap() }.to_string();
-    let data = get_emscripten_data(&ctx);
-    let path = PathBuf::from(path_str);
-    let mut prefix_added = false;
-    let mut components = path.components().collect::<VecDeque<_>>();
-    // TODO(mark): handle absolute/non-canonical/non-relative paths too (this
-    // functionality should be shared among the abis)
-    if components.len() == 1 {
-        components.push_front(std::path::Component::CurDir);
-        prefix_added = true;
-    }
-    let mut cumulative_path = PathBuf::new();
-    for c in components.into_iter() {
-        cumulative_path.push(c);
-        if let Some(val) = data
-            .as_ref()
-            .unwrap()
-            .mapped_dirs
-            .get(&cumulative_path.to_string_lossy().to_string())
-        {
-            let rest_of_path = if !prefix_added {
-                path.strip_prefix(cumulative_path).ok()?
-            } else {
-                &path
-            };
-            let rebased_path = val.join(rest_of_path);
-            return std::ffi::CString::new(rebased_path.to_string_lossy().as_bytes()).ok();
-        }
-    }
-    None
-}
-
-/// gets the current directory
-/// handles mapdir logic
-pub fn get_current_directory(ctx: FunctionEnvMut<EmEnv>) -> Option<PathBuf> {
-    if let Some(val) = get_emscripten_data(&ctx)
-        .as_ref()
-        .unwrap()
-        .mapped_dirs
-        .get(".")
-    {
-        return Some(val.clone());
-    }
-    std::env::current_dir()
-        .map(|cwd| {
-            if let Some(val) = get_emscripten_data(&ctx)
-                .as_ref()
-                .unwrap()
-                .mapped_dirs
-                .get(&cwd.to_string_lossy().to_string())
-            {
-                val.clone()
-            } else {
-                cwd
-            }
-        })
-        .ok()
-}
diff --git a/lib/emscripten/src/varargs.rs b/lib/emscripten/src/varargs.rs
deleted file mode 100644
index 126d1fa080..0000000000
--- a/lib/emscripten/src/varargs.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-use crate::EmEnv;
-use std::mem;
-use wasmer::FromToNativeWasmType;
-// use std::ffi::CStr;
-use std::os::raw::c_char;
-use wasmer::FunctionEnvMut;
-
-#[repr(transparent)]
-#[derive(Copy, Clone)]
-pub struct VarArgs {
-    pub pointer: u32, // assuming 32bit wasm
-}
-
-impl VarArgs {
-    pub fn get<T: Sized>(&mut self, ctx: &FunctionEnvMut<EmEnv>) -> T {
-        let memory = ctx.data().memory(0);
-        let ptr = emscripten_memory_pointer!(memory.view(&ctx), self.pointer);
-        self.pointer += mem::size_of::<T>() as u32;
-        unsafe { (ptr as *const T).read() }
-    }
-
-    // pub fn getStr<'a>(&mut self, ctx: &mut Ctx) -> &'a CStr {
-    pub fn get_str(&mut self, ctx: &FunctionEnvMut<EmEnv>) -> *const c_char {
-        let ptr_addr: u32 = self.get(ctx);
-        let memory = ctx.data().memory(0);
-        emscripten_memory_pointer!(memory.view(&ctx), ptr_addr) as *const c_char
-    }
-}
-
-unsafe impl FromToNativeWasmType for VarArgs {
-    type Native = i32;
-
-    fn to_native(self) -> Self::Native {
-        self.pointer as _
-    }
-    fn from_native(n: Self::Native) -> Self {
-        Self { pointer: n as u32 }
-    }
-}
diff --git a/lib/journal/Cargo.toml b/lib/journal/Cargo.toml
index 891040d40f..c475dfd914 100644
--- a/lib/journal/Cargo.toml
+++ b/lib/journal/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "wasmer-journal"
-version = "0.9.0"
+version = "0.601.0"
 description = "Journaling functionality used by Wasmer to save and restore WASM state"
 authors.workspace = true
 edition.workspace = true
@@ -10,31 +10,41 @@ repository.workspace = true
 rust-version.workspace = true
 
 [features]
-default = [ "log-file", "wasmer/sys" ]
-log-file = [ "shared-buffer" ]
+default = ["log-file", "wasmer/sys-default"]
+log-file = ["shared-buffer"]
 
 [dependencies]
-wasmer = { default-features = false, path = "../api", version = "=4.3.7" }
-wasmer-wasix-types = { path = "../wasi-types", version = "0.27.0", features = [ "enable-serde" ] }
-virtual-net = { path = "../virtual-net", version = "0.8.0", default-features = false, features = ["rkyv"] }
-virtual-fs = { path = "../virtual-fs", version = "0.16.0", default-features = false }
+wasmer = { default-features = false, path = "../api", version = "=6.1.0" }
+wasmer-config = { default-features = false, path = "../config", version = "=0.601.0" }
+wasmer-wasix-types = { path = "../wasi-types", version = "0.601.0", features = [
+	"enable-serde",
+] }
+virtual-net = { path = "../virtual-net", version = "0.601.0", default-features = false, features = [
+	"rkyv",
+] }
+virtual-fs = { path = "../virtual-fs", version = "0.601.0", default-features = false }
 
 shared-buffer = { workspace = true, optional = true }
-thiserror = "1"
-bytes = "1.1"
-async-trait = { version = "^0.1" }
-tracing = "0.1"
-derivative = { version = "^2" }
-base64 = "0.21"
+base64.workspace = true
+derive_more.workspace = true
+rkyv.workspace = true
+
+thiserror.workspace = true
+bytes.workspace = true
+async-trait = { workspace = true }
+tracing.workspace = true
 bincode = { version = "1.3" }
-serde = { version = "1.0", default-features = false, features = ["derive"] }
-anyhow = "1.0"
-rkyv = { workspace = true }
-bytecheck = { version = "0.6.8" }
+serde = { workspace = true, default-features = false, features = ["derive"] }
+serde_json.workspace = true
+anyhow.workspace = true
+bytecheck.workspace = true
 lz4_flex = { version = "0.11" }
-num_enum = "0.5.7"
-serde_json = { version = "^1" }
+num_enum.workspace = true
 
 [dev-dependencies]
-tracing-test = "0.2.4"
-tempfile = "3.6.0"
\ No newline at end of file
+tracing-test.workspace = true
+tempfile.workspace = true
+
+[package.metadata.docs.rs]
+features = ["wasmer/sys", "wasmer/compiler"]
+rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/journal/src/concrete/aligned_cow_str.rs b/lib/journal/src/concrete/aligned_cow_str.rs
index c9676cbaf4..b77e42c9f8 100644
--- a/lib/journal/src/concrete/aligned_cow_str.rs
+++ b/lib/journal/src/concrete/aligned_cow_str.rs
@@ -1,9 +1,10 @@
-use std::{borrow::Cow, fmt, ops::Deref};
+use std::{borrow::Cow, ops::Deref};
 
 use rkyv::{
-    ser::{ScratchSpace, Serializer},
+    rancor::Fallible,
+    ser::{Allocator, WriterExt},
     vec::{ArchivedVec, VecResolver},
-    Archive, Archived, Serialize,
+    Archive, Archived,
 };
 
 #[derive(Clone)]
@@ -32,7 +33,7 @@ impl<'a> AlignedCowStr<'a> {
     }
 }
 
-impl<'a> Default for AlignedCowStr<'a> {
+impl Default for AlignedCowStr<'_> {
     fn default() -> Self {
         Self {
             inner: String::new().into(),
@@ -40,14 +41,14 @@ impl<'a> Default for AlignedCowStr<'a> {
     }
 }
 
-impl<'a> fmt::Debug for AlignedCowStr<'a> {
+impl std::fmt::Debug for AlignedCowStr<'_> {
     #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         self.inner.fmt(f)
     }
 }
 
-impl<'a> From<String> for AlignedCowStr<'a> {
+impl From<String> for AlignedCowStr<'_> {
     fn from(value: String) -> Self {
         Self {
             inner: value.into(),
@@ -56,7 +57,7 @@ impl<'a> From<String> for AlignedCowStr<'a> {
 }
 
 #[allow(clippy::from_over_into)]
-impl<'a> Into<String> for AlignedCowStr<'a> {
+impl Into<String> for AlignedCowStr<'_> {
     fn into(self) -> String {
         self.inner.into_owned()
     }
@@ -75,7 +76,7 @@ impl<'a> Into<Cow<'a, str>> for AlignedCowStr<'a> {
     }
 }
 
-impl<'a> Deref for AlignedCowStr<'a> {
+impl Deref for AlignedCowStr<'_> {
     type Target = str;
 
     fn deref(&self) -> &Self::Target {
@@ -83,32 +84,31 @@ impl<'a> Deref for AlignedCowStr<'a> {
     }
 }
 
-impl<'a> AsRef<str> for AlignedCowStr<'a> {
+impl AsRef<str> for AlignedCowStr<'_> {
     #[inline]
     fn as_ref(&self) -> &str {
         self.inner.as_ref()
     }
 }
 
-impl<'a> Archive for AlignedCowStr<'a> {
+impl Archive for AlignedCowStr<'_> {
     type Archived = ArchivedVec<u8>;
     type Resolver = VecResolver;
 
     #[inline]
-    unsafe fn resolve(&self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived) {
-        ArchivedVec::resolve_from_len(self.inner.as_bytes().len(), pos, resolver, out);
+    fn resolve(&self, resolver: Self::Resolver, out: rkyv::Place<Self::Archived>) {
+        ArchivedVec::resolve_from_len(self.inner.len(), resolver, out);
     }
 }
 
-impl<'a, S: ScratchSpace + Serializer + ?Sized> Serialize<S> for AlignedCowStr<'a> {
+impl<S> rkyv::Serialize<S> for AlignedCowStr<'_>
+where
+    S: Fallible + WriterExt<S::Error> + Allocator + ?Sized,
+    S::Error: rkyv::rancor::Source,
+{
     #[inline]
     fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
         serializer.align(Self::ALIGNMENT)?;
-        unsafe {
-            ArchivedVec::<Archived<u8>>::serialize_copy_from_slice(
-                self.inner.as_bytes(),
-                serializer,
-            )
-        }
+        ArchivedVec::<Archived<u8>>::serialize_from_slice(self.inner.as_bytes(), serializer)
     }
 }
diff --git a/lib/journal/src/concrete/aligned_cow_vec.rs b/lib/journal/src/concrete/aligned_cow_vec.rs
index 49ff1bb93c..08db36347e 100644
--- a/lib/journal/src/concrete/aligned_cow_vec.rs
+++ b/lib/journal/src/concrete/aligned_cow_vec.rs
@@ -5,9 +5,10 @@ use std::{
 };
 
 use rkyv::{
-    ser::{ScratchSpace, Serializer},
+    rancor::Fallible,
+    ser::{Allocator, WriterExt},
     vec::{ArchivedVec, VecResolver},
-    Archive, Archived, Serialize,
+    Archive, Archived,
 };
 
 /// An aligned COW vector of bytes which avoids copying data
@@ -92,7 +93,7 @@ where
 }
 
 #[allow(clippy::from_over_into)]
-impl<'a> Into<Vec<u8>> for AlignedCowVec<'a, u8> {
+impl Into<Vec<u8>> for AlignedCowVec<'_, u8> {
     fn into(self) -> Vec<u8> {
         self.inner.into_owned()
     }
@@ -197,17 +198,19 @@ where
     type Resolver = VecResolver;
 
     #[inline]
-    unsafe fn resolve(&self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived) {
-        ArchivedVec::resolve_from_len(self.len(), pos, resolver, out);
+    fn resolve(&self, resolver: Self::Resolver, out: rkyv::Place<Self::Archived>) {
+        ArchivedVec::resolve_from_len(self.len(), resolver, out);
     }
 }
 
-impl<'a, S: ScratchSpace + Serializer + ?Sized> Serialize<S> for AlignedCowVec<'a, u8> {
+impl<S> rkyv::Serialize<S> for AlignedCowVec<'_, u8>
+where
+    S: Fallible + WriterExt<S::Error> + Allocator + ?Sized,
+    S::Error: rkyv::rancor::Source,
+{
     #[inline]
     fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
         serializer.align(Self::ALIGNMENT)?;
-        unsafe {
-            ArchivedVec::<Archived<u8>>::serialize_copy_from_slice(self.as_slice(), serializer)
-        }
+        ArchivedVec::<Archived<u8>>::serialize_from_slice(self.as_slice(), serializer)
     }
 }
diff --git a/lib/journal/src/concrete/archived.rs b/lib/journal/src/concrete/archived.rs
index 64d0ad2ce6..af403f705a 100644
--- a/lib/journal/src/concrete/archived.rs
+++ b/lib/journal/src/concrete/archived.rs
@@ -1,6 +1,9 @@
 use num_enum::{IntoPrimitive, TryFromPrimitive};
-use rkyv::ser::{ScratchSpace, Serializer};
-use rkyv::{Archive, CheckBytes, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+use rkyv::rancor::Fallible;
+use rkyv::ser::{Allocator, Writer};
+use rkyv::{
+    api::serialize_using, Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize,
+};
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
 use std::time::{Duration, SystemTime};
 
@@ -22,7 +25,7 @@ pub const JOURNAL_MAGIC_NUMBER_BYTES: [u8; 8] = JOURNAL_MAGIC_NUMBER.to_be_bytes
     RkyvDeserialize,
     Archive,
 )]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub enum JournalEntryRecordType {
     InitModuleV1 = 1,
     ProcessExitV1 = 2,
@@ -83,6 +86,10 @@ pub enum JournalEntryRecordType {
     SocketShutdownV1 = 58,
     SnapshotV1 = 59,
     ClearEtherealV1 = 60,
+    OpenFileDescriptorV2 = 61,
+    DuplicateFileDescriptorV2 = 62,
+    FileDescriptorSetFdFlagsV1 = 63,
+    SocketPairV1 = 64,
 }
 
 impl JournalEntryRecordType {
@@ -93,257 +100,195 @@ impl JournalEntryRecordType {
     /// can not be manipulated or corrupted.
     pub unsafe fn deserialize_archive(self, data: &[u8]) -> anyhow::Result<JournalEntry<'_>> {
         match self {
-            JournalEntryRecordType::InitModuleV1 => ArchivedJournalEntry::InitModuleV1(
-                rkyv::archived_root::<JournalEntryInitModuleV1>(data),
-            ),
+            JournalEntryRecordType::InitModuleV1 => {
+                ArchivedJournalEntry::InitModuleV1(rkyv::access_unchecked(data))
+            }
             JournalEntryRecordType::ClearEtherealV1 => {
-                ArchivedJournalEntry::ClearEtherealV1(rkyv::archived_root::<
-                    JournalEntryClearEtherealV1,
-                >(data))
+                ArchivedJournalEntry::ClearEtherealV1(rkyv::access_unchecked(data))
+            }
+            JournalEntryRecordType::ProcessExitV1 => {
+                ArchivedJournalEntry::ProcessExitV1(rkyv::access_unchecked(data))
+            }
+            JournalEntryRecordType::SetThreadV1 => {
+                ArchivedJournalEntry::SetThreadV1(rkyv::access_unchecked(data))
+            }
+            JournalEntryRecordType::CloseThreadV1 => {
+                ArchivedJournalEntry::CloseThreadV1(rkyv::access_unchecked(data))
             }
-            JournalEntryRecordType::ProcessExitV1 => ArchivedJournalEntry::ProcessExitV1(
-                rkyv::archived_root::<JournalEntryProcessExitV1>(data),
-            ),
-            JournalEntryRecordType::SetThreadV1 => ArchivedJournalEntry::SetThreadV1(
-                rkyv::archived_root::<JournalEntrySetThreadV1>(data),
-            ),
-            JournalEntryRecordType::CloseThreadV1 => ArchivedJournalEntry::CloseThreadV1(
-                rkyv::archived_root::<JournalEntryCloseThreadV1>(data),
-            ),
             JournalEntryRecordType::FileDescriptorSeekV1 => {
-                ArchivedJournalEntry::FileDescriptorSeekV1(rkyv::archived_root::<
-                    JournalEntryFileDescriptorSeekV1,
-                >(data))
+                ArchivedJournalEntry::FileDescriptorSeekV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::FileDescriptorWriteV1 => {
-                ArchivedJournalEntry::FileDescriptorWriteV1(rkyv::archived_root::<
-                    JournalEntryFileDescriptorWriteV1,
-                >(data))
+                ArchivedJournalEntry::FileDescriptorWriteV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::UpdateMemoryRegionV1 => {
-                ArchivedJournalEntry::UpdateMemoryRegionV1(rkyv::archived_root::<
-                    JournalEntryUpdateMemoryRegionV1,
-                >(data))
+                ArchivedJournalEntry::UpdateMemoryRegionV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::SetClockTimeV1 => {
-                ArchivedJournalEntry::SetClockTimeV1(rkyv::archived_root::<
-                    JournalEntrySetClockTimeV1,
-                >(data))
+                ArchivedJournalEntry::SetClockTimeV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::OpenFileDescriptorV1 => {
-                ArchivedJournalEntry::OpenFileDescriptorV1(rkyv::archived_root::<
-                    JournalEntryOpenFileDescriptorV1,
-                >(data))
+                ArchivedJournalEntry::OpenFileDescriptorV1(rkyv::access_unchecked(data))
+            }
+            JournalEntryRecordType::OpenFileDescriptorV2 => {
+                ArchivedJournalEntry::OpenFileDescriptorV2(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::CloseFileDescriptorV1 => {
-                ArchivedJournalEntry::CloseFileDescriptorV1(rkyv::archived_root::<
-                    JournalEntryCloseFileDescriptorV1,
-                >(data))
+                ArchivedJournalEntry::CloseFileDescriptorV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::RenumberFileDescriptorV1 => {
-                ArchivedJournalEntry::RenumberFileDescriptorV1(rkyv::archived_root::<
-                    JournalEntryRenumberFileDescriptorV1,
-                >(data))
+                ArchivedJournalEntry::RenumberFileDescriptorV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::DuplicateFileDescriptorV1 => {
-                ArchivedJournalEntry::DuplicateFileDescriptorV1(rkyv::archived_root::<
-                    JournalEntryDuplicateFileDescriptorV1,
-                >(data))
+                ArchivedJournalEntry::DuplicateFileDescriptorV1(rkyv::access_unchecked(data))
+            }
+            JournalEntryRecordType::DuplicateFileDescriptorV2 => {
+                ArchivedJournalEntry::DuplicateFileDescriptorV2(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::CreateDirectoryV1 => {
-                ArchivedJournalEntry::CreateDirectoryV1(rkyv::archived_root::<
-                    JournalEntryCreateDirectoryV1,
-                >(data))
+                ArchivedJournalEntry::CreateDirectoryV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::RemoveDirectoryV1 => {
-                ArchivedJournalEntry::RemoveDirectoryV1(rkyv::archived_root::<
-                    JournalEntryRemoveDirectoryV1,
-                >(data))
+                ArchivedJournalEntry::RemoveDirectoryV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::PathSetTimesV1 => {
-                ArchivedJournalEntry::PathSetTimesV1(rkyv::archived_root::<
-                    JournalEntryPathSetTimesV1,
-                >(data))
+                ArchivedJournalEntry::PathSetTimesV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::FileDescriptorSetTimesV1 => {
-                ArchivedJournalEntry::FileDescriptorSetTimesV1(rkyv::archived_root::<
-                    JournalEntryFileDescriptorSetTimesV1,
-                >(data))
+                ArchivedJournalEntry::FileDescriptorSetTimesV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::FileDescriptorSetSizeV1 => {
-                ArchivedJournalEntry::FileDescriptorSetSizeV1(rkyv::archived_root::<
-                    JournalEntryFileDescriptorSetSizeV1,
-                >(data))
+                ArchivedJournalEntry::FileDescriptorSetSizeV1(rkyv::access_unchecked(data))
+            }
+            JournalEntryRecordType::FileDescriptorSetFdFlagsV1 => {
+                ArchivedJournalEntry::FileDescriptorSetFdFlagsV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::FileDescriptorSetFlagsV1 => {
-                ArchivedJournalEntry::FileDescriptorSetFlagsV1(rkyv::archived_root::<
-                    JournalEntryFileDescriptorSetFlagsV1,
-                >(data))
+                ArchivedJournalEntry::FileDescriptorSetFlagsV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::FileDescriptorSetRightsV1 => {
-                ArchivedJournalEntry::FileDescriptorSetRightsV1(rkyv::archived_root::<
-                    JournalEntryFileDescriptorSetRightsV1,
-                >(data))
+                ArchivedJournalEntry::FileDescriptorSetRightsV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::FileDescriptorAdviseV1 => {
-                ArchivedJournalEntry::FileDescriptorAdviseV1(rkyv::archived_root::<
-                    JournalEntryFileDescriptorAdviseV1,
-                >(data))
+                ArchivedJournalEntry::FileDescriptorAdviseV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::FileDescriptorAllocateV1 => {
-                ArchivedJournalEntry::FileDescriptorAllocateV1(rkyv::archived_root::<
-                    JournalEntryFileDescriptorAllocateV1,
-                >(data))
+                ArchivedJournalEntry::FileDescriptorAllocateV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::CreateHardLinkV1 => {
-                ArchivedJournalEntry::CreateHardLinkV1(rkyv::archived_root::<
-                    JournalEntryCreateHardLinkV1,
-                >(data))
+                ArchivedJournalEntry::CreateHardLinkV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::CreateSymbolicLinkV1 => {
-                ArchivedJournalEntry::CreateSymbolicLinkV1(rkyv::archived_root::<
-                    JournalEntryCreateSymbolicLinkV1,
-                >(data))
+                ArchivedJournalEntry::CreateSymbolicLinkV1(rkyv::access_unchecked(data))
+            }
+            JournalEntryRecordType::UnlinkFileV1 => {
+                ArchivedJournalEntry::UnlinkFileV1(rkyv::access_unchecked(data))
+            }
+            JournalEntryRecordType::PathRenameV1 => {
+                ArchivedJournalEntry::PathRenameV1(rkyv::access_unchecked(data))
             }
-            JournalEntryRecordType::UnlinkFileV1 => ArchivedJournalEntry::UnlinkFileV1(
-                rkyv::archived_root::<JournalEntryUnlinkFileV1>(data),
-            ),
-            JournalEntryRecordType::PathRenameV1 => ArchivedJournalEntry::PathRenameV1(
-                rkyv::archived_root::<JournalEntryPathRenameV1>(data),
-            ),
             JournalEntryRecordType::ChangeDirectoryV1 => {
-                ArchivedJournalEntry::ChangeDirectoryV1(rkyv::archived_root::<
-                    JournalEntryChangeDirectoryV1,
-                >(data))
+                ArchivedJournalEntry::ChangeDirectoryV1(rkyv::access_unchecked(data))
+            }
+            JournalEntryRecordType::EpollCreateV1 => {
+                ArchivedJournalEntry::EpollCreateV1(rkyv::access_unchecked(data))
+            }
+            JournalEntryRecordType::EpollCtlV1 => {
+                ArchivedJournalEntry::EpollCtlV1(rkyv::access_unchecked(data))
             }
-            JournalEntryRecordType::EpollCreateV1 => ArchivedJournalEntry::EpollCreateV1(
-                rkyv::archived_root::<JournalEntryEpollCreateV1>(data),
-            ),
-            JournalEntryRecordType::EpollCtlV1 => ArchivedJournalEntry::EpollCtlV1(
-                rkyv::archived_root::<JournalEntryEpollCtlV1>(data),
-            ),
             JournalEntryRecordType::TtySetV1 => {
-                ArchivedJournalEntry::TtySetV1(rkyv::archived_root::<JournalEntryTtySetV1>(data))
+                ArchivedJournalEntry::TtySetV1(rkyv::access_unchecked(data))
+            }
+            JournalEntryRecordType::CreatePipeV1 => {
+                ArchivedJournalEntry::CreatePipeV1(rkyv::access_unchecked(data))
+            }
+            JournalEntryRecordType::CreateEventV1 => {
+                ArchivedJournalEntry::CreateEventV1(rkyv::access_unchecked(data))
+            }
+            JournalEntryRecordType::PortAddAddrV1 => {
+                ArchivedJournalEntry::PortAddAddrV1(rkyv::access_unchecked(data))
+            }
+            JournalEntryRecordType::PortDelAddrV1 => {
+                ArchivedJournalEntry::PortDelAddrV1(rkyv::access_unchecked(data))
             }
-            JournalEntryRecordType::CreatePipeV1 => ArchivedJournalEntry::CreatePipeV1(
-                rkyv::archived_root::<JournalEntryCreatePipeV1>(data),
-            ),
-            JournalEntryRecordType::CreateEventV1 => ArchivedJournalEntry::CreateEventV1(
-                rkyv::archived_root::<JournalEntryCreateEventV1>(data),
-            ),
-            JournalEntryRecordType::PortAddAddrV1 => ArchivedJournalEntry::PortAddAddrV1(
-                rkyv::archived_root::<JournalEntryPortAddAddrV1>(data),
-            ),
-            JournalEntryRecordType::PortDelAddrV1 => ArchivedJournalEntry::PortDelAddrV1(
-                rkyv::archived_root::<JournalEntryPortDelAddrV1>(data),
-            ),
             JournalEntryRecordType::PortAddrClearV1 => return Ok(JournalEntry::PortAddrClearV1),
-            JournalEntryRecordType::PortBridgeV1 => ArchivedJournalEntry::PortBridgeV1(
-                rkyv::archived_root::<JournalEntryPortBridgeV1>(data),
-            ),
+            JournalEntryRecordType::PortBridgeV1 => {
+                ArchivedJournalEntry::PortBridgeV1(rkyv::access_unchecked(data))
+            }
             JournalEntryRecordType::PortUnbridgeV1 => return Ok(JournalEntry::PortUnbridgeV1),
             JournalEntryRecordType::PortDhcpAcquireV1 => {
                 return Ok(JournalEntry::PortDhcpAcquireV1)
             }
             JournalEntryRecordType::PortGatewaySetV1 => {
-                ArchivedJournalEntry::PortGatewaySetV1(rkyv::archived_root::<
-                    JournalEntryPortGatewaySetV1,
-                >(data))
+                ArchivedJournalEntry::PortGatewaySetV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::PortRouteAddV1 => {
-                ArchivedJournalEntry::PortRouteAddV1(rkyv::archived_root::<
-                    JournalEntryPortRouteAddV1,
-                >(data))
+                ArchivedJournalEntry::PortRouteAddV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::PortRouteClearV1 => return Ok(JournalEntry::PortRouteClearV1),
             JournalEntryRecordType::PortRouteDelV1 => {
-                ArchivedJournalEntry::PortRouteDelV1(rkyv::archived_root::<
-                    JournalEntryPortRouteDelV1,
-                >(data))
+                ArchivedJournalEntry::PortRouteDelV1(rkyv::access_unchecked(data))
+            }
+            JournalEntryRecordType::SocketOpenV1 => {
+                ArchivedJournalEntry::SocketOpenV1(rkyv::access_unchecked(data))
+            }
+            JournalEntryRecordType::SocketPairV1 => {
+                ArchivedJournalEntry::SocketPairV1(rkyv::access_unchecked(data))
             }
-            JournalEntryRecordType::SocketOpenV1 => ArchivedJournalEntry::SocketOpenV1(
-                rkyv::archived_root::<JournalEntrySocketOpenV1>(data),
-            ),
             JournalEntryRecordType::SocketListenV1 => {
-                ArchivedJournalEntry::SocketListenV1(rkyv::archived_root::<
-                    JournalEntrySocketListenV1,
-                >(data))
+                ArchivedJournalEntry::SocketListenV1(rkyv::access_unchecked(data))
+            }
+            JournalEntryRecordType::SocketBindV1 => {
+                ArchivedJournalEntry::SocketBindV1(rkyv::access_unchecked(data))
             }
-            JournalEntryRecordType::SocketBindV1 => ArchivedJournalEntry::SocketBindV1(
-                rkyv::archived_root::<JournalEntrySocketBindV1>(data),
-            ),
             JournalEntryRecordType::SocketConnectedV1 => {
-                ArchivedJournalEntry::SocketConnectedV1(rkyv::archived_root::<
-                    JournalEntrySocketConnectedV1,
-                >(data))
+                ArchivedJournalEntry::SocketConnectedV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::SocketAcceptedV1 => {
-                ArchivedJournalEntry::SocketAcceptedV1(rkyv::archived_root::<
-                    JournalEntrySocketAcceptedV1,
-                >(data))
+                ArchivedJournalEntry::SocketAcceptedV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::SocketJoinIpv4MulticastV1 => {
-                ArchivedJournalEntry::SocketJoinIpv4MulticastV1(rkyv::archived_root::<
-                    JournalEntrySocketJoinIpv4MulticastV1,
-                >(data))
+                ArchivedJournalEntry::SocketJoinIpv4MulticastV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::SocketJoinIpv6MulticastV1 => {
-                ArchivedJournalEntry::SocketJoinIpv6MulticastV1(rkyv::archived_root::<
-                    JournalEntrySocketJoinIpv6MulticastV1,
-                >(data))
+                ArchivedJournalEntry::SocketJoinIpv6MulticastV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::SocketLeaveIpv4MulticastV1 => {
-                ArchivedJournalEntry::SocketLeaveIpv4MulticastV1(rkyv::archived_root::<
-                    JournalEntrySocketLeaveIpv4MulticastV1,
-                >(data))
+                ArchivedJournalEntry::SocketLeaveIpv4MulticastV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::SocketLeaveIpv6MulticastV1 => {
-                ArchivedJournalEntry::SocketLeaveIpv6MulticastV1(rkyv::archived_root::<
-                    JournalEntrySocketLeaveIpv6MulticastV1,
-                >(data))
+                ArchivedJournalEntry::SocketLeaveIpv6MulticastV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::SocketSendFileV1 => {
-                ArchivedJournalEntry::SocketSendFileV1(rkyv::archived_root::<
-                    JournalEntrySocketSendFileV1,
-                >(data))
+                ArchivedJournalEntry::SocketSendFileV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::SocketSendToV1 => {
-                ArchivedJournalEntry::SocketSendToV1(rkyv::archived_root::<
-                    JournalEntrySocketSendToV1,
-                >(data))
+                ArchivedJournalEntry::SocketSendToV1(rkyv::access_unchecked(data))
+            }
+            JournalEntryRecordType::SocketSendV1 => {
+                ArchivedJournalEntry::SocketSendV1(rkyv::access_unchecked(data))
             }
-            JournalEntryRecordType::SocketSendV1 => ArchivedJournalEntry::SocketSendV1(
-                rkyv::archived_root::<JournalEntrySocketSendV1>(data),
-            ),
             JournalEntryRecordType::SocketSetOptFlagV1 => {
-                ArchivedJournalEntry::SocketSetOptFlagV1(rkyv::archived_root::<
-                    JournalEntrySocketSetOptFlagV1,
-                >(data))
+                ArchivedJournalEntry::SocketSetOptFlagV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::SocketSetOptSizeV1 => {
-                ArchivedJournalEntry::SocketSetOptSizeV1(rkyv::archived_root::<
-                    JournalEntrySocketSetOptSizeV1,
-                >(data))
+                ArchivedJournalEntry::SocketSetOptSizeV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::SocketSetOptTimeV1 => {
-                ArchivedJournalEntry::SocketSetOptTimeV1(rkyv::archived_root::<
-                    JournalEntrySocketSetOptTimeV1,
-                >(data))
+                ArchivedJournalEntry::SocketSetOptTimeV1(rkyv::access_unchecked(data))
             }
             JournalEntryRecordType::SocketShutdownV1 => {
-                ArchivedJournalEntry::SocketShutdownV1(rkyv::archived_root::<
-                    JournalEntrySocketShutdownV1,
-                >(data))
+                ArchivedJournalEntry::SocketShutdownV1(rkyv::access_unchecked(data))
+            }
+            JournalEntryRecordType::SnapshotV1 => {
+                ArchivedJournalEntry::SnapshotV1(rkyv::access_unchecked(data))
             }
-            JournalEntryRecordType::SnapshotV1 => ArchivedJournalEntry::SnapshotV1(
-                rkyv::archived_root::<JournalEntrySnapshotV1>(data),
-            ),
         }
         .try_into()
     }
 }
 
-impl<'a> JournalEntry<'a> {
+impl JournalEntry<'_> {
     pub fn archive_record_type(&self) -> JournalEntryRecordType {
         match self {
             Self::InitModuleV1 { .. } => JournalEntryRecordType::InitModuleV1,
@@ -357,18 +302,25 @@ impl<'a> JournalEntry<'a> {
             Self::SetClockTimeV1 { .. } => JournalEntryRecordType::SetClockTimeV1,
             Self::CloseFileDescriptorV1 { .. } => JournalEntryRecordType::CloseFileDescriptorV1,
             Self::OpenFileDescriptorV1 { .. } => JournalEntryRecordType::OpenFileDescriptorV1,
+            Self::OpenFileDescriptorV2 { .. } => JournalEntryRecordType::OpenFileDescriptorV2,
             Self::RenumberFileDescriptorV1 { .. } => {
                 JournalEntryRecordType::RenumberFileDescriptorV1
             }
             Self::DuplicateFileDescriptorV1 { .. } => {
                 JournalEntryRecordType::DuplicateFileDescriptorV1
             }
+            Self::DuplicateFileDescriptorV2 { .. } => {
+                JournalEntryRecordType::DuplicateFileDescriptorV2
+            }
             Self::CreateDirectoryV1 { .. } => JournalEntryRecordType::CreateDirectoryV1,
             Self::RemoveDirectoryV1 { .. } => JournalEntryRecordType::RemoveDirectoryV1,
             Self::PathSetTimesV1 { .. } => JournalEntryRecordType::PathSetTimesV1,
             Self::FileDescriptorSetTimesV1 { .. } => {
                 JournalEntryRecordType::FileDescriptorSetTimesV1
             }
+            Self::FileDescriptorSetFdFlagsV1 { .. } => {
+                JournalEntryRecordType::FileDescriptorSetFdFlagsV1
+            }
             Self::FileDescriptorSetFlagsV1 { .. } => {
                 JournalEntryRecordType::FileDescriptorSetFlagsV1
             }
@@ -401,6 +353,7 @@ impl<'a> JournalEntry<'a> {
             Self::PortRouteClearV1 => JournalEntryRecordType::PortRouteClearV1,
             Self::PortRouteDelV1 { .. } => JournalEntryRecordType::PortRouteDelV1,
             Self::SocketOpenV1 { .. } => JournalEntryRecordType::SocketOpenV1,
+            Self::SocketPairV1 { .. } => JournalEntryRecordType::SocketPairV1,
             Self::SocketListenV1 { .. } => JournalEntryRecordType::SocketListenV1,
             Self::SocketBindV1 { .. } => JournalEntryRecordType::SocketBindV1,
             Self::SocketConnectedV1 { .. } => JournalEntryRecordType::SocketConnectedV1,
@@ -428,33 +381,37 @@ impl<'a> JournalEntry<'a> {
         }
     }
 
-    pub fn serialize_archive<T: Serializer + ScratchSpace>(
+    pub fn serialize_archive<T: Fallible + Writer + Allocator>(
         self,
         serializer: &mut T,
     ) -> anyhow::Result<usize>
     where
-        T::Error: std::fmt::Display,
+        T::Error: rkyv::rancor::Source,
     {
         let amt = match self {
             JournalEntry::InitModuleV1 { wasm_hash } => {
-                serializer.serialize_value(&JournalEntryInitModuleV1 { wasm_hash })
+                serialize_using(&JournalEntryInitModuleV1 { wasm_hash }, serializer)
             }
             JournalEntry::ClearEtherealV1 => {
-                serializer.serialize_value(&JournalEntryClearEtherealV1 {})
+                serialize_using(&JournalEntryClearEtherealV1 {}, serializer)
             }
             JournalEntry::UpdateMemoryRegionV1 {
                 region,
                 compressed_data,
-            } => serializer.serialize_value(&JournalEntryUpdateMemoryRegionV1 {
-                start: region.start,
-                end: region.end,
-                compressed_data: compressed_data.into(),
-            }),
-            JournalEntry::ProcessExitV1 { exit_code } => {
-                serializer.serialize_value(&JournalEntryProcessExitV1 {
+            } => serialize_using(
+                &JournalEntryUpdateMemoryRegionV1 {
+                    start: region.start,
+                    end: region.end,
+                    compressed_data: compressed_data.into(),
+                },
+                serializer,
+            ),
+            JournalEntry::ProcessExitV1 { exit_code } => serialize_using(
+                &JournalEntryProcessExitV1 {
                     exit_code: exit_code.map(|e| e.into()),
-                })
-            }
+                },
+                serializer,
+            ),
             JournalEntry::SetThreadV1 {
                 id,
                 call_stack,
@@ -463,46 +420,56 @@ impl<'a> JournalEntry<'a> {
                 is_64bit,
                 start,
                 layout,
-            } => serializer.serialize_value(&JournalEntrySetThreadV1 {
-                id,
-                call_stack: call_stack.into(),
-                memory_stack: memory_stack.into(),
-                store_data: store_data.into(),
-                start: start.into(),
-                layout: layout.into(),
-                is_64bit,
-            }),
-            JournalEntry::CloseThreadV1 { id, exit_code } => {
-                serializer.serialize_value(&JournalEntryCloseThreadV1 {
+            } => serialize_using(
+                &JournalEntrySetThreadV1 {
+                    id,
+                    call_stack: call_stack.into(),
+                    memory_stack: memory_stack.into(),
+                    store_data: store_data.into(),
+                    start: start.into(),
+                    layout: layout.into(),
+                    is_64bit,
+                },
+                serializer,
+            ),
+            JournalEntry::CloseThreadV1 { id, exit_code } => serialize_using(
+                &JournalEntryCloseThreadV1 {
                     id,
                     exit_code: exit_code.map(|e| e.into()),
-                })
-            }
-            JournalEntry::FileDescriptorSeekV1 { fd, offset, whence } => serializer
-                .serialize_value(&JournalEntryFileDescriptorSeekV1 {
+                },
+                serializer,
+            ),
+            JournalEntry::FileDescriptorSeekV1 { fd, offset, whence } => serialize_using(
+                &JournalEntryFileDescriptorSeekV1 {
                     fd,
                     offset,
                     whence: whence.into(),
-                }),
+                },
+                serializer,
+            ),
             JournalEntry::FileDescriptorWriteV1 {
                 fd,
                 offset,
                 data,
                 is_64bit,
-            } => serializer.serialize_value(&JournalEntryFileDescriptorWriteV1 {
-                fd,
-                offset,
-                data: data.into(),
-                is_64bit,
-            }),
-            JournalEntry::SetClockTimeV1 { clock_id, time } => {
-                serializer.serialize_value(&JournalEntrySetClockTimeV1 {
+            } => serialize_using(
+                &JournalEntryFileDescriptorWriteV1 {
+                    fd,
+                    offset,
+                    data: data.into(),
+                    is_64bit,
+                },
+                serializer,
+            ),
+            JournalEntry::SetClockTimeV1 { clock_id, time } => serialize_using(
+                &JournalEntrySetClockTimeV1 {
                     clock_id: clock_id.into(),
                     time,
-                })
-            }
+                },
+                serializer,
+            ),
             JournalEntry::CloseFileDescriptorV1 { fd } => {
-                serializer.serialize_value(&JournalEntryCloseFileDescriptorV1 { fd })
+                serialize_using(&JournalEntryCloseFileDescriptorV1 { fd }, serializer)
             }
             JournalEntry::OpenFileDescriptorV1 {
                 fd,
@@ -513,38 +480,83 @@ impl<'a> JournalEntry<'a> {
                 fs_rights_base,
                 fs_rights_inheriting,
                 fs_flags,
-            } => serializer.serialize_value(&JournalEntryOpenFileDescriptorV1 {
+            } => serialize_using(
+                &JournalEntryOpenFileDescriptorV1 {
+                    fd,
+                    dirfd,
+                    dirflags,
+                    path: path.into(),
+                    o_flags: o_flags.bits(),
+                    fs_rights_base: fs_rights_base.bits(),
+                    fs_rights_inheriting: fs_rights_inheriting.bits(),
+                    fs_flags: fs_flags.bits(),
+                },
+                serializer,
+            ),
+            JournalEntry::OpenFileDescriptorV2 {
                 fd,
                 dirfd,
                 dirflags,
-                path: path.into(),
-                o_flags: o_flags.bits(),
-                fs_rights_base: fs_rights_base.bits(),
-                fs_rights_inheriting: fs_rights_inheriting.bits(),
-                fs_flags: fs_flags.bits(),
-            }),
-            JournalEntry::RenumberFileDescriptorV1 { old_fd, new_fd } => {
-                serializer.serialize_value(&JournalEntryRenumberFileDescriptorV1 { old_fd, new_fd })
-            }
+                path,
+                o_flags,
+                fs_rights_base,
+                fs_rights_inheriting,
+                fs_flags,
+                fd_flags,
+            } => serialize_using(
+                &JournalEntryOpenFileDescriptorV2 {
+                    fd,
+                    dirfd,
+                    dirflags,
+                    path: path.into(),
+                    o_flags: o_flags.bits(),
+                    fs_rights_base: fs_rights_base.bits(),
+                    fs_rights_inheriting: fs_rights_inheriting.bits(),
+                    fs_flags: fs_flags.bits(),
+                    fd_flags: fd_flags.bits(),
+                },
+                serializer,
+            ),
+            JournalEntry::RenumberFileDescriptorV1 { old_fd, new_fd } => serialize_using(
+                &JournalEntryRenumberFileDescriptorV1 { old_fd, new_fd },
+                serializer,
+            ),
             JournalEntry::DuplicateFileDescriptorV1 {
                 original_fd,
                 copied_fd,
-            } => serializer.serialize_value(&JournalEntryDuplicateFileDescriptorV1 {
+            } => serialize_using(
+                &JournalEntryDuplicateFileDescriptorV1 {
+                    original_fd,
+                    copied_fd,
+                },
+                serializer,
+            ),
+            JournalEntry::DuplicateFileDescriptorV2 {
                 original_fd,
                 copied_fd,
-            }),
-            JournalEntry::CreateDirectoryV1 { fd, path } => {
-                serializer.serialize_value(&JournalEntryCreateDirectoryV1 {
+                cloexec,
+            } => serialize_using(
+                &JournalEntryDuplicateFileDescriptorV2 {
+                    original_fd,
+                    copied_fd,
+                    cloexec,
+                },
+                serializer,
+            ),
+            JournalEntry::CreateDirectoryV1 { fd, path } => serialize_using(
+                &JournalEntryCreateDirectoryV1 {
                     fd,
                     path: path.into(),
-                })
-            }
-            JournalEntry::RemoveDirectoryV1 { fd, path } => {
-                serializer.serialize_value(&JournalEntryRemoveDirectoryV1 {
+                },
+                serializer,
+            ),
+            JournalEntry::RemoveDirectoryV1 { fd, path } => serialize_using(
+                &JournalEntryRemoveDirectoryV1 {
                     fd,
                     path: path.into(),
-                })
-            }
+                },
+                serializer,
+            ),
             JournalEntry::PathSetTimesV1 {
                 fd,
                 flags,
@@ -552,114 +564,151 @@ impl<'a> JournalEntry<'a> {
                 st_atim,
                 st_mtim,
                 fst_flags,
-            } => serializer.serialize_value(&JournalEntryPathSetTimesV1 {
-                fd,
-                flags,
-                path: path.into(),
-                st_atim,
-                st_mtim,
-                fst_flags: fst_flags.bits(),
-            }),
+            } => serialize_using(
+                &JournalEntryPathSetTimesV1 {
+                    fd,
+                    flags,
+                    path: path.into(),
+                    st_atim,
+                    st_mtim,
+                    fst_flags: fst_flags.bits(),
+                },
+                serializer,
+            ),
             JournalEntry::FileDescriptorSetTimesV1 {
                 fd,
                 st_atim,
                 st_mtim,
                 fst_flags,
-            } => serializer.serialize_value(&JournalEntryFileDescriptorSetTimesV1 {
-                fd,
-                st_atim,
-                st_mtim,
-                fst_flags: fst_flags.bits(),
-            }),
-            JournalEntry::FileDescriptorSetFlagsV1 { fd, flags } => {
-                serializer.serialize_value(&JournalEntryFileDescriptorSetFlagsV1 {
+            } => serialize_using(
+                &JournalEntryFileDescriptorSetTimesV1 {
+                    fd,
+                    st_atim,
+                    st_mtim,
+                    fst_flags: fst_flags.bits(),
+                },
+                serializer,
+            ),
+            JournalEntry::FileDescriptorSetFdFlagsV1 { fd, flags } => serialize_using(
+                &JournalEntryFileDescriptorSetFdFlagsV1 {
                     fd,
                     flags: flags.bits(),
-                })
-            }
+                },
+                serializer,
+            ),
+            JournalEntry::FileDescriptorSetFlagsV1 { fd, flags } => serialize_using(
+                &JournalEntryFileDescriptorSetFlagsV1 {
+                    fd,
+                    flags: flags.bits(),
+                },
+                serializer,
+            ),
             JournalEntry::FileDescriptorSetRightsV1 {
                 fd,
                 fs_rights_base,
                 fs_rights_inheriting,
-            } => serializer.serialize_value(&JournalEntryFileDescriptorSetRightsV1 {
-                fd,
-                fs_rights_base: fs_rights_base.bits(),
-                fs_rights_inheriting: fs_rights_inheriting.bits(),
-            }),
-            JournalEntry::FileDescriptorSetSizeV1 { fd, st_size } => {
-                serializer.serialize_value(&JournalEntryFileDescriptorSetSizeV1 { fd, st_size })
-            }
+            } => serialize_using(
+                &JournalEntryFileDescriptorSetRightsV1 {
+                    fd,
+                    fs_rights_base: fs_rights_base.bits(),
+                    fs_rights_inheriting: fs_rights_inheriting.bits(),
+                },
+                serializer,
+            ),
+            JournalEntry::FileDescriptorSetSizeV1 { fd, st_size } => serialize_using(
+                &JournalEntryFileDescriptorSetSizeV1 { fd, st_size },
+                serializer,
+            ),
             JournalEntry::FileDescriptorAdviseV1 {
                 fd,
                 offset,
                 len,
                 advice,
-            } => serializer.serialize_value(&JournalEntryFileDescriptorAdviseV1 {
-                fd,
-                offset,
-                len,
-                advice: advice.into(),
-            }),
-            JournalEntry::FileDescriptorAllocateV1 { fd, offset, len } => serializer
-                .serialize_value(&JournalEntryFileDescriptorAllocateV1 { fd, offset, len }),
+            } => serialize_using(
+                &JournalEntryFileDescriptorAdviseV1 {
+                    fd,
+                    offset,
+                    len,
+                    advice: advice.into(),
+                },
+                serializer,
+            ),
+            JournalEntry::FileDescriptorAllocateV1 { fd, offset, len } => serialize_using(
+                &JournalEntryFileDescriptorAllocateV1 { fd, offset, len },
+                serializer,
+            ),
             JournalEntry::CreateHardLinkV1 {
                 old_fd,
                 old_path,
                 old_flags,
                 new_fd,
                 new_path,
-            } => serializer.serialize_value(&JournalEntryCreateHardLinkV1 {
-                old_fd,
-                old_path: old_path.into(),
-                old_flags,
-                new_fd,
-                new_path: new_path.into(),
-            }),
+            } => serialize_using(
+                &JournalEntryCreateHardLinkV1 {
+                    old_fd,
+                    old_path: old_path.into(),
+                    old_flags,
+                    new_fd,
+                    new_path: new_path.into(),
+                },
+                serializer,
+            ),
             JournalEntry::CreateSymbolicLinkV1 {
                 old_path,
                 fd,
                 new_path,
-            } => serializer.serialize_value(&JournalEntryCreateSymbolicLinkV1 {
-                old_path: old_path.into(),
-                fd,
-                new_path: new_path.into(),
-            }),
-            JournalEntry::UnlinkFileV1 { fd, path } => {
-                serializer.serialize_value(&JournalEntryUnlinkFileV1 {
+            } => serialize_using(
+                &JournalEntryCreateSymbolicLinkV1 {
+                    old_path: old_path.into(),
+                    fd,
+                    new_path: new_path.into(),
+                },
+                serializer,
+            ),
+            JournalEntry::UnlinkFileV1 { fd, path } => serialize_using(
+                &JournalEntryUnlinkFileV1 {
                     fd,
                     path: path.into(),
-                })
-            }
+                },
+                serializer,
+            ),
             JournalEntry::PathRenameV1 {
                 old_fd,
                 old_path,
                 new_fd,
                 new_path,
-            } => serializer.serialize_value(&JournalEntryPathRenameV1 {
-                old_fd,
-                old_path: old_path.into(),
-                new_fd,
-                new_path: new_path.into(),
-            }),
-            JournalEntry::ChangeDirectoryV1 { path } => {
-                serializer.serialize_value(&JournalEntryChangeDirectoryV1 { path: path.into() })
-            }
+            } => serialize_using(
+                &JournalEntryPathRenameV1 {
+                    old_fd,
+                    old_path: old_path.into(),
+                    new_fd,
+                    new_path: new_path.into(),
+                },
+                serializer,
+            ),
+            JournalEntry::ChangeDirectoryV1 { path } => serialize_using(
+                &JournalEntryChangeDirectoryV1 { path: path.into() },
+                serializer,
+            ),
             JournalEntry::EpollCreateV1 { fd } => {
-                serializer.serialize_value(&JournalEntryEpollCreateV1 { fd })
+                serialize_using(&JournalEntryEpollCreateV1 { fd }, serializer)
             }
             JournalEntry::EpollCtlV1 {
                 epfd,
                 op,
                 fd,
                 event,
-            } => serializer.serialize_value(&JournalEntryEpollCtlV1 {
-                epfd,
-                op: op.into(),
-                fd,
-                event: event.map(|e| e.into()),
-            }),
-            JournalEntry::TtySetV1 { tty, line_feeds } => {
-                serializer.serialize_value(&JournalEntryTtySetV1 {
+            } => serialize_using(
+                &JournalEntryEpollCtlV1 {
+                    epfd,
+                    op: op.into(),
+                    fd,
+                    event: event.map(|e| e.into()),
+                },
+                serializer,
+            ),
+            JournalEntry::TtySetV1 { tty, line_feeds } => serialize_using(
+                &JournalEntryTtySetV1 {
                     cols: tty.cols,
                     rows: tty.rows,
                     width: tty.width,
@@ -670,79 +719,96 @@ impl<'a> JournalEntry<'a> {
                     echo: tty.echo,
                     line_buffered: tty.line_buffered,
                     line_feeds,
-                })
-            }
-            JournalEntry::CreatePipeV1 { fd1, fd2 } => {
-                serializer.serialize_value(&JournalEntryCreatePipeV1 { fd1, fd2 })
+                },
+                serializer,
+            ),
+            JournalEntry::CreatePipeV1 { read_fd, write_fd } => {
+                serialize_using(&JournalEntryCreatePipeV1 { read_fd, write_fd }, serializer)
             }
             JournalEntry::CreateEventV1 {
                 initial_val,
                 flags,
                 fd,
-            } => serializer.serialize_value(&JournalEntryCreateEventV1 {
-                initial_val,
-                flags,
-                fd,
-            }),
+            } => serialize_using(
+                &JournalEntryCreateEventV1 {
+                    initial_val,
+                    flags,
+                    fd,
+                },
+                serializer,
+            ),
             JournalEntry::PortAddAddrV1 { cidr } => {
-                serializer.serialize_value(&JournalEntryPortAddAddrV1 { cidr: cidr.into() })
+                serialize_using(&JournalEntryPortAddAddrV1 { cidr: cidr.into() }, serializer)
             }
             JournalEntry::PortDelAddrV1 { addr } => {
-                serializer.serialize_value(&JournalEntryPortDelAddrV1 { addr })
+                serialize_using(&JournalEntryPortDelAddrV1 { addr }, serializer)
             }
-            JournalEntry::PortAddrClearV1 => serializer.serialize_value(&()),
+            JournalEntry::PortAddrClearV1 => serialize_using(&(), serializer),
             JournalEntry::PortBridgeV1 {
                 network,
                 token,
                 security,
-            } => serializer.serialize_value(&JournalEntryPortBridgeV1 {
-                network: network.into(),
-                token: token.into(),
-                security: security.into(),
-            }),
-            JournalEntry::PortUnbridgeV1 => serializer.serialize_value(&()),
-            JournalEntry::PortDhcpAcquireV1 => serializer.serialize_value(&()),
+            } => serialize_using(
+                &JournalEntryPortBridgeV1 {
+                    network: network.into(),
+                    token: token.into(),
+                    security: security.into(),
+                },
+                serializer,
+            ),
+            JournalEntry::PortUnbridgeV1 => serialize_using(&(), serializer),
+            JournalEntry::PortDhcpAcquireV1 => serialize_using(&(), serializer),
             JournalEntry::PortGatewaySetV1 { ip } => {
-                serializer.serialize_value(&JournalEntryPortGatewaySetV1 { ip })
+                serialize_using(&JournalEntryPortGatewaySetV1 { ip }, serializer)
             }
             JournalEntry::PortRouteAddV1 {
                 cidr,
                 via_router,
                 preferred_until,
                 expires_at,
-            } => serializer.serialize_value(&JournalEntryPortRouteAddV1 {
-                cidr: cidr.into(),
-                via_router,
-                preferred_until,
-                expires_at,
-            }),
-            JournalEntry::PortRouteClearV1 => serializer.serialize_value(&()),
+            } => serialize_using(
+                &JournalEntryPortRouteAddV1 {
+                    cidr: cidr.into(),
+                    via_router,
+                    preferred_until,
+                    expires_at,
+                },
+                serializer,
+            ),
+            JournalEntry::PortRouteClearV1 => serialize_using(&(), serializer),
             JournalEntry::PortRouteDelV1 { ip } => {
-                serializer.serialize_value(&JournalEntryPortRouteDelV1 { ip })
+                serialize_using(&JournalEntryPortRouteDelV1 { ip }, serializer)
             }
-            JournalEntry::SocketOpenV1 { af, ty, pt, fd } => {
-                serializer.serialize_value(&JournalEntrySocketOpenV1 {
+            JournalEntry::SocketOpenV1 { af, ty, pt, fd } => serialize_using(
+                &JournalEntrySocketOpenV1 {
                     af: af.into(),
                     ty: ty.into(),
                     pt: pt.into(),
                     fd,
-                })
+                },
+                serializer,
+            ),
+            JournalEntry::SocketPairV1 { fd1, fd2 } => {
+                serialize_using(&JournalEntrySocketPairV1 { fd1, fd2 }, serializer)
             }
             JournalEntry::SocketListenV1 { fd, backlog } => {
-                serializer.serialize_value(&JournalEntrySocketListenV1 { fd, backlog })
+                serialize_using(&JournalEntrySocketListenV1 { fd, backlog }, serializer)
             }
             JournalEntry::SocketBindV1 { fd, addr } => {
-                serializer.serialize_value(&JournalEntrySocketBindV1 { fd, addr })
+                serialize_using(&JournalEntrySocketBindV1 { fd, addr }, serializer)
             }
             JournalEntry::SocketConnectedV1 {
                 fd,
                 local_addr,
                 peer_addr,
-            } => serializer.serialize_value(&JournalEntrySocketConnectedV1 {
-                fd,
-                local_addr,
-                peer_addr,
-            }),
+            } => serialize_using(
+                &JournalEntrySocketConnectedV1 {
+                    fd,
+                    local_addr,
+                    peer_addr,
+                },
+                serializer,
+            ),
             JournalEntry::SocketAcceptedV1 {
                 listen_fd,
                 fd,
@@ -750,120 +816,149 @@ impl<'a> JournalEntry<'a> {
                 peer_addr,
                 fd_flags,
                 non_blocking: nonblocking,
-            } => serializer.serialize_value(&JournalEntrySocketAcceptedV1 {
-                listen_fd,
-                fd,
-                local_addr: addr,
-                peer_addr,
-                fd_flags: fd_flags.bits(),
-                nonblocking,
-            }),
+            } => serialize_using(
+                &JournalEntrySocketAcceptedV1 {
+                    listen_fd,
+                    fd,
+                    local_addr: addr,
+                    peer_addr,
+                    fd_flags: fd_flags.bits(),
+                    nonblocking,
+                },
+                serializer,
+            ),
             JournalEntry::SocketJoinIpv4MulticastV1 {
                 fd,
                 multiaddr,
                 iface,
-            } => serializer.serialize_value(&JournalEntrySocketJoinIpv4MulticastV1 {
-                fd,
-                multiaddr,
-                iface,
-            }),
+            } => serialize_using(
+                &JournalEntrySocketJoinIpv4MulticastV1 {
+                    fd,
+                    multiaddr,
+                    iface,
+                },
+                serializer,
+            ),
             JournalEntry::SocketJoinIpv6MulticastV1 {
                 fd,
                 multi_addr: multiaddr,
                 iface,
-            } => serializer.serialize_value(&JournalEntrySocketJoinIpv6MulticastV1 {
-                fd,
-                multiaddr,
-                iface,
-            }),
+            } => serialize_using(
+                &JournalEntrySocketJoinIpv6MulticastV1 {
+                    fd,
+                    multiaddr,
+                    iface,
+                },
+                serializer,
+            ),
             JournalEntry::SocketLeaveIpv4MulticastV1 {
                 fd,
                 multi_addr: multiaddr,
                 iface,
-            } => serializer.serialize_value(&JournalEntrySocketLeaveIpv4MulticastV1 {
-                fd,
-                multiaddr,
-                iface,
-            }),
+            } => serialize_using(
+                &JournalEntrySocketLeaveIpv4MulticastV1 {
+                    fd,
+                    multiaddr,
+                    iface,
+                },
+                serializer,
+            ),
             JournalEntry::SocketLeaveIpv6MulticastV1 {
                 fd,
                 multi_addr: multiaddr,
                 iface,
-            } => serializer.serialize_value(&JournalEntrySocketLeaveIpv6MulticastV1 {
-                fd,
-                multiaddr,
-                iface,
-            }),
+            } => serialize_using(
+                &JournalEntrySocketLeaveIpv6MulticastV1 {
+                    fd,
+                    multiaddr,
+                    iface,
+                },
+                serializer,
+            ),
             JournalEntry::SocketSendFileV1 {
                 socket_fd,
                 file_fd,
                 offset,
                 count,
-            } => serializer.serialize_value(&JournalEntrySocketSendFileV1 {
-                socket_fd,
-                file_fd,
-                offset,
-                count,
-            }),
+            } => serialize_using(
+                &JournalEntrySocketSendFileV1 {
+                    socket_fd,
+                    file_fd,
+                    offset,
+                    count,
+                },
+                serializer,
+            ),
             JournalEntry::SocketSendToV1 {
                 fd,
                 data,
                 flags,
                 addr,
                 is_64bit,
-            } => serializer.serialize_value(&JournalEntrySocketSendToV1 {
-                fd,
-                data: data.into(),
-                flags,
-                addr,
-                is_64bit,
-            }),
+            } => serialize_using(
+                &JournalEntrySocketSendToV1 {
+                    fd,
+                    data: data.into(),
+                    flags,
+                    addr,
+                    is_64bit,
+                },
+                serializer,
+            ),
             JournalEntry::SocketSendV1 {
                 fd,
                 data,
                 flags,
                 is_64bit,
-            } => serializer.serialize_value(&JournalEntrySocketSendV1 {
-                fd,
-                data: data.into(),
-                flags,
-                is_64bit,
-            }),
-            JournalEntry::SocketSetOptFlagV1 { fd, opt, flag } => {
-                serializer.serialize_value(&JournalEntrySocketSetOptFlagV1 {
+            } => serialize_using(
+                &JournalEntrySocketSendV1 {
+                    fd,
+                    data: data.into(),
+                    flags,
+                    is_64bit,
+                },
+                serializer,
+            ),
+            JournalEntry::SocketSetOptFlagV1 { fd, opt, flag } => serialize_using(
+                &JournalEntrySocketSetOptFlagV1 {
                     fd,
                     opt: opt.into(),
                     flag,
-                })
-            }
-            JournalEntry::SocketSetOptSizeV1 { fd, opt, size } => {
-                serializer.serialize_value(&JournalEntrySocketSetOptSizeV1 {
+                },
+                serializer,
+            ),
+            JournalEntry::SocketSetOptSizeV1 { fd, opt, size } => serialize_using(
+                &JournalEntrySocketSetOptSizeV1 {
                     fd,
                     opt: opt.into(),
                     size,
-                })
-            }
-            JournalEntry::SocketSetOptTimeV1 { fd, ty, time } => {
-                serializer.serialize_value(&JournalEntrySocketSetOptTimeV1 {
+                },
+                serializer,
+            ),
+            JournalEntry::SocketSetOptTimeV1 { fd, ty, time } => serialize_using(
+                &JournalEntrySocketSetOptTimeV1 {
                     fd,
                     ty: ty.into(),
                     time,
-                })
-            }
-            JournalEntry::SocketShutdownV1 { fd, how } => {
-                serializer.serialize_value(&JournalEntrySocketShutdownV1 {
+                },
+                serializer,
+            ),
+            JournalEntry::SocketShutdownV1 { fd, how } => serialize_using(
+                &JournalEntrySocketShutdownV1 {
                     fd,
                     how: how.into(),
-                })
-            }
-            JournalEntry::SnapshotV1 { when, trigger } => {
-                serializer.serialize_value(&JournalEntrySnapshotV1 {
+                },
+                serializer,
+            ),
+            JournalEntry::SnapshotV1 { when, trigger } => serialize_using(
+                &JournalEntrySnapshotV1 {
                     since_epoch: when
                         .duration_since(SystemTime::UNIX_EPOCH)
                         .unwrap_or(Duration::ZERO),
                     trigger: trigger.into(),
-                })
-            }
+                },
+                serializer,
+            ),
         }
         .map_err(|err| anyhow::format_err!("failed to serialize journal record - {}", err))?;
         Ok(amt)
@@ -877,7 +972,7 @@ impl<'a> JournalEntry<'a> {
 /// changes to the journal entry types without having to
 /// worry about backward and forward compatibility
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub(crate) struct JournalEntryHeader {
     pub record_type: u16,
     pub record_size: u64,
@@ -894,14 +989,17 @@ pub enum ArchivedJournalEntry<'a> {
     UpdateMemoryRegionV1(&'a ArchivedJournalEntryUpdateMemoryRegionV1<'a>),
     SetClockTimeV1(&'a ArchivedJournalEntrySetClockTimeV1),
     OpenFileDescriptorV1(&'a ArchivedJournalEntryOpenFileDescriptorV1<'a>),
+    OpenFileDescriptorV2(&'a ArchivedJournalEntryOpenFileDescriptorV2<'a>),
     CloseFileDescriptorV1(&'a ArchivedJournalEntryCloseFileDescriptorV1),
     RenumberFileDescriptorV1(&'a ArchivedJournalEntryRenumberFileDescriptorV1),
     DuplicateFileDescriptorV1(&'a ArchivedJournalEntryDuplicateFileDescriptorV1),
+    DuplicateFileDescriptorV2(&'a ArchivedJournalEntryDuplicateFileDescriptorV2),
     CreateDirectoryV1(&'a ArchivedJournalEntryCreateDirectoryV1<'a>),
     RemoveDirectoryV1(&'a ArchivedJournalEntryRemoveDirectoryV1<'a>),
     PathSetTimesV1(&'a ArchivedJournalEntryPathSetTimesV1<'a>),
     FileDescriptorSetTimesV1(&'a ArchivedJournalEntryFileDescriptorSetTimesV1),
     FileDescriptorSetSizeV1(&'a ArchivedJournalEntryFileDescriptorSetSizeV1),
+    FileDescriptorSetFdFlagsV1(&'a ArchivedJournalEntryFileDescriptorSetFdFlagsV1),
     FileDescriptorSetFlagsV1(&'a ArchivedJournalEntryFileDescriptorSetFlagsV1),
     FileDescriptorSetRightsV1(&'a ArchivedJournalEntryFileDescriptorSetRightsV1),
     FileDescriptorAdviseV1(&'a ArchivedJournalEntryFileDescriptorAdviseV1),
@@ -927,6 +1025,7 @@ pub enum ArchivedJournalEntry<'a> {
     PortRouteClearV1,
     PortRouteDelV1(&'a ArchivedJournalEntryPortRouteDelV1),
     SocketOpenV1(&'a ArchivedJournalEntrySocketOpenV1),
+    SocketPairV1(&'a ArchivedJournalEntrySocketPairV1),
     SocketListenV1(&'a ArchivedJournalEntrySocketListenV1),
     SocketBindV1(&'a ArchivedJournalEntrySocketBindV1),
     SocketConnectedV1(&'a ArchivedJournalEntrySocketConnectedV1),
@@ -948,7 +1047,7 @@ pub enum ArchivedJournalEntry<'a> {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryInitModuleV1 {
     pub wasm_hash: Box<[u8]>,
 }
@@ -956,13 +1055,13 @@ pub struct JournalEntryInitModuleV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryClearEtherealV1 {}
 
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryProcessExitV1 {
     pub exit_code: Option<JournalExitCodeV1>,
 }
@@ -970,7 +1069,7 @@ pub struct JournalEntryProcessExitV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(attr(repr(align(8))))]
 pub struct JournalEntrySetThreadV1<'a> {
     pub id: u32,
     pub call_stack: AlignedCowVec<'a, u8>,
@@ -984,7 +1083,7 @@ pub struct JournalEntrySetThreadV1<'a> {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(attr(repr(align(8))))]
 pub struct JournalEntryCloseThreadV1 {
     pub id: u32,
     pub exit_code: Option<JournalExitCodeV1>,
@@ -993,7 +1092,7 @@ pub struct JournalEntryCloseThreadV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryFileDescriptorSeekV1 {
     pub fd: u32,
     pub whence: JournalWhenceV1,
@@ -1008,7 +1107,7 @@ pub struct JournalEntryFileDescriptorSeekV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(attr(repr(align(8))))]
 pub struct JournalEntryFileDescriptorWriteV1<'a> {
     /// DO NOT MOVE!
     pub data: AlignedCowVec<'a, u8>,
@@ -1020,7 +1119,7 @@ pub struct JournalEntryFileDescriptorWriteV1<'a> {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(attr(repr(align(8))))]
 pub struct JournalEntryUpdateMemoryRegionV1<'a> {
     pub compressed_data: AlignedCowVec<'a, u8>,
     pub start: u64,
@@ -1030,7 +1129,7 @@ pub struct JournalEntryUpdateMemoryRegionV1<'a> {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntrySetClockTimeV1 {
     pub clock_id: JournalSnapshot0ClockidV1,
     pub time: u64,
@@ -1039,7 +1138,7 @@ pub struct JournalEntrySetClockTimeV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(attr(repr(align(8))))]
 pub struct JournalEntryOpenFileDescriptorV1<'a> {
     pub fd: u32,
     pub dirfd: u32,
@@ -1054,7 +1153,23 @@ pub struct JournalEntryOpenFileDescriptorV1<'a> {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(attr(repr(align(8))))]
+pub struct JournalEntryOpenFileDescriptorV2<'a> {
+    pub fd: u32,
+    pub dirfd: u32,
+    pub dirflags: u32,
+    pub fs_flags: u16,
+    pub fd_flags: u16,
+    pub o_flags: u16,
+    pub fs_rights_base: u64,
+    pub fs_rights_inheriting: u64,
+    pub path: AlignedCowStr<'a>,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryCloseFileDescriptorV1 {
     pub fd: u32,
 }
@@ -1062,7 +1177,7 @@ pub struct JournalEntryCloseFileDescriptorV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryRenumberFileDescriptorV1 {
     pub old_fd: u32,
     pub new_fd: u32,
@@ -1071,7 +1186,7 @@ pub struct JournalEntryRenumberFileDescriptorV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryDuplicateFileDescriptorV1 {
     pub original_fd: u32,
     pub copied_fd: u32,
@@ -1080,7 +1195,17 @@ pub struct JournalEntryDuplicateFileDescriptorV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
+pub struct JournalEntryDuplicateFileDescriptorV2 {
+    pub original_fd: u32,
+    pub copied_fd: u32,
+    pub cloexec: bool,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[rkyv(attr(repr(align(8))))]
 pub struct JournalEntryCreateDirectoryV1<'a> {
     pub fd: u32,
     pub path: AlignedCowStr<'a>,
@@ -1089,7 +1214,7 @@ pub struct JournalEntryCreateDirectoryV1<'a> {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(attr(repr(align(8))))]
 pub struct JournalEntryRemoveDirectoryV1<'a> {
     pub fd: u32,
     pub path: AlignedCowStr<'a>,
@@ -1098,7 +1223,7 @@ pub struct JournalEntryRemoveDirectoryV1<'a> {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(attr(repr(align(8))))]
 pub struct JournalEntryPathSetTimesV1<'a> {
     pub fd: u32,
     pub flags: u32,
@@ -1111,7 +1236,7 @@ pub struct JournalEntryPathSetTimesV1<'a> {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryFileDescriptorSetTimesV1 {
     pub fd: u32,
     pub fst_flags: u16,
@@ -1122,7 +1247,7 @@ pub struct JournalEntryFileDescriptorSetTimesV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryFileDescriptorSetSizeV1 {
     pub fd: u32,
     pub st_size: u64,
@@ -1131,7 +1256,16 @@ pub struct JournalEntryFileDescriptorSetSizeV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
+pub struct JournalEntryFileDescriptorSetFdFlagsV1 {
+    pub fd: u32,
+    pub flags: u16,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryFileDescriptorSetFlagsV1 {
     pub fd: u32,
     pub flags: u16,
@@ -1140,7 +1274,7 @@ pub struct JournalEntryFileDescriptorSetFlagsV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryFileDescriptorSetRightsV1 {
     pub fd: u32,
     pub fs_rights_base: u64,
@@ -1150,7 +1284,7 @@ pub struct JournalEntryFileDescriptorSetRightsV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryFileDescriptorAdviseV1 {
     pub fd: u32,
     pub offset: u64,
@@ -1161,7 +1295,7 @@ pub struct JournalEntryFileDescriptorAdviseV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryFileDescriptorAllocateV1 {
     pub fd: u32,
     pub offset: u64,
@@ -1171,7 +1305,7 @@ pub struct JournalEntryFileDescriptorAllocateV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(attr(repr(align(8))))]
 pub struct JournalEntryCreateHardLinkV1<'a> {
     pub old_fd: u32,
     pub old_path: AlignedCowStr<'a>,
@@ -1183,7 +1317,7 @@ pub struct JournalEntryCreateHardLinkV1<'a> {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(attr(repr(align(8))))]
 pub struct JournalEntryCreateSymbolicLinkV1<'a> {
     pub fd: u32,
     pub old_path: AlignedCowStr<'a>,
@@ -1193,7 +1327,7 @@ pub struct JournalEntryCreateSymbolicLinkV1<'a> {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(attr(repr(align(8))))]
 pub struct JournalEntryUnlinkFileV1<'a> {
     pub fd: u32,
     pub path: AlignedCowStr<'a>,
@@ -1202,7 +1336,7 @@ pub struct JournalEntryUnlinkFileV1<'a> {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(attr(repr(align(8))))]
 pub struct JournalEntryPathRenameV1<'a> {
     pub old_fd: u32,
     pub old_path: AlignedCowStr<'a>,
@@ -1213,7 +1347,7 @@ pub struct JournalEntryPathRenameV1<'a> {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(attr(repr(align(8))))]
 pub struct JournalEntryChangeDirectoryV1<'a> {
     pub path: AlignedCowStr<'a>,
 }
@@ -1221,7 +1355,7 @@ pub struct JournalEntryChangeDirectoryV1<'a> {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryEpollCreateV1 {
     pub fd: u32,
 }
@@ -1229,7 +1363,7 @@ pub struct JournalEntryEpollCreateV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryEpollCtlV1 {
     pub epfd: u32,
     pub op: JournalEpollCtlV1,
@@ -1240,7 +1374,7 @@ pub struct JournalEntryEpollCtlV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryTtySetV1 {
     pub cols: u32,
     pub rows: u32,
@@ -1257,16 +1391,16 @@ pub struct JournalEntryTtySetV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryCreatePipeV1 {
-    pub fd1: u32,
-    pub fd2: u32,
+    pub read_fd: u32,
+    pub write_fd: u32,
 }
 
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryCreateEventV1 {
     pub initial_val: u64,
     pub flags: u16,
@@ -1276,7 +1410,7 @@ pub struct JournalEntryCreateEventV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryPortAddAddrV1 {
     pub cidr: JournalIpCidrV1,
 }
@@ -1284,7 +1418,7 @@ pub struct JournalEntryPortAddAddrV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryPortDelAddrV1 {
     pub addr: IpAddr,
 }
@@ -1292,7 +1426,7 @@ pub struct JournalEntryPortDelAddrV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(attr(repr(align(8))))]
 pub struct JournalEntryPortBridgeV1<'a> {
     pub network: AlignedCowStr<'a>,
     pub token: AlignedCowStr<'a>,
@@ -1302,7 +1436,7 @@ pub struct JournalEntryPortBridgeV1<'a> {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryPortGatewaySetV1 {
     pub ip: IpAddr,
 }
@@ -1310,7 +1444,7 @@ pub struct JournalEntryPortGatewaySetV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryPortRouteAddV1 {
     pub cidr: JournalIpCidrV1,
     pub via_router: IpAddr,
@@ -1321,7 +1455,7 @@ pub struct JournalEntryPortRouteAddV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntryPortRouteDelV1 {
     pub ip: IpAddr,
 }
@@ -1329,7 +1463,7 @@ pub struct JournalEntryPortRouteDelV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntrySocketOpenV1 {
     pub af: JournalAddressfamilyV1,
     pub ty: JournalSocktypeV1,
@@ -1337,10 +1471,18 @@ pub struct JournalEntrySocketOpenV1 {
     pub fd: u32,
 }
 
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
+pub struct JournalEntrySocketPairV1 {
+    pub fd1: u32,
+    pub fd2: u32,
+}
+
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntrySocketListenV1 {
     pub fd: u32,
     pub backlog: u32,
@@ -1349,7 +1491,7 @@ pub struct JournalEntrySocketListenV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntrySocketBindV1 {
     pub fd: u32,
     pub addr: SocketAddr,
@@ -1358,7 +1500,7 @@ pub struct JournalEntrySocketBindV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntrySocketConnectedV1 {
     pub fd: u32,
     pub local_addr: SocketAddr,
@@ -1368,7 +1510,7 @@ pub struct JournalEntrySocketConnectedV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntrySocketAcceptedV1 {
     pub listen_fd: u32,
     pub fd: u32,
@@ -1381,7 +1523,7 @@ pub struct JournalEntrySocketAcceptedV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntrySocketJoinIpv4MulticastV1 {
     pub fd: u32,
     pub multiaddr: Ipv4Addr,
@@ -1391,7 +1533,7 @@ pub struct JournalEntrySocketJoinIpv4MulticastV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntrySocketJoinIpv6MulticastV1 {
     pub fd: u32,
     pub multiaddr: Ipv6Addr,
@@ -1401,7 +1543,7 @@ pub struct JournalEntrySocketJoinIpv6MulticastV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntrySocketLeaveIpv4MulticastV1 {
     pub fd: u32,
     pub multiaddr: Ipv4Addr,
@@ -1411,7 +1553,7 @@ pub struct JournalEntrySocketLeaveIpv4MulticastV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntrySocketLeaveIpv6MulticastV1 {
     pub fd: u32,
     pub multiaddr: Ipv6Addr,
@@ -1421,7 +1563,7 @@ pub struct JournalEntrySocketLeaveIpv6MulticastV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntrySocketSendFileV1 {
     pub socket_fd: u32,
     pub file_fd: u32,
@@ -1432,7 +1574,7 @@ pub struct JournalEntrySocketSendFileV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(attr(repr(align(8))))]
 pub struct JournalEntrySocketSendToV1<'a> {
     pub fd: u32,
     pub data: AlignedCowVec<'a, u8>,
@@ -1444,7 +1586,7 @@ pub struct JournalEntrySocketSendToV1<'a> {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(attr(repr(align(8))))]
 pub struct JournalEntrySocketSendV1<'a> {
     pub fd: u32,
     pub data: AlignedCowVec<'a, u8>,
@@ -1455,7 +1597,7 @@ pub struct JournalEntrySocketSendV1<'a> {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntrySocketSetOptFlagV1 {
     pub fd: u32,
     pub opt: JournalSockoptionV1,
@@ -1465,7 +1607,7 @@ pub struct JournalEntrySocketSetOptFlagV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntrySocketSetOptSizeV1 {
     pub fd: u32,
     pub opt: JournalSockoptionV1,
@@ -1475,7 +1617,7 @@ pub struct JournalEntrySocketSetOptSizeV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntrySocketSetOptTimeV1 {
     pub fd: u32,
     pub ty: JournalTimeTypeV1,
@@ -1485,7 +1627,7 @@ pub struct JournalEntrySocketSetOptTimeV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntrySocketShutdownV1 {
     pub fd: u32,
     pub how: JournalSocketShutdownV1,
@@ -1494,7 +1636,7 @@ pub struct JournalEntrySocketShutdownV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalEntrySnapshotV1 {
     pub since_epoch: Duration,
     pub trigger: JournalSnapshotTriggerV1,
@@ -1502,7 +1644,7 @@ pub struct JournalEntrySnapshotV1 {
 
 #[repr(C)]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub enum JournalSnapshot0ClockidV1 {
     Realtime,
     Monotonic,
@@ -1513,7 +1655,7 @@ pub enum JournalSnapshot0ClockidV1 {
 
 #[repr(C)]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub enum JournalWhenceV1 {
     Set,
     Cur,
@@ -1523,7 +1665,7 @@ pub enum JournalWhenceV1 {
 
 #[repr(C)]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub enum JournalAdviceV1 {
     Normal,
     Sequential,
@@ -1537,7 +1679,7 @@ pub enum JournalAdviceV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub struct JournalIpCidrV1 {
     pub ip: IpAddr,
     pub prefix: u8,
@@ -1545,7 +1687,7 @@ pub struct JournalIpCidrV1 {
 
 #[repr(C)]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub enum JournalExitCodeV1 {
     Errno(u16),
     Other(i32),
@@ -1565,7 +1707,7 @@ pub enum JournalExitCodeV1 {
     RkyvDeserialize,
     Archive,
 )]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub enum JournalSnapshotTriggerV1 {
     Idle,
     Listen,
@@ -1579,6 +1721,7 @@ pub enum JournalSnapshotTriggerV1 {
     NonDeterministicCall,
     Bootstrap,
     Transaction,
+    Explicit,
 }
 
 #[repr(C)]
@@ -1595,7 +1738,7 @@ pub enum JournalSnapshotTriggerV1 {
     RkyvDeserialize,
     Archive,
 )]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub enum JournalEpollCtlV1 {
     Add,
     Mod,
@@ -1606,7 +1749,7 @@ pub enum JournalEpollCtlV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub struct JournalEpollEventCtlV1 {
     pub events: u32,
     pub ptr: u64,
@@ -1629,7 +1772,7 @@ pub struct JournalEpollEventCtlV1 {
     RkyvDeserialize,
     Archive,
 )]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub enum JournalStreamSecurityV1 {
     Unencrypted,
     AnyEncryption,
@@ -1652,7 +1795,7 @@ pub enum JournalStreamSecurityV1 {
     RkyvDeserialize,
     Archive,
 )]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub enum JournalAddressfamilyV1 {
     Unspec,
     Inet4,
@@ -1674,7 +1817,7 @@ pub enum JournalAddressfamilyV1 {
     RkyvDeserialize,
     Archive,
 )]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub enum JournalSocktypeV1 {
     Unknown,
     Stream,
@@ -1697,7 +1840,7 @@ pub enum JournalSocktypeV1 {
     RkyvDeserialize,
     Archive,
 )]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub enum JournalSockoptionV1 {
     Noop,
     ReusePort,
@@ -1742,7 +1885,7 @@ pub enum JournalSockoptionV1 {
     RkyvDeserialize,
     Archive,
 )]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub enum JournalTimeTypeV1 {
     ReadTimeout,
     WriteTimeout,
@@ -1766,7 +1909,7 @@ pub enum JournalTimeTypeV1 {
     RkyvDeserialize,
     Archive,
 )]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub enum JournalSocketShutdownV1 {
     Read,
     Write,
@@ -1788,7 +1931,7 @@ pub enum JournalSocketShutdownV1 {
     Eq,
     Hash,
 )]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub enum JournalThreadStartTypeV1 {
     MainThread,
     ThreadSpawn { start_ptr: u64 },
@@ -1797,7 +1940,7 @@ pub enum JournalThreadStartTypeV1 {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Clone, Copy, RkyvSerialize, RkyvDeserialize, Archive, PartialEq, Eq, Hash)]
-#[archive_attr(derive(CheckBytes), repr(align(8)))]
+#[rkyv(derive(Debug), attr(repr(align(8))))]
 pub struct JournalWasiMemoryLayout {
     pub stack_upper: u64,
     pub stack_lower: u64,
diff --git a/lib/journal/src/concrete/archived_from.rs b/lib/journal/src/concrete/archived_from.rs
index e86e5c5719..1d0690ae25 100644
--- a/lib/journal/src/concrete/archived_from.rs
+++ b/lib/journal/src/concrete/archived_from.rs
@@ -140,20 +140,15 @@ impl From<JournalIpCidrV1> for virtual_net::IpCidr {
 
 impl From<wasi::ExitCode> for JournalExitCodeV1 {
     fn from(val: wasi::ExitCode) -> Self {
-        match val {
-            wasi::ExitCode::Errno(errno) => JournalExitCodeV1::Errno(errno as u16),
-            wasi::ExitCode::Other(id) => JournalExitCodeV1::Other(id),
-        }
+        JournalExitCodeV1::Other(val.raw())
     }
 }
 
 impl From<JournalExitCodeV1> for wasi::ExitCode {
     fn from(val: JournalExitCodeV1) -> Self {
         match val {
-            JournalExitCodeV1::Errno(errno) => {
-                wasi::ExitCode::Errno(errno.try_into().unwrap_or(wasi::Errno::Unknown))
-            }
-            JournalExitCodeV1::Other(id) => wasi::ExitCode::Other(id),
+            JournalExitCodeV1::Errno(errno) => wasi::ExitCode::from(errno),
+            JournalExitCodeV1::Other(id) => wasi::ExitCode::from(id),
         }
     }
 }
@@ -161,10 +156,8 @@ impl From<JournalExitCodeV1> for wasi::ExitCode {
 impl From<&'_ ArchivedJournalExitCodeV1> for wasi::ExitCode {
     fn from(val: &'_ ArchivedJournalExitCodeV1) -> Self {
         match val {
-            ArchivedJournalExitCodeV1::Errno(errno) => {
-                wasi::ExitCode::Errno((*errno).try_into().unwrap_or(wasi::Errno::Unknown))
-            }
-            ArchivedJournalExitCodeV1::Other(id) => wasi::ExitCode::Other(*id),
+            ArchivedJournalExitCodeV1::Errno(errno) => wasi::ExitCode::from(errno.to_native()),
+            ArchivedJournalExitCodeV1::Other(id) => wasi::ExitCode::from(id.to_native()),
         }
     }
 }
@@ -185,6 +178,7 @@ impl From<SnapshotTrigger> for JournalSnapshotTriggerV1 {
             SnapshotTrigger::NonDeterministicCall => JournalSnapshotTriggerV1::NonDeterministicCall,
             SnapshotTrigger::Bootstrap => JournalSnapshotTriggerV1::Bootstrap,
             SnapshotTrigger::Transaction => JournalSnapshotTriggerV1::Transaction,
+            SnapshotTrigger::Explicit => JournalSnapshotTriggerV1::Explicit,
         }
     }
 }
@@ -204,6 +198,7 @@ impl From<JournalSnapshotTriggerV1> for SnapshotTrigger {
             JournalSnapshotTriggerV1::NonDeterministicCall => SnapshotTrigger::NonDeterministicCall,
             JournalSnapshotTriggerV1::Bootstrap => SnapshotTrigger::Bootstrap,
             JournalSnapshotTriggerV1::Transaction => SnapshotTrigger::Transaction,
+            JournalSnapshotTriggerV1::Explicit => SnapshotTrigger::Explicit,
         }
     }
 }
@@ -225,6 +220,7 @@ impl From<&'_ ArchivedJournalSnapshotTriggerV1> for SnapshotTrigger {
             }
             ArchivedJournalSnapshotTriggerV1::Bootstrap => SnapshotTrigger::Bootstrap,
             ArchivedJournalSnapshotTriggerV1::Transaction => SnapshotTrigger::Transaction,
+            ArchivedJournalSnapshotTriggerV1::Explicit => SnapshotTrigger::Explicit,
         }
     }
 }
@@ -289,11 +285,11 @@ impl From<JournalEpollEventCtlV1> for wasi::EpollEventCtl {
 impl From<&'_ ArchivedJournalEpollEventCtlV1> for wasi::EpollEventCtl {
     fn from(val: &'_ ArchivedJournalEpollEventCtlV1) -> Self {
         Self {
-            events: wasi::EpollType::from_bits_truncate(val.events),
-            ptr: val.ptr,
-            fd: val.fd,
-            data1: val.data1,
-            data2: val.data2,
+            events: wasi::EpollType::from_bits_truncate(val.events.to_native()),
+            ptr: val.ptr.to_native(),
+            fd: val.fd.to_native(),
+            data1: val.data1.to_native(),
+            data2: val.data2.to_native(),
         }
     }
 }
@@ -593,7 +589,7 @@ impl From<&'_ ArchivedJournalThreadStartTypeV1> for ThreadStartType {
             ArchivedJournalThreadStartTypeV1::MainThread => ThreadStartType::MainThread,
             ArchivedJournalThreadStartTypeV1::ThreadSpawn { start_ptr } => {
                 ThreadStartType::ThreadSpawn {
-                    start_ptr: *start_ptr,
+                    start_ptr: start_ptr.to_native(),
                 }
             }
         }
@@ -618,6 +614,7 @@ impl From<JournalWasiMemoryLayout> for WasiMemoryLayout {
             stack_lower: value.stack_lower,
             guard_size: value.guard_size,
             stack_size: value.stack_size,
+            tls_base: None,
         }
     }
 }
@@ -625,10 +622,11 @@ impl From<JournalWasiMemoryLayout> for WasiMemoryLayout {
 impl From<&'_ ArchivedJournalWasiMemoryLayout> for WasiMemoryLayout {
     fn from(value: &'_ ArchivedJournalWasiMemoryLayout) -> Self {
         Self {
-            stack_upper: value.stack_upper,
-            stack_lower: value.stack_lower,
-            guard_size: value.guard_size,
-            stack_size: value.stack_size,
+            stack_upper: value.stack_upper.to_native(),
+            stack_lower: value.stack_lower.to_native(),
+            guard_size: value.guard_size.to_native(),
+            stack_size: value.stack_size.to_native(),
+            tls_base: None,
         }
     }
 }
@@ -664,7 +662,7 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                     compressed_data,
                 },
             ) => Self::UpdateMemoryRegionV1 {
-                region: (*start)..(*end),
+                region: (start.to_native())..(end.to_native()),
                 compressed_data: Cow::Borrowed(compressed_data.as_ref()),
             },
             ArchivedJournalEntry::ProcessExitV1(ArchivedJournalEntryProcessExitV1 {
@@ -681,7 +679,7 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 start,
                 layout,
             }) => Self::SetThreadV1 {
-                id: *id,
+                id: id.to_native(),
                 call_stack: call_stack.as_ref().into(),
                 memory_stack: memory_stack.as_ref().into(),
                 store_data: store_data.as_ref().into(),
@@ -693,7 +691,7 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 id,
                 exit_code,
             }) => Self::CloseThreadV1 {
-                id: *id,
+                id: id.to_native(),
                 exit_code: exit_code.as_ref().map(|code| code.into()),
             },
             ArchivedJournalEntry::FileDescriptorWriteV1(
@@ -705,8 +703,8 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 },
             ) => Self::FileDescriptorWriteV1 {
                 data: data.as_ref().into(),
-                fd: *fd,
-                offset: *offset,
+                fd: fd.to_native(),
+                offset: offset.to_native(),
                 is_64bit: *is_64bit,
             },
             ArchivedJournalEntry::FileDescriptorSeekV1(
@@ -716,8 +714,8 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                     ref whence,
                 },
             ) => Self::FileDescriptorSeekV1 {
-                fd: *fd,
-                offset: *offset,
+                fd: fd.to_native(),
+                offset: offset.to_native(),
                 whence: whence.into(),
             },
             ArchivedJournalEntry::OpenFileDescriptorV1(
@@ -732,28 +730,55 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                     fs_flags,
                 },
             ) => Self::OpenFileDescriptorV1 {
-                fd: *fd,
-                dirfd: *dirfd,
-                dirflags: *dirflags,
+                fd: fd.to_native(),
+                dirfd: dirfd.to_native(),
+                dirflags: dirflags.to_native(),
+                path: String::from_utf8_lossy(path.as_ref()),
+                o_flags: wasi::Oflags::from_bits_truncate(o_flags.to_native()),
+                fs_rights_base: wasi::Rights::from_bits_truncate(fs_rights_base.to_native()),
+                fs_rights_inheriting: wasi::Rights::from_bits_truncate(
+                    fs_rights_inheriting.to_native(),
+                ),
+                fs_flags: wasi::Fdflags::from_bits_truncate(fs_flags.to_native()),
+            },
+            ArchivedJournalEntry::OpenFileDescriptorV2(
+                ArchivedJournalEntryOpenFileDescriptorV2 {
+                    fd,
+                    dirfd,
+                    dirflags,
+                    path,
+                    o_flags,
+                    fs_rights_base,
+                    fs_rights_inheriting,
+                    fs_flags,
+                    fd_flags,
+                },
+            ) => Self::OpenFileDescriptorV2 {
+                fd: fd.to_native(),
+                dirfd: dirfd.to_native(),
+                dirflags: dirflags.to_native(),
                 path: String::from_utf8_lossy(path.as_ref()),
-                o_flags: wasi::Oflags::from_bits_truncate(*o_flags),
-                fs_rights_base: wasi::Rights::from_bits_truncate(*fs_rights_base),
-                fs_rights_inheriting: wasi::Rights::from_bits_truncate(*fs_rights_inheriting),
-                fs_flags: wasi::Fdflags::from_bits_truncate(*fs_flags),
+                o_flags: wasi::Oflags::from_bits_truncate(o_flags.to_native()),
+                fs_rights_base: wasi::Rights::from_bits_truncate(fs_rights_base.to_native()),
+                fs_rights_inheriting: wasi::Rights::from_bits_truncate(
+                    fs_rights_inheriting.to_native(),
+                ),
+                fs_flags: wasi::Fdflags::from_bits_truncate(fs_flags.to_native()),
+                fd_flags: wasi::Fdflagsext::from_bits_truncate(fd_flags.to_native()),
             },
             ArchivedJournalEntry::CloseFileDescriptorV1(
                 ArchivedJournalEntryCloseFileDescriptorV1 { fd },
-            ) => Self::CloseFileDescriptorV1 { fd: *fd },
+            ) => Self::CloseFileDescriptorV1 { fd: fd.to_native() },
             ArchivedJournalEntry::RemoveDirectoryV1(ArchivedJournalEntryRemoveDirectoryV1 {
                 fd,
                 path,
             }) => Self::RemoveDirectoryV1 {
-                fd: *fd,
+                fd: fd.to_native(),
                 path: String::from_utf8_lossy(path.as_ref()),
             },
             ArchivedJournalEntry::UnlinkFileV1(ArchivedJournalEntryUnlinkFileV1 { fd, path }) => {
                 Self::UnlinkFileV1 {
-                    fd: *fd,
+                    fd: fd.to_native(),
                     path: String::from_utf8_lossy(path.as_ref()),
                 }
             }
@@ -763,9 +788,9 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 new_fd,
                 new_path,
             }) => Self::PathRenameV1 {
-                old_fd: *old_fd,
+                old_fd: old_fd.to_native(),
                 old_path: String::from_utf8_lossy(old_path.as_ref()),
-                new_fd: *new_fd,
+                new_fd: new_fd.to_native(),
                 new_path: String::from_utf8_lossy(new_path.as_ref()),
             },
             ArchivedJournalEntry::SnapshotV1(ArchivedJournalEntrySnapshotV1 {
@@ -773,7 +798,7 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 ref trigger,
             }) => Self::SnapshotV1 {
                 when: SystemTime::UNIX_EPOCH
-                    .checked_add((*since_epoch).try_into().unwrap())
+                    .checked_add((*since_epoch).into())
                     .unwrap_or(SystemTime::UNIX_EPOCH),
                 trigger: trigger.into(),
             },
@@ -782,13 +807,13 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 time,
             }) => Self::SetClockTimeV1 {
                 clock_id: clock_id.into(),
-                time: *time,
+                time: time.to_native(),
             },
             ArchivedJournalEntry::RenumberFileDescriptorV1(
                 ArchivedJournalEntryRenumberFileDescriptorV1 { old_fd, new_fd },
             ) => Self::RenumberFileDescriptorV1 {
-                old_fd: *old_fd,
-                new_fd: *new_fd,
+                old_fd: old_fd.to_native(),
+                new_fd: new_fd.to_native(),
             },
             ArchivedJournalEntry::DuplicateFileDescriptorV1(
                 ArchivedJournalEntryDuplicateFileDescriptorV1 {
@@ -796,14 +821,25 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                     copied_fd: new_fd,
                 },
             ) => Self::DuplicateFileDescriptorV1 {
-                original_fd: *old_fd,
-                copied_fd: *new_fd,
+                original_fd: old_fd.to_native(),
+                copied_fd: new_fd.to_native(),
+            },
+            ArchivedJournalEntry::DuplicateFileDescriptorV2(
+                ArchivedJournalEntryDuplicateFileDescriptorV2 {
+                    original_fd: old_fd,
+                    copied_fd: new_fd,
+                    cloexec,
+                },
+            ) => Self::DuplicateFileDescriptorV2 {
+                original_fd: old_fd.to_native(),
+                copied_fd: new_fd.to_native(),
+                cloexec: *cloexec,
             },
             ArchivedJournalEntry::CreateDirectoryV1(ArchivedJournalEntryCreateDirectoryV1 {
                 fd,
                 path,
             }) => Self::CreateDirectoryV1 {
-                fd: *fd,
+                fd: fd.to_native(),
                 path: String::from_utf8_lossy(path.as_ref()),
             },
             ArchivedJournalEntry::PathSetTimesV1(ArchivedJournalEntryPathSetTimesV1 {
@@ -814,12 +850,12 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 st_mtim,
                 fst_flags,
             }) => Self::PathSetTimesV1 {
-                fd: *fd,
+                fd: fd.to_native(),
                 path: String::from_utf8_lossy(path.as_ref()),
-                flags: *flags,
-                st_atim: *st_atim,
-                st_mtim: *st_mtim,
-                fst_flags: wasi::Fstflags::from_bits_truncate(*fst_flags),
+                flags: flags.to_native(),
+                st_atim: st_atim.to_native(),
+                st_mtim: st_mtim.to_native(),
+                fst_flags: wasi::Fstflags::from_bits_truncate(fst_flags.to_native()),
             },
             ArchivedJournalEntry::FileDescriptorSetTimesV1(
                 ArchivedJournalEntryFileDescriptorSetTimesV1 {
@@ -829,22 +865,28 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                     fst_flags,
                 },
             ) => Self::FileDescriptorSetTimesV1 {
-                fd: *fd,
-                st_atim: *st_atim,
-                st_mtim: *st_mtim,
-                fst_flags: wasi::Fstflags::from_bits_truncate(*fst_flags),
+                fd: fd.to_native(),
+                st_atim: st_atim.to_native(),
+                st_mtim: st_mtim.to_native(),
+                fst_flags: wasi::Fstflags::from_bits_truncate(fst_flags.to_native()),
             },
             ArchivedJournalEntry::FileDescriptorSetSizeV1(
                 ArchivedJournalEntryFileDescriptorSetSizeV1 { fd, st_size },
             ) => Self::FileDescriptorSetSizeV1 {
-                fd: *fd,
-                st_size: *st_size,
+                fd: fd.to_native(),
+                st_size: st_size.to_native(),
+            },
+            ArchivedJournalEntry::FileDescriptorSetFdFlagsV1(
+                ArchivedJournalEntryFileDescriptorSetFdFlagsV1 { fd, flags },
+            ) => Self::FileDescriptorSetFdFlagsV1 {
+                fd: fd.to_native(),
+                flags: wasi::Fdflagsext::from_bits_truncate(flags.to_native()),
             },
             ArchivedJournalEntry::FileDescriptorSetFlagsV1(
                 ArchivedJournalEntryFileDescriptorSetFlagsV1 { fd, flags },
             ) => Self::FileDescriptorSetFlagsV1 {
-                fd: *fd,
-                flags: wasi::Fdflags::from_bits_truncate(*flags),
+                fd: fd.to_native(),
+                flags: wasi::Fdflags::from_bits_truncate(flags.to_native()),
             },
             ArchivedJournalEntry::FileDescriptorSetRightsV1(
                 ArchivedJournalEntryFileDescriptorSetRightsV1 {
@@ -853,9 +895,11 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                     fs_rights_inheriting,
                 },
             ) => Self::FileDescriptorSetRightsV1 {
-                fd: *fd,
-                fs_rights_base: wasi::Rights::from_bits_truncate(*fs_rights_base),
-                fs_rights_inheriting: wasi::Rights::from_bits_truncate(*fs_rights_inheriting),
+                fd: fd.to_native(),
+                fs_rights_base: wasi::Rights::from_bits_truncate(fs_rights_base.to_native()),
+                fs_rights_inheriting: wasi::Rights::from_bits_truncate(
+                    fs_rights_inheriting.to_native(),
+                ),
             },
             ArchivedJournalEntry::FileDescriptorAdviseV1(
                 ArchivedJournalEntryFileDescriptorAdviseV1 {
@@ -865,17 +909,17 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                     ref advice,
                 },
             ) => Self::FileDescriptorAdviseV1 {
-                fd: *fd,
-                offset: *offset,
-                len: *len,
+                fd: fd.to_native(),
+                offset: offset.to_native(),
+                len: len.to_native(),
                 advice: advice.into(),
             },
             ArchivedJournalEntry::FileDescriptorAllocateV1(
                 ArchivedJournalEntryFileDescriptorAllocateV1 { fd, offset, len },
             ) => Self::FileDescriptorAllocateV1 {
-                fd: *fd,
-                offset: *offset,
-                len: *len,
+                fd: fd.to_native(),
+                offset: offset.to_native(),
+                len: len.to_native(),
             },
             ArchivedJournalEntry::CreateHardLinkV1(ArchivedJournalEntryCreateHardLinkV1 {
                 old_fd,
@@ -884,10 +928,10 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 new_fd,
                 new_path,
             }) => Self::CreateHardLinkV1 {
-                old_fd: *old_fd,
+                old_fd: old_fd.to_native(),
                 old_path: String::from_utf8_lossy(old_path.as_ref()),
-                old_flags: *old_flags,
-                new_fd: *new_fd,
+                old_flags: old_flags.to_native(),
+                new_fd: new_fd.to_native(),
                 new_path: String::from_utf8_lossy(new_path.as_ref()),
             },
             ArchivedJournalEntry::CreateSymbolicLinkV1(
@@ -898,7 +942,7 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 },
             ) => Self::CreateSymbolicLinkV1 {
                 old_path: String::from_utf8_lossy(old_path.as_ref()),
-                fd: *fd,
+                fd: fd.to_native(),
                 new_path: String::from_utf8_lossy(new_path.as_ref()),
             },
             ArchivedJournalEntry::ChangeDirectoryV1(ArchivedJournalEntryChangeDirectoryV1 {
@@ -907,7 +951,7 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 path: String::from_utf8_lossy(path.as_ref()),
             },
             ArchivedJournalEntry::EpollCreateV1(ArchivedJournalEntryEpollCreateV1 { fd }) => {
-                Self::EpollCreateV1 { fd: *fd }
+                Self::EpollCreateV1 { fd: fd.to_native() }
             }
             ArchivedJournalEntry::EpollCtlV1(ArchivedJournalEntryEpollCtlV1 {
                 epfd,
@@ -915,9 +959,9 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 fd,
                 ref event,
             }) => Self::EpollCtlV1 {
-                epfd: *epfd,
+                epfd: epfd.to_native(),
                 op: op.into(),
-                fd: *fd,
+                fd: fd.to_native(),
                 event: event.as_ref().map(|e| e.into()),
             },
             ArchivedJournalEntry::TtySetV1(ArchivedJournalEntryTtySetV1 {
@@ -933,10 +977,10 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 line_feeds,
             }) => Self::TtySetV1 {
                 tty: wasi::Tty {
-                    cols: *cols,
-                    rows: *rows,
-                    width: *width,
-                    height: *height,
+                    cols: cols.to_native(),
+                    rows: rows.to_native(),
+                    width: width.to_native(),
+                    height: height.to_native(),
                     stdin_tty: *stdin_tty,
                     stdout_tty: *stdout_tty,
                     stderr_tty: *stderr_tty,
@@ -945,12 +989,13 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 },
                 line_feeds: *line_feeds,
             },
-            ArchivedJournalEntry::CreatePipeV1(ArchivedJournalEntryCreatePipeV1 { fd1, fd2 }) => {
-                Self::CreatePipeV1 {
-                    fd1: *fd1,
-                    fd2: *fd2,
-                }
-            }
+            ArchivedJournalEntry::CreatePipeV1(ArchivedJournalEntryCreatePipeV1 {
+                read_fd,
+                write_fd,
+            }) => Self::CreatePipeV1 {
+                read_fd: read_fd.to_native(),
+                write_fd: write_fd.to_native(),
+            },
             ArchivedJournalEntry::PortAddAddrV1(ArchivedJournalEntryPortAddAddrV1 { cidr }) => {
                 Self::PortAddAddrV1 {
                     cidr: JournalIpCidrV1 {
@@ -992,10 +1037,8 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 }
                 .into(),
                 via_router: via_router.as_ipaddr(),
-                preferred_until: preferred_until
-                    .as_ref()
-                    .map(|time| (*time).try_into().unwrap()),
-                expires_at: expires_at.as_ref().map(|time| (*time).try_into().unwrap()),
+                preferred_until: preferred_until.as_ref().map(|time| (*time).into()),
+                expires_at: expires_at.as_ref().map(|time| (*time).into()),
             },
             ArchivedJournalEntry::PortRouteClearV1 => Self::PortRouteClearV1,
             ArchivedJournalEntry::PortRouteDelV1(ArchivedJournalEntryPortRouteDelV1 { ip }) => {
@@ -1009,19 +1052,25 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
             }) => Self::SocketOpenV1 {
                 af: af.into(),
                 ty: ty.into(),
-                pt: (*pt).try_into().unwrap_or(wasi::SockProto::Max),
-                fd: *fd,
+                pt: (pt.to_native()).try_into().unwrap_or(wasi::SockProto::Max),
+                fd: fd.to_native(),
             },
+            ArchivedJournalEntry::SocketPairV1(ArchivedJournalEntrySocketPairV1 { fd1, fd2 }) => {
+                Self::SocketPairV1 {
+                    fd1: fd1.to_native(),
+                    fd2: fd2.to_native(),
+                }
+            }
             ArchivedJournalEntry::SocketListenV1(ArchivedJournalEntrySocketListenV1 {
                 fd,
                 backlog,
             }) => Self::SocketListenV1 {
-                fd: *fd,
-                backlog: *backlog,
+                fd: fd.to_native(),
+                backlog: backlog.to_native(),
             },
             ArchivedJournalEntry::SocketBindV1(ArchivedJournalEntrySocketBindV1 { fd, addr }) => {
                 Self::SocketBindV1 {
-                    fd: *fd,
+                    fd: fd.to_native(),
                     addr: addr.as_socket_addr(),
                 }
             }
@@ -1030,7 +1079,7 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 local_addr,
                 peer_addr,
             }) => Self::SocketConnectedV1 {
-                fd: *fd,
+                fd: fd.to_native(),
                 local_addr: local_addr.as_socket_addr(),
                 peer_addr: peer_addr.as_socket_addr(),
             },
@@ -1042,11 +1091,11 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 fd_flags,
                 nonblocking,
             }) => Self::SocketAcceptedV1 {
-                listen_fd: *listen_fd,
-                fd: *fd,
+                listen_fd: listen_fd.to_native(),
+                fd: fd.to_native(),
                 local_addr: local_addr.as_socket_addr(),
                 peer_addr: peer_addr.as_socket_addr(),
-                fd_flags: wasi::Fdflags::from_bits_truncate(*fd_flags),
+                fd_flags: wasi::Fdflags::from_bits_truncate(fd_flags.to_native()),
                 non_blocking: *nonblocking,
             },
             ArchivedJournalEntry::SocketJoinIpv4MulticastV1(
@@ -1056,7 +1105,7 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                     iface,
                 },
             ) => Self::SocketJoinIpv4MulticastV1 {
-                fd: *fd,
+                fd: fd.to_native(),
                 multiaddr: multiaddr.as_ipv4(),
                 iface: iface.as_ipv4(),
             },
@@ -1067,9 +1116,9 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                     iface,
                 },
             ) => Self::SocketJoinIpv6MulticastV1 {
-                fd: *fd,
+                fd: fd.to_native(),
                 multi_addr: multiaddr.as_ipv6(),
-                iface: *iface,
+                iface: iface.to_native(),
             },
             ArchivedJournalEntry::SocketLeaveIpv4MulticastV1(
                 ArchivedJournalEntrySocketLeaveIpv4MulticastV1 {
@@ -1078,7 +1127,7 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                     iface,
                 },
             ) => Self::SocketLeaveIpv4MulticastV1 {
-                fd: *fd,
+                fd: fd.to_native(),
                 multi_addr: multiaddr.as_ipv4(),
                 iface: iface.as_ipv4(),
             },
@@ -1089,9 +1138,9 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                     iface,
                 },
             ) => Self::SocketLeaveIpv6MulticastV1 {
-                fd: *fd,
+                fd: fd.to_native(),
                 multi_addr: multiaddr.as_ipv6(),
-                iface: *iface,
+                iface: iface.to_native(),
             },
             ArchivedJournalEntry::SocketSendFileV1(ArchivedJournalEntrySocketSendFileV1 {
                 socket_fd,
@@ -1099,10 +1148,10 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 offset,
                 count,
             }) => Self::SocketSendFileV1 {
-                socket_fd: *socket_fd,
-                file_fd: *file_fd,
-                offset: *offset,
-                count: *count,
+                socket_fd: socket_fd.to_native(),
+                file_fd: file_fd.to_native(),
+                offset: offset.to_native(),
+                count: count.to_native(),
             },
             ArchivedJournalEntry::SocketSendToV1(ArchivedJournalEntrySocketSendToV1 {
                 fd,
@@ -1111,9 +1160,9 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 addr,
                 is_64bit,
             }) => Self::SocketSendToV1 {
-                fd: *fd,
+                fd: fd.to_native(),
                 data: data.as_ref().into(),
-                flags: *flags,
+                flags: flags.to_native(),
                 addr: addr.as_socket_addr(),
                 is_64bit: *is_64bit,
             },
@@ -1123,9 +1172,9 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 flags,
                 is_64bit,
             }) => Self::SocketSendV1 {
-                fd: *fd,
+                fd: fd.to_native(),
                 data: data.as_ref().into(),
-                flags: *flags,
+                flags: flags.to_native(),
                 is_64bit: *is_64bit,
             },
             ArchivedJournalEntry::SocketSetOptFlagV1(ArchivedJournalEntrySocketSetOptFlagV1 {
@@ -1133,7 +1182,7 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 ref opt,
                 flag,
             }) => Self::SocketSetOptFlagV1 {
-                fd: *fd,
+                fd: fd.to_native(),
                 opt: opt.into(),
                 flag: *flag,
             },
@@ -1142,24 +1191,24 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 ref opt,
                 size,
             }) => Self::SocketSetOptSizeV1 {
-                fd: *fd,
+                fd: fd.to_native(),
                 opt: opt.into(),
-                size: *size,
+                size: size.to_native(),
             },
             ArchivedJournalEntry::SocketSetOptTimeV1(ArchivedJournalEntrySocketSetOptTimeV1 {
                 fd,
                 ref ty,
                 time,
             }) => Self::SocketSetOptTimeV1 {
-                fd: *fd,
+                fd: fd.to_native(),
                 ty: ty.into(),
-                time: time.as_ref().map(|time| (*time).try_into().unwrap()),
+                time: time.as_ref().map(|time| (*time).into()),
             },
             ArchivedJournalEntry::SocketShutdownV1(ArchivedJournalEntrySocketShutdownV1 {
                 fd,
                 ref how,
             }) => Self::SocketShutdownV1 {
-                fd: *fd,
+                fd: fd.to_native(),
                 how: how.into(),
             },
             ArchivedJournalEntry::CreateEventV1(ArchivedJournalEntryCreateEventV1 {
@@ -1167,9 +1216,9 @@ impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
                 flags,
                 fd,
             }) => Self::CreateEventV1 {
-                initial_val: *initial_val,
-                flags: *flags,
-                fd: *fd,
+                initial_val: initial_val.to_native(),
+                flags: flags.to_native(),
+                fd: fd.to_native(),
             },
         })
     }
diff --git a/lib/journal/src/concrete/auto_consistent.rs b/lib/journal/src/concrete/auto_consistent.rs
index 511106afb2..09dc487e64 100644
--- a/lib/journal/src/concrete/auto_consistent.rs
+++ b/lib/journal/src/concrete/auto_consistent.rs
@@ -69,10 +69,10 @@ impl<W: WritableJournal> WritableJournal for AutoConsistentJournalTx<W> {
                 let mut state = self.state.lock().unwrap();
                 state.open_sockets.insert(*fd);
             }
-            JournalEntry::CreatePipeV1 { fd1, fd2 } => {
+            JournalEntry::CreatePipeV1 { read_fd, write_fd } => {
                 let mut state = self.state.lock().unwrap();
-                state.open_files.insert(*fd1);
-                state.open_files.insert(*fd2);
+                state.open_files.insert(*read_fd);
+                state.open_files.insert(*write_fd);
             }
             JournalEntry::RenumberFileDescriptorV1 { old_fd, new_fd } => {
                 let mut state = self.state.lock().unwrap();
diff --git a/lib/journal/src/concrete/compacting.rs b/lib/journal/src/concrete/compacting.rs
index 08bbe55fee..6b542e1cb1 100644
--- a/lib/journal/src/concrete/compacting.rs
+++ b/lib/journal/src/concrete/compacting.rs
@@ -61,7 +61,7 @@ impl From<Range<u64>> for MemoryRange {
 /// on the final deterministic outcome of the entire log.
 ///
 /// By grouping events into subevents it makes it possible to ignore an
-/// entire subgroup of events which are superseeded by a later event. For
+/// entire subgroup of events which are superceded by a later event. For
 /// example, all the events involved in creating a file are irrelevant if
 /// that file is later deleted.
 #[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash)]
@@ -230,6 +230,15 @@ impl State {
         filter.build_split(writer, reader)
     }
 
+    fn insert_new_sub_events_empty(&mut self) -> SubGroupIndex {
+        let lookup = SubGroupIndex(self.descriptor_seed);
+        self.descriptor_seed += 1;
+
+        self.sub_events.entry(lookup).or_default();
+
+        lookup
+    }
+
     fn insert_new_sub_events(&mut self, event_index: usize) -> SubGroupIndex {
         let lookup = SubGroupIndex(self.descriptor_seed);
         self.descriptor_seed += 1;
@@ -299,6 +308,10 @@ impl State {
         self.stdio_descriptors.clear();
         self.suspect_descriptors.clear();
         self.thread_map.clear();
+        for i in 0..=2 {
+            let lookup = self.insert_new_sub_events_empty();
+            self.stdio_descriptors.insert(i, lookup);
+        }
     }
 }
 
@@ -335,7 +348,7 @@ impl CompactingJournal {
         J: Journal,
     {
         let (tx, rx) = inner.split();
-        let state = State {
+        let mut state = State {
             inner_tx: tx,
             inner_rx: rx.as_restarted()?,
             tty: None,
@@ -364,6 +377,11 @@ impl CompactingJournal {
             delta_list: None,
             event_index: 0,
         };
+        // stdio FDs are always created for a process initially, fill them out here
+        for i in 0..=2 {
+            let lookup = state.insert_new_sub_events_empty();
+            state.stdio_descriptors.insert(i, lookup);
+        }
         Ok(Self {
             tx: CompactingJournalTx {
                 state: Arc::new(Mutex::new(state)),
@@ -506,6 +524,7 @@ impl CompactingJournalTx {
 }
 
 impl WritableJournal for CompactingJournalTx {
+    #[allow(clippy::assigning_clones)]
     fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
         let mut state = self.state.lock().unwrap();
         let event_index = state.event_index;
@@ -545,6 +564,9 @@ impl WritableJournal for CompactingJournalTx {
             }
             JournalEntry::OpenFileDescriptorV1 {
                 fd, o_flags, path, ..
+            }
+            | JournalEntry::OpenFileDescriptorV2 {
+                fd, o_flags, path, ..
             } => {
                 // Creating a file and erasing anything that was there before means
                 // the entire create branch that exists before this one can be ignored
@@ -580,12 +602,6 @@ impl WritableJournal for CompactingJournalTx {
                     state.keep_descriptors.insert(*fd, lookup);
                 }
 
-                // If its stdio then we need to create the descriptor if its not there already
-                if *fd <= 3 && !state.stdio_descriptors.contains_key(fd) {
-                    let lookup = state.insert_new_sub_events(event_index);
-                    state.stdio_descriptors.insert(*fd, lookup);
-                }
-
                 // Update the state
                 if let Some(state) = state
                     .find_sub_events(fd)
@@ -604,18 +620,11 @@ impl WritableJournal for CompactingJournalTx {
                     }
                 }
             }
-            // Seeks to a particular position within
-            JournalEntry::FileDescriptorSeekV1 { fd, .. }
-            | JournalEntry::FileDescriptorSetFlagsV1 { fd, .. } => {
-                // If its stdio then we need to create the descriptor if its not there already
-                if *fd <= 3 && !state.stdio_descriptors.contains_key(fd) {
-                    let lookup = state.insert_new_sub_events(event_index);
-                    state.stdio_descriptors.insert(*fd, lookup);
-                }
-                state.find_sub_events_and_append(fd, event_index);
-            }
             // We keep non-mutable events for file descriptors that are suspect
-            JournalEntry::SocketBindV1 { fd, .. }
+            JournalEntry::FileDescriptorSeekV1 { fd, .. }
+            | JournalEntry::FileDescriptorSetFdFlagsV1 { fd, .. }
+            | JournalEntry::FileDescriptorSetFlagsV1 { fd, .. }
+            | JournalEntry::SocketBindV1 { fd, .. }
             | JournalEntry::SocketSendFileV1 { socket_fd: fd, .. }
             | JournalEntry::SocketSendToV1 { fd, .. }
             | JournalEntry::SocketSendV1 { fd, .. }
@@ -656,39 +665,58 @@ impl WritableJournal for CompactingJournalTx {
             JournalEntry::DuplicateFileDescriptorV1 {
                 original_fd,
                 copied_fd,
+            }
+            | JournalEntry::DuplicateFileDescriptorV2 {
+                original_fd,
+                copied_fd,
+                ..
             } => {
                 if let Some(lookup) = state.suspect_descriptors.get(original_fd).cloned() {
                     state.suspect_descriptors.insert(*copied_fd, lookup);
+                    state.append_to_sub_events(&lookup, event_index);
                 } else if let Some(lookup) = state.keep_descriptors.get(original_fd).cloned() {
                     state.keep_descriptors.insert(*copied_fd, lookup);
+                    state.append_to_sub_events(&lookup, event_index);
                 } else if let Some(lookup) = state.stdio_descriptors.get(original_fd).cloned() {
                     state.stdio_descriptors.insert(*copied_fd, lookup);
+                    state.append_to_sub_events(&lookup, event_index);
                 } else if let Some(lookup) = state.open_pipes.get(original_fd).cloned() {
                     state.open_pipes.insert(*copied_fd, lookup);
+                    state.append_to_sub_events(&lookup, event_index);
                 } else if let Some(lookup) = state.open_sockets.get(original_fd).cloned() {
                     state.open_sockets.insert(*copied_fd, lookup);
+                    state.append_to_sub_events(&lookup, event_index);
                 } else if let Some(lookup) = state.accepted_sockets.get(original_fd).cloned() {
                     state.accepted_sockets.insert(*copied_fd, lookup);
+                    state.append_to_sub_events(&lookup, event_index);
                 } else if let Some(lookup) = state.event_descriptors.get(original_fd).cloned() {
                     state.event_descriptors.insert(*copied_fd, lookup);
+                    state.append_to_sub_events(&lookup, event_index);
                 }
             }
             // Renumbered file descriptors will retain their suspect status
             JournalEntry::RenumberFileDescriptorV1 { old_fd, new_fd } => {
                 if let Some(lookup) = state.suspect_descriptors.remove(old_fd) {
                     state.suspect_descriptors.insert(*new_fd, lookup);
+                    state.append_to_sub_events(&lookup, event_index);
                 } else if let Some(lookup) = state.keep_descriptors.remove(old_fd) {
                     state.keep_descriptors.insert(*new_fd, lookup);
+                    state.append_to_sub_events(&lookup, event_index);
                 } else if let Some(lookup) = state.stdio_descriptors.remove(old_fd) {
                     state.stdio_descriptors.insert(*new_fd, lookup);
+                    state.append_to_sub_events(&lookup, event_index);
                 } else if let Some(lookup) = state.open_pipes.remove(old_fd) {
                     state.open_pipes.insert(*new_fd, lookup);
+                    state.append_to_sub_events(&lookup, event_index);
                 } else if let Some(lookup) = state.open_sockets.remove(old_fd) {
                     state.open_sockets.insert(*new_fd, lookup);
+                    state.append_to_sub_events(&lookup, event_index);
                 } else if let Some(lookup) = state.open_sockets.remove(old_fd) {
                     state.accepted_sockets.insert(*new_fd, lookup);
+                    state.append_to_sub_events(&lookup, event_index);
                 } else if let Some(lookup) = state.event_descriptors.remove(old_fd) {
                     state.event_descriptors.insert(*new_fd, lookup);
+                    state.append_to_sub_events(&lookup, event_index);
                 }
             }
             // Creating a new directory only needs to be done once
@@ -732,10 +760,10 @@ impl WritableJournal for CompactingJournalTx {
                 }
             }
             // Pipes that remain open at the end will be added
-            JournalEntry::CreatePipeV1 { fd1, fd2, .. } => {
+            JournalEntry::CreatePipeV1 { read_fd, write_fd } => {
                 let lookup = state.insert_new_sub_events(event_index);
-                state.open_pipes.insert(*fd1, lookup);
-                state.open_pipes.insert(*fd2, lookup);
+                state.open_pipes.insert(*read_fd, lookup);
+                state.open_pipes.insert(*write_fd, lookup);
             }
             // Epoll events
             JournalEntry::EpollCreateV1 { fd } => {
@@ -756,6 +784,11 @@ impl WritableJournal for CompactingJournalTx {
                 let lookup = state.insert_new_sub_events(event_index);
                 state.open_sockets.insert(*fd, lookup);
             }
+            JournalEntry::SocketPairV1 { fd1, fd2 } => {
+                let lookup = state.insert_new_sub_events(event_index);
+                state.open_sockets.insert(*fd1, lookup);
+                state.open_sockets.insert(*fd2, lookup);
+            }
             JournalEntry::InitModuleV1 { .. } => {
                 state.clear_run_sub_events();
                 state.init_module = Some(event_index);
diff --git a/lib/journal/src/concrete/filter.rs b/lib/journal/src/concrete/filter.rs
index c6412be1e7..17ed9e17b6 100644
--- a/lib/journal/src/concrete/filter.rs
+++ b/lib/journal/src/concrete/filter.rs
@@ -272,11 +272,16 @@ impl<W: WritableJournal> WritableJournal for FilteredJournalTx<W> {
             JournalEntry::FileDescriptorSeekV1 { fd, .. }
             | JournalEntry::FileDescriptorWriteV1 { fd, .. }
             | JournalEntry::OpenFileDescriptorV1 { fd, .. }
+            | JournalEntry::OpenFileDescriptorV2 { fd, .. }
             | JournalEntry::CloseFileDescriptorV1 { fd, .. }
             | JournalEntry::RenumberFileDescriptorV1 { old_fd: fd, .. }
             | JournalEntry::DuplicateFileDescriptorV1 {
                 original_fd: fd, ..
             }
+            | JournalEntry::DuplicateFileDescriptorV2 {
+                original_fd: fd, ..
+            }
+            | JournalEntry::FileDescriptorSetFdFlagsV1 { fd, .. }
             | JournalEntry::FileDescriptorSetFlagsV1 { fd, .. }
             | JournalEntry::FileDescriptorAdviseV1 { fd, .. }
             | JournalEntry::FileDescriptorAllocateV1 { fd, .. }
@@ -335,6 +340,7 @@ impl<W: WritableJournal> WritableJournal for FilteredJournalTx<W> {
             | JournalEntry::PortRouteClearV1
             | JournalEntry::PortRouteDelV1 { .. }
             | JournalEntry::SocketOpenV1 { .. }
+            | JournalEntry::SocketPairV1 { .. }
             | JournalEntry::SocketListenV1 { .. }
             | JournalEntry::SocketBindV1 { .. }
             | JournalEntry::SocketConnectedV1 { .. }
diff --git a/lib/journal/src/concrete/log_file.rs b/lib/journal/src/concrete/log_file.rs
index f309816ecc..d2abd6e664 100644
--- a/lib/journal/src/concrete/log_file.rs
+++ b/lib/journal/src/concrete/log_file.rs
@@ -1,7 +1,13 @@
 use bytes::Buf;
-use rkyv::ser::{
-    serializers::{AllocScratch, CompositeSerializer, SharedSerializeMap, WriteSerializer},
-    Serializer,
+use rkyv::{
+    api::high::HighSerializer,
+    rancor::Strategy,
+    ser::{
+        allocator::{Arena, ArenaHandle},
+        sharing::Share,
+        writer::IoWriter,
+        Positional, Serializer, Writer,
+    },
 };
 use shared_buffer::OwnedBuffer;
 use std::{
@@ -31,10 +37,49 @@ pub struct LogFileJournal {
     rx: LogFileJournalRx,
 }
 
-#[derive(Debug)]
 struct TxState {
+    /// The original handle to the file
+    underlying_file: File,
+
+    /// A modified handle to the original underlying file
     file: File,
-    serializer: CompositeSerializer<WriteSerializer<File>, AllocScratch, SharedSerializeMap>,
+
+    /// The arena necessary for serialization
+    arena: Arena,
+
+    /// The latest position in the file the serializator got to
+    pos: usize,
+}
+
+impl TxState {
+    fn get_serializer(&mut self) -> Serializer<IoWriter<&File>, ArenaHandle<'_>, Share> {
+        self.get_serializer_with_pos(self.pos)
+    }
+
+    fn get_serializer_with_pos(
+        &mut self,
+        pos: usize,
+    ) -> Serializer<IoWriter<&File>, ArenaHandle<'_>, Share> {
+        Serializer::new(
+            IoWriter::with_pos(&self.file, pos),
+            self.arena.acquire(),
+            Share::new(),
+        )
+    }
+
+    fn to_high<'a>(
+        serializer: &'a mut Serializer<IoWriter<&'a File>, ArenaHandle<'a>, Share>,
+    ) -> &'a mut HighSerializer<IoWriter<&'a File>, ArenaHandle<'a>, rkyv::rancor::Error> {
+        Strategy::wrap(serializer)
+    }
+}
+
+impl std::fmt::Debug for TxState {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("TxState")
+            .field("file", &self.underlying_file)
+            .finish()
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -63,7 +108,7 @@ impl LogFileJournalRx {
 impl LogFileJournalTx {
     pub fn as_rx(&self) -> anyhow::Result<LogFileJournalRx> {
         let state = self.state.lock().unwrap();
-        let file = state.file.try_clone()?;
+        let file = state.underlying_file.try_clone()?;
 
         let store = OffloadBackingStore::from_file(&file);
         let buffer = store.owned_buffer();
@@ -101,6 +146,7 @@ impl LogFileJournal {
             .read(true)
             .write(true)
             .create(true)
+            .truncate(false)
             .open(path)?;
         Self::from_file(file)
     }
@@ -123,24 +169,35 @@ impl LogFileJournal {
         // Move to the end of the file and write the
         // magic if one is needed
         let underlying_file = file.try_clone()?;
+        let arena = Arena::new();
+
         let end_pos = file.seek(SeekFrom::End(0))?;
-        let mut serializer = WriteSerializer::with_pos(file, end_pos as usize);
+
+        let mut tx = TxState {
+            underlying_file,
+            arena,
+            file,
+            pos: end_pos as usize,
+        };
+
+        let mut serializer = tx.get_serializer();
+        let serializer = TxState::to_high(&mut serializer);
+
         if serializer.pos() == 0 {
             let magic = JOURNAL_MAGIC_NUMBER;
             let magic = magic.to_be_bytes();
             serializer.write(&magic)?;
         }
 
+        let last_pos = serializer.pos();
+        let _ = serializer;
+
+        tx.arena.shrink();
+        tx.pos = last_pos;
+
         // Create the tx
         let tx = LogFileJournalTx {
-            state: Arc::new(Mutex::new(TxState {
-                file: underlying_file,
-                serializer: CompositeSerializer::new(
-                    serializer,
-                    AllocScratch::default(),
-                    SharedSerializeMap::default(),
-                ),
-            })),
+            state: Arc::new(Mutex::new(tx)),
         };
 
         // First we create the readable journal
@@ -177,27 +234,36 @@ impl WritableJournal for LogFileJournalTx {
 
         // Write the header (with a record size of zero)
         let record_type: JournalEntryRecordType = entry.archive_record_type();
-        let offset_header = state.serializer.pos() as u64;
-        state.serializer.write(&[0u8; 8])?;
+        let mut serializer = state.get_serializer();
+        let serializer = TxState::to_high(&mut serializer);
+        let offset_header = serializer.pos() as u64;
+        tracing::trace!("serpos is {offset_header}");
+        serializer.write(&[0u8; 8])?;
 
         // Now serialize the actual data to the log
-        let offset_start = state.serializer.pos() as u64;
-        entry.serialize_archive(&mut state.serializer)?;
-        let offset_end = state.serializer.pos() as u64;
+        let offset_start = serializer.pos() as u64;
+        entry.serialize_archive(serializer)?;
+        let offset_end = serializer.pos() as u64;
         let record_size = offset_end - offset_start;
         tracing::trace!(
             "delimiter header={offset_header},start={offset_start},record_size={record_size}"
         );
 
+        let last_pos = serializer.pos();
+        let _ = serializer;
+
         // Write the record and then move back to the end again
-        state.file.seek(SeekFrom::Start(offset_header))?;
+        state.underlying_file.seek(SeekFrom::Start(offset_header))?;
         let header_bytes = {
             let a = (record_type as u16).to_be_bytes();
             let b = &record_size.to_be_bytes()[2..8];
             [a[0], a[1], b[0], b[1], b[2], b[3], b[4], b[5]]
         };
-        state.file.write_all(&header_bytes)?;
-        state.file.seek(SeekFrom::Start(offset_end))?;
+        state.underlying_file.write_all(&header_bytes)?;
+        state.underlying_file.seek(SeekFrom::Start(offset_end))?;
+
+        state.arena.shrink();
+        state.pos = last_pos;
 
         // Now write the actual data and update the offsets
         Ok(LogWriteResult {
@@ -208,7 +274,7 @@ impl WritableJournal for LogFileJournalTx {
 
     fn flush(&self) -> anyhow::Result<()> {
         let mut state = self.state.lock().unwrap();
-        state.file.flush()?;
+        state.underlying_file.flush()?;
         Ok(())
     }
 }
@@ -346,7 +412,10 @@ mod tests {
         // Write some events to it
         let journal = LogFileJournal::from_file(file.as_file().try_clone().unwrap()).unwrap();
         journal
-            .write(JournalEntry::CreatePipeV1 { fd1: 1, fd2: 2 })
+            .write(JournalEntry::CreatePipeV1 {
+                read_fd: 1,
+                write_fd: 2,
+            })
             .unwrap();
         journal
             .write(JournalEntry::SetThreadV1 {
@@ -360,6 +429,7 @@ mod tests {
                     stack_lower: 1024,
                     guard_size: 16,
                     stack_size: 1024,
+                    tls_base: None,
                 },
                 start: wasmer_wasix_types::wasix::ThreadStartType::MainThread,
             })
@@ -375,7 +445,13 @@ mod tests {
         let event4 = journal.read().unwrap().map(LogReadResult::into_inner);
 
         // Check the events
-        assert_eq!(event1, Some(JournalEntry::CreatePipeV1 { fd1: 1, fd2: 2 }));
+        assert_eq!(
+            event1,
+            Some(JournalEntry::CreatePipeV1 {
+                read_fd: 1,
+                write_fd: 2
+            })
+        );
         assert_eq!(
             event2,
             Some(JournalEntry::SetThreadV1 {
@@ -389,6 +465,7 @@ mod tests {
                     stack_lower: 1024,
                     guard_size: 16,
                     stack_size: 1024,
+                    tls_base: None,
                 },
                 start: wasmer_wasix_types::wasix::ThreadStartType::MainThread,
             })
@@ -415,8 +492,8 @@ mod tests {
         // Before we read it, we will throw in another event
         journal
             .write(JournalEntry::CreatePipeV1 {
-                fd1: 1234,
-                fd2: 5432,
+                read_fd: 1234,
+                write_fd: 5432,
             })
             .unwrap();
 
@@ -425,7 +502,13 @@ mod tests {
         let event3 = journal.read().unwrap().map(LogReadResult::into_inner);
         let event4 = journal.read().unwrap().map(LogReadResult::into_inner);
         let event5 = journal.read().unwrap().map(LogReadResult::into_inner);
-        assert_eq!(event1, Some(JournalEntry::CreatePipeV1 { fd1: 1, fd2: 2 }));
+        assert_eq!(
+            event1,
+            Some(JournalEntry::CreatePipeV1 {
+                read_fd: 1,
+                write_fd: 2
+            })
+        );
         assert_eq!(
             event2,
             Some(JournalEntry::SetThreadV1 {
@@ -439,6 +522,7 @@ mod tests {
                     stack_lower: 1024,
                     guard_size: 16,
                     stack_size: 1024,
+                    tls_base: None,
                 },
                 start: wasmer_wasix_types::wasix::ThreadStartType::MainThread,
             })
@@ -472,7 +556,13 @@ mod tests {
         tracing::info!("event5 {:?}", event5);
         tracing::info!("event6 {:?}", event6);
 
-        assert_eq!(event1, Some(JournalEntry::CreatePipeV1 { fd1: 1, fd2: 2 }));
+        assert_eq!(
+            event1,
+            Some(JournalEntry::CreatePipeV1 {
+                read_fd: 1,
+                write_fd: 2
+            })
+        );
         assert_eq!(
             event2,
             Some(JournalEntry::SetThreadV1 {
@@ -486,6 +576,7 @@ mod tests {
                     stack_lower: 1024,
                     guard_size: 16,
                     stack_size: 1024,
+                    tls_base: None,
                 },
                 start: wasmer_wasix_types::wasix::ThreadStartType::MainThread,
             })
@@ -503,8 +594,8 @@ mod tests {
         assert_eq!(
             event5,
             Some(JournalEntry::CreatePipeV1 {
-                fd1: 1234,
-                fd2: 5432,
+                read_fd: 1234,
+                write_fd: 5432,
             })
         );
         assert_eq!(event6, None);
diff --git a/lib/journal/src/concrete/mem_file.rs b/lib/journal/src/concrete/mem_file.rs
index 6e19ace60b..6f59220bc9 100644
--- a/lib/journal/src/concrete/mem_file.rs
+++ b/lib/journal/src/concrete/mem_file.rs
@@ -23,6 +23,7 @@ impl MemFileJournal {
             file: RwLock::new(
                 std::fs::OpenOptions::new()
                     .create(true)
+                    .truncate(false)
                     .write(true)
                     .open(path)?,
             ),
diff --git a/lib/journal/src/concrete/printing.rs b/lib/journal/src/concrete/printing.rs
index bea5041c9d..f39f36e757 100644
--- a/lib/journal/src/concrete/printing.rs
+++ b/lib/journal/src/concrete/printing.rs
@@ -42,7 +42,7 @@ impl ReadableJournal for PrintingJournal {
 impl WritableJournal for PrintingJournal {
     fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
         match self.mode {
-            JournalPrintingMode::Text => println!("{}", entry),
+            JournalPrintingMode::Text => println!("{entry}"),
             JournalPrintingMode::Json => {
                 println!("{}", serde_json::to_string_pretty(&entry)?)
             }
@@ -67,11 +67,11 @@ impl Journal for PrintingJournal {
     }
 }
 
-impl<'a> fmt::Display for JournalEntry<'a> {
+impl fmt::Display for JournalEntry<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             JournalEntry::InitModuleV1 { wasm_hash } => {
-                write!(f, "init-module (hash={:x?})", wasm_hash)
+                write!(f, "init-module (hash={wasm_hash:x?})")
             }
             JournalEntry::ClearEtherealV1 => {
                 write!(f, "clear-ethereal")
@@ -90,7 +90,7 @@ impl<'a> fmt::Display for JournalEntry<'a> {
                 compressed_data.len()
             ),
             JournalEntry::ProcessExitV1 { exit_code } => {
-                write!(f, "process-exit (code={:?})", exit_code)
+                write!(f, "process-exit (code={exit_code:?})")
             }
             JournalEntry::SetThreadV1 {
                 id,
@@ -100,149 +100,128 @@ impl<'a> fmt::Display for JournalEntry<'a> {
                 ..
             } => write!(
                 f,
-                "thread-update (id={}, call-stack.len={}, mem-stack.len={}, store-size={}",
+                "thread-update (id={}, call-stack.len={}, mem-stack.len={}, store-size={})",
                 id,
                 call_stack.len(),
                 memory_stack.len(),
                 store_data.len(),
             ),
             JournalEntry::CloseThreadV1 { id, exit_code } => {
-                write!(f, "thread-close (id={}, code={:?})", id, exit_code)
+                write!(f, "thread-close (id={id}, code={exit_code:?})")
             }
-            JournalEntry::FileDescriptorSeekV1 { fd, offset, whence } => write!(
-                f,
-                "fd-seek (fd={}, offset={}, whence={:?})",
-                fd, offset, whence
-            ),
+            JournalEntry::FileDescriptorSeekV1 { fd, offset, whence } => {
+                write!(f, "fd-seek (fd={fd}, offset={offset}, whence={whence:?})")
+            },
             JournalEntry::FileDescriptorWriteV1 {
                 fd, offset, data, ..
-            } => write!(
-                f,
-                "fd-write (fd={}, offset={}, data.len={})",
-                fd,
-                offset,
-                data.len()
-            ),
+            } => write!(f, "fd-write (fd={fd}, offset={offset}, data.len={})", data.len()),
             JournalEntry::SetClockTimeV1 { clock_id, time } => {
-                write!(f, "set-clock-time (id={:?}, time={})", clock_id, time)
+                write!(f, "set-clock-time (id={clock_id:?}, time={time})")
             }
-            JournalEntry::CloseFileDescriptorV1 { fd } => write!(f, "fd-close (fd={})", fd),
+            JournalEntry::CloseFileDescriptorV1 { fd } => write!(f, "fd-close (fd={fd})"),
             JournalEntry::OpenFileDescriptorV1 {
                 fd, path, o_flags, ..
-            } => {
+            }
+            | JournalEntry::OpenFileDescriptorV2 {
+                fd, path, o_flags, ..
+            }=> {
                 if o_flags.contains(wasi::Oflags::CREATE) {
                     if o_flags.contains(wasi::Oflags::TRUNC) {
-                        write!(f, "fd-create-new (fd={}, path={})", fd, path)
+                        write!(f, "fd-create-new (fd={fd}, path={path})")
                     } else if o_flags.contains(wasi::Oflags::EXCL) {
-                        write!(f, "fd-create-excl (fd={}, path={})", fd, path)
+                        write!(f, "fd-create-excl (fd={fd}, path={path})")
                     } else {
-                        write!(f, "fd-create (fd={}, path={})", fd, path)
+                        write!(f, "fd-create (fd={fd}, path={path})")
                     }
                 } else if o_flags.contains(wasi::Oflags::TRUNC) {
-                    write!(f, "fd-open-new (fd={}, path={})", fd, path)
+                    write!(f, "fd-open-new (fd={fd}, path={path})")
                 } else {
-                    write!(f, "fd-open (fd={}, path={})", fd, path)
+                    write!(f, "fd-open (fd={fd}, path={path})")
                 }
             }
             JournalEntry::RenumberFileDescriptorV1 { old_fd, new_fd } => {
-                write!(f, "fd-renumber (old={}, new={})", old_fd, new_fd)
+                write!(f, "fd-renumber (old={old_fd}, new={new_fd})")
             }
             JournalEntry::DuplicateFileDescriptorV1 {
                 original_fd,
                 copied_fd,
-            } => write!(
-                f,
-                "fd-duplicate (original={}, copied={})",
-                original_fd, copied_fd
-            ),
+            } => write!(f, "fd-duplicate (original={original_fd}, copied={copied_fd})"),
+            JournalEntry::DuplicateFileDescriptorV2 {
+                original_fd,
+                copied_fd,
+                cloexec
+            } => write!(f, "fd-duplicate (original={original_fd}, copied={copied_fd}, cloexec={cloexec})"),
             JournalEntry::CreateDirectoryV1 { fd, path } => {
-                write!(f, "path-create-dir (fd={}, path={})", fd, path)
+                write!(f, "path-create-dir (fd={fd}, path={path})")
             }
             JournalEntry::RemoveDirectoryV1 { fd, path } => {
-                write!(f, "path-remove-dir (fd={}, path={})", fd, path)
+                write!(f, "path-remove-dir (fd={fd}, path={path})")
             }
             JournalEntry::PathSetTimesV1 {
                 path,
                 st_atim,
                 st_mtim,
                 ..
-            } => write!(
-                f,
-                "path-set-times (path={}, atime={}, mtime={}))",
-                path, st_atim, st_mtim
-            ),
+            } => write!(f, "path-set-times (path={path}, atime={st_atim}, mtime={st_mtim}))"),
             JournalEntry::FileDescriptorSetTimesV1 {
                 fd,
                 st_atim,
                 st_mtim,
                 ..
-            } => write!(
-                f,
-                "fd-set-times (fd={}, atime={}, mtime={})",
-                fd, st_atim, st_mtim
-            ),
+            } => write!(f, "fd-set-times (fd={fd}, atime={st_atim}, mtime={st_mtim})"),
+            JournalEntry::FileDescriptorSetFdFlagsV1 { fd, flags } => {
+                write!(f, "fd-set-fd-flags (fd={fd}, flags={flags:?})")
+            }
             JournalEntry::FileDescriptorSetFlagsV1 { fd, flags } => {
-                write!(f, "fd-set-flags (fd={}, flags={:?})", fd, flags)
+                write!(f, "fd-set-flags (fd={fd}, flags={flags:?})")
             }
             JournalEntry::FileDescriptorSetRightsV1 {
                 fd,
                 fs_rights_base,
                 fs_rights_inheriting,
-            } => write!(
-                f,
-                "fd-set-rights (fd={}, base={:?}, inherited={:?})",
-                fd, fs_rights_base, fs_rights_inheriting
-            ),
+            } => write!(f, "fd-set-rights (fd={fd}, base={fs_rights_base:?}, inherited={fs_rights_inheriting:?})"),
             JournalEntry::FileDescriptorSetSizeV1 { fd, st_size } => {
-                write!(f, "fd-set-size (fd={}, size={})", fd, st_size)
+                write!(f, "fd-set-size (fd={fd}, size={st_size})")
             }
             JournalEntry::FileDescriptorAdviseV1 {
                 fd, offset, len, ..
-            } => write!(f, "fd-advise (fd={}, offset={}, len={})", fd, offset, len),
+            } => write!(f, "fd-advise (fd={fd}, offset={offset}, len={len})"),
             JournalEntry::FileDescriptorAllocateV1 { fd, offset, len } => {
-                write!(f, "fd-allocate (fd={}, offset={}, len={})", fd, offset, len)
+                write!(f, "fd-allocate (fd={fd}, offset={offset}, len={len})")
             }
             JournalEntry::CreateHardLinkV1 {
                 old_path, new_path, ..
-            } => write!(f, "path-link (from={}, to={})", old_path, new_path),
+            } => write!(f, "path-link (from={old_path}, to={new_path})"),
             JournalEntry::CreateSymbolicLinkV1 {
                 old_path, new_path, ..
-            } => write!(f, "path-symlink (from={}, to={})", old_path, new_path),
-            JournalEntry::UnlinkFileV1 { path, .. } => write!(f, "path-unlink (path={})", path),
+            } => write!(f, "path-symlink (from={old_path}, to={new_path})"),
+            JournalEntry::UnlinkFileV1 { path, .. } => write!(f, "path-unlink (path={path})"),
             JournalEntry::PathRenameV1 {
                 old_path, new_path, ..
-            } => write!(
-                f,
-                "path-rename (old-path={}, new-path={})",
-                old_path, new_path
-            ),
-            JournalEntry::ChangeDirectoryV1 { path } => write!(f, "chdir (path={})", path),
-            JournalEntry::EpollCreateV1 { fd } => write!(f, "epoll-create (fd={})", fd),
+            } => write!(f, "path-rename (old-path={old_path}, new-path={new_path})"),
+            JournalEntry::ChangeDirectoryV1 { path } => write!(f, "chdir (path={path})"),
+            JournalEntry::EpollCreateV1 { fd } => write!(f, "epoll-create (fd={fd})"),
             JournalEntry::EpollCtlV1 { epfd, op, fd, .. } => {
-                write!(f, "epoll-ctl (epfd={}, op={:?}, fd={})", epfd, op, fd)
+                write!(f, "epoll-ctl (epfd={epfd}, op={op:?}, fd={fd})")
             }
-            JournalEntry::TtySetV1 { tty, line_feeds } => write!(
-                f,
-                "tty-set (echo={}, buffering={}, feeds={})",
-                tty.echo, tty.line_buffered, line_feeds
-            ),
-            JournalEntry::CreatePipeV1 { fd1, fd2 } => {
-                write!(f, "fd-pipe (fd1={}, fd2={})", fd1, fd2)
+            JournalEntry::TtySetV1 { tty, line_feeds } => write!(f, "tty-set (echo={}, buffering={}, feeds={})", tty.echo, tty.line_buffered, line_feeds),
+            JournalEntry::CreatePipeV1 { read_fd, write_fd } => {
+                write!(f, "fd-pipe (read_fd={read_fd}, write_fd={write_fd})")
             }
             JournalEntry::CreateEventV1 {
                 initial_val, fd, ..
-            } => write!(f, "fd-event (fd={}, initial={})", fd, initial_val),
+            } => write!(f, "fd-event (fd={fd}, initial={initial_val})"),
             JournalEntry::PortAddAddrV1 { cidr } => {
                 write!(f, "port-addr-add (ip={}, prefix={})", cidr.ip, cidr.prefix)
             }
-            JournalEntry::PortDelAddrV1 { addr } => write!(f, "port-addr-del (addr={})", addr),
+            JournalEntry::PortDelAddrV1 { addr } => write!(f, "port-addr-del (addr={addr})"),
             JournalEntry::PortAddrClearV1 => write!(f, "port-addr-clear"),
             JournalEntry::PortBridgeV1 { network, .. } => {
-                write!(f, "port-bridge (network={})", network)
+                write!(f, "port-bridge (network={network})")
             }
             JournalEntry::PortUnbridgeV1 => write!(f, "port-unbridge"),
             JournalEntry::PortDhcpAcquireV1 => write!(f, "port-dhcp-acquire"),
-            JournalEntry::PortGatewaySetV1 { ip } => write!(f, "port-gateway-set (ip={})", ip),
+            JournalEntry::PortGatewaySetV1 { ip } => write!(f, "port-gateway-set (ip={ip})"),
             JournalEntry::PortRouteAddV1 {
                 cidr, via_router, ..
             } => write!(
@@ -251,30 +230,25 @@ impl<'a> fmt::Display for JournalEntry<'a> {
                 cidr.ip, cidr.prefix, via_router
             ),
             JournalEntry::PortRouteClearV1 => write!(f, "port-route-clear"),
-            JournalEntry::PortRouteDelV1 { ip } => write!(f, "port-route-del (ip={})", ip),
+            JournalEntry::PortRouteDelV1 { ip } => write!(f, "port-route-del (ip={ip})"),
             JournalEntry::SocketOpenV1 { af, ty, pt, fd } => {
-                write!(
-                    f,
-                    "sock-open (fd={}, af={:?}, ty={:?}, pt={:?})",
-                    fd, af, ty, pt
-                )
+                write!(f, "sock-open (fd={fd}, af={af:?}, ty={ty:?}, pt={pt:?})")
+            }
+            JournalEntry::SocketPairV1 { fd1, fd2 } => {
+                write!(f, "sock-pair (fd1={fd1}, fd2={fd2})")
             }
             JournalEntry::SocketListenV1 { fd, backlog } => {
-                write!(f, "sock-listen (fd={}, backlog={})", fd, backlog)
+                write!(f, "sock-listen (fd={fd}, backlog={backlog})")
             }
             JournalEntry::SocketBindV1 { fd, addr } => {
-                write!(f, "sock-bind (fd={}, addr={})", fd, addr)
+                write!(f, "sock-bind (fd={fd}, addr={addr})")
             }
             JournalEntry::SocketConnectedV1 {
                 fd,
                 local_addr,
                 peer_addr,
             } => {
-                write!(
-                    f,
-                    "sock-connect (fd={}, addr={}, peer={})",
-                    fd, local_addr, peer_addr
-                )
+                write!(f, "sock-connect (fd={fd}, addr={local_addr}, peer={peer_addr})")
             }
             JournalEntry::SocketAcceptedV1 {
                 listen_fd,
@@ -282,81 +256,53 @@ impl<'a> fmt::Display for JournalEntry<'a> {
                 local_addr,
                 peer_addr,
                 ..
-            } => write!(
-                f,
-                "sock-accept (listen-fd={}, sock_fd={}, addr={}, peer={})",
-                listen_fd, fd, local_addr, peer_addr
-            ),
+            } => write!(f, "sock-accept (listen-fd={listen_fd}, sock_fd={fd}, addr={local_addr}, peer={peer_addr})"),
             JournalEntry::SocketJoinIpv4MulticastV1 {
                 fd,
                 multiaddr,
                 iface,
-            } => write!(
-                f,
-                "sock-join-mcast-ipv4 (fd={}, addr={}, iface={})",
-                fd, multiaddr, iface
-            ),
+            } => write!(f, "sock-join-mcast-ipv4 (fd={fd}, addr={multiaddr}, iface={iface})"),
             JournalEntry::SocketJoinIpv6MulticastV1 {
                 fd,
                 multi_addr: multiaddr,
                 iface,
-            } => write!(
-                f,
-                "sock-join-mcast-ipv6 (fd={}, addr={}, iface={})",
-                fd, multiaddr, iface
-            ),
+            } => write!(f, "sock-join-mcast-ipv6 (fd={fd}, addr={multiaddr}, iface={iface})"),
             JournalEntry::SocketLeaveIpv4MulticastV1 {
                 fd,
                 multi_addr: multiaddr,
                 iface,
-            } => write!(
-                f,
-                "sock-leave-mcast-ipv4 (fd={}, addr={}, iface={})",
-                fd, multiaddr, iface
-            ),
+            } => write!(f, "sock-leave-mcast-ipv4 (fd={fd}, addr={multiaddr}, iface={iface})"),
             JournalEntry::SocketLeaveIpv6MulticastV1 {
                 fd,
                 multi_addr: multiaddr,
                 iface,
-            } => write!(
-                f,
-                "sock-leave-mcast-ipv6 (fd={}, addr={}, iface={})",
-                fd, multiaddr, iface
-            ),
+            } => write!(f, "sock-leave-mcast-ipv6 (fd={fd}, addr={multiaddr}, iface={iface})"),
             JournalEntry::SocketSendFileV1 {
                 socket_fd,
                 file_fd,
                 offset,
                 count,
-            } => write!(
-                f,
-                "sock-send-file (sock-fd={}, file-fd={}, offset={}, count={})",
-                socket_fd, file_fd, offset, count
-            ),
-            JournalEntry::SocketSendToV1 { fd, data, addr, .. } => write!(
-                f,
-                "sock-send-to (fd={}, data.len={}, addr={})",
-                fd,
-                data.len(),
-                addr
-            ),
+            } => write!(f, "sock-send-file (sock-fd={socket_fd}, file-fd={file_fd}, offset={offset}, count={count})"),
+            JournalEntry::SocketSendToV1 { fd, data, addr, .. } => {
+                write!(f, "sock-send-to (fd={}, data.len={}, addr={})", fd, data.len(), addr)
+            }
             JournalEntry::SocketSendV1 { fd, data, .. } => {
-                write!(f, "sock-send (fd={}, data.len={}", fd, data.len())
+                write!(f, "sock-send (fd={}, data.len={})", fd, data.len())
             }
             JournalEntry::SocketSetOptFlagV1 { fd, opt, flag } => {
-                write!(f, "sock-set-opt (fd={}, opt={:?}, flag={})", fd, opt, flag)
+                write!(f, "sock-set-opt (fd={fd}, opt={opt:?}, flag={flag})")
             }
             JournalEntry::SocketSetOptSizeV1 { fd, opt, size } => {
-                write!(f, "sock-set-opt (fd={}, opt={:?}, size={})", fd, opt, size)
+                write!(f, "sock-set-opt (fd={fd}, opt={opt:?}, size={size})")
             }
             JournalEntry::SocketSetOptTimeV1 { fd, ty, time } => {
-                write!(f, "sock-set-opt (fd={}, opt={:?}, time={:?})", fd, ty, time)
+                write!(f, "sock-set-opt (fd={fd}, opt={ty:?}, time={time:?})")
             }
             JournalEntry::SocketShutdownV1 { fd, how } => {
-                write!(f, "sock-shutdown (fd={}, how={:?})", fd, how)
+                write!(f, "sock-shutdown (fd={fd}, how={how:?})")
             }
             JournalEntry::SnapshotV1 { when, trigger } => {
-                write!(f, "snapshot (when={:?}, trigger={:?})", when, trigger)
+                write!(f, "snapshot (when={when:?}, trigger={trigger:?})")
             }
         }
     }
diff --git a/lib/journal/src/concrete/tests.rs b/lib/journal/src/concrete/tests.rs
index f9d22117c3..a8c6c8c97a 100644
--- a/lib/journal/src/concrete/tests.rs
+++ b/lib/journal/src/concrete/tests.rs
@@ -5,8 +5,14 @@ use std::{
 
 use super::*;
 use lz4_flex::compress_prepend_size;
-use rkyv::ser::serializers::{
-    AllocScratch, CompositeSerializer, SharedSerializeMap, WriteSerializer,
+use rkyv::{
+    api::high::HighSerializer,
+    rancor::Strategy,
+    ser::{
+        allocator::{Arena, ArenaHandle},
+        sharing::Share,
+        Serializer,
+    },
 };
 use wasmer_wasix_types::wasi;
 
@@ -18,14 +24,13 @@ pub fn run_test(record: JournalEntry<'_>) {
     tracing::info!("record_type: {:?}", record_type);
 
     // Serialize it
+    let mut arena = Arena::new();
     let mut buffer = Vec::new();
-    let mut serializer = CompositeSerializer::new(
-        WriteSerializer::new(&mut buffer),
-        AllocScratch::default(),
-        SharedSerializeMap::default(),
-    );
+    let mut serializer = Serializer::new(&mut buffer, arena.acquire(), Share::new());
+    let serializer: &mut HighSerializer<&mut Vec<u8>, ArenaHandle, rkyv::rancor::Error> =
+        Strategy::wrap(&mut serializer);
 
-    record.clone().serialize_archive(&mut serializer).unwrap();
+    record.clone().serialize_archive(serializer).unwrap();
     let buffer = &buffer[..];
     if buffer.len() < 20 {
         tracing::info!("buffer: {:x?}", buffer);
@@ -58,7 +63,7 @@ pub fn test_record_init_module() {
 #[test]
 pub fn test_record_process_exit() {
     run_test(JournalEntry::ProcessExitV1 {
-        exit_code: Some(wasi::ExitCode::Errno(wasi::Errno::Fault)),
+        exit_code: Some(wasi::ExitCode::from(wasi::Errno::Fault)),
     });
 }
 
@@ -76,6 +81,7 @@ pub fn test_record_set_thread() {
             stack_lower: 1024,
             guard_size: 16,
             stack_size: 1024,
+            tls_base: None,
         },
         start: wasmer_wasix_types::wasix::ThreadStartType::MainThread,
     });
@@ -86,7 +92,7 @@ pub fn test_record_set_thread() {
 pub fn test_record_close_thread() {
     run_test(JournalEntry::CloseThreadV1 {
         id: 987u32,
-        exit_code: Some(wasi::ExitCode::Errno(wasi::Errno::Fault)),
+        exit_code: Some(wasi::ExitCode::from(wasi::Errno::Fault)),
     });
 }
 
@@ -355,8 +361,8 @@ pub fn test_record_tty_set() {
 #[test]
 pub fn test_record_create_pipe() {
     run_test(JournalEntry::CreatePipeV1 {
-        fd1: 3452345,
-        fd2: 2345163,
+        read_fd: 3452345,
+        write_fd: 2345163,
     });
 }
 
diff --git a/lib/journal/src/entry.rs b/lib/journal/src/entry.rs
index 6b570cdc3b..9cbd0056d2 100644
--- a/lib/journal/src/entry.rs
+++ b/lib/journal/src/entry.rs
@@ -1,4 +1,3 @@
-use derivative::Derivative;
 use serde::{Deserialize, Serialize};
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
 use std::net::{Shutdown, SocketAddr};
@@ -6,9 +5,9 @@ use std::time::{Duration, SystemTime};
 use std::{borrow::Cow, ops::Range};
 use virtual_net::{IpCidr, StreamSecurity};
 use wasmer_wasix_types::wasi::{
-    Addressfamily, Advice, EpollCtl, EpollEventCtl, EventFdFlags, ExitCode, Fdflags, FileDelta,
-    Filesize, Fstflags, LookupFlags, Oflags, Rights, SiFlags, Snapshot0Clockid, SockProto,
-    Sockoption, Socktype, Timestamp, Tty, Whence,
+    Addressfamily, Advice, EpollCtl, EpollEventCtl, EventFdFlags, ExitCode, Fdflags, Fdflagsext,
+    FileDelta, Filesize, Fstflags, LookupFlags, Oflags, Rights, SiFlags, Snapshot0Clockid,
+    SockProto, Sockoption, Socktype, Timestamp, Tty, Whence,
 };
 use wasmer_wasix_types::wasix::{ThreadStartType, WasiMemoryLayout};
 
@@ -79,8 +78,7 @@ pub enum SocketOptTimeType {
 /// Represents a log entry in a snapshot log stream that represents the total
 /// state of a WASM process at a point in time.
 #[allow(clippy::large_enum_variant)]
-#[derive(Derivative, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[derivative(Debug)]
+#[derive(derive_more::Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum JournalEntry<'a> {
     InitModuleV1 {
@@ -89,7 +87,7 @@ pub enum JournalEntry<'a> {
     ClearEtherealV1,
     UpdateMemoryRegionV1 {
         region: Range<u64>,
-        #[derivative(Debug = "ignore")]
+        #[debug(ignore)]
         #[serde(with = "base64")]
         compressed_data: Cow<'a, [u8]>,
     },
@@ -98,13 +96,13 @@ pub enum JournalEntry<'a> {
     },
     SetThreadV1 {
         id: u32,
-        #[derivative(Debug = "ignore")]
+        #[debug(ignore)]
         #[serde(with = "base64")]
         call_stack: Cow<'a, [u8]>,
-        #[derivative(Debug = "ignore")]
+        #[debug(ignore)]
         #[serde(with = "base64")]
         memory_stack: Cow<'a, [u8]>,
-        #[derivative(Debug = "ignore")]
+        #[debug(ignore)]
         #[serde(with = "base64")]
         store_data: Cow<'a, [u8]>,
         start: ThreadStartType,
@@ -123,7 +121,7 @@ pub enum JournalEntry<'a> {
     FileDescriptorWriteV1 {
         fd: Fd,
         offset: u64,
-        #[derivative(Debug = "ignore")]
+        #[debug(ignore)]
         #[serde(with = "base64")]
         data: Cow<'a, [u8]>,
         is_64bit: bool,
@@ -141,12 +139,25 @@ pub enum JournalEntry<'a> {
         dirflags: LookupFlags,
         path: Cow<'a, str>,
         o_flags: Oflags,
-        #[derivative(Debug = "ignore")]
+        #[debug(ignore)]
         fs_rights_base: Rights,
-        #[derivative(Debug = "ignore")]
+        #[debug(ignore)]
         fs_rights_inheriting: Rights,
         fs_flags: Fdflags,
     },
+    OpenFileDescriptorV2 {
+        fd: Fd,
+        dirfd: Fd,
+        dirflags: LookupFlags,
+        path: Cow<'a, str>,
+        o_flags: Oflags,
+        #[debug(ignore)]
+        fs_rights_base: Rights,
+        #[debug(ignore)]
+        fs_rights_inheriting: Rights,
+        fs_flags: Fdflags,
+        fd_flags: Fdflagsext,
+    },
     RenumberFileDescriptorV1 {
         old_fd: Fd,
         new_fd: Fd,
@@ -155,6 +166,11 @@ pub enum JournalEntry<'a> {
         original_fd: Fd,
         copied_fd: Fd,
     },
+    DuplicateFileDescriptorV2 {
+        original_fd: Fd,
+        copied_fd: Fd,
+        cloexec: bool,
+    },
     CreateDirectoryV1 {
         fd: Fd,
         path: Cow<'a, str>,
@@ -177,6 +193,10 @@ pub enum JournalEntry<'a> {
         st_mtim: Timestamp,
         fst_flags: Fstflags,
     },
+    FileDescriptorSetFdFlagsV1 {
+        fd: Fd,
+        flags: Fdflagsext,
+    },
     FileDescriptorSetFlagsV1 {
         fd: Fd,
         flags: Fdflags,
@@ -240,8 +260,8 @@ pub enum JournalEntry<'a> {
         line_feeds: bool,
     },
     CreatePipeV1 {
-        fd1: Fd,
-        fd2: Fd,
+        read_fd: Fd,
+        write_fd: Fd,
     },
     CreateEventV1 {
         initial_val: u64,
@@ -281,6 +301,10 @@ pub enum JournalEntry<'a> {
         pt: SockProto,
         fd: Fd,
     },
+    SocketPairV1 {
+        fd1: Fd,
+        fd2: Fd,
+    },
     SocketListenV1 {
         fd: Fd,
         backlog: u32,
@@ -330,7 +354,7 @@ pub enum JournalEntry<'a> {
     },
     SocketSendToV1 {
         fd: Fd,
-        #[derivative(Debug = "ignore")]
+        #[debug(ignore)]
         #[serde(with = "base64")]
         data: Cow<'a, [u8]>,
         flags: SiFlags,
@@ -339,7 +363,7 @@ pub enum JournalEntry<'a> {
     },
     SocketSendV1 {
         fd: Fd,
-        #[derivative(Debug = "ignore")]
+        #[debug(ignore)]
         #[serde(with = "base64")]
         data: Cow<'a, [u8]>,
         flags: SiFlags,
@@ -371,7 +395,7 @@ pub enum JournalEntry<'a> {
     },
 }
 
-impl<'a> JournalEntry<'a> {
+impl JournalEntry<'_> {
     pub fn into_owned(self) -> JournalEntry<'static> {
         match self {
             Self::InitModuleV1 { wasm_hash } => JournalEntry::InitModuleV1 { wasm_hash },
@@ -439,6 +463,27 @@ impl<'a> JournalEntry<'a> {
                 fs_rights_inheriting,
                 fs_flags,
             },
+            Self::OpenFileDescriptorV2 {
+                fd,
+                dirfd,
+                dirflags,
+                path,
+                o_flags,
+                fs_rights_base,
+                fs_rights_inheriting,
+                fs_flags,
+                fd_flags,
+            } => JournalEntry::OpenFileDescriptorV2 {
+                fd,
+                dirfd,
+                dirflags,
+                path: path.into_owned().into(),
+                o_flags,
+                fs_rights_base,
+                fs_rights_inheriting,
+                fs_flags,
+                fd_flags,
+            },
             Self::RenumberFileDescriptorV1 { old_fd, new_fd } => {
                 JournalEntry::RenumberFileDescriptorV1 { old_fd, new_fd }
             }
@@ -449,6 +494,15 @@ impl<'a> JournalEntry<'a> {
                 original_fd,
                 copied_fd,
             },
+            Self::DuplicateFileDescriptorV2 {
+                original_fd,
+                copied_fd,
+                cloexec,
+            } => JournalEntry::DuplicateFileDescriptorV2 {
+                original_fd,
+                copied_fd,
+                cloexec,
+            },
             Self::CreateDirectoryV1 { fd, path } => JournalEntry::CreateDirectoryV1 {
                 fd,
                 path: path.into_owned().into(),
@@ -483,6 +537,9 @@ impl<'a> JournalEntry<'a> {
                 st_mtim,
                 fst_flags,
             },
+            Self::FileDescriptorSetFdFlagsV1 { fd, flags } => {
+                JournalEntry::FileDescriptorSetFdFlagsV1 { fd, flags }
+            }
             Self::FileDescriptorSetFlagsV1 { fd, flags } => {
                 JournalEntry::FileDescriptorSetFlagsV1 { fd, flags }
             }
@@ -565,7 +622,9 @@ impl<'a> JournalEntry<'a> {
                 event,
             },
             Self::TtySetV1 { tty, line_feeds } => JournalEntry::TtySetV1 { tty, line_feeds },
-            Self::CreatePipeV1 { fd1, fd2 } => JournalEntry::CreatePipeV1 { fd1, fd2 },
+            Self::CreatePipeV1 { read_fd, write_fd } => {
+                JournalEntry::CreatePipeV1 { read_fd, write_fd }
+            }
             Self::CreateEventV1 {
                 initial_val,
                 flags,
@@ -604,6 +663,7 @@ impl<'a> JournalEntry<'a> {
             Self::PortRouteClearV1 => JournalEntry::PortRouteClearV1,
             Self::PortRouteDelV1 { ip } => JournalEntry::PortRouteDelV1 { ip },
             Self::SocketOpenV1 { af, ty, pt, fd } => JournalEntry::SocketOpenV1 { af, ty, pt, fd },
+            Self::SocketPairV1 { fd1, fd2 } => JournalEntry::SocketPairV1 { fd1, fd2 },
             Self::SocketListenV1 { fd, backlog } => JournalEntry::SocketListenV1 { fd, backlog },
             Self::SocketBindV1 { fd, addr } => JournalEntry::SocketBindV1 { fd, addr },
             Self::SocketConnectedV1 {
@@ -735,13 +795,16 @@ impl<'a> JournalEntry<'a> {
             JournalEntry::FileDescriptorWriteV1 { data, .. } => base_size + data.len(),
             JournalEntry::SetClockTimeV1 { .. } => base_size,
             JournalEntry::CloseFileDescriptorV1 { .. } => base_size,
-            JournalEntry::OpenFileDescriptorV1 { path, .. } => base_size + path.as_bytes().len(),
+            JournalEntry::OpenFileDescriptorV1 { path, .. } => base_size + path.len(),
+            JournalEntry::OpenFileDescriptorV2 { path, .. } => base_size + path.len(),
             JournalEntry::RenumberFileDescriptorV1 { .. } => base_size,
             JournalEntry::DuplicateFileDescriptorV1 { .. } => base_size,
-            JournalEntry::CreateDirectoryV1 { path, .. } => base_size + path.as_bytes().len(),
-            JournalEntry::RemoveDirectoryV1 { path, .. } => base_size + path.as_bytes().len(),
-            JournalEntry::PathSetTimesV1 { path, .. } => base_size + path.as_bytes().len(),
+            JournalEntry::DuplicateFileDescriptorV2 { .. } => base_size,
+            JournalEntry::CreateDirectoryV1 { path, .. } => base_size + path.len(),
+            JournalEntry::RemoveDirectoryV1 { path, .. } => base_size + path.len(),
+            JournalEntry::PathSetTimesV1 { path, .. } => base_size + path.len(),
             JournalEntry::FileDescriptorSetTimesV1 { .. } => base_size,
+            JournalEntry::FileDescriptorSetFdFlagsV1 { .. } => base_size,
             JournalEntry::FileDescriptorSetFlagsV1 { .. } => base_size,
             JournalEntry::FileDescriptorSetRightsV1 { .. } => base_size,
             JournalEntry::FileDescriptorSetSizeV1 { .. } => base_size,
@@ -749,15 +812,15 @@ impl<'a> JournalEntry<'a> {
             JournalEntry::FileDescriptorAllocateV1 { .. } => base_size,
             JournalEntry::CreateHardLinkV1 {
                 old_path, new_path, ..
-            } => base_size + old_path.as_bytes().len() + new_path.as_bytes().len(),
+            } => base_size + old_path.len() + new_path.len(),
             JournalEntry::CreateSymbolicLinkV1 {
                 old_path, new_path, ..
-            } => base_size + old_path.as_bytes().len() + new_path.as_bytes().len(),
-            JournalEntry::UnlinkFileV1 { path, .. } => base_size + path.as_bytes().len(),
+            } => base_size + old_path.len() + new_path.len(),
+            JournalEntry::UnlinkFileV1 { path, .. } => base_size + path.len(),
             JournalEntry::PathRenameV1 {
                 old_path, new_path, ..
-            } => base_size + old_path.as_bytes().len() + new_path.as_bytes().len(),
-            JournalEntry::ChangeDirectoryV1 { path } => base_size + path.as_bytes().len(),
+            } => base_size + old_path.len() + new_path.len(),
+            JournalEntry::ChangeDirectoryV1 { path } => base_size + path.len(),
             JournalEntry::EpollCreateV1 { .. } => base_size,
             JournalEntry::EpollCtlV1 { .. } => base_size,
             JournalEntry::TtySetV1 { .. } => base_size,
@@ -767,7 +830,7 @@ impl<'a> JournalEntry<'a> {
             JournalEntry::PortDelAddrV1 { .. } => base_size,
             JournalEntry::PortAddrClearV1 => base_size,
             JournalEntry::PortBridgeV1 { network, token, .. } => {
-                base_size + network.as_bytes().len() + token.as_bytes().len()
+                base_size + network.len() + token.len()
             }
             JournalEntry::PortUnbridgeV1 => base_size,
             JournalEntry::PortDhcpAcquireV1 => base_size,
@@ -776,6 +839,7 @@ impl<'a> JournalEntry<'a> {
             JournalEntry::PortRouteClearV1 => base_size,
             JournalEntry::PortRouteDelV1 { .. } => base_size,
             JournalEntry::SocketOpenV1 { .. } => base_size,
+            JournalEntry::SocketPairV1 { .. } => base_size,
             JournalEntry::SocketListenV1 { .. } => base_size,
             JournalEntry::SocketBindV1 { .. } => base_size,
             JournalEntry::SocketConnectedV1 { .. } => base_size,
diff --git a/lib/journal/src/lib.rs b/lib/journal/src/lib.rs
index 478945eec2..de470563b3 100644
--- a/lib/journal/src/lib.rs
+++ b/lib/journal/src/lib.rs
@@ -95,7 +95,9 @@ pub trait ReadableJournal: std::fmt::Debug {
 /// a WASM process at a point in time and saves it so that it can be restored.
 /// It also allows for the restoration of that state at a later moment
 #[allow(unused_variables)]
-pub trait Journal: WritableJournal + ReadableJournal + std::fmt::Debug {
+pub trait Journal:
+    WritableJournal + ReadableJournal + AsDynReadableJournal + std::fmt::Debug
+{
     /// Splits the journal into a read and write side
     fn split(self) -> (Box<DynWritableJournal>, Box<DynReadableJournal>);
 }
@@ -103,3 +105,14 @@ pub trait Journal: WritableJournal + ReadableJournal + std::fmt::Debug {
 pub type DynJournal = dyn Journal + Send + Sync;
 pub type DynWritableJournal = dyn WritableJournal + Send + Sync;
 pub type DynReadableJournal = dyn ReadableJournal + Send + Sync;
+
+/// A bit of manual up-casting support
+pub trait AsDynReadableJournal {
+    fn as_dyn_readable_journal(&self) -> &DynReadableJournal;
+}
+
+impl<T: Journal + Send + Sync + 'static> AsDynReadableJournal for T {
+    fn as_dyn_readable_journal(&self) -> &DynReadableJournal {
+        self
+    }
+}
diff --git a/lib/journal/src/snapshot.rs b/lib/journal/src/snapshot.rs
index 787101db3b..3a1446badc 100644
--- a/lib/journal/src/snapshot.rs
+++ b/lib/journal/src/snapshot.rs
@@ -1,8 +1,12 @@
+use std::fmt::Display;
+
+use wasmer_config::app::SnapshotTrigger as ConfigSnapshotTrigger;
+
 use super::*;
 
 /// Various triggers that will cause the runtime to take snapshot
 /// of the WASM state and store it in the snapshot file.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum SnapshotTrigger {
     /// Triggered when all the threads in the process goes idle
     Idle,
@@ -30,44 +34,106 @@ pub enum SnapshotTrigger {
     Bootstrap,
     /// Transaction
     Transaction,
+    /// Explicitly requested by the guest module
+    Explicit,
 }
 
 impl SnapshotTrigger {
     pub fn only_once(&self) -> bool {
         matches!(
             self,
-            Self::FirstListen | Self::FirstEnviron | Self::FirstStdin | Self::FirstSigint
+            Self::FirstListen
+                | Self::FirstEnviron
+                | Self::FirstStdin
+                | Self::FirstSigint
+                // TODO: I don't think this should be an only_once trigger, but
+                // repeatable triggers currently get stuck in a loop
+                | Self::Explicit
         )
     }
 }
 
-pub const DEFAULT_SNAPSHOT_TRIGGERS: [SnapshotTrigger; 4] = [
+pub const DEFAULT_SNAPSHOT_TRIGGERS: [SnapshotTrigger; 5] = [
     SnapshotTrigger::Idle,
     SnapshotTrigger::FirstEnviron,
     SnapshotTrigger::FirstListen,
     SnapshotTrigger::FirstStdin,
+    SnapshotTrigger::Explicit,
 ];
 
+// We're purposefully redirecting serialization-related functionality for SnapshotTrigger
+// through the equivalent type in wasmer_config (ConfigSnapshotTrigger) to make sure the
+// two types always stay in sync.
+impl From<ConfigSnapshotTrigger> for SnapshotTrigger {
+    fn from(value: ConfigSnapshotTrigger) -> Self {
+        match value {
+            ConfigSnapshotTrigger::Bootstrap => Self::Bootstrap,
+            ConfigSnapshotTrigger::Explicit => Self::Explicit,
+            ConfigSnapshotTrigger::FirstEnviron => Self::FirstEnviron,
+            ConfigSnapshotTrigger::FirstListen => Self::FirstListen,
+            ConfigSnapshotTrigger::FirstSigint => Self::FirstSigint,
+            ConfigSnapshotTrigger::FirstStdin => Self::FirstStdin,
+            ConfigSnapshotTrigger::Idle => Self::Idle,
+            ConfigSnapshotTrigger::NonDeterministicCall => Self::NonDeterministicCall,
+            ConfigSnapshotTrigger::PeriodicInterval => Self::PeriodicInterval,
+            ConfigSnapshotTrigger::Sigalrm => Self::Sigalrm,
+            ConfigSnapshotTrigger::Sigint => Self::Sigint,
+            ConfigSnapshotTrigger::Sigstop => Self::Sigstop,
+            ConfigSnapshotTrigger::Sigtstp => Self::Sigtstp,
+            ConfigSnapshotTrigger::Transaction => Self::Transaction,
+        }
+    }
+}
+
+impl From<SnapshotTrigger> for ConfigSnapshotTrigger {
+    fn from(value: SnapshotTrigger) -> Self {
+        match value {
+            SnapshotTrigger::Bootstrap => Self::Bootstrap,
+            SnapshotTrigger::Explicit => Self::Explicit,
+            SnapshotTrigger::FirstEnviron => Self::FirstEnviron,
+            SnapshotTrigger::FirstListen => Self::FirstListen,
+            SnapshotTrigger::FirstSigint => Self::FirstSigint,
+            SnapshotTrigger::FirstStdin => Self::FirstStdin,
+            SnapshotTrigger::Idle => Self::Idle,
+            SnapshotTrigger::NonDeterministicCall => Self::NonDeterministicCall,
+            SnapshotTrigger::PeriodicInterval => Self::PeriodicInterval,
+            SnapshotTrigger::Sigalrm => Self::Sigalrm,
+            SnapshotTrigger::Sigint => Self::Sigint,
+            SnapshotTrigger::Sigstop => Self::Sigstop,
+            SnapshotTrigger::Sigtstp => Self::Sigtstp,
+            SnapshotTrigger::Transaction => Self::Transaction,
+        }
+    }
+}
+
 impl FromStr for SnapshotTrigger {
-    type Err = anyhow::Error;
+    type Err = <ConfigSnapshotTrigger as FromStr>::Err;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        <ConfigSnapshotTrigger as FromStr>::from_str(s).map(Into::into)
+    }
+}
+
+impl Display for SnapshotTrigger {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        <ConfigSnapshotTrigger as Display>::fmt(&(*self).into(), f)
+    }
+}
+
+impl Serialize for SnapshotTrigger {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        ConfigSnapshotTrigger::from(*self).serialize(serializer)
+    }
+}
 
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        let s = s.trim().to_lowercase();
-        Ok(match s.as_str() {
-            "idle" => Self::Idle,
-            "first-listen" => Self::FirstListen,
-            "first-stdin" => Self::FirstStdin,
-            "first-environ" => Self::FirstEnviron,
-            "first-intr" | "first-sigint" | "first-ctrlc" | "first-ctrl-c" => Self::FirstSigint,
-            "periodic-interval" => Self::PeriodicInterval,
-            "intr" | "sigint" | "ctrlc" | "ctrl-c" => Self::Sigint,
-            "alarm" | "timer" | "sigalrm" => Self::Sigalrm,
-            "sigtstp" | "ctrlz" | "ctrl-z" => Self::Sigtstp,
-            "stop" | "sigstop" => Self::Sigstop,
-            "non-deterministic-call" => Self::NonDeterministicCall,
-            "bootstrap" => Self::Bootstrap,
-            "transaction" => Self::Transaction,
-            a => return Err(anyhow::format_err!("invalid or unknown trigger ({a})")),
-        })
+impl<'de> Deserialize<'de> for SnapshotTrigger {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        <ConfigSnapshotTrigger as Deserialize>::deserialize(deserializer).map(Into::into)
     }
 }
diff --git a/lib/middlewares/Cargo.toml b/lib/middlewares/Cargo.toml
index 7f31f09aac..bf67387479 100644
--- a/lib/middlewares/Cargo.toml
+++ b/lib/middlewares/Cargo.toml
@@ -13,12 +13,18 @@ rust-version.workspace = true
 version.workspace = true
 
 [dependencies]
-wasmer = { path = "../api", version = "=4.3.7", default-features = false, features = ["compiler"] }
-wasmer-types = { path = "../types", version = "=4.3.7" }
-wasmer-vm = { path = "../vm", version = "=4.3.7" }
+wasmer = { path = "../api", version = "=6.1.0", default-features = false, features = [
+	"compiler",
+	"wasmparser",
+] }
+wasmer-types = { path = "../types", version = "=6.1.0" }
+wasmer-vm = { path = "../vm", version = "=6.1.0" }
 
 [dev-dependencies]
-wasmer = { path = "../api", version = "=4.3.7", features = ["compiler"] }
+wasmer = { path = "../api", version = "=6.1.0", features = [
+	"compiler",
+	"wasmparser",
+] }
 
 [badges]
 maintenance = { status = "actively-developed" }
diff --git a/lib/middlewares/src/metering.rs b/lib/middlewares/src/metering.rs
index d374f21cf7..d77b08bc87 100644
--- a/lib/middlewares/src/metering.rs
+++ b/lib/middlewares/src/metering.rs
@@ -13,8 +13,9 @@ use std::fmt;
 use std::sync::{Arc, Mutex};
 use wasmer::wasmparser::{BlockType as WpTypeOrFuncType, Operator};
 use wasmer::{
-    AsStoreMut, ExportIndex, FunctionMiddleware, GlobalInit, GlobalType, Instance,
-    LocalFunctionIndex, MiddlewareError, MiddlewareReaderState, ModuleMiddleware, Mutability, Type,
+    sys::{FunctionMiddleware, MiddlewareError, MiddlewareReaderState, ModuleMiddleware},
+    AsStoreMut, ExportIndex, GlobalInit, GlobalType, Instance, LocalFunctionIndex, Mutability,
+    Type,
 };
 use wasmer_types::{GlobalIndex, ModuleInfo};
 
@@ -59,7 +60,7 @@ impl fmt::Debug for MeteringGlobalIndexes {
 ///
 /// ```rust
 /// use std::sync::Arc;
-/// use wasmer::{wasmparser::Operator, CompilerConfig};
+/// use wasmer::{wasmparser::Operator, sys::CompilerConfig};
 /// use wasmer_middlewares::Metering;
 ///
 /// fn create_metering_middleware(compiler_config: &mut dyn CompilerConfig) {
@@ -124,6 +125,10 @@ pub enum MeteringPoints {
 
 impl<F: Fn(&Operator) -> u64 + Send + Sync> Metering<F> {
     /// Creates a `Metering` middleware.
+    ///
+    /// When providing a cost function, you should consider that branching operations do
+    /// additional work to track the metering points and probably need to have a higher cost.
+    /// To find out which operations are affected by this, you can call [`is_accounting`].
     pub fn new(initial_limit: u64, cost_function: F) -> Self {
         Self {
             initial_limit,
@@ -201,6 +206,42 @@ impl<F: Fn(&Operator) -> u64 + Send + Sync + 'static> ModuleMiddleware for Meter
     }
 }
 
+/// Returns `true` if and only if the given operator is an accounting operator.
+/// Accounting operators do additional work to track the metering points.
+pub fn is_accounting(operator: &Operator) -> bool {
+    // Possible sources and targets of a branch.
+    matches!(
+        operator,
+        Operator::Loop { .. } // loop headers are branch targets
+            | Operator::End // block ends are branch targets
+            | Operator::If { .. } // branch source, "if" can branch to else branch
+            | Operator::Else // "else" is the "end" of an if branch
+            | Operator::Br { .. } // branch source
+            | Operator::BrTable { .. } // branch source
+            | Operator::BrIf { .. } // branch source
+            | Operator::Call { .. } // function call - branch source
+            | Operator::CallIndirect { .. } // function call - branch source
+            | Operator::Return // end of function - branch source
+            // exceptions proposal
+            | Operator::Throw { .. } // branch source
+            | Operator::ThrowRef // branch source
+            | Operator::Rethrow { .. } // branch source
+            | Operator::Delegate { .. } // branch source
+            | Operator::Catch { .. } // branch target
+            // tail_call proposal
+            | Operator::ReturnCall { .. } // branch source
+            | Operator::ReturnCallIndirect { .. } // branch source
+            // gc proposal
+            | Operator::BrOnCast { .. } // branch source
+            | Operator::BrOnCastFail { .. } // branch source
+            // function_references proposal
+            | Operator::CallRef { .. } // branch source
+            | Operator::ReturnCallRef { .. } // branch source
+            | Operator::BrOnNull { .. } // branch source
+            | Operator::BrOnNonNull { .. } // branch source
+    )
+}
+
 impl<F: Fn(&Operator) -> u64 + Send + Sync> fmt::Debug for FunctionMetering<F> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("FunctionMetering")
@@ -221,41 +262,40 @@ impl<'a, F: Fn(&Operator) -> u64 + Send + Sync> FunctionMiddleware<'a> for Funct
         // corner cases.
         self.accumulated_cost += (self.cost_function)(&operator);
 
-        // Possible sources and targets of a branch. Finalize the cost of the previous basic block and perform necessary checks.
-        match operator {
-            Operator::Loop { .. } // loop headers are branch targets
-            | Operator::End // block ends are branch targets
-            | Operator::Else // "else" is the "end" of an if branch
-            | Operator::Br { .. } // branch source
-            | Operator::BrTable { .. } // branch source
-            | Operator::BrIf { .. } // branch source
-            | Operator::Call { .. } // function call - branch source
-            | Operator::CallIndirect { .. } // function call - branch source
-            | Operator::Return // end of function - branch source
-            => {
-                if self.accumulated_cost > 0 {
-                    state.extend(&[
-                        // if unsigned(globals[remaining_points_index]) < unsigned(self.accumulated_cost) { throw(); }
-                        Operator::GlobalGet { global_index: self.global_indexes.remaining_points().as_u32() },
-                        Operator::I64Const { value: self.accumulated_cost as i64 },
-                        Operator::I64LtU,
-                        Operator::If { blockty: WpTypeOrFuncType::Empty },
-                        Operator::I32Const { value: 1 },
-                        Operator::GlobalSet { global_index: self.global_indexes.points_exhausted().as_u32() },
-                        Operator::Unreachable,
-                        Operator::End,
-
-                        // globals[remaining_points_index] -= self.accumulated_cost;
-                        Operator::GlobalGet { global_index: self.global_indexes.remaining_points().as_u32() },
-                        Operator::I64Const { value: self.accumulated_cost as i64 },
-                        Operator::I64Sub,
-                        Operator::GlobalSet { global_index: self.global_indexes.remaining_points().as_u32() },
-                    ]);
-
-                    self.accumulated_cost = 0;
-                }
-            }
-            _ => {}
+        // Finalize the cost of the previous basic block and perform necessary checks.
+        if is_accounting(&operator) && self.accumulated_cost > 0 {
+            state.extend(&[
+                // if unsigned(globals[remaining_points_index]) < unsigned(self.accumulated_cost) { throw(); }
+                Operator::GlobalGet {
+                    global_index: self.global_indexes.remaining_points().as_u32(),
+                },
+                Operator::I64Const {
+                    value: self.accumulated_cost as i64,
+                },
+                Operator::I64LtU,
+                Operator::If {
+                    blockty: WpTypeOrFuncType::Empty,
+                },
+                Operator::I32Const { value: 1 },
+                Operator::GlobalSet {
+                    global_index: self.global_indexes.points_exhausted().as_u32(),
+                },
+                Operator::Unreachable,
+                Operator::End,
+                // globals[remaining_points_index] -= self.accumulated_cost;
+                Operator::GlobalGet {
+                    global_index: self.global_indexes.remaining_points().as_u32(),
+                },
+                Operator::I64Const {
+                    value: self.accumulated_cost as i64,
+                },
+                Operator::I64Sub,
+                Operator::GlobalSet {
+                    global_index: self.global_indexes.remaining_points().as_u32(),
+                },
+            ]);
+
+            self.accumulated_cost = 0;
         }
         state.push_operator(operator);
 
@@ -359,7 +399,11 @@ mod tests {
 
     use std::sync::Arc;
     use wasmer::sys::EngineBuilder;
-    use wasmer::{imports, wat2wasm, CompilerConfig, Cranelift, Module, Store, TypedFunction};
+    use wasmer::{
+        imports,
+        sys::{CompilerConfig, Cranelift},
+        wat2wasm, Module, Store, TypedFunction,
+    };
 
     fn cost_function(operator: &Operator) -> u64 {
         match operator {
diff --git a/lib/object/Cargo.toml b/lib/object/Cargo.toml
deleted file mode 100644
index 676ed2968c..0000000000
--- a/lib/object/Cargo.toml
+++ /dev/null
@@ -1,21 +0,0 @@
-[package]
-name = "wasmer-object"
-description = "Wasmer Native Object generator"
-categories = ["wasm"]
-keywords = ["wasm", "webassembly"]
-readme = "README.md"
-authors.workspace = true
-edition.workspace = true
-homepage.workspace = true
-license.workspace = true
-repository.workspace = true
-rust-version.workspace = true
-version.workspace = true
-
-[dependencies]
-wasmer-types = { path = "../types", version = "=4.3.7" }
-object = { version = "0.29.0", default-features = false, features = ["write"] }
-thiserror = "1.0"
-
-[package.metadata.docs.rs]
-rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/object/README.md b/lib/object/README.md
deleted file mode 100644
index 273a2cb2cc..0000000000
--- a/lib/object/README.md
+++ /dev/null
@@ -1,10 +0,0 @@
-# `wasmer-object` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE)
-
-The Wasmer Native Object crate aims at cross-generating native objects
-for various platforms.
-
-Given a compilation result, i.e. the result
-of `wasmer_compiler::Compiler::compile_module`, this crate exposes
-functions to create an `Object` file for a given target. It is a
-useful thin layer on top of [the `object`
-crate](https://github.com/gimli-rs/object).
diff --git a/lib/package/Cargo.toml b/lib/package/Cargo.toml
new file mode 100644
index 0000000000..3fd4199944
--- /dev/null
+++ b/lib/package/Cargo.toml
@@ -0,0 +1,45 @@
+[package]
+name = "wasmer-package"
+version = "0.601.0"
+description = "Packaging related types and functions for Wasmer"
+
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+webc.workspace = true
+wasmer-config = { version = "0.601.0", path = "../config" }
+wasmer-types = { version = "6.1.0", path = "../types", features = ["detect-wasm-features"] }
+toml.workspace = true
+bytes.workspace = true
+sha2.workspace = true
+shared-buffer.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+anyhow.workspace = true
+thiserror.workspace = true
+cfg-if.workspace = true
+ciborium.workspace = true
+semver.workspace = true
+url.workspace = true
+insta = { version = "1", features = ["filters", "yaml"] }
+flate2.workspace = true
+tar.workspace = true
+tempfile.workspace = true
+ignore.workspace = true
+
+[target.'cfg(all(target_family = "wasm", target_os = "wasi"))'.dependencies]
+libc.workspace = true
+
+[dev-dependencies]
+pretty_assertions.workspace = true
+tempfile.workspace = true
+regex = "1.11.0"
+ureq = "2.10.1"
+hexdump = "0.1.2"
diff --git a/lib/package/src/convert/error.rs b/lib/package/src/convert/error.rs
new file mode 100644
index 0000000000..5efe29fe82
--- /dev/null
+++ b/lib/package/src/convert/error.rs
@@ -0,0 +1,47 @@
+use std::sync::Arc;
+
+#[derive(Clone, Debug)]
+pub struct ConversionError {
+    message: String,
+    cause: Option<Arc<dyn std::error::Error + Send + Sync>>,
+}
+
+impl ConversionError {
+    pub fn msg(msg: impl Into<String>) -> Self {
+        Self {
+            message: msg.into(),
+            cause: None,
+        }
+    }
+
+    pub fn with_cause(
+        msg: impl Into<String>,
+        cause: impl std::error::Error + Send + Sync + 'static,
+    ) -> Self {
+        Self {
+            message: msg.into(),
+            cause: Some(Arc::new(cause)),
+        }
+    }
+}
+
+impl std::fmt::Display for ConversionError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "could not convert manifest: {}", self.message)?;
+        if let Some(cause) = &self.cause {
+            write!(f, " (cause: {cause})")?;
+        }
+
+        Ok(())
+    }
+}
+
+impl std::error::Error for ConversionError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        if let Some(e) = &self.cause {
+            Some(e)
+        } else {
+            None
+        }
+    }
+}
diff --git a/lib/package/src/convert/mod.rs b/lib/package/src/convert/mod.rs
new file mode 100644
index 0000000000..ca75e1a1b6
--- /dev/null
+++ b/lib/package/src/convert/mod.rs
@@ -0,0 +1,4 @@
+mod error;
+mod webc_to_package;
+
+pub use self::{error::ConversionError, webc_to_package::webc_to_package_dir};
diff --git a/lib/package/src/convert/webc_to_package.rs b/lib/package/src/convert/webc_to_package.rs
new file mode 100644
index 0000000000..81dea85b90
--- /dev/null
+++ b/lib/package/src/convert/webc_to_package.rs
@@ -0,0 +1,355 @@
+use std::path::Path;
+
+use wasmer_config::package::{ModuleReference, SuggestedCompilerOptimizations, UserAnnotations};
+
+use webc::Container;
+
+use super::ConversionError;
+
+/// Convert a webc image into a directory with a wasmer.toml file that can
+/// be used for generating a new pacakge.
+pub fn webc_to_package_dir(webc: &Container, target_dir: &Path) -> Result<(), ConversionError> {
+    let mut pkg_manifest = wasmer_config::package::Manifest::new_empty();
+
+    let manifest = webc.manifest();
+    // Convert the package annotation.
+
+    let pkg_annotation = manifest
+        .wapm()
+        .map_err(|err| ConversionError::msg(format!("could not read package annotation: {err}")))?;
+    if let Some(ann) = pkg_annotation {
+        let mut pkg = wasmer_config::package::Package::new_empty();
+
+        pkg.name = ann.name;
+        pkg.version = if let Some(raw) = ann.version {
+            let v = raw
+                .parse()
+                .map_err(|e| ConversionError::with_cause("invalid package version", e))?;
+            Some(v)
+        } else {
+            None
+        };
+
+        pkg.description = ann.description;
+        pkg.license = ann.license;
+
+        // TODO: map license_file and README (paths!)
+
+        pkg.homepage = ann.homepage;
+        pkg.repository = ann.repository;
+        pkg.private = ann.private;
+        pkg.entrypoint = manifest.entrypoint.clone();
+
+        pkg_manifest.package = Some(pkg);
+    }
+
+    // Map dependencies.
+    for (_name, target) in &manifest.use_map {
+        match target {
+            webc::metadata::UrlOrManifest::Url(_url) => {
+                // Not supported.
+            }
+            webc::metadata::UrlOrManifest::Manifest(_) => {
+                // Not supported.
+            }
+            webc::metadata::UrlOrManifest::RegistryDependentUrl(raw) => {
+                let (name, version) = if let Some((name, version_raw)) = raw.split_once('@') {
+                    let version = version_raw.parse().map_err(|err| {
+                        ConversionError::with_cause(
+                            format!("Could not parse version of dependency: '{raw}'"),
+                            err,
+                        )
+                    })?;
+                    (name.to_string(), version)
+                } else {
+                    (raw.to_string(), "*".parse().unwrap())
+                };
+
+                pkg_manifest.dependencies.insert(name, version);
+            }
+        }
+    }
+
+    // Convert filesystem mappings.
+
+    let fs_annotation = manifest
+        .filesystem()
+        .map_err(|err| ConversionError::msg(format!("could not read fs annotation: {err}")))?;
+    if let Some(ann) = fs_annotation {
+        for mapping in ann.0 {
+            if mapping.from.is_some() {
+                // wasmer.toml does not allow specifying dependency mounts.
+                continue;
+            }
+
+            // Extract the volume to "<target-dir>/<volume-name>".
+            let volume = webc.get_volume(&mapping.volume_name).ok_or_else(|| {
+                ConversionError::msg(format!(
+                    "Package annotations specify a volume that does not exist: '{}'",
+                    mapping.volume_name
+                ))
+            })?;
+
+            let volume_path = target_dir.join(mapping.volume_name.trim_start_matches('/'));
+
+            std::fs::create_dir_all(&volume_path).map_err(|err| {
+                ConversionError::with_cause(
+                    format!(
+                        "could not create volume directory '{}'",
+                        volume_path.display()
+                    ),
+                    err,
+                )
+            })?;
+
+            volume.unpack("/", &volume_path).map_err(|err| {
+                ConversionError::with_cause("could not unpack volume to filesystemt", err)
+            })?;
+
+            let mut source_path = mapping
+                .volume_name
+                .trim_start_matches('/')
+                .trim_end_matches('/')
+                .to_string();
+            if let Some(subpath) = mapping.host_path {
+                if !source_path.ends_with('/') {
+                    source_path.push('/');
+                }
+                source_path.push_str(&subpath);
+            }
+            source_path.insert_str(0, "./");
+
+            pkg_manifest
+                .fs
+                .insert(mapping.mount_path, source_path.into());
+        }
+    }
+
+    // Convert modules.
+
+    let module_dir_name = "modules";
+    let module_dir = target_dir.join(module_dir_name);
+
+    let atoms = webc.atoms();
+    if !atoms.is_empty() {
+        std::fs::create_dir_all(&module_dir).map_err(|err| {
+            ConversionError::with_cause(
+                format!("Could not create directory '{}'", module_dir.display()),
+                err,
+            )
+        })?;
+        for (atom_name, data) in atoms {
+            let atom_path = module_dir.join(&atom_name);
+
+            std::fs::write(&atom_path, &data).map_err(|err| {
+                ConversionError::with_cause(
+                    format!("Could not write atom to path '{}'", atom_path.display()),
+                    err,
+                )
+            })?;
+
+            let relative_path = format!("./{module_dir_name}/{atom_name}");
+
+            let mut annotations = None;
+
+            if let Some(manifest_atom) = manifest.atoms.get(&atom_name) {
+                if let Some(sco) = manifest_atom
+                    .annotations
+                    .get(SuggestedCompilerOptimizations::KEY)
+                {
+                    if let Some((_, v)) = sco.as_map().and_then(|v| {
+                        v.iter().find(|(k, _)| {
+                            k.as_text().is_some_and(|v| {
+                                v == SuggestedCompilerOptimizations::PASS_PARAMS_KEY
+                            })
+                        })
+                    }) {
+                        annotations = Some(UserAnnotations {
+                            suggested_compiler_optimizations: SuggestedCompilerOptimizations {
+                                pass_params: Some(v.as_bool().unwrap_or_default()),
+                            },
+                        });
+                    }
+                }
+            }
+
+            pkg_manifest.modules.push(wasmer_config::package::Module {
+                name: atom_name,
+                source: relative_path.into(),
+                abi: wasmer_config::package::Abi::None,
+                kind: None,
+                interfaces: None,
+                bindings: None,
+                annotations,
+            });
+        }
+    }
+
+    // Convert commands.
+    for (name, spec) in &manifest.commands {
+        let mut annotations = toml::Table::new();
+        for (key, value) in &spec.annotations {
+            if key == webc::metadata::annotations::Atom::KEY {
+                continue;
+            }
+
+            let raw_toml = toml::to_string(&value).unwrap();
+            let toml_value = toml::from_str::<toml::Value>(&raw_toml).unwrap();
+            annotations.insert(key.into(), toml_value);
+        }
+
+        let atom_annotation = spec
+            .annotation::<webc::metadata::annotations::Atom>(webc::metadata::annotations::Atom::KEY)
+            .map_err(|err| {
+                ConversionError::msg(format!(
+                    "could not read atom annotation for command '{name}': {err}"
+                ))
+            })?
+            .ok_or_else(|| {
+                ConversionError::msg(format!(
+                    "Command '{name}' is missing the required atom annotation"
+                ))
+            })?;
+
+        let module = if let Some(dep) = atom_annotation.dependency {
+            ModuleReference::Dependency {
+                dependency: dep,
+                module: atom_annotation.name,
+            }
+        } else {
+            ModuleReference::CurrentPackage {
+                module: atom_annotation.name,
+            }
+        };
+
+        let cmd = wasmer_config::package::Command::V2(wasmer_config::package::CommandV2 {
+            name: name.clone(),
+            module,
+            runner: spec.runner.clone(),
+            annotations: Some(wasmer_config::package::CommandAnnotations::Raw(
+                annotations.into(),
+            )),
+        });
+
+        pkg_manifest.commands.push(cmd);
+    }
+
+    // Write out the manifest.
+    let manifest_toml = toml::to_string(&pkg_manifest)
+        .map_err(|err| ConversionError::with_cause("could not serialize package manifest", err))?;
+    std::fs::write(target_dir.join("wasmer.toml"), manifest_toml)
+        .map_err(|err| ConversionError::with_cause("could not write wasmer.toml", err))?;
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use std::fs::create_dir_all;
+
+    use pretty_assertions::assert_eq;
+
+    use crate::{package::Package, utils::from_bytes};
+
+    use super::*;
+
+    // Build a webc from a pacakge directory, and then restore the directory
+    // from the webc.
+    #[test]
+    fn test_wasmer_package_webc_roundtrip() {
+        let tmpdir = tempfile::tempdir().unwrap();
+        let dir = tmpdir.path();
+
+        let webc = {
+            let dir_input = dir.join("input");
+            let dir_public = dir_input.join("public");
+
+            create_dir_all(&dir_public).unwrap();
+
+            std::fs::write(dir_public.join("index.html"), "INDEX").unwrap();
+
+            std::fs::write(dir_input.join("mywasm.wasm"), "()").unwrap();
+
+            std::fs::write(
+                dir_input.join("wasmer.toml"),
+                r#"
+[package]
+name = "testns/testpkg"
+version = "0.0.1"
+description = "descr1"
+license = "MIT"
+
+[dependencies]
+"wasmer/python" = "8.12.0"
+
+[fs]
+public = "./public"
+
+[[module]]
+name = "mywasm"
+source = "./mywasm.wasm"
+
+[[command]]
+name = "run"
+module = "mywasm"
+runner = "wasi"
+
+[command.annotations.wasi]
+env =  ["A=B"]
+main-args = ["/mounted/script.py"]
+"#,
+            )
+            .unwrap();
+
+            let pkg = Package::from_manifest(dir_input.join("wasmer.toml")).unwrap();
+            let raw = pkg.serialize().unwrap();
+            from_bytes(raw).unwrap()
+        };
+
+        let dir_output = dir.join("output");
+        webc_to_package_dir(&webc, &dir_output).unwrap();
+
+        assert_eq!(
+            std::fs::read_to_string(dir_output.join("public/index.html")).unwrap(),
+            "INDEX",
+        );
+
+        assert_eq!(
+            std::fs::read_to_string(dir_output.join("modules/mywasm")).unwrap(),
+            "()",
+        );
+
+        assert_eq!(
+            std::fs::read_to_string(dir_output.join("wasmer.toml"))
+                .unwrap()
+                .trim(),
+            r#"
+
+[package]
+license = "MIT"
+entrypoint = "run"
+
+[dependencies]
+"wasmer/python" = "^8.12.0"
+
+[fs]
+"/public" = "./public"
+
+[[module]]
+name = "mywasm"
+source = "./modules/mywasm"
+
+[[command]]
+name = "run"
+module = "mywasm"
+runner = "https://webc.org/runner/wasi"
+
+[command.annotations.wasi]
+atom = "mywasm"
+env = ["A=B"]
+main-args = ["/mounted/script.py"]
+            "#
+            .trim(),
+        );
+    }
+}
diff --git a/lib/package/src/lib.rs b/lib/package/src/lib.rs
new file mode 100644
index 0000000000..2d4ab3b197
--- /dev/null
+++ b/lib/package/src/lib.rs
@@ -0,0 +1,7 @@
+#[macro_use]
+#[cfg(test)]
+mod macros;
+
+pub mod convert;
+pub mod package;
+pub mod utils;
diff --git a/lib/package/src/macros.rs b/lib/package/src/macros.rs
new file mode 100644
index 0000000000..cfdb764c0c
--- /dev/null
+++ b/lib/package/src/macros.rs
@@ -0,0 +1,129 @@
+//! Macros and abstractions used during testing.
+
+use bytes::{Bytes, BytesMut};
+
+use webc::Version;
+
+/// Construct a sequence of bytes using one or more items that implement the
+/// [`ToBytes`] trait.
+macro_rules! bytes {
+    ($($item:expr),* $(,)?) => {
+        {
+            #[allow(unused_mut)]
+            let mut buffer: ::bytes::BytesMut = ::bytes::BytesMut::new();
+            $(
+                #[allow(clippy::identity_op)]
+                $crate::macros::ToBytes::to_bytes(&$item, &mut buffer);
+            )*
+            buffer.freeze()
+        }
+    };
+}
+
+/// Write something to a byte buffer.
+pub(crate) trait ToBytes {
+    fn to_bytes(&self, buffer: &mut BytesMut);
+}
+
+impl ToBytes for webc::v3::Tag {
+    fn to_bytes(&self, buffer: &mut BytesMut) {
+        self.as_u8().to_bytes(buffer);
+    }
+}
+
+impl ToBytes for webc::v3::Timestamps {
+    fn to_bytes(&self, buffer: &mut BytesMut) {
+        // TODO: This impl is used in the bytes macro. This macro
+        // is not public, so this unwrap should be fine for now.
+        // But a better solution will make `ToBytes` fallible.
+        self.write_to(buffer).unwrap()
+    }
+}
+
+impl ToBytes for [u8] {
+    fn to_bytes(&self, buffer: &mut BytesMut) {
+        buffer.extend_from_slice(self);
+    }
+}
+
+impl<const N: usize> ToBytes for [u8; N] {
+    fn to_bytes(&self, buffer: &mut BytesMut) {
+        buffer.extend_from_slice(self);
+    }
+}
+
+impl ToBytes for str {
+    fn to_bytes(&self, buffer: &mut BytesMut) {
+        self.as_bytes().to_bytes(buffer);
+    }
+}
+
+impl<T: ToBytes + ?Sized> ToBytes for &T {
+    fn to_bytes(&self, buffer: &mut BytesMut) {
+        (**self).to_bytes(buffer);
+    }
+}
+
+impl ToBytes for u8 {
+    fn to_bytes(&self, buffer: &mut BytesMut) {
+        [*self].to_bytes(buffer);
+    }
+}
+
+impl ToBytes for Vec<u8> {
+    fn to_bytes(&self, buffer: &mut BytesMut) {
+        self.as_slice().to_bytes(buffer);
+    }
+}
+
+impl ToBytes for Bytes {
+    fn to_bytes(&self, buffer: &mut BytesMut) {
+        self.as_ref().to_bytes(buffer);
+    }
+}
+
+impl ToBytes for Version {
+    fn to_bytes(&self, buffer: &mut BytesMut) {
+        self.0.to_bytes(buffer);
+    }
+}
+
+impl ToBytes for BytesMut {
+    fn to_bytes(&self, buffer: &mut BytesMut) {
+        self.as_ref().to_bytes(buffer);
+    }
+}
+
+macro_rules! impl_to_bytes_le {
+    ($( $type:ty ),* $(,)?) => {
+        $(
+            impl ToBytes for $type {
+                fn to_bytes(&self, buffer: &mut BytesMut) {
+                    self.to_le_bytes().to_bytes(buffer);
+                }
+            }
+        )*
+    };
+}
+
+impl_to_bytes_le!(u16, u32);
+
+macro_rules! assert_bytes_eq {
+    ($lhs:expr, $rhs:expr, $msg:literal $( $tokens:tt)*) => {{
+        let lhs = &$lhs[..];
+        let rhs = &$rhs[..];
+        if lhs != rhs {
+            let lhs: Vec<_> = hexdump::hexdump_iter(lhs)
+                .map(|line| line.to_string())
+                .collect();
+            let rhs: Vec<_> = hexdump::hexdump_iter(rhs)
+                .map(|line| line.to_string())
+                .collect::<Vec<_>>();
+
+            pretty_assertions::assert_eq!(lhs.join("\n"), rhs.join("\n"), $msg $($tokens)*);
+        }
+    }};
+    ($lhs:expr, $rhs:expr) => {
+        assert_bytes_eq!($lhs, $rhs, "{} != {}", stringify!($lhs), stringify!($rhs));
+    };
+}
diff --git a/lib/package/src/package/manifest.rs b/lib/package/src/package/manifest.rs
new file mode 100644
index 0000000000..e716e46332
--- /dev/null
+++ b/lib/package/src/package/manifest.rs
@@ -0,0 +1,1430 @@
+use std::{
+    collections::BTreeMap,
+    path::{Path, PathBuf},
+};
+
+use ciborium::{cbor, Value};
+use semver::VersionReq;
+use sha2::Digest;
+use shared_buffer::{MmapError, OwnedBuffer};
+use url::Url;
+#[allow(deprecated)]
+use wasmer_config::package::{CommandV1, CommandV2, Manifest as WasmerManifest, Package};
+use wasmer_config::package::{SuggestedCompilerOptimizations, UserAnnotations};
+use webc::{
+    indexmap::{self, IndexMap},
+    metadata::AtomSignature,
+    sanitize_path,
+};
+
+use crate::utils::features_to_wasm_annotations;
+
+use webc::metadata::{
+    annotations::{
+        Atom as AtomAnnotation, FileSystemMapping, FileSystemMappings, VolumeSpecificPath, Wapm,
+        Wasi,
+    },
+    Atom, Binding, Command, Manifest as WebcManifest, UrlOrManifest, WaiBindings, WitBindings,
+};
+
+use super::{FsVolume, Strictness};
+
+const METADATA_VOLUME: &str = FsVolume::METADATA;
+
+/// Errors that may occur when converting from a [`wasmer_config::package::Manifest`] to
+/// a [`crate::metadata::Manifest`].
+#[derive(Debug, thiserror::Error)]
+#[non_exhaustive]
+pub enum ManifestError {
+    /// A dependency specification had a syntax error.
+    #[error("The dependency, \"{_0}\", isn't in the \"namespace/name\" format")]
+    InvalidDependency(String),
+    /// Unable to serialize an annotation.
+    #[error("Unable to serialize the \"{key}\" annotation")]
+    SerializeCborAnnotation {
+        /// Which annotation was being serialized?
+        key: String,
+        /// The underlying error.
+        #[source]
+        error: ciborium::value::Error,
+    },
+    /// Specified an unknown atom kind.
+    #[error("Unknown atom kind, \"{_0}\"")]
+    UnknownAtomKind(String),
+    /// A module was specified more than once.
+    #[error("Duplicate module, \"{_0}\"")]
+    DuplicateModule(String),
+    /// Unable to read a module's `source`.
+    #[error("Unable to read the \"{module}\" module's file from \"{}\"", path.display())]
+    ReadAtomFile {
+        /// The name of the module.
+        module: String,
+        /// The path that was read.
+        path: PathBuf,
+        /// The underlying error.
+        #[source]
+        error: std::io::Error,
+    },
+    /// A command was specified more than once.
+    #[error("Duplicate command, \"{_0}\"")]
+    DuplicateCommand(String),
+    /// An unknown runner kind was specified.
+    #[error("Unknown runner kind, \"{_0}\"")]
+    UnknownRunnerKind(String),
+    /// An error occurred while merging user-defined annotations in with
+    /// automatically generated ones.
+    #[error("Unable to merge in user-defined \"{key}\" annotations for the \"{command}\" command")]
+    #[non_exhaustive]
+    MergeAnnotations {
+        /// The command annotations were being merged for.
+        command: String,
+        /// The annotation that was being merged.
+        key: String,
+    },
+    /// A command uses a non-existent module.
+    #[error("The \"{command}\" command uses a non-existent module, \"{module}\"")]
+    InvalidModuleReference {
+        /// The command name.
+        command: String,
+        /// The module name.
+        module: String,
+    },
+    /// A command references a module from an undeclared dependency.
+    #[error("The \"{command}\" command references the undeclared dependency \"{dependency}\"")]
+    UndeclaredCommandDependency {
+        /// The command name.
+        command: String,
+        /// The dependency name.
+        dependency: String,
+    },
+    /// Unable to deserialize custom annotations from the `wasmer.toml`
+    /// manifest.
+    #[error("Unable to deserialize custom annotations from the wasmer.toml manifest")]
+    WasmerTomlAnnotations {
+        /// The underlying error.
+        #[source]
+        error: Box<dyn std::error::Error + Send + Sync>,
+    },
+    /// The `wasmer.toml` file references a file outside of its base directory.
+    #[error("\"{}\" is outside of \"{}\"", path.display(), base_dir.display())]
+    OutsideBaseDirectory {
+        /// The file that was referenced.
+        path: PathBuf,
+        /// The base directory.
+        base_dir: PathBuf,
+    },
+    /// The manifest references a file that doesn't exist.
+    #[error("The \"{}\" doesn't exist (base dir: {})", path.display(), base_dir.display())]
+    MissingFile {
+        /// The file that was referenced.
+        path: PathBuf,
+        /// The base directory.
+        base_dir: PathBuf,
+    },
+    /// File based commands are not supported for in-memory package creation
+    #[error("File based commands are not supported for in-memory package creation")]
+    FileNotSupported,
+}
+
+/// take a `wasmer.toml` manifest and convert it to the `*.webc` equivalent.
+pub(crate) fn wasmer_manifest_to_webc(
+    manifest: &WasmerManifest,
+    base_dir: &Path,
+    strictness: Strictness,
+) -> Result<(WebcManifest, BTreeMap<String, OwnedBuffer>), ManifestError> {
+    let use_map = transform_dependencies(&manifest.dependencies)?;
+
+    // Note: We need to clone the [fs] table because the wasmer-toml crate has
+    // already upgraded to indexmap v2.0, but the webc crate needs to stay at
+    // 1.9.2 for backwards compatibility reasons.
+    let fs: IndexMap<String, PathBuf> = manifest.fs.clone().into_iter().collect();
+
+    let package =
+        transform_package_annotations(manifest.package.as_ref(), &fs, base_dir, strictness)?;
+    let (atoms, atom_files) = transform_atoms(manifest, base_dir)?;
+    let commands = transform_commands(manifest, base_dir)?;
+    let bindings = transform_bindings(manifest, base_dir)?;
+
+    let manifest = WebcManifest {
+        origin: None,
+        use_map,
+        package,
+        atoms,
+        commands,
+        bindings,
+        entrypoint: entrypoint(manifest),
+    };
+
+    Ok((manifest, atom_files))
+}
+
+/// take a `wasmer.toml` manifest and convert it to the `*.webc` equivalent.
+pub(crate) fn in_memory_wasmer_manifest_to_webc(
+    manifest: &WasmerManifest,
+    atoms: &BTreeMap<String, (Option<String>, OwnedBuffer, Option<&UserAnnotations>)>,
+) -> Result<(WebcManifest, BTreeMap<String, OwnedBuffer>), ManifestError> {
+    let use_map = transform_dependencies(&manifest.dependencies)?;
+
+    // Note: We need to clone the [fs] table because the wasmer-toml crate has
+    // already upgraded to indexmap v2.0, but the webc crate needs to stay at
+    // 1.9.2 for backwards compatibility reasons.
+    let fs: IndexMap<String, PathBuf> = manifest.fs.clone().into_iter().collect();
+
+    let package = transform_in_memory_package_annotations(manifest.package.as_ref(), &fs)?;
+    let (atoms, atom_files) = transform_in_memory_atoms(atoms)?;
+    let commands = transform_in_memory_commands(manifest)?;
+    let bindings = transform_in_memory_bindings(manifest)?;
+
+    let manifest = WebcManifest {
+        origin: None,
+        use_map,
+        package,
+        atoms,
+        commands,
+        bindings,
+        entrypoint: entrypoint(manifest),
+    };
+
+    Ok((manifest, atom_files))
+}
+
+fn transform_package_annotations(
+    package: Option<&wasmer_config::package::Package>,
+    fs: &IndexMap<String, PathBuf>,
+    base_dir: &Path,
+    strictness: Strictness,
+) -> Result<IndexMap<String, Value>, ManifestError> {
+    transform_package_annotations_shared(package, fs, |package| {
+        transform_package_meta_to_annotations(package, base_dir, strictness)
+    })
+}
+
+fn transform_in_memory_package_annotations(
+    package: Option<&wasmer_config::package::Package>,
+    fs: &IndexMap<String, PathBuf>,
+) -> Result<IndexMap<String, Value>, ManifestError> {
+    transform_package_annotations_shared(package, fs, |package| {
+        transform_in_memory_package_meta_to_annotations(package)
+    })
+}
+
+fn transform_package_annotations_shared(
+    package: Option<&wasmer_config::package::Package>,
+    fs: &IndexMap<String, PathBuf>,
+    transform_package_meta_to_annotations: impl Fn(&Package) -> Result<Wapm, ManifestError>,
+) -> Result<IndexMap<String, Value>, ManifestError> {
+    let mut annotations = IndexMap::new();
+
+    if let Some(wasmer_package) = package {
+        let wapm = transform_package_meta_to_annotations(wasmer_package)?;
+        insert_annotation(&mut annotations, Wapm::KEY, wapm)?;
+    }
+
+    let fs = get_fs_table(fs);
+
+    if !fs.is_empty() {
+        insert_annotation(&mut annotations, FileSystemMappings::KEY, fs)?;
+    }
+
+    Ok(annotations)
+}
+
+fn transform_dependencies(
+    original_dependencies: &IndexMap<String, VersionReq>,
+) -> Result<IndexMap<String, UrlOrManifest>, ManifestError> {
+    let mut dependencies = IndexMap::new();
+
+    for (dep, version) in original_dependencies {
+        let (namespace, package_name) = extract_dependency_parts(dep)
+            .ok_or_else(|| ManifestError::InvalidDependency(dep.clone()))?;
+
+        // Note: the wasmer.toml format forces you to go through a registry for
+        // all dependencies. There's no way to specify a URL-based dependency.
+        let dependency_specifier =
+            UrlOrManifest::RegistryDependentUrl(format!("{namespace}/{package_name}@{version}"));
+
+        dependencies.insert(dep.clone(), dependency_specifier);
+    }
+
+    Ok(dependencies)
+}
+
+fn extract_dependency_parts(dep: &str) -> Option<(&str, &str)> {
+    let (namespace, package_name) = dep.split_once('/')?;
+
+    fn invalid_char(c: char) -> bool {
+        !matches!(c, 'a'..='z' | 'A'..='Z' | '_' | '-' | '0'..='9')
+    }
+
+    if namespace.contains(invalid_char) || package_name.contains(invalid_char) {
+        None
+    } else {
+        Some((namespace, package_name))
+    }
+}
+
+type Atoms = BTreeMap<String, OwnedBuffer>;
+
+fn transform_atoms(
+    manifest: &WasmerManifest,
+    base_dir: &Path,
+) -> Result<(IndexMap<String, Atom>, Atoms), ManifestError> {
+    let mut atom_entries = BTreeMap::new();
+
+    for module in &manifest.modules {
+        let name = &module.name;
+        let path = base_dir.join(&module.source);
+        let file = open_file(&path).map_err(|error| ManifestError::ReadAtomFile {
+            module: name.clone(),
+            path,
+            error,
+        })?;
+
+        atom_entries.insert(
+            name.clone(),
+            (module.kind.clone(), file, module.annotations.as_ref()),
+        );
+    }
+
+    transform_atoms_shared(&atom_entries)
+}
+
+fn transform_in_memory_atoms(
+    atoms: &BTreeMap<String, (Option<String>, OwnedBuffer, Option<&UserAnnotations>)>,
+) -> Result<(IndexMap<String, Atom>, Atoms), ManifestError> {
+    transform_atoms_shared(atoms)
+}
+
+fn transform_atoms_shared(
+    atoms: &BTreeMap<String, (Option<String>, OwnedBuffer, Option<&UserAnnotations>)>,
+) -> Result<(IndexMap<String, Atom>, Atoms), ManifestError> {
+    let mut atom_files = BTreeMap::new();
+    let mut metadata = IndexMap::new();
+
+    for (name, (kind, content, misc_annotations)) in atoms.iter() {
+        // Create atom with annotations including Wasm features if available
+        let mut annotations = IndexMap::new();
+        if let Some(misc_annotations) = misc_annotations {
+            if let Some(pass_params) = misc_annotations
+                .suggested_compiler_optimizations
+                .pass_params
+            {
+                annotations.insert(
+                    SuggestedCompilerOptimizations::KEY.to_string(),
+                    cbor!({"pass_params" => pass_params}).unwrap(),
+                );
+            }
+        }
+
+        // Detect required WebAssembly features by analyzing the module binary
+        let features_result = wasmer_types::Features::detect_from_wasm(content);
+
+        if let Ok(features) = features_result {
+            // Convert wasmer_types::Features to webc::metadata::annotations::Wasm
+            let feature_strings = features_to_wasm_annotations(&features);
+
+            // Only create annotation if we detected features
+            if !feature_strings.is_empty() {
+                let wasm = webc::metadata::annotations::Wasm::new(feature_strings);
+                match ciborium::value::Value::serialized(&wasm) {
+                    Ok(wasm_value) => {
+                        annotations.insert(
+                            webc::metadata::annotations::Wasm::KEY.to_string(),
+                            wasm_value,
+                        );
+                    }
+                    Err(e) => {
+                        eprintln!("Failed to serialize wasm features: {e}");
+                    }
+                }
+            }
+        }
+
+        let atom = Atom {
+            kind: atom_kind(kind.as_ref().map(|s| s.as_str()))?,
+            signature: atom_signature(content),
+            annotations,
+        };
+
+        if metadata.contains_key(name) {
+            return Err(ManifestError::DuplicateModule(name.clone()));
+        }
+
+        metadata.insert(name.clone(), atom);
+        atom_files.insert(name.clone(), content.clone());
+    }
+
+    Ok((metadata, atom_files))
+}
+
+fn atom_signature(atom: &[u8]) -> String {
+    let hash: [u8; 32] = sha2::Sha256::digest(atom).into();
+    AtomSignature::Sha256(hash).to_string()
+}
+
+/// Map the "kind" field in a `[module]` to the corresponding URI.
+fn atom_kind(kind: Option<&str>) -> Result<Url, ManifestError> {
+    const WASM_ATOM_KIND: &str = "https://webc.org/kind/wasm";
+    const TENSORFLOW_SAVED_MODEL_KIND: &str = "https://webc.org/kind/tensorflow-SavedModel";
+
+    let url = match kind {
+        Some("wasm") | None => WASM_ATOM_KIND.parse().expect("Should never fail"),
+        Some("tensorflow-SavedModel") => TENSORFLOW_SAVED_MODEL_KIND
+            .parse()
+            .expect("Should never fail"),
+        Some(other) => {
+            if let Ok(url) = Url::parse(other) {
+                // if it is a valid URL, pass that through as-is
+                url
+            } else {
+                return Err(ManifestError::UnknownAtomKind(other.to_string()));
+            }
+        }
+    };
+
+    Ok(url)
+}
+
+/// Try to open a file, preferring mmap and falling back to [`std::fs::read()`]
+/// if mapping fails.
+fn open_file(path: &Path) -> Result<OwnedBuffer, std::io::Error> {
+    match OwnedBuffer::mmap(path) {
+        Ok(b) => return Ok(b),
+        Err(MmapError::Map(_)) => {
+            // Unable to mmap the atom file. Falling back to std::fs::read()
+        }
+        Err(MmapError::FileOpen { error, .. }) => {
+            return Err(error);
+        }
+    }
+
+    let bytes = std::fs::read(path)?;
+
+    Ok(OwnedBuffer::from_bytes(bytes))
+}
+
+fn insert_annotation(
+    annotations: &mut IndexMap<String, ciborium::Value>,
+    key: impl Into<String>,
+    value: impl serde::Serialize,
+) -> Result<(), ManifestError> {
+    let key = key.into();
+
+    match ciborium::value::Value::serialized(&value) {
+        Ok(value) => {
+            annotations.insert(key, value);
+            Ok(())
+        }
+        Err(error) => Err(ManifestError::SerializeCborAnnotation { key, error }),
+    }
+}
+
+fn get_fs_table(fs: &IndexMap<String, PathBuf>) -> FileSystemMappings {
+    if fs.is_empty() {
+        return FileSystemMappings::default();
+    }
+
+    // When wapm-targz-to-pirita creates the final webc all files will be
+    // merged into one "atom" volume, but we want to map each directory
+    // separately.
+    let mut entries = Vec::new();
+    for (guest, host) in fs {
+        let volume_name = host
+            .to_str()
+            .expect("failed to convert path to string")
+            .to_string();
+
+        let volume_name = sanitize_path(volume_name);
+
+        let mapping = FileSystemMapping {
+            from: None,
+            volume_name,
+            host_path: None,
+            mount_path: sanitize_path(guest),
+        };
+        entries.push(mapping);
+    }
+
+    FileSystemMappings(entries)
+}
+
+fn transform_package_meta_to_annotations(
+    package: &wasmer_config::package::Package,
+    base_dir: &Path,
+    strictness: Strictness,
+) -> Result<Wapm, ManifestError> {
+    fn metadata_file(
+        path: Option<&PathBuf>,
+        base_dir: &Path,
+        strictness: Strictness,
+    ) -> Result<Option<VolumeSpecificPath>, ManifestError> {
+        let path = match path {
+            Some(p) => p,
+            None => return Ok(None),
+        };
+
+        let absolute_path = base_dir.join(path);
+
+        // Touch the file to make sure it actually exists
+        if !absolute_path.exists() {
+            match strictness.missing_file(path, base_dir) {
+                Ok(_) => return Ok(None),
+                Err(e) => {
+                    return Err(e);
+                }
+            }
+        }
+
+        match base_dir.join(path).strip_prefix(base_dir) {
+            Ok(without_prefix) => Ok(Some(VolumeSpecificPath {
+                volume: METADATA_VOLUME.to_string(),
+                path: sanitize_path(without_prefix),
+            })),
+            Err(_) => match strictness.outside_base_directory(path, base_dir) {
+                Ok(_) => Ok(None),
+                Err(e) => Err(e),
+            },
+        }
+    }
+
+    transform_package_meta_to_annotations_shared(package, |path| {
+        metadata_file(path, base_dir, strictness)
+    })
+}
+
+fn transform_in_memory_package_meta_to_annotations(
+    package: &wasmer_config::package::Package,
+) -> Result<Wapm, ManifestError> {
+    transform_package_meta_to_annotations_shared(package, |path| {
+        Ok(path.map(|readme_file| VolumeSpecificPath {
+            volume: METADATA_VOLUME.to_string(),
+            path: sanitize_path(readme_file),
+        }))
+    })
+}
+
+fn transform_package_meta_to_annotations_shared(
+    package: &wasmer_config::package::Package,
+    volume_specific_path: impl Fn(Option<&PathBuf>) -> Result<Option<VolumeSpecificPath>, ManifestError>,
+) -> Result<Wapm, ManifestError> {
+    let mut wapm = Wapm::new(
+        package.name.clone(),
+        package.version.clone().map(|v| v.to_string()),
+        package.description.clone(),
+    );
+
+    wapm.license = package.license.clone();
+    wapm.license_file = volume_specific_path(package.license_file.as_ref())?;
+    wapm.readme = volume_specific_path(package.readme.as_ref())?;
+    wapm.repository = package.repository.clone();
+    wapm.homepage = package.homepage.clone();
+    wapm.private = package.private;
+
+    Ok(wapm)
+}
+
+fn transform_commands(
+    manifest: &WasmerManifest,
+    base_dir: &Path,
+) -> Result<IndexMap<String, Command>, ManifestError> {
+    trasform_commands_shared(
+        manifest,
+        |cmd| transform_command_v1(cmd, manifest),
+        |cmd| transform_command_v2(cmd, base_dir),
+    )
+}
+
+fn transform_in_memory_commands(
+    manifest: &WasmerManifest,
+) -> Result<IndexMap<String, Command>, ManifestError> {
+    trasform_commands_shared(
+        manifest,
+        |cmd| transform_command_v1(cmd, manifest),
+        transform_in_memory_command_v2,
+    )
+}
+
+#[allow(deprecated)]
+fn trasform_commands_shared(
+    manifest: &WasmerManifest,
+    transform_command_v1: impl Fn(&CommandV1) -> Result<Command, ManifestError>,
+    transform_command_v2: impl Fn(&CommandV2) -> Result<Command, ManifestError>,
+) -> Result<IndexMap<String, Command>, ManifestError> {
+    let mut commands = IndexMap::new();
+
+    for command in &manifest.commands {
+        let cmd = match command {
+            wasmer_config::package::Command::V1(cmd) => transform_command_v1(cmd)?,
+            wasmer_config::package::Command::V2(cmd) => transform_command_v2(cmd)?,
+        };
+
+        // If a command uses a module from a dependency, then ensure that
+        // the dependency is declared.
+        match command.get_module() {
+            wasmer_config::package::ModuleReference::CurrentPackage { .. } => {}
+            wasmer_config::package::ModuleReference::Dependency { dependency, .. } => {
+                if !manifest.dependencies.contains_key(dependency) {
+                    return Err(ManifestError::UndeclaredCommandDependency {
+                        command: command.get_name().to_string(),
+                        dependency: dependency.to_string(),
+                    });
+                }
+            }
+        }
+
+        match commands.entry(command.get_name().to_string()) {
+            indexmap::map::Entry::Occupied(_) => {
+                return Err(ManifestError::DuplicateCommand(
+                    command.get_name().to_string(),
+                ));
+            }
+            indexmap::map::Entry::Vacant(entry) => {
+                entry.insert(cmd);
+            }
+        }
+    }
+
+    Ok(commands)
+}
+
+#[allow(deprecated)]
+fn transform_command_v1(
+    cmd: &wasmer_config::package::CommandV1,
+    manifest: &WasmerManifest,
+) -> Result<Command, ManifestError> {
+    // Note: a key difference between CommandV1 and CommandV2 is that v1 uses
+    // a module's "abi" field to figure out which runner to use, whereas v2 has
+    // a dedicated "runner" field and ignores module.abi.
+    let runner = match &cmd.module {
+        wasmer_config::package::ModuleReference::CurrentPackage { module } => {
+            let module = manifest
+                .modules
+                .iter()
+                .find(|m| m.name == module.as_str())
+                .ok_or_else(|| ManifestError::InvalidModuleReference {
+                    command: cmd.name.clone(),
+                    module: cmd.module.to_string(),
+                })?;
+
+            RunnerKind::from_name(module.abi.to_str())?
+        }
+        wasmer_config::package::ModuleReference::Dependency { .. } => {
+            // Note: We don't have any visibility into dependencies (this code
+            // doesn't do resolution), so we blindly assume it's a WASI command.
+            // That should be fine because people shouldn't use the CommandV1
+            // syntax any more.
+            RunnerKind::Wasi
+        }
+    };
+
+    let mut annotations = IndexMap::new();
+    // Splitting by whitespace isn't really correct, but proper shell splitting
+    // would require a dependency and CommandV1 won't be used any more, anyway.
+    let main_args = cmd
+        .main_args
+        .as_deref()
+        .map(|args| args.split_whitespace().map(String::from).collect());
+    runner.runner_specific_annotations(
+        &mut annotations,
+        &cmd.module,
+        cmd.package.clone(),
+        main_args,
+    )?;
+
+    Ok(Command {
+        runner: runner.uri().to_string(),
+        annotations,
+    })
+}
+
+fn transform_command_v2(
+    cmd: &wasmer_config::package::CommandV2,
+    base_dir: &Path,
+) -> Result<Command, ManifestError> {
+    transform_command_v2_shared(cmd, || {
+        cmd.get_annotations(base_dir)
+            .map_err(|error| ManifestError::WasmerTomlAnnotations {
+                error: error.into(),
+            })
+    })
+}
+
+fn transform_in_memory_command_v2(
+    cmd: &wasmer_config::package::CommandV2,
+) -> Result<Command, ManifestError> {
+    transform_command_v2_shared(cmd, || {
+        cmd.annotations
+            .as_ref()
+            .map(|a| match a {
+                wasmer_config::package::CommandAnnotations::File(_) => {
+                    Err(ManifestError::FileNotSupported)
+                }
+                wasmer_config::package::CommandAnnotations::Raw(v) => Ok(toml_to_cbor_value(v)),
+            })
+            .transpose()
+    })
+}
+
+fn transform_command_v2_shared(
+    cmd: &wasmer_config::package::CommandV2,
+    custom_annotations: impl Fn() -> Result<Option<Value>, ManifestError>,
+) -> Result<Command, ManifestError> {
+    let runner = RunnerKind::from_name(&cmd.runner)?;
+    let mut annotations = IndexMap::new();
+
+    runner.runner_specific_annotations(&mut annotations, &cmd.module, None, None)?;
+
+    let custom_annotations = custom_annotations()?;
+
+    if let Some(ciborium::Value::Map(custom_annotations)) = custom_annotations {
+        for (key, value) in custom_annotations {
+            if let ciborium::Value::Text(key) = key {
+                match annotations.entry(key) {
+                    indexmap::map::Entry::Occupied(mut entry) => {
+                        merge_cbor(entry.get_mut(), value).map_err(|_| {
+                            ManifestError::MergeAnnotations {
+                                command: cmd.name.clone(),
+                                key: entry.key().clone(),
+                            }
+                        })?;
+                    }
+                    indexmap::map::Entry::Vacant(entry) => {
+                        entry.insert(value);
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(Command {
+        runner: runner.uri().to_string(),
+        annotations,
+    })
+}
+
+fn toml_to_cbor_value(val: &toml::value::Value) -> ciborium::Value {
+    match val {
+        toml::Value::String(s) => ciborium::Value::Text(s.clone()),
+        toml::Value::Integer(i) => ciborium::Value::Integer(ciborium::value::Integer::from(*i)),
+        toml::Value::Float(f) => ciborium::Value::Float(*f),
+        toml::Value::Boolean(b) => ciborium::Value::Bool(*b),
+        toml::Value::Datetime(d) => ciborium::Value::Text(format!("{d}")),
+        toml::Value::Array(sq) => {
+            ciborium::Value::Array(sq.iter().map(toml_to_cbor_value).collect())
+        }
+        toml::Value::Table(m) => ciborium::Value::Map(
+            m.iter()
+                .map(|(k, v)| (ciborium::Value::Text(k.clone()), toml_to_cbor_value(v)))
+                .collect(),
+        ),
+    }
+}
+
+fn merge_cbor(original: &mut Value, addition: Value) -> Result<(), ()> {
+    match (original, addition) {
+        (Value::Map(left), Value::Map(right)) => {
+            for (k, v) in right {
+                if let Some(entry) = left.iter_mut().find(|lk| lk.0 == k) {
+                    merge_cbor(&mut entry.1, v)?;
+                } else {
+                    left.push((k, v));
+                }
+            }
+        }
+        (Value::Array(left), Value::Array(right)) => {
+            left.extend(right);
+        }
+        // Primitives that have the same values are fine
+        (Value::Bool(left), Value::Bool(right)) if *left == right => {}
+        (Value::Bytes(left), Value::Bytes(right)) if *left == right => {}
+        (Value::Float(left), Value::Float(right)) if *left == right => {}
+        (Value::Integer(left), Value::Integer(right)) if *left == right => {}
+        (Value::Text(left), Value::Text(right)) if *left == right => {}
+        // null can be overwritten
+        (original @ Value::Null, value) => {
+            *original = value;
+        }
+        (_original, Value::Null) => {}
+        // Oh well, we tried...
+        (_left, _right) => {
+            return Err(());
+        }
+    }
+
+    Ok(())
+}
+
+#[derive(Debug, Clone, PartialEq)]
+enum RunnerKind {
+    Wasi,
+    Wcgi,
+    Wasm4,
+    Other(Url),
+}
+
+impl RunnerKind {
+    fn from_name(name: &str) -> Result<Self, ManifestError> {
+        match name {
+            "wasi" | "wasi@unstable_" | webc::metadata::annotations::WASI_RUNNER_URI => {
+                Ok(RunnerKind::Wasi)
+            }
+            "generic" => {
+                // This is what you get with a CommandV1 and abi = "none"
+                Ok(RunnerKind::Wasi)
+            }
+            "wcgi" | webc::metadata::annotations::WCGI_RUNNER_URI => Ok(RunnerKind::Wcgi),
+            "wasm4" | webc::metadata::annotations::WASM4_RUNNER_URI => Ok(RunnerKind::Wasm4),
+            other => {
+                if let Ok(other) = Url::parse(other) {
+                    Ok(RunnerKind::Other(other))
+                } else if let Ok(other) = format!("https://webc.org/runner/{other}").parse() {
+                    // fall back to something under webc.org
+                    Ok(RunnerKind::Other(other))
+                } else {
+                    Err(ManifestError::UnknownRunnerKind(other.to_string()))
+                }
+            }
+        }
+    }
+
+    fn uri(&self) -> &str {
+        match self {
+            RunnerKind::Wasi => webc::metadata::annotations::WASI_RUNNER_URI,
+            RunnerKind::Wcgi => webc::metadata::annotations::WCGI_RUNNER_URI,
+            RunnerKind::Wasm4 => webc::metadata::annotations::WASM4_RUNNER_URI,
+            RunnerKind::Other(other) => other.as_str(),
+        }
+    }
+
+    #[allow(deprecated)]
+    fn runner_specific_annotations(
+        &self,
+        annotations: &mut IndexMap<String, Value>,
+        module: &wasmer_config::package::ModuleReference,
+        package: Option<String>,
+        main_args: Option<Vec<String>>,
+    ) -> Result<(), ManifestError> {
+        let atom_annotation = match module {
+            wasmer_config::package::ModuleReference::CurrentPackage { module } => {
+                AtomAnnotation::new(module, None)
+            }
+            wasmer_config::package::ModuleReference::Dependency { dependency, module } => {
+                AtomAnnotation::new(module, dependency.to_string())
+            }
+        };
+        insert_annotation(annotations, AtomAnnotation::KEY, atom_annotation)?;
+
+        match self {
+            RunnerKind::Wasi | RunnerKind::Wcgi => {
+                let mut wasi = Wasi::new(module.to_string());
+                wasi.main_args = main_args;
+                wasi.package = package;
+                insert_annotation(annotations, Wasi::KEY, wasi)?;
+            }
+            RunnerKind::Wasm4 | RunnerKind::Other(_) => {
+                // No extra annotations to add
+            }
+        }
+
+        Ok(())
+    }
+}
+
+/// Infer the package's entrypoint.
+fn entrypoint(manifest: &WasmerManifest) -> Option<String> {
+    // check if manifest.package is none
+    if let Some(package) = &manifest.package {
+        if let Some(entrypoint) = &package.entrypoint {
+            return Some(entrypoint.clone());
+        }
+    }
+
+    if let [only_command] = manifest.commands.as_slice() {
+        // For convenience (and to stay compatible with old docs), if there is
+        // only one command we'll use that as the entrypoint
+        return Some(only_command.get_name().to_string());
+    }
+
+    None
+}
+
+fn transform_bindings(
+    manifest: &WasmerManifest,
+    base_dir: &Path,
+) -> Result<Vec<Binding>, ManifestError> {
+    transform_bindings_shared(
+        manifest,
+        |wit, module| transform_wit_bindings(wit, module, base_dir),
+        |wit, module| transform_wai_bindings(wit, module, base_dir),
+    )
+}
+
+fn transform_in_memory_bindings(manifest: &WasmerManifest) -> Result<Vec<Binding>, ManifestError> {
+    transform_bindings_shared(
+        manifest,
+        transform_in_memory_wit_bindings,
+        transform_in_memory_wai_bindings,
+    )
+}
+
+fn transform_bindings_shared(
+    manifest: &WasmerManifest,
+    wit_binding: impl Fn(
+        &wasmer_config::package::WitBindings,
+        &wasmer_config::package::Module,
+    ) -> Result<Binding, ManifestError>,
+    wai_binding: impl Fn(
+        &wasmer_config::package::WaiBindings,
+        &wasmer_config::package::Module,
+    ) -> Result<Binding, ManifestError>,
+) -> Result<Vec<Binding>, ManifestError> {
+    let mut bindings = Vec::new();
+
+    for module in &manifest.modules {
+        let b = match &module.bindings {
+            Some(wasmer_config::package::Bindings::Wit(wit)) => wit_binding(wit, module)?,
+            Some(wasmer_config::package::Bindings::Wai(wai)) => wai_binding(wai, module)?,
+            None => continue,
+        };
+        bindings.push(b);
+    }
+
+    Ok(bindings)
+}
+
+fn transform_wai_bindings(
+    wai: &wasmer_config::package::WaiBindings,
+    module: &wasmer_config::package::Module,
+    base_dir: &Path,
+) -> Result<Binding, ManifestError> {
+    transform_wai_bindings_shared(wai, module, |path| metadata_volume_uri(path, base_dir))
+}
+
+fn transform_in_memory_wai_bindings(
+    wai: &wasmer_config::package::WaiBindings,
+    module: &wasmer_config::package::Module,
+) -> Result<Binding, ManifestError> {
+    transform_wai_bindings_shared(wai, module, |path| {
+        Ok(format!("{METADATA_VOLUME}:/{}", sanitize_path(path)))
+    })
+}
+
+fn transform_wai_bindings_shared(
+    wai: &wasmer_config::package::WaiBindings,
+    module: &wasmer_config::package::Module,
+    metadata_volume_path: impl Fn(&PathBuf) -> Result<String, ManifestError>,
+) -> Result<Binding, ManifestError> {
+    let wasmer_config::package::WaiBindings {
+        wai_version,
+        exports,
+        imports,
+    } = wai;
+
+    let bindings = WaiBindings {
+        exports: exports.as_ref().map(&metadata_volume_path).transpose()?,
+        module: module.name.clone(),
+        imports: imports
+            .iter()
+            .map(metadata_volume_path)
+            .collect::<Result<Vec<_>, ManifestError>>()?,
+    };
+    let mut annotations = IndexMap::new();
+    insert_annotation(&mut annotations, "wai", bindings)?;
+
+    Ok(Binding {
+        name: "library-bindings".to_string(),
+        kind: format!("wai@{wai_version}"),
+        annotations: Value::Map(
+            annotations
+                .into_iter()
+                .map(|(k, v)| (Value::Text(k), v))
+                .collect(),
+        ),
+    })
+}
+
+fn metadata_volume_uri(path: &Path, base_dir: &Path) -> Result<String, ManifestError> {
+    make_relative_path(path, base_dir)
+        .map(sanitize_path)
+        .map(|p| format!("{METADATA_VOLUME}:/{p}"))
+}
+
+fn transform_wit_bindings(
+    wit: &wasmer_config::package::WitBindings,
+    module: &wasmer_config::package::Module,
+    base_dir: &Path,
+) -> Result<Binding, ManifestError> {
+    transform_wit_bindings_shared(wit, module, |path| metadata_volume_uri(path, base_dir))
+}
+
+fn transform_in_memory_wit_bindings(
+    wit: &wasmer_config::package::WitBindings,
+    module: &wasmer_config::package::Module,
+) -> Result<Binding, ManifestError> {
+    transform_wit_bindings_shared(wit, module, |path| {
+        Ok(format!("{METADATA_VOLUME}:/{}", sanitize_path(path)))
+    })
+}
+
+fn transform_wit_bindings_shared(
+    wit: &wasmer_config::package::WitBindings,
+    module: &wasmer_config::package::Module,
+    metadata_volume_path: impl Fn(&PathBuf) -> Result<String, ManifestError>,
+) -> Result<Binding, ManifestError> {
+    let wasmer_config::package::WitBindings {
+        wit_bindgen,
+        wit_exports,
+    } = wit;
+
+    let bindings = WitBindings {
+        exports: metadata_volume_path(wit_exports)?,
+        module: module.name.clone(),
+    };
+    let mut annotations = IndexMap::new();
+    insert_annotation(&mut annotations, "wit", bindings)?;
+
+    Ok(Binding {
+        name: "library-bindings".to_string(),
+        kind: format!("wit@{wit_bindgen}"),
+        annotations: Value::Map(
+            annotations
+                .into_iter()
+                .map(|(k, v)| (Value::Text(k), v))
+                .collect(),
+        ),
+    })
+}
+
+/// Resolve an item relative to the base directory, returning an error if the
+/// file lies outside of it.
+fn make_relative_path(path: &Path, base_dir: &Path) -> Result<PathBuf, ManifestError> {
+    let absolute_path = base_dir.join(path);
+
+    match absolute_path.strip_prefix(base_dir) {
+        Ok(p) => Ok(p.into()),
+        Err(_) => Err(ManifestError::OutsideBaseDirectory {
+            path: absolute_path,
+            base_dir: base_dir.to_path_buf(),
+        }),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use tempfile::TempDir;
+    use webc::metadata::annotations::Wasi;
+
+    use super::*;
+
+    #[test]
+    fn custom_annotations_are_copied_across_verbatim() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+        [package]
+        name = "test"
+        version = "0.0.0"
+        description = "asdf"
+
+        [[module]]
+        name = "module"
+        source = "file.wasm"
+        abi = "wasi"
+
+        [[command]]
+        name = "command"
+        module = "module"
+        runner = "asdf"
+        annotations = { first = 42, second = ["a", "b"] }
+        "#;
+        let manifest: WasmerManifest = toml::from_str(wasmer_toml).unwrap();
+        std::fs::write(temp.path().join("file.wasm"), b"\0asm...").unwrap();
+
+        let (transformed, _) =
+            wasmer_manifest_to_webc(&manifest, temp.path(), Strictness::Strict).unwrap();
+
+        let command = &transformed.commands["command"];
+        assert_eq!(command.annotation::<u32>("first").unwrap(), Some(42));
+        assert_eq!(command.annotation::<String>("non-existent").unwrap(), None);
+        insta::with_settings! {
+            { description => wasmer_toml },
+            { insta::assert_yaml_snapshot!(&transformed); }
+        }
+    }
+
+    #[test]
+    fn transform_empty_manifest() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+            [package]
+            name = "some/package"
+            version = "0.0.0"
+            description = "My awesome package"
+        "#;
+        let manifest: WasmerManifest = toml::from_str(wasmer_toml).unwrap();
+
+        let (transformed, atoms) =
+            wasmer_manifest_to_webc(&manifest, temp.path(), Strictness::Strict).unwrap();
+
+        assert!(atoms.is_empty());
+        insta::with_settings! {
+            { description => wasmer_toml },
+            { insta::assert_yaml_snapshot!(&transformed); }
+        }
+    }
+
+    #[test]
+    fn transform_manifest_with_single_atom() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+            [package]
+            name = "some/package"
+            version = "0.0.0"
+            description = "My awesome package"
+
+            [[module]]
+            name = "first"
+            source = "./path/to/file.wasm"
+            abi = "wasi"
+        "#;
+        let manifest: WasmerManifest = toml::from_str(wasmer_toml).unwrap();
+        let dir = temp.path().join("path").join("to");
+        std::fs::create_dir_all(&dir).unwrap();
+        std::fs::write(dir.join("file.wasm"), b"\0asm...").unwrap();
+
+        let (transformed, atoms) =
+            wasmer_manifest_to_webc(&manifest, temp.path(), Strictness::Strict).unwrap();
+
+        assert_eq!(atoms.len(), 1);
+        assert_eq!(atoms["first"].as_slice(), b"\0asm...");
+        insta::with_settings! {
+            { description => wasmer_toml },
+            { insta::assert_yaml_snapshot!(&transformed); }
+        }
+    }
+
+    #[test]
+    fn transform_manifest_with_atom_and_command() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+            [package]
+            name = "some/package"
+            version = "0.0.0"
+            description = "My awesome package"
+
+            [[module]]
+            name = "cpython"
+            source = "python.wasm"
+            abi = "wasi"
+
+            [[command]]
+            name = "python"
+            module = "cpython"
+            runner = "wasi"
+        "#;
+        let manifest: WasmerManifest = toml::from_str(wasmer_toml).unwrap();
+        std::fs::write(temp.path().join("python.wasm"), b"\0asm...").unwrap();
+
+        let (transformed, _) =
+            wasmer_manifest_to_webc(&manifest, temp.path(), Strictness::Strict).unwrap();
+
+        assert_eq!(transformed.commands.len(), 1);
+        let python = &transformed.commands["python"];
+        assert_eq!(&python.runner, webc::metadata::annotations::WASI_RUNNER_URI);
+        assert_eq!(python.wasi().unwrap().unwrap(), Wasi::new("cpython"));
+        insta::with_settings! {
+            { description => wasmer_toml },
+            { insta::assert_yaml_snapshot!(&transformed); }
+        }
+    }
+
+    #[test]
+    fn transform_manifest_with_multiple_commands() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+            [package]
+            name = "some/package"
+            version = "0.0.0"
+            description = "My awesome package"
+
+            [[module]]
+            name = "cpython"
+            source = "python.wasm"
+            abi = "wasi"
+
+            [[command]]
+            name = "first"
+            module = "cpython"
+            runner = "wasi"
+
+            [[command]]
+            name = "second"
+            module = "cpython"
+            runner = "wasi"
+
+            [[command]]
+            name = "third"
+            module = "cpython"
+            runner = "wasi"
+        "#;
+        let manifest: WasmerManifest = toml::from_str(wasmer_toml).unwrap();
+        std::fs::write(temp.path().join("python.wasm"), b"\0asm...").unwrap();
+
+        let (transformed, _) =
+            wasmer_manifest_to_webc(&manifest, temp.path(), Strictness::Strict).unwrap();
+
+        assert_eq!(transformed.commands.len(), 3);
+        assert!(transformed.commands.contains_key("first"));
+        assert!(transformed.commands.contains_key("second"));
+        assert!(transformed.commands.contains_key("third"));
+        insta::with_settings! {
+            { description => wasmer_toml },
+            { insta::assert_yaml_snapshot!(&transformed); }
+        }
+    }
+
+    #[test]
+    fn merge_custom_attributes_with_builtin_ones() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+            [package]
+            name = "some/package"
+            version = "0.0.0"
+            description = "My awesome package"
+
+            [[module]]
+            name = "cpython"
+            source = "python.wasm"
+            abi = "wasi"
+
+            [[command]]
+            name = "python"
+            module = "cpython"
+            runner = "wasi"
+            annotations = { wasi = { env = ["KEY=val"]} }
+        "#;
+        let manifest: WasmerManifest = toml::from_str(wasmer_toml).unwrap();
+        std::fs::write(temp.path().join("python.wasm"), b"\0asm...").unwrap();
+
+        let (transformed, _) =
+            wasmer_manifest_to_webc(&manifest, temp.path(), Strictness::Strict).unwrap();
+
+        assert_eq!(transformed.commands.len(), 1);
+        let cmd = &transformed.commands["python"];
+        assert_eq!(
+            &cmd.wasi().unwrap().unwrap(),
+            Wasi::new("cpython").with_env("KEY", "val")
+        );
+        insta::with_settings! {
+            { description => wasmer_toml },
+            { insta::assert_yaml_snapshot!(&transformed); }
+        }
+    }
+
+    #[test]
+    fn transform_bash_manifest() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+            [package]
+            name = "sharrattj/bash"
+            version = "1.0.17"
+            description = "Bash is a modern POSIX-compliant implementation of /bin/sh."
+            license = "GNU"
+            wasmer-extra-flags = "--enable-threads --enable-bulk-memory"
+
+            [dependencies]
+            "sharrattj/coreutils" = "1.0.16"
+
+            [[module]]
+            name = "bash"
+            source = "bash.wasm"
+            abi = "wasi"
+
+            [[command]]
+            name = "bash"
+            module = "bash"
+            runner = "wasi@unstable_"
+        "#;
+        let manifest: WasmerManifest = toml::from_str(wasmer_toml).unwrap();
+        std::fs::write(temp.path().join("bash.wasm"), b"\0asm...").unwrap();
+
+        let (transformed, _) =
+            wasmer_manifest_to_webc(&manifest, temp.path(), Strictness::Strict).unwrap();
+
+        insta::with_settings! {
+            { description => wasmer_toml },
+            { insta::assert_yaml_snapshot!(&transformed); }
+        }
+    }
+
+    #[test]
+    fn transform_wasmer_pack_manifest() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+            [package]
+            name = "wasmer/wasmer-pack"
+            version = "0.7.0"
+            description = "The WebAssembly interface to wasmer-pack."
+            license = "MIT"
+            readme = "README.md"
+            repository = "https://github.com/wasmerio/wasmer-pack"
+            homepage = "https://wasmer.io/"
+
+            [[module]]
+            name = "wasmer-pack-wasm"
+            source = "wasmer_pack_wasm.wasm"
+
+            [module.bindings]
+            wai-version = "0.2.0"
+            exports = "wasmer-pack.exports.wai"
+            imports = []
+        "#;
+        let manifest: WasmerManifest = toml::from_str(wasmer_toml).unwrap();
+        std::fs::write(temp.path().join("wasmer_pack_wasm.wasm"), b"\0asm...").unwrap();
+        std::fs::write(temp.path().join("wasmer-pack.exports.wai"), b"").unwrap();
+        std::fs::write(temp.path().join("README.md"), b"").unwrap();
+
+        let (transformed, _) =
+            wasmer_manifest_to_webc(&manifest, temp.path(), Strictness::Strict).unwrap();
+
+        insta::with_settings! {
+            { description => wasmer_toml },
+            { insta::assert_yaml_snapshot!(&transformed); }
+        }
+    }
+
+    #[test]
+    fn transform_python_manifest() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+            [package]
+            name = "python"
+            version = "0.1.0"
+            description = "Python is an interpreted, high-level, general-purpose programming language"
+            license = "ISC"
+            repository = "https://github.com/wapm-packages/python"
+
+            [[module]]
+            name = "python"
+            source = "bin/python.wasm"
+            abi = "wasi"
+
+            [module.interfaces]
+            wasi = "0.0.0-unstable"
+
+            [[command]]
+            name = "python"
+            module = "python"
+
+            [fs]
+            lib = "lib"
+        "#;
+        let manifest: WasmerManifest = toml::from_str(wasmer_toml).unwrap();
+        let bin = temp.path().join("bin");
+        std::fs::create_dir_all(&bin).unwrap();
+        std::fs::write(bin.join("python.wasm"), b"\0asm...").unwrap();
+
+        let (transformed, _) =
+            wasmer_manifest_to_webc(&manifest, temp.path(), Strictness::Strict).unwrap();
+
+        insta::with_settings! {
+            { description => wasmer_toml },
+            { insta::assert_yaml_snapshot!(&transformed); }
+        }
+    }
+
+    #[test]
+    fn transform_manifest_with_fs_table() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+            [package]
+            name = "some/package"
+            version = "0.0.0"
+            description = "This is a package"
+
+            [fs]
+            lib = "lib"
+            "/public" = "out"
+        "#;
+        let manifest: WasmerManifest = toml::from_str(wasmer_toml).unwrap();
+        std::fs::write(temp.path().join("python.wasm"), b"\0asm...").unwrap();
+
+        let (transformed, _) =
+            wasmer_manifest_to_webc(&manifest, temp.path(), Strictness::Strict).unwrap();
+
+        let fs = transformed.filesystem().unwrap().unwrap();
+        assert_eq!(
+            fs,
+            [
+                FileSystemMapping {
+                    from: None,
+                    volume_name: "/lib".to_string(),
+                    host_path: None,
+                    mount_path: "/lib".to_string(),
+                },
+                FileSystemMapping {
+                    from: None,
+                    volume_name: "/out".to_string(),
+                    host_path: None,
+                    mount_path: "/public".to_string(),
+                }
+            ]
+        );
+        insta::with_settings! {
+            { description => wasmer_toml },
+            { insta::assert_yaml_snapshot!(&transformed); }
+        }
+    }
+
+    #[test]
+    fn missing_command_dependency() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+            [[command]]
+            name = "python"
+            module = "test/python:python"
+        "#;
+        let manifest: WasmerManifest = toml::from_str(wasmer_toml).unwrap();
+        let bin = temp.path().join("bin");
+        std::fs::create_dir_all(&bin).unwrap();
+        let res = wasmer_manifest_to_webc(&manifest, temp.path(), Strictness::Strict);
+
+        assert!(matches!(
+            res,
+            Err(ManifestError::UndeclaredCommandDependency { .. })
+        ));
+    }
+
+    #[test]
+    fn issue_124_command_runner_is_swallowed() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+            [package]
+            name = "wasmer-tests/wcgi-always-panic"
+            version = "0.1.0"
+            description = "wasmer-tests/wcgi-always-panic website"
+
+            [[module]]
+            name = "wcgi-always-panic"
+            source = "./wcgi-always-panic.wasm"
+            abi = "wasi"
+
+            [[command]]
+            name = "wcgi"
+            module = "wcgi-always-panic"
+            runner = "https://webc.org/runner/wcgi"
+        "#;
+        let manifest: WasmerManifest = toml::from_str(wasmer_toml).unwrap();
+        std::fs::write(temp.path().join("wcgi-always-panic.wasm"), b"\0asm...").unwrap();
+
+        let (transformed, _) =
+            wasmer_manifest_to_webc(&manifest, temp.path(), Strictness::Strict).unwrap();
+
+        let cmd = &transformed.commands["wcgi"];
+        assert_eq!(cmd.runner, webc::metadata::annotations::WCGI_RUNNER_URI);
+        assert_eq!(cmd.wasi().unwrap().unwrap(), Wasi::new("wcgi-always-panic"));
+        insta::with_settings! {
+            { description => wasmer_toml },
+            { insta::assert_yaml_snapshot!(&transformed); }
+        }
+    }
+}
diff --git a/lib/package/src/package/mod.rs b/lib/package/src/package/mod.rs
new file mode 100644
index 0000000000..ac0a9c3644
--- /dev/null
+++ b/lib/package/src/package/mod.rs
@@ -0,0 +1,299 @@
+//! Load a Wasmer package from disk.
+pub(crate) mod manifest;
+#[allow(clippy::module_inception)]
+pub(crate) mod package;
+pub(crate) mod strictness;
+pub(crate) mod volume;
+
+pub use self::{
+    manifest::ManifestError,
+    package::{
+        include_everything_walker, wasmer_ignore_walker, Package, WalkBuilderFactory,
+        WasmerPackageError,
+    },
+    strictness::Strictness,
+    volume::{fs::*, in_memory::*, WasmerPackageVolume},
+};
+
+#[cfg(test)]
+mod tests {
+    use sha2::Digest;
+    use shared_buffer::OwnedBuffer;
+    use tempfile::TempDir;
+
+    use webc::{
+        metadata::annotations::FileSystemMapping,
+        migration::{are_semantically_equivalent, v2_to_v3, v3_to_v2},
+    };
+
+    use crate::{package::Package, utils::from_bytes};
+
+    #[test]
+    fn migration_roundtrip() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+                [package]
+                name = "some/package"
+                version = "0.0.0"
+                description = "Test package"
+                [fs]
+                "/first" = "first"
+                second = "nested/dir"
+                "second/child" = "third"
+                empty = "empty"
+            "#;
+        let manifest = temp.path().join("wasmer.toml");
+        std::fs::write(&manifest, wasmer_toml).unwrap();
+        // Now we want to set up the following filesystem tree:
+        //
+        // - first/ ("/first")
+        //   - file.txt
+        // - nested/
+        //   - dir/ ("second")
+        //     - README.md
+        //     - another-dir/
+        //       - empty.txt
+        // - third/ ("second/child")
+        //   - file.txt
+        // - empty/ ("empty")
+        //
+        // The "/first" entry
+        let first = temp.path().join("first");
+        std::fs::create_dir_all(&first).unwrap();
+        std::fs::write(first.join("file.txt"), "File").unwrap();
+        // The "second" entry
+        let second = temp.path().join("nested").join("dir");
+        std::fs::create_dir_all(&second).unwrap();
+        std::fs::write(second.join("README.md"), "please").unwrap();
+        let another_dir = temp.path().join("nested").join("dir").join("another-dir");
+        std::fs::create_dir_all(&another_dir).unwrap();
+        std::fs::write(another_dir.join("empty.txt"), "").unwrap();
+        // The "second/child" entry
+        let third = temp.path().join("third");
+        std::fs::create_dir_all(&third).unwrap();
+        std::fs::write(third.join("file.txt"), "Hello, World!").unwrap();
+        // The "empty" entry
+        let empty_dir = temp.path().join("empty");
+        std::fs::create_dir_all(empty_dir).unwrap();
+
+        let package = Package::from_manifest(manifest).unwrap();
+
+        let webc = package.serialize().unwrap();
+
+        let webc_v2 = v3_to_v2(webc.clone()).unwrap();
+
+        are_semantically_equivalent(webc_v2.clone(), webc.into()).unwrap();
+
+        let container = from_bytes(webc_v2.clone().into_bytes()).unwrap();
+        let manifest = container.manifest();
+        let fs_table = manifest.filesystem().unwrap().unwrap();
+        assert_eq!(
+            fs_table,
+            [
+                FileSystemMapping {
+                    from: None,
+                    volume_name: "atom".to_string(),
+                    host_path: Some("/first".to_string()),
+                    mount_path: "/first".to_string(),
+                },
+                FileSystemMapping {
+                    from: None,
+                    volume_name: "atom".to_string(),
+                    host_path: Some("/nested/dir".to_string()),
+                    mount_path: "/second".to_string(),
+                },
+                FileSystemMapping {
+                    from: None,
+                    volume_name: "atom".to_string(),
+                    host_path: Some("/third".to_string()),
+                    mount_path: "/second/child".to_string(),
+                },
+                FileSystemMapping {
+                    from: None,
+                    volume_name: "atom".to_string(),
+                    host_path: Some("/empty".to_string()),
+                    mount_path: "/empty".to_string(),
+                },
+            ]
+        );
+
+        let atom_volume = container.get_volume("atom").unwrap();
+        assert_eq!(
+            atom_volume.read_file("/first/file.txt").unwrap(),
+            (OwnedBuffer::from(b"File".as_slice()), None)
+        );
+        assert_eq!(
+            atom_volume.read_file("/nested/dir/README.md").unwrap(),
+            (OwnedBuffer::from(b"please".as_slice()), None),
+        );
+        assert_eq!(
+            atom_volume
+                .read_file("/nested/dir/another-dir/empty.txt")
+                .unwrap(),
+            (OwnedBuffer::from(b"".as_slice()), None)
+        );
+        assert_eq!(
+            atom_volume.read_file("/third/file.txt").unwrap(),
+            (OwnedBuffer::from(b"Hello, World!".as_slice()), None)
+        );
+        assert_eq!(
+            atom_volume.read_dir("/empty").unwrap().len(),
+            0,
+            "Directories should be included, even if empty"
+        );
+
+        // Go back to v3
+        let webc_v3 = v2_to_v3(webc_v2.clone()).unwrap();
+
+        are_semantically_equivalent(webc_v2, webc_v3.clone()).unwrap();
+
+        let container = from_bytes(webc_v3.into_bytes()).unwrap();
+        let manifest = container.manifest();
+        let fs_table = manifest.filesystem().unwrap().unwrap();
+        assert_eq!(
+            fs_table,
+            [
+                FileSystemMapping {
+                    from: None,
+                    volume_name: "/first".to_string(),
+                    host_path: None,
+                    mount_path: "/first".to_string(),
+                },
+                FileSystemMapping {
+                    from: None,
+                    volume_name: "/nested/dir".to_string(),
+                    host_path: None,
+                    mount_path: "/second".to_string(),
+                },
+                FileSystemMapping {
+                    from: None,
+                    volume_name: "/third".to_string(),
+                    host_path: None,
+                    mount_path: "/second/child".to_string(),
+                },
+                FileSystemMapping {
+                    from: None,
+                    volume_name: "/empty".to_string(),
+                    host_path: None,
+                    mount_path: "/empty".to_string(),
+                },
+            ]
+        );
+
+        let first_file_hash: [u8; 32] = sha2::Sha256::digest(b"File").into();
+        let readme_hash: [u8; 32] = sha2::Sha256::digest(b"please").into();
+        let empty_hash: [u8; 32] = sha2::Sha256::digest(b"").into();
+        let third_file_hash: [u8; 32] = sha2::Sha256::digest(b"Hello, World!").into();
+
+        let first_volume = container.get_volume("/first").unwrap();
+        assert_eq!(
+            first_volume.read_file("/file.txt").unwrap(),
+            (b"File".as_slice().into(), Some(first_file_hash)),
+        );
+
+        let nested_dir_volume = container.get_volume("/nested/dir").unwrap();
+        assert_eq!(
+            nested_dir_volume.read_file("README.md").unwrap(),
+            (b"please".as_slice().into(), Some(readme_hash)),
+        );
+        assert_eq!(
+            nested_dir_volume
+                .read_file("/another-dir/empty.txt")
+                .unwrap(),
+            (b"".as_slice().into(), Some(empty_hash))
+        );
+
+        let third_volume = container.get_volume("/third").unwrap();
+        assert_eq!(
+            third_volume.read_file("/file.txt").unwrap(),
+            (b"Hello, World!".as_slice().into(), Some(third_file_hash))
+        );
+
+        let empty_volume = container.get_volume("/empty").unwrap();
+        assert_eq!(
+            empty_volume.read_dir("/").unwrap().len(),
+            0,
+            "Directories should be included, even if empty"
+        );
+    }
+
+    #[test]
+    fn fs_entry_is_not_required_for_migration() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+                [package]
+                name = "some/package"
+                version = "0.0.0"
+                description = "Test package"
+            "#;
+        let manifest = temp.path().join("wasmer.toml");
+        std::fs::write(&manifest, wasmer_toml).unwrap();
+        let package = Package::from_manifest(manifest).unwrap();
+
+        let webc = package.serialize().unwrap();
+
+        let webc_v2 = v3_to_v2(webc).unwrap();
+        let container = from_bytes(webc_v2.clone().into_bytes()).unwrap();
+        let manifest = container.manifest();
+        assert!(manifest.filesystem().unwrap().is_none());
+
+        // Go back to v3
+        let webc_v3 = v2_to_v3(webc_v2).unwrap();
+        let container = from_bytes(webc_v3.into_bytes()).unwrap();
+        let manifest = container.manifest();
+        assert!(manifest.filesystem().unwrap().is_none());
+    }
+
+    #[test]
+    fn container_unpacks_atoms() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+                [package]
+                name = "some/package"
+                version = "0.0.0"
+                description = "Test package"
+                [[module]]
+                name = "foo"
+                source = "foo.wasm"
+                abi = "wasi"
+                [fs]
+                "/bar" = "bar"
+            "#;
+
+        let manifest = temp.path().join("wasmer.toml");
+        std::fs::write(&manifest, wasmer_toml).unwrap();
+
+        let atom_path = temp.path().join("foo.wasm");
+        std::fs::write(&atom_path, b"").unwrap();
+
+        let bar = temp.path().join("bar");
+        std::fs::create_dir(&bar).unwrap();
+
+        let webc = Package::from_manifest(&manifest)
+            .unwrap()
+            .serialize()
+            .unwrap();
+        let container = from_bytes(webc).unwrap();
+
+        let out_dir = temp.path().join("out");
+        container.unpack(&out_dir, false).unwrap();
+
+        let expected_entries = [
+            "bar",      // the volume
+            "metadata", // the metadata volume
+            "foo",      // the atom
+            "manifest.json",
+        ];
+        let entries = std::fs::read_dir(&out_dir)
+            .unwrap()
+            .map(|e| e.unwrap())
+            .collect::<Vec<_>>();
+
+        assert_eq!(expected_entries.len(), entries.len());
+        assert!(expected_entries.iter().all(|e| {
+            entries
+                .iter()
+                .any(|entry| entry.file_name().as_os_str() == *e)
+        }))
+    }
+}
diff --git a/lib/package/src/package/package.rs b/lib/package/src/package/package.rs
new file mode 100644
index 0000000000..31fe6cab89
--- /dev/null
+++ b/lib/package/src/package/package.rs
@@ -0,0 +1,2071 @@
+use std::{
+    borrow::Cow,
+    collections::{BTreeMap, BTreeSet},
+    fmt::Debug,
+    fs::File,
+    io::{BufRead, BufReader},
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+
+use anyhow::{Context, Error};
+use bytes::Bytes;
+use flate2::bufread::GzDecoder;
+use shared_buffer::OwnedBuffer;
+use tar::Archive;
+use tempfile::TempDir;
+use wasmer_config::package::Manifest as WasmerManifest;
+
+use webc::{
+    metadata::{annotations::Wapm, Manifest as WebcManifest},
+    v3::{
+        write::{FileEntry, Writer},
+        ChecksumAlgorithm, Timestamps,
+    },
+    AbstractVolume, AbstractWebc, Container, ContainerError, DetectError, PathSegment, Version,
+    Volume,
+};
+
+use super::{
+    manifest::wasmer_manifest_to_webc,
+    volume::{fs::FsVolume, WasmerPackageVolume},
+    ManifestError, MemoryVolume, Strictness,
+};
+
+/// Errors that may occur while loading a Wasmer package from disk.
+#[derive(Debug, thiserror::Error)]
+#[allow(clippy::result_large_err)]
+#[non_exhaustive]
+pub enum WasmerPackageError {
+    /// Unable to create a temporary directory.
+    #[error("Unable to create a temporary directory")]
+    TempDir(#[source] std::io::Error),
+    /// Unable to open a file.
+    #[error("Unable to open \"{}\"", path.display())]
+    FileOpen {
+        /// The file being opened.
+        path: PathBuf,
+        /// The underlying error.
+        #[source]
+        error: std::io::Error,
+    },
+    /// Unable to read a file.
+    #[error("Unable to read \"{}\"", path.display())]
+    FileRead {
+        /// The file being opened.
+        path: PathBuf,
+        /// The underlying error.
+        #[source]
+        error: std::io::Error,
+    },
+
+    /// Generic IO error.
+    #[error("IO Error: {0:?}")]
+    IoError(#[from] std::io::Error),
+
+    /// Unexpected path format
+    #[error("Malformed path format: {0:?}")]
+    MalformedPath(PathBuf),
+
+    /// Unable to extract the tarball.
+    #[error("Unable to extract the tarball")]
+    Tarball(#[source] std::io::Error),
+    /// Unable to deserialize the `wasmer.toml` file.
+    #[error("Unable to deserialize \"{}\"", path.display())]
+    TomlDeserialize {
+        /// The file being deserialized.
+        path: PathBuf,
+        /// The underlying error.
+        #[source]
+        error: toml::de::Error,
+    },
+    /// Unable to deserialize a json file.
+    #[error("Unable to deserialize \"{}\"", path.display())]
+    JsonDeserialize {
+        /// The file being deserialized.
+        path: PathBuf,
+        /// The underlying error.
+        #[source]
+        error: serde_json::Error,
+    },
+    /// Unable to find the `wasmer.toml` file.
+    #[error("Unable to find the \"wasmer.toml\"")]
+    MissingManifest,
+    /// Unable to canonicalize a path.
+    #[error("Unable to get the absolute path for \"{}\"", path.display())]
+    Canonicalize {
+        /// The path being canonicalized.
+        path: PathBuf,
+        /// The underlying error.
+        #[source]
+        error: std::io::Error,
+    },
+    /// Unable to load the `wasmer.toml` manifest.
+    #[error("Unable to load the \"wasmer.toml\" manifest")]
+    Manifest(#[from] ManifestError),
+    /// A manifest validation error.
+    #[error("The manifest is invalid")]
+    Validation(#[from] wasmer_config::package::ValidationError),
+    /// A path in the fs mapping does not exist
+    #[error("Path: \"{}\" does not exist", path.display())]
+    PathNotExists {
+        /// Path entry in fs mapping
+        path: PathBuf,
+    },
+    /// Any error happening when populating the volumes tree map of a package
+    #[error("Volume creation failed: {0:?}")]
+    VolumeCreation(#[from] anyhow::Error),
+
+    /// Error when serializing or deserializing
+    #[error("serde error: {0:?}")]
+    SerdeError(#[from] ciborium::value::Error),
+
+    /// Container Error
+    #[error("container error: {0:?}")]
+    ContainerError(#[from] ContainerError),
+
+    /// Detect Error
+    #[error("detect error: {0:?}")]
+    DetectError(#[from] DetectError),
+}
+
+// Serious Java vibes from this one! Still better than repeating the
+// function type everywhere.
+// I'm opting not to use a trait object here to avoid generics and boxing.
+#[derive(Clone, Copy)]
+pub struct WalkBuilderFactory {
+    pub walker_factory: fn(&Path) -> ignore::WalkBuilder,
+}
+
+impl Debug for WalkBuilderFactory {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("WalkBuilderFactory").finish()
+    }
+}
+
+impl WalkBuilderFactory {
+    pub fn new(walker_factory: fn(&Path) -> ignore::WalkBuilder) -> Self {
+        Self { walker_factory }
+    }
+
+    pub fn create_walk_builder(&self, path: &Path) -> ignore::WalkBuilder {
+        (self.walker_factory)(path)
+    }
+}
+
+fn is_wasmer_ignore_present(path: &Path) -> bool {
+    path.ancestors().any(|p| p.join(".wasmerignore").is_file())
+}
+
+/// Create and configure a default ignore walker for building packages that:
+///   * If a `.wasmerignore` file is present, it will be used to ignore files.
+///   * Otherwise, only `.git` folders will be ignored.
+pub fn wasmer_ignore_walker() -> WalkBuilderFactory {
+    fn walker_factory(root_dir: &Path) -> ignore::WalkBuilder {
+        let mut builder = ignore::WalkBuilder::new(root_dir);
+        // We always add .wasmerignore because it could exist in a sub-directory.
+        builder
+            .standard_filters(false)
+            .follow_links(false)
+            .parents(true)
+            .add_custom_ignore_filename(".wasmerignore");
+
+        // However, if there is no .wasmerignore in the root directory,
+        // we want to at least ignore .git folders. This setup creates the
+        // very niche edge case of having .wasmerignore in a subdirectory
+        // causing .git folders to be ignored in other directories, but
+        // that seems acceptable given how rare that would be. The proper
+        // solution would be to do this logic per-directory, but that's
+        // not supported by `ignore`.
+        if !is_wasmer_ignore_present(root_dir) {
+            let mut overrides = ignore::overrides::OverrideBuilder::new(root_dir);
+            overrides.add("!.git").expect("valid override");
+            builder.overrides(overrides.build().expect("valid overrides"));
+        }
+
+        builder
+    }
+    WalkBuilderFactory::new(walker_factory)
+}
+
+pub fn include_everything_walker() -> WalkBuilderFactory {
+    fn walker_factory(root_dir: &Path) -> ignore::WalkBuilder {
+        let mut builder = ignore::WalkBuilder::new(root_dir);
+        builder.standard_filters(false).follow_links(false);
+        builder
+    }
+    WalkBuilderFactory::new(walker_factory)
+}
+
+/// A Wasmer package that will be lazily loaded from disk.
+#[derive(Debug)]
+pub struct Package {
+    // base dir could be a temp dir, so we keep it around to prevent the directory
+    // from being deleted
+    #[allow(dead_code)]
+    base_dir: BaseDir,
+    manifest: WebcManifest,
+    atoms: BTreeMap<String, OwnedBuffer>,
+    strictness: Strictness,
+    volumes: BTreeMap<String, Arc<dyn WasmerPackageVolume + Send + Sync + 'static>>,
+}
+
+impl Package {
+    /// Load a [`Package`] from a `*.tar.gz` file on disk.
+    ///
+    /// # Implementation Details
+    ///
+    /// This will unpack the tarball to a temporary directory on disk and use
+    /// memory-mapped files in order to reduce RAM usage.
+    pub fn from_tarball_file(path: impl AsRef<Path>) -> Result<Self, WasmerPackageError> {
+        Package::from_tarball_file_with_walker(path.as_ref(), include_everything_walker())
+    }
+
+    /// Load a [`Package`] from a `*.tar.gz` file on disk.
+    ///
+    /// # Implementation Details
+    ///
+    /// This will unpack the tarball to a temporary directory on disk and use
+    /// memory-mapped files in order to reduce RAM usage.
+    pub fn from_tarball_file_with_walker(
+        path: impl AsRef<Path>,
+        walker_factory: WalkBuilderFactory,
+    ) -> Result<Self, WasmerPackageError> {
+        Package::from_tarball_file_with_strictness(
+            path.as_ref(),
+            Strictness::default(),
+            walker_factory,
+        )
+    }
+
+    /// Load a [`Package`] from a `*.tar.gz` file on disk.
+    ///
+    /// # Implementation Details
+    ///
+    /// This will unpack the tarball to a temporary directory on disk and use
+    /// memory-mapped files in order to reduce RAM usage.
+    pub fn from_tarball_file_with_strictness(
+        path: impl AsRef<Path>,
+        strictness: Strictness,
+        walker_factory: WalkBuilderFactory,
+    ) -> Result<Self, WasmerPackageError> {
+        let path = path.as_ref();
+        let f = File::open(path).map_err(|error| WasmerPackageError::FileOpen {
+            path: path.to_path_buf(),
+            error,
+        })?;
+
+        Package::from_tarball_with_strictness(BufReader::new(f), strictness, walker_factory)
+    }
+
+    /// Load a package from a `*.tar.gz` archive.
+    pub fn from_tarball(tarball: impl BufRead) -> Result<Self, WasmerPackageError> {
+        Package::from_tarball_with_walker(tarball, include_everything_walker())
+    }
+
+    /// Load a package from a `*.tar.gz` archive.
+    pub fn from_tarball_with_walker(
+        tarball: impl BufRead,
+        walker_factory: WalkBuilderFactory,
+    ) -> Result<Self, WasmerPackageError> {
+        Package::from_tarball_with_strictness(tarball, Strictness::default(), walker_factory)
+    }
+
+    /// Load a package from a `*.tar.gz` archive.
+    pub fn from_tarball_with_strictness(
+        tarball: impl BufRead,
+        strictness: Strictness,
+        walker_factory: WalkBuilderFactory,
+    ) -> Result<Self, WasmerPackageError> {
+        let tarball = GzDecoder::new(tarball);
+        let temp = tempdir().map_err(WasmerPackageError::TempDir)?;
+        let archive = Archive::new(tarball);
+        unpack_archive(archive, temp.path()).map_err(WasmerPackageError::Tarball)?;
+
+        let (_manifest_path, manifest) = read_manifest(temp.path())?;
+
+        Package::load(manifest, temp, strictness, walker_factory)
+    }
+
+    /// Load a package from a `wasmer.toml` manifest on disk.
+    pub fn from_manifest(wasmer_toml: impl AsRef<Path>) -> Result<Self, WasmerPackageError> {
+        Package::from_manifest_with_walker(wasmer_toml, wasmer_ignore_walker())
+    }
+
+    /// Load a package from a `wasmer.toml` manifest on disk.
+    pub fn from_manifest_with_walker(
+        wasmer_toml: impl AsRef<Path>,
+        walker_factory: WalkBuilderFactory,
+    ) -> Result<Self, WasmerPackageError> {
+        Package::from_manifest_with_strictness(wasmer_toml, Strictness::default(), walker_factory)
+    }
+
+    /// Load a package from a `wasmer.toml` manifest on disk.
+    pub fn from_manifest_with_strictness(
+        wasmer_toml: impl AsRef<Path>,
+        strictness: Strictness,
+        walker_factory: WalkBuilderFactory,
+    ) -> Result<Self, WasmerPackageError> {
+        let path = wasmer_toml.as_ref();
+        let path = path
+            .canonicalize()
+            .map_err(|error| WasmerPackageError::Canonicalize {
+                path: path.to_path_buf(),
+                error,
+            })?;
+
+        let wasmer_toml =
+            std::fs::read_to_string(&path).map_err(|error| WasmerPackageError::FileRead {
+                path: path.to_path_buf(),
+                error,
+            })?;
+        let wasmer_toml: WasmerManifest =
+            toml::from_str(&wasmer_toml).map_err(|error| WasmerPackageError::TomlDeserialize {
+                path: path.to_path_buf(),
+                error,
+            })?;
+
+        let base_dir = path
+            .parent()
+            .expect("Canonicalizing should always result in a file with a parent directory")
+            .to_path_buf();
+
+        for path in wasmer_toml.fs.values() {
+            if !base_dir.join(path).exists() {
+                return Err(WasmerPackageError::PathNotExists { path: path.clone() });
+            }
+        }
+
+        Package::load(wasmer_toml, base_dir, strictness, walker_factory)
+    }
+
+    /// (Re)loads a package from a manifest.json file which was created as the result of calling [`Container::unpack`](crate::Container::unpack)
+    pub fn from_json_manifest(manifest: PathBuf) -> Result<Self, WasmerPackageError> {
+        Self::from_json_manifest_with_strictness(manifest, Strictness::default())
+    }
+
+    /// (Re)loads a package from a manifest.json file which was created as the result of calling [`Container::unpack`](crate::Container::unpack)
+    pub fn from_json_manifest_with_strictness(
+        manifest: PathBuf,
+        strictness: Strictness,
+    ) -> Result<Self, WasmerPackageError> {
+        let base_dir = manifest
+            .parent()
+            .expect("Canonicalizing should always result in a file with a parent directory")
+            .to_path_buf();
+
+        let base_dir: BaseDir = base_dir.into();
+
+        let contents = std::fs::read(&manifest)?;
+        let manifest: WebcManifest =
+            serde_json::from_slice(&contents).map_err(|e| WasmerPackageError::JsonDeserialize {
+                path: manifest.clone(),
+                error: e,
+            })?;
+
+        let mut atoms = BTreeMap::<String, OwnedBuffer>::new();
+        for atom in manifest.atoms.keys() {
+            let path = base_dir.path().join(atom);
+
+            let contents = std::fs::read(&path)
+                .map_err(|e| WasmerPackageError::FileRead { path, error: e })?;
+
+            atoms.insert(atom.clone(), contents.into());
+        }
+
+        let mut volumes: BTreeMap<String, Arc<dyn WasmerPackageVolume + Send + Sync + 'static>> =
+            BTreeMap::new();
+        if let Some(fs_mappings) = manifest.filesystem()? {
+            for entry in fs_mappings.iter() {
+                let mut dirs = BTreeSet::new();
+                let path = entry.volume_name.strip_prefix('/').ok_or_else(|| {
+                    WasmerPackageError::MalformedPath(PathBuf::from(&entry.volume_name))
+                })?;
+                let path = base_dir.path().join(path);
+                dirs.insert(path);
+
+                volumes.insert(
+                    entry.volume_name.clone(),
+                    Arc::new(FsVolume::new(
+                        entry.volume_name.clone(),
+                        base_dir.path().to_owned(),
+                        BTreeSet::new(),
+                        dirs,
+                        include_everything_walker(),
+                    )),
+                );
+            }
+        }
+
+        let mut files = BTreeSet::new();
+        for entry in std::fs::read_dir(base_dir.path().join(FsVolume::METADATA))? {
+            let entry = entry?;
+
+            files.insert(entry.path());
+        }
+
+        if let Some(wapm) = manifest.wapm().unwrap() {
+            if let Some(license_file) = wapm.license_file.as_ref() {
+                let path = license_file.path.strip_prefix('/').ok_or_else(|| {
+                    WasmerPackageError::MalformedPath(PathBuf::from(&license_file.path))
+                })?;
+                let path = base_dir.path().join(FsVolume::METADATA).join(path);
+
+                files.insert(path);
+            }
+
+            if let Some(readme_file) = wapm.readme.as_ref() {
+                let path = readme_file.path.strip_prefix('/').ok_or_else(|| {
+                    WasmerPackageError::MalformedPath(PathBuf::from(&readme_file.path))
+                })?;
+                let path = base_dir.path().join(FsVolume::METADATA).join(path);
+
+                files.insert(path);
+            }
+        }
+
+        volumes.insert(
+            FsVolume::METADATA.to_string(),
+            Arc::new(FsVolume::new_with_intermediate_dirs(
+                FsVolume::METADATA.to_string(),
+                base_dir.path().join(FsVolume::METADATA).to_owned(),
+                files,
+                BTreeSet::new(),
+                include_everything_walker(),
+            )),
+        );
+
+        Ok(Package {
+            base_dir,
+            manifest,
+            atoms,
+            strictness,
+            volumes,
+        })
+    }
+
+    /// Create a [`Package`] from an in-memory representation.
+    pub fn from_in_memory(
+        manifest: WasmerManifest,
+        volumes: BTreeMap<String, MemoryVolume>,
+        atoms: BTreeMap<String, (Option<String>, OwnedBuffer)>,
+        metadata: MemoryVolume,
+        strictness: Strictness,
+    ) -> Result<Self, WasmerPackageError> {
+        let mut new_volumes = BTreeMap::new();
+
+        for (k, v) in volumes.into_iter() {
+            new_volumes.insert(k, Arc::new(v) as _);
+        }
+
+        new_volumes.insert(MemoryVolume::METADATA.to_string(), Arc::new(metadata) as _);
+
+        let volumes = new_volumes;
+
+        let mut annotated_atoms = BTreeMap::new();
+
+        for (atom_name, (a, b)) in atoms {
+            let annotations =
+                if let Some(module) = manifest.modules.iter().find(|v| v.name == atom_name) {
+                    module.annotations.as_ref()
+                } else {
+                    None
+                };
+
+            annotated_atoms.insert(atom_name, (a, b, annotations));
+        }
+
+        let (mut manifest, atoms) =
+            super::manifest::in_memory_wasmer_manifest_to_webc(&manifest, &annotated_atoms)?;
+
+        if let Some(entry) = manifest.package.get_mut(Wapm::KEY) {
+            let mut wapm: Wapm = entry.deserialized()?;
+
+            wapm.name.take();
+            wapm.version.take();
+            wapm.description.take();
+
+            *entry = ciborium::value::Value::serialized(&wapm)?;
+        };
+
+        Ok(Package {
+            base_dir: BaseDir::Path(Path::new("/").to_path_buf()),
+            manifest,
+            atoms,
+            strictness,
+            volumes,
+        })
+    }
+
+    fn load(
+        wasmer_toml: WasmerManifest,
+        base_dir: impl Into<BaseDir>,
+        strictness: Strictness,
+        walker_factory: WalkBuilderFactory,
+    ) -> Result<Self, WasmerPackageError> {
+        let base_dir = base_dir.into();
+
+        if strictness.is_strict() {
+            wasmer_toml.validate()?;
+        }
+
+        let (mut manifest, atoms) =
+            wasmer_manifest_to_webc(&wasmer_toml, base_dir.path(), strictness)?;
+
+        // remove name, description, and version before creating the webc file
+        if let Some(entry) = manifest.package.get_mut(Wapm::KEY) {
+            let mut wapm: Wapm = entry.deserialized()?;
+
+            wapm.name.take();
+            wapm.version.take();
+            wapm.description.take();
+
+            *entry = ciborium::value::Value::serialized(&wapm)?;
+        };
+
+        // Create volumes
+        let base_dir_path = base_dir.path().to_path_buf();
+        // Create metadata volume
+        let metadata_volume = FsVolume::new_metadata(&wasmer_toml, base_dir_path.clone())?;
+        // Create assets volume
+        let mut volumes: BTreeMap<String, Arc<dyn WasmerPackageVolume + Send + Sync + 'static>> = {
+            let old = FsVolume::new_assets(&wasmer_toml, &base_dir_path, walker_factory)?;
+            let mut new = BTreeMap::new();
+
+            for (k, v) in old.into_iter() {
+                new.insert(k, Arc::new(v) as _);
+            }
+
+            new
+        };
+        volumes.insert(
+            metadata_volume.name().to_string(),
+            Arc::new(metadata_volume),
+        );
+
+        Ok(Package {
+            base_dir,
+            manifest,
+            atoms,
+            strictness,
+            volumes,
+        })
+    }
+
+    /// Returns the Sha256 has of the webc represented by this Package
+    pub fn webc_hash(&self) -> Option<[u8; 32]> {
+        None
+    }
+
+    /// Get the WEBC manifest.
+    pub fn manifest(&self) -> &WebcManifest {
+        &self.manifest
+    }
+
+    /// Get all atoms in this package.
+    pub fn atoms(&self) -> &BTreeMap<String, OwnedBuffer> {
+        &self.atoms
+    }
+
+    /// Returns all volumes in this package
+    pub fn volumes(
+        &self,
+    ) -> impl Iterator<Item = &Arc<dyn WasmerPackageVolume + Sync + Send + 'static>> {
+        self.volumes.values()
+    }
+
+    /// Serialize the package to a `*.webc` v2 file, ignoring errors due to
+    /// missing files.
+    pub fn serialize(&self) -> Result<Bytes, Error> {
+        let mut w = Writer::new(ChecksumAlgorithm::Sha256)
+            .write_manifest(self.manifest())?
+            .write_atoms(self.atom_entries()?)?;
+
+        for (name, volume) in &self.volumes {
+            w.write_volume(name.as_str(), volume.as_directory_tree(self.strictness)?)?;
+        }
+
+        let serialized = w.finish(webc::v3::SignatureAlgorithm::None)?;
+
+        Ok(serialized)
+    }
+
+    fn atom_entries(&self) -> Result<BTreeMap<PathSegment, FileEntry<'_>>, Error> {
+        self.atoms()
+            .iter()
+            .map(|(key, value)| {
+                let filename = PathSegment::parse(key)
+                    .with_context(|| format!("\"{key}\" isn't a valid atom name"))?;
+                // FIXME: maybe?
+                Ok((filename, FileEntry::borrowed(value, Timestamps::default())))
+            })
+            .collect()
+    }
+
+    pub(crate) fn get_volume(
+        &self,
+        name: &str,
+    ) -> Option<Arc<dyn WasmerPackageVolume + Sync + Send + 'static>> {
+        self.volumes.get(name).cloned()
+    }
+
+    pub(crate) fn volume_names(&self) -> Vec<Cow<'_, str>> {
+        self.volumes
+            .keys()
+            .map(|name| Cow::Borrowed(name.as_str()))
+            .collect()
+    }
+}
+
+impl AbstractWebc for Package {
+    fn version(&self) -> Version {
+        Version::V3
+    }
+
+    fn manifest(&self) -> &WebcManifest {
+        self.manifest()
+    }
+
+    fn atom_names(&self) -> Vec<Cow<'_, str>> {
+        self.atoms()
+            .keys()
+            .map(|s| Cow::Borrowed(s.as_str()))
+            .collect()
+    }
+
+    fn get_atom(&self, name: &str) -> Option<OwnedBuffer> {
+        self.atoms().get(name).cloned()
+    }
+
+    fn get_webc_hash(&self) -> Option<[u8; 32]> {
+        self.webc_hash()
+    }
+
+    fn get_atoms_hash(&self) -> Option<[u8; 32]> {
+        None
+    }
+
+    fn volume_names(&self) -> Vec<Cow<'_, str>> {
+        self.volume_names()
+    }
+
+    fn get_volume(&self, name: &str) -> Option<Volume> {
+        self.get_volume(name).map(|v| {
+            let a: Arc<dyn AbstractVolume + Send + Sync + 'static> = v.as_volume();
+
+            Volume::from(a)
+        })
+    }
+}
+
+impl From<Package> for Container {
+    fn from(value: Package) -> Self {
+        Container::new(value)
+    }
+}
+
+const IS_WASI: bool = cfg!(all(target_family = "wasm", target_os = "wasi"));
+
+/// A polyfill for [`TempDir::new()`] that will work when compiling to
+/// WASI-based targets.
+///
+/// This works around [`std::env::temp_dir()`][tempdir] panicking
+/// unconditionally on WASI.
+///
+/// [tempdir]: https://github.com/wasix-org/rust/blob/ef19cdcdff77047f1e5ea4d09b4869d6fa456cc7/library/std/src/sys/wasi/os.rs#L228-L230
+fn tempdir() -> Result<TempDir, std::io::Error> {
+    if !IS_WASI {
+        // The happy path.
+        return TempDir::new();
+    }
+
+    // Note: When compiling to wasm32-wasip1, we can't use TempDir::new()
+    // because std::env::temp_dir() will unconditionally panic.
+    let temp_dir: PathBuf = std::env::var("TMPDIR")
+        .unwrap_or_else(|_| "/tmp".to_string())
+        .into();
+
+    if temp_dir.exists() {
+        TempDir::new_in(temp_dir)
+    } else {
+        // The temporary directory doesn't exist. A naive create_dir_all()
+        // doesn't work when running with "wasmer run" because the root
+        // directory is immutable, so let's try to use the current exe's
+        // directory as our tempdir.
+        // See also: https://github.com/wasmerio/wasmer/blob/482b78890b789f6867a91be9f306385e6255b260/lib/wasix/src/syscalls/wasi/path_create_directory.rs#L30-L32
+        if let Ok(current_exe) = std::env::current_exe() {
+            if let Some(parent) = current_exe.parent() {
+                if let Ok(temp) = TempDir::new_in(parent) {
+                    return Ok(temp);
+                }
+            }
+        }
+
+        // Oh well, this will probably fail, but at least we tried.
+        std::fs::create_dir_all(&temp_dir)?;
+        TempDir::new_in(temp_dir)
+    }
+}
+
+/// A polyfill for [`Archive::unpack()`] that is WASI-compatible.
+///
+/// This works around `canonicalize()` being [unsupported][github] on
+/// `wasm32-wasip1`.
+///
+/// [github]: https://github.com/rust-lang/rust/blob/5b1dc9de77106cb08ce9a1a8deaa14f52751d7e4/library/std/src/sys/wasi/fs.rs#L654-L658
+fn unpack_archive(
+    mut archive: Archive<impl std::io::Read>,
+    dest: &Path,
+) -> Result<(), std::io::Error> {
+    cfg_if::cfg_if! {
+        if #[cfg(all(target_family = "wasm", target_os = "wasi"))]
+        {
+            // A naive version of unpack() that should be good enough for WASI
+            // https://github.com/alexcrichton/tar-rs/blob/c77f47cb1b4b47fc4404a170d9d91cb42cc762ea/src/archive.rs#L216-L247
+            for entry in archive.entries()? {
+                let mut entry = entry?;
+                let item_path = entry.path()?;
+                let full_path = resolve_archive_path(dest, &item_path);
+
+                match entry.header().entry_type() {
+                    tar::EntryType::Directory => {
+                        std::fs::create_dir_all(&full_path)?;
+                    }
+                    tar::EntryType::Regular => {
+                        if let Some(parent) = full_path.parent() {
+                            std::fs::create_dir_all(parent)?;
+                        }
+                        let mut f = File::create(&full_path)?;
+                        std::io::copy(&mut entry, &mut f)?;
+
+                        let mtime = entry.header().mtime().unwrap_or_default();
+                        if let Err(e) = set_timestamp(full_path.as_path(), mtime) {
+                            println!("WARN: {e:?}");
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            Ok(())
+
+        } else {
+            archive.unpack(dest)
+        }
+    }
+}
+
+#[cfg(all(target_family = "wasm", target_os = "wasi"))]
+fn set_timestamp(path: &Path, timestamp: u64) -> Result<(), anyhow::Error> {
+    let fd = unsafe {
+        libc::open(
+            path.as_os_str().as_encoded_bytes().as_ptr() as _,
+            libc::O_RDONLY,
+        )
+    };
+
+    if fd < 0 {
+        anyhow::bail!(format!("failed to open: {}", path.display()));
+    }
+
+    let timespec = [
+        // accessed
+        libc::timespec {
+            tv_sec: unsafe { libc::time(std::ptr::null_mut()) }, // now
+            tv_nsec: 0,
+        },
+        // modified
+        libc::timespec {
+            tv_sec: timestamp as i64,
+            tv_nsec: 0,
+        },
+    ];
+
+    let res = unsafe { libc::futimens(fd, timespec.as_ptr() as _) };
+
+    if res < 0 {
+        anyhow::bail!("failed to set timestamp for: {}", path.display());
+    }
+
+    Ok(())
+}
+
+#[cfg(all(target_family = "wasm", target_os = "wasi"))]
+fn resolve_archive_path(base_dir: &Path, path: &Path) -> PathBuf {
+    let mut buffer = base_dir.to_path_buf();
+
+    for component in path.components() {
+        match component {
+            std::path::Component::Prefix(_)
+            | std::path::Component::RootDir
+            | std::path::Component::CurDir => continue,
+            std::path::Component::ParentDir => {
+                buffer.pop();
+            }
+            std::path::Component::Normal(segment) => {
+                buffer.push(segment);
+            }
+        }
+    }
+
+    buffer
+}
+
+fn read_manifest(base_dir: &Path) -> Result<(PathBuf, WasmerManifest), WasmerPackageError> {
+    for path in ["wasmer.toml", "wapm.toml"] {
+        let path = base_dir.join(path);
+
+        match std::fs::read_to_string(&path) {
+            Ok(s) => {
+                let toml_file = toml::from_str(&s).map_err({
+                    let path = path.clone();
+                    |error| WasmerPackageError::TomlDeserialize { path, error }
+                })?;
+
+                return Ok((path, toml_file));
+            }
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => continue,
+            Err(error) => {
+                return Err(WasmerPackageError::FileRead { path, error });
+            }
+        }
+    }
+
+    Err(WasmerPackageError::MissingManifest)
+}
+
+#[derive(Debug)]
+enum BaseDir {
+    /// An existing directory.
+    Path(PathBuf),
+    /// A temporary directory that will be deleted on drop.
+    Temp(TempDir),
+}
+
+impl BaseDir {
+    fn path(&self) -> &Path {
+        match self {
+            BaseDir::Path(p) => p.as_path(),
+            BaseDir::Temp(t) => t.path(),
+        }
+    }
+}
+
+impl From<TempDir> for BaseDir {
+    fn from(v: TempDir) -> Self {
+        Self::Temp(v)
+    }
+}
+
+impl From<PathBuf> for BaseDir {
+    fn from(v: PathBuf) -> Self {
+        Self::Path(v)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{
+        collections::BTreeMap,
+        fs::File,
+        path::{Path, PathBuf},
+        str::FromStr,
+        time::SystemTime,
+    };
+
+    use flate2::{write::GzEncoder, Compression};
+    use sha2::Digest;
+    use shared_buffer::OwnedBuffer;
+    use tempfile::TempDir;
+    use webc::{
+        metadata::{
+            annotations::{FileSystemMapping, VolumeSpecificPath},
+            Binding, BindingsExtended, WaiBindings, WitBindings,
+        },
+        PathSegment, PathSegments,
+    };
+
+    use crate::{package::*, utils::from_bytes};
+
+    #[test]
+    fn nonexistent_files() {
+        let temp = TempDir::new().unwrap();
+
+        assert!(Package::from_manifest(temp.path().join("nonexistent.toml")).is_err());
+        assert!(Package::from_tarball_file(temp.path().join("nonexistent.tar.gz")).is_err());
+    }
+
+    #[test]
+    fn load_a_tarball() {
+        let coreutils = Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("..")
+            .join("..")
+            .join("tests")
+            .join("old-tar-gz")
+            .join("coreutils-1.0.11.tar.gz");
+        assert!(coreutils.exists());
+
+        let package = Package::from_tarball_file(coreutils).unwrap();
+
+        let wapm = package.manifest().wapm().unwrap().unwrap();
+        assert!(wapm.name.is_none());
+        assert!(wapm.version.is_none());
+        assert!(wapm.description.is_none());
+    }
+
+    #[test]
+    fn tarball_with_no_manifest() {
+        let temp = TempDir::new().unwrap();
+        let empty_tarball = temp.path().join("empty.tar.gz");
+        let mut f = File::create(&empty_tarball).unwrap();
+        tar::Builder::new(GzEncoder::new(&mut f, Compression::fast()))
+            .finish()
+            .unwrap();
+
+        assert!(Package::from_tarball_file(&empty_tarball).is_err());
+    }
+
+    #[test]
+    fn empty_package_on_disk() {
+        let temp = TempDir::new().unwrap();
+        let manifest = temp.path().join("wasmer.toml");
+        std::fs::write(
+            &manifest,
+            r#"
+                [package]
+                name = "some/package"
+                version = "0.0.0"
+                description = "A dummy package"
+            "#,
+        )
+        .unwrap();
+
+        let package = Package::from_manifest(&manifest).unwrap();
+
+        let wapm = package.manifest().wapm().unwrap().unwrap();
+        assert!(wapm.name.is_none());
+        assert!(wapm.version.is_none());
+        assert!(wapm.description.is_none());
+    }
+
+    #[test]
+    fn load_old_cowsay() {
+        let tarball = Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("..")
+            .join("..")
+            .join("tests")
+            .join("old-tar-gz")
+            .join("cowsay-0.3.0.tar.gz");
+
+        let pkg = Package::from_tarball_file(tarball).unwrap();
+
+        insta::assert_yaml_snapshot!(pkg.manifest());
+        assert_eq!(
+            pkg.manifest.commands.keys().collect::<Vec<_>>(),
+            ["cowsay", "cowthink"],
+        );
+    }
+
+    #[test]
+    fn serialize_package_with_non_existent_fs() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+                [package]
+                name = "some/package"
+                version = "0.0.0"
+                description = "Test package"
+
+                [fs]
+                "/first" = "./first"
+            "#;
+        let manifest = temp.path().join("wasmer.toml");
+
+        std::fs::write(&manifest, wasmer_toml).unwrap();
+
+        let error = Package::from_manifest(manifest).unwrap_err();
+
+        match error {
+            WasmerPackageError::PathNotExists { path } => {
+                assert_eq!(path, PathBuf::from_str("./first").unwrap());
+            }
+            e => panic!("unexpected error: {e:?}"),
+        }
+    }
+
+    #[test]
+    fn serialize_package_with_bundled_directories() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+                [package]
+                name = "some/package"
+                version = "0.0.0"
+                description = "Test package"
+
+                [fs]
+                "/first" = "first"
+                second = "nested/dir"
+                "second/child" = "third"
+                empty = "empty"
+            "#;
+        let manifest = temp.path().join("wasmer.toml");
+        std::fs::write(&manifest, wasmer_toml).unwrap();
+        // Now we want to set up the following filesystem tree:
+        //
+        // - first/ ("/first")
+        //   - file.txt
+        // - nested/
+        //   - dir/ ("second")
+        //     - .wasmerignore
+        //     - .hidden (should be ignored)
+        //     - ignore_me (should be ignored)
+        //     - README.md
+        //     - another-dir/
+        //       - empty.txt
+        // - third/ ("second/child")
+        //   - file.txt
+        // - empty/ ("empty")
+        //
+        // The "/first" entry
+        let first = temp.path().join("first");
+        std::fs::create_dir_all(&first).unwrap();
+        std::fs::write(first.join("file.txt"), "File").unwrap();
+        // The "second" entry
+        let second = temp.path().join("nested").join("dir");
+        std::fs::create_dir_all(&second).unwrap();
+        std::fs::write(second.join(".wasmerignore"), "ignore_me").unwrap();
+        std::fs::write(second.join(".hidden"), "something something").unwrap();
+        std::fs::write(second.join("ignore_me"), "something something").unwrap();
+        std::fs::write(second.join("README.md"), "please").unwrap();
+        let another_dir = temp.path().join("nested").join("dir").join("another-dir");
+        std::fs::create_dir_all(&another_dir).unwrap();
+        std::fs::write(another_dir.join("empty.txt"), "").unwrap();
+        // The "second/child" entry
+        let third = temp.path().join("third");
+        std::fs::create_dir_all(&third).unwrap();
+        std::fs::write(third.join("file.txt"), "Hello, World!").unwrap();
+        // The "empty" entry
+        let empty_dir = temp.path().join("empty");
+        std::fs::create_dir_all(empty_dir).unwrap();
+
+        let package = Package::from_manifest(manifest).unwrap();
+
+        let webc = package.serialize().unwrap();
+        let webc = from_bytes(webc).unwrap();
+        let manifest = webc.manifest();
+        let wapm_metadata = manifest.wapm().unwrap().unwrap();
+        assert!(wapm_metadata.name.is_none());
+        assert!(wapm_metadata.version.is_none());
+        assert!(wapm_metadata.description.is_none());
+        let fs_table = manifest.filesystem().unwrap().unwrap();
+        assert_eq!(
+            fs_table,
+            [
+                FileSystemMapping {
+                    from: None,
+                    volume_name: "/first".to_string(),
+                    host_path: None,
+                    mount_path: "/first".to_string(),
+                },
+                FileSystemMapping {
+                    from: None,
+                    volume_name: "/nested/dir".to_string(),
+                    host_path: None,
+                    mount_path: "/second".to_string(),
+                },
+                FileSystemMapping {
+                    from: None,
+                    volume_name: "/third".to_string(),
+                    host_path: None,
+                    mount_path: "/second/child".to_string(),
+                },
+                FileSystemMapping {
+                    from: None,
+                    volume_name: "/empty".to_string(),
+                    host_path: None,
+                    mount_path: "/empty".to_string(),
+                },
+            ]
+        );
+
+        let first_file_hash: [u8; 32] = sha2::Sha256::digest(b"File").into();
+        let readme_hash: [u8; 32] = sha2::Sha256::digest(b"please").into();
+        let empty_hash: [u8; 32] = sha2::Sha256::digest(b"").into();
+        let third_file_hash: [u8; 32] = sha2::Sha256::digest(b"Hello, World!").into();
+
+        let first_volume = webc.get_volume("/first").unwrap();
+        assert_eq!(
+            first_volume.read_file("/file.txt").unwrap(),
+            (b"File".as_slice().into(), Some(first_file_hash)),
+        );
+
+        let nested_dir_volume = webc.get_volume("/nested/dir").unwrap();
+        assert_eq!(
+            nested_dir_volume.read_file("README.md").unwrap(),
+            (b"please".as_slice().into(), Some(readme_hash)),
+        );
+        assert!(nested_dir_volume.read_file(".wasmerignore").is_some());
+        assert!(nested_dir_volume.read_file(".hidden").is_some());
+        assert!(nested_dir_volume.read_file("ignore_me").is_none());
+        assert_eq!(
+            nested_dir_volume
+                .read_file("/another-dir/empty.txt")
+                .unwrap(),
+            (b"".as_slice().into(), Some(empty_hash))
+        );
+
+        let third_volume = webc.get_volume("/third").unwrap();
+        assert_eq!(
+            third_volume.read_file("/file.txt").unwrap(),
+            (b"Hello, World!".as_slice().into(), Some(third_file_hash))
+        );
+
+        let empty_volume = webc.get_volume("/empty").unwrap();
+        assert_eq!(
+            empty_volume.read_dir("/").unwrap().len(),
+            0,
+            "Directories should be included, even if empty"
+        );
+    }
+
+    #[test]
+    fn serialize_package_with_metadata_files() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+                [package]
+                name = "some/package"
+                version = "0.0.0"
+                description = "Test package"
+                readme = "README.md"
+                license-file = "LICENSE"
+            "#;
+        let manifest = temp.path().join("wasmer.toml");
+        std::fs::write(&manifest, wasmer_toml).unwrap();
+        std::fs::write(temp.path().join("README.md"), "readme").unwrap();
+        std::fs::write(temp.path().join("LICENSE"), "license").unwrap();
+
+        let serialized = Package::from_manifest(manifest)
+            .unwrap()
+            .serialize()
+            .unwrap();
+
+        let webc = from_bytes(serialized).unwrap();
+        let metadata_volume = webc.get_volume("metadata").unwrap();
+
+        let readme_hash: [u8; 32] = sha2::Sha256::digest(b"readme").into();
+        let license_hash: [u8; 32] = sha2::Sha256::digest(b"license").into();
+
+        assert_eq!(
+            metadata_volume.read_file("/README.md").unwrap(),
+            (b"readme".as_slice().into(), Some(readme_hash))
+        );
+        assert_eq!(
+            metadata_volume.read_file("/LICENSE").unwrap(),
+            (b"license".as_slice().into(), Some(license_hash))
+        );
+    }
+
+    #[test]
+    fn load_package_with_wit_bindings() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+            [package]
+            name = "some/package"
+            version = "0.0.0"
+            description = ""
+
+            [[module]]
+            name = "my-lib"
+            source = "./my-lib.wasm"
+            abi = "none"
+            bindings = { wit-bindgen = "0.1.0", wit-exports = "./file.wit" }
+        "#;
+        std::fs::write(temp.path().join("wasmer.toml"), wasmer_toml).unwrap();
+        std::fs::write(temp.path().join("file.wit"), "file").unwrap();
+        std::fs::write(temp.path().join("my-lib.wasm"), b"\0asm...").unwrap();
+
+        let package = Package::from_manifest(temp.path().join("wasmer.toml"))
+            .unwrap()
+            .serialize()
+            .unwrap();
+        let webc = from_bytes(package).unwrap();
+
+        assert_eq!(
+            webc.manifest().bindings,
+            vec![Binding {
+                name: "library-bindings".to_string(),
+                kind: "wit@0.1.0".to_string(),
+                annotations: ciborium::value::Value::serialized(&BindingsExtended::Wit(
+                    WitBindings {
+                        exports: "metadata://file.wit".to_string(),
+                        module: "my-lib".to_string(),
+                    }
+                ))
+                .unwrap(),
+            }]
+        );
+        let metadata_volume = webc.get_volume("metadata").unwrap();
+        let file_hash: [u8; 32] = sha2::Sha256::digest(b"file").into();
+        assert_eq!(
+            metadata_volume.read_file("/file.wit").unwrap(),
+            (b"file".as_slice().into(), Some(file_hash))
+        );
+        insta::with_settings! {
+            { description => wasmer_toml },
+            { insta::assert_yaml_snapshot!(webc.manifest()); }
+        }
+    }
+
+    #[test]
+    fn load_package_with_wai_bindings() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+            [package]
+            name = "some/package"
+            version = "0.0.0"
+            description = ""
+
+            [[module]]
+            name = "my-lib"
+            source = "./my-lib.wasm"
+            abi = "none"
+            bindings = { wai-version = "0.2.0", exports = "./file.wai", imports = ["a.wai", "b.wai"] }
+        "#;
+        std::fs::write(temp.path().join("wasmer.toml"), wasmer_toml).unwrap();
+        std::fs::write(temp.path().join("file.wai"), "file").unwrap();
+        std::fs::write(temp.path().join("a.wai"), "a").unwrap();
+        std::fs::write(temp.path().join("b.wai"), "b").unwrap();
+        std::fs::write(temp.path().join("my-lib.wasm"), b"\0asm...").unwrap();
+
+        let package = Package::from_manifest(temp.path().join("wasmer.toml"))
+            .unwrap()
+            .serialize()
+            .unwrap();
+        let webc = from_bytes(package).unwrap();
+
+        assert_eq!(
+            webc.manifest().bindings,
+            vec![Binding {
+                name: "library-bindings".to_string(),
+                kind: "wai@0.2.0".to_string(),
+                annotations: ciborium::value::Value::serialized(&BindingsExtended::Wai(
+                    WaiBindings {
+                        exports: Some("metadata://file.wai".to_string()),
+                        module: "my-lib".to_string(),
+                        imports: vec![
+                            "metadata://a.wai".to_string(),
+                            "metadata://b.wai".to_string(),
+                        ]
+                    }
+                ))
+                .unwrap(),
+            }]
+        );
+        let metadata_volume = webc.get_volume("metadata").unwrap();
+
+        let file_hash: [u8; 32] = sha2::Sha256::digest(b"file").into();
+        let a_hash: [u8; 32] = sha2::Sha256::digest(b"a").into();
+        let b_hash: [u8; 32] = sha2::Sha256::digest(b"b").into();
+
+        assert_eq!(
+            metadata_volume.read_file("/file.wai").unwrap(),
+            (b"file".as_slice().into(), Some(file_hash))
+        );
+        assert_eq!(
+            metadata_volume.read_file("/a.wai").unwrap(),
+            (b"a".as_slice().into(), Some(a_hash))
+        );
+        assert_eq!(
+            metadata_volume.read_file("/b.wai").unwrap(),
+            (b"b".as_slice().into(), Some(b_hash))
+        );
+        insta::with_settings! {
+            { description => wasmer_toml },
+            { insta::assert_yaml_snapshot!(webc.manifest()); }
+        }
+    }
+
+    /// See <https://github.com/wasmerio/pirita/issues/105> for more.
+    #[test]
+    fn absolute_paths_in_wasmer_toml_issue_105() {
+        let temp = TempDir::new().unwrap();
+        let base_dir = temp.path().canonicalize().unwrap();
+        let sep = std::path::MAIN_SEPARATOR;
+        let wasmer_toml = format!(
+            r#"
+                [package]
+                name = 'some/package'
+                version = '0.0.0'
+                description = 'Test package'
+                readme = '{BASE_DIR}{sep}README.md'
+                license-file = '{BASE_DIR}{sep}LICENSE'
+
+                [[module]]
+                name = 'first'
+                source = '{BASE_DIR}{sep}target{sep}debug{sep}package.wasm'
+                bindings = {{ wai-version = '0.2.0', exports = '{BASE_DIR}{sep}bindings{sep}file.wai', imports = ['{BASE_DIR}{sep}bindings{sep}a.wai'] }}
+            "#,
+            BASE_DIR = base_dir.display(),
+        );
+        let manifest = temp.path().join("wasmer.toml");
+        std::fs::write(&manifest, &wasmer_toml).unwrap();
+        std::fs::write(temp.path().join("README.md"), "readme").unwrap();
+        std::fs::write(temp.path().join("LICENSE"), "license").unwrap();
+        let bindings = temp.path().join("bindings");
+        std::fs::create_dir_all(&bindings).unwrap();
+        std::fs::write(bindings.join("file.wai"), "file.wai").unwrap();
+        std::fs::write(bindings.join("a.wai"), "a.wai").unwrap();
+        let target = temp.path().join("target").join("debug");
+        std::fs::create_dir_all(&target).unwrap();
+        std::fs::write(target.join("package.wasm"), b"\0asm...").unwrap();
+
+        let serialized = Package::from_manifest(manifest)
+            .unwrap()
+            .serialize()
+            .unwrap();
+
+        let webc = from_bytes(serialized).unwrap();
+        let manifest = webc.manifest();
+        let wapm = manifest.wapm().unwrap().unwrap();
+
+        // we should be able to look up the files using the manifest
+        let lookup = |item: VolumeSpecificPath| {
+            let volume = webc.get_volume(&item.volume).unwrap();
+            let (contents, _) = volume.read_file(&item.path).unwrap();
+            String::from_utf8(contents.into()).unwrap()
+        };
+        assert_eq!(lookup(wapm.license_file.unwrap()), "license");
+        assert_eq!(lookup(wapm.readme.unwrap()), "readme");
+
+        // The paths for bindings are stored slightly differently, but it's the
+        // same general idea
+        let lookup = |item: &str| {
+            let (volume, path) = item.split_once(":/").unwrap();
+            let volume = webc.get_volume(volume).unwrap();
+            let (content, _) = volume.read_file(path).unwrap();
+            String::from_utf8(content.into()).unwrap()
+        };
+        let bindings = manifest.bindings[0].get_wai_bindings().unwrap();
+        assert_eq!(lookup(&bindings.imports[0]), "a.wai");
+        assert_eq!(lookup(bindings.exports.unwrap().as_str()), "file.wai");
+
+        // Snapshot tests for good measure
+        let mut settings = insta::Settings::clone_current();
+        let base_dir = base_dir.display().to_string();
+        settings.set_description(wasmer_toml.replace(&base_dir, "[BASE_DIR]"));
+        let filter = regex::escape(&base_dir);
+        settings.add_filter(&filter, "[BASE_DIR]");
+        settings.bind(|| {
+            insta::assert_yaml_snapshot!(webc.manifest());
+        });
+    }
+
+    #[test]
+    fn serializing_will_skip_missing_metadata_by_default() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+                [package]
+                name = 'some/package'
+                version = '0.0.0'
+                description = 'Test package'
+                readme = '/this/does/not/exist/README.md'
+                license-file = 'LICENSE.wtf'
+            "#;
+        let manifest = temp.path().join("wasmer.toml");
+        std::fs::write(&manifest, wasmer_toml).unwrap();
+        let pkg = Package::from_manifest(manifest).unwrap();
+
+        let serialized = pkg.serialize().unwrap();
+
+        let webc = from_bytes(serialized).unwrap();
+        let manifest = webc.manifest();
+        let wapm = manifest.wapm().unwrap().unwrap();
+        // We re-wrote the WAPM annotations to just not include the license file
+        assert!(wapm.license_file.is_none());
+        assert!(wapm.readme.is_none());
+
+        // Note: serializing in strict mode should still fail
+        let pkg = Package {
+            strictness: Strictness::Strict,
+            ..pkg
+        };
+        assert!(pkg.serialize().is_err());
+    }
+
+    #[test]
+    fn serialize_package_without_local_base_fs_paths() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+                [package]
+                name = "some/package"
+                version = "0.0.0"
+                description = "Test package"
+                readme = 'README.md'
+                license-file = 'LICENSE'
+
+                [fs]
+                "/path_in_wasix" = "local-dir/dir1"
+            "#;
+        let manifest = temp.path().join("wasmer.toml");
+        std::fs::write(&manifest, wasmer_toml).unwrap();
+
+        std::fs::write(temp.path().join("README.md"), "readme").unwrap();
+        std::fs::write(temp.path().join("LICENSE"), "license").unwrap();
+
+        // Now we want to set up the following filesystem tree:
+        //
+        // - local-dir/
+        //   - dir1/
+        //     - a
+        //     - b
+        let dir1 = temp.path().join("local-dir").join("dir1");
+        std::fs::create_dir_all(&dir1).unwrap();
+
+        let a = dir1.join("a");
+        let b = dir1.join("b");
+
+        std::fs::write(a, "a").unwrap();
+        std::fs::write(b, "b").unwrap();
+
+        let package = Package::from_manifest(manifest).unwrap();
+
+        let webc = package.serialize().unwrap();
+        let webc = from_bytes(webc).unwrap();
+        let manifest = webc.manifest();
+        let wapm_metadata = manifest.wapm().unwrap().unwrap();
+
+        assert!(wapm_metadata.name.is_none());
+        assert!(wapm_metadata.version.is_none());
+        assert!(wapm_metadata.description.is_none());
+
+        let fs_table = manifest.filesystem().unwrap().unwrap();
+        assert_eq!(
+            fs_table,
+            [FileSystemMapping {
+                from: None,
+                volume_name: "/local-dir/dir1".to_string(),
+                host_path: None,
+                mount_path: "/path_in_wasix".to_string(),
+            },]
+        );
+
+        let readme_hash: [u8; 32] = sha2::Sha256::digest(b"readme").into();
+        let license_hash: [u8; 32] = sha2::Sha256::digest(b"license").into();
+
+        let a_hash: [u8; 32] = sha2::Sha256::digest(b"a").into();
+        let b_hash: [u8; 32] = sha2::Sha256::digest(b"b").into();
+
+        let dir1_volume = webc.get_volume("/local-dir/dir1").unwrap();
+        let meta_volume = webc.get_volume("metadata").unwrap();
+
+        assert_eq!(
+            meta_volume.read_file("LICENSE").unwrap(),
+            (b"license".as_slice().into(), Some(license_hash)),
+        );
+        assert_eq!(
+            meta_volume.read_file("README.md").unwrap(),
+            (b"readme".as_slice().into(), Some(readme_hash)),
+        );
+        assert_eq!(
+            dir1_volume.read_file("a").unwrap(),
+            (b"a".as_slice().into(), Some(a_hash))
+        );
+        assert_eq!(
+            dir1_volume.read_file("b").unwrap(),
+            (b"b".as_slice().into(), Some(b_hash))
+        );
+    }
+
+    #[test]
+    fn serialize_package_with_nested_fs_entries_without_local_base_fs_paths() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+                [package]
+                name = "some/package"
+                version = "0.0.0"
+                description = "Test package"
+                readme = 'README.md'
+                license-file = 'LICENSE'
+
+                [fs]
+                "/path_in_wasix" = "local-dir/dir1"
+            "#;
+        let manifest = temp.path().join("wasmer.toml");
+        std::fs::write(&manifest, wasmer_toml).unwrap();
+
+        std::fs::write(temp.path().join("README.md"), "readme").unwrap();
+        std::fs::write(temp.path().join("LICENSE"), "license").unwrap();
+
+        // Now we want to set up the following filesystem tree:
+        //
+        // - local-dir/
+        //   - dir1/
+        //     - dir2/
+        //       - a
+        //     - b
+        let local_dir = temp.path().join("local-dir");
+        std::fs::create_dir_all(&local_dir).unwrap();
+
+        let dir1 = local_dir.join("dir1");
+        std::fs::create_dir_all(&dir1).unwrap();
+
+        let dir2 = dir1.join("dir2");
+        std::fs::create_dir_all(&dir2).unwrap();
+
+        let a = dir2.join("a");
+        let b = dir1.join("b");
+
+        std::fs::write(a, "a").unwrap();
+        std::fs::write(b, "b").unwrap();
+
+        let package = Package::from_manifest(manifest).unwrap();
+
+        let webc = package.serialize().unwrap();
+        let webc = from_bytes(webc).unwrap();
+        let manifest = webc.manifest();
+        let wapm_metadata = manifest.wapm().unwrap().unwrap();
+
+        assert!(wapm_metadata.name.is_none());
+        assert!(wapm_metadata.version.is_none());
+        assert!(wapm_metadata.description.is_none());
+
+        let fs_table = manifest.filesystem().unwrap().unwrap();
+        assert_eq!(
+            fs_table,
+            [FileSystemMapping {
+                from: None,
+                volume_name: "/local-dir/dir1".to_string(),
+                host_path: None,
+                mount_path: "/path_in_wasix".to_string(),
+            },]
+        );
+
+        let readme_hash: [u8; 32] = sha2::Sha256::digest(b"readme").into();
+        let license_hash: [u8; 32] = sha2::Sha256::digest(b"license").into();
+
+        let a_hash: [u8; 32] = sha2::Sha256::digest(b"a").into();
+        let dir2_hash: [u8; 32] = sha2::Sha256::digest(a_hash).into();
+        let b_hash: [u8; 32] = sha2::Sha256::digest(b"b").into();
+
+        let dir1_volume = webc.get_volume("/local-dir/dir1").unwrap();
+        let meta_volume = webc.get_volume("metadata").unwrap();
+
+        assert_eq!(
+            meta_volume.read_file("LICENSE").unwrap(),
+            (b"license".as_slice().into(), Some(license_hash)),
+        );
+        assert_eq!(
+            meta_volume.read_file("README.md").unwrap(),
+            (b"readme".as_slice().into(), Some(readme_hash)),
+        );
+        assert_eq!(
+            dir1_volume
+                .read_dir("/")
+                .unwrap()
+                .into_iter()
+                .map(|(p, h, _)| (p, h))
+                .collect::<Vec<_>>(),
+            vec![
+                (PathSegment::parse("b").unwrap(), Some(b_hash)),
+                (PathSegment::parse("dir2").unwrap(), Some(dir2_hash))
+            ]
+        );
+        assert_eq!(
+            dir1_volume
+                .read_dir("/dir2")
+                .unwrap()
+                .into_iter()
+                .map(|(p, h, _)| (p, h))
+                .collect::<Vec<_>>(),
+            vec![(PathSegment::parse("a").unwrap(), Some(a_hash))]
+        );
+        assert_eq!(
+            dir1_volume.read_file("/dir2/a").unwrap(),
+            (b"a".as_slice().into(), Some(a_hash))
+        );
+        assert_eq!(
+            dir1_volume.read_file("/b").unwrap(),
+            (b"b".as_slice().into(), Some(b_hash))
+        );
+    }
+
+    #[test]
+    fn serialize_package_mapped_to_same_dir_without_local_base_fs_paths() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+                [package]
+                name = "some/package"
+                version = "0.0.0"
+                description = "Test package"
+                readme = 'README.md'
+                license-file = 'LICENSE'
+
+                [fs]
+                "/dir1" = "local-dir1/dir"
+                "/dir2" = "local-dir2/dir"
+            "#;
+        let manifest = temp.path().join("wasmer.toml");
+        std::fs::write(&manifest, wasmer_toml).unwrap();
+
+        std::fs::write(temp.path().join("README.md"), "readme").unwrap();
+        std::fs::write(temp.path().join("LICENSE"), "license").unwrap();
+
+        // Now we want to set up the following filesystem tree:
+        //
+        // - local-dir1/
+        //   - dir
+        // - local-dir2/
+        //   - dir
+        let dir1 = temp.path().join("local-dir1").join("dir");
+        std::fs::create_dir_all(&dir1).unwrap();
+        let dir2 = temp.path().join("local-dir2").join("dir");
+        std::fs::create_dir_all(&dir2).unwrap();
+
+        let package = Package::from_manifest(manifest).unwrap();
+
+        let webc = package.serialize().unwrap();
+        let webc = from_bytes(webc).unwrap();
+        let manifest = webc.manifest();
+        let wapm_metadata = manifest.wapm().unwrap().unwrap();
+
+        assert!(wapm_metadata.name.is_none());
+        assert!(wapm_metadata.version.is_none());
+        assert!(wapm_metadata.description.is_none());
+
+        let fs_table = manifest.filesystem().unwrap().unwrap();
+        assert_eq!(
+            fs_table,
+            [
+                FileSystemMapping {
+                    from: None,
+                    volume_name: "/local-dir1/dir".to_string(),
+                    host_path: None,
+                    mount_path: "/dir1".to_string(),
+                },
+                FileSystemMapping {
+                    from: None,
+                    volume_name: "/local-dir2/dir".to_string(),
+                    host_path: None,
+                    mount_path: "/dir2".to_string(),
+                },
+            ]
+        );
+
+        let readme_hash: [u8; 32] = sha2::Sha256::digest(b"readme").into();
+        let license_hash: [u8; 32] = sha2::Sha256::digest(b"license").into();
+
+        let dir1_volume = webc.get_volume("/local-dir1/dir").unwrap();
+        let dir2_volume = webc.get_volume("/local-dir2/dir").unwrap();
+        let meta_volume = webc.get_volume("metadata").unwrap();
+
+        assert_eq!(
+            meta_volume.read_file("LICENSE").unwrap(),
+            (b"license".as_slice().into(), Some(license_hash)),
+        );
+        assert_eq!(
+            meta_volume.read_file("README.md").unwrap(),
+            (b"readme".as_slice().into(), Some(readme_hash)),
+        );
+        assert!(dir1_volume.read_dir("/").unwrap().is_empty());
+        assert!(dir2_volume.read_dir("/").unwrap().is_empty());
+    }
+
+    #[test]
+    fn metadata_only_contains_relevant_files() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+            [package]
+            name = "some/package"
+            version = "0.0.0"
+            description = ""
+            license-file = "./path/to/LICENSE"
+            readme = "README.md"
+
+            [[module]]
+            name = "asdf"
+            source = "asdf.wasm"
+            abi = "none"
+            bindings = { wai-version = "0.2.0", exports = "asdf.wai", imports = ["browser.wai"] }
+        "#;
+
+        let manifest = temp.path().join("wasmer.toml");
+        std::fs::write(&manifest, wasmer_toml).unwrap();
+
+        let license_dir = temp.path().join("path").join("to");
+        std::fs::create_dir_all(&license_dir).unwrap();
+        std::fs::write(license_dir.join("LICENSE"), "license").unwrap();
+        std::fs::write(temp.path().join("README.md"), "readme").unwrap();
+        std::fs::write(temp.path().join("asdf.wasm"), b"\0asm...").unwrap();
+        std::fs::write(temp.path().join("asdf.wai"), "exports").unwrap();
+        std::fs::write(temp.path().join("browser.wai"), "imports").unwrap();
+        std::fs::write(temp.path().join("unwanted_file.txt"), "unwanted_file").unwrap();
+
+        let package = Package::from_manifest(manifest).unwrap();
+
+        let contents: Vec<_> = package
+            .get_volume("metadata")
+            .unwrap()
+            .read_dir(&PathSegments::ROOT)
+            .unwrap()
+            .into_iter()
+            .map(|(path, _, _)| path)
+            .collect();
+
+        assert_eq!(
+            contents,
+            vec![
+                PathSegment::parse("README.md").unwrap(),
+                PathSegment::parse("asdf.wai").unwrap(),
+                PathSegment::parse("browser.wai").unwrap(),
+                PathSegment::parse("path").unwrap(),
+            ]
+        );
+    }
+
+    #[test]
+    fn create_from_in_memory() -> anyhow::Result<()> {
+        let wasmer_toml = r#"
+            [dependencies]
+            "wasmer/python" = "3.12.9+build.9"
+            
+            
+            [[command]]
+            module = "wasmer/python:python"
+            name = "hello"
+            runner = "wasi"
+            
+            [command.annotations.wasi]
+            main-args = [ "-c", "import os; print([f for f in os.walk('/public')]); " ]
+            
+            [fs]
+            "/public" = "public" 
+        "#;
+
+        let manifest = toml::from_str(wasmer_toml)?;
+
+        let file_modified = SystemTime::now();
+        let file_data = String::from("Hello, world!").as_bytes().to_vec();
+
+        let file = MemoryFile {
+            modified: file_modified,
+            data: file_data,
+        };
+
+        let mut nodes = BTreeMap::new();
+        nodes.insert(String::from("hello.txt"), MemoryNode::File(file));
+
+        let dir_modified = SystemTime::now();
+        let dir = MemoryDir {
+            modified: dir_modified,
+            nodes,
+        };
+
+        let volume = MemoryVolume { node: dir };
+        let mut volumes = BTreeMap::new();
+
+        volumes.insert("public".to_string(), volume);
+
+        let atoms = BTreeMap::new();
+        let package = super::Package::from_in_memory(
+            manifest,
+            volumes,
+            atoms,
+            MemoryVolume {
+                node: MemoryDir {
+                    modified: SystemTime::now(),
+                    nodes: BTreeMap::new(),
+                },
+            },
+            Strictness::Strict,
+        )?;
+
+        _ = package.serialize()?;
+
+        Ok(())
+    }
+
+    #[test]
+    fn compare_fs_mem_manifest() -> anyhow::Result<()> {
+        let wasmer_toml = r#"
+            [package]
+            name = "test"
+            version = "0.0.0"
+            description = "asdf"
+        "#;
+
+        let temp = TempDir::new()?;
+        let manifest_path = temp.path().join("wasmer.toml");
+        std::fs::write(&manifest_path, wasmer_toml).unwrap();
+
+        let fs_package = super::Package::from_manifest(manifest_path)?;
+
+        let manifest = toml::from_str(wasmer_toml)?;
+        let memory_package = super::Package::from_in_memory(
+            manifest,
+            Default::default(),
+            Default::default(),
+            MemoryVolume {
+                node: MemoryDir {
+                    modified: SystemTime::UNIX_EPOCH,
+                    nodes: BTreeMap::new(),
+                },
+            },
+            Strictness::Lossy,
+        )?;
+
+        assert_eq!(memory_package.serialize()?, fs_package.serialize()?);
+
+        Ok(())
+    }
+
+    #[test]
+    fn compare_fs_mem_manifest_and_atoms() -> anyhow::Result<()> {
+        let wasmer_toml = r#"
+            [package]
+            name = "test"
+            version = "0.0.0"
+            description = "asdf"
+
+            [[module]]
+            name = "foo"
+            source = "foo.wasm"
+            abi = "wasi"
+        "#;
+
+        let temp = TempDir::new()?;
+        let manifest_path = temp.path().join("wasmer.toml");
+        std::fs::write(&manifest_path, wasmer_toml).unwrap();
+
+        let atom_path = temp.path().join("foo.wasm");
+        std::fs::write(&atom_path, b"").unwrap();
+
+        let fs_package = super::Package::from_manifest(manifest_path)?;
+
+        let manifest = toml::from_str(wasmer_toml)?;
+        let mut atoms = BTreeMap::new();
+        atoms.insert("foo".to_owned(), (None, OwnedBuffer::new()));
+        let memory_package = super::Package::from_in_memory(
+            manifest,
+            Default::default(),
+            atoms,
+            MemoryVolume {
+                node: MemoryDir {
+                    modified: SystemTime::UNIX_EPOCH,
+                    nodes: BTreeMap::new(),
+                },
+            },
+            Strictness::Lossy,
+        )?;
+
+        assert_eq!(memory_package.serialize()?, fs_package.serialize()?);
+
+        Ok(())
+    }
+
+    #[test]
+    fn compare_fs_mem_volume() -> anyhow::Result<()> {
+        let wasmer_toml = r#"
+            [package]
+            name = "test"
+            version = "0.0.0"
+            description = "asdf"
+
+            [[module]]
+            name = "foo"
+            source = "foo.wasm"
+            abi = "wasi"
+
+            [fs]
+            "/bar" = "bar"
+        "#;
+
+        let temp = TempDir::new()?;
+        let manifest_path = temp.path().join("wasmer.toml");
+        std::fs::write(&manifest_path, wasmer_toml).unwrap();
+
+        let atom_path = temp.path().join("foo.wasm");
+        std::fs::write(&atom_path, b"").unwrap();
+
+        let bar = temp.path().join("bar");
+        std::fs::create_dir(&bar).unwrap();
+
+        let baz = bar.join("baz");
+        std::fs::write(&baz, b"abc")?;
+
+        let baz_metadata = std::fs::metadata(&baz)?;
+
+        let fs_package = super::Package::from_manifest(manifest_path)?;
+
+        let manifest = toml::from_str(wasmer_toml)?;
+
+        let mut atoms = BTreeMap::new();
+        atoms.insert("foo".to_owned(), (None, OwnedBuffer::new()));
+
+        let mut volumes = BTreeMap::new();
+        volumes.insert(
+            "/bar".to_owned(),
+            MemoryVolume {
+                node: MemoryDir {
+                    modified: SystemTime::UNIX_EPOCH,
+                    nodes: {
+                        let mut children = BTreeMap::new();
+
+                        children.insert(
+                            "baz".to_owned(),
+                            MemoryNode::File(MemoryFile {
+                                modified: baz_metadata.modified()?,
+                                data: b"abc".to_vec(),
+                            }),
+                        );
+
+                        children
+                    },
+                },
+            },
+        );
+        let memory_package = super::Package::from_in_memory(
+            manifest,
+            volumes,
+            atoms,
+            MemoryVolume {
+                node: MemoryDir {
+                    modified: SystemTime::UNIX_EPOCH,
+                    nodes: Default::default(),
+                },
+            },
+            Strictness::Lossy,
+        )?;
+
+        assert_eq!(memory_package.serialize()?, fs_package.serialize()?);
+
+        Ok(())
+    }
+
+    #[test]
+    fn compare_fs_mem_bindings() -> anyhow::Result<()> {
+        let temp = TempDir::new().unwrap();
+
+        let wasmer_toml = r#"
+            [package]
+            name = "some/package"
+            version = "0.0.0"
+            description = ""
+            license-file = "LICENSE"
+            readme = "README.md"
+
+            [[module]]
+            name = "asdf"
+            source = "asdf.wasm"
+            abi = "none"
+            bindings = { wai-version = "0.2.0", exports = "asdf.wai", imports = ["browser.wai"] }
+
+            [fs]
+            "/dir1" = "local-dir1/dir"
+            "/dir2" = "local-dir2/dir"
+        "#;
+
+        let manifest = temp.path().join("wasmer.toml");
+        std::fs::write(&manifest, wasmer_toml).unwrap();
+
+        std::fs::write(temp.path().join("LICENSE"), "license").unwrap();
+        std::fs::write(temp.path().join("README.md"), "readme").unwrap();
+        std::fs::write(temp.path().join("asdf.wasm"), b"\0asm...").unwrap();
+        std::fs::write(temp.path().join("asdf.wai"), "exports").unwrap();
+        std::fs::write(temp.path().join("browser.wai"), "imports").unwrap();
+
+        // Now we want to set up the following filesystem tree:
+        //
+        // - local-dir1/
+        //   - dir
+        // - local-dir2/
+        //   - dir
+        let dir1 = temp.path().join("local-dir1").join("dir");
+        std::fs::create_dir_all(&dir1).unwrap();
+        let dir2 = temp.path().join("local-dir2").join("dir");
+        std::fs::create_dir_all(&dir2).unwrap();
+
+        let fs_package = super::Package::from_manifest(manifest)?;
+
+        let manifest = toml::from_str(wasmer_toml)?;
+
+        let mut atoms = BTreeMap::new();
+        atoms.insert(
+            "asdf".to_owned(),
+            (None, OwnedBuffer::from_static(b"\0asm...")),
+        );
+
+        let mut volumes = BTreeMap::new();
+        volumes.insert(
+            "/local-dir1/dir".to_owned(),
+            MemoryVolume {
+                node: MemoryDir {
+                    modified: SystemTime::UNIX_EPOCH,
+                    nodes: Default::default(),
+                },
+            },
+        );
+        volumes.insert(
+            "/local-dir2/dir".to_owned(),
+            MemoryVolume {
+                node: MemoryDir {
+                    modified: SystemTime::UNIX_EPOCH,
+                    nodes: Default::default(),
+                },
+            },
+        );
+
+        let memory_package = super::Package::from_in_memory(
+            manifest,
+            volumes,
+            atoms,
+            MemoryVolume {
+                node: MemoryDir {
+                    modified: SystemTime::UNIX_EPOCH,
+                    nodes: {
+                        let mut children = BTreeMap::new();
+
+                        children.insert(
+                            "README.md".to_owned(),
+                            MemoryNode::File(MemoryFile {
+                                modified: temp.path().join("README.md").metadata()?.modified()?,
+                                data: b"readme".to_vec(),
+                            }),
+                        );
+
+                        children.insert(
+                            "LICENSE".to_owned(),
+                            MemoryNode::File(MemoryFile {
+                                modified: temp.path().join("LICENSE").metadata()?.modified()?,
+                                data: b"license".to_vec(),
+                            }),
+                        );
+
+                        children.insert(
+                            "asdf.wai".to_owned(),
+                            MemoryNode::File(MemoryFile {
+                                modified: temp.path().join("asdf.wai").metadata()?.modified()?,
+                                data: b"exports".to_vec(),
+                            }),
+                        );
+
+                        children.insert(
+                            "browser.wai".to_owned(),
+                            MemoryNode::File(MemoryFile {
+                                modified: temp.path().join("browser.wai").metadata()?.modified()?,
+                                data: b"imports".to_vec(),
+                            }),
+                        );
+
+                        children
+                    },
+                },
+            },
+            Strictness::Lossy,
+        )?;
+
+        let memory_package = memory_package.serialize()?;
+        let fs_package = fs_package.serialize()?;
+
+        assert_eq!(memory_package, fs_package);
+
+        Ok(())
+    }
+}
diff --git a/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__custom_annotations_are_copied_across_verbatim.snap b/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__custom_annotations_are_copied_across_verbatim.snap
new file mode 100644
index 0000000000..2fe34c410f
--- /dev/null
+++ b/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__custom_annotations_are_copied_across_verbatim.snap
@@ -0,0 +1,26 @@
+---
+source: crates/webc/src/wasmer_package/manifest.rs
+description: "\n        [package]\n        name = \"test\"\n        version = \"0.0.0\"\n        description = \"asdf\"\n\n        [[module]]\n        name = \"module\"\n        source = \"file.wasm\"\n        abi = \"wasi\"\n\n        [[command]]\n        name = \"command\"\n        module = \"module\"\n        runner = \"asdf\"\n        annotations = { first = 42, second = [\"a\", \"b\"] }\n        "
+expression: "&transformed"
+---
+package:
+  wapm:
+    name: test
+    version: 0.0.0
+    description: asdf
+atoms:
+  module:
+    kind: "https://webc.org/kind/wasm"
+    signature: "sha256:Wjn+71LlO4/+39cFFVbsEF7YaYLxIqBdJyjZZ3jk65Y="
+commands:
+  command:
+    runner: "https://webc.org/runner/asdf"
+    annotations:
+      atom:
+        name: module
+      first: 42
+      second:
+        - a
+        - b
+entrypoint: command
+
diff --git a/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__issue_124_command_runner_is_swallowed.snap b/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__issue_124_command_runner_is_swallowed.snap
new file mode 100644
index 0000000000..b5257fed24
--- /dev/null
+++ b/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__issue_124_command_runner_is_swallowed.snap
@@ -0,0 +1,24 @@
+---
+source: crates/webc/src/wasmer_package/manifest.rs
+description: "\n            [package]\n            name = \"wasmer-tests/wcgi-always-panic\"\n            version = \"0.1.0\"\n            description = \"wasmer-tests/wcgi-always-panic website\"\n\n            [[module]]\n            name = \"wcgi-always-panic\"\n            source = \"./wcgi-always-panic.wasm\"\n            abi = \"wasi\"\n\n            [[command]]\n            name = \"wcgi\"\n            module = \"wcgi-always-panic\"\n            runner = \"https://webc.org/runner/wcgi\"\n        "
+expression: "&transformed"
+---
+package:
+  wapm:
+    name: wasmer-tests/wcgi-always-panic
+    version: 0.1.0
+    description: wasmer-tests/wcgi-always-panic website
+atoms:
+  wcgi-always-panic:
+    kind: "https://webc.org/kind/wasm"
+    signature: "sha256:Wjn+71LlO4/+39cFFVbsEF7YaYLxIqBdJyjZZ3jk65Y="
+commands:
+  wcgi:
+    runner: "https://webc.org/runner/wcgi"
+    annotations:
+      atom:
+        name: wcgi-always-panic
+      wasi:
+        atom: wcgi-always-panic
+entrypoint: wcgi
+
diff --git a/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__merge_custom_attributes_with_builtin_ones.snap b/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__merge_custom_attributes_with_builtin_ones.snap
new file mode 100644
index 0000000000..78e6f7d309
--- /dev/null
+++ b/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__merge_custom_attributes_with_builtin_ones.snap
@@ -0,0 +1,25 @@
+---
+source: crates/webc/src/wasmer_package/manifest.rs
+description: "\n            [package]\n            name = \"some/package\"\n            version = \"0.0.0\"\n            description = \"My awesome package\"\n\n            [[module]]\n            name = \"cpython\"\n            source = \"python.wasm\"\n            abi = \"wasi\"\n\n            [[command]]\n            name = \"python\"\n            module = \"cpython\"\n            runner = \"wasi\"\n            annotations = { wasi = { env = [\"KEY=val\"]} }\n        "
+expression: "&transformed"
+---
+package:
+  wapm:
+    name: some/package
+    version: 0.0.0
+    description: My awesome package
+atoms:
+  cpython:
+    kind: "https://webc.org/kind/wasm"
+    signature: "sha256:Wjn+71LlO4/+39cFFVbsEF7YaYLxIqBdJyjZZ3jk65Y="
+commands:
+  python:
+    runner: "https://webc.org/runner/wasi"
+    annotations:
+      atom:
+        name: cpython
+      wasi:
+        atom: cpython
+        env:
+          - KEY=val
+entrypoint: python
diff --git a/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_bash_manifest.snap b/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_bash_manifest.snap
new file mode 100644
index 0000000000..0d24c0c175
--- /dev/null
+++ b/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_bash_manifest.snap
@@ -0,0 +1,26 @@
+---
+source: crates/webc/src/wasmer_package/manifest.rs
+description: "\n            [package]\n            name = \"sharrattj/bash\"\n            version = \"1.0.17\"\n            description = \"Bash is a modern POSIX-compliant implementation of /bin/sh.\"\n            license = \"GNU\"\n            wasmer-extra-flags = \"--enable-threads --enable-bulk-memory\"\n\n            [dependencies]\n            \"sharrattj/coreutils\" = \"1.0.16\"\n\n            [[module]]\n            name = \"bash\"\n            source = \"bash.wasm\"\n            abi = \"wasi\"\n\n            [[command]]\n            name = \"bash\"\n            module = \"bash\"\n            runner = \"wasi@unstable_\"\n        "
+expression: "&transformed"
+---
+use:
+  sharrattj/coreutils: sharrattj/coreutils@^1.0.16
+package:
+  wapm:
+    name: sharrattj/bash
+    version: 1.0.17
+    description: Bash is a modern POSIX-compliant implementation of /bin/sh.
+    license: GNU
+atoms:
+  bash:
+    kind: "https://webc.org/kind/wasm"
+    signature: "sha256:Wjn+71LlO4/+39cFFVbsEF7YaYLxIqBdJyjZZ3jk65Y="
+commands:
+  bash:
+    runner: "https://webc.org/runner/wasi"
+    annotations:
+      atom:
+        name: bash
+      wasi:
+        atom: bash
+entrypoint: bash
diff --git a/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_empty_manifest.snap b/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_empty_manifest.snap
new file mode 100644
index 0000000000..0870a6ca27
--- /dev/null
+++ b/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_empty_manifest.snap
@@ -0,0 +1,11 @@
+---
+source: crates/webc/src/wasmer_package/manifest.rs
+description: "\n            [package]\n            name = \"some/package\"\n            version = \"0.0.0\"\n            description = \"My awesome package\"\n        "
+expression: "&transformed"
+---
+package:
+  wapm:
+    name: some/package
+    version: 0.0.0
+    description: My awesome package
+
diff --git a/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_manifest_with_atom_and_command.snap b/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_manifest_with_atom_and_command.snap
new file mode 100644
index 0000000000..7088d20848
--- /dev/null
+++ b/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_manifest_with_atom_and_command.snap
@@ -0,0 +1,24 @@
+---
+source: crates/webc/src/wasmer_package/manifest.rs
+description: "\n            [package]\n            name = \"some/package\"\n            version = \"0.0.0\"\n            description = \"My awesome package\"\n\n            [[module]]\n            name = \"cpython\"\n            source = \"python.wasm\"\n            abi = \"wasi\"\n\n            [[command]]\n            name = \"python\"\n            module = \"cpython\"\n            runner = \"wasi\"\n        "
+expression: "&transformed"
+---
+package:
+  wapm:
+    name: some/package
+    version: 0.0.0
+    description: My awesome package
+atoms:
+  cpython:
+    kind: "https://webc.org/kind/wasm"
+    signature: "sha256:Wjn+71LlO4/+39cFFVbsEF7YaYLxIqBdJyjZZ3jk65Y="
+commands:
+  python:
+    runner: "https://webc.org/runner/wasi"
+    annotations:
+      atom:
+        name: cpython
+      wasi:
+        atom: cpython
+entrypoint: python
+
diff --git a/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_manifest_with_fs_table.snap b/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_manifest_with_fs_table.snap
new file mode 100644
index 0000000000..76aacb266e
--- /dev/null
+++ b/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_manifest_with_fs_table.snap
@@ -0,0 +1,17 @@
+---
+source: crates/webc/src/wasmer_package/manifest.rs
+description: "\n            [package]\n            name = \"some/package\"\n            version = \"0.0.0\"\n            description = \"This is a package\"\n\n            [fs]\n            lib = \"lib\"\n            \"/public\" = \"out\"\n        "
+expression: "&transformed"
+---
+package:
+  wapm:
+    name: some/package
+    version: 0.0.0
+    description: This is a package
+  fs:
+    - from: ~
+      volume_name: /lib
+      mount_path: /lib
+    - from: ~
+      volume_name: /out
+      mount_path: /public
diff --git a/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_manifest_with_multiple_commands.snap b/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_manifest_with_multiple_commands.snap
new file mode 100644
index 0000000000..ca2d88afc8
--- /dev/null
+++ b/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_manifest_with_multiple_commands.snap
@@ -0,0 +1,37 @@
+---
+source: crates/webc/src/wasmer_package/manifest.rs
+description: "\n            [package]\n            name = \"some/package\"\n            version = \"0.0.0\"\n            description = \"My awesome package\"\n\n            [[module]]\n            name = \"cpython\"\n            source = \"python.wasm\"\n            abi = \"wasi\"\n\n            [[command]]\n            name = \"first\"\n            module = \"cpython\"\n            runner = \"wasi\"\n\n            [[command]]\n            name = \"second\"\n            module = \"cpython\"\n            runner = \"wasi\"\n\n            [[command]]\n            name = \"third\"\n            module = \"cpython\"\n            runner = \"wasi\"\n        "
+expression: "&transformed"
+---
+package:
+  wapm:
+    name: some/package
+    version: 0.0.0
+    description: My awesome package
+atoms:
+  cpython:
+    kind: "https://webc.org/kind/wasm"
+    signature: "sha256:Wjn+71LlO4/+39cFFVbsEF7YaYLxIqBdJyjZZ3jk65Y="
+commands:
+  first:
+    runner: "https://webc.org/runner/wasi"
+    annotations:
+      atom:
+        name: cpython
+      wasi:
+        atom: cpython
+  second:
+    runner: "https://webc.org/runner/wasi"
+    annotations:
+      atom:
+        name: cpython
+      wasi:
+        atom: cpython
+  third:
+    runner: "https://webc.org/runner/wasi"
+    annotations:
+      atom:
+        name: cpython
+      wasi:
+        atom: cpython
+
diff --git a/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_manifest_with_single_atom.snap b/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_manifest_with_single_atom.snap
new file mode 100644
index 0000000000..c320b3a80d
--- /dev/null
+++ b/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_manifest_with_single_atom.snap
@@ -0,0 +1,15 @@
+---
+source: crates/webc/src/wasmer_package/manifest.rs
+description: "\n            [package]\n            name = \"some/package\"\n            version = \"0.0.0\"\n            description = \"My awesome package\"\n\n            [[module]]\n            name = \"first\"\n            source = \"./path/to/file.wasm\"\n            abi = \"wasi\"\n        "
+expression: "&transformed"
+---
+package:
+  wapm:
+    name: some/package
+    version: 0.0.0
+    description: My awesome package
+atoms:
+  first:
+    kind: "https://webc.org/kind/wasm"
+    signature: "sha256:Wjn+71LlO4/+39cFFVbsEF7YaYLxIqBdJyjZZ3jk65Y="
+
diff --git a/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_python_manifest.snap b/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_python_manifest.snap
new file mode 100644
index 0000000000..a9cd3d9161
--- /dev/null
+++ b/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_python_manifest.snap
@@ -0,0 +1,29 @@
+---
+source: crates/webc/src/wasmer_package/manifest.rs
+description: "\n            [package]\n            name = \"python\"\n            version = \"0.1.0\"\n            description = \"Python is an interpreted, high-level, general-purpose programming language\"\n            license = \"ISC\"\n            repository = \"https://github.com/wapm-packages/python\"\n\n            [[module]]\n            name = \"python\"\n            source = \"bin/python.wasm\"\n            abi = \"wasi\"\n\n            [module.interfaces]\n            wasi = \"0.0.0-unstable\"\n\n            [[command]]\n            name = \"python\"\n            module = \"python\"\n\n            [fs]\n            lib = \"lib\"\n        "
+expression: "&transformed"
+---
+package:
+  wapm:
+    name: python
+    version: 0.1.0
+    description: "Python is an interpreted, high-level, general-purpose programming language"
+    license: ISC
+    repository: "https://github.com/wapm-packages/python"
+  fs:
+    - from: ~
+      volume_name: /lib
+      mount_path: /lib
+atoms:
+  python:
+    kind: "https://webc.org/kind/wasm"
+    signature: "sha256:Wjn+71LlO4/+39cFFVbsEF7YaYLxIqBdJyjZZ3jk65Y="
+commands:
+  python:
+    runner: "https://webc.org/runner/wasi"
+    annotations:
+      atom:
+        name: python
+      wasi:
+        atom: python
+entrypoint: python
diff --git a/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_wasmer_pack_manifest.snap b/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_wasmer_pack_manifest.snap
new file mode 100644
index 0000000000..fa86e62826
--- /dev/null
+++ b/lib/package/src/package/snapshots/wasmer_package__package__manifest__tests__transform_wasmer_pack_manifest.snap
@@ -0,0 +1,28 @@
+---
+source: crates/webc/src/wasmer_package/manifest.rs
+description: "\n            [package]\n            name = \"wasmer/wasmer-pack\"\n            version = \"0.7.0\"\n            description = \"The WebAssembly interface to wasmer-pack.\"\n            license = \"MIT\"\n            readme = \"README.md\"\n            repository = \"https://github.com/wasmerio/wasmer-pack\"\n            homepage = \"https://wasmer.io/\"\n\n            [[module]]\n            name = \"wasmer-pack-wasm\"\n            source = \"wasmer_pack_wasm.wasm\"\n\n            [module.bindings]\n            wai-version = \"0.2.0\"\n            exports = \"wasmer-pack.exports.wai\"\n            imports = []\n        "
+expression: "&transformed"
+---
+package:
+  wapm:
+    name: wasmer/wasmer-pack
+    version: 0.7.0
+    description: The WebAssembly interface to wasmer-pack.
+    license: MIT
+    readme:
+      volume: metadata
+      path: /README.md
+    repository: "https://github.com/wasmerio/wasmer-pack"
+    homepage: "https://wasmer.io/"
+atoms:
+  wasmer-pack-wasm:
+    kind: "https://webc.org/kind/wasm"
+    signature: "sha256:Wjn+71LlO4/+39cFFVbsEF7YaYLxIqBdJyjZZ3jk65Y="
+bindings:
+  - name: library-bindings
+    kind: wai@0.2.0
+    annotations:
+      wai:
+        exports: "metadata://wasmer-pack.exports.wai"
+        module: wasmer-pack-wasm
+        imports: []
diff --git a/lib/package/src/package/snapshots/wasmer_package__package__package__tests__absolute_paths_in_wasmer_toml_issue_105.snap b/lib/package/src/package/snapshots/wasmer_package__package__package__tests__absolute_paths_in_wasmer_toml_issue_105.snap
new file mode 100644
index 0000000000..15884c47a9
--- /dev/null
+++ b/lib/package/src/package/snapshots/wasmer_package__package__package__tests__absolute_paths_in_wasmer_toml_issue_105.snap
@@ -0,0 +1,26 @@
+---
+source: crates/webc/src/wasmer_package/package.rs
+description: "\n                [package]\n                name = 'some/package'\n                version = '0.0.0'\n                description = 'Test package'\n                readme = '[BASE_DIR]/README.md'\n                license-file = '[BASE_DIR]/LICENSE'\n\n                [[module]]\n                name = 'first'\n                source = '[BASE_DIR]/target/debug/package.wasm'\n                bindings = { wai-version = '0.2.0', exports = '[BASE_DIR]/bindings/file.wai', imports = ['[BASE_DIR]/bindings/a.wai'] }\n            "
+expression: webc.manifest()
+---
+package:
+  wapm:
+    license-file:
+      volume: metadata
+      path: /LICENSE
+    readme:
+      volume: metadata
+      path: /README.md
+atoms:
+  first:
+    kind: "https://webc.org/kind/wasm"
+    signature: "sha256:Wjn+71LlO4/+39cFFVbsEF7YaYLxIqBdJyjZZ3jk65Y="
+bindings:
+  - name: library-bindings
+    kind: wai@0.2.0
+    annotations:
+      wai:
+        exports: "metadata://bindings/file.wai"
+        module: first
+        imports:
+          - "metadata://bindings/a.wai"
diff --git a/lib/package/src/package/snapshots/wasmer_package__package__package__tests__load_old_cowsay.snap b/lib/package/src/package/snapshots/wasmer_package__package__package__tests__load_old_cowsay.snap
new file mode 100644
index 0000000000..3f4543df47
--- /dev/null
+++ b/lib/package/src/package/snapshots/wasmer_package__package__package__tests__load_old_cowsay.snap
@@ -0,0 +1,37 @@
+---
+source: lib/package/src/package/package.rs
+expression: pkg.manifest()
+---
+package:
+  wapm:
+    readme:
+      volume: metadata
+      path: /README.md
+    repository: "https://github.com/wapm-packages/cowsay"
+atoms:
+  cowsay:
+    kind: "https://webc.org/kind/wasm"
+    signature: "sha256:DPmhiSNXCg5261eTUi3BIvAc/aJttGj+nD+bGhQkVQo="
+    annotations:
+      wasm:
+        features:
+          - simd
+          - bulk-memory
+          - reference-types
+          - multi-value
+          - threads
+commands:
+  cowsay:
+    runner: "https://webc.org/runner/wasi"
+    annotations:
+      atom:
+        name: cowsay
+      wasi:
+        atom: cowsay
+  cowthink:
+    runner: "https://webc.org/runner/wasi"
+    annotations:
+      atom:
+        name: cowsay
+      wasi:
+        atom: cowsay
diff --git a/lib/package/src/package/snapshots/wasmer_package__package__package__tests__load_package_with_wai_bindings.snap b/lib/package/src/package/snapshots/wasmer_package__package__package__tests__load_package_with_wai_bindings.snap
new file mode 100644
index 0000000000..243ecd921f
--- /dev/null
+++ b/lib/package/src/package/snapshots/wasmer_package__package__package__tests__load_package_with_wai_bindings.snap
@@ -0,0 +1,21 @@
+---
+source: crates/webc/src/wasmer_package/package.rs
+description: "\n            [package]\n            name = \"some/package\"\n            version = \"0.0.0\"\n            description = \"\"\n\n            [[module]]\n            name = \"my-lib\"\n            source = \"./my-lib.wasm\"\n            abi = \"none\"\n            bindings = { wai-version = \"0.2.0\", exports = \"./file.wai\", imports = [\"a.wai\", \"b.wai\"] }\n        "
+expression: webc.manifest()
+---
+package:
+  wapm: {}
+atoms:
+  my-lib:
+    kind: "https://webc.org/kind/wasm"
+    signature: "sha256:Wjn+71LlO4/+39cFFVbsEF7YaYLxIqBdJyjZZ3jk65Y="
+bindings:
+  - name: library-bindings
+    kind: wai@0.2.0
+    annotations:
+      wai:
+        exports: "metadata://file.wai"
+        module: my-lib
+        imports:
+          - "metadata://a.wai"
+          - "metadata://b.wai"
diff --git a/lib/package/src/package/snapshots/wasmer_package__package__package__tests__load_package_with_wit_bindings.snap b/lib/package/src/package/snapshots/wasmer_package__package__package__tests__load_package_with_wit_bindings.snap
new file mode 100644
index 0000000000..020af80dfe
--- /dev/null
+++ b/lib/package/src/package/snapshots/wasmer_package__package__package__tests__load_package_with_wit_bindings.snap
@@ -0,0 +1,18 @@
+---
+source: crates/webc/src/wasmer_package/package.rs
+description: "\n            [package]\n            name = \"some/package\"\n            version = \"0.0.0\"\n            description = \"\"\n\n            [[module]]\n            name = \"my-lib\"\n            source = \"./my-lib.wasm\"\n            abi = \"none\"\n            bindings = { wit-bindgen = \"0.1.0\", wit-exports = \"./file.wit\" }\n        "
+expression: webc.manifest()
+---
+package:
+  wapm: {}
+atoms:
+  my-lib:
+    kind: "https://webc.org/kind/wasm"
+    signature: "sha256:Wjn+71LlO4/+39cFFVbsEF7YaYLxIqBdJyjZZ3jk65Y="
+bindings:
+  - name: library-bindings
+    kind: wit@0.1.0
+    annotations:
+      wit:
+        exports: "metadata://file.wit"
+        module: my-lib
diff --git a/lib/package/src/package/strictness.rs b/lib/package/src/package/strictness.rs
new file mode 100644
index 0000000000..3831079e64
--- /dev/null
+++ b/lib/package/src/package/strictness.rs
@@ -0,0 +1,48 @@
+use std::{fmt::Debug, path::Path};
+
+use super::ManifestError;
+
+/// The strictness to use when working with a
+/// [`crate::wasmer_package::Package`].
+///
+/// This can be useful when loading a package that may be edited interactively
+/// or if you just want to use a package and don't care if the manifest is
+/// invalid.
+#[derive(Debug, Default, Copy, Clone, PartialEq)]
+pub enum Strictness {
+    /// Prefer to lose data rather than error out.
+    #[default]
+    Lossy,
+    /// All package issues should be errors.
+    Strict,
+}
+
+impl Strictness {
+    pub(crate) fn is_strict(self) -> bool {
+        matches!(self, Strictness::Strict)
+    }
+
+    pub(crate) fn outside_base_directory(
+        &self,
+        path: &Path,
+        base_dir: &Path,
+    ) -> Result<(), ManifestError> {
+        match self {
+            Strictness::Lossy => todo!(),
+            Strictness::Strict => Err(ManifestError::OutsideBaseDirectory {
+                path: path.to_path_buf(),
+                base_dir: base_dir.to_path_buf(),
+            }),
+        }
+    }
+
+    pub(crate) fn missing_file(&self, path: &Path, base_dir: &Path) -> Result<(), ManifestError> {
+        match self {
+            Strictness::Lossy => Ok(()),
+            Strictness::Strict => Err(ManifestError::MissingFile {
+                path: path.to_path_buf(),
+                base_dir: base_dir.to_path_buf(),
+            }),
+        }
+    }
+}
diff --git a/lib/package/src/package/volume/fs.rs b/lib/package/src/package/volume/fs.rs
new file mode 100644
index 0000000000..f93094918b
--- /dev/null
+++ b/lib/package/src/package/volume/fs.rs
@@ -0,0 +1,568 @@
+use std::{
+    collections::{BTreeMap, BTreeSet},
+    fmt::Debug,
+    fs::File,
+    io::Read,
+    path::{Path, PathBuf},
+};
+
+use anyhow::{Context, Error};
+use shared_buffer::OwnedBuffer;
+
+use webc::{
+    sanitize_path,
+    v3::{
+        self,
+        write::{DirEntry, Directory, FileEntry},
+    },
+    AbstractVolume, Metadata, PathSegment, PathSegments, Timestamps, ToPathSegments,
+};
+
+use crate::package::{Strictness, WalkBuilderFactory};
+
+use super::WasmerPackageVolume;
+
+/// A lazily loaded volume in a Wasmer package.
+///
+/// Note that it is the package resolver's role to interpret a package's
+/// [`crate::metadata::annotations::FileSystemMappings`]. A [`Volume`] contains
+/// directories as they were when the package was published.
+pub struct FsVolume {
+    /// Name of the volume
+    name: String,
+    /// A pre-computed set of intermediate directories that are needed to allow
+    /// access to the whitelisted files and directories.
+    intermediate_directories: BTreeSet<PathBuf>,
+    /// Specific files that this volume has access to.
+    metadata_files: BTreeSet<PathBuf>,
+    /// Directories that allow the user to access anything inside them.
+    mapped_directories: BTreeSet<PathBuf>,
+    /// The base directory all [`PathSegments`] will be resolved relative to.
+    base_dir: PathBuf,
+    /// The walker builder factory to use when reading directories.
+    walker_factory: WalkBuilderFactory,
+}
+
+impl Debug for FsVolume {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("FsVolume")
+            .field("name", &self.name)
+            .field("intermediate_directories", &self.intermediate_directories)
+            .field("metadata_files", &self.metadata_files)
+            .field("mapped_directories", &self.mapped_directories)
+            .field("base_dir", &self.base_dir)
+            .finish()
+    }
+}
+
+impl FsVolume {
+    /// The name of the volume used to store metadata files.
+    pub(crate) const METADATA: &'static str = "metadata";
+
+    /// Create a new metadata volume.
+    pub(crate) fn new_metadata(
+        manifest: &wasmer_config::package::Manifest,
+        base_dir: impl Into<PathBuf>,
+    ) -> Result<Self, Error> {
+        let base_dir = base_dir.into();
+        let mut files = BTreeSet::new();
+
+        // check if manifest.package is None
+        if let Some(package) = &manifest.package {
+            if let Some(license_file) = &package.license_file {
+                files.insert(base_dir.join(license_file));
+            }
+
+            if let Some(readme) = &package.readme {
+                files.insert(base_dir.join(readme));
+            }
+        }
+
+        for module in &manifest.modules {
+            if let Some(bindings) = &module.bindings {
+                let bindings_files = bindings.referenced_files(&base_dir)?;
+                files.extend(bindings_files);
+            }
+        }
+
+        Ok(FsVolume::new_with_intermediate_dirs(
+            FsVolume::METADATA.to_string(),
+            base_dir,
+            files,
+            BTreeSet::new(),
+            crate::package::include_everything_walker(),
+        ))
+    }
+
+    pub(crate) fn new_assets(
+        manifest: &wasmer_config::package::Manifest,
+        base_dir: &Path,
+        walker_factory: crate::package::WalkBuilderFactory,
+    ) -> Result<BTreeMap<String, Self>, Error> {
+        // Create asset volumes
+        let dirs: BTreeSet<_> = manifest
+            .fs
+            .values()
+            .map(|path| base_dir.join(path))
+            .collect();
+
+        for path in &dirs {
+            // Perform a basic sanity check to make sure the directories exist.
+            let _ = std::fs::metadata(path).with_context(|| {
+                format!("Unable to get the metadata for \"{}\"", path.display())
+            })?;
+        }
+
+        let mut volumes = BTreeMap::new();
+        for entry in manifest.fs.values() {
+            let name = entry
+                .to_str()
+                .ok_or_else(|| anyhow::anyhow!("Failed to convert path to str"))?;
+
+            let name = sanitize_path(name);
+
+            let mut dirs = BTreeSet::new();
+            let dir = base_dir.join(entry);
+            dirs.insert(dir);
+
+            volumes.insert(
+                name.clone(),
+                FsVolume::new(
+                    name.to_string(),
+                    base_dir.to_path_buf(),
+                    BTreeSet::new(),
+                    dirs,
+                    walker_factory,
+                ),
+            );
+        }
+
+        Ok(volumes)
+    }
+
+    pub(crate) fn new_with_intermediate_dirs(
+        name: String,
+        base_dir: PathBuf,
+        whitelisted_files: BTreeSet<PathBuf>,
+        whitelisted_directories: BTreeSet<PathBuf>,
+        walker_factory: crate::package::WalkBuilderFactory,
+    ) -> Self {
+        let mut intermediate_directories: BTreeSet<PathBuf> = whitelisted_files
+            .iter()
+            .filter_map(|p| p.parent())
+            .chain(whitelisted_directories.iter().map(|p| p.as_path()))
+            .flat_map(|dir| dir.ancestors())
+            .filter(|dir| dir.starts_with(&base_dir))
+            .map(|dir| dir.to_path_buf())
+            .collect();
+
+        // The base directory is always accessible (even if its contents isn't)
+        intermediate_directories.insert(base_dir.clone());
+
+        FsVolume {
+            name,
+            intermediate_directories,
+            metadata_files: whitelisted_files,
+            mapped_directories: whitelisted_directories,
+            base_dir,
+            walker_factory,
+        }
+    }
+
+    pub(crate) fn new(
+        name: String,
+        base_dir: PathBuf,
+        whitelisted_files: BTreeSet<PathBuf>,
+        whitelisted_directories: BTreeSet<PathBuf>,
+        walker_factory: crate::package::WalkBuilderFactory,
+    ) -> Self {
+        FsVolume {
+            name,
+            intermediate_directories: BTreeSet::new(),
+            metadata_files: whitelisted_files,
+            mapped_directories: whitelisted_directories,
+            base_dir,
+            walker_factory,
+        }
+    }
+
+    fn is_accessible(&self, path: &Path) -> bool {
+        self.intermediate_directories.contains(path)
+            || self.metadata_files.contains(path)
+            || self
+                .mapped_directories
+                .iter()
+                .any(|dir| path.starts_with(dir))
+    }
+
+    fn resolve(&self, path: &PathSegments) -> Option<PathBuf> {
+        let resolved = if let Some(dir) = &self.mapped_directories.first() {
+            resolve(dir, path)
+        } else {
+            resolve(&self.base_dir, path)
+        };
+
+        let accessible = self.is_accessible(&resolved);
+        accessible.then_some(resolved)
+    }
+
+    /// Returns the name of the volume
+    pub fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    /// Read a file from the volume.
+    pub fn read_file(&self, path: &PathSegments) -> Option<OwnedBuffer> {
+        let path = self.resolve(path)?;
+        let mut f = File::open(path).ok()?;
+
+        // First we try to mmap it
+        if let Ok(mmapped) = OwnedBuffer::from_file(&f) {
+            return Some(mmapped);
+        }
+
+        // otherwise, fall back to reading the file's contents into memory
+        let mut buffer = Vec::new();
+        f.read_to_end(&mut buffer).ok()?;
+        Some(OwnedBuffer::from_bytes(buffer))
+    }
+
+    /// Read the contents of a directory.
+    #[allow(clippy::type_complexity)]
+    pub fn read_dir(
+        &self,
+        path: &PathSegments,
+    ) -> Option<Vec<(PathSegment, Option<[u8; 32]>, Metadata)>> {
+        let resolved = self.resolve(path)?;
+
+        let mut walker_builder = self.walker_factory.create_walk_builder(&resolved);
+        walker_builder.max_depth(Some(1));
+        let walker = walker_builder.build();
+
+        let mut entries = Vec::new();
+
+        for entry in walker {
+            let entry = entry.ok()?;
+            // Walk returns the root dir as well, we don't want to process it
+            if entry.depth() == 0 {
+                continue;
+            }
+
+            let entry = entry.path();
+
+            if !self.is_accessible(entry) {
+                continue;
+            }
+
+            let segment: PathSegment = entry.file_name()?.to_str()?.parse().ok()?;
+
+            let path = path.join(segment.clone());
+            let metadata = self.metadata(&path)?;
+            entries.push((segment, None, metadata));
+        }
+
+        entries.sort_by_key(|k| k.0.clone());
+
+        Some(entries)
+    }
+
+    /// Get the metadata for a particular item.
+    pub fn metadata(&self, path: &PathSegments) -> Option<Metadata> {
+        let path = self.resolve(path)?;
+        let meta = path.metadata().ok()?;
+
+        let timestamps = Timestamps::from_metadata(&meta).unwrap();
+
+        if meta.is_dir() {
+            Some(Metadata::Dir {
+                timestamps: Some(timestamps),
+            })
+        } else if meta.is_file() {
+            Some(Metadata::File {
+                length: meta.len().try_into().ok()?,
+                timestamps: Some(timestamps),
+            })
+        } else {
+            None
+        }
+    }
+
+    pub(crate) fn as_directory_tree(&self, strictness: Strictness) -> Result<Directory<'_>, Error> {
+        if self.name() == "metadata" {
+            let mut root = Directory::default();
+
+            for file_path in self.metadata_files.iter() {
+                if !file_path.exists() || !file_path.is_file() {
+                    if strictness.is_strict() {
+                        anyhow::bail!("{} does not exist", file_path.display());
+                    }
+
+                    // ignore missing metadata
+                    continue;
+                }
+                let path = file_path.strip_prefix(&self.base_dir)?;
+                let path = PathBuf::from("/").join(path);
+                let segments = path.to_path_segments()?;
+                let segments: Vec<_> = segments.iter().collect();
+
+                let file_entry = DirEntry::File(FileEntry::from_path(file_path)?);
+
+                let mut curr_dir = &mut root;
+                for (index, segment) in segments.iter().enumerate() {
+                    if segments.len() == 1 {
+                        curr_dir.children.insert((*segment).clone(), file_entry);
+                        break;
+                    } else {
+                        if index == segments.len() - 1 {
+                            curr_dir.children.insert((*segment).clone(), file_entry);
+                            break;
+                        }
+
+                        let curr_entry = curr_dir
+                            .children
+                            .entry((*segment).clone())
+                            .or_insert(DirEntry::Dir(Directory::default()));
+                        let DirEntry::Dir(dir) = curr_entry else {
+                            unreachable!()
+                        };
+
+                        curr_dir = dir;
+                    }
+                }
+            }
+
+            Ok(root)
+        } else {
+            let paths: Vec<_> = self.mapped_directories.iter().cloned().collect();
+            directory_tree(paths, &self.base_dir, self.walker_factory)
+        }
+    }
+}
+
+impl AbstractVolume for FsVolume {
+    fn read_file(&self, path: &PathSegments) -> Option<(OwnedBuffer, Option<[u8; 32]>)> {
+        self.read_file(path).map(|c| (c, None))
+    }
+
+    fn read_dir(
+        &self,
+        path: &PathSegments,
+    ) -> Option<Vec<(PathSegment, Option<[u8; 32]>, Metadata)>> {
+        self.read_dir(path)
+    }
+
+    fn metadata(&self, path: &PathSegments) -> Option<Metadata> {
+        self.metadata(path)
+    }
+}
+
+impl WasmerPackageVolume for FsVolume {
+    fn as_directory_tree(&self, strictness: Strictness) -> Result<Directory<'_>, Error> {
+        self.as_directory_tree(strictness)
+    }
+}
+
+/// Resolve a [`PathSegments`] to its equivalent path on disk.
+fn resolve(base_dir: &Path, path: &PathSegments) -> PathBuf {
+    let mut resolved = base_dir.to_path_buf();
+    for segment in path.iter() {
+        resolved.push(segment.as_str());
+    }
+
+    resolved
+}
+
+/// Given a list of absolute paths, create a directory tree relative to some
+/// base directory.
+fn directory_tree(
+    paths: impl IntoIterator<Item = PathBuf>,
+    base_dir: &Path,
+    walker_factory: crate::package::WalkBuilderFactory,
+) -> Result<Directory<'static>, Error> {
+    let paths: Vec<_> = paths.into_iter().collect();
+    let mut root = Directory::default();
+
+    for path in paths {
+        if path.is_file() {
+            let dir_entry = v3::write::DirEntry::File(v3::write::FileEntry::from_path(&path)?);
+            let path = path.strip_prefix(base_dir)?;
+            let path_segment = PathSegment::try_from(path.as_os_str())?;
+
+            if root.children.insert(path_segment, dir_entry).is_some() {
+                println!("Warning: {path:?} already exists. Overriding the old entry");
+            }
+        } else {
+            let dir = webc::v3::write::Directory::from_path_with_walker(
+                &path,
+                walker_factory.create_walk_builder(&path).build(),
+            )
+            .map_err(|e| {
+                Error::from(e).context(format!(
+                    "Unable to add \"{}\" to the directory tree",
+                    path.display()
+                ))
+            })?;
+            for (path, child) in dir.children {
+                root.children.insert(path.clone(), child);
+            }
+        }
+    }
+
+    Ok(root)
+}
+
+#[cfg(test)]
+mod tests {
+    use tempfile::TempDir;
+    use wasmer_config::package::Manifest;
+
+    use super::*;
+
+    #[test]
+    fn metadata_volume() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+            [package]
+            name = "some/package"
+            version = "0.0.0"
+            description = ""
+            license-file = "./path/to/LICENSE"
+            readme = "README.md"
+
+            [[module]]
+            name = "asdf"
+            source = "asdf.wasm"
+            abi = "none"
+            bindings = { wai-version = "0.2.0", exports = "asdf.wai", imports = ["browser.wai"] }
+        "#;
+        let wasmer_toml_path = temp.path().join("wasmer.toml");
+        std::fs::write(&wasmer_toml_path, wasmer_toml.as_bytes()).unwrap();
+        let license_dir = temp.path().join("path").join("to");
+        std::fs::create_dir_all(&license_dir).unwrap();
+        std::fs::write(license_dir.join("LICENSE"), "license").unwrap();
+        std::fs::write(temp.path().join("README.md"), "readme").unwrap();
+        std::fs::write(temp.path().join("asdf.wai"), "exports").unwrap();
+        std::fs::write(temp.path().join("browser.wai"), "imports").unwrap();
+        let manifest: Manifest = toml::from_str(wasmer_toml).unwrap();
+
+        let volume = FsVolume::new_metadata(&manifest, temp.path().to_path_buf()).unwrap();
+
+        let entries = volume.read_dir(&PathSegments::ROOT).unwrap();
+        let expected = [
+            PathSegment::parse("README.md").unwrap(),
+            PathSegment::parse("asdf.wai").unwrap(),
+            PathSegment::parse("browser.wai").unwrap(),
+            PathSegment::parse("path").unwrap(),
+        ];
+
+        for i in 0..expected.len() {
+            assert_eq!(entries[i].0, expected[i]);
+            assert!(entries[i].2.timestamps().is_some());
+        }
+
+        let license: PathSegments = "/path/to/LICENSE".parse().unwrap();
+        assert_eq!(
+            String::from_utf8(volume.read_file(&license).unwrap().into()).unwrap(),
+            "license"
+        );
+    }
+
+    #[test]
+    fn asset_volume() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+            [package]
+            name = "some/package"
+            version = "0.0.0"
+            description = ""
+            license_file = "./path/to/LICENSE"
+            readme = "README.md"
+
+            [[module]]
+            name = "asdf"
+            source = "asdf.wasm"
+            abi = "none"
+            bindings = { wai-version = "0.2.0", exports = "asdf.wai", imports = ["browser.wai"] }
+
+            [fs]
+            "/etc" = "etc"
+        "#;
+        let license_dir = temp.path().join("path").join("to");
+        std::fs::create_dir_all(&license_dir).unwrap();
+        std::fs::write(license_dir.join("LICENSE"), "license").unwrap();
+        std::fs::write(temp.path().join("README.md"), "readme").unwrap();
+        std::fs::write(temp.path().join("asdf.wai"), "exports").unwrap();
+        std::fs::write(temp.path().join("browser.wai"), "imports").unwrap();
+
+        let etc = temp.path().join("etc");
+        let share = etc.join("share");
+        std::fs::create_dir_all(&share).unwrap();
+
+        std::fs::write(etc.join(".wasmerignore"), b"ignore_me").unwrap();
+        std::fs::write(etc.join(".hidden"), "anything, really").unwrap();
+        std::fs::write(etc.join("ignore_me"), "I should be ignored").unwrap();
+        std::fs::write(share.join("package.1"), "man page").unwrap();
+        std::fs::write(share.join("ignore_me"), "I should be ignored too").unwrap();
+
+        let manifest: Manifest = toml::from_str(wasmer_toml).unwrap();
+
+        let volume = FsVolume::new_assets(
+            &manifest,
+            temp.path(),
+            crate::package::wasmer_ignore_walker(),
+        )
+        .unwrap();
+
+        let volume = &volume["/etc"];
+
+        let entries = volume.read_dir(&PathSegments::ROOT).unwrap();
+        let expected = [
+            PathSegment::parse(".hidden").unwrap(),
+            PathSegment::parse(".wasmerignore").unwrap(),
+            PathSegment::parse("share").unwrap(),
+        ];
+
+        for i in 0..expected.len() {
+            assert_eq!(entries[i].0, expected[i]);
+            assert!(entries[i].2.timestamps().is_some());
+        }
+
+        let man_page: PathSegments = "/share/package.1".parse().unwrap();
+        assert_eq!(
+            String::from_utf8(volume.read_file(&man_page).unwrap().into()).unwrap(),
+            "man page"
+        );
+    }
+
+    #[test]
+    fn directory_tree_propagates_errors() {
+        let temp = TempDir::new().unwrap();
+
+        // Create a directory that will be used as the base directory
+        let base_dir = temp.path().to_path_buf();
+
+        // Create a non-existent path that will cause `from_path_with_walker` to fail
+        let non_existent_path = base_dir.join("non_existent_dir");
+
+        // Try to create a directory tree with a non-existent path
+        let result = directory_tree(
+            std::iter::once(non_existent_path.clone()),
+            &base_dir,
+            crate::package::wasmer_ignore_walker(),
+        );
+
+        // Verify that the error is propagated
+        assert!(result.is_err());
+        let error = result.unwrap_err();
+        assert!(
+            error.to_string().contains("Unable to add"),
+            "Error message should indicate failure to add path: {}",
+            error
+        );
+        assert!(
+            error.to_string().contains("non_existent_dir"),
+            "Error message should include the problematic path: {}",
+            error
+        );
+    }
+}
diff --git a/lib/package/src/package/volume/in_memory.rs b/lib/package/src/package/volume/in_memory.rs
new file mode 100644
index 0000000000..5754736661
--- /dev/null
+++ b/lib/package/src/package/volume/in_memory.rs
@@ -0,0 +1,465 @@
+use std::{
+    collections::BTreeMap,
+    str::FromStr,
+    time::{SystemTime, UNIX_EPOCH},
+};
+
+use webc::{
+    v3::{self, write::FileEntry},
+    AbstractVolume, Metadata, PathSegment, PathSegments,
+};
+
+use crate::package::Strictness;
+
+use super::WasmerPackageVolume;
+
+/// An in-memory representation of a volume.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct MemoryVolume {
+    /// The internal node
+    pub node: MemoryDir,
+}
+
+impl MemoryVolume {
+    /// The name of the volume used to store metadata files.
+    pub(crate) const METADATA: &'static str = "metadata";
+}
+
+/// An in-memory representation of a filesystem node.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub enum MemoryNode {
+    /// A file
+    File(MemoryFile),
+
+    /// A directory
+    Dir(MemoryDir),
+}
+
+impl MemoryNode {
+    /// Try to return a [`MemoryDir`] out of [`self`].
+    pub fn as_dir(&self) -> Option<&MemoryDir> {
+        match self {
+            MemoryNode::Dir(d) => Some(d),
+            _ => None,
+        }
+    }
+
+    /// Try to return a [`MemoryFile`] out of [`self`].
+    pub fn as_file(&self) -> Option<&MemoryFile> {
+        match self {
+            MemoryNode::File(f) => Some(f),
+            _ => None,
+        }
+    }
+
+    fn as_dir_entry(&self) -> anyhow::Result<webc::v3::write::DirEntry<'_>> {
+        match self {
+            MemoryNode::File(f) => f.as_dir_entry(),
+            MemoryNode::Dir(d) => d.as_dir_entry(),
+        }
+    }
+
+    fn metadata(&self) -> Metadata {
+        match self {
+            MemoryNode::File(f) => f.metadata(),
+            MemoryNode::Dir(d) => d.metadata(),
+        }
+    }
+}
+
+/// An in-memory file.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct MemoryFile {
+    /// When the file was last modified.
+    pub modified: SystemTime,
+    /// Raw data  
+    pub data: Vec<u8>,
+}
+impl MemoryFile {
+    fn as_dir_entry(&self) -> anyhow::Result<v3::write::DirEntry<'_>> {
+        Ok(v3::write::DirEntry::File(FileEntry::owned(
+            self.data.clone(),
+            v3::Timestamps {
+                modified: self.modified,
+            },
+        )))
+    }
+
+    fn metadata(&self) -> Metadata {
+        let modified = self.modified.duration_since(UNIX_EPOCH).unwrap().as_nanos() as u64;
+        Metadata::File {
+            length: self.data.len(),
+            timestamps: Some(webc::Timestamps::from_modified(modified)),
+        }
+    }
+}
+
+/// An in-memory directory.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct MemoryDir {
+    /// When the directory or its contents were last modified.
+    pub modified: SystemTime,
+    /// List of nodes in the directory
+    pub nodes: BTreeMap<String, MemoryNode>,
+}
+
+impl MemoryDir {
+    fn metadata(&self) -> Metadata {
+        let modified = self.modified.duration_since(UNIX_EPOCH).unwrap().as_nanos() as u64;
+        Metadata::Dir {
+            timestamps: Some(webc::Timestamps::from_modified(modified)),
+        }
+    }
+
+    // Can't return a reference to MemoryNode as it can return itself.
+    fn find_node(&self, path: &PathSegments) -> Option<MemoryNode> {
+        let mut segments = path.iter().collect::<Vec<_>>();
+        if segments.is_empty() {
+            return Some(MemoryNode::Dir(self.clone()));
+        }
+
+        let mut dir = self;
+
+        while !segments.is_empty() {
+            let next = (*segments.first().unwrap()).clone();
+            segments.remove(0);
+
+            if let Some(next_node) = dir.nodes.get(&next.to_string()) {
+                if segments.is_empty() {
+                    return Some(next_node.clone());
+                } else {
+                    match next_node {
+                        MemoryNode::File(_) => break,
+                        MemoryNode::Dir(d) => dir = d,
+                    }
+                }
+            }
+        }
+
+        None
+    }
+
+    fn read_file(&self, path: &PathSegments) -> Option<shared_buffer::OwnedBuffer> {
+        self.find_node(path).and_then(|n| {
+            if let MemoryNode::File(f) = n {
+                Some(shared_buffer::OwnedBuffer::from_bytes(f.data.clone()))
+            } else {
+                None
+            }
+        })
+    }
+
+    #[allow(clippy::type_complexity)]
+    fn read_dir(
+        &self,
+        path: &PathSegments,
+    ) -> Option<Vec<(PathSegment, Option<[u8; 32]>, Metadata)>> {
+        self.find_node(path).and_then(|n| {
+            if let MemoryNode::Dir(d) = n {
+                let mut ret = vec![];
+
+                for (name, node) in &d.nodes {
+                    let meta = node.metadata();
+                    ret.push((PathSegment::from_str(name).ok()?, None, meta))
+                }
+
+                Some(ret)
+            } else {
+                None
+            }
+        })
+    }
+
+    fn find_meta(&self, path: &PathSegments) -> Option<Metadata> {
+        self.find_node(path).map(|n| n.metadata())
+    }
+
+    fn as_directory_tree(
+        &self,
+        _strictness: Strictness,
+    ) -> Result<webc::v3::write::Directory<'_>, anyhow::Error> {
+        let mut children = BTreeMap::new();
+
+        for (key, value) in self.nodes.iter() {
+            children.insert(PathSegment::from_str(key)?, value.as_dir_entry()?);
+        }
+
+        let dir = v3::write::Directory::new(
+            children,
+            v3::Timestamps {
+                modified: self.modified,
+            },
+        );
+
+        Ok(dir)
+    }
+
+    fn as_dir_entry(&self) -> anyhow::Result<v3::write::DirEntry<'_>> {
+        Ok(v3::write::DirEntry::Dir(
+            self.as_directory_tree(Strictness::default())?,
+        ))
+    }
+}
+
+impl AbstractVolume for MemoryVolume {
+    fn read_file(
+        &self,
+        path: &PathSegments,
+    ) -> Option<(shared_buffer::OwnedBuffer, Option<[u8; 32]>)> {
+        self.node.read_file(path).map(|c| (c, None))
+    }
+
+    fn read_dir(
+        &self,
+        path: &PathSegments,
+    ) -> Option<Vec<(PathSegment, Option<[u8; 32]>, Metadata)>> {
+        self.node.read_dir(path)
+    }
+
+    fn metadata(&self, path: &PathSegments) -> Option<Metadata> {
+        self.node.find_meta(path)
+    }
+}
+
+impl WasmerPackageVolume for MemoryVolume {
+    fn as_directory_tree(
+        &self,
+        strictness: Strictness,
+    ) -> Result<webc::v3::write::Directory<'_>, anyhow::Error> {
+        let res = self.node.as_directory_tree(strictness);
+        res
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use sha2::{Digest, Sha256};
+    use v3::{
+        write::Writer, Checksum, ChecksumAlgorithm, Index, IndexEntry, Signature,
+        SignatureAlgorithm, Span, Tag, Timestamps,
+    };
+    use webc::metadata::Manifest;
+
+    use super::*;
+
+    fn sha256(data: impl AsRef<[u8]>) -> [u8; 32] {
+        let mut state = Sha256::default();
+        state.update(data.as_ref());
+        state.finalize().into()
+    }
+
+    #[test]
+    fn volume_metadata() -> anyhow::Result<()> {
+        let file_modified = SystemTime::now();
+        let file_data = String::from("Hello, world!").as_bytes().to_vec();
+        let file_data_len = file_data.len();
+
+        let file = MemoryFile {
+            modified: file_modified,
+            data: file_data,
+        };
+
+        let mut nodes = BTreeMap::new();
+        nodes.insert(String::from("hello.txt"), MemoryNode::File(file));
+
+        let dir_modified = SystemTime::now();
+        let dir = MemoryDir {
+            modified: dir_modified,
+            nodes,
+        };
+
+        let volume = MemoryVolume { node: dir };
+
+        let file_metadata = volume.metadata(&PathSegments::from_str("hello.txt")?);
+        assert!(file_metadata.is_some());
+
+        let file_metadata = file_metadata.unwrap();
+        assert!(file_metadata.is_file());
+
+        let (length, timestamps) = match file_metadata {
+            Metadata::File { length, timestamps } => (length, timestamps),
+            _ => unreachable!(),
+        };
+
+        assert_eq!(
+            timestamps.unwrap().modified(),
+            file_modified.duration_since(UNIX_EPOCH)?.as_nanos() as u64
+        );
+
+        assert_eq!(length, file_data_len);
+
+        let dir_metadata = volume.metadata(&PathSegments::from_str("/")?);
+        assert!(dir_metadata.is_some());
+
+        let dir_metadata = dir_metadata.unwrap();
+        assert!(dir_metadata.is_dir());
+
+        let timestamps = match dir_metadata {
+            Metadata::Dir { timestamps } => timestamps,
+            _ => unreachable!(),
+        };
+
+        assert_eq!(
+            timestamps.unwrap().modified(),
+            dir_modified.duration_since(UNIX_EPOCH)?.as_nanos() as u64
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn create_webc_file_from_memory() -> Result<(), Box<dyn std::error::Error>> {
+        let manifest = Manifest::default();
+
+        let mut writer = Writer::new(ChecksumAlgorithm::Sha256)
+            .write_manifest(&manifest)?
+            .write_atoms(BTreeMap::new())?;
+
+        let file_contents = "Hello, World!";
+        let file = MemoryFile {
+            modified: SystemTime::UNIX_EPOCH,
+            data: file_contents.as_bytes().to_vec(),
+        };
+        let mut nodes = BTreeMap::new();
+        nodes.insert(String::from("a"), MemoryNode::File(file));
+
+        let dir_modified = std::time::SystemTime::UNIX_EPOCH;
+        let dir = MemoryDir {
+            modified: dir_modified,
+            nodes,
+        };
+
+        let volume = MemoryVolume { node: dir };
+
+        writer.write_volume(
+            "first",
+            dbg!(WasmerPackageVolume::as_directory_tree(
+                &volume,
+                Strictness::Strict,
+            )?),
+        )?;
+
+        let webc = writer.finish(SignatureAlgorithm::None)?;
+
+        let mut data = vec![];
+        ciborium::into_writer(&manifest, &mut data).unwrap();
+        let manifest_hash: [u8; 32] = sha2::Sha256::digest(data).into();
+        let manifest_section = bytes! {
+            Tag::Manifest,
+            manifest_hash,
+            1_u64.to_le_bytes(),
+            [0xa0],
+        };
+
+        let empty_hash: [u8; 32] = sha2::Sha256::new().finalize().into();
+
+        let atoms_header_and_data = bytes! {
+            // header section
+            65_u64.to_le_bytes(),
+            Tag::Directory,
+            56_u64.to_le_bytes(),
+            Timestamps::default(),
+            empty_hash,
+            // data section (empty)
+            0_u64.to_le_bytes(),
+        };
+
+        let atoms_hash: [u8; 32] = sha2::Sha256::digest(&atoms_header_and_data).into();
+        let atoms_section = bytes! {
+            Tag::Atoms,
+            atoms_hash,
+            81_u64.to_le_bytes(),
+            atoms_header_and_data,
+        };
+
+        let a_hash: [u8; 32] = sha2::Sha256::digest(file_contents).into();
+        let dir_hash: [u8; 32] = sha2::Sha256::digest(a_hash).into();
+        let volume_header_and_data = bytes! {
+            // ==== Name ====
+            5_u64.to_le_bytes(),
+            "first",
+            // ==== Header Section ====
+            187_u64.to_le_bytes(),
+            // ---- root directory ----
+            Tag::Directory,
+            105_u64.to_le_bytes(),
+            Timestamps::default(),
+            dir_hash,
+            // first entry
+            114_u64.to_le_bytes(),
+            a_hash,
+            1_u64.to_le_bytes(),
+            "a",
+
+            // ---- first item ----
+            Tag::File,
+            0_u64.to_le_bytes(),
+            13_u64.to_le_bytes(),
+            sha256("Hello, World!"),
+            Timestamps::default(),
+
+            // ==== Data Section ====
+            13_u64.to_le_bytes(),
+            file_contents,
+        };
+        let volume_hash: [u8; 32] = sha2::Sha256::digest(&volume_header_and_data).into();
+        let first_volume_section = bytes! {
+            Tag::Volume,
+            volume_hash,
+            229_u64.to_le_bytes(),
+            volume_header_and_data,
+        };
+
+        let index = Index::new(
+            IndexEntry::new(
+                Span::new(437, 42),
+                Checksum::sha256(sha256(&manifest_section[41..])),
+            ),
+            IndexEntry::new(
+                Span::new(479, 122),
+                Checksum::sha256(sha256(&atoms_section[41..])),
+            ),
+            [(
+                "first".to_string(),
+                IndexEntry::new(
+                    Span::new(601, 270),
+                    Checksum::sha256(sha256(&first_volume_section[41..])),
+                ),
+            )]
+            .into_iter()
+            .collect(),
+            Signature::none(),
+        );
+
+        let mut serialized_index = vec![];
+        ciborium::into_writer(&index, &mut serialized_index).unwrap();
+        let index_section = bytes! {
+            Tag::Index,
+            420_u64.to_le_bytes(),
+            serialized_index,
+            // padding bytes to compensate for an unknown index length
+            // NOTE: THIS VALUE IS COMPLETELY RANDOM AND YOU SHOULD GUESS WHAT VALUE
+            // WILL WORK.
+            [0_u8; 75],
+        };
+
+        assert_bytes_eq!(
+            &webc,
+            bytes! {
+                webc::MAGIC,
+                webc::Version::V3,
+                index_section,
+                manifest_section,
+                atoms_section,
+                first_volume_section,
+            }
+        );
+
+        // make sure the index is accurate
+        assert_bytes_eq!(&webc[index.manifest.span], manifest_section);
+        assert_bytes_eq!(&webc[index.atoms.span], atoms_section);
+        assert_bytes_eq!(&webc[index.volumes["first"].span], first_volume_section);
+
+        Ok(())
+    }
+}
diff --git a/lib/package/src/package/volume/mod.rs b/lib/package/src/package/volume/mod.rs
new file mode 100644
index 0000000000..cab6198608
--- /dev/null
+++ b/lib/package/src/package/volume/mod.rs
@@ -0,0 +1,39 @@
+pub(crate) mod fs;
+pub(crate) mod in_memory;
+
+use std::{fmt::Debug, sync::Arc};
+
+use anyhow::Error;
+
+use webc::{v3::write::Directory, AbstractVolume};
+
+use super::Strictness;
+
+pub trait IntoSuper<Super: ?Sized> {
+    fn into_super(self: Arc<Self>) -> Arc<Super>;
+}
+
+impl<T: AbstractVolume + Send + Sync + 'static>
+    IntoSuper<dyn AbstractVolume + Send + Sync + 'static> for T
+{
+    fn into_super(self: Arc<Self>) -> Arc<dyn AbstractVolume + Send + Sync + 'static> {
+        self
+    }
+}
+
+/// An abstraction over concrete volumes implementation to be used in a Wasmer Package.
+pub trait WasmerPackageVolume:
+    AbstractVolume
+    + Send
+    + Sync
+    + 'static
+    + Debug
+    + IntoSuper<dyn AbstractVolume + Send + Sync + 'static>
+{
+    fn as_volume(self: Arc<Self>) -> Arc<dyn AbstractVolume + Send + Sync + 'static> {
+        self.into_super()
+    }
+
+    /// Serialize the volume as a [`webc::v3::write::Directory`].  
+    fn as_directory_tree(&self, strictness: Strictness) -> Result<Directory<'_>, Error>;
+}
diff --git a/lib/package/src/utils.rs b/lib/package/src/utils.rs
new file mode 100644
index 0000000000..133933c189
--- /dev/null
+++ b/lib/package/src/utils.rs
@@ -0,0 +1,201 @@
+use bytes::{Buf, Bytes};
+use std::{
+    fs::File,
+    io::{BufRead, BufReader, Read, Seek},
+    path::Path,
+};
+use wasmer_types::Features;
+use webc::{Container, ContainerError, Version};
+
+use crate::package::{Package, WasmerPackageError};
+
+/// Check if something looks like a `*.tar.gz` file.
+fn is_tarball(mut file: impl Read + Seek) -> bool {
+    /// Magic bytes for a `*.tar.gz` file according to
+    /// [Wikipedia](https://en.wikipedia.org/wiki/List_of_file_signatures).
+    const TAR_GZ_MAGIC_BYTES: [u8; 2] = [0x1F, 0x8B];
+
+    let mut buffer = [0_u8; 2];
+    let result = match file.read_exact(&mut buffer) {
+        Ok(_) => buffer == TAR_GZ_MAGIC_BYTES,
+        Err(_) => false,
+    };
+
+    let _ = file.rewind();
+
+    result
+}
+
+pub fn from_disk(path: impl AsRef<Path>) -> Result<Container, WasmerPackageError> {
+    let path = path.as_ref();
+
+    if path.is_dir() {
+        return parse_dir(path);
+    }
+
+    let mut f = File::open(path).map_err(|error| ContainerError::Open {
+        error,
+        path: path.to_path_buf(),
+    })?;
+
+    if is_tarball(&mut f) {
+        return parse_tarball(BufReader::new(f));
+    }
+
+    match webc::detect(&mut f) {
+        Ok(Version::V1) => parse_v1_mmap(f).map_err(Into::into),
+        Ok(Version::V2) => parse_v2_mmap(f).map_err(Into::into),
+        Ok(Version::V3) => parse_v3_mmap(f).map_err(Into::into),
+        Ok(other) => {
+            // fall back to the allocating generic version
+            let mut buffer = Vec::new();
+            f.rewind()
+                .and_then(|_| f.read_to_end(&mut buffer))
+                .map_err(|error| ContainerError::Read {
+                    path: path.to_path_buf(),
+                    error,
+                })?;
+
+            Container::from_bytes_and_version(buffer.into(), other).map_err(Into::into)
+        }
+        Err(e) => Err(ContainerError::Detect(e).into()),
+    }
+}
+
+/// Check if the data looks like a webc.
+pub fn is_container(bytes: &[u8]) -> bool {
+    is_tarball(std::io::Cursor::new(bytes)) || webc::detect(bytes).is_ok()
+}
+
+pub fn from_bytes(bytes: impl Into<Bytes>) -> Result<Container, WasmerPackageError> {
+    let bytes: Bytes = bytes.into();
+
+    if is_tarball(std::io::Cursor::new(&bytes)) {
+        return parse_tarball(bytes.reader());
+    }
+
+    let version = webc::detect(bytes.as_ref())?;
+    Container::from_bytes_and_version(bytes, version).map_err(Into::into)
+}
+
+#[allow(clippy::result_large_err)]
+fn parse_tarball(reader: impl BufRead) -> Result<Container, WasmerPackageError> {
+    let pkg = Package::from_tarball(reader)?;
+    Ok(Container::new(pkg))
+}
+
+#[allow(clippy::result_large_err)]
+fn parse_dir(path: &Path) -> Result<Container, WasmerPackageError> {
+    let wasmer_toml = path.join("wasmer.toml");
+    let pkg = Package::from_manifest(wasmer_toml)?;
+    Ok(Container::new(pkg))
+}
+
+#[allow(clippy::result_large_err)]
+fn parse_v1_mmap(f: File) -> Result<Container, ContainerError> {
+    // We need to explicitly use WebcMmap to get a memory-mapped
+    // parser
+    let options = webc::v1::ParseOptions::default();
+    let webc = webc::v1::WebCMmap::from_file(f, &options)?;
+    Ok(Container::new(webc))
+}
+
+#[allow(clippy::result_large_err)]
+fn parse_v2_mmap(f: File) -> Result<Container, ContainerError> {
+    // Note: OwnedReader::from_file() will automatically try to
+    // use a memory-mapped file when possible.
+    let webc = webc::v2::read::OwnedReader::from_file(f)?;
+    Ok(Container::new(webc))
+}
+
+#[allow(clippy::result_large_err)]
+fn parse_v3_mmap(f: File) -> Result<Container, ContainerError> {
+    // Note: OwnedReader::from_file() will automatically try to
+    // use a memory-mapped file when possible.
+    let webc = webc::v3::read::OwnedReader::from_file(f)?;
+    Ok(Container::new(webc))
+}
+
+/// Convert a `Features` object to a list of WebAssembly feature strings
+/// that can be used in annotations.
+///
+/// This maps each enabled feature to its corresponding string identifier
+/// used in the WebAssembly ecosystem.
+pub fn features_to_wasm_annotations(features: &Features) -> Vec<String> {
+    let mut feature_strings = Vec::new();
+
+    if features.simd {
+        feature_strings.push("simd".to_string());
+    }
+    if features.bulk_memory {
+        feature_strings.push("bulk-memory".to_string());
+    }
+    if features.reference_types {
+        feature_strings.push("reference-types".to_string());
+    }
+    if features.multi_value {
+        feature_strings.push("multi-value".to_string());
+    }
+    if features.threads {
+        feature_strings.push("threads".to_string());
+    }
+    if features.exceptions {
+        feature_strings.push("exception-handling".to_string());
+    }
+    if features.memory64 {
+        feature_strings.push("memory64".to_string());
+    }
+    // Note: We don't currently include tail_call, module_linking, multi_memory,
+    // relaxed_simd, or extended_const in the feature strings
+
+    feature_strings
+}
+
+/// Create a `Features` object from a list of WebAssembly feature strings.
+///
+/// This is the inverse of `features_to_wasm_annotations`, mapping string identifiers
+/// back to Features settings.
+pub fn wasm_annotations_to_features(feature_strings: &[String]) -> Features {
+    let mut features = Features::default();
+
+    // Initialize with default values
+    features
+        .simd(false)
+        .bulk_memory(false)
+        .reference_types(false)
+        .multi_value(false)
+        .threads(false)
+        .exceptions(false)
+        .memory64(false);
+
+    // Set features based on the string values
+    for feature in feature_strings {
+        match feature.as_str() {
+            "simd" => {
+                features.simd(true);
+            }
+            "bulk-memory" => {
+                features.bulk_memory(true);
+            }
+            "reference-types" => {
+                features.reference_types(true);
+            }
+            "multi-value" => {
+                features.multi_value(true);
+            }
+            "threads" => {
+                features.threads(true);
+            }
+            "exception-handling" => {
+                features.exceptions(true);
+            }
+            "memory64" => {
+                features.memory64(true);
+            }
+            // Ignore unrecognized features
+            _ => {}
+        }
+    }
+
+    features
+}
diff --git a/lib/registry/Cargo.toml b/lib/registry/Cargo.toml
deleted file mode 100644
index bdf0b036a2..0000000000
--- a/lib/registry/Cargo.toml
+++ /dev/null
@@ -1,64 +0,0 @@
-[package]
-name = "wasmer-registry"
-version = "5.19.0"
-description = "Crate to interact with the wasmer registry, download packages, etc."
-authors.workspace = true
-edition.workspace = true
-homepage.workspace = true
-license.workspace = true
-repository.workspace = true
-rust-version.workspace = true
-
-[features]
-build-package  = ["rusqlite", "indexmap", "wasmer-wasm-interface", "wasmparser", "rpassword", "minisign", "time"]
-
-[dependencies]
-anyhow = "1.0.65"
-clap = { version = "4.3.7", default-features = false, features = ["derive", "env"], optional = true }
-console = "0.15.2"
-dialoguer = "0.11.0"
-dirs = "4.0.0"
-filetime = "0.2.19"
-flate2 = "1.0.24"
-futures = "0.3"
-futures-util = "0.3.25"
-graphql-ws-client = {version = "0.8.0", features = ["async-tungstenite", "client-graphql-client"]}
-graphql_client = "0.13.0"
-hex = "0.4.3"
-indexmap = { version = "1.9.3", optional = true }
-indicatif = "0.17.2"
-lazy_static = "1.4.0"
-log = "0.4.17"
-lzma-rs = "0.2.0"
-minisign = { version = "0.7.2", optional = true }
-rand = "0.8.5"
-regex = "1.7.0"
-reqwest = { workspace = true, default-features = false, features = ["blocking", "multipart", "json", "stream"] }
-rpassword = { version = "7.2.0", optional = true }
-rusqlite = { version = "0.28.0", optional = true, features = ["bundled"] }
-semver = "1.0.14"
-serde = { version = "1.0.145", features = ["derive"] }
-serde_json = "1.0.85"
-tar = "0.4.38"
-tempfile = "3.6.0"
-thiserror = "1.0.37"
-time = { version = "0.3.17", default-features = false, features = ["parsing", "std", "formatting"], optional = true }
-tldextract = "0.6.0"
-tokio = {version = "1", features = ["rt-multi-thread"]}
-tokio-tungstenite = {version = "0.21", features = ["rustls-tls-native-roots"]}
-toml.workspace = true
-tracing = "0.1.40"
-url = "2.5.0"
-wasmer-config = { version = "0.8.0", path = "../config" }
-wasmer-wasm-interface = { version = "4.3.7", path = "../wasm-interface", optional = true }
-wasmparser = { workspace = true, optional = true }
-whoami = "1.2.3"
-webc.workspace = true
-async-tungstenite = { version = "0.25.1", features = ["tokio-runtime", "tokio-rustls-native-certs"] }
-
-[dev-dependencies]
-pretty_assertions = "1.3.0"
-
-[package.metadata.docs.rs]
-features = ["build-package"]
-rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/registry/README.md b/lib/registry/README.md
deleted file mode 100644
index 625820a77e..0000000000
--- a/lib/registry/README.md
+++ /dev/null
@@ -1,24 +0,0 @@
-# wasmer-registry
-
-This crate provides integration with the Wasmer package registry GraphQL API.
-
-## Development
-
-### Updating the GraphQL Schema
-
-The GraphQL API schema used for generating queries and mutations is located at
-`./graphql/schema.graphql`.
-
-To update it to a deployed version of the backend, run:
-
-```bash
-npx get-graphql-schema https://registry.wasmer.wtf/graphql > graphql/schema.graphql
-```
-
-### Formatting GraphQL Files
-
-To format the GraphQL query and mutation files, run:
-
-```bash
-npx prettier --write ./graphql/**/*.graphql
-```
diff --git a/lib/registry/graphql/mutations/generate_deploy_token.graphql b/lib/registry/graphql/mutations/generate_deploy_token.graphql
deleted file mode 100644
index 4c4244b999..0000000000
--- a/lib/registry/graphql/mutations/generate_deploy_token.graphql
+++ /dev/null
@@ -1,5 +0,0 @@
-mutation GenerateDeployToken($appVersionId: String!) {
-  generateDeployToken(input: { deployAppVersionId: $configId }) {
-    token
-  }
-}
diff --git a/lib/registry/graphql/mutations/new_nonce.graphql b/lib/registry/graphql/mutations/new_nonce.graphql
deleted file mode 100644
index b5a6b1827e..0000000000
--- a/lib/registry/graphql/mutations/new_nonce.graphql
+++ /dev/null
@@ -1,7 +0,0 @@
-mutation NewNonce($name: String!, $callbackUrl: String!) {
-  newNonce(input: { name: $name, callbackUrl: $callbackUrl }) {
-    nonce {
-      authUrl
-    }
-  }
-}
diff --git a/lib/registry/graphql/mutations/publish_deploy_app.graphql b/lib/registry/graphql/mutations/publish_deploy_app.graphql
deleted file mode 100644
index 123843dd1b..0000000000
--- a/lib/registry/graphql/mutations/publish_deploy_app.graphql
+++ /dev/null
@@ -1,16 +0,0 @@
-mutation PublishDeployApp($config: JSONString!, $name: ID, $owner: ID) {
-  publishDeployApp(input: { config: $config, name: $name, owner: $owner }) {
-    deployAppVersion {
-      id
-      version
-      app {
-        id
-        owner {
-          __typename
-          globalName
-        }
-        name
-      }
-    }
-  }
-}
diff --git a/lib/registry/graphql/mutations/publish_package_chunked.graphql b/lib/registry/graphql/mutations/publish_package_chunked.graphql
deleted file mode 100644
index 0537e5a47e..0000000000
--- a/lib/registry/graphql/mutations/publish_package_chunked.graphql
+++ /dev/null
@@ -1,50 +0,0 @@
-mutation PublishPackageMutationChunked(
-  $name: String
-  $namespace: String
-  $version: String
-  $description: String
-  $manifest: String!
-  $license: String
-  $licenseFile: String
-  $readme: String
-  $fileName: String
-  $repository: String
-  $homepage: String
-  $signature: InputSignature
-  $signedUrl: String
-  $private: Boolean
-  $wait: Boolean
-) {
-  publishPackage(
-    input: {
-      name: $name
-	  namespace: $namespace
-      version: $version
-      description: $description
-      manifest: $manifest
-      license: $license
-      licenseFile: $licenseFile
-      readme: $readme
-      file: $fileName
-      signedUrl: $signedUrl
-      repository: $repository
-      homepage: $homepage
-      signature: $signature
-      clientMutationId: ""
-      private: $private
-      wait: $wait
-    }
-  ) {
-    success
-    packageVersion {
-      id
-      version
-    }
-
-   packageWebc {
-	  webcV3 {
-		webcSha256
-	  }	
-   }
-  }
-}
diff --git a/lib/registry/graphql/queries/get_bindings.graphql b/lib/registry/graphql/queries/get_bindings.graphql
deleted file mode 100644
index 9a8cbe7a3d..0000000000
--- a/lib/registry/graphql/queries/get_bindings.graphql
+++ /dev/null
@@ -1,22 +0,0 @@
-query GetBindingsQuery($name: String!, $version: String = "latest") {
-  packageVersion: getPackageVersion(name: $name, version: $version) {
-    bindings {
-      id
-      language
-      url
-
-      generator {
-        packageVersion {
-          id
-          version
-          package {
-            name
-          }
-        }
-        commandName
-      }
-
-      __typename
-    }
-  }
-}
diff --git a/lib/registry/graphql/queries/get_interface_version.graphql b/lib/registry/graphql/queries/get_interface_version.graphql
deleted file mode 100644
index 48508aaad8..0000000000
--- a/lib/registry/graphql/queries/get_interface_version.graphql
+++ /dev/null
@@ -1,9 +0,0 @@
-query GetInterfaceVersionQuery($name: String!, $version: String!) {
-  interface: getInterfaceVersion(name: $name, version: $version) {
-    version
-    content
-    interface {
-      name
-    }
-  }
-}
diff --git a/lib/registry/graphql/queries/get_package_by_command.graphql b/lib/registry/graphql/queries/get_package_by_command.graphql
deleted file mode 100644
index 8511d47a1f..0000000000
--- a/lib/registry/graphql/queries/get_package_by_command.graphql
+++ /dev/null
@@ -1,18 +0,0 @@
-query GetPackageByCommandQuery($commandName: String!) {
-  getCommand(name: $commandName) {
-    command
-    packageVersion {
-      version
-      isLastVersion
-      manifest
-      distribution {
-        downloadUrl
-        piritaDownloadUrl
-      }
-      package {
-        displayName
-        private
-      }
-    }
-  }
-}
diff --git a/lib/registry/graphql/queries/get_package_version.graphql b/lib/registry/graphql/queries/get_package_version.graphql
deleted file mode 100644
index 751c3b40d4..0000000000
--- a/lib/registry/graphql/queries/get_package_version.graphql
+++ /dev/null
@@ -1,15 +0,0 @@
-query GetPackageVersionQuery($name: String!, $version: String) {
-  packageVersion: getPackageVersion(name: $name, version: $version) {
-    package {
-      name
-      private
-    }
-    version
-    isLastVersion
-    distribution {
-      downloadUrl
-      piritaDownloadUrl
-    }
-    manifest
-  }
-}
diff --git a/lib/registry/graphql/queries/get_signed_url.graphql b/lib/registry/graphql/queries/get_signed_url.graphql
deleted file mode 100644
index a4aacb0b82..0000000000
--- a/lib/registry/graphql/queries/get_signed_url.graphql
+++ /dev/null
@@ -1,15 +0,0 @@
-query GetSignedUrl(
-  $name: String
-  $version: String
-  $filename: String
-  $expiresAfterSeconds: Int
-) {
-  url: getSignedUrlForPackageUpload(
-    name: $name
-    version: $version
-	filename: $filename
-    expiresAfterSeconds: $expiresAfterSeconds
-  ) {
-    url
-  }
-}
diff --git a/lib/registry/graphql/queries/test_if_registry_present.graphql b/lib/registry/graphql/queries/test_if_registry_present.graphql
deleted file mode 100644
index 61c21522e4..0000000000
--- a/lib/registry/graphql/queries/test_if_registry_present.graphql
+++ /dev/null
@@ -1,3 +0,0 @@
-query TestIfRegistryPresent {
-  __typename
-}
diff --git a/lib/registry/graphql/queries/whoami.graphql b/lib/registry/graphql/queries/whoami.graphql
deleted file mode 100644
index 256c983a15..0000000000
--- a/lib/registry/graphql/queries/whoami.graphql
+++ /dev/null
@@ -1,5 +0,0 @@
-query WhoAmIQuery {
-  viewer {
-    username
-  }
-}
diff --git a/lib/registry/graphql/schema.graphql b/lib/registry/graphql/schema.graphql
deleted file mode 100644
index 82df13b7bd..0000000000
--- a/lib/registry/graphql/schema.graphql
+++ /dev/null
@@ -1,3974 +0,0 @@
-"""
-Directs the executor to include this field or fragment only when the user is not logged in.
-"""
-directive @includeIfLoggedIn on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
-
-"""
-Directs the executor to skip this field or fragment when the user is not logged in.
-"""
-directive @skipIfLoggedIn on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
-
-interface Node {
-  """The ID of the object"""
-  id: ID!
-}
-
-type PublicKey implements Node {
-  """The ID of the object"""
-  id: ID!
-  owner: User!
-  keyId: String!
-  key: String!
-  revokedAt: DateTime
-  uploadedAt: DateTime!
-  verifyingSignature: Signature
-  revoked: Boolean!
-}
-
-type User implements Node & PackageOwner & Owner {
-  firstName: String!
-  lastName: String!
-  email: String!
-  dateJoined: DateTime!
-
-  """Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only."""
-  username: String!
-  isEmailValidated: Boolean!
-  bio: String
-  location: String
-  websiteUrl: String
-
-  """The ID of the object"""
-  id: ID!
-  globalName: String!
-  globalId: ID!
-  avatar(size: Int = 80): String!
-  isViewer: Boolean!
-  hasUsablePassword: Boolean
-  fullName: String!
-  githubUrl: String
-  twitterUrl: String
-  companyRole: String
-  companyDescription: String
-  publicActivity(offset: Int, before: String, after: String, first: Int, last: Int): ActivityEventConnection!
-  billing: Billing
-  waitlist(name: String!): WaitlistMember
-  namespaces(role: GrapheneRole, offset: Int, before: String, after: String, first: Int, last: Int): NamespaceConnection!
-  packages(collaborating: Boolean = false, offset: Int, before: String, after: String, first: Int, last: Int): PackageConnection!
-  apps(collaborating: Boolean = false, sortBy: DeployAppsSortBy, offset: Int, before: String, after: String, first: Int, last: Int): DeployAppConnection!
-  usageMetrics(forRange: MetricRange!, variant: MetricType!): [UsageMetric]!
-  domains(offset: Int, before: String, after: String, first: Int, last: Int): DNSDomainConnection!
-  isStaff: Boolean
-  packageVersions(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionConnection!
-  packageTransfersIncoming(offset: Int, before: String, after: String, first: Int, last: Int): PackageTransferRequestConnection!
-  packageInvitesIncoming(offset: Int, before: String, after: String, first: Int, last: Int): PackageCollaboratorInviteConnection!
-  namespaceInvitesIncoming(offset: Int, before: String, after: String, first: Int, last: Int): NamespaceCollaboratorInviteConnection!
-  apiTokens(before: String, after: String, first: Int, last: Int): APITokenConnection!
-  notifications(before: String, after: String, first: Int, last: Int): UserNotificationConnection!
-  dashboardActivity(offset: Int, before: String, after: String, first: Int, last: Int): ActivityEventConnection!
-  loginMethods: [LoginMethod!]!
-  githubUser: SocialAuth
-  githubScopes: [String]!
-}
-
-"""Setup for backwards compatibility with existing frontends."""
-interface PackageOwner {
-  globalName: String!
-  globalId: ID!
-}
-
-"""An owner of a package."""
-interface Owner {
-  globalName: String!
-  globalId: ID!
-}
-
-"""
-The `DateTime` scalar type represents a DateTime
-value as specified by
-[iso8601](https://en.wikipedia.org/wiki/ISO_8601).
-"""
-scalar DateTime
-
-type ActivityEventConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [ActivityEventEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""
-The Relay compliant `PageInfo` type, containing data necessary to paginate this connection.
-"""
-type PageInfo {
-  """When paginating forwards, are there more items?"""
-  hasNextPage: Boolean!
-
-  """When paginating backwards, are there more items?"""
-  hasPreviousPage: Boolean!
-
-  """When paginating backwards, the cursor to continue."""
-  startCursor: String
-
-  """When paginating forwards, the cursor to continue."""
-  endCursor: String
-}
-
-"""A Relay edge containing a `ActivityEvent` and its cursor."""
-type ActivityEventEdge {
-  """The item at the end of the edge"""
-  node: ActivityEvent
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type ActivityEvent implements Node {
-  """The ID of the object"""
-  id: ID!
-  body: EventBody!
-  actorIcon: String!
-  createdAt: DateTime!
-}
-
-type EventBody {
-  text: String!
-  ranges: [NodeBodyRange!]!
-}
-
-type NodeBodyRange {
-  entity: Node!
-  offset: Int!
-  length: Int!
-}
-
-type WaitlistMember implements Node {
-  waitlist: Waitlist!
-  joinedAt: DateTime!
-  approvedAt: DateTime
-
-  """The ID of the object"""
-  id: ID!
-  member: Owner!
-  approved: Boolean!
-}
-
-type Waitlist implements Node {
-  name: String!
-  createdAt: DateTime!
-  updatedAt: DateTime!
-
-  """The ID of the object"""
-  id: ID!
-}
-
-type NamespaceConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [NamespaceEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `Namespace` and its cursor."""
-type NamespaceEdge {
-  """The item at the end of the edge"""
-  node: Namespace
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type Namespace implements Node & PackageOwner & Owner {
-  """The ID of the object"""
-  id: ID!
-  name: String!
-  displayName: String
-  description: String!
-  avatar: String!
-  avatarUpdatedAt: DateTime
-  twitterHandle: String
-  githubHandle: String
-  websiteUrl: String
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  maintainerInvites(offset: Int, before: String, after: String, first: Int, last: Int): NamespaceCollaboratorInviteConnection!
-  userSet(offset: Int, before: String, after: String, first: Int, last: Int): UserConnection!
-  globalName: String!
-  globalId: ID!
-  packages(offset: Int, before: String, after: String, first: Int, last: Int): PackageConnection!
-  apps(sortBy: DeployAppsSortBy, offset: Int, before: String, after: String, first: Int, last: Int): DeployAppConnection!
-  packageVersions(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionConnection!
-  collaborators(offset: Int, before: String, after: String, first: Int, last: Int): NamespaceCollaboratorConnection!
-  publicActivity(before: String, after: String, first: Int, last: Int): ActivityEventConnection!
-  pendingInvites(offset: Int, before: String, after: String, first: Int, last: Int): NamespaceCollaboratorInviteConnection!
-  viewerHasRole(role: GrapheneRole!): Boolean!
-  viewerAsCollaborator(role: GrapheneRole): NamespaceCollaborator
-
-  """Whether the current user is invited to the namespace"""
-  viewerIsInvited: Boolean!
-
-  """The invitation for the current user to the namespace"""
-  viewerInvitation: NamespaceCollaboratorInvite
-  packageTransfersIncoming(offset: Int, before: String, after: String, first: Int, last: Int): PackageTransferRequestConnection!
-  usageMetrics(forRange: MetricRange!, variant: MetricType!): [UsageMetric]!
-  domains(offset: Int, before: String, after: String, first: Int, last: Int): DNSDomainConnection!
-}
-
-type NamespaceCollaboratorInviteConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [NamespaceCollaboratorInviteEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""
-A Relay edge containing a `NamespaceCollaboratorInvite` and its cursor.
-"""
-type NamespaceCollaboratorInviteEdge {
-  """The item at the end of the edge"""
-  node: NamespaceCollaboratorInvite
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type NamespaceCollaboratorInvite implements Node {
-  """The ID of the object"""
-  id: ID!
-  requestedBy: User!
-  user: User
-  inviteEmail: String
-  namespace: Namespace!
-  role: RegistryNamespaceMaintainerInviteRoleChoices!
-  accepted: NamespaceCollaborator
-  approvedBy: User
-  declinedBy: User
-  createdAt: DateTime!
-  expiresAt: DateTime!
-  closedAt: DateTime
-}
-
-enum RegistryNamespaceMaintainerInviteRoleChoices {
-  """Owner"""
-  OWNER
-
-  """Admin"""
-  ADMIN
-
-  """Editor"""
-  EDITOR
-
-  """Viewer"""
-  VIEWER
-}
-
-type NamespaceCollaborator implements Node {
-  """The ID of the object"""
-  id: ID!
-  user: User!
-  role: RegistryNamespaceMaintainerRoleChoices!
-  namespace: Namespace!
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  invite: NamespaceCollaboratorInvite
-}
-
-enum RegistryNamespaceMaintainerRoleChoices {
-  """Owner"""
-  OWNER
-
-  """Admin"""
-  ADMIN
-
-  """Editor"""
-  EDITOR
-
-  """Viewer"""
-  VIEWER
-}
-
-type UserConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [UserEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `User` and its cursor."""
-type UserEdge {
-  """The item at the end of the edge"""
-  node: User
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type PackageConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [PackageEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `Package` and its cursor."""
-type PackageEdge {
-  """The item at the end of the edge"""
-  node: Package
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type Package implements Likeable & Node & PackageOwner {
-  """The ID of the object"""
-  id: ID!
-  name: String!
-  private: Boolean!
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  maintainers: [User]! @deprecated(reason: "Please use collaborators instead")
-  curated: Boolean!
-  ownerObjectId: Int!
-  lastVersion: PackageVersion
-
-  """The app icon. It should be formatted in the same way as Apple icons"""
-  icon: String!
-  totalDownloads: Int!
-  iconUpdatedAt: DateTime
-  watchersCount: Int!
-  webcs(offset: Int, before: String, after: String, first: Int, last: Int): WebcImageConnection!
-
-  """List of app templates for this package"""
-  appTemplates(offset: Int, before: String, after: String, first: Int, last: Int): AppTemplateConnection!
-  packagewebcSet(offset: Int, before: String, after: String, first: Int, last: Int): PackageWebcConnection!
-  versions: [PackageVersion]!
-  collectionSet: [Collection!]!
-  categories(offset: Int, before: String, after: String, first: Int, last: Int): CategoryConnection!
-  keywords(offset: Int, before: String, after: String, first: Int, last: Int): PackageKeywordConnection!
-  likersCount: Int!
-  viewerHasLiked: Boolean!
-  globalName: String!
-  globalId: ID!
-  alias: String
-  namespace: String!
-  displayName: String!
-
-  """The name of the package without the owner"""
-  packageName: String!
-
-  """The app icon. It should be formatted in the same way as Apple icons"""
-  appIcon: String! @deprecated(reason: "Please use icon instead")
-
-  """The total number of downloads of the package"""
-  downloadsCount: Int
-
-  """The public keys for all the published versions"""
-  publicKeys: [PublicKey!]!
-  collaborators(offset: Int, before: String, after: String, first: Int, last: Int): PackageCollaboratorConnection!
-  pendingInvites(offset: Int, before: String, after: String, first: Int, last: Int): PackageCollaboratorInviteConnection!
-  viewerHasRole(role: GrapheneRole!): Boolean!
-  viewerAsCollaborator(role: GrapheneRole): PackageCollaborator
-  owner: PackageOwner!
-  isTransferring: Boolean!
-  activeTransferRequest: PackageTransferRequest
-  isArchived: Boolean!
-  viewerIsWatching: Boolean!
-  showDeployButton: Boolean!
-  similarPackageVersions(before: String, after: String, first: Int, last: Int): PackageSearchConnection!
-
-  """Whether the current user is invited to the package"""
-  viewerIsInvited: Boolean!
-
-  """The invitation for the current user to the package"""
-  viewerInvitation: PackageCollaboratorInvite
-}
-
-interface Likeable {
-  id: ID!
-  likersCount: Int!
-  viewerHasLiked: Boolean!
-}
-
-type PackageVersion implements Node & PackageReleaseInterface & PackageInstance {
-  """The ID of the object"""
-  id: ID!
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  deletedAt: DateTime
-  package: Package!
-  webc: WebcImage
-  webcV3: WebcImage
-
-  """List of direct dependencies of this package version"""
-  dependencies(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionConnection!
-  publishedBy: User!
-  tag: String!
-  clientName: String
-  webcGenerationErrors: String
-  version: String!
-  description: String!
-  manifest: String!
-  license: String
-  licenseFile: String
-  readme: String
-  witMd: String
-  repository: String
-  homepage: String
-  staticObjectsCompiled: Boolean!
-  nativeExecutablesCompiled: Boolean!
-  signature: Signature
-  isArchived: Boolean!
-  file: String!
-
-  """"""
-  fileSize: BigInt!
-  totalDownloads: Int!
-  bindingsState: RegistryPackageVersionBindingsStateChoices!
-  nativeExecutablesState: RegistryPackageVersionNativeExecutablesStateChoices!
-  deployappversionSet(offset: Int, before: String, after: String, first: Int, last: Int): DeployAppVersionConnection!
-  lastversionPackage(offset: Int, before: String, after: String, first: Int, last: Int): PackageConnection!
-  commands: [Command!]!
-  nativeexecutableSet(offset: Int, before: String, after: String, first: Int, last: Int): NativeExecutableConnection!
-  bindingsgeneratorSet(offset: Int, before: String, after: String, first: Int, last: Int): BindingsGeneratorConnection!
-  javascriptlanguagebindingSet(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionNPMBindingConnection!
-  pythonlanguagebindingSet(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionPythonBindingConnection!
-  piritaManifest: JSONString
-  piritaOffsets: JSONString
-  piritaVolumes: JSONString
-  piritaFile: String @deprecated(reason: "Please use distribution.piritaDownloadUrl instead.")
-  piritaFileSize: Int @deprecated(reason: "Please use distribution.piritaSize instead.")
-  pirita256hash: String @deprecated(reason: "Please use distribution.piritaSha256Hash instead.")
-  distribution(version: WebcVersion): PackageDistribution!
-  filesystem: [PackageVersionFilesystem]!
-  isLastVersion: Boolean!
-  witFile: String
-  isSigned: Boolean!
-  moduleInterfaces: [InterfaceVersion!]!
-  modules: [PackageVersionModule!]!
-  getPiritaContents(volume: String! = "atom", base: String! = ""): [PiritaFilesystemItem!]!
-  getWebcContents(volume: String! = "atom", base: String! = "/"): [WEBCFilesystemItem!]!
-  nativeExecutables(triple: String, wasmerCompilerVersion: String): [NativeExecutable]
-  bindings: [PackageVersionLanguageBinding]!
-  npmBindings: PackageVersionNPMBinding
-  pythonBindings: PackageVersionPythonBinding
-  bindingsSet(before: String, after: String, first: Int, last: Int): PackageVersionBindingConnection
-  hasBindings: Boolean!
-  hasCommands: Boolean!
-  showDeployButton: Boolean!
-  isCorrupt: Boolean!
-}
-
-interface PackageReleaseInterface {
-  piritaManifest: JSONString
-  piritaOffsets: JSONString
-  piritaVolumes: JSONString
-  isArchived: Boolean!
-  clientName: String
-  publishedBy: User!
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  package: Package!
-  webc: WebcImage
-  webcV3: WebcImage
-  tag: String!
-}
-
-"""
-Allows use of a JSON String for input / output from the GraphQL schema.
-
-Use of this type is *not recommended* as you lose the benefits of having a defined, static
-schema (one of the key benefits of GraphQL).
-"""
-scalar JSONString
-
-type WebcImage implements Node {
-  """The ID of the object"""
-  id: ID!
-  version: RegistryWebcImageVersionChoices!
-
-  """"""
-  fileSize: BigInt!
-  manifest: JSONString!
-  volumes: JSONString!
-  offsets: JSONString!
-  webcSha256: String!
-  targzSha256: String
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  webcUrl: String!
-}
-
-enum RegistryWebcImageVersionChoices {
-  """v2"""
-  V2
-
-  """v3"""
-  V3
-}
-
-"""
-The `BigInt` scalar type represents non-fractional whole numeric values.
-`BigInt` is not constrained to 32-bit like the `Int` type and thus is a less
-compatible type.
-"""
-scalar BigInt
-
-type PackageVersionConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [PackageVersionEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `PackageVersion` and its cursor."""
-type PackageVersionEdge {
-  """The item at the end of the edge"""
-  node: PackageVersion
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-enum RegistryPackageVersionBindingsStateChoices {
-  """Bindings are not detected"""
-  NOT_PRESENT
-
-  """Bindings are being built"""
-  GENERATING
-
-  """Bindings generation has failed"""
-  ERROR
-
-  """Bindings are built and present"""
-  GENERATED_AND_PRESENT
-}
-
-enum RegistryPackageVersionNativeExecutablesStateChoices {
-  """Native Executables are not detected"""
-  NOT_PRESENT
-
-  """Native Executables are being built"""
-  GENERATING
-
-  """Native Executables generation has failed"""
-  ERROR
-
-  """Native Executables are built and present"""
-  GENERATED_AND_PRESENT
-}
-
-type DeployAppVersionConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [DeployAppVersionEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `DeployAppVersion` and its cursor."""
-type DeployAppVersionEdge {
-  """The item at the end of the edge"""
-  node: DeployAppVersion
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type DeployAppVersion implements Node {
-  """The ID of the object"""
-  id: ID!
-  app: DeployApp!
-  yamlConfig: String!
-  userYamlConfig: String!
-  clientName: String!
-  signature: String
-  description: String
-  publishedBy: User!
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  configWebc: String @deprecated(reason: "webc support has been deprecated for apps")
-  config: String! @deprecated(reason: "Please use jsonConfig instead")
-  jsonConfig: String!
-  url: String!
-  permalink: String!
-  urls: [String]!
-  version: String!
-  isActive: Boolean!
-  manifest: String!
-  logs(
-    """
-    Get logs starting from this timestamp. Takes EPOCH timestamp in seconds.
-    """
-    startingFrom: Float
-
-    """Get logs starting from this timestamp. Takes ISO timestamp."""
-    startingFromISO: DateTime
-
-    """Fetch logs until this timestamp. Takes EPOCH timestamp in seconds."""
-    until: Float
-
-    """List of streams to fetch logs from. e.g. stdout, stderr."""
-    streams: [LogStream]
-
-    """List of instance ids to fetch logs from."""
-    instanceIds: [String]
-    before: String
-    after: String
-    first: Int
-    last: Int
-  ): LogConnection!
-  usageMetrics(forRange: MetricRange!, variant: MetricType!): [UsageMetric]!
-  sourcePackageVersion: PackageVersion!
-  aggregateMetrics: AggregateMetrics!
-  volumes: [AppVersionVolume]
-  favicon: URL
-  screenshot: URL
-}
-
-type DeployApp implements Node & Owner {
-  """The ID of the object"""
-  id: ID!
-  createdBy: User!
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  activeVersion: DeployAppVersion!
-  globalName: String!
-  globalId: ID!
-  url: String!
-  adminUrl: String!
-  permalink: String!
-  urls: [String]!
-  description: String
-  name: String!
-  owner: Owner!
-  versions(sortBy: DeployAppVersionsSortBy, createdAfter: DateTime, offset: Int, before: String, after: String, first: Int, last: Int): DeployAppVersionConnection!
-  aggregateMetrics: AggregateMetrics!
-  aliases(offset: Int, before: String, after: String, first: Int, last: Int): AppAliasConnection!
-  usageMetrics(forRange: MetricRange!, variant: MetricType!): [UsageMetric]!
-  deleted: Boolean!
-  favicon: URL
-  screenshot: URL
-}
-
-enum DeployAppVersionsSortBy {
-  NEWEST
-  OLDEST
-}
-
-type AggregateMetrics {
-  cpuTime: String!
-  memoryTime: String!
-  ingress: String!
-  egress: String!
-  noRequests: String!
-  noFailedRequests: String!
-  monthlyCost: String!
-}
-
-type AppAliasConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [AppAliasEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `AppAlias` and its cursor."""
-type AppAliasEdge {
-  """The item at the end of the edge"""
-  node: AppAlias
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type AppAlias implements Node {
-  name: String!
-  app: DeployApp!
-  isDefault: Boolean!
-  hostname: String!
-  text: String!
-  kind: DeployAppAliasKindChoices!
-
-  """The ID of the object"""
-  id: ID!
-  url: String!
-}
-
-enum DeployAppAliasKindChoices {
-  """Deployment"""
-  DEPLOYMENT
-
-  """Domain"""
-  DOMAIN
-}
-
-type UsageMetric {
-  variant: MetricType!
-  value: Float!
-  unit: MetricUnit!
-  timestamp: DateTime!
-}
-
-enum MetricType {
-  cpu_time
-  memory_time
-  network_egress
-  network_ingress
-  no_of_requests
-  no_of_failed_requests
-  cost
-}
-
-"""Units for metrics"""
-enum MetricUnit {
-  """represents the unit of "seconds"."""
-  SEC
-
-  """represents the unit of "milliseconds"."""
-  MS
-
-  """represents the unit of "kilobytes"."""
-  KB
-
-  """represents the unit of "kilobytes per second"."""
-  KBS
-
-  """represents the unit of "number of requests"."""
-  NO_REQUESTS
-
-  """represents the unit of "cost" in USD."""
-  DOLLARS
-}
-
-enum MetricRange {
-  LAST_24_HOURS
-  LAST_30_DAYS
-  LAST_1_HOUR
-}
-
-"""
-The `URL` scalar type represents a URL as text, represented as UTF-8
-character sequences.
-"""
-scalar URL
-
-type LogConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [LogEdge]!
-}
-
-"""A Relay edge containing a `Log` and its cursor."""
-type LogEdge {
-  """The item at the end of the edge"""
-  node: Log
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-enum LogStream {
-  STDOUT
-  STDERR
-  RUNTIME
-}
-
-type AppVersionVolume {
-  name: String!
-  mountPaths: [AppVersionVolumeMountPath]!
-  size: Int
-  usedSize: Int
-}
-
-type AppVersionVolumeMountPath {
-  path: String!
-  subpath: String!
-}
-
-type Command {
-  command: String!
-  packageVersion: PackageVersion!
-  module: PackageVersionModule!
-}
-
-type PackageVersionModule {
-  name: String!
-  source: String!
-  abi: String
-  publicUrl: String!
-  atom: PiritaFilesystemFile!
-  rangeHeader: String!
-}
-
-type PiritaFilesystemFile {
-  name(display: PiritaFilesystemNameDisplay): String!
-  size: Int!
-  offset: Int!
-}
-
-enum PiritaFilesystemNameDisplay {
-  RELATIVE
-  ABSOLUTE
-}
-
-type NativeExecutableConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [NativeExecutableEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `NativeExecutable` and its cursor."""
-type NativeExecutableEdge {
-  """The item at the end of the edge"""
-  node: NativeExecutable
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type NativeExecutable implements Node {
-  """The ID of the object"""
-  id: ID!
-  module: String! @deprecated(reason: "Use filename instead")
-  filename: String!
-  filesize: Int!
-  targetTriple: String!
-  downloadUrl: String!
-}
-
-type BindingsGeneratorConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [BindingsGeneratorEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `BindingsGenerator` and its cursor."""
-type BindingsGeneratorEdge {
-  """The item at the end of the edge"""
-  node: BindingsGenerator
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type BindingsGenerator implements Node {
-  """The ID of the object"""
-  id: ID!
-  packageVersion: PackageVersion!
-  active: Boolean!
-  commandName: String!
-  registryJavascriptlanguagebindings(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionNPMBindingConnection!
-  registryPythonlanguagebindings(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionPythonBindingConnection!
-}
-
-type PackageVersionNPMBindingConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [PackageVersionNPMBindingEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `PackageVersionNPMBinding` and its cursor."""
-type PackageVersionNPMBindingEdge {
-  """The item at the end of the edge"""
-  node: PackageVersionNPMBinding
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type PackageVersionNPMBinding implements PackageVersionLanguageBinding & Node {
-  """The ID of the object"""
-  id: ID!
-  language: ProgrammingLanguage!
-
-  """The URL of the generated artifacts on Wasmer CDN."""
-  url: String!
-
-  """When the binding was generated"""
-  createdAt: DateTime!
-
-  """Package version used to generate this binding"""
-  generator: BindingsGenerator!
-  name: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
-  kind: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
-
-  """Name of package source"""
-  packageName: String!
-
-  """Name of the package to import"""
-  importablePackageName: String!
-
-  """Code snippet example to use the package"""
-  codeSnippetExample: String!
-  module: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
-  npmDefaultInstallPackageName(url: String): String! @deprecated(reason: "Please use packageName instead")
-}
-
-interface PackageVersionLanguageBinding {
-  id: ID!
-  language: ProgrammingLanguage!
-
-  """The URL of the generated artifacts on Wasmer CDN."""
-  url: String!
-
-  """When the binding was generated"""
-  createdAt: DateTime!
-
-  """Package version used to generate this binding"""
-  generator: BindingsGenerator!
-  name: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
-  kind: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
-
-  """Name of package source"""
-  packageName: String!
-
-  """Name of the package to import"""
-  importablePackageName: String!
-
-  """Code snippet example to use the package"""
-  codeSnippetExample: String!
-  module: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
-}
-
-enum ProgrammingLanguage {
-  PYTHON
-  JAVASCRIPT
-}
-
-type PackageVersionPythonBindingConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [PackageVersionPythonBindingEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""
-A Relay edge containing a `PackageVersionPythonBinding` and its cursor.
-"""
-type PackageVersionPythonBindingEdge {
-  """The item at the end of the edge"""
-  node: PackageVersionPythonBinding
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type PackageVersionPythonBinding implements PackageVersionLanguageBinding & Node {
-  """The ID of the object"""
-  id: ID!
-  language: ProgrammingLanguage!
-
-  """The URL of the generated artifacts on Wasmer CDN."""
-  url: String!
-
-  """When the binding was generated"""
-  createdAt: DateTime!
-
-  """Package version used to generate this binding"""
-  generator: BindingsGenerator!
-  name: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
-  kind: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
-
-  """Name of package source"""
-  packageName: String!
-
-  """Name of the package to import"""
-  importablePackageName: String!
-
-  """Code snippet example to use the package"""
-  codeSnippetExample: String!
-  module: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
-  pythonDefaultInstallPackageName(url: String): String!
-}
-
-type PackageDistribution {
-  """
-  Download URL of the tar.gz file.
-  If the package was published with webc only,this will contain download URL for webc file instead.
-  """
-  downloadUrl: String!
-  expiresInSeconds: Int
-  size: Int
-  piritaDownloadUrl: String
-  piritaExpiresInSeconds: Int
-  piritaSize: Int
-  piritaSha256Hash: String
-  webcDownloadUrl: String
-  webcExpiresInSeconds: Int
-  webcSize: Int
-  webcSha256Hash: String
-  webcVersion: WebcVersion
-}
-
-enum WebcVersion {
-  V2
-  V3
-}
-
-type PackageVersionFilesystem {
-  wasm: String!
-  host: String!
-}
-
-type InterfaceVersion implements Node {
-  """The ID of the object"""
-  id: ID!
-  interface: Interface!
-  version: String!
-  content: String!
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  publishedBy: User!
-  packageVersions(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionConnection!
-}
-
-type Interface implements Node {
-  """The ID of the object"""
-  id: ID!
-  name: String!
-  displayName: String!
-  description: String!
-  homepage: String
-  icon: String
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  versions(offset: Int, before: String, after: String, first: Int, last: Int): InterfaceVersionConnection!
-  lastVersion: InterfaceVersion
-}
-
-type InterfaceVersionConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [InterfaceVersionEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `InterfaceVersion` and its cursor."""
-type InterfaceVersionEdge {
-  """The item at the end of the edge"""
-  node: InterfaceVersion
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-union PiritaFilesystemItem = PiritaFilesystemFile | PiritaFilesystemDir
-
-type PiritaFilesystemDir {
-  name(display: PiritaFilesystemNameDisplay): String!
-}
-
-type WEBCFilesystemItem {
-  name: String!
-  checksum: String!
-  size: Int!
-  offset: Int!
-}
-
-type PackageVersionBindingConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [PackageVersionBindingEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `PackageVersionBinding` and its cursor."""
-type PackageVersionBindingEdge {
-  """The item at the end of the edge"""
-  node: PackageVersionBinding
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-union PackageVersionBinding = PackageVersionNPMBinding | PackageVersionPythonBinding
-
-type WebcImageConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [WebcImageEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `WebcImage` and its cursor."""
-type WebcImageEdge {
-  """The item at the end of the edge"""
-  node: WebcImage
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type AppTemplateConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [AppTemplateEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `AppTemplate` and its cursor."""
-type AppTemplateEdge {
-  """The item at the end of the edge"""
-  node: AppTemplate
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type AppTemplate implements Node {
-  """The ID of the object"""
-  id: ID!
-  name: String!
-  slug: String!
-  description: String!
-  demoUrl: String!
-  repoUrl: String!
-  category: AppTemplateCategory!
-  isPublic: Boolean!
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  readme: String!
-  useCases: JSONString!
-  framework: String!
-  language: String!
-  repoLicense: String!
-  usingPackage: Package
-  defaultImage: String
-}
-
-type AppTemplateCategory implements Node {
-  """The ID of the object"""
-  id: ID!
-  name: String!
-  slug: String!
-  description: String!
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  appTemplates(offset: Int, before: String, after: String, first: Int, last: Int): AppTemplateConnection!
-}
-
-type PackageWebcConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [PackageWebcEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `PackageWebc` and its cursor."""
-type PackageWebcEdge {
-  """The item at the end of the edge"""
-  node: PackageWebc
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type PackageWebc implements Node & PackageReleaseInterface & PackageInstance {
-  """The ID of the object"""
-  id: ID!
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  package: Package!
-  webc: WebcImage
-  piritaManifest: JSONString
-  piritaOffsets: JSONString
-  piritaVolumes: JSONString
-  isArchived: Boolean!
-  clientName: String
-  publishedBy: User!
-  webcV3: WebcImage
-  tag: String!
-  webcUrl: String!
-}
-
-type Collection {
-  slug: String!
-  displayName: String!
-  description: String!
-  createdAt: DateTime!
-  banner: String!
-  packages(before: String, after: String, first: Int, last: Int): PackageConnection!
-}
-
-type CategoryConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [CategoryEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `Category` and its cursor."""
-type CategoryEdge {
-  """The item at the end of the edge"""
-  node: Category
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type Category implements Node {
-  """The ID of the object"""
-  id: ID!
-
-  """A category is a label that can be attached to a package."""
-  name: String!
-  packages(offset: Int, before: String, after: String, first: Int, last: Int): PackageConnection
-}
-
-type PackageKeywordConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [PackageKeywordEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `PackageKeyword` and its cursor."""
-type PackageKeywordEdge {
-  """The item at the end of the edge"""
-  node: PackageKeyword
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type PackageKeyword implements Node {
-  """The ID of the object"""
-  id: ID!
-  name: String!
-}
-
-type PackageCollaboratorConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [PackageCollaboratorEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `PackageCollaborator` and its cursor."""
-type PackageCollaboratorEdge {
-  """The item at the end of the edge"""
-  node: PackageCollaborator
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type PackageCollaborator implements Node {
-  """The ID of the object"""
-  id: ID!
-  user: User!
-  role: RegistryPackageMaintainerRoleChoices!
-  package: Package!
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  invite: PackageCollaboratorInvite
-}
-
-enum RegistryPackageMaintainerRoleChoices {
-  """Owner"""
-  OWNER
-
-  """Admin"""
-  ADMIN
-
-  """Editor"""
-  EDITOR
-
-  """Viewer"""
-  VIEWER
-}
-
-type PackageCollaboratorInvite implements Node {
-  """The ID of the object"""
-  id: ID!
-  requestedBy: User!
-  user: User
-  inviteEmail: String
-  package: Package!
-  role: RegistryPackageMaintainerInviteRoleChoices!
-  accepted: PackageCollaborator
-  approvedBy: User
-  declinedBy: User
-  createdAt: DateTime!
-  expiresAt: DateTime!
-  closedAt: DateTime
-}
-
-enum RegistryPackageMaintainerInviteRoleChoices {
-  """Owner"""
-  OWNER
-
-  """Admin"""
-  ADMIN
-
-  """Editor"""
-  EDITOR
-
-  """Viewer"""
-  VIEWER
-}
-
-type PackageCollaboratorInviteConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [PackageCollaboratorInviteEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `PackageCollaboratorInvite` and its cursor."""
-type PackageCollaboratorInviteEdge {
-  """The item at the end of the edge"""
-  node: PackageCollaboratorInvite
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-enum GrapheneRole {
-  OWNER
-  ADMIN
-  EDITOR
-  VIEWER
-}
-
-type PackageTransferRequest implements Node {
-  """The ID of the object"""
-  id: ID!
-  requestedBy: User!
-  previousOwnerObjectId: Int!
-  newOwnerObjectId: Int!
-  package: Package!
-  approvedBy: User
-  declinedBy: User
-  createdAt: DateTime!
-  expiresAt: DateTime!
-  closedAt: DateTime
-  previousOwner: PackageOwner!
-  newOwner: PackageOwner!
-}
-
-type PackageSearchConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [PackageSearchEdge]!
-  totalCount: Int
-}
-
-"""A Relay edge containing a `PackageSearch` and its cursor."""
-type PackageSearchEdge {
-  """The item at the end of the edge"""
-  node: PackageVersion
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type DeployAppConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [DeployAppEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `DeployApp` and its cursor."""
-type DeployAppEdge {
-  """The item at the end of the edge"""
-  node: DeployApp
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-enum DeployAppsSortBy {
-  NEWEST
-  OLDEST
-  MOST_ACTIVE
-}
-
-type NamespaceCollaboratorConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [NamespaceCollaboratorEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `NamespaceCollaborator` and its cursor."""
-type NamespaceCollaboratorEdge {
-  """The item at the end of the edge"""
-  node: NamespaceCollaborator
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type PackageTransferRequestConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [PackageTransferRequestEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `PackageTransferRequest` and its cursor."""
-type PackageTransferRequestEdge {
-  """The item at the end of the edge"""
-  node: PackageTransferRequest
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type DNSDomainConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [DNSDomainEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `DNSDomain` and its cursor."""
-type DNSDomainEdge {
-  """The item at the end of the edge"""
-  node: DNSDomain
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type DNSDomain implements Node {
-  name: String!
-
-  """This zone will be accessible at /dns/{slug}/."""
-  slug: String!
-  zoneFile: String!
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  deletedAt: DateTime
-
-  """The ID of the object"""
-  id: ID!
-  records: [DNSRecord]
-  owner: Owner!
-}
-
-union DNSRecord = ARecord | AAAARecord | CNAMERecord | TXTRecord | MXRecord | NSRecord | CAARecord | DNAMERecord | PTRRecord | SOARecord | SRVRecord | SSHFPRecord
-
-type ARecord implements Node & DNSRecordInterface {
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  deletedAt: DateTime
-  address: String!
-
-  """The ID of the object"""
-  id: ID!
-  name: String!
-  ttl: Int!
-  dnsClass: String
-  text: String!
-  domain: DNSDomain!
-}
-
-interface DNSRecordInterface {
-  name: String!
-  ttl: Int!
-  dnsClass: String
-  text: String!
-  domain: DNSDomain!
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  deletedAt: DateTime
-}
-
-type AAAARecord implements Node & DNSRecordInterface {
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  deletedAt: DateTime
-  address: String!
-
-  """The ID of the object"""
-  id: ID!
-  name: String!
-  ttl: Int!
-  dnsClass: String
-  text: String!
-  domain: DNSDomain!
-}
-
-type CNAMERecord implements Node & DNSRecordInterface {
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  deletedAt: DateTime
-
-  """This domain name will alias to this canonical name."""
-  cName: String!
-
-  """The ID of the object"""
-  id: ID!
-  name: String!
-  ttl: Int!
-  dnsClass: String
-  text: String!
-  domain: DNSDomain!
-}
-
-type TXTRecord implements Node & DNSRecordInterface {
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  deletedAt: DateTime
-  data: String!
-
-  """The ID of the object"""
-  id: ID!
-  name: String!
-  ttl: Int!
-  dnsClass: String
-  text: String!
-  domain: DNSDomain!
-}
-
-type MXRecord implements Node & DNSRecordInterface {
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  deletedAt: DateTime
-  preference: Int!
-  exchange: String!
-
-  """The ID of the object"""
-  id: ID!
-  name: String!
-  ttl: Int!
-  dnsClass: String
-  text: String!
-  domain: DNSDomain!
-}
-
-type NSRecord implements Node & DNSRecordInterface {
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  deletedAt: DateTime
-  nsdname: String!
-
-  """The ID of the object"""
-  id: ID!
-  name: String!
-  ttl: Int!
-  dnsClass: String
-  text: String!
-  domain: DNSDomain!
-}
-
-type CAARecord implements Node & DNSRecordInterface {
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  deletedAt: DateTime
-  flags: Int!
-  tag: DnsmanagerCertificationAuthorityAuthorizationRecordTagChoices!
-  value: String!
-
-  """The ID of the object"""
-  id: ID!
-  name: String!
-  ttl: Int!
-  dnsClass: String
-  text: String!
-  domain: DNSDomain!
-}
-
-enum DnsmanagerCertificationAuthorityAuthorizationRecordTagChoices {
-  """issue"""
-  ISSUE
-
-  """issue wildcard"""
-  ISSUEWILD
-
-  """Incident object description exchange format"""
-  IODEF
-}
-
-type DNAMERecord implements Node & DNSRecordInterface {
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  deletedAt: DateTime
-
-  """
-  This domain name will alias to the entire subtree of that delegation domain.
-  """
-  dName: String!
-
-  """The ID of the object"""
-  id: ID!
-  name: String!
-  ttl: Int!
-  dnsClass: String
-  text: String!
-  domain: DNSDomain!
-}
-
-type PTRRecord implements Node & DNSRecordInterface {
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  deletedAt: DateTime
-  ptrdname: String!
-
-  """The ID of the object"""
-  id: ID!
-  name: String!
-  ttl: Int!
-  dnsClass: String
-  text: String!
-  domain: DNSDomain!
-}
-
-type SOARecord implements Node & DNSRecordInterface {
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  deletedAt: DateTime
-
-  """Primary master name server for this zone."""
-  mname: String!
-
-  """Email address of the administrator responsible for this zone."""
-  rname: String!
-
-  """
-  A slave name server will initiate a zone transfer if this serial is incremented.
-  """
-  serial: BigInt!
-
-  """
-  Number of seconds after which secondary name servers should query the master to detect zone changes.
-  """
-  refresh: BigInt!
-
-  """
-  Number of seconds after which secondary name servers should retry to request the serial number from the master if the master does not respond.
-  """
-  retry: BigInt!
-
-  """
-  Number of seconds after which secondary name servers should stop answering request for this zone if the master does not respond.
-  """
-  expire: BigInt!
-
-  """Time to live for purposes of negative caching."""
-  minimum: BigInt!
-
-  """The ID of the object"""
-  id: ID!
-  name: String!
-  ttl: Int!
-  dnsClass: String
-  text: String!
-  domain: DNSDomain!
-}
-
-type SRVRecord implements Node & DNSRecordInterface {
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  deletedAt: DateTime
-
-  """The symbolic name of the desired service."""
-  service: String!
-
-  """
-  The transport protocol of the desired service, usually either TCP or UDP.
-  """
-  protocol: String!
-
-  """The priority of the target host, lower value means more preferred."""
-  priority: Int!
-
-  """
-  A relative weight for records with the same priority, higher value means higher chance of getting picked.
-  """
-  weight: Int!
-  port: Int!
-
-  """
-  The canonical hostname of the machine providing the service, ending in a dot.
-  """
-  target: String!
-
-  """The ID of the object"""
-  id: ID!
-  name: String!
-  ttl: Int!
-  dnsClass: String
-  text: String!
-  domain: DNSDomain!
-}
-
-type SSHFPRecord implements Node & DNSRecordInterface {
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  deletedAt: DateTime
-  algorithm: DnsmanagerSshFingerprintRecordAlgorithmChoices!
-  type: DnsmanagerSshFingerprintRecordTypeChoices!
-  fingerprint: String!
-
-  """The ID of the object"""
-  id: ID!
-  name: String!
-  ttl: Int!
-  dnsClass: String
-  text: String!
-  domain: DNSDomain!
-}
-
-enum DnsmanagerSshFingerprintRecordAlgorithmChoices {
-  """RSA"""
-  A_1
-
-  """DSA"""
-  A_2
-
-  """ECDSA"""
-  A_3
-
-  """Ed25519"""
-  A_4
-}
-
-enum DnsmanagerSshFingerprintRecordTypeChoices {
-  """SHA-1"""
-  A_1
-
-  """SHA-256"""
-  A_2
-}
-
-type APITokenConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [APITokenEdge]!
-}
-
-"""A Relay edge containing a `APIToken` and its cursor."""
-type APITokenEdge {
-  """The item at the end of the edge"""
-  node: APIToken
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type APIToken {
-  id: ID!
-  user: User!
-  identifier: String
-  createdAt: DateTime!
-  revokedAt: DateTime
-  lastUsedAt: DateTime
-  nonceSet(offset: Int, before: String, after: String, first: Int, last: Int): NonceConnection!
-}
-
-type NonceConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [NonceEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `Nonce` and its cursor."""
-type NonceEdge {
-  """The item at the end of the edge"""
-  node: Nonce
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type Nonce implements Node {
-  """The ID of the object"""
-  id: ID!
-  name: String!
-  callbackUrl: String!
-  createdAt: DateTime!
-  isValidated: Boolean!
-  secret: String!
-  token: String!
-  expired: Boolean!
-  authUrl: String!
-}
-
-type UserNotificationConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [UserNotificationEdge]!
-  hasPendingNotifications: Boolean!
-  pendingNotificationsCount: Int!
-}
-
-"""A Relay edge containing a `UserNotification` and its cursor."""
-type UserNotificationEdge {
-  """The item at the end of the edge"""
-  node: UserNotification
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type UserNotification implements Node {
-  """The ID of the object"""
-  id: ID!
-  icon: String
-  body: EventBody!
-  seenState: UserNotificationSeenState!
-  kind: UserNotificationKind
-  createdAt: DateTime!
-}
-
-enum UserNotificationSeenState {
-  UNSEEN
-  SEEN
-  SEEN_AND_READ
-}
-
-union UserNotificationKind = UserNotificationKindPublishedPackageVersion | UserNotificationKindIncomingPackageTransfer | UserNotificationKindIncomingPackageInvite | UserNotificationKindIncomingNamespaceInvite | UserNotificationKindValidateEmail
-
-type UserNotificationKindPublishedPackageVersion {
-  packageVersion: PackageVersion!
-}
-
-type UserNotificationKindIncomingNamespaceInvite {
-  namespaceInvite: NamespaceCollaboratorInvite!
-}
-
-type UserNotificationKindValidateEmail {
-  user: User!
-}
-
-"""
-
-    Enum of ways a user can login. One user can have many login methods
-    associated with their account.
-    
-"""
-enum LoginMethod {
-  GOOGLE
-  GITHUB
-  PASSWORD
-}
-
-type SocialAuth implements Node {
-  """The ID of the object"""
-  id: ID!
-  user: User!
-  provider: String!
-  uid: String!
-  extraData: JSONString!
-  created: DateTime!
-  modified: DateTime!
-  username: String!
-}
-
-type Signature {
-  id: ID!
-  publicKey: PublicKey!
-  data: String!
-  createdAt: DateTime!
-}
-
-type StripeCustomer {
-  id: ID!
-}
-
-type Billing {
-  stripeCustomer: StripeCustomer!
-  payments: [PaymentIntent]!
-  paymentMethods: [PaymentMethod]!
-}
-
-type PaymentIntent implements Node {
-  """The datetime this object was created in stripe."""
-  created: DateTime
-
-  """Three-letter ISO currency code"""
-  currency: String!
-
-  """
-  Status of this PaymentIntent, one of requires_payment_method, requires_confirmation, requires_action, processing, requires_capture, canceled, or succeeded. You can read more about PaymentIntent statuses here.
-  """
-  status: DjstripePaymentIntentStatusChoices!
-
-  """The ID of the object"""
-  id: ID!
-  amount: String!
-}
-
-enum DjstripePaymentIntentStatusChoices {
-  """
-  Cancellation invalidates the intent for future confirmation and cannot be undone.
-  """
-  CANCELED
-
-  """Required actions have been handled."""
-  PROCESSING
-
-  """Payment Method require additional action, such as 3D secure."""
-  REQUIRES_ACTION
-
-  """Capture the funds on the cards which have been put on holds."""
-  REQUIRES_CAPTURE
-
-  """Intent is ready to be confirmed."""
-  REQUIRES_CONFIRMATION
-
-  """Intent created and requires a Payment Method to be attached."""
-  REQUIRES_PAYMENT_METHOD
-
-  """The funds are in your account."""
-  SUCCEEDED
-}
-
-union PaymentMethod = CardPaymentMethod
-
-type CardPaymentMethod implements Node {
-  """The ID of the object"""
-  id: ID!
-  brand: CardBrand!
-  country: String!
-  expMonth: Int!
-  expYear: Int!
-  funding: CardFunding!
-  last4: String!
-  isDefault: Boolean!
-}
-
-"""
-Card brand.
-
-Can be amex, diners, discover, jcb, mastercard, unionpay, visa, or unknown.
-"""
-enum CardBrand {
-  AMEX
-  DINERS
-  DISCOVER
-  JCB
-  MASTERCARD
-  UNIONPAY
-  VISA
-  UNKNOWN
-}
-
-"""
-Card funding type.
-
-Can be credit, debit, prepaid, or unknown.
-"""
-enum CardFunding {
-  CREDIT
-  DEBIT
-  PREPAID
-  UNKNOWN
-}
-
-type Payment {
-  id: ID
-  amount: String
-  paidOn: DateTime
-}
-
-"""Log entry for deploy app."""
-type Log {
-  """Timestamp in nanoseconds"""
-  timestamp: Float!
-
-  """ISO 8601 string in UTC"""
-  datetime: DateTime!
-
-  """Log message"""
-  message: String!
-
-  """Log stream"""
-  stream: LogStream
-}
-
-"""This is for backwards compatibility with the old PackageInstance type."""
-interface PackageInstance {
-  piritaManifest: JSONString
-  piritaOffsets: JSONString
-  piritaVolumes: JSONString
-  isArchived: Boolean!
-  clientName: String
-  publishedBy: User!
-  createdAt: DateTime!
-  updatedAt: DateTime!
-  package: Package!
-  webc: WebcImage
-  webcV3: WebcImage
-  tag: String!
-}
-
-type UserNotificationKindIncomingPackageTransfer {
-  packageTransferRequest: PackageTransferRequest!
-}
-
-type UserNotificationKindIncomingPackageInvite {
-  packageInvite: PackageCollaboratorInvite!
-}
-
-input DeploymentV1 {
-  name: String!
-  workload: WorkloadV1!
-}
-
-input WorkloadV1 {
-  capability: CapabilityMapV1
-  name: String = null
-  runner: WorkloadRunnerV1!
-}
-
-input AppV1Spec {
-  aliases: [String] = []
-  workload: WorkloadV2!
-}
-
-input WorkloadV2 {
-  source: String!
-}
-
-input CapabilityCpuV1 {
-  maximumThreads: Int
-  maximumUsage: Int
-}
-
-input FileSystemPermissionsV1 {
-  delete: Boolean
-  read: Boolean
-  write: Boolean
-}
-
-input FileSystemVolumeMountV1 {
-  path: String!
-  permissions: [FileSystemPermissionsV1]
-}
-
-input FileSystemVolumeSourceLocalV1 {
-  maximumSize: String!
-}
-
-input FileSystemVolumeSourceV1 {
-  local: FileSystemVolumeSourceLocalV1!
-}
-
-input FileSystemVolumeConfigV1 {
-  mounts: [FileSystemVolumeMountV1]!
-  name: String!
-  source: FileSystemVolumeSourceV1!
-}
-
-input CapabilityFileSystemV1 {
-  volumes: [FileSystemVolumeConfigV1]!
-}
-
-input CapabilityPersistentMemoryV1 {
-  volumes: [String]
-}
-
-input CapabilityMemorySwapV1 {
-  maximumSize: String
-  memoryId: String
-}
-
-input CapabilityNetworkV1 {
-  egress: NetworkEgressV1
-}
-
-input NetworkEgressV1 {
-  enabled: Boolean
-}
-
-input CapabilityNetworkDnsV1 {
-  enabled: Boolean
-  servers: [String]
-  allowedHosts: NetworkDnsAllowedHostsV1
-}
-
-input NetworkDnsAllowedHostsV1 {
-  allowAllHosts: Boolean
-  hosts: [String]
-  regexPatterns: [String]
-  wildcardPatterns: [String]
-}
-
-input CapabilityNetworkGatewayV1 {
-  domains: [String]
-  enforceHttps: Boolean
-}
-
-input CapabilityMapV1 {
-  memorySwap: CapabilityCpuV1
-}
-
-input WebcSourceV1 {
-  name: String!
-  namespace: String!
-  repository: String! = "https://registry.wasmer.wtf"
-  tag: String
-  authToken: String
-}
-
-input WorkloadRunnerV1 {
-  webProxy: RunnerWebProxyV1
-  wcgi: RunnerWCGIV1
-}
-
-"""Run a webassembly file."""
-input RunnerWCGIV1 {
-  source: WorkloadRunnerWasmSourceV1!
-  dialect: String
-}
-
-input RunnerWebProxyV1 {
-  source: WorkloadRunnerWasmSourceV1!
-}
-
-input WorkloadRunnerWasmSourceV1 {
-  webc: WebcSourceV1!
-}
-
-type Query {
-  latestTOS: TermsOfService!
-  getDeployAppVersion(name: String!, owner: String, version: String): DeployAppVersion
-  getAllDomains(namespace: String, offset: Int, before: String, after: String, first: Int, last: Int): DNSDomainConnection!
-  getAllDNSRecords(sortBy: DNSRecordsSortBy, updatedAfter: DateTime, before: String, after: String, first: Int, last: Int): DNSRecordConnection!
-  getDomain(name: String!): DNSDomain
-  getDeployApp(
-    name: String!
-
-    """Owner of the app. Defaults to logged in user."""
-    owner: String
-  ): DeployApp
-  getAppByGlobalAlias(alias: String!): DeployApp
-  getDeployApps(sortBy: DeployAppsSortBy, updatedAfter: DateTime, offset: Int, before: String, after: String, first: Int, last: Int): DeployAppConnection!
-  getAppVersions(sortBy: DeployAppVersionsSortBy, updatedAfter: DateTime, offset: Int, before: String, after: String, first: Int, last: Int): DeployAppVersionConnection!
-  getAppTemplates(categorySlug: String, offset: Int, before: String, after: String, first: Int, last: Int): AppTemplateConnection
-  getAppTemplate(slug: String!): AppTemplate
-  getAppTemplateCategories(offset: Int, before: String, after: String, first: Int, last: Int): AppTemplateCategoryConnection
-  viewer: User
-  getUser(username: String!): User
-  getPasswordResetToken(token: String!): GetPasswordResetToken
-  getAuthNonce(name: String!): Nonce
-
-  """Can the logged in user create app templates?"""
-  canDeployAppToGithub: Boolean!
-
-  """Check if a repo exists in the logged in user's github account."""
-  checkRepoExists(
-    """The namespace of the repo to check."""
-    namespace: String!
-
-    """The name of the repo to check."""
-    name: String!
-  ): Boolean!
-
-  """Generate a unique repo name in the logged in user's github account."""
-  newRepoName(
-    """The github namespace of the repo to create the repo in."""
-    namespace: String!
-
-    """The template to use."""
-    templateSlug: String!
-  ): String!
-  packages(offset: Int, before: String, after: String, first: Int, last: Int): PackageConnection
-  recentPackageVersions(curated: Boolean, offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionConnection!
-  allPackageVersions(sortBy: PackageVersionSortBy, createdAfter: DateTime, updatedAfter: DateTime, offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionConnection!
-  allPackageReleases(sortBy: PackageVersionSortBy, createdAfter: DateTime, updatedAfter: DateTime, offset: Int, before: String, after: String, first: Int, last: Int): PackageWebcConnection!
-  getWebcImage(hash: String!): WebcImage
-  getNamespace(name: String!): Namespace
-  getPackage(name: String!): Package
-  getPackages(names: [String!]!): [Package]!
-  getPackageVersion(name: String!, version: String = "latest"): PackageVersion
-  getPackageVersions(names: [String!]!): [PackageVersion]
-  getPackageVersionByHash(name: String!, hash: String!): PackageVersion
-  getInterface(name: String!): Interface
-  getInterfaces(names: [String!]!): [Interface]!
-  getInterfaceVersion(name: String!, version: String = "latest"): InterfaceVersion
-  getContract(name: String!): Interface @deprecated(reason: "Please use getInterface instead")
-  getContracts(names: [String!]!): [Interface]! @deprecated(reason: "Please use getInterfaces instead")
-  getContractVersion(name: String!, version: String): InterfaceVersion @deprecated(reason: "Please use getInterfaceVersion instead")
-  getCommand(name: String!): Command
-  getCommands(names: [String!]!): [Command]
-  getCollections(before: String, after: String, first: Int, last: Int): CollectionConnection
-  getSignedUrlForPackageUpload(name: String, version: String = "latest", filename: String, expiresAfterSeconds: Int = 60): SignedUrl
-  getPackageHash(name: String, hash: String!): PackageWebc
-  getPackageRelease(hash: String!): PackageWebc
-  categories(offset: Int, before: String, after: String, first: Int, last: Int): CategoryConnection!
-  blogposts(tags: [String!], before: String, after: String, first: Int, last: Int): BlogPostConnection!
-  getBlogpost(slug: String, featured: Boolean): BlogPost
-  allBlogpostTags(offset: Int, before: String, after: String, first: Int, last: Int): BlogPostTagConnection
-  search(query: String!, packages: PackagesFilter, namespaces: NamespacesFilter, users: UsersFilter, apps: AppFilter, blogposts: BlogPostsFilter, appTemplates: AppTemplateFilter, before: String, after: String, first: Int, last: Int): SearchConnection!
-  searchAutocomplete(kind: [SearchKind!], query: String!, before: String, after: String, first: Int, last: Int): SearchConnection!
-  getGlobalObject(slug: String!): GlobalObject
-  node(
-    """The ID of the object"""
-    id: ID!
-  ): Node
-  nodes(ids: [ID!]!): [Node]
-  info: RegistryInfo
-}
-
-type TermsOfService implements Node {
-  """The ID of the object"""
-  id: ID!
-  content: String!
-  createdAt: DateTime!
-  viewerHasAccepted: Boolean!
-}
-
-type DNSRecordConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [DNSRecordEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `DNSRecord` and its cursor."""
-type DNSRecordEdge {
-  """The item at the end of the edge"""
-  node: DNSRecord
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-enum DNSRecordsSortBy {
-  NEWEST
-  OLDEST
-}
-
-type AppTemplateCategoryConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [AppTemplateCategoryEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `AppTemplateCategory` and its cursor."""
-type AppTemplateCategoryEdge {
-  """The item at the end of the edge"""
-  node: AppTemplateCategory
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type GetPasswordResetToken {
-  valid: Boolean!
-  user: User
-}
-
-enum PackageVersionSortBy {
-  NEWEST
-  OLDEST
-}
-
-type CollectionConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [CollectionEdge]!
-}
-
-"""A Relay edge containing a `Collection` and its cursor."""
-type CollectionEdge {
-  """The item at the end of the edge"""
-  node: Collection
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type SignedUrl {
-  url: String!
-}
-
-type BlogPostConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [BlogPostEdge]!
-}
-
-"""A Relay edge containing a `BlogPost` and its cursor."""
-type BlogPostEdge {
-  """The item at the end of the edge"""
-  node: BlogPost
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type BlogPost implements Node {
-  """The ID of the object"""
-  id: ID!
-  live: Boolean!
-
-  """The page title as you'd like it to be seen by the public"""
-  title: String!
-
-  """
-  The name of the page as it will appear in URLs e.g http://domain.com/blog/[my-slug]/
-  """
-  slug: String!
-  owner: User
-  body: String!
-  publishDate: DateTime
-  theme: BlogBlogPostThemeChoices!
-  url: String!
-  coverImageUrl: String
-  opengraphImageUrl: String
-  tagline: String!
-  relatedArticles: [BlogPost!]
-  updatedAt: DateTime!
-  tags: [BlogPostTag!]
-  editUrl: String
-}
-
-enum BlogBlogPostThemeChoices {
-  """Green"""
-  GREEN
-
-  """Purple"""
-  PURPLE
-
-  """Orange"""
-  ORANGE
-
-  """Blue"""
-  BLUE
-}
-
-type BlogPostTag implements Node {
-  """The ID of the object"""
-  id: ID!
-  name: String!
-  slug: String!
-}
-
-type BlogPostTagConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [BlogPostTagEdge]!
-
-  """Total number of items in the connection."""
-  totalCount: Int
-}
-
-"""A Relay edge containing a `BlogPostTag` and its cursor."""
-type BlogPostTagEdge {
-  """The item at the end of the edge"""
-  node: BlogPostTag
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-type SearchConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [SearchEdge]!
-  totalCount: Int
-}
-
-"""A Relay edge containing a `Search` and its cursor."""
-type SearchEdge {
-  """The item at the end of the edge"""
-  node: SearchResult
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-
-union SearchResult = PackageVersion | User | Namespace | DeployApp | BlogPost | AppTemplate
-
-input PackagesFilter {
-  count: Int = 1000
-  sortBy: SearchOrderSort = ASC
-
-  """Filter packages by being curated."""
-  curated: Boolean
-
-  """Filter packages by publish date."""
-  publishDate: SearchPublishDate
-
-  """Filter packages by having bindings."""
-  hasBindings: Boolean = false
-
-  """Filter packages by being standalone."""
-  isStandalone: Boolean = false
-
-  """Filter packages by having commands."""
-  hasCommands: Boolean = false
-
-  """Filter packages by interface."""
-  withInterfaces: [String]
-
-  """Filter packages by deployable status."""
-  deployable: Boolean
-
-  """Filter packages by license."""
-  license: String
-
-  """Filter packages created after this date."""
-  createdAfter: DateTime
-
-  """Filter packages created before this date."""
-  createdBefore: DateTime
-
-  """Filter packages with version published after this date."""
-  lastPublishedAfter: DateTime
-
-  """Filter packages with version published before this date."""
-  lastPublishedBefore: DateTime
-
-  """Filter packages by size."""
-  size: CountFilter
-
-  """Filter packages by download count."""
-  downloads: CountFilter
-
-  """Filter packages by like count."""
-  likes: CountFilter
-
-  """Filter packages by owner."""
-  owner: String
-
-  """Filter packages by published by."""
-  publishedBy: String
-
-  """Order packages by field."""
-  orderBy: PackageOrderBy = PUBLISHED_DATE
-}
-
-enum SearchOrderSort {
-  ASC
-  DESC
-}
-
-enum SearchPublishDate {
-  LAST_DAY
-  LAST_WEEK
-  LAST_MONTH
-  LAST_YEAR
-}
-
-input CountFilter {
-  count: Int = 0
-  comparison: CountComparison = GREATER_THAN_OR_EQUAL
-}
-
-enum CountComparison {
-  EQUAL
-  GREATER_THAN
-  LESS_THAN
-  GREATER_THAN_OR_EQUAL
-  LESS_THAN_OR_EQUAL
-}
-
-enum PackageOrderBy {
-  ALPHABETICALLY
-  SIZE
-  TOTAL_DOWNLOADS
-  PUBLISHED_DATE
-  CREATED_DATE
-  TOTAL_LIKES
-}
-
-input NamespacesFilter {
-  count: Int = 1000
-  sortBy: SearchOrderSort = ASC
-
-  """Filter namespaces by package count."""
-  packageCount: CountFilter
-
-  """Filter namespaces created after this date."""
-  createdAfter: DateTime
-
-  """Filter namespaces created before this date."""
-  createdBefore: DateTime
-
-  """Filter namespaces by user count."""
-  userCount: CountFilter
-
-  """Filter namespaces by collaborator."""
-  collaborator: String
-
-  """Order namespaces by field."""
-  orderBy: NamespaceOrderBy = CREATED_DATE
-}
-
-enum NamespaceOrderBy {
-  PACKAGE_COUNT
-  COLLABORATOR_COUNT
-  APP_COUNT
-  CREATED_DATE
-}
-
-input UsersFilter {
-  count: Int = 1000
-  sortBy: SearchOrderSort = ASC
-
-  """Filter users by package count."""
-  packageCount: CountFilter
-
-  """Filter users by namespace count."""
-  namespaceCount: CountFilter
-
-  """Filter users joined after this date."""
-  joinedAfter: DateTime
-
-  """Filter users joined before this date."""
-  joinedBefore: DateTime
-
-  """Order users by field."""
-  orderBy: UserOrderBy = CREATED_DATE
-}
-
-enum UserOrderBy {
-  PACKAGE_COUNT
-  APP_COUNT
-  CREATED_DATE
-}
-
-input AppFilter {
-  count: Int = 1000
-  sortBy: SearchOrderSort = ASC
-
-  """Filter apps by deployed by."""
-  deployedBy: String
-
-  """Filter apps last deployed after this date."""
-  lastDeployedAfter: DateTime
-
-  """Filter apps last deployed before this date."""
-  lastDeployedBefore: DateTime
-
-  """Filter apps by owner."""
-  owner: String
-
-  """Order apps by field."""
-  orderBy: AppOrderBy = CREATED_DATE
-
-  """Filter apps by client name."""
-  clientName: String
-}
-
-enum AppOrderBy {
-  PUBLISHED_DATE
-  CREATED_DATE
-}
-
-input BlogPostsFilter {
-  count: Int = 1000
-  sortBy: SearchOrderSort = ASC
-
-  """Filter blog posts by tag."""
-  tags: [String]
-}
-
-input AppTemplateFilter {
-  count: Int = 1000
-  sortBy: SearchOrderSort = ASC
-
-  """Order app templates by field."""
-  orderBy: AppTemplateOrderBy = CREATED_DATE
-
-  """Filter by app template framework"""
-  framework: String
-
-  """Filter by app template language"""
-  language: String
-
-  """Filter by one or more of the use-cases for the app template"""
-  useCases: [String]
-}
-
-enum AppTemplateOrderBy {
-  CREATED_DATE
-}
-
-enum SearchKind {
-  PACKAGE
-  NAMESPACE
-  USER
-}
-
-union GlobalObject = User | Namespace
-
-type RegistryInfo {
-  """Base URL for this registry"""
-  baseUrl: String!
-
-  """Base URL for the default frontend"""
-  defaultFrontend: String!
-
-  """URL to the graphql endpoint"""
-  graphqlUrl: String!
-
-  """URL to the graphql endpoint"""
-  createBlogpostUrl: String
-
-  """Public metadata about packages"""
-  packages: PackageInfo!
-
-  """Public metadata about the graphql schema"""
-  schema: SchemaInfo!
-}
-
-type PackageInfo {
-  """Number of package versions published this month"""
-  versionsPublishedThisMonth: Int!
-
-  """Number of new packages published this month"""
-  newPackagesThisMonth: Int!
-
-  """Number of package downloads this month"""
-  packageDownloadsThisMonth: Int!
-}
-
-type SchemaInfo {
-  """Download link for graphql schema"""
-  downloadUrl: String!
-
-  """SHA256 hash of the schema data"""
-  SHA256Hash: String!
-
-  """Timestamp when the schema was last updated"""
-  lastUpdated: DateTime!
-}
-
-type Mutation {
-  """Viewer accepts the latest ToS."""
-  acceptTOS(input: AcceptTOSInput!): AcceptTOSPayload
-  publishDeployApp(input: PublishDeployAppInput!): PublishDeployAppPayload
-  deleteApp(input: DeleteAppInput!): DeleteAppPayload
-
-  """Add current user to the waitlist."""
-  joinWaitlist(input: JoinWaitlistInput!): JoinWaitlistPayload
-
-  """Add stripe payment to the user"""
-  addPayment(input: AddPaymentInput!): AddPaymentPayload
-
-  """
-  Mutation to change the active version of a DeployApp to another DeployAppVersion.
-  """
-  markAppVersionAsActive(input: MarkAppVersionAsActiveInput!): MarkAppVersionAsActivePayload
-
-  """Set a payment method as default for the user."""
-  makePaymentDefault(input: SetDefaultPaymentMethodInput!): SetDefaultPaymentMethodPayload
-
-  """
-  Try to detach a payment method from customer.
-  Fails if trying to detach a default method,
-  or if it's the only payment method.
-  """
-  detachPaymentMethod(input: DetachPaymentMethodInput!): DetachPaymentMethodPayload
-  generateDeployConfigToken(input: GenerateDeployConfigTokenInput!): GenerateDeployConfigTokenPayload
-  renameApp(input: RenameAppInput!): RenameAppPayload
-  renameAppAlias(input: RenameAppAliasInput!): RenameAppAliasPayload
-  requestAppTransfer(input: RequestAppTransferInput!): RequestAppTransferPayload
-  acceptAppTransferRequest(input: AcceptAppTransferRequestInput!): AcceptAppTransferRequestPayload
-  removeAppTransferRequest(input: RemoveAppTransferRequestInput!): RemoveAppTransferRequestPayload
-  createRepoForAppTemplate(input: CreateRepoForAppTemplateInput!): CreateRepoForAppTemplatePayload
-  registerDomain(input: RegisterDomainInput!): RegisterDomainPayload
-  upsertDNSRecord(input: UpsertDNSRecordInput!): UpsertDNSRecordPayload
-  deleteDNSRecord(input: DeleteDNSRecordInput!): DeleteDNSRecordPayload
-  upsertDomainFromZoneFile(input: UpsertDomainFromZoneFileInput!): UpsertDomainFromZoneFilePayload
-  deleteDomain(input: DeleteDomainInput!): DeleteDomainPayload
-  tokenAuth(input: ObtainJSONWebTokenInput!): ObtainJSONWebTokenPayload
-  generateDeployToken(input: GenerateDeployTokenInput!): GenerateDeployTokenPayload
-  verifyAccessToken(token: String): Verify
-  refreshAccessToken(refreshToken: String): Refresh
-  revokeAccessToken(refreshToken: String): Revoke
-  registerUser(input: RegisterUserInput!): RegisterUserPayload
-  socialAuth(input: SocialAuthJWTInput!): SocialAuthJWTPayload
-  validateUserEmail(input: ValidateUserEmailInput!): ValidateUserEmailPayload
-  requestPasswordReset(input: RequestPasswordResetInput!): RequestPasswordResetPayload
-  requestValidationEmail(input: RequestValidationEmailInput!): RequestValidationEmailPayload
-  changeUserPassword(input: ChangeUserPasswordInput!): ChangeUserPasswordPayload
-  changeUserUsername(input: ChangeUserUsernameInput!): ChangeUserUsernamePayload
-  changeUserEmail(input: ChangeUserEmailInput!): ChangeUserEmailPayload
-  updateUserInfo(input: UpdateUserInfoInput!): UpdateUserInfoPayload
-  validateUserPassword(input: ValidateUserPasswordInput!): ValidateUserPasswordPayload
-  generateApiToken(input: GenerateAPITokenInput!): GenerateAPITokenPayload
-  revokeApiToken(input: RevokeAPITokenInput!): RevokeAPITokenPayload
-  checkUserExists(input: CheckUserExistsInput!): CheckUserExistsPayload
-  readNotification(input: ReadNotificationInput!): ReadNotificationPayload
-  seePendingNotifications(input: SeePendingNotificationsInput!): SeePendingNotificationsPayload
-  newNonce(input: NewNonceInput!): NewNoncePayload
-  validateNonce(input: ValidateNonceInput!): ValidateNoncePayload
-  mfa2totpGetToken(input: MFATOTPGetTokenInput!): MFATOTPTokenType
-  mfa2totpVerify(input: MFATOTPVerifyInput!): MFATOTPVerifyPayload
-  mfa2totpAuth(input: MFATOTPAuthInput!): MFAAuthResponse
-  mfa2RecoveryGetToken(input: MFAGenerateRecoveryTokenInput!): MFARecoveryCodes
-  mfa2RecoveryAuth(input: MFARecoveryAuthInput!): MFAAuthResponse
-  mfa2EmailAuth(input: MFAEmailAuthInput!): MFAAuthResponse
-  mfa2EmailGetToken(input: MFAGenerateEmailOTPInput!): MFAEmailGenerationResponse
-  publishPublicKey(input: PublishPublicKeyInput!): PublishPublicKeyPayload
-  publishPackage(input: PublishPackageInput!): PublishPackagePayload
-  updatePackage(input: UpdatePackageInput!): UpdatePackagePayload
-  likePackage(input: LikePackageInput!): LikePackagePayload
-  unlikePackage(input: UnlikePackageInput!): UnlikePackagePayload
-  watchPackage(input: WatchPackageInput!): WatchPackagePayload
-  unwatchPackage(input: UnwatchPackageInput!): UnwatchPackagePayload
-  archivePackage(input: ArchivePackageInput!): ArchivePackagePayload
-  renamePackage(input: RenamePackageInput!): RenamePackagePayload
-  changePackageVersionArchivedStatus(input: ChangePackageVersionArchivedStatusInput!): ChangePackageVersionArchivedStatusPayload
-  createNamespace(input: CreateNamespaceInput!): CreateNamespacePayload
-  updateNamespace(input: UpdateNamespaceInput!): UpdateNamespacePayload
-  deleteNamespace(input: DeleteNamespaceInput!): DeleteNamespacePayload
-  inviteNamespaceCollaborator(input: InviteNamespaceCollaboratorInput!): InviteNamespaceCollaboratorPayload
-  acceptNamespaceCollaboratorInvite(input: AcceptNamespaceCollaboratorInviteInput!): AcceptNamespaceCollaboratorInvitePayload
-  removeNamespaceCollaboratorInvite(input: RemoveNamespaceCollaboratorInviteInput!): RemoveNamespaceCollaboratorInvitePayload
-  removeNamespaceCollaborator(input: RemoveNamespaceCollaboratorInput!): RemoveNamespaceCollaboratorPayload
-  updateNamespaceCollaboratorRole(input: UpdateNamespaceCollaboratorRoleInput!): UpdateNamespaceCollaboratorRolePayload
-  updateNamespaceCollaboratorInviteRole(input: UpdateNamespaceCollaboratorInviteRoleInput!): UpdateNamespaceCollaboratorInviteRolePayload
-  invitePackageCollaborator(input: InvitePackageCollaboratorInput!): InvitePackageCollaboratorPayload
-  acceptPackageCollaboratorInvite(input: AcceptPackageCollaboratorInviteInput!): AcceptPackageCollaboratorInvitePayload
-  removePackageCollaboratorInvite(input: RemovePackageCollaboratorInviteInput!): RemovePackageCollaboratorInvitePayload
-  updatePackageCollaboratorRole(input: UpdatePackageCollaboratorRoleInput!): UpdatePackageCollaboratorRolePayload
-  updatePackageCollaboratorInviteRole(input: UpdatePackageCollaboratorInviteRoleInput!): UpdatePackageCollaboratorInviteRolePayload
-  removePackageCollaborator(input: RemovePackageCollaboratorInput!): RemovePackageCollaboratorPayload
-  requestPackageTransfer(input: RequestPackageTransferInput!): RequestPackageTransferPayload
-  acceptPackageTransferRequest(input: AcceptPackageTransferRequestInput!): AcceptPackageTransferRequestPayload
-  removePackageTransferRequest(input: RemovePackageTransferRequestInput!): RemovePackageTransferRequestPayload
-  generateBindingsForAllPackages(input: GenerateBindingsForAllPackagesInput!): GenerateBindingsForAllPackagesPayload
-  makePackagePublic(input: MakePackagePublicInput!): MakePackagePublicPayload
-}
-
-"""Viewer accepts the latest ToS."""
-type AcceptTOSPayload {
-  TOS: TermsOfService!
-  clientMutationId: String
-}
-
-input AcceptTOSInput {
-  clientMutationId: String
-}
-
-type PublishDeployAppPayload {
-  deployAppVersion: DeployAppVersion!
-  clientMutationId: String
-}
-
-input PublishDeployAppInput {
-  """The configuration of the app."""
-  config: Configuration!
-
-  """The name of the app."""
-  name: ID
-
-  """The owner of the app."""
-  owner: ID
-
-  """The description of the app."""
-  description: String
-
-  """If true, the new version will be set as the default version."""
-  makeDefault: Boolean = true
-
-  """
-  If true, Publishing will fail if the source package does not have a valid webc.
-  """
-  strict: Boolean = false
-  clientMutationId: String
-}
-
-input Configuration {
-  deployment: AppConfigV1
-  yamlConfig: String
-}
-
-input AppConfigV1 {
-  kind: String = "wasmer.io/App.v0"
-  appId: ID
-  name: String!
-  description: String
-  package: String!
-}
-
-type DeleteAppPayload {
-  success: Boolean!
-  clientMutationId: String
-}
-
-input DeleteAppInput {
-  """App ID to delete."""
-  id: ID!
-  clientMutationId: String
-}
-
-"""Add current user to the waitlist."""
-type JoinWaitlistPayload {
-  waitlistMember: WaitlistMember!
-  clientMutationId: String
-}
-
-input JoinWaitlistInput {
-  name: String!
-  clientMutationId: String
-}
-
-"""Add stripe payment to the user"""
-type AddPaymentPayload {
-  customerSecret: String!
-  clientMutationId: String
-}
-
-input AddPaymentInput {
-  clientMutationId: String
-}
-
-"""
-Mutation to change the active version of a DeployApp to another DeployAppVersion.
-"""
-type MarkAppVersionAsActivePayload {
-  app: DeployApp!
-  clientMutationId: String
-}
-
-input MarkAppVersionAsActiveInput {
-  """The ID of the DeployAppVersion to set as the new active version."""
-  appVersion: ID!
-  clientMutationId: String
-}
-
-"""Set a payment method as default for the user."""
-type SetDefaultPaymentMethodPayload {
-  success: Boolean!
-  billing: Billing!
-  clientMutationId: String
-}
-
-input SetDefaultPaymentMethodInput {
-  paymentMethod: ID!
-  clientMutationId: String
-}
-
-"""
-Try to detach a payment method from customer.
-Fails if trying to detach a default method,
-or if it's the only payment method.
-"""
-type DetachPaymentMethodPayload {
-  success: Boolean!
-  billing: Billing!
-  clientMutationId: String
-}
-
-input DetachPaymentMethodInput {
-  paymentMethod: ID!
-  clientMutationId: String
-}
-
-type GenerateDeployConfigTokenPayload {
-  token: String!
-  config: String!
-  clientMutationId: String
-}
-
-input GenerateDeployConfigTokenInput {
-  config: String!
-  clientMutationId: String
-}
-
-type RenameAppPayload {
-  success: Boolean!
-  app: DeployApp!
-  clientMutationId: String
-}
-
-input RenameAppInput {
-  """App ID to delete."""
-  id: ID!
-
-  """New name for the app."""
-  name: String!
-  clientMutationId: String
-}
-
-type RenameAppAliasPayload {
-  success: Boolean!
-  alias: AppAlias!
-  clientMutationId: String
-}
-
-input RenameAppAliasInput {
-  """App alias ID to delete."""
-  id: ID!
-
-  """New name for the alias."""
-  name: String!
-  clientMutationId: String
-}
-
-type RequestAppTransferPayload {
-  appTransferRequest: AppTransferRequest
-  wasInstantlyTransferred: Boolean!
-  clientMutationId: String
-}
-
-type AppTransferRequest implements Node {
-  """The ID of the object"""
-  id: ID!
-  requestedBy: User!
-  previousOwnerObjectId: Int!
-  newOwnerObjectId: Int!
-  app: DeployApp!
-  approvedBy: User
-  declinedBy: User
-  createdAt: DateTime!
-  expiresAt: DateTime!
-  closedAt: DateTime
-  previousOwner: Owner!
-  newOwner: Owner!
-}
-
-input RequestAppTransferInput {
-  appId: ID!
-  newOwnerId: ID!
-  clientMutationId: String
-}
-
-type AcceptAppTransferRequestPayload {
-  app: DeployApp!
-  appTransferRequest: AppTransferRequest!
-  clientMutationId: String
-}
-
-input AcceptAppTransferRequestInput {
-  appTransferRequestId: ID!
-  clientMutationId: String
-}
-
-type RemoveAppTransferRequestPayload {
-  app: DeployApp!
-  clientMutationId: String
-}
-
-input RemoveAppTransferRequestInput {
-  appTransferRequestId: ID!
-  clientMutationId: String
-}
-
-type CreateRepoForAppTemplatePayload {
-  success: Boolean!
-  repoId: ID!
-  clientMutationId: String
-}
-
-input CreateRepoForAppTemplateInput {
-  templateId: ID!
-  name: String!
-  namespace: String!
-  private: Boolean = false
-  clientMutationId: String
-}
-
-type RegisterDomainPayload {
-  success: Boolean!
-  domain: DNSDomain
-  clientMutationId: String
-}
-
-input RegisterDomainInput {
-  name: String!
-  namespace: String
-  importRecords: Boolean = true
-  clientMutationId: String
-}
-
-type UpsertDNSRecordPayload {
-  success: Boolean!
-  record: DNSRecord!
-  clientMutationId: String
-}
-
-input UpsertDNSRecordInput {
-  kind: RecordKind!
-  domainId: String!
-  name: String!
-  value: String!
-  ttl: Int
-  recordId: String
-  mx: DNSMXExtraInput
-  clientMutationId: String
-}
-
-enum RecordKind {
-  A
-  AAAA
-  CNAME
-  MX
-  NS
-  TXT
-  DNAME
-  PTR
-  SOA
-  SRV
-  CAA
-  SSHFP
-}
-
-input DNSMXExtraInput {
-  preference: Int!
-}
-
-type DeleteDNSRecordPayload {
-  success: Boolean!
-  clientMutationId: String
-}
-
-input DeleteDNSRecordInput {
-  recordId: ID!
-  clientMutationId: String
-}
-
-type UpsertDomainFromZoneFilePayload {
-  success: Boolean!
-  domain: DNSDomain!
-  clientMutationId: String
-}
-
-input UpsertDomainFromZoneFileInput {
-  zoneFile: String!
-  deleteMissingRecords: Boolean
-  clientMutationId: String
-}
-
-type DeleteDomainPayload {
-  success: Boolean!
-  clientMutationId: String
-}
-
-input DeleteDomainInput {
-  domainId: ID!
-  clientMutationId: String
-}
-
-type ObtainJSONWebTokenPayload {
-  payload: GenericScalar!
-  refreshExpiresIn: Int!
-  username: CaseInsensitiveString!
-  clientMutationId: String
-  token: String!
-  refreshToken: String!
-}
-
-"""
-The `GenericScalar` scalar type represents a generic
-GraphQL scalar value that could be:
-String, Boolean, Int, Float, List or Object.
-"""
-scalar GenericScalar
-
-"""
-The `CaseInsensitiveString` scalar type represents textual data, represented as UTF-8
-character sequences. The String type is most often used by GraphQL to
-represent free-form human-readable text.
-"""
-scalar CaseInsensitiveString
-
-input ObtainJSONWebTokenInput {
-  clientMutationId: String
-  username: String!
-  password: String!
-}
-
-type GenerateDeployTokenPayload {
-  token: String!
-  deployConfigVersion: DeployAppVersion!
-  clientMutationId: String
-}
-
-input GenerateDeployTokenInput {
-  deployConfigVersionId: String!
-  clientMutationId: String
-}
-
-type Verify {
-  payload: GenericScalar!
-}
-
-type Refresh {
-  payload: GenericScalar!
-  refreshExpiresIn: Int!
-  token: String!
-  refreshToken: String!
-}
-
-type Revoke {
-  revoked: Int!
-}
-
-type RegisterUserPayload {
-  token: String
-  clientMutationId: String
-}
-
-input RegisterUserInput {
-  fullName: String!
-  email: String!
-  username: CaseInsensitiveString!
-  password: String!
-  acceptedTos: Boolean
-  clientMutationId: String
-}
-
-type SocialAuthJWTPayload {
-  social: SocialAuth
-  token: String
-  clientMutationId: String
-}
-
-input SocialAuthJWTInput {
-  provider: String!
-  accessToken: String!
-  register: Boolean = false
-  clientMutationId: String
-}
-
-type ValidateUserEmailPayload {
-  user: User
-  clientMutationId: String
-}
-
-input ValidateUserEmailInput {
-  """The user id"""
-  userId: ID
-  challenge: String!
-  clientMutationId: String
-}
-
-type RequestPasswordResetPayload {
-  email: String!
-  errors: [ErrorType]
-  clientMutationId: String
-}
-
-type ErrorType {
-  field: String!
-  messages: [String!]!
-}
-
-input RequestPasswordResetInput {
-  email: String!
-  clientMutationId: String
-}
-
-type RequestValidationEmailPayload {
-  user: User
-  success: Boolean!
-  clientMutationId: String
-}
-
-input RequestValidationEmailInput {
-  """The user id"""
-  userId: ID
-  clientMutationId: String
-}
-
-type ChangeUserPasswordPayload {
-  token: String
-  clientMutationId: String
-}
-
-input ChangeUserPasswordInput {
-  """
-  The token associated to change the password. If not existing it will use the request user by default
-  """
-  token: String
-  oldPassword: String
-  password: String!
-  clientMutationId: String
-}
-
-type ChangeUserUsernamePayload {
-  user: User
-  token: String
-  clientMutationId: String
-}
-
-input ChangeUserUsernameInput {
-  """The new user username"""
-  username: CaseInsensitiveString!
-  clientMutationId: String
-}
-
-type ChangeUserEmailPayload {
-  user: User!
-  clientMutationId: String
-}
-
-input ChangeUserEmailInput {
-  newEmail: String!
-  clientMutationId: String
-}
-
-type UpdateUserInfoPayload {
-  user: User
-  clientMutationId: String
-}
-
-input UpdateUserInfoInput {
-  """The user id"""
-  userId: ID
-
-  """The user full name"""
-  fullName: String
-
-  """The user bio"""
-  bio: String
-
-  """The user avatar"""
-  avatar: String
-
-  """
-  The user Twitter (it can be the url, or the handle with or without the @)
-  """
-  twitter: String
-
-  """
-  The user Github (it can be the url, or the handle with or without the @)
-  """
-  github: String
-
-  """The user website (it must be a valid url)"""
-  websiteUrl: String
-
-  """The user location"""
-  location: String
-  clientMutationId: String
-}
-
-type ValidateUserPasswordPayload {
-  success: Boolean
-  clientMutationId: String
-}
-
-input ValidateUserPasswordInput {
-  password: String!
-  clientMutationId: String
-}
-
-type GenerateAPITokenPayload {
-  token: APIToken
-  tokenRaw: String
-  user: User
-  clientMutationId: String
-}
-
-input GenerateAPITokenInput {
-  identifier: String
-  clientMutationId: String
-}
-
-type RevokeAPITokenPayload {
-  token: APIToken
-  success: Boolean
-  clientMutationId: String
-}
-
-input RevokeAPITokenInput {
-  """The API token ID"""
-  tokenId: ID!
-  clientMutationId: String
-}
-
-type CheckUserExistsPayload {
-  exists: Boolean!
-
-  """The user is only returned if the user input was the username"""
-  user: User
-  clientMutationId: String
-}
-
-input CheckUserExistsInput {
-  """The user"""
-  user: String!
-  clientMutationId: String
-}
-
-type ReadNotificationPayload {
-  notification: UserNotification
-  clientMutationId: String
-}
-
-input ReadNotificationInput {
-  notificationId: ID!
-  clientMutationId: String
-}
-
-type SeePendingNotificationsPayload {
-  success: Boolean
-  clientMutationId: String
-}
-
-input SeePendingNotificationsInput {
-  clientMutationId: String
-}
-
-type NewNoncePayload {
-  nonce: Nonce!
-  clientMutationId: String
-}
-
-input NewNonceInput {
-  name: String!
-  callbackUrl: String!
-  clientMutationId: String
-}
-
-type ValidateNoncePayload {
-  nonce: Nonce!
-  clientMutationId: String
-}
-
-input ValidateNonceInput {
-  id: ID!
-  secret: String!
-  clientMutationId: String
-}
-
-type MFATOTPTokenType {
-  qr: String
-  secretKey: String
-}
-
-input MFATOTPGetTokenInput {
-  clientMutationId: String
-}
-
-type MFATOTPVerifyPayload {
-  status: MFATOTPVerifyStatus
-  clientMutationId: String
-}
-
-enum MFATOTPVerifyStatus {
-  SUCCESS
-  RECOVERY
-}
-
-input MFATOTPVerifyInput {
-  answer: String!
-  secretKey: String!
-  clientMutationId: String
-}
-
-"""Response object for MFAAuth mutation."""
-type MFAAuthResponse {
-  success: Boolean!
-  token: String
-  refreshToken: String
-  username: String
-  refreshTokenExpiresIn: Int
-}
-
-input MFATOTPAuthInput {
-  username: String!
-  otp: String!
-  clientMutationId: String
-}
-
-type MFARecoveryCodes {
-  codes: [String]!
-}
-
-input MFAGenerateRecoveryTokenInput {
-  clientMutationId: String
-}
-
-input MFARecoveryAuthInput {
-  username: String!
-  otp: String!
-  clientMutationId: String
-}
-
-input MFAEmailAuthInput {
-  username: String!
-  otp: String!
-  clientMutationId: String
-}
-
-type MFAEmailGenerationResponse {
-  success: Boolean!
-}
-
-input MFAGenerateEmailOTPInput {
-  clientMutationId: String
-}
-
-type PublishPublicKeyPayload {
-  success: Boolean!
-  publicKey: PublicKey!
-  clientMutationId: String
-}
-
-input PublishPublicKeyInput {
-  keyId: String!
-  key: String!
-  verifyingSignatureId: String
-  clientMutationId: String
-}
-
-type PublishPackagePayload {
-  success: Boolean!
-  packageVersion: PackageVersion
-  packageWebc: PackageWebc
-  clientMutationId: String
-}
-
-input PublishPackageInput {
-  manifest: String!
-  name: String
-  namespace: String
-  version: String
-  description: String
-  license: String
-  licenseFile: String
-  readme: String
-  repository: String
-  homepage: String
-  file: String
-  signedUrl: String
-  signature: InputSignature
-
-  """The package icon"""
-  icon: String
-
-  """Whether the package is private"""
-  private: Boolean = false
-
-  """The upload format of the package"""
-  uploadFormat: UploadFormat = targz
-
-  """Whether to wait for webc generation to finish"""
-  wait: Boolean = false
-  clientMutationId: String
-}
-
-input InputSignature {
-  publicKeyKeyId: String!
-  data: String!
-}
-
-enum UploadFormat {
-  targz
-  webcv2
-  webcv3
-}
-
-type UpdatePackagePayload {
-  package: Package!
-  clientMutationId: String
-}
-
-input UpdatePackageInput {
-  packageId: ID!
-
-  """The package icon"""
-  icon: String
-  clientMutationId: String
-}
-
-type LikePackagePayload {
-  package: Package!
-  clientMutationId: String
-}
-
-input LikePackageInput {
-  packageId: ID!
-  clientMutationId: String
-}
-
-type UnlikePackagePayload {
-  package: Package!
-  clientMutationId: String
-}
-
-input UnlikePackageInput {
-  packageId: ID!
-  clientMutationId: String
-}
-
-type WatchPackagePayload {
-  package: Package!
-  clientMutationId: String
-}
-
-input WatchPackageInput {
-  packageId: ID!
-  clientMutationId: String
-}
-
-type UnwatchPackagePayload {
-  package: Package!
-  clientMutationId: String
-}
-
-input UnwatchPackageInput {
-  packageId: ID!
-  clientMutationId: String
-}
-
-type ArchivePackagePayload {
-  package: Package!
-  clientMutationId: String
-}
-
-input ArchivePackageInput {
-  packageId: ID!
-  clientMutationId: String
-}
-
-type RenamePackagePayload {
-  package: Package!
-  clientMutationId: String
-}
-
-input RenamePackageInput {
-  packageId: ID!
-  newName: String!
-  clientMutationId: String
-}
-
-type ChangePackageVersionArchivedStatusPayload {
-  packageVersion: PackageVersion!
-  clientMutationId: String
-}
-
-input ChangePackageVersionArchivedStatusInput {
-  packageVersionId: ID!
-  isArchived: Boolean
-  clientMutationId: String
-}
-
-type CreateNamespacePayload {
-  namespace: Namespace!
-  user: User!
-  clientMutationId: String
-}
-
-input CreateNamespaceInput {
-  name: String!
-
-  """The namespace display name"""
-  displayName: String
-
-  """The namespace description"""
-  description: String
-
-  """The namespace avatar"""
-  avatar: String
-  clientMutationId: String
-}
-
-type UpdateNamespacePayload {
-  namespace: Namespace!
-  clientMutationId: String
-}
-
-input UpdateNamespaceInput {
-  namespaceId: ID!
-
-  """The namespace slug name"""
-  name: String
-
-  """The namespace display name"""
-  displayName: String
-
-  """The namespace description"""
-  description: String
-
-  """The namespace avatar"""
-  avatar: String
-
-  """
-  The user Twitter (it can be the url, or the handle with or without the @)
-  """
-  twitter: String
-
-  """
-  The user Github (it can be the url, or the handle with or without the @)
-  """
-  github: String
-
-  """The user website (it must be a valid url)"""
-  websiteUrl: String
-  clientMutationId: String
-}
-
-type DeleteNamespacePayload {
-  success: Boolean!
-  clientMutationId: String
-}
-
-input DeleteNamespaceInput {
-  namespaceId: ID!
-  clientMutationId: String
-}
-
-type InviteNamespaceCollaboratorPayload {
-  invite: NamespaceCollaboratorInvite!
-  namespace: Namespace!
-  clientMutationId: String
-}
-
-input InviteNamespaceCollaboratorInput {
-  namespaceId: ID!
-  role: GrapheneRole!
-  username: String
-  email: String
-  clientMutationId: String
-}
-
-type AcceptNamespaceCollaboratorInvitePayload {
-  namespaceCollaboratorInvite: NamespaceCollaboratorInvite!
-  clientMutationId: String
-}
-
-input AcceptNamespaceCollaboratorInviteInput {
-  inviteId: ID!
-  clientMutationId: String
-}
-
-type RemoveNamespaceCollaboratorInvitePayload {
-  namespace: Namespace!
-  clientMutationId: String
-}
-
-input RemoveNamespaceCollaboratorInviteInput {
-  inviteId: ID!
-  clientMutationId: String
-}
-
-type RemoveNamespaceCollaboratorPayload {
-  namespace: Namespace!
-  clientMutationId: String
-}
-
-input RemoveNamespaceCollaboratorInput {
-  namespaceCollaboratorId: ID!
-  clientMutationId: String
-}
-
-type UpdateNamespaceCollaboratorRolePayload {
-  collaborator: NamespaceCollaborator!
-  clientMutationId: String
-}
-
-input UpdateNamespaceCollaboratorRoleInput {
-  namespaceCollaboratorId: ID!
-  role: GrapheneRole!
-  clientMutationId: String
-}
-
-type UpdateNamespaceCollaboratorInviteRolePayload {
-  collaboratorInvite: NamespaceCollaboratorInvite!
-  clientMutationId: String
-}
-
-input UpdateNamespaceCollaboratorInviteRoleInput {
-  namespaceCollaboratorInviteId: ID!
-  role: GrapheneRole!
-  clientMutationId: String
-}
-
-type InvitePackageCollaboratorPayload {
-  invite: PackageCollaboratorInvite!
-  package: Package!
-  clientMutationId: String
-}
-
-input InvitePackageCollaboratorInput {
-  packageName: String!
-  role: GrapheneRole!
-  username: String
-  email: String
-  clientMutationId: String
-}
-
-type AcceptPackageCollaboratorInvitePayload {
-  packageCollaboratorInvite: PackageCollaboratorInvite!
-  clientMutationId: String
-}
-
-input AcceptPackageCollaboratorInviteInput {
-  inviteId: ID!
-  clientMutationId: String
-}
-
-type RemovePackageCollaboratorInvitePayload {
-  package: Package!
-  clientMutationId: String
-}
-
-input RemovePackageCollaboratorInviteInput {
-  inviteId: ID!
-  clientMutationId: String
-}
-
-type UpdatePackageCollaboratorRolePayload {
-  collaborator: PackageCollaborator!
-  clientMutationId: String
-}
-
-input UpdatePackageCollaboratorRoleInput {
-  packageCollaboratorId: ID!
-  role: GrapheneRole!
-  clientMutationId: String
-}
-
-type UpdatePackageCollaboratorInviteRolePayload {
-  collaboratorInvite: PackageCollaboratorInvite!
-  clientMutationId: String
-}
-
-input UpdatePackageCollaboratorInviteRoleInput {
-  packageCollaboratorInviteId: ID!
-  role: GrapheneRole!
-  clientMutationId: String
-}
-
-type RemovePackageCollaboratorPayload {
-  package: Package!
-  clientMutationId: String
-}
-
-input RemovePackageCollaboratorInput {
-  packageCollaboratorId: ID!
-  clientMutationId: String
-}
-
-type RequestPackageTransferPayload {
-  package: Package!
-  wasInstantlyTransferred: Boolean!
-  packageTransferRequest: PackageTransferRequest
-  clientMutationId: String
-}
-
-input RequestPackageTransferInput {
-  packageId: ID!
-  newOwnerId: ID!
-  clientMutationId: String
-}
-
-type AcceptPackageTransferRequestPayload {
-  package: Package!
-  packageTransferRequest: PackageTransferRequest!
-  clientMutationId: String
-}
-
-input AcceptPackageTransferRequestInput {
-  packageTransferRequestId: ID!
-  clientMutationId: String
-}
-
-type RemovePackageTransferRequestPayload {
-  package: Package!
-  clientMutationId: String
-}
-
-input RemovePackageTransferRequestInput {
-  packageTransferRequestId: ID!
-  clientMutationId: String
-}
-
-type GenerateBindingsForAllPackagesPayload {
-  message: String!
-  clientMutationId: String
-}
-
-input GenerateBindingsForAllPackagesInput {
-  bindingsGeneratorId: ID
-  bindingsGeneratorCommand: String
-  clientMutationId: String
-}
-
-type MakePackagePublicPayload {
-  package: Package!
-  clientMutationId: String
-}
-
-input MakePackagePublicInput {
-  """The ID of the package to make public"""
-  id: ID!
-  clientMutationId: String
-}
-
-type Subscription {
-  streamLogs(
-    appVersionId: ID!
-
-    """
-    Get logs starting from this timestamp. Takes ISO timestamp in UTC timezone.
-    """
-    startingFromISO: DateTime
-
-    """
-    Fetch logs until this timestamp. Takes ISO timestamp in UTC timezone. If specified, the subscription will at this time.
-    """
-    untilISO: DateTime
-
-    """Filter logs by stream"""
-    streams: [LogStream]
-
-    """Filter logs by instance ids"""
-    instanceIds: [String]
-
-    """Search logs for this term"""
-    searchTerm: String
-  ): Log!
-  waitOnRepoCreation(repoId: ID!): Boolean!
-  appIsPublishedFromRepo(repoId: ID!): DeployAppVersion!
-  packageVersionCreated(publishedBy: ID, ownerId: ID): PackageVersion!
-
-  """Subscribe to package version ready"""
-  packageVersionReady(packageVersionId: ID!): PackageVersionReadyResponse!
-  userNotificationCreated(userId: ID!): UserNotificationCreated!
-}
-
-type PackageVersionReadyResponse {
-  state: PackageVersionState!
-  packageVersion: PackageVersion!
-  success: Boolean!
-}
-
-enum PackageVersionState {
-  WEBC_GENERATED
-  BINDINGS_GENERATED
-  NATIVE_EXES_GENERATED
-}
-
-type UserNotificationCreated {
-  notification: UserNotification
-  notificationDeletedId: ID
-}
diff --git a/lib/registry/graphql/subscriptions/packageVersionReady.graphql b/lib/registry/graphql/subscriptions/packageVersionReady.graphql
deleted file mode 100644
index f7324e50da..0000000000
--- a/lib/registry/graphql/subscriptions/packageVersionReady.graphql
+++ /dev/null
@@ -1,6 +0,0 @@
-subscription PackageVersionReady ($packageVersionId: ID!) {
-  packageVersionReady(packageVersionId: $packageVersionId) {
-    state
-    success
-  }
-}
diff --git a/lib/registry/src/api.rs b/lib/registry/src/api.rs
deleted file mode 100644
index 5c107cea7d..0000000000
--- a/lib/registry/src/api.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-use anyhow::Context;
-
-use crate::RegistryClient;
-
-use crate::graphql::mutations::{self};
-use crate::types::{NewNonceOutput, PublishDeployAppOutput, PublishDeployAppRawVars};
-
-/// Generate a Deploy token for for the given Deploy app version id.
-pub async fn generate_deploy_token(
-    client: &RegistryClient,
-    app_version_id: String,
-) -> Result<String, anyhow::Error> {
-    let vars = mutations::generate_deploy_token::Variables { app_version_id };
-    let res = client
-        .execute::<mutations::GenerateDeployToken>(vars)
-        .await?;
-    let token = res
-        .generate_deploy_token
-        .context("Query did not return a token")?
-        .token;
-
-    Ok(token)
-}
-
-/// Publish a Deploy app.
-///
-/// Takes a raw, unvalidated deployment config.
-// TODO: Add a variant of this query that takes a typed DeployV1 config.
-pub async fn publish_deploy_app_raw(
-    client: &RegistryClient,
-    data: PublishDeployAppRawVars,
-) -> Result<PublishDeployAppOutput, anyhow::Error> {
-    let vars2 = mutations::publish_deploy_app::Variables {
-        name: data.name,
-        owner: data.namespace,
-        config: serde_json::to_string(&data.config)?,
-    };
-
-    let version = client
-        .execute::<mutations::PublishDeployApp>(vars2)
-        .await?
-        .publish_deploy_app
-        .context("Query did not return data")?
-        .deploy_app_version;
-
-    let app = version.app;
-    // let app = version.app.context("Query did not return expected data")?;
-
-    Ok(PublishDeployAppOutput {
-        app_id: app.id,
-        app_name: app.name,
-        version_id: version.id,
-        version_name: version.version,
-        owner_name: app.owner.global_name,
-    })
-}
-
-/// Generate a new Nonce
-///
-/// Takes a name and a callbackUrl and returns a nonce
-pub async fn create_nonce(
-    client: &RegistryClient,
-    name: String,
-    callback_url: String,
-) -> Result<NewNonceOutput, anyhow::Error> {
-    let vars = mutations::new_nonce::Variables { name, callback_url };
-    let nonce = client
-        .execute::<mutations::NewNonce>(vars)
-        .await?
-        .new_nonce
-        .context("Query did not return a nonce")?
-        .nonce;
-
-    Ok(NewNonceOutput {
-        auth_url: nonce.auth_url,
-    })
-}
diff --git a/lib/registry/src/client.rs b/lib/registry/src/client.rs
deleted file mode 100644
index 3ae909bc4b..0000000000
--- a/lib/registry/src/client.rs
+++ /dev/null
@@ -1,100 +0,0 @@
-use anyhow::Context;
-use graphql_client::GraphQLQuery;
-use url::Url;
-
-/// API client for the Wasmer registry.
-#[derive(Clone)]
-pub struct RegistryClient {
-    client: reqwest::Client,
-    endpoint: Url,
-    token: Option<String>,
-}
-
-impl RegistryClient {
-    /// Construct a new registry.
-    pub fn new(endpoint: Url, token: Option<String>, user_agent: Option<String>) -> Self {
-        let user_agent = user_agent.unwrap_or_else(Self::default_user_agent);
-        let client = reqwest::Client::builder()
-            .user_agent(user_agent)
-            .build()
-            .unwrap();
-        Self {
-            client,
-            endpoint,
-            token,
-        }
-    }
-
-    /// Construct a client from a [`crate::config::RegistryLogin`].
-    pub fn from_registry(registry: crate::config::RegistryLogin) -> Result<Self, anyhow::Error> {
-        let endpoint = registry.registry.parse().context("Invalid registry URL")?;
-        let client = Self::new(endpoint, Some(registry.token), None);
-        Ok(client)
-    }
-
-    pub(crate) fn default_user_agent() -> String {
-        format!(
-            "wasmer/{} {} {}",
-            env!("CARGO_PKG_VERSION"),
-            whoami::platform(),
-            crate::graphql::whoami_distro(),
-        )
-    }
-
-    /// Set the GraphQL API endpoint.
-    pub fn with_endpoint(self, endpoint: Url) -> Self {
-        Self { endpoint, ..self }
-    }
-
-    /// Set the authentication token.
-    pub fn with_token(self, token: String) -> Self {
-        Self {
-            token: Some(token),
-            ..self
-        }
-    }
-
-    /// Execute a GraphQL query.
-    pub(crate) async fn execute_unchecked<Q: GraphQLQuery>(
-        &self,
-        vars: Q::Variables,
-    ) -> Result<graphql_client::Response<Q::ResponseData>, reqwest::Error> {
-        let body = Q::build_query(vars);
-
-        let req = self.client.post(self.endpoint.as_str());
-
-        let req = if let Some(token) = &self.token {
-            req.bearer_auth(token)
-        } else {
-            req
-        };
-        req.json(&body)
-            .send()
-            .await?
-            .error_for_status()?
-            .json::<graphql_client::Response<Q::ResponseData>>()
-            .await
-    }
-
-    /// Execute a GraphQL query, and convert a response with errors to a Rust error.
-    pub(crate) async fn execute<Q: GraphQLQuery>(
-        &self,
-        vars: Q::Variables,
-    ) -> Result<Q::ResponseData, anyhow::Error> {
-        let res = self.execute_unchecked::<Q>(vars).await?;
-
-        match (res.data, res.errors) {
-            (_, Some(errors)) => {
-                // TODO: Better error forwaring with a custom error type.
-                let errors = errors
-                    .iter()
-                    .map(|x| x.to_string())
-                    .collect::<Vec<_>>()
-                    .join(", ");
-                anyhow::bail!("GraphQL error: {errors}");
-            }
-            (Some(data), None) => Ok(data),
-            (None, None) => anyhow::bail!("GraphQL response contained no data"),
-        }
-    }
-}
diff --git a/lib/registry/src/config.rs b/lib/registry/src/config.rs
deleted file mode 100644
index 4eb49b5bb2..0000000000
--- a/lib/registry/src/config.rs
+++ /dev/null
@@ -1,323 +0,0 @@
-use serde::{Deserialize, Serialize};
-use std::path::{Path, PathBuf};
-use url::Url;
-
-pub static GLOBAL_CONFIG_DATABASE_FILE_NAME: &str = "wasmer.sqlite";
-
-#[derive(Deserialize, Default, Serialize, Debug, PartialEq, Eq)]
-pub struct WasmerConfig {
-    /// Whether or not telemetry is enabled.
-    #[serde(default)]
-    pub telemetry_enabled: bool,
-
-    /// Whether or not updated notifications are enabled.
-    #[serde(default)]
-    pub update_notifications_enabled: bool,
-
-    /// The registry that wasmer will connect to.
-    pub registry: MultiRegistry,
-
-    /// The proxy to use when connecting to the Internet.
-    #[serde(default)]
-    pub proxy: Proxy,
-}
-
-pub const fn wax_default_cooldown() -> i32 {
-    5 * 60
-}
-
-#[derive(Deserialize, Serialize, Debug, PartialEq, Eq, Default)]
-pub struct Proxy {
-    pub url: Option<String>,
-}
-
-/// Struct to store login tokens for multiple registry URLs
-/// inside of the wasmer.toml configuration file
-#[derive(Deserialize, Serialize, Debug, PartialEq, Eq, Clone)]
-pub struct MultiRegistry {
-    /// Currently active registry
-    pub active_registry: String,
-    /// Map from "RegistryUrl" to "LoginToken", in order to
-    /// be able to be able to easily switch between registries
-    pub tokens: Vec<RegistryLogin>,
-}
-
-#[derive(Deserialize, Serialize, Debug, PartialEq, Eq, Clone)]
-pub struct RegistryLogin {
-    /// Registry URL to login to
-    pub registry: String,
-    /// Login token for the registry
-    pub token: String,
-}
-
-impl Default for MultiRegistry {
-    fn default() -> Self {
-        MultiRegistry {
-            active_registry: format_graphql("wasmer.io"),
-            tokens: Vec::new(),
-        }
-    }
-}
-
-#[derive(Deserialize, Serialize, Debug, PartialEq, Eq, Clone)]
-pub struct Registry {
-    pub url: String,
-    pub token: Option<String>,
-}
-
-pub fn format_graphql(registry: &str) -> String {
-    if let Ok(mut url) = Url::parse(registry) {
-        // Looks like we've got a valid URL. Let's try to use it as-is.
-        if url.has_host() {
-            if url.path() == "/" {
-                // make sure we convert http://registry.wasmer.io/ to
-                // http://registry.wasmer.io/graphql
-                url.set_path("/graphql");
-            }
-
-            return url.to_string();
-        }
-    }
-
-    if !registry.contains("://") && !registry.contains('/') {
-        return endpoint_from_domain_name(registry);
-    }
-
-    // looks like we've received something we can't deal with. Just pass it
-    // through as-is and hopefully it'll either work or the end user can figure
-    // it out
-    registry.to_string()
-}
-
-/// By convention, something like `"wasmer.io"` should be converted to
-/// `"https://registry.wasmer.io/graphql"`.
-fn endpoint_from_domain_name(domain_name: &str) -> String {
-    if domain_name.contains("localhost") {
-        return format!("http://{domain_name}/graphql");
-    }
-
-    format!("https://registry.{domain_name}/graphql")
-}
-
-fn test_if_registry_present(registry: &str) -> Result<(), String> {
-    crate::utils::get_username_registry_token(registry, "")
-        .map(|_| ())
-        .map_err(|e| format!("{e}"))
-}
-
-#[derive(PartialEq, Eq, Copy, Clone)]
-pub enum UpdateRegistry {
-    Update,
-    LeaveAsIs,
-}
-
-impl MultiRegistry {
-    /// Gets the current (active) registry URL
-    pub fn clear_current_registry_token(&mut self) {
-        let MultiRegistry {
-            active_registry,
-            tokens,
-        } = self;
-        tokens.retain(|i| i.registry != *active_registry);
-        tokens.retain(|i| i.registry != format_graphql(active_registry));
-    }
-
-    pub fn get_graphql_url(&self) -> String {
-        let registry = self.get_current_registry();
-        format_graphql(&registry)
-    }
-
-    /// Gets the current (active) registry URL
-    pub fn get_current_registry(&self) -> String {
-        format_graphql(&self.active_registry)
-    }
-
-    pub fn current_login(&self) -> Option<&RegistryLogin> {
-        self.tokens
-            .iter()
-            .find(|login| login.registry == self.active_registry)
-    }
-
-    /// Sets the current (active) registry URL
-    pub fn set_current_registry(&mut self, registry: &str) {
-        let registry = format_graphql(registry);
-        if let Err(e) = test_if_registry_present(&registry) {
-            println!("Error when trying to ping registry {registry:?}: {e}");
-            println!("WARNING: Registry {registry:?} will be used, but commands may not succeed.");
-        }
-        self.active_registry = registry;
-    }
-
-    /// Returns the login token for the registry
-    pub fn get_login_token_for_registry(&self, registry: &str) -> Option<String> {
-        let registry_formatted = format_graphql(registry);
-        self.tokens
-            .iter()
-            .filter(|login| login.registry == registry || login.registry == registry_formatted)
-            .last()
-            .map(|login| login.token.clone())
-    }
-
-    /// Sets the login token for the registry URL
-    pub fn set_login_token_for_registry(
-        &mut self,
-        registry: &str,
-        token: &str,
-        update_current_registry: UpdateRegistry,
-    ) {
-        let registry_formatted = format_graphql(registry);
-        self.tokens
-            .retain(|login| !(login.registry == registry || login.registry == registry_formatted));
-        self.tokens.push(RegistryLogin {
-            registry: format_graphql(registry),
-            token: token.to_string(),
-        });
-        if update_current_registry == UpdateRegistry::Update {
-            self.active_registry = format_graphql(registry);
-        }
-    }
-}
-
-impl WasmerConfig {
-    pub(crate) const ENV_VAR_WASMER_REGISTRY_TOKEN: &'static str = "WASMER_TOKEN";
-    pub(crate) const ENV_VAR_WASMER_REGISTRY_TOKEN_LEGACY: &'static str = "WAPM_REGISTRY_TOKEN";
-
-    /// Save the config to a file
-    pub fn save<P: AsRef<Path>>(&self, to: P) -> anyhow::Result<()> {
-        use std::{fs::File, io::Write};
-        let config_serialized = toml::to_string(&self)?;
-        let mut file = File::create(to)?;
-        file.write_all(config_serialized.as_bytes())?;
-        Ok(())
-    }
-
-    pub fn from_file(wasmer_dir: &Path) -> Result<Self, String> {
-        let path = Self::get_file_location(wasmer_dir);
-        match std::fs::read_to_string(path) {
-            Ok(config_toml) => Ok(toml::from_str(&config_toml).unwrap_or_else(|_| Self::default())),
-            Err(_e) => Ok(Self::default()),
-        }
-    }
-
-    /// Creates and returns the `WASMER_DIR` directory (or $HOME/.wasmer as a fallback)
-    pub fn get_wasmer_dir() -> Result<PathBuf, String> {
-        Ok(
-            if let Some(folder_str) = std::env::var("WASMER_DIR").ok().filter(|s| !s.is_empty()) {
-                let folder = PathBuf::from(folder_str);
-                std::fs::create_dir_all(folder.clone())
-                    .map_err(|e| format!("cannot create config directory: {e}"))?;
-                folder
-            } else {
-                #[allow(unused_variables)]
-                let default_dir = Self::get_current_dir()
-                    .ok()
-                    .unwrap_or_else(|| PathBuf::from("/".to_string()));
-                let home_dir =
-                    dirs::home_dir().ok_or_else(|| "cannot find home directory".to_string())?;
-                let mut folder = home_dir;
-                folder.push(".wasmer");
-                std::fs::create_dir_all(folder.clone())
-                    .map_err(|e| format!("cannot create config directory: {e}"))?;
-                folder
-            },
-        )
-    }
-
-    /// Load the config based on environment variables and default config file locations.
-    pub fn from_env() -> Result<Self, anyhow::Error> {
-        let dir = Self::get_wasmer_dir()
-            .map_err(|err| anyhow::anyhow!("Could not determine wasmer dir: {err}"))?;
-        let file_path = Self::get_file_location(&dir);
-        Self::from_file(&file_path).map_err(|err| {
-            anyhow::anyhow!(
-                "Could not load config file at '{}': {}",
-                file_path.display(),
-                err
-            )
-        })
-    }
-
-    pub fn get_current_dir() -> std::io::Result<PathBuf> {
-        std::env::current_dir()
-    }
-
-    pub fn get_file_location(wasmer_dir: &Path) -> PathBuf {
-        wasmer_dir.join(crate::GLOBAL_CONFIG_FILE_NAME)
-    }
-
-    pub fn get_database_file_path(wasmer_dir: &Path) -> PathBuf {
-        wasmer_dir.join(GLOBAL_CONFIG_DATABASE_FILE_NAME)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_registries_switch_token() {
-        let mut registries = MultiRegistry::default();
-
-        registries.set_current_registry("https://registry.wasmer.wtf");
-        assert_eq!(
-            registries.get_current_registry(),
-            "https://registry.wasmer.wtf/graphql".to_string()
-        );
-        registries.set_login_token_for_registry(
-            "https://registry.wasmer.io",
-            "token1",
-            UpdateRegistry::LeaveAsIs,
-        );
-        assert_eq!(
-            registries.get_current_registry(),
-            "https://registry.wasmer.wtf/graphql".to_string()
-        );
-        assert_eq!(
-            registries.get_login_token_for_registry(&registries.get_current_registry()),
-            None
-        );
-        registries.set_current_registry("https://registry.wasmer.io");
-        assert_eq!(
-            registries.get_login_token_for_registry(&registries.get_current_registry()),
-            Some("token1".to_string())
-        );
-        registries.clear_current_registry_token();
-        assert_eq!(
-            registries.get_login_token_for_registry(&registries.get_current_registry()),
-            None
-        );
-    }
-
-    #[test]
-    fn format_registry_urls() {
-        let inputs = [
-            // Domain names work
-            ("wasmer.io", "https://registry.wasmer.io/graphql"),
-            ("wasmer.wtf", "https://registry.wasmer.wtf/graphql"),
-            // Plain URLs
-            (
-                "https://registry.wasmer.wtf/graphql",
-                "https://registry.wasmer.wtf/graphql",
-            ),
-            (
-                "https://registry.wasmer.wtf/something/else",
-                "https://registry.wasmer.wtf/something/else",
-            ),
-            // We don't automatically prepend the domain name with
-            // "registry", but we will make sure "/" gets turned into "/graphql"
-            ("https://wasmer.wtf/", "https://wasmer.wtf/graphql"),
-            ("https://wasmer.wtf", "https://wasmer.wtf/graphql"),
-            // local development
-            (
-                "http://localhost:8000/graphql",
-                "http://localhost:8000/graphql",
-            ),
-            ("localhost:8000", "http://localhost:8000/graphql"),
-        ];
-
-        for (input, expected) in inputs {
-            let url = format_graphql(input);
-            assert_eq!(url, expected);
-        }
-    }
-}
diff --git a/lib/registry/src/graphql/mod.rs b/lib/registry/src/graphql/mod.rs
deleted file mode 100644
index 467a1aaec8..0000000000
--- a/lib/registry/src/graphql/mod.rs
+++ /dev/null
@@ -1,157 +0,0 @@
-pub(crate) mod mutations;
-pub(crate) mod proxy;
-pub(crate) mod queries;
-pub(crate) mod subscriptions;
-
-use graphql_client::*;
-use reqwest::{
-    blocking::{multipart::Form, Client},
-    header::USER_AGENT,
-};
-use std::env;
-use std::time::Duration;
-
-use crate::config::WasmerConfig;
-
-pub fn whoami_distro() -> String {
-    #[cfg(target_os = "wasi")]
-    {
-        whoami::os().to_lowercase()
-    }
-    #[cfg(not(target_os = "wasi"))]
-    {
-        whoami::distro().to_lowercase()
-    }
-}
-
-fn setup_client() -> Result<Client, anyhow::Error> {
-    let builder = Client::builder();
-    let builder = proxy::maybe_set_up_proxy_blocking(builder)?;
-    builder.build().map_err(|e| e.into())
-}
-
-/// This function is being used to "ping" the registry
-/// (see test_if_registry_present and see whether the response
-/// is valid JSON, it doesn't check the response itself,
-/// since the response format might change
-pub fn execute_query_modifier_inner_check_json<V, F>(
-    registry_url: &str,
-    login_token: &str,
-    query: &QueryBody<V>,
-    timeout: Option<Duration>,
-    form_modifier: F,
-) -> anyhow::Result<()>
-where
-    V: serde::Serialize,
-    F: FnOnce(Form) -> Form,
-{
-    let client = setup_client()?;
-
-    let vars = serde_json::to_string(&query.variables).unwrap();
-
-    let form = Form::new()
-        .text("query", query.query.to_string())
-        .text("operationName", query.operation_name.to_string())
-        .text("variables", vars);
-
-    let form = form_modifier(form);
-
-    let user_agent = crate::client::RegistryClient::default_user_agent();
-
-    let mut res = client
-        .post(registry_url)
-        .multipart(form)
-        .bearer_auth(
-            env::var(WasmerConfig::ENV_VAR_WASMER_REGISTRY_TOKEN)
-                .ok()
-                .or_else(|| env::var(WasmerConfig::ENV_VAR_WASMER_REGISTRY_TOKEN_LEGACY).ok())
-                .unwrap_or_else(|| login_token.to_string()),
-        )
-        .header(USER_AGENT, user_agent);
-
-    if let Some(t) = timeout {
-        res = res.timeout(t);
-    }
-
-    let res = res.send()?;
-
-    let _: Response<serde_json::Value> = res.json()?;
-
-    Ok(())
-}
-
-pub fn execute_query_modifier_inner<R, V, F>(
-    registry_url: &str,
-    login_token: &str,
-    query: &QueryBody<V>,
-    timeout: Option<Duration>,
-    form_modifier: F,
-) -> anyhow::Result<R>
-where
-    for<'de> R: serde::Deserialize<'de>,
-    V: serde::Serialize,
-    F: FnOnce(Form) -> Form,
-{
-    let client = setup_client()?;
-
-    let vars = serde_json::to_string(&query.variables).unwrap();
-
-    let form = Form::new()
-        .text("query", query.query.to_string())
-        .text("operationName", query.operation_name.to_string())
-        .text("variables", vars);
-
-    let form = form_modifier(form);
-
-    let user_agent = crate::client::RegistryClient::default_user_agent();
-
-    let mut res = client
-        .post(registry_url)
-        .multipart(form)
-        .bearer_auth(
-            env::var("WASMER_TOKEN")
-                .ok()
-                .or_else(|| env::var("WAPM_REGISTRY_TOKEN").ok())
-                .unwrap_or_else(|| login_token.to_string()),
-        )
-        .header(USER_AGENT, user_agent);
-
-    if let Some(t) = timeout {
-        res = res.timeout(t);
-    }
-
-    let res = res.send()?;
-    let response_body: Response<R> = res.json()?;
-    if let Some(errors) = response_body.errors {
-        let error_messages: Vec<String> = errors.into_iter().map(|err| err.message).collect();
-        return Err(anyhow::anyhow!("{}", error_messages.join(", ")));
-    }
-    response_body
-        .data
-        .ok_or_else(|| anyhow::anyhow!("missing response data"))
-}
-
-pub fn execute_query<R, V>(
-    registry_url: &str,
-    login_token: &str,
-    query: &QueryBody<V>,
-) -> anyhow::Result<R>
-where
-    for<'de> R: serde::Deserialize<'de>,
-    V: serde::Serialize,
-{
-    execute_query_modifier_inner(registry_url, login_token, query, None, |f| f)
-}
-
-pub fn execute_query_with_timeout<R, V>(
-    registry_url: &str,
-    login_token: &str,
-    timeout: Duration,
-    query: &QueryBody<V>,
-) -> anyhow::Result<R>
-where
-    for<'de> R: serde::Deserialize<'de>,
-    V: serde::Serialize,
-{
-    execute_query_modifier_inner(registry_url, login_token, query, Some(timeout), |f| f)
-}
diff --git a/lib/registry/src/graphql/mutations.rs b/lib/registry/src/graphql/mutations.rs
deleted file mode 100644
index 18558379ff..0000000000
--- a/lib/registry/src/graphql/mutations.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-use graphql_client::GraphQLQuery;
-
-#[derive(GraphQLQuery)]
-#[graphql(
-    schema_path = "graphql/schema.graphql",
-    query_path = "graphql/mutations/publish_package_chunked.graphql",
-    response_derives = "Debug",
-    variables_derives = "Debug"
-    // additional_derives = "Debug"
-)]
-pub(crate) struct PublishPackageMutationChunked;
-
-#[derive(GraphQLQuery)]
-#[graphql(
-    schema_path = "graphql/schema.graphql",
-    query_path = "graphql/mutations/generate_deploy_token.graphql",
-    response_derives = "Debug"
-)]
-pub(crate) struct GenerateDeployToken;
-
-pub type JSONString = String;
-
-#[derive(GraphQLQuery)]
-#[graphql(
-    schema_path = "graphql/schema.graphql",
-    query_path = "graphql/mutations/publish_deploy_app.graphql",
-    response_derives = "Debug"
-)]
-pub(crate) struct PublishDeployApp;
-
-#[derive(GraphQLQuery)]
-#[graphql(
-    schema_path = "graphql/schema.graphql",
-    query_path = "graphql/mutations/new_nonce.graphql",
-    response_derives = "Debug"
-)]
-pub(crate) struct NewNonce;
diff --git a/lib/registry/src/graphql/proxy.rs b/lib/registry/src/graphql/proxy.rs
deleted file mode 100644
index 75ac81faec..0000000000
--- a/lib/registry/src/graphql/proxy.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-//! Code for dealing with setting things up to proxy network requests
-
-use std::env;
-
-use anyhow::Context;
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-pub enum ProxyError {
-    #[error("Failed to parse URL from {}: {}", url_location, error_message)]
-    UrlParseError {
-        url_location: String,
-        error_message: String,
-    },
-
-    #[error("Could not connect to proxy: {0}")]
-    ConnectionError(String),
-}
-
-pub fn maybe_set_up_proxy_blocking(
-    builder: reqwest::blocking::ClientBuilder,
-) -> anyhow::Result<reqwest::blocking::ClientBuilder> {
-    if let Some(proxy) =
-        maybe_set_up_proxy_inner().context("failed to setup proxy for reqwest Client")?
-    {
-        return Ok(builder.proxy(proxy));
-    }
-    Ok(builder)
-}
-
-/// Tries to set up a proxy
-///
-/// This function reads from wasmer config's `proxy.url` first, then checks
-/// `ALL_PROXY`, `HTTPS_PROXY`, and `HTTP_PROXY` environment variables, in both
-/// upper case and lower case, in that order.
-///
-/// If a proxy is specified in wasmer config's `proxy.url`, it is assumed
-/// to be a general proxy
-///
-/// A return value of `Ok(None)` means that there was no attempt to set up a proxy,
-/// `Ok(Some(proxy))` means that the proxy was set up successfully, and `Err(e)` that
-/// there was a failure while attempting to set up the proxy.
-fn maybe_set_up_proxy_inner() -> anyhow::Result<Option<reqwest::Proxy>> {
-    let proxy = if let Ok(proxy_url) = env::var("ALL_PROXY").or_else(|_| env::var("all_proxy")) {
-        reqwest::Proxy::all(&proxy_url).map(|proxy| (proxy_url, proxy, "ALL_PROXY"))
-    } else if let Ok(https_proxy_url) = env::var("HTTPS_PROXY").or_else(|_| env::var("https_proxy"))
-    {
-        reqwest::Proxy::https(&https_proxy_url).map(|proxy| (https_proxy_url, proxy, "HTTPS_PROXY"))
-    } else if let Ok(http_proxy_url) = env::var("HTTP_PROXY").or_else(|_| env::var("http_proxy")) {
-        reqwest::Proxy::http(&http_proxy_url).map(|proxy| (http_proxy_url, proxy, "http_proxy"))
-    } else {
-        return Ok(None);
-    }
-    .map_err(|e| ProxyError::ConnectionError(e.to_string()))
-    .and_then(
-        |(proxy_url_str, proxy, url_location): (String, _, &'static str)| {
-            url::Url::parse(&proxy_url_str)
-                .map_err(|e| ProxyError::UrlParseError {
-                    url_location: url_location.to_string(),
-                    error_message: e.to_string(),
-                })
-                .map(|url| {
-                    if !(url.username().is_empty()) && url.password().is_some() {
-                        proxy.basic_auth(url.username(), url.password().unwrap_or_default())
-                    } else {
-                        proxy
-                    }
-                })
-        },
-    )?;
-
-    Ok(Some(proxy))
-}
diff --git a/lib/registry/src/graphql/queries.rs b/lib/registry/src/graphql/queries.rs
deleted file mode 100644
index a95234f855..0000000000
--- a/lib/registry/src/graphql/queries.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-//! Low-level GraphQL queries used by this crate.
-//!
-//! If possible, users should prefer the high-level functions exposed under
-//! [`crate`].
-//!
-//! This module is primarily used in combination with
-//! [`crate::graphql::execute_query()`] as an "escape hatch" for accessing
-//! information that may not be exposed via the high-level functions.
-//!
-//! # Backwards Compatibility
-//!
-//! Queries won't be deleted or have breaking changes to their inputs during
-//! patch releases, however new fields may be added to the response types
-//! generated by `graphql_client` at any time.
-//!
-//! Users should treat all response types as if they had the `#[non_exhaustive]`
-//! attribute.
-
-use graphql_client::GraphQLQuery;
-
-#[derive(GraphQLQuery)]
-#[graphql(
-    schema_path = "graphql/schema.graphql",
-    query_path = "graphql/queries/get_package_version.graphql",
-    response_derives = "Debug"
-)]
-pub(crate) struct GetPackageVersionQuery;
-
-#[derive(GraphQLQuery)]
-#[graphql(
-    schema_path = "graphql/schema.graphql",
-    query_path = "graphql/queries/get_package_by_command.graphql",
-    response_derives = "Debug"
-)]
-pub(crate) struct GetPackageByCommandQuery;
-
-#[derive(GraphQLQuery)]
-#[graphql(
-    schema_path = "graphql/schema.graphql",
-    query_path = "graphql/queries/test_if_registry_present.graphql",
-    response_derives = "Debug"
-)]
-pub(crate) struct TestIfRegistryPresent;
-
-#[derive(GraphQLQuery)]
-#[graphql(
-    schema_path = "graphql/schema.graphql",
-    query_path = "graphql/queries/get_bindings.graphql",
-    response_derives = "Debug,Clone,PartialEq,Eq"
-)]
-pub(crate) struct GetBindingsQuery;
-
-#[derive(GraphQLQuery)]
-#[graphql(
-    schema_path = "graphql/schema.graphql",
-    query_path = "graphql/queries/get_signed_url.graphql",
-    response_derives = "Debug, Clone"
-)]
-pub(crate) struct GetSignedUrl;
-
-#[derive(GraphQLQuery)]
-#[graphql(
-    schema_path = "graphql/schema.graphql",
-    query_path = "graphql/queries/get_interface_version.graphql",
-    response_derives = "Debug"
-)]
-pub(crate) struct GetInterfaceVersionQuery;
-
-#[derive(GraphQLQuery)]
-#[graphql(
-    schema_path = "graphql/schema.graphql",
-    query_path = "graphql/queries/whoami.graphql",
-    response_derives = "Debug"
-)]
-pub struct WhoAmIQuery;
diff --git a/lib/registry/src/graphql/subscriptions.rs b/lib/registry/src/graphql/subscriptions.rs
deleted file mode 100644
index 6f0115f4a0..0000000000
--- a/lib/registry/src/graphql/subscriptions.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-use graphql_client::GraphQLQuery;
-
-#[derive(GraphQLQuery)]
-#[graphql(
-    schema_path = "graphql/schema.graphql",
-    query_path = "graphql/subscriptions/packageVersionReady.graphql",
-    response_derives = "Debug"
-)]
-pub struct PackageVersionReady;
diff --git a/lib/registry/src/interface.rs b/lib/registry/src/interface.rs
deleted file mode 100644
index 614ae386dc..0000000000
--- a/lib/registry/src/interface.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-#![cfg_attr(
-    not(feature = "full"),
-    allow(dead_code, unused_imports, unused_variables)
-)]
-
-use graphql_client::GraphQLQuery;
-
-use crate::graphql::{
-    execute_query,
-    queries::{get_interface_version_query, GetInterfaceVersionQuery},
-};
-
-#[derive(Debug)]
-pub struct InterfaceFromServer {
-    pub name: String,
-    pub version: String,
-    pub content: String,
-}
-
-impl InterfaceFromServer {
-    fn get_response(
-        registry: &str,
-        name: String,
-        version: String,
-    ) -> anyhow::Result<get_interface_version_query::ResponseData> {
-        let q = GetInterfaceVersionQuery::build_query(get_interface_version_query::Variables {
-            name,
-            version,
-        });
-        execute_query(registry, "", &q)
-    }
-
-    pub fn get(registry: &str, name: String, version: String) -> anyhow::Result<Self> {
-        let response = Self::get_response(registry, name, version)?;
-        let response_val = response
-            .interface
-            .ok_or_else(|| anyhow::anyhow!("Error downloading Interface from the server"))?;
-        Ok(Self {
-            name: response_val.interface.name,
-            version: response_val.version,
-            content: response_val.content,
-        })
-    }
-}
diff --git a/lib/registry/src/lib.rs b/lib/registry/src/lib.rs
deleted file mode 100644
index 6804d864e1..0000000000
--- a/lib/registry/src/lib.rs
+++ /dev/null
@@ -1,526 +0,0 @@
-//! High-level interactions with the Wasmer backend.
-//!
-//! The GraphQL schema can be updated by running `make` in the Wasmer repo's
-//! root directory.
-//!
-//! ```console
-//! $ make update-graphql-schema
-//! curl -sSfL https://registry.wasmer.io/graphql/schema.graphql > lib/registry/graphql/schema.graphql
-//! ```
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
-
-pub mod api;
-mod client;
-pub mod config;
-pub mod graphql;
-pub mod interface;
-pub mod login;
-pub mod package;
-pub mod publish;
-pub mod subscriptions;
-pub mod types;
-pub mod utils;
-pub mod wasmer_env;
-
-pub use crate::client::RegistryClient;
-
-use std::{
-    fmt,
-    path::{Path, PathBuf},
-    time::Duration,
-};
-
-use anyhow::Context;
-use graphql_client::GraphQLQuery;
-use tar::EntryType;
-
-use crate::utils::normalize_path;
-pub use crate::{
-    config::{format_graphql, WasmerConfig},
-    graphql::queries::get_bindings_query::ProgrammingLanguage,
-    package::Package,
-};
-
-pub static PACKAGE_TOML_FILE_NAME: &str = "wasmer.toml";
-pub static PACKAGE_TOML_FALLBACK_NAME: &str = "wapm.toml";
-pub static GLOBAL_CONFIG_FILE_NAME: &str = "wasmer.toml";
-
-#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord)]
-#[non_exhaustive]
-pub struct PackageDownloadInfo {
-    pub registry: String,
-    pub package: String,
-    pub version: String,
-    pub is_latest_version: bool,
-    /// Is the package private?
-    pub is_private: bool,
-    pub commands: String,
-    pub manifest: String,
-    pub url: String,
-    pub pirita_url: Option<String>,
-}
-
-pub fn query_command_from_registry(
-    registry_url: &str,
-    command_name: &str,
-) -> Result<PackageDownloadInfo, String> {
-    use crate::graphql::{
-        execute_query,
-        queries::{get_package_by_command_query, GetPackageByCommandQuery},
-    };
-
-    let q = GetPackageByCommandQuery::build_query(get_package_by_command_query::Variables {
-        command_name: command_name.to_string(),
-    });
-
-    let response: get_package_by_command_query::ResponseData = execute_query(registry_url, "", &q)
-        .map_err(|e| format!("Error sending GetPackageByCommandQuery:  {e}"))?;
-
-    let command = response
-        .get_command
-        .ok_or_else(|| "GetPackageByCommandQuery: no get_command".to_string())?;
-
-    let package = command.package_version.package.display_name;
-    let version = command.package_version.version;
-    let url = command.package_version.distribution.download_url;
-    let pirita_url = command.package_version.distribution.pirita_download_url;
-
-    Ok(PackageDownloadInfo {
-        registry: registry_url.to_string(),
-        package,
-        version,
-        is_latest_version: command.package_version.is_last_version,
-        manifest: command.package_version.manifest,
-        commands: command_name.to_string(),
-        url,
-        pirita_url,
-        is_private: command.package_version.package.private,
-    })
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd)]
-pub enum QueryPackageError {
-    ErrorSendingQuery(String),
-    NoPackageFound {
-        name: String,
-        version: Option<String>,
-    },
-}
-
-impl fmt::Display for QueryPackageError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            QueryPackageError::ErrorSendingQuery(q) => write!(f, "error sending query: {q}"),
-            QueryPackageError::NoPackageFound { name, version } => {
-                write!(f, "no package found for {name:?}")?;
-                if let Some(version) = version {
-                    write!(f, " (version = {version:?})")?;
-                }
-
-                Ok(())
-            }
-        }
-    }
-}
-
-impl std::error::Error for QueryPackageError {}
-
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd)]
-pub enum GetIfPackageHasNewVersionResult {
-    // if version = Some(...) and the ~/.wasmer/checkouts/.../{version} exists, the package is already installed
-    UseLocalAlreadyInstalled {
-        registry_host: String,
-        namespace: String,
-        name: String,
-        version: String,
-        path: PathBuf,
-    },
-    // if version = None, check for the latest version
-    LocalVersionMayBeOutdated {
-        registry_host: String,
-        namespace: String,
-        name: String,
-        /// Versions that are already installed + whether they are
-        /// older (true) or younger (false) than the timeout
-        installed_versions: Vec<(String, bool)>,
-    },
-    // registry / namespace / name / version doesn't exist yet
-    PackageNotInstalledYet {
-        registry_url: String,
-        namespace: String,
-        name: String,
-        version: Option<String>,
-    },
-}
-
-/// Returns the download info of the packages, on error returns all the available packages
-/// i.e. (("foo/python", "wasmer.io"), ("bar/python" "wasmer.io")))
-pub fn query_package_from_registry(
-    registry_url: &str,
-    name: &str,
-    version: Option<&str>,
-    auth_token: Option<&str>,
-) -> Result<PackageDownloadInfo, QueryPackageError> {
-    use crate::graphql::{
-        execute_query,
-        queries::{get_package_version_query, GetPackageVersionQuery},
-    };
-
-    let q = GetPackageVersionQuery::build_query(get_package_version_query::Variables {
-        name: name.to_string(),
-        version: version.map(|s| s.to_string()),
-    });
-
-    let response: get_package_version_query::ResponseData =
-        execute_query(registry_url, auth_token.unwrap_or_default(), &q).map_err(|e| {
-            QueryPackageError::ErrorSendingQuery(format!("Error sending GetPackagesQuery: {e}"))
-        })?;
-
-    let v = response
-        .package_version
-        .as_ref()
-        .ok_or_else(|| QueryPackageError::NoPackageFound {
-            name: name.to_string(),
-            version: None,
-        })?;
-
-    let manifest =
-        toml::from_str::<wasmer_config::package::Manifest>(&v.manifest).map_err(|e| {
-            QueryPackageError::ErrorSendingQuery(format!(
-                "Invalid manifest for crate {name:?}: {e}"
-            ))
-        })?;
-
-    Ok(PackageDownloadInfo {
-        registry: registry_url.to_string(),
-        package: v.package.name.clone(),
-
-        version: v.version.clone(),
-        is_latest_version: v.is_last_version,
-        is_private: v.package.private,
-        manifest: v.manifest.clone(),
-
-        commands: manifest
-            .commands
-            .iter()
-            .map(|s| s.get_name())
-            .collect::<Vec<_>>()
-            .join(", "),
-
-        url: v.distribution.download_url.clone(),
-        pirita_url: v.distribution.pirita_download_url.clone(),
-    })
-}
-
-pub fn get_checkouts_dir(wasmer_dir: &Path) -> PathBuf {
-    wasmer_dir.join("checkouts")
-}
-
-pub fn get_webc_dir(wasmer_dir: &Path) -> PathBuf {
-    wasmer_dir.join("webc")
-}
-
-/// Convenience function that will unpack .tar.gz files and .tar.bz
-/// files to a target directory (does NOT remove the original .tar.gz)
-pub fn try_unpack_targz<P: AsRef<Path>>(
-    target_targz_path: P,
-    target_path: P,
-    strip_toplevel: bool,
-) -> Result<PathBuf, anyhow::Error> {
-    let target_targz_path = target_targz_path.as_ref().to_string_lossy().to_string();
-    let target_targz_path = crate::utils::normalize_path(&target_targz_path);
-    let target_targz_path = Path::new(&target_targz_path);
-
-    let target_path = target_path.as_ref().to_string_lossy().to_string();
-    let target_path = crate::utils::normalize_path(&target_path);
-    let target_path = Path::new(&target_path);
-
-    let open_file = || {
-        std::fs::File::open(target_targz_path)
-            .map_err(|e| anyhow::anyhow!("failed to open {}: {e}", target_targz_path.display()))
-    };
-
-    let try_decode_gz = || {
-        let file = open_file()?;
-        let gz_decoded = flate2::read::GzDecoder::new(&file);
-        let ar = tar::Archive::new(gz_decoded);
-        if strip_toplevel {
-            unpack_sans_parent(ar, target_path).map_err(|e| {
-                anyhow::anyhow!(
-                    "failed to unpack (gz_ar_unpack_sans_parent) {}: {e}",
-                    target_targz_path.display()
-                )
-            })
-        } else {
-            unpack_with_parent(ar, target_path).map_err(|e| {
-                anyhow::anyhow!(
-                    "failed to unpack (gz_ar_unpack) {}: {e}",
-                    target_targz_path.display()
-                )
-            })
-        }
-    };
-
-    let try_decode_xz = || {
-        let file = open_file()?;
-        let mut decomp: Vec<u8> = Vec::new();
-        let mut bufread = std::io::BufReader::new(&file);
-        lzma_rs::xz_decompress(&mut bufread, &mut decomp).map_err(|e| {
-            anyhow::anyhow!(
-                "failed to unpack (try_decode_xz) {}: {e}",
-                target_targz_path.display()
-            )
-        })?;
-
-        let cursor = std::io::Cursor::new(decomp);
-        let mut ar = tar::Archive::new(cursor);
-        if strip_toplevel {
-            unpack_sans_parent(ar, target_path).map_err(|e| {
-                anyhow::anyhow!(
-                    "failed to unpack (sans parent) {}: {e}",
-                    target_targz_path.display()
-                )
-            })
-        } else {
-            ar.unpack(target_path).map_err(|e| {
-                anyhow::anyhow!(
-                    "failed to unpack (with parent) {}: {e}",
-                    target_targz_path.display()
-                )
-            })
-        }
-    };
-
-    try_decode_gz().or_else(|e1| {
-        try_decode_xz()
-            .map_err(|e2| anyhow::anyhow!("could not decode gz: {e1}, could not decode xz: {e2}"))
-    })?;
-
-    Ok(Path::new(&target_targz_path).to_path_buf())
-}
-
-/// Whether the top-level directory should be stripped
-pub fn download_and_unpack_targz(
-    url: &str,
-    target_path: &Path,
-    strip_toplevel: bool,
-) -> Result<PathBuf, anyhow::Error> {
-    let tempdir = tempfile::TempDir::new()?;
-
-    let target_targz_path = tempdir.path().join("package.tar.gz");
-
-    let mut resp = reqwest::blocking::get(url)
-        .map_err(|e| anyhow::anyhow!("failed to download {url}: {e}"))?;
-
-    {
-        let mut file = std::fs::File::create(&target_targz_path).map_err(|e| {
-            anyhow::anyhow!(
-                "failed to download {url} into {}: {e}",
-                target_targz_path.display()
-            )
-        })?;
-
-        resp.copy_to(&mut file)
-            .map_err(|e| anyhow::anyhow!("{e}"))?;
-    }
-
-    try_unpack_targz(target_targz_path.as_path(), target_path, strip_toplevel)
-        .with_context(|| anyhow::anyhow!("Could not download {url}"))?;
-
-    Ok(target_path.to_path_buf())
-}
-
-pub fn unpack_with_parent<R>(mut archive: tar::Archive<R>, dst: &Path) -> Result<(), anyhow::Error>
-where
-    R: std::io::Read,
-{
-    use std::path::Component::Normal;
-
-    let dst_normalized = normalize_path(dst.to_string_lossy().as_ref());
-
-    for entry in archive.entries()? {
-        let mut entry = entry?;
-        let path: PathBuf = entry
-            .path()?
-            .components()
-            .skip(1) // strip top-level directory
-            .filter(|c| matches!(c, Normal(_))) // prevent traversal attacks
-            .collect();
-        if entry.header().entry_type().is_file() {
-            entry.unpack_in(&dst_normalized)?;
-        } else if entry.header().entry_type() == EntryType::Directory {
-            std::fs::create_dir_all(&Path::new(&dst_normalized).join(&path))?;
-        }
-    }
-    Ok(())
-}
-
-pub fn unpack_sans_parent<R>(mut archive: tar::Archive<R>, dst: &Path) -> std::io::Result<()>
-where
-    R: std::io::Read,
-{
-    use std::path::Component::Normal;
-
-    let dst_normalized = normalize_path(dst.to_string_lossy().as_ref());
-
-    for entry in archive.entries()? {
-        let mut entry = entry?;
-        let path: PathBuf = entry
-            .path()?
-            .components()
-            .skip(1) // strip top-level directory
-            .filter(|c| matches!(c, Normal(_))) // prevent traversal attacks
-            .collect();
-        entry.unpack(Path::new(&dst_normalized).join(path))?;
-    }
-    Ok(())
-}
-
-pub fn whoami(
-    wasmer_dir: &Path,
-    registry: Option<&str>,
-    token: Option<&str>,
-) -> Result<(String, String), anyhow::Error> {
-    use crate::graphql::queries::{who_am_i_query, WhoAmIQuery};
-
-    let config = WasmerConfig::from_file(wasmer_dir);
-
-    let config = config
-        .map_err(|e| anyhow::anyhow!("{e}"))
-        .with_context(|| format!("{registry:?}"))?;
-
-    let registry = match registry {
-        Some(s) => format_graphql(s),
-        None => config.registry.get_current_registry(),
-    };
-
-    let login_token = token
-        .map(|s| s.to_string())
-        .or_else(|| config.registry.get_login_token_for_registry(&registry))
-        .ok_or_else(|| anyhow::anyhow!("not logged into registry {:?}", registry))?;
-
-    let q = WhoAmIQuery::build_query(who_am_i_query::Variables {});
-    let response: who_am_i_query::ResponseData =
-        crate::graphql::execute_query(&registry, &login_token, &q)
-            .with_context(|| format!("{registry:?}"))?;
-
-    let username = response
-        .viewer
-        .as_ref()
-        .ok_or_else(|| anyhow::anyhow!("not logged into registry {:?}", registry))?
-        .username
-        .to_string();
-
-    Ok((registry, username))
-}
-
-pub fn test_if_registry_present(registry: &str) -> Result<bool, String> {
-    use crate::graphql::queries::{test_if_registry_present, TestIfRegistryPresent};
-
-    let q = TestIfRegistryPresent::build_query(test_if_registry_present::Variables {});
-    crate::graphql::execute_query_modifier_inner_check_json(
-        registry,
-        "",
-        &q,
-        Some(Duration::from_secs(1)),
-        |f| f,
-    )
-    .map_err(|e| format!("{e}"))?;
-
-    Ok(true)
-}
-
-pub fn get_all_available_registries(wasmer_dir: &Path) -> Result<Vec<String>, String> {
-    let config = WasmerConfig::from_file(wasmer_dir)?;
-    let mut registries = Vec::new();
-    for login in config.registry.tokens {
-        registries.push(format_graphql(&login.registry));
-    }
-    Ok(registries)
-}
-
-/// A library that exposes bindings to a Wasmer package.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Bindings {
-    /// A unique ID specifying this set of bindings.
-    pub id: String,
-    /// The URL which can be used to download the files that were generated
-    /// (typically as a `*.tar.gz` file).
-    pub url: String,
-    /// The programming language these bindings are written in.
-    pub language: ProgrammingLanguage,
-    /// The generator used to generate these bindings.
-    pub generator: BindingsGenerator,
-}
-
-/// The generator used to create [`Bindings`].
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct BindingsGenerator {
-    /// A unique ID specifying this generator.
-    pub id: String,
-    /// The generator package's name (e.g. `wasmer/wasmer-pack`).
-    pub package_name: String,
-    /// The exact package version.
-    pub version: String,
-    /// The name of the command that was used for generating bindings.
-    pub command: String,
-}
-
-impl fmt::Display for BindingsGenerator {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let BindingsGenerator {
-            package_name,
-            version,
-            command,
-            ..
-        } = self;
-
-        write!(f, "{package_name}@{version}:{command}")?;
-
-        Ok(())
-    }
-}
-
-/// List all bindings associated with a particular package.
-///
-/// If a version number isn't provided, this will default to the most recently
-/// published version.
-pub fn list_bindings(
-    registry: &str,
-    name: &str,
-    version: Option<&str>,
-) -> Result<Vec<Bindings>, anyhow::Error> {
-    use crate::graphql::queries::{
-        get_bindings_query::{ResponseData, Variables},
-        GetBindingsQuery,
-    };
-
-    let variables = Variables {
-        name: name.to_string(),
-        version: version.map(String::from),
-    };
-
-    let q = GetBindingsQuery::build_query(variables);
-    let response: ResponseData = crate::graphql::execute_query(registry, "", &q)?;
-
-    let package_version = response.package_version.context("Package not found")?;
-
-    let mut bindings_packages = Vec::new();
-
-    for b in package_version.bindings.into_iter().flatten() {
-        let pkg = Bindings {
-            id: b.id,
-            url: b.url,
-            language: b.language,
-            generator: BindingsGenerator {
-                id: b.generator.package_version.id,
-                package_name: b.generator.package_version.package.name,
-                version: b.generator.package_version.version,
-                command: b.generator.command_name,
-            },
-        };
-        bindings_packages.push(pkg);
-    }
-
-    Ok(bindings_packages)
-}
diff --git a/lib/registry/src/login.rs b/lib/registry/src/login.rs
deleted file mode 100644
index 9803f6f622..0000000000
--- a/lib/registry/src/login.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-use crate::config::{format_graphql, UpdateRegistry};
-use crate::WasmerConfig;
-use std::path::Path;
-
-/// Login to a registry and save the token associated with it.
-///
-/// Also sets the registry as the currently active registry to provide a better UX.
-pub fn login_and_save_token(
-    wasmer_dir: &Path,
-    registry: &str,
-    token: &str,
-) -> Result<Option<String>, anyhow::Error> {
-    let registry = format_graphql(registry);
-    let mut config = WasmerConfig::from_file(wasmer_dir)
-        .map_err(|e| anyhow::anyhow!("config from file: {e}"))?;
-    config.registry.set_current_registry(&registry);
-    config.registry.set_login_token_for_registry(
-        &config.registry.get_current_registry(),
-        token,
-        UpdateRegistry::Update,
-    );
-    let path = WasmerConfig::get_file_location(wasmer_dir);
-    config.save(path)?;
-    crate::utils::get_username_registry_token(&registry, token)
-}
diff --git a/lib/registry/src/package/builder.rs b/lib/registry/src/package/builder.rs
deleted file mode 100644
index 56c13eac0e..0000000000
--- a/lib/registry/src/package/builder.rs
+++ /dev/null
@@ -1,1095 +0,0 @@
-use std::io::{self, Write};
-use std::path::{Path, PathBuf};
-use std::time::Duration;
-use std::{fs, io::IsTerminal};
-
-use anyhow::{anyhow, bail, Context};
-use flate2::{write::GzEncoder, Compression};
-use rusqlite::{params, Connection, OpenFlags, TransactionBehavior};
-use tar::Builder;
-use thiserror::Error;
-use time::{self, OffsetDateTime};
-use wasmer_config::package::{PackageIdent, MANIFEST_FILE_NAME};
-
-use crate::publish::PublishWait;
-use crate::WasmerConfig;
-use crate::{package::builder::validate::ValidationPolicy, publish::SignArchiveResult};
-
-const MIGRATIONS: &[(i32, &str)] = &[
-    (0, include_str!("./sql/migrations/0000.sql")),
-    (1, include_str!("./sql/migrations/0001.sql")),
-    (2, include_str!("./sql/migrations/0002.sql")),
-];
-
-const CURRENT_DATA_VERSION: usize = MIGRATIONS.len();
-
-/// An abstraction for the action of publishing a named or unnamed package.
-#[derive(Debug)]
-pub struct Publish {
-    /// Registry to publish to
-    pub registry: Option<String>,
-    /// Run the publish logic without sending anything to the registry server
-    pub dry_run: bool,
-    /// Run the publish command without any output
-    pub quiet: bool,
-    /// Override the namespace of the package to upload
-    pub package_namespace: Option<String>,
-    /// Override the name of the package to upload
-    pub package_name: Option<String>,
-    /// Override the package version of the uploaded package in the wasmer.toml
-    pub version: Option<semver::Version>,
-    /// The auth token to use.
-    pub token: String,
-    /// Skip validation of the uploaded package
-    pub no_validate: bool,
-    /// Directory containing the `wasmer.toml` (defaults to current root dir)
-    pub package_path: Option<String>,
-    /// Wait for package to be available on the registry before exiting
-    pub wait: PublishWait,
-    /// Timeout (in seconds) for the publish query to the registry
-    pub timeout: Duration,
-}
-
-#[derive(Debug, Error)]
-enum PackageBuildError {
-    #[error("Unable to publish the \"{module}\" module because \"{}\" is not a file", path.display())]
-    SourceMustBeFile { module: String, path: PathBuf },
-    #[error("Unable to load the bindings for \"{module}\" because \"{}\" doesn't exist", path.display())]
-    MissingBindings { module: String, path: PathBuf },
-    #[error("Error building package when parsing module \"{0}\": {1}.")]
-    ErrorBuildingPackage(String, io::Error),
-    #[error(
-        "Path \"{0}\", specified in the manifest as part of the package file system does not exist.",
-    )]
-    MissingManifestFsPath(String),
-    #[error("When processing the package filesystem, found path \"{0}\" which is not a directory")]
-    PackageFileSystemEntryMustBeDirectory(String),
-}
-
-impl Publish {
-    /// Publish the package to the selected (or default) registry.
-    pub async fn execute(&self) -> Result<Option<PackageIdent>, anyhow::Error> {
-        let input_path = match self.package_path.as_ref() {
-            Some(s) => std::env::current_dir()?.join(s),
-            None => std::env::current_dir()?,
-        };
-
-        let manifest_path = match input_path.metadata() {
-            Ok(metadata) => {
-                if metadata.is_dir() {
-                    let p = input_path.join("wasmer.toml");
-                    if !p.is_file() {
-                        bail!(
-                            "directory does not contain a 'wasmer.toml' manifest - use 'wasmer init' to initialize a new packagae, or specify a valid package directory or manifest file instead. (path: {})",
-                            input_path.display()
-                        );
-                    }
-
-                    p
-                } else if metadata.is_file() {
-                    if input_path.extension().and_then(|x| x.to_str()) != Some("toml") {
-                        bail!(
-                            "The specified file path is not a .toml file: '{}'",
-                            input_path.display()
-                        );
-                    }
-                    input_path
-                } else {
-                    bail!("Invalid path specified: '{}'", input_path.display());
-                }
-            }
-            Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
-                bail!("Specified path does not exist: '{}'", input_path.display());
-            }
-            Err(err) => {
-                bail!("Could not read path '{}': {}", input_path.display(), err);
-            }
-        };
-
-        let manifest = std::fs::read_to_string(&manifest_path)
-            .map_err(|e| anyhow::anyhow!("could not find manifest: {e}"))
-            .with_context(|| anyhow::anyhow!("{}", manifest_path.display()))?;
-        let mut manifest = wasmer_config::package::Manifest::parse(&manifest)?;
-
-        let manifest_path_canon = manifest_path.canonicalize()?;
-        let manifest_dir = manifest_path_canon
-            .parent()
-            .context("could not determine manifest parent directory")?
-            .to_owned();
-
-        if let Some(package_name) = self.package_name.as_ref() {
-            if let Some(ref mut package) = manifest.package {
-                package.name = Some(package_name.clone());
-            }
-        }
-
-        if let Some(version) = self.version.as_ref() {
-            if let Some(ref mut package) = manifest.package {
-                package.version = Some(version.clone());
-            }
-        }
-
-        let archive_dir = tempfile::TempDir::new()?;
-        let archive_meta = construct_tar_gz(archive_dir.path(), &manifest, &manifest_path)?;
-
-        let registry = match self.registry.as_deref() {
-            Some(s) => crate::format_graphql(s),
-            None => {
-                let wasmer_dir = WasmerConfig::get_wasmer_dir()
-                    .map_err(|e| anyhow::anyhow!("no wasmer dir: {e}"))?;
-                let config = WasmerConfig::from_file(&wasmer_dir)
-                    .map_err(|e| anyhow::anyhow!("could not load config {e}"))?;
-                config.registry.get_current_registry()
-            }
-        };
-
-        let mut policy = self.validation_policy();
-
-        if !policy.skip_validation() {
-            validate::validate_directory(
-                &manifest,
-                &registry,
-                manifest_dir,
-                &mut *policy,
-                &self.token,
-            )?;
-        }
-
-        let archive_path = &archive_meta.archive_path;
-        let mut compressed_archive_reader = fs::File::open(archive_path)?;
-
-        let maybe_signature_data = sign_compressed_archive(&mut compressed_archive_reader)?;
-        let archived_data_size = archive_path.metadata()?.len();
-
-        assert!(archive_path.exists());
-        assert!(archive_path.is_file());
-
-        if self.dry_run {
-            // dry run: publish is done here
-            println!("🚀 Package published successfully!");
-
-            let path = archive_dir.into_path();
-            eprintln!("Archive persisted at: {}", path.display());
-
-            log::info!(
-                "Publish succeeded, but package was not published because it was run in dry-run mode"
-            );
-
-            return Ok(None);
-        }
-
-        crate::publish::try_chunked_uploading(
-            Some(registry),
-            Some(self.token.clone()),
-            &manifest.package,
-            &archive_meta.manifest_toml,
-            &archive_meta.license,
-            &archive_meta.readme,
-            &archive_meta
-                .archive_path
-                .file_name()
-                .unwrap()
-                .to_str()
-                .unwrap()
-                .to_string(),
-            archive_path,
-            &maybe_signature_data,
-            archived_data_size,
-            self.quiet,
-            self.wait,
-            self.timeout,
-            self.package_namespace.clone(),
-        )
-        .await
-    }
-
-    fn validation_policy(&self) -> Box<dyn ValidationPolicy> {
-        if self.no_validate {
-            Box::<validate::Skip>::default()
-        } else if std::io::stdin().is_terminal() {
-            Box::<validate::Interactive>::default()
-        } else {
-            Box::<validate::NonInteractive>::default()
-        }
-    }
-}
-
-struct ConstructedPackageArchive {
-    manifest_toml: String,
-    readme: Option<String>,
-    license: Option<String>,
-    archive_path: PathBuf,
-}
-
-fn construct_tar_gz(
-    archive_dir: &Path,
-    manifest: &wasmer_config::package::Manifest,
-    manifest_path: &Path,
-) -> Result<ConstructedPackageArchive, anyhow::Error> {
-    // This is an assert instead of returned error because this is a programmer error.
-    debug_assert!(manifest_path.is_file(), "manifest path is not a file");
-
-    let manifest_dir = manifest_path
-        .parent()
-        .context("manifest path has no parent directory")?;
-
-    let mut builder = Builder::new(Vec::new());
-    builder.append_path_with_name(
-        manifest_path,
-        manifest_path
-            .file_name()
-            .map(|s| s.to_str().unwrap_or_default())
-            .unwrap_or(MANIFEST_FILE_NAME),
-    )?;
-
-    let manifest_string = toml::to_string(&manifest)?;
-
-    let modules = &manifest.modules;
-
-    let readme = if let Some(ref package) = manifest.package {
-        match package.readme.as_ref() {
-            None => None,
-            Some(s) => {
-                let path =
-                    append_path_to_tar_gz(&mut builder, manifest_dir, s).map_err(|(p, e)| {
-                        PackageBuildError::ErrorBuildingPackage(format!("{}", p.display()), e)
-                    })?;
-                Some(std::fs::read_to_string(path)?)
-            }
-        }
-    } else {
-        None
-    };
-
-    let license = if let Some(ref package) = manifest.package {
-        match package.license_file.as_ref() {
-            None => None,
-            Some(s) => {
-                let path =
-                    append_path_to_tar_gz(&mut builder, manifest_dir, s).map_err(|(p, e)| {
-                        PackageBuildError::ErrorBuildingPackage(format!("{}", p.display()), e)
-                    })?;
-                Some(std::fs::read_to_string(path)?)
-            }
-        }
-    } else {
-        None
-    };
-
-    for module in modules {
-        append_path_to_tar_gz(&mut builder, manifest_dir, &module.source).map_err(
-            |(normalized_path, _)| PackageBuildError::SourceMustBeFile {
-                module: module.name.clone(),
-                path: normalized_path,
-            },
-        )?;
-
-        if let Some(bindings) = &module.bindings {
-            for path in bindings.referenced_files(manifest_dir)? {
-                let relative_path = path.strip_prefix(manifest_dir).with_context(|| {
-                    format!(
-                        "\"{}\" should be inside \"{}\"",
-                        path.display(),
-                        manifest_dir.display(),
-                    )
-                })?;
-
-                append_path_to_tar_gz(&mut builder, manifest_dir, relative_path).map_err(
-                    |(normalized_path, _)| PackageBuildError::MissingBindings {
-                        module: module.name.clone(),
-                        path: normalized_path,
-                    },
-                )?;
-            }
-        }
-    }
-
-    // bundle the package filesystem
-    for (_alias, path) in &manifest.fs {
-        let normalized_path = normalize_path(manifest_dir, path);
-        let path_metadata = normalized_path.metadata().map_err(|_| {
-            PackageBuildError::MissingManifestFsPath(normalized_path.to_string_lossy().to_string())
-        })?;
-        if path_metadata.is_dir() {
-            builder.append_dir_all(path, &normalized_path)
-        } else {
-            return Err(PackageBuildError::PackageFileSystemEntryMustBeDirectory(
-                path.to_string_lossy().to_string(),
-            )
-            .into());
-        }
-        .map_err(|_| {
-            PackageBuildError::MissingManifestFsPath(normalized_path.to_string_lossy().to_string())
-        })?;
-    }
-
-    builder
-        .finish()
-        .map_err(|e| anyhow::anyhow!("failed to finish .tar.gz builder: {e}"))?;
-    let tar_archive_data = builder.into_inner().expect("tar archive was not finalized");
-    let archive_name = "package.tar.gz".to_string();
-    fs::create_dir(archive_dir.join("wapm_package"))?;
-    let archive_path = archive_dir.join("wapm_package").join(archive_name);
-    let mut compressed_archive = fs::File::create(&archive_path).unwrap();
-    let mut gz_enc = GzEncoder::new(&mut compressed_archive, Compression::best());
-
-    gz_enc.write_all(&tar_archive_data).unwrap();
-    let _compressed_archive = gz_enc.finish().unwrap();
-
-    Ok(ConstructedPackageArchive {
-        manifest_toml: manifest_string,
-        archive_path,
-        readme,
-        license,
-    })
-}
-
-fn append_path_to_tar_gz(
-    builder: &mut tar::Builder<Vec<u8>>,
-    base_path: &Path,
-    target_path: &Path,
-) -> Result<PathBuf, (PathBuf, io::Error)> {
-    let normalized_path = normalize_path(base_path, target_path);
-    normalized_path
-        .metadata()
-        .map_err(|e| (normalized_path.clone(), e))?;
-    builder
-        .append_path_with_name(&normalized_path, target_path)
-        .map_err(|e| (normalized_path.clone(), e))?;
-    Ok(normalized_path)
-}
-
-fn normalize_path(cwd: &Path, path: &Path) -> PathBuf {
-    let mut out = PathBuf::from(cwd);
-    let mut components = path.components();
-    if path.is_absolute() {
-        log::warn!(
-            "Interpreting absolute path {} as a relative path",
-            path.to_string_lossy()
-        );
-        components.next();
-    }
-    for comp in components {
-        out.push(comp);
-    }
-    out
-}
-
-/// Takes the package archive as a File and attempts to sign it using the active key
-/// returns the public key id used to sign it and the signature string itself
-pub fn sign_compressed_archive(
-    compressed_archive: &mut fs::File,
-) -> anyhow::Result<SignArchiveResult> {
-    let key_db = open_db()?;
-    let personal_key = if let Ok(v) = get_active_personal_key(&key_db) {
-        v
-    } else {
-        return Ok(SignArchiveResult::NoKeyRegistered);
-    };
-    let password = rpassword::prompt_password(format!(
-        "Please enter your password for the key pair {}:",
-        &personal_key.public_key_id
-    ))
-    .ok();
-    let private_key = if let Some(priv_key_location) = personal_key.private_key_location {
-        match minisign::SecretKey::from_file(&priv_key_location, password) {
-            Ok(priv_key_data) => priv_key_data,
-            Err(e) => {
-                log::error!(
-                    "Could not read private key from location {}: {}",
-                    priv_key_location,
-                    e
-                );
-                return Err(e.into());
-            }
-        }
-    } else {
-        // TODO: add more info about why this might have happened and what the user can do about it
-        log::warn!("Active key does not have a private key location registered with it!");
-        return Err(anyhow!("Cannot sign package, no private key"));
-    };
-    let public_key = minisign::PublicKey::from_base64(&personal_key.public_key_value)?;
-    let signature = minisign::sign(
-        Some(&public_key),
-        &private_key,
-        compressed_archive,
-        None,
-        None,
-    )?;
-    Ok(SignArchiveResult::Ok {
-        public_key_id: personal_key.public_key_id,
-        signature: signature.to_string(),
-    })
-}
-
-/// Opens an exclusive read/write connection to the database, creating it if it does not exist
-pub fn open_db() -> anyhow::Result<Connection> {
-    let wasmer_dir =
-        WasmerConfig::get_wasmer_dir().map_err(|e| anyhow::anyhow!("no wasmer dir: {e}"))?;
-    let db_path = WasmerConfig::get_database_file_path(&wasmer_dir);
-    let mut conn = Connection::open_with_flags(
-        db_path,
-        OpenFlags::SQLITE_OPEN_CREATE
-            | OpenFlags::SQLITE_OPEN_READ_WRITE
-            | OpenFlags::SQLITE_OPEN_FULL_MUTEX,
-    )?;
-
-    apply_migrations(&mut conn)?;
-    Ok(conn)
-}
-
-/// Applies migrations to the database
-pub fn apply_migrations(conn: &mut Connection) -> anyhow::Result<()> {
-    let user_version = conn.pragma_query_value(None, "user_version", |val| val.get(0))?;
-    for data_version in user_version..CURRENT_DATA_VERSION {
-        log::debug!("Applying migration {}", data_version);
-        apply_migration(conn, data_version as i32)?;
-    }
-    Ok(())
-}
-
-#[derive(Debug, Error)]
-enum MigrationError {
-    #[error(
-        "Critical internal error: the data version {0} is not handleded; current data version: {1}"
-    )]
-    MigrationNumberDoesNotExist(i32, i32),
-    #[error("Critical internal error: failed to commit trasaction migrating to data version {0}")]
-    CommitFailed(i32),
-    #[error("Critical internal error: transaction failed on migration number {0}: {1}")]
-    TransactionFailed(i32, String),
-}
-
-/// Applies migrations to the database and updates the `user_version` pragma.
-/// Every migration must leave the database in a valid state.
-fn apply_migration(conn: &mut Connection, migration_number: i32) -> Result<(), MigrationError> {
-    let tx = conn
-        .transaction_with_behavior(TransactionBehavior::Immediate)
-        .map_err(|e| MigrationError::TransactionFailed(migration_number, format!("{}", e)))?;
-
-    let migration_to_apply = MIGRATIONS
-        .iter()
-        .find_map(|(number, sql)| {
-            if *number == migration_number {
-                Some(sql)
-            } else {
-                None
-            }
-        })
-        .ok_or({
-            MigrationError::MigrationNumberDoesNotExist(
-                migration_number,
-                CURRENT_DATA_VERSION as i32,
-            )
-        })?;
-
-    tx.execute_batch(migration_to_apply)
-        .map_err(|e| MigrationError::TransactionFailed(migration_number, format!("{}", e)))?;
-
-    tx.pragma_update(None, "user_version", migration_number + 1)
-        .map_err(|e| MigrationError::TransactionFailed(migration_number, format!("{}", e)))?;
-    tx.commit()
-        .map_err(|_| MigrationError::CommitFailed(migration_number))
-}
-
-/// Information about one of the user's keys
-#[derive(Debug)]
-pub struct PersonalKey {
-    /// Flag saying if the key will be used (there can only be one active key at a time)
-    pub active: bool,
-    /// The public key's tag. Used to identify the key pair
-    pub public_key_id: String,
-    /// The raw value of the public key in base64
-    pub public_key_value: String,
-    /// The location in the file system of the private key
-    pub private_key_location: Option<String>,
-    /// The type of private/public key this is
-    pub key_type_identifier: String,
-    /// The time at which the key was registered with wasmer
-    pub date_created: OffsetDateTime,
-}
-
-fn get_active_personal_key(conn: &Connection) -> anyhow::Result<PersonalKey> {
-    let mut stmt = conn.prepare(
-        "SELECT active, public_key_value, private_key_location, date_added, key_type_identifier, public_key_id FROM personal_keys
-         where active = 1",
-    )?;
-
-    let result = stmt
-        .query_map(params![], |row| {
-            Ok(PersonalKey {
-                active: row.get(0)?,
-                public_key_value: row.get(1)?,
-                private_key_location: row.get(2)?,
-                date_created: {
-                    use time::format_description::well_known::Rfc3339;
-                    let time_str: String = row.get(3)?;
-                    OffsetDateTime::parse(&time_str, &Rfc3339)
-                        .unwrap_or_else(|_| panic!("Failed to parse time string {}", &time_str))
-                },
-                key_type_identifier: row.get(4)?,
-                public_key_id: row.get(5)?,
-            })
-        })?
-        .next();
-
-    if let Some(res) = result {
-        Ok(res?)
-    } else {
-        Err(anyhow!("No active key found"))
-    }
-}
-
-mod interfaces {
-    use anyhow::anyhow;
-    use rusqlite::{params, Connection, TransactionBehavior};
-
-    pub const WASM_INTERFACE_EXISTENCE_CHECK: &str =
-        include_str!("./sql/queries/wasm_interface_existence_check.sql");
-    pub const INSERT_WASM_INTERFACE: &str = include_str!("./sql/queries/insert_interface.sql");
-    pub const GET_WASM_INTERFACE: &str = include_str!("./sql/queries/get_interface.sql");
-
-    pub fn interface_exists(
-        conn: &mut Connection,
-        interface_name: &str,
-        version: &str,
-    ) -> anyhow::Result<bool> {
-        let mut stmt = conn.prepare(WASM_INTERFACE_EXISTENCE_CHECK)?;
-        Ok(stmt.exists(params![interface_name, version])?)
-    }
-
-    pub fn load_interface_from_db(
-        conn: &mut Connection,
-        interface_name: &str,
-        version: &str,
-    ) -> anyhow::Result<wasmer_wasm_interface::Interface> {
-        let mut stmt = conn.prepare(GET_WASM_INTERFACE)?;
-        let interface_string: String =
-            stmt.query_row(params![interface_name, version], |row| row.get(0))?;
-
-        wasmer_wasm_interface::parser::parse_interface(&interface_string).map_err(|e| {
-            anyhow!(
-                "Failed to parse interface {} version {} in database: {}",
-                interface_name,
-                version,
-                e
-            )
-        })
-    }
-
-    pub fn import_interface(
-        conn: &mut Connection,
-        interface_name: &str,
-        version: &str,
-        content: &str,
-    ) -> anyhow::Result<()> {
-        // fail if we already have this interface
-        {
-            let mut key_check = conn.prepare(WASM_INTERFACE_EXISTENCE_CHECK)?;
-            let result = key_check.exists(params![interface_name, version])?;
-
-            if result {
-                return Err(anyhow!(
-                    "Interface {}, version {} already exists",
-                    interface_name,
-                    version
-                ));
-            }
-        }
-
-        let tx = conn.transaction_with_behavior(TransactionBehavior::Immediate)?;
-        let time_string = get_current_time_in_format().expect("Could not get current time");
-
-        log::debug!("Adding interface {:?} {:?}", interface_name, version);
-        tx.execute(
-            INSERT_WASM_INTERFACE,
-            params![interface_name, version, time_string, content],
-        )?;
-
-        tx.commit()?;
-        Ok(())
-    }
-
-    /// Gets the current time in our standard format
-    pub fn get_current_time_in_format() -> Option<String> {
-        use time::format_description::well_known::Rfc3339;
-        let cur_time = time::OffsetDateTime::now_utc();
-        cur_time.format(&Rfc3339).ok()
-    }
-}
-
-mod validate {
-    use anyhow::anyhow;
-    use thiserror::Error;
-    use wasmer_wasm_interface::{validate, Interface};
-
-    use super::interfaces;
-    use crate::{interface::InterfaceFromServer, QueryPackageError};
-    use std::{
-        fs,
-        io::Read,
-        ops::ControlFlow,
-        path::{Path, PathBuf},
-    };
-
-    pub(crate) fn validate_directory(
-        manifest: &wasmer_config::package::Manifest,
-        registry: &str,
-        pkg_path: PathBuf,
-        callbacks: &mut dyn ValidationPolicy,
-        auth_token: &str,
-    ) -> anyhow::Result<()> {
-        // validate as dir
-        for module in manifest.modules.iter() {
-            if let Err(e) = validate_module(module, registry, &pkg_path) {
-                if callbacks.on_invalid_module(module, &e).is_break() {
-                    return Err(e.into());
-                }
-            }
-        }
-
-        if would_change_package_privacy(manifest, registry, auth_token)?
-            && callbacks.on_package_privacy_changed(manifest).is_break()
-        {
-            if let Some(package) = &manifest.package {
-                if package.private {
-                    return Err(ValidationError::WouldBecomePrivate.into());
-                } else {
-                    return Err(ValidationError::WouldBecomePublic.into());
-                }
-            }
-        }
-
-        log::debug!("package at path {:#?} validated", &pkg_path);
-
-        Ok(())
-    }
-
-    /// Check if publishing this manifest would change the package's privacy.
-    fn would_change_package_privacy(
-        manifest: &wasmer_config::package::Manifest,
-        registry: &str,
-        auth_token: &str,
-    ) -> Result<bool, ValidationError> {
-        match &manifest.package {
-            Some(pkg) => {
-                if let Some(ref name) = pkg.name {
-                    let result =
-                        crate::query_package_from_registry(registry, name, None, Some(auth_token));
-
-                    match result {
-                        Ok(package_version) => Ok(package_version.is_private != pkg.private),
-                        Err(QueryPackageError::NoPackageFound { .. }) => {
-                            // The package hasn't been published yet
-                            Ok(false)
-                        }
-                        Err(e) => Err(e.into()),
-                    }
-                } else {
-                    Ok(false)
-                }
-            }
-
-            // This manifest refers to an unnamed package:
-            // as of now, unnamed packages are private by default.
-            None => Ok(false),
-        }
-    }
-
-    fn validate_module(
-        module: &wasmer_config::package::Module,
-        registry: &str,
-        pkg_path: &Path,
-    ) -> Result<(), ValidationError> {
-        let source_path = if module.source.is_relative() {
-            pkg_path.join(&module.source)
-        } else {
-            module.source.clone()
-        };
-        let source_path_string = source_path.to_string_lossy().to_string();
-        let mut wasm_file =
-            fs::File::open(&source_path).map_err(|_| ValidationError::MissingFile {
-                file: source_path_string.clone(),
-            })?;
-        let mut wasm_buffer = Vec::new();
-        wasm_file
-            .read_to_end(&mut wasm_buffer)
-            .map_err(|err| ValidationError::MiscCannotRead {
-                file: source_path_string.clone(),
-                error: format!("{}", err),
-            })?;
-
-        if let Some(bindings) = &module.bindings {
-            validate_bindings(bindings, pkg_path)?;
-        }
-
-        // hack, short circuit if no interface for now
-        if module.interfaces.is_none() {
-            return validate_wasm_and_report_errors_old(&wasm_buffer[..], source_path_string);
-        }
-
-        let mut conn = super::open_db().map_err(ValidationError::UpdatingInterfaces)?;
-        let mut interface: Interface = Default::default();
-        for (interface_name, interface_version) in
-            module.interfaces.clone().unwrap_or_default().into_iter()
-        {
-            add_module_interface(
-                &mut conn,
-                interface_name,
-                interface_version,
-                registry,
-                &mut interface,
-            )
-            .map_err(ValidationError::UpdatingInterfaces)?;
-        }
-        validate::validate_wasm_and_report_errors(&wasm_buffer, &interface).map_err(|e| {
-            ValidationError::InvalidWasm {
-                file: source_path_string,
-                error: format!("{:?}", e),
-            }
-        })?;
-
-        Ok(())
-    }
-
-    fn add_module_interface(
-        conn: &mut rusqlite::Connection,
-        interface_name: String,
-        interface_version: String,
-        registry: &str,
-        interface: &mut Interface,
-    ) -> anyhow::Result<()> {
-        if !interfaces::interface_exists(conn, &interface_name, &interface_version)? {
-            // download interface and store it if we don't have it locally
-            let interface_data_from_server = InterfaceFromServer::get(
-                registry,
-                interface_name.clone(),
-                interface_version.clone(),
-            )?;
-            interfaces::import_interface(
-                conn,
-                &interface_name,
-                &interface_version,
-                &interface_data_from_server.content,
-            )?;
-        }
-        let sub_interface =
-            interfaces::load_interface_from_db(conn, &interface_name, &interface_version)?;
-        *interface = interface
-            .merge(sub_interface)
-            .map_err(|e| anyhow!("Failed to merge interface {}: {}", &interface_name, e))?;
-        Ok(())
-    }
-
-    fn validate_bindings(
-        bindings: &wasmer_config::package::Bindings,
-        base_directory_path: &Path,
-    ) -> Result<(), ValidationError> {
-        // Note: checking for referenced files will make sure they all exist.
-        let _ = bindings.referenced_files(base_directory_path)?;
-
-        Ok(())
-    }
-
-    #[derive(Debug, Error)]
-    #[non_exhaustive]
-    pub enum ValidationError {
-        #[error("WASM file \"{file}\" detected as invalid because {error}")]
-        InvalidWasm { file: String, error: String },
-        #[error("Could not find file {file}")]
-        MissingFile { file: String },
-        #[error("Failed to read file {file}; {error}")]
-        MiscCannotRead { file: String, error: String },
-        #[error(transparent)]
-        Imports(#[from] wasmer_config::package::ImportsError),
-        #[error("Unable to update the interfaces database")]
-        UpdatingInterfaces(#[source] anyhow::Error),
-        #[error("Aborting because publishing the package would make it public")]
-        WouldBecomePublic,
-        #[error("Aborting because publishing the package would make it private")]
-        WouldBecomePrivate,
-        #[error("Unable to look up package information")]
-        Registry(#[from] QueryPackageError),
-    }
-
-    // legacy function, validates wasm.  TODO: clean up
-    pub fn validate_wasm_and_report_errors_old(
-        wasm: &[u8],
-        file_name: String,
-    ) -> Result<(), ValidationError> {
-        let mut val = wasmparser::Validator::new_with_features(wasmparser::WasmFeatures {
-            threads: true,
-            reference_types: true,
-            simd: true,
-            bulk_memory: true,
-            multi_value: true,
-            ..Default::default()
-        });
-
-        val.validate_all(wasm)
-            .map_err(|e| ValidationError::InvalidWasm {
-                file: file_name.clone(),
-                error: format!("{}", e),
-            })?;
-
-        Ok(())
-    }
-
-    /// How should validation be treated by the publishing process?
-    pub(crate) trait ValidationPolicy: Send + Sync {
-        /// Should validation be skipped entirely?
-        fn skip_validation(&mut self) -> bool;
-
-        /// How should publishing proceed when a module is invalid?
-        fn on_invalid_module(
-            &mut self,
-            module: &wasmer_config::package::Module,
-            error: &ValidationError,
-        ) -> ControlFlow<(), ()>;
-
-        /// How should publishing proceed when it might change a package's
-        /// privacy? (i.e. by making a private package publicly available).
-        fn on_package_privacy_changed(
-            &mut self,
-            manifest: &wasmer_config::package::Manifest,
-        ) -> ControlFlow<(), ()>;
-    }
-
-    #[derive(Debug, Default, Copy, Clone, PartialEq)]
-    pub(crate) struct Skip;
-
-    impl ValidationPolicy for Skip {
-        fn skip_validation(&mut self) -> bool {
-            true
-        }
-
-        fn on_invalid_module(
-            &mut self,
-            _module: &wasmer_config::package::Module,
-            _error: &ValidationError,
-        ) -> ControlFlow<(), ()> {
-            unreachable!()
-        }
-
-        fn on_package_privacy_changed(
-            &mut self,
-            _manifest: &wasmer_config::package::Manifest,
-        ) -> ControlFlow<(), ()> {
-            unreachable!()
-        }
-    }
-
-    #[derive(Debug, Default, Copy, Clone, PartialEq)]
-    pub(crate) struct Interactive;
-
-    impl ValidationPolicy for Interactive {
-        fn skip_validation(&mut self) -> bool {
-            false
-        }
-
-        fn on_invalid_module(
-            &mut self,
-            module: &wasmer_config::package::Module,
-            error: &ValidationError,
-        ) -> ControlFlow<(), ()> {
-            let module_name = &module.name;
-            let prompt =
-                format!("Validation error with the \"{module_name}\" module: {error}. Would you like to continue?");
-
-            match dialoguer::Confirm::new()
-                .with_prompt(prompt)
-                .default(false)
-                .interact()
-            {
-                Ok(true) => ControlFlow::Continue(()),
-                Ok(false) => ControlFlow::Break(()),
-                Err(e) => {
-                    tracing::error!(
-                        error = &e as &dyn std::error::Error,
-                        "Unable to check whether the user wants to change the package's privacy",
-                    );
-                    ControlFlow::Break(())
-                }
-            }
-        }
-
-        fn on_package_privacy_changed(
-            &mut self,
-            manifest: &wasmer_config::package::Manifest,
-        ) -> ControlFlow<(), ()> {
-            if let Some(pkg) = &manifest.package {
-                let privacy = if pkg.private { "private" } else { "public" };
-                let prompt =
-                    format!("This will make the package {privacy}. Would you like to continue?");
-
-                match dialoguer::Confirm::new()
-                    .with_prompt(prompt)
-                    .default(false)
-                    .interact()
-                {
-                    Ok(true) => ControlFlow::Continue(()),
-                    Ok(false) => ControlFlow::Break(()),
-                    Err(e) => {
-                        tracing::error!(
-                        error = &e as &dyn std::error::Error,
-                        "Unable to check whether the user wants to change the package's privacy",
-                    );
-                        ControlFlow::Break(())
-                    }
-                }
-            } else {
-                ControlFlow::Continue(())
-            }
-        }
-    }
-
-    #[derive(Debug, Default, Copy, Clone, PartialEq)]
-    pub(crate) struct NonInteractive;
-
-    impl ValidationPolicy for NonInteractive {
-        fn skip_validation(&mut self) -> bool {
-            false
-        }
-
-        fn on_invalid_module(
-            &mut self,
-            _module: &wasmer_config::package::Module,
-            _error: &ValidationError,
-        ) -> ControlFlow<(), ()> {
-            ControlFlow::Break(())
-        }
-
-        fn on_package_privacy_changed(
-            &mut self,
-            _manifest: &wasmer_config::package::Manifest,
-        ) -> ControlFlow<(), ()> {
-            ControlFlow::Break(())
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::io::Read;
-
-    use super::*;
-
-    #[test]
-    fn test_construct_package_tar_gz() {
-        let manifest_str = r#"[package]
-name = "wasmer-tests/wcgi-always-panic"
-version = "0.6.0"
-description = "wasmer-tests/wcgi-always-panic website"
-
-[[module]]
-name = "wcgi-always-panic"
-source = "module.wasm"
-abi = "wasi"
-
-[[command]]
-name = "wcgi"
-module = "wcgi-always-panic"
-runner = "https://webc.org/runner/wcgi"
-"#;
-
-        let archive_dir = tempfile::tempdir().unwrap();
-
-        let manifest_dir = tempfile::tempdir().unwrap();
-
-        let mp = manifest_dir.path();
-        let manifest_path = mp.join("wasmer.toml");
-
-        std::fs::write(&manifest_path, manifest_str).unwrap();
-        std::fs::write(mp.join("module.wasm"), "()").unwrap();
-
-        let manifest = wasmer_config::package::Manifest::parse(manifest_str).unwrap();
-
-        let meta = construct_tar_gz(archive_dir.path(), &manifest, &manifest_path).unwrap();
-
-        let mut data = std::io::Cursor::new(std::fs::read(meta.archive_path).unwrap());
-
-        let gz = flate2::read::GzDecoder::new(&mut data);
-        let mut archive = tar::Archive::new(gz);
-
-        let map = archive
-            .entries()
-            .unwrap()
-            .map(|res| {
-                let mut entry = res.unwrap();
-                let name = entry.path().unwrap().to_str().unwrap().to_string();
-                let mut contents = String::new();
-                entry.read_to_string(&mut contents).unwrap();
-                eprintln!("{name}:\n{contents}\n\n");
-                (name, contents)
-            })
-            .collect::<std::collections::HashMap<String, String>>();
-
-        let expected: std::collections::HashMap<String, String> = [
-            ("wapm.toml".to_string(), manifest_str.to_string()),
-            ("module.wasm".to_string(), "()".to_string()),
-        ]
-        .into_iter()
-        .collect();
-
-        pretty_assertions::assert_eq!(map, expected);
-    }
-
-    #[test]
-    fn test_construct_wai_package_tar_gz() {
-        let manifest_str = r#"[package]
-name = "wasmer/crumsort-wasm"
-version = "0.2.4"
-description = "Crumsort from Google made for WASM"
-
-[[module]]
-name = "crumsort-wasm"
-source = "crumsort_wasm.wasm"
-
-[module.bindings]
-wai-version = "0.2.0"
-exports = "crum-sort.wai"
-"#;
-
-        let archive_dir = tempfile::tempdir().unwrap();
-
-        let manifest_dir = tempfile::tempdir().unwrap();
-
-        let mp = manifest_dir.path();
-        let manifest_path = mp.join("wasmer.toml");
-
-        std::fs::write(&manifest_path, manifest_str).unwrap();
-        std::fs::write(mp.join("crumsort_wasm.wasm"), "()").unwrap();
-        std::fs::write(mp.join("crum-sort.wai"), "/// crum-sort.wai").unwrap();
-
-        let manifest = wasmer_config::package::Manifest::parse(manifest_str).unwrap();
-        let meta = construct_tar_gz(archive_dir.path(), &manifest, &manifest_path).unwrap();
-
-        let mut data = std::io::Cursor::new(std::fs::read(meta.archive_path).unwrap());
-
-        let gz = flate2::read::GzDecoder::new(&mut data);
-        let mut archive = tar::Archive::new(gz);
-
-        let map = archive
-            .entries()
-            .unwrap()
-            .map(|res| {
-                let mut entry = res.unwrap();
-                let name = entry.path().unwrap().to_str().unwrap().to_string();
-                let mut contents = String::new();
-                entry.read_to_string(&mut contents).unwrap();
-                eprintln!("{name}:\n{contents}\n\n");
-                (name, contents)
-            })
-            .collect::<std::collections::HashMap<String, String>>();
-
-        let expected: std::collections::HashMap<String, String> = [
-            ("wapm.toml".to_string(), manifest_str.to_string()),
-            ("crum-sort.wai".to_string(), "/// crum-sort.wai".to_string()),
-            ("crumsort_wasm.wasm".to_string(), "()".to_string()),
-        ]
-        .into_iter()
-        .collect();
-
-        pretty_assertions::assert_eq!(map, expected);
-    }
-}
diff --git a/lib/registry/src/package/mod.rs b/lib/registry/src/package/mod.rs
deleted file mode 100644
index 7296c0f4b9..0000000000
--- a/lib/registry/src/package/mod.rs
+++ /dev/null
@@ -1,190 +0,0 @@
-#[cfg(feature = "build-package")]
-pub mod builder;
-
-use crate::WasmerConfig;
-use regex::Regex;
-use std::path::{Path, PathBuf};
-use std::{fmt, str::FromStr};
-use url::Url;
-
-const REGEX_PACKAGE_WITH_VERSION: &str =
-    r"^([a-zA-Z0-9\-_]+)/([a-zA-Z0-9\-_]+)(@([a-zA-Z0-9\.\-_]+*))?$";
-
-lazy_static::lazy_static! {
-    static ref PACKAGE_WITH_VERSION: Regex = regex::Regex::new(REGEX_PACKAGE_WITH_VERSION).unwrap();
-}
-
-#[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Package {
-    pub namespace: String,
-    pub name: String,
-    pub version: Option<String>,
-}
-
-impl fmt::Display for Package {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.file())
-    }
-}
-
-impl Package {
-    /// Checks whether the package is already installed, if yes, returns the path to the root dir
-    pub fn already_installed(&self, wasmer_dir: &Path) -> Option<PathBuf> {
-        let checkouts_dir = crate::get_checkouts_dir(wasmer_dir);
-        let config = WasmerConfig::from_file(wasmer_dir).ok()?;
-        let current_registry = config.registry.get_current_registry();
-        let hash = self.get_hash(&current_registry);
-
-        let found = std::fs::read_dir(&checkouts_dir)
-            .ok()?
-            .filter_map(|e| Some(e.ok()?.file_name().to_str()?.to_string()))
-            .find(|s| match self.version.as_ref() {
-                None => s.contains(&hash),
-                Some(v) => s.contains(&hash) && s.ends_with(v),
-            })?;
-        Some(checkouts_dir.join(found))
-    }
-
-    /// Checks if the URL is already installed, note that `{url}@{version}`
-    /// and `{url}` are treated the same
-    pub fn is_url_already_installed(url: &Url, wasmer_dir: &Path) -> Option<PathBuf> {
-        let checkouts_dir = crate::get_checkouts_dir(wasmer_dir);
-
-        let url_string = url.to_string();
-        let (url, version) = match url_string.split('@').collect::<Vec<_>>()[..] {
-            [url, version] => (url.to_string(), Some(version)),
-            _ => (url_string, None),
-        };
-        let hash = Self::hash_url(&url);
-        let found = std::fs::read_dir(&checkouts_dir)
-            .ok()?
-            .filter_map(|e| Some(e.ok()?.file_name().to_str()?.to_string()))
-            .find(|s| match version.as_ref() {
-                None => s.contains(&hash),
-                Some(v) => s.contains(&hash) && s.ends_with(v),
-            })?;
-        Some(checkouts_dir.join(found))
-    }
-
-    /// Returns the hash of the URL with a maximum of 128 bytes length
-    /// (necessary for not erroring on filesystem limitations)
-    pub fn hash_url(url: &str) -> String {
-        hex::encode(url).chars().take(128).collect()
-    }
-
-    /// Returns the hash of the URL with a maximum of 64 bytes length
-    pub fn unhash_url(hashed: &str) -> String {
-        String::from_utf8_lossy(&hex::decode(hashed).unwrap_or_default()).to_string()
-    }
-
-    /// Returns the hash of the package URL without the version
-    /// (because the version is encoded as @version and isn't part of the hash itself)
-    pub fn get_hash(&self, registry: &str) -> String {
-        let url = self.get_url_without_version(registry);
-        Self::hash_url(&url.unwrap_or_default())
-    }
-
-    fn get_url_without_version(&self, registry: &str) -> Result<String, anyhow::Error> {
-        let url = self.url(registry);
-        Ok(format!(
-            "{}/{}/{}",
-            url?.origin().ascii_serialization(),
-            self.namespace,
-            self.name
-        ))
-    }
-
-    /// Returns the filename for this package
-    pub fn file(&self) -> String {
-        let version = self
-            .version
-            .as_ref()
-            .map(|f| format!("@{f}"))
-            .unwrap_or_default();
-        format!("{}/{}{version}", self.namespace, self.name)
-    }
-
-    /// Returns the {namespace}/{name} package name
-    pub fn package(&self) -> String {
-        format!("{}/{}", self.namespace, self.name)
-    }
-
-    /// Returns the full URL including the version for this package
-    pub fn url(&self, registry: &str) -> Result<Url, anyhow::Error> {
-        let registry_tld = tldextract::TldExtractor::new(tldextract::TldOption::default())
-            .extract(registry)
-            .map_err(|e| anyhow::anyhow!("Invalid registry: {}: {e}", registry))?;
-
-        let registry_tld = format!(
-            "{}.{}",
-            registry_tld.domain.as_deref().unwrap_or(""),
-            registry_tld.suffix.as_deref().unwrap_or(""),
-        );
-
-        let version = self
-            .version
-            .as_ref()
-            .map(|f| format!("@{f}"))
-            .unwrap_or_default();
-        let url = format!(
-            "https://{registry_tld}/{}/{}{version}",
-            self.namespace, self.name
-        );
-        url::Url::parse(&url).map_err(|e| anyhow::anyhow!("error parsing {url}: {e}"))
-    }
-
-    /// Returns the path to the installation directory.
-    /// Does not check whether the installation directory already exists.
-    pub fn get_path(&self, wasmer_dir: &Path) -> Result<PathBuf, anyhow::Error> {
-        let checkouts_dir = crate::get_checkouts_dir(wasmer_dir);
-        let config = WasmerConfig::from_file(wasmer_dir)
-            .map_err(|e| anyhow::anyhow!("could not load config {e}"))?;
-        let hash = self.get_hash(&config.registry.get_current_registry());
-
-        match self.version.as_ref() {
-            Some(v) => Ok(checkouts_dir.join(format!("{}@{}", hash, v))),
-            None => Ok(checkouts_dir.join(&hash)),
-        }
-    }
-}
-
-impl FromStr for Package {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let captures = PACKAGE_WITH_VERSION
-            .captures(s.trim())
-            .map(|c| {
-                c.iter()
-                    .flatten()
-                    .map(|m| m.as_str().to_owned())
-                    .collect::<Vec<_>>()
-            })
-            .unwrap_or_default();
-
-        match captures.len() {
-            // namespace/package
-            3 => {
-                let namespace = captures[1].to_string();
-                let name = captures[2].to_string();
-                Ok(Package {
-                    namespace,
-                    name,
-                    version: None,
-                })
-            }
-            // namespace/package@version
-            5 => {
-                let namespace = captures[1].to_string();
-                let name = captures[2].to_string();
-                let version = captures[4].to_string();
-                Ok(Package {
-                    namespace,
-                    name,
-                    version: Some(version),
-                })
-            }
-            other => Err(anyhow::anyhow!("invalid package {other}")),
-        }
-    }
-}
diff --git a/lib/registry/src/package/sql/migrations/0000.sql b/lib/registry/src/package/sql/migrations/0000.sql
deleted file mode 100644
index a527dbc4f2..0000000000
--- a/lib/registry/src/package/sql/migrations/0000.sql
+++ /dev/null
@@ -1,27 +0,0 @@
-CREATE TABLE personal_keys
-(
-  id integer primary key,
-  active integer not null,
-  public_key_id text not null UNIQUE,
-  public_key_value text not null UNIQUE,
-  private_key_location text UNIQUE,
-  key_type_identifier text not null,
-  date_added text not null
-);
-
-CREATE TABLE wapm_users
-(
-  id integer primary key,
-  name text not null UNIQUE
-);
-
-CREATE TABLE wapm_public_keys
-(
-  id integer primary key,
-  public_key_id text not null UNIQUE,
-  user_key integer not null,
-  public_key_value text not null UNIQUE,
-  key_type_identifier text not null,
-  date_added text not null,
-  FOREIGN KEY(user_key) REFERENCES wapm_users(id)
-);
diff --git a/lib/registry/src/package/sql/migrations/0001.sql b/lib/registry/src/package/sql/migrations/0001.sql
deleted file mode 100644
index 4258731915..0000000000
--- a/lib/registry/src/package/sql/migrations/0001.sql
+++ /dev/null
@@ -1,9 +0,0 @@
-CREATE TABLE wasm_contracts
-(
-  id integer primary key,
-  contract_name text not null,
-  version text not null,
-  date_added text not null,
-  content text not null,
-  CONSTRAINT name_version_unique UNIQUE (contract_name, version)
-);
diff --git a/lib/registry/src/package/sql/migrations/0002.sql b/lib/registry/src/package/sql/migrations/0002.sql
deleted file mode 100644
index cc57ff9b8e..0000000000
--- a/lib/registry/src/package/sql/migrations/0002.sql
+++ /dev/null
@@ -1,26 +0,0 @@
-PRAGMA foreign_keys=off;
-
-CREATE TABLE wasm_interfaces
-(
-  id integer primary key,
-  interface_name text not null,
-  version text not null,
-  date_added text not null,
-  content text not null,
-  CONSTRAINT name_version_unique UNIQUE (interface_name, version)
-);
-
-INSERT INTO wasm_interfaces
-(
-  id,
-  interface_name,
-  version,
-  date_added,
-  content
-)
-  SELECT id, contract_name, version, date_added, content
-  FROM wasm_contracts;
-
-DROP TABLE wasm_contracts;
-
-PRAGMA foreign_keys=on;
diff --git a/lib/registry/src/package/sql/queries/get_interface.sql b/lib/registry/src/package/sql/queries/get_interface.sql
deleted file mode 100644
index 8dffff7ece..0000000000
--- a/lib/registry/src/package/sql/queries/get_interface.sql
+++ /dev/null
@@ -1,4 +0,0 @@
-SELECT content
-FROM wasm_interfaces
-WHERE interface_name = (?1)
-  AND version = (?2)
diff --git a/lib/registry/src/package/sql/queries/insert_interface.sql b/lib/registry/src/package/sql/queries/insert_interface.sql
deleted file mode 100644
index b1f99678ff..0000000000
--- a/lib/registry/src/package/sql/queries/insert_interface.sql
+++ /dev/null
@@ -1,3 +0,0 @@
-INSERT INTO wasm_interfaces
-(interface_name, version, date_added, content)
-VALUES (?1, ?2, ?3, ?4)
diff --git a/lib/registry/src/package/sql/queries/wasm_interface_existence_check.sql b/lib/registry/src/package/sql/queries/wasm_interface_existence_check.sql
deleted file mode 100644
index d00f31e2d9..0000000000
--- a/lib/registry/src/package/sql/queries/wasm_interface_existence_check.sql
+++ /dev/null
@@ -1,5 +0,0 @@
-SELECT 1
-FROM wasm_interfaces
-WHERE interface_name = (?1) 
-   AND version = (?2)
-LIMIT 1
diff --git a/lib/registry/src/publish.rs b/lib/registry/src/publish.rs
deleted file mode 100644
index 570d3864ec..0000000000
--- a/lib/registry/src/publish.rs
+++ /dev/null
@@ -1,621 +0,0 @@
-use crate::graphql::queries::get_signed_url::GetSignedUrlUrl;
-
-use crate::graphql::subscriptions::package_version_ready::PackageVersionState;
-use crate::graphql::{
-    mutations::{publish_package_mutation_chunked, PublishPackageMutationChunked},
-    queries::{get_signed_url, GetSignedUrl},
-};
-use crate::subscriptions::subscribe_package_version_ready;
-use crate::{format_graphql, WasmerConfig};
-use anyhow::{Context, Result};
-use console::{style, Emoji};
-use futures_util::StreamExt;
-use graphql_client::GraphQLQuery;
-use indicatif::{ProgressBar, ProgressState, ProgressStyle};
-use std::collections::BTreeMap;
-use std::fmt::Write;
-use std::io::Write as _;
-use std::path::PathBuf;
-use std::str::FromStr;
-use std::sync::{Arc, Mutex};
-use std::time::Duration;
-use tokio::io::AsyncBufReadExt;
-use tokio::sync::oneshot::Receiver;
-use wasmer_config::package::{NamedPackageIdent, PackageHash, PackageIdent};
-
-static UPLOAD: Emoji<'_, '_> = Emoji("📤", "");
-static PACKAGE: Emoji<'_, '_> = Emoji("📦", "");
-static FIRE: Emoji<'_, '_> = Emoji("🔥", "");
-
-/// Different conditions that can be "awaited" when publishing a package.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct PublishWait {
-    pub container: bool,
-    pub native_executables: bool,
-    pub bindings: bool,
-
-    pub timeout: Option<Duration>,
-}
-
-impl PublishWait {
-    pub fn is_any(self) -> bool {
-        self.container || self.native_executables || self.bindings
-    }
-
-    pub fn new_none() -> Self {
-        Self {
-            container: false,
-            native_executables: false,
-            bindings: false,
-            timeout: None,
-        }
-    }
-
-    pub fn new_all() -> Self {
-        Self {
-            container: true,
-            native_executables: true,
-            bindings: true,
-            timeout: None,
-        }
-    }
-
-    pub fn new_container() -> Self {
-        Self {
-            container: true,
-            native_executables: false,
-            bindings: false,
-            timeout: None,
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub enum SignArchiveResult {
-    Ok {
-        public_key_id: String,
-        signature: String,
-    },
-    NoKeyRegistered,
-}
-
-async fn wait_on(mut recv: Receiver<()>) {
-    loop {
-        _ = std::io::stdout().flush();
-        if recv.try_recv().is_ok() {
-            println!(".");
-            break;
-        } else {
-            tokio::time::sleep(Duration::from_secs(1)).await;
-            print!(".");
-        }
-    }
-}
-
-#[allow(clippy::too_many_arguments)]
-pub async fn try_chunked_uploading(
-    registry: Option<String>,
-    token: Option<String>,
-    package: &Option<wasmer_config::package::Package>,
-    manifest_string: &String,
-    license_file: &Option<String>,
-    readme: &Option<String>,
-    archive_name: &String,
-    archive_path: &PathBuf,
-    maybe_signature_data: &SignArchiveResult,
-    archived_data_size: u64,
-    quiet: bool,
-    wait: PublishWait,
-    timeout: Duration,
-    patch_namespace: Option<String>,
-) -> Result<Option<PackageIdent>, anyhow::Error> {
-    let (registry, token) = initialize_registry_and_token(registry, token)?;
-
-    let steps = if wait.is_any() { 3 } else { 2 };
-
-    let maybe_signature_data = sign_package(maybe_signature_data);
-
-    // fetch this before showing the `Uploading...` message
-    // because there is a chance that the registry may not return a signed url.
-    // This usually happens if the package version already exists in the registry.
-    let signed_url = google_signed_url(&registry, &token, package, timeout)?;
-
-    if !quiet {
-        println!(
-            "{} {} Uploading",
-            style(format!("[1/{steps}]")).bold().dim(),
-            UPLOAD
-        );
-    }
-
-    upload_package(&signed_url.url, archive_path, archived_data_size, timeout).await?;
-
-    let name = package.as_ref().and_then(|p| p.name.clone());
-
-    let namespace = match patch_namespace {
-        Some(n) => Some(n),
-        None => package.as_ref().and_then(|p| {
-            p.name
-                .as_ref()
-                .map(|p| String::from(p.split_once('/').unwrap().0))
-        }),
-    };
-
-    let q =
-        PublishPackageMutationChunked::build_query(publish_package_mutation_chunked::Variables {
-            name,
-            namespace,
-            version: package
-                .as_ref()
-                .and_then(|p| p.version.as_ref().map(|v| v.to_string())),
-            description: package.as_ref().and_then(|p| p.description.clone()),
-            manifest: manifest_string.to_string(),
-            license: package.as_ref().and_then(|p| p.license.clone()),
-            license_file: license_file.to_owned(),
-            readme: readme.to_owned(),
-            repository: package.as_ref().and_then(|p| p.repository.clone()),
-            homepage: package.as_ref().and_then(|p| p.homepage.clone()),
-            file_name: Some(archive_name.to_string()),
-            signature: maybe_signature_data,
-            signed_url: Some(signed_url.url),
-            private: Some(match package {
-                Some(p) => p.private,
-                None => true,
-            }),
-            wait: Some(wait.is_any()),
-        });
-
-    tracing::debug!("{:#?}", q);
-
-    let (send, recv) = tokio::sync::oneshot::channel();
-    let mut wait_t = None;
-
-    if !quiet {
-        print!(
-            "{} {} Publishing package",
-            style(format!("[2/{steps}]")).bold().dim(),
-            PACKAGE
-        );
-
-        _ = std::io::stdout().flush();
-        wait_t = Some(tokio::spawn(wait_on(recv)))
-    }
-
-    let response: publish_package_mutation_chunked::ResponseData = {
-        let registry = registry.clone();
-        let token = token.clone();
-        tokio::spawn(async move {
-            crate::graphql::execute_query_with_timeout(&registry, &token, timeout, &q)
-        })
-        .await??
-    };
-
-    _ = send.send(());
-
-    if let Some(wait_t) = wait_t {
-        _ = wait_t.await;
-    };
-
-    tracing::debug!("{:#?}", response);
-
-    if let Some(payload) = response.publish_package {
-        if !payload.success {
-            return Err(anyhow::anyhow!("Could not publish package"));
-        } else if let Some(pkg_version) = payload.package_version {
-            // Here we can assume that the package is *Some*.
-            let package = package.clone().unwrap();
-
-            if wait.is_any() {
-                wait_for_package_version_to_become_ready(
-                    &registry,
-                    &token,
-                    pkg_version.id,
-                    quiet,
-                    wait,
-                    steps,
-                )
-                .await?;
-            }
-
-            let package_ident = PackageIdent::Named(NamedPackageIdent::from_str(&format!(
-                "{}@{}",
-                package
-                    .name
-                    .expect("Unnamed package was published as named"),
-                package
-                    .version
-                    .expect("Unversioned package was published as versioned")
-            ))?);
-            eprintln!("Package published successfully");
-            // println!("🚀 Successfully published package `{}`", package_ident);
-            return Ok(Some(package_ident));
-        } else if let Some(pkg_hash) = payload.package_webc {
-            let package_ident = PackageIdent::Hash(
-                PackageHash::from_str(&format!("sha256:{}", pkg_hash.webc_v3.unwrap().webc_sha256))
-                    .unwrap(),
-            );
-            eprintln!("Package published successfully");
-            // println!("🚀 Successfully published package `{}`", package_ident);
-            return Ok(Some(package_ident));
-        }
-
-        unreachable!();
-    } else {
-        unreachable!();
-    }
-}
-
-fn initialize_registry_and_token(
-    registry: Option<String>,
-    token: Option<String>,
-) -> Result<(String, String), anyhow::Error> {
-    let registry = match registry.as_ref() {
-        Some(s) => format_graphql(s),
-        None => {
-            let wasmer_dir = WasmerConfig::get_wasmer_dir().map_err(|e| anyhow::anyhow!("{e}"))?;
-
-            let config = WasmerConfig::from_file(&wasmer_dir);
-
-            config
-                .map_err(|e| anyhow::anyhow!("{e}"))?
-                .registry
-                .get_current_registry()
-        }
-    };
-
-    let token = match token.as_ref() {
-        Some(s) => s.to_string(),
-        None => {
-            let wasmer_dir = WasmerConfig::get_wasmer_dir().map_err(|e| anyhow::anyhow!("{e}"))?;
-
-            let config = WasmerConfig::from_file(&wasmer_dir);
-
-            config
-                .map_err(|e| anyhow::anyhow!("{e}"))?
-                .registry
-                .get_login_token_for_registry(&registry)
-                .ok_or_else(|| {
-                    anyhow::anyhow!("cannot publish package: not logged into registry {registry:?}")
-                })?
-        }
-    };
-
-    Ok((registry, token))
-}
-
-fn sign_package(
-    maybe_signature_data: &SignArchiveResult,
-) -> Option<publish_package_mutation_chunked::InputSignature> {
-    match maybe_signature_data {
-        SignArchiveResult::Ok {
-            public_key_id,
-            signature,
-        } => {
-            log::info!(
-                "Package successfully signed with public key: \"{}\"!",
-                &public_key_id
-            );
-            Some(publish_package_mutation_chunked::InputSignature {
-                public_key_key_id: public_key_id.to_string(),
-                data: signature.to_string(),
-            })
-        }
-        SignArchiveResult::NoKeyRegistered => {
-            // TODO: uncomment this when we actually want users to start using it
-            //warn!("Publishing package without a verifying signature. Consider registering a key pair with wasmer");
-            None
-        }
-    }
-}
-
-fn google_signed_url(
-    registry: &str,
-    token: &str,
-    package: &Option<wasmer_config::package::Package>,
-    timeout: Duration,
-) -> Result<GetSignedUrlUrl, anyhow::Error> {
-    let get_google_signed_url = GetSignedUrl::build_query(get_signed_url::Variables {
-        name: package
-            .as_ref()
-            .and_then(|p| p.name.as_ref().map(|n| n.to_string())),
-        version: package
-            .as_ref()
-            .and_then(|p| p.version.as_ref().map(|v| v.to_string())),
-        filename: match package {
-            Some(_) => None,
-            None => Some(format!("unnamed_package_{}", rand::random::<usize>())),
-        },
-        expires_after_seconds: Some(60 * 30),
-    });
-
-    let _response: get_signed_url::ResponseData = crate::graphql::execute_query_with_timeout(
-        registry,
-        token,
-        timeout,
-        &get_google_signed_url,
-    )?;
-
-    let url = _response.url.ok_or_else(|| match package {
-        Some(pkg) => {
-            anyhow::anyhow!(
-                "could not get signed url for package {:?}@{:?}",
-                pkg.name,
-                pkg.version
-            )
-        }
-        None => {
-            anyhow::anyhow!("could not get signed url for unnamed package",)
-        }
-    })?;
-    Ok(url)
-}
-
-async fn upload_package(
-    signed_url: &str,
-    archive_path: &PathBuf,
-    archived_data_size: u64,
-    timeout: Duration,
-) -> Result<(), anyhow::Error> {
-    let url = url::Url::parse(signed_url).context("cannot parse signed url")?;
-    let client = reqwest::Client::builder()
-        .default_headers(reqwest::header::HeaderMap::default())
-        .timeout(timeout)
-        .build()
-        .unwrap();
-
-    let res = client
-        .post(url)
-        .header(reqwest::header::CONTENT_LENGTH, "0")
-        .header(reqwest::header::CONTENT_TYPE, "application/octet-stream")
-        .header("x-goog-resumable", "start");
-
-    let result = res.send().await.unwrap();
-
-    if result.status() != reqwest::StatusCode::from_u16(201).unwrap() {
-        return Err(anyhow::anyhow!(
-            "Uploading package failed: got HTTP {:?} when uploading",
-            result.status()
-        ));
-    }
-
-    let headers = result
-        .headers()
-        .into_iter()
-        .filter_map(|(k, v)| {
-            let k = k.to_string();
-            let v = v.to_str().ok()?.to_string();
-            Some((k.to_lowercase(), v))
-        })
-        .collect::<BTreeMap<_, _>>();
-
-    let session_uri = headers.get("location").unwrap().clone();
-
-    let total = archived_data_size;
-
-    // archive_path
-    let mut file = tokio::fs::OpenOptions::new()
-        .read(true)
-        .open(archive_path)
-        .await
-        .map_err(|e| anyhow::anyhow!("cannot open archive {}: {e}", archive_path.display()))?;
-
-    let pb = ProgressBar::new(archived_data_size);
-    pb.set_style(ProgressStyle::with_template("{spinner:.green} [{elapsed_precise}] [{wide_bar:.cyan/blue}] {bytes}/{total_bytes} ({eta})")
-    .unwrap()
-    .with_key("eta", |state: &ProgressState, w: &mut dyn Write| {
-        write!(w, "{:.1}s", state.eta().as_secs_f64()).unwrap()
-    })
-    .progress_chars("#>-"));
-
-    let chunk_size = 1_048_576; // 1MB - 315s / 100MB
-    let mut file_pointer = 0;
-
-    let mut reader = tokio::io::BufReader::with_capacity(chunk_size, &mut file);
-
-    let client = reqwest::Client::builder()
-        .default_headers(reqwest::header::HeaderMap::default())
-        .build()
-        .unwrap();
-
-    while let Some(chunk) = reader.fill_buf().await.ok().map(|s| s.to_vec()) {
-        let n = chunk.len();
-
-        if chunk.is_empty() {
-            break;
-        }
-
-        let start = file_pointer;
-        let end = file_pointer + chunk.len().saturating_sub(1);
-        let content_range = format!("bytes {start}-{end}/{total}");
-
-        let res = client
-            .put(&session_uri)
-            .header(reqwest::header::CONTENT_TYPE, "application/octet-stream")
-            .header(reqwest::header::CONTENT_LENGTH, format!("{}", chunk.len()))
-            .header("Content-Range".to_string(), content_range)
-            .body(chunk.to_vec());
-
-        pb.set_position(file_pointer as u64);
-
-        res.send()
-            .await
-            .map(|response| response.error_for_status())
-            .map_err(|e| {
-                anyhow::anyhow!(
-                    "cannot send request to {session_uri} (chunk {}..{}): {e}",
-                    file_pointer,
-                    file_pointer + chunk_size
-                )
-            })??;
-
-        if n < chunk_size {
-            break;
-        }
-
-        reader.consume(n);
-        file_pointer += n;
-    }
-
-    pb.finish_and_clear();
-    Ok(())
-}
-
-struct PackageVersionReadySharedState {
-    webc_generated: Arc<Mutex<Option<bool>>>,
-    bindings_generated: Arc<Mutex<Option<bool>>>,
-    native_exes_generated: Arc<Mutex<Option<bool>>>,
-}
-
-impl PackageVersionReadySharedState {
-    fn new() -> Self {
-        Self {
-            webc_generated: Arc::new(Mutex::new(Option::None)),
-            bindings_generated: Arc::new(Mutex::new(Option::None)),
-            native_exes_generated: Arc::new(Mutex::new(Option::None)),
-        }
-    }
-}
-
-// fn create_spinner(m: &MultiProgress, message: String) -> ProgressBar {
-//     let spinner = m.add(ProgressBar::new_spinner());
-//     spinner.set_message(message);
-//     spinner.set_style(ProgressStyle::default_spinner());
-//     spinner.enable_steady_tick(Duration::from_millis(100));
-//     spinner
-// }
-//
-// fn show_spinners_while_waiting(state: &PackageVersionReadySharedState) {
-//     // Clone shared state for threads
-//     let (state_webc, state_bindings, state_native) = (
-//         Arc::clone(&state.webc_generated),
-//         Arc::clone(&state.bindings_generated),
-//         Arc::clone(&state.native_exes_generated),
-//     );
-//     let m = MultiProgress::new();
-//
-//     let webc_spinner = create_spinner(&m, String::from("Generating package..."));
-//     let bindings_spinner = create_spinner(&m, String::from("Generating language bindings..."));
-//     let exe_spinner = create_spinner(&m, String::from("Generating native executables..."));
-//
-//     let check_and_finish = |spinner: ProgressBar, state: Arc<Mutex<Option<bool>>>, name: String| {
-//         thread::spawn(move || loop {
-//             match state.lock() {
-//                 Ok(lock) => {
-//                     if lock.is_some() {
-//                         // spinner.finish_with_message(format!("✅ {} generation complete", name));
-//                         spinner.finish_and_clear();
-//                         break;
-//                     }
-//                 }
-//                 Err(_) => {
-//                     break;
-//                 }
-//             }
-//             thread::sleep(Duration::from_millis(100));
-//         });
-//     };
-//     check_and_finish(webc_spinner, state_webc, String::from("package"));
-//     check_and_finish(
-//         bindings_spinner,
-//         state_bindings,
-//         String::from("Language bindings"),
-//     );
-//     check_and_finish(
-//         exe_spinner,
-//         state_native,
-//         String::from("Native executables"),
-//     );
-// }
-
-async fn wait_for_package_version_to_become_ready(
-    registry: &str,
-    token: &str,
-    package_version_id: impl AsRef<str>,
-    quiet: bool,
-    mut conditions: PublishWait,
-    steps: usize,
-) -> Result<()> {
-    let (mut stream, _client) =
-        subscribe_package_version_ready(registry, token, package_version_id.as_ref()).await?;
-
-    let state = PackageVersionReadySharedState::new();
-
-    let (send, recv) = tokio::sync::oneshot::channel();
-    let mut wait_t = None;
-
-    if !quiet {
-        print!(
-            "{} {} Waiting for package to be available",
-            style(format!("[3/{steps}]")).bold().dim(),
-            FIRE
-        );
-        _ = std::io::stdout().flush();
-        wait_t = Some(tokio::spawn(wait_on(recv)));
-    }
-
-    if !conditions.is_any() {
-        return Ok(());
-    }
-
-    let deadline = conditions
-        .timeout
-        .map(|x| std::time::Instant::now() + x)
-        .unwrap_or_else(|| std::time::Instant::now() + std::time::Duration::from_secs(60 * 10));
-
-    loop {
-        if !conditions.is_any() {
-            break;
-        }
-        if std::time::Instant::now() > deadline {
-            _ = send.send(());
-            return Err(anyhow::anyhow!(
-                "Timed out waiting for package version to become ready"
-            ));
-        }
-
-        let data = match tokio::time::timeout_at(deadline.into(), stream.next()).await {
-            Err(_) => {
-                _ = send.send(());
-                return Err(anyhow::anyhow!(
-                    "Timed out waiting for package version to become ready"
-                ));
-            }
-            Ok(None) => {
-                break;
-            }
-            Ok(Some(data)) => data,
-        };
-
-        if let Some(res_data) = data.unwrap().data {
-            match res_data.package_version_ready.state {
-                PackageVersionState::BINDINGS_GENERATED => {
-                    let mut st = state.bindings_generated.lock().unwrap();
-                    let is_ready = res_data.package_version_ready.success;
-                    *st = Some(is_ready);
-                    conditions.bindings = false;
-                }
-                PackageVersionState::NATIVE_EXES_GENERATED => {
-                    let mut st = state.native_exes_generated.lock().unwrap();
-                    *st = Some(res_data.package_version_ready.success);
-
-                    conditions.native_executables = false;
-                }
-                PackageVersionState::WEBC_GENERATED => {
-                    let mut st = state.webc_generated.lock().unwrap();
-                    *st = Some(res_data.package_version_ready.success);
-
-                    conditions.container = false;
-                }
-                PackageVersionState::Other(_) => {}
-            }
-        }
-    }
-
-    _ = send.send(());
-
-    if let Some(wait_t) = wait_t {
-        _ = wait_t.await;
-    }
-
-    Ok(())
-}
diff --git a/lib/registry/src/subscriptions.rs b/lib/registry/src/subscriptions.rs
deleted file mode 100644
index daca2295e5..0000000000
--- a/lib/registry/src/subscriptions.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-use std::{env, future::IntoFuture};
-
-use anyhow::Context;
-
-use crate::graphql::subscriptions::{package_version_ready, PackageVersionReady};
-
-use graphql_client::GraphQLQuery;
-use graphql_ws_client::{graphql::StreamingOperation, Client, Subscription};
-
-use tokio_tungstenite::tungstenite::{client::IntoClientRequest, http::HeaderValue};
-
-pub use crate::graphql::subscriptions::package_version_ready::PackageVersionState;
-
-async fn subscribe_graphql<Q: GraphQLQuery + Send + Sync + Unpin + 'static>(
-    registry_url: &str,
-    login_token: &str,
-    variables: Q::Variables,
-) -> anyhow::Result<(Subscription<StreamingOperation<Q>>, Client)>
-where
-    <Q as GraphQLQuery>::Variables: Send + Sync + Unpin,
-{
-    let mut url = url::Url::parse(registry_url).unwrap();
-    if url.scheme() == "http" {
-        url.set_scheme("ws").unwrap();
-    } else if url.scheme() == "https" {
-        url.set_scheme("wss").unwrap();
-    }
-
-    let mut req = url.into_client_request()?;
-    req.headers_mut().insert(
-        "Sec-WebSocket-Protocol",
-        HeaderValue::from_str("graphql-transport-ws")?,
-    );
-    let token = env::var("WASMER_TOKEN")
-        .ok()
-        .or_else(|| env::var("WAPM_REGISTRY_TOKEN").ok())
-        .unwrap_or_else(|| login_token.to_string());
-    req.headers_mut().insert(
-        reqwest::header::AUTHORIZATION,
-        HeaderValue::from_str(&format!("Bearer {}", token))?,
-    );
-    let user_agent = crate::client::RegistryClient::default_user_agent();
-    req.headers_mut().insert(
-        reqwest::header::USER_AGENT,
-        HeaderValue::from_str(&user_agent)?,
-    );
-    let (connection, _resp) = async_tungstenite::tokio::connect_async(req)
-        .await
-        .context("could not connect")?;
-
-    let (client, actor) = graphql_ws_client::Client::build(connection).await?;
-    tokio::spawn(actor.into_future());
-
-    let stream = client
-        .subscribe(StreamingOperation::<Q>::new(variables))
-        .await?;
-
-    Ok((stream, client))
-}
-
-pub async fn subscribe_package_version_ready(
-    registry_url: &str,
-    login_token: &str,
-    package_version_id: &str,
-) -> anyhow::Result<(
-    Subscription<StreamingOperation<PackageVersionReady>>,
-    Client,
-)> {
-    subscribe_graphql(
-        registry_url,
-        login_token,
-        package_version_ready::Variables {
-            package_version_id: package_version_id.to_string(),
-        },
-    )
-    .await
-}
diff --git a/lib/registry/src/types.rs b/lib/registry/src/types.rs
deleted file mode 100644
index 3db9a2bf8c..0000000000
--- a/lib/registry/src/types.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-/// Payload for publishing a new Deploy app.
-#[derive(Clone, Debug)]
-pub struct PublishDeployAppRawVars {
-    /// Name for the app.
-    /// If not specified a random name will be generated.
-    pub name: Option<String>,
-
-    /// The namespace to deploy the app to.
-    ///
-    /// If not specified the app will be deployed under the current users
-    /// namespace.
-    pub namespace: Option<String>,
-
-    /// The raw DeployV1 configuration.
-    pub config: serde_json::Value,
-}
-
-/// Data for a deployed app.
-#[derive(Clone, Debug)]
-pub struct PublishDeployAppOutput {
-    pub app_id: String,
-    pub app_name: String,
-    pub version_id: String,
-    pub version_name: String,
-    pub owner_name: String,
-}
-
-#[derive(Clone, Debug)]
-pub struct NewNonceOutput {
-    pub auth_url: String,
-}
diff --git a/lib/registry/src/utils.rs b/lib/registry/src/utils.rs
deleted file mode 100644
index a45ed237b6..0000000000
--- a/lib/registry/src/utils.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-use crate::graphql::{
-    execute_query,
-    queries::{who_am_i_query, WhoAmIQuery},
-};
-use graphql_client::GraphQLQuery;
-
-pub fn get_username(registry: &str) -> anyhow::Result<Option<String>> {
-    let q = WhoAmIQuery::build_query(who_am_i_query::Variables {});
-    let response: who_am_i_query::ResponseData = execute_query(registry, "", &q)?;
-    Ok(response.viewer.map(|viewer| viewer.username))
-}
-
-pub fn get_username_registry_token(registry: &str, token: &str) -> anyhow::Result<Option<String>> {
-    let q = WhoAmIQuery::build_query(who_am_i_query::Variables {});
-    let response: who_am_i_query::ResponseData = execute_query(registry, token, &q)?;
-    Ok(response.viewer.map(|viewer| viewer.username))
-}
-
-pub fn normalize_path(s: &str) -> String {
-    s.strip_prefix(r"\\?\").unwrap_or(s).to_string()
-}
diff --git a/lib/registry/src/wasmer_env.rs b/lib/registry/src/wasmer_env.rs
deleted file mode 100644
index dbcc267a71..0000000000
--- a/lib/registry/src/wasmer_env.rs
+++ /dev/null
@@ -1,295 +0,0 @@
-use std::path::{Path, PathBuf};
-
-use crate::WasmerConfig;
-use anyhow::{Context, Error};
-use url::Url;
-
-/// Command-line flags for determining the local "Wasmer Environment".
-///
-/// This is where you access `$WASMER_DIR`, the `$WASMER_DIR/wasmer.toml` config
-/// file, and specify the current registry.
-#[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "clap", derive(clap::Parser))]
-pub struct WasmerEnv {
-    /// Set Wasmer's home directory
-    #[cfg_attr(feature = "clap", clap(long, env = "WASMER_DIR", default_value = WASMER_DIR.as_os_str()))]
-    wasmer_dir: PathBuf,
-    /// The registry to fetch packages from (inferred from the environment by
-    /// default)
-    #[cfg_attr(feature = "clap", clap(long, env = "WASMER_REGISTRY"))]
-    registry: Option<Registry>,
-    /// The directory cached artefacts are saved to.
-    #[cfg_attr(feature = "clap", clap(long, env = "WASMER_CACHE_DIR"))]
-    cache_dir: Option<PathBuf>,
-    /// The API token to use when communicating with the registry (inferred from
-    /// the environment by default)
-    #[cfg_attr(feature = "clap", clap(long, env = "WASMER_TOKEN"))]
-    token: Option<String>,
-}
-
-impl WasmerEnv {
-    pub fn new(
-        wasmer_dir: PathBuf,
-        registry: Option<Registry>,
-        token: Option<String>,
-        cache_dir: Option<PathBuf>,
-    ) -> Self {
-        WasmerEnv {
-            wasmer_dir,
-            registry,
-            token,
-            cache_dir,
-        }
-    }
-
-    pub fn registry_public_url(&self) -> Result<Url, Error> {
-        let mut url = self.registry_endpoint()?;
-        url.set_path("");
-
-        let mut domain = url.host_str().context("url has no host")?.to_string();
-        if domain.starts_with("registry.") {
-            domain = domain.strip_prefix("registry.").unwrap().to_string();
-        }
-        url.set_host(Some(&domain))
-            .context("could not derive registry public url")?;
-
-        Ok(url)
-    }
-
-    /// Get the GraphQL endpoint used to query the registry.
-    pub fn registry_endpoint(&self) -> Result<Url, Error> {
-        if let Some(registry) = &self.registry {
-            return registry.graphql_endpoint();
-        }
-
-        let config = self.config()?;
-        let url = config.registry.get_current_registry().parse()?;
-
-        Ok(url)
-    }
-
-    /// Load the current Wasmer config.
-    pub fn config(&self) -> Result<WasmerConfig, Error> {
-        WasmerConfig::from_file(self.dir())
-            .map_err(Error::msg)
-            .with_context(|| {
-                format!(
-                    "Unable to load the config from the \"{}\" directory",
-                    self.dir().display()
-                )
-            })
-    }
-
-    /// The directory all Wasmer artifacts are stored in.
-    pub fn dir(&self) -> &Path {
-        &self.wasmer_dir
-    }
-
-    /// The directory all cached artifacts should be saved to.
-    pub fn cache_dir(&self) -> PathBuf {
-        match &self.cache_dir {
-            Some(cache_dir) => cache_dir.clone(),
-            None => self.dir().join("cache"),
-        }
-    }
-
-    /// Retrieve the specified token.
-    ///
-    /// NOTE: In contrast to [`Self::token`], this will not fall back to loading
-    /// the token from the confg file.
-    pub fn get_token_opt(&self) -> Option<&str> {
-        self.token.as_deref()
-    }
-
-    /// The API token for the active registry.
-    pub fn token(&self) -> Option<String> {
-        if let Some(token) = &self.token {
-            return Some(token.clone());
-        }
-
-        // Fall back to the config file
-
-        let config = self.config().ok()?;
-        let registry_endpoint = self.registry_endpoint().ok()?;
-        config
-            .registry
-            .get_login_token_for_registry(registry_endpoint.as_str())
-    }
-}
-
-impl Default for WasmerEnv {
-    fn default() -> Self {
-        Self {
-            wasmer_dir: WASMER_DIR.clone(),
-            registry: None,
-            token: None,
-            cache_dir: None,
-        }
-    }
-}
-
-lazy_static::lazy_static! {
-    /// The default value for `$WASMER_DIR`.
-    pub static ref WASMER_DIR: PathBuf = match crate::WasmerConfig::get_wasmer_dir() {
-        Ok(path) => path,
-        Err(e) => {
-            if let Some(install_prefix) = option_env!("WASMER_INSTALL_PREFIX") {
-                return PathBuf::from(install_prefix);
-            }
-
-            panic!("Unable to determine the wasmer dir: {e}");
-        }
-    };
-}
-
-/// A registry as specified by the user.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Registry(String);
-
-impl Registry {
-    /// Get the [`Registry`]'s string representation.
-    pub fn as_str(&self) -> &str {
-        self.0.as_str()
-    }
-
-    /// Get the GraphQL endpoint for this [`Registry`].
-    pub fn graphql_endpoint(&self) -> Result<Url, Error> {
-        let url = crate::format_graphql(self.as_str()).parse()?;
-        Ok(url)
-    }
-}
-
-impl From<String> for Registry {
-    fn from(value: String) -> Self {
-        Registry(value)
-    }
-}
-
-impl From<&str> for Registry {
-    fn from(value: &str) -> Self {
-        Registry(value.to_string())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use tempfile::TempDir;
-
-    use super::*;
-
-    const WASMER_TOML: &str = r#"
-    telemetry_enabled = false
-    update_notifications_enabled = false
-
-    [registry]
-    active_registry = "https://registry.wasmer.io/graphql"
-
-    [[registry.tokens]]
-    registry = "https://registry.wasmer.wtf/graphql"
-    token = "dev-token"
-
-    [[registry.tokens]]
-    registry = "https://registry.wasmer.io/graphql"
-    token = "prod-token"
-    "#;
-
-    #[test]
-    fn load_defaults_from_config() {
-        let temp = TempDir::new().unwrap();
-        std::fs::write(temp.path().join("wasmer.toml"), WASMER_TOML).unwrap();
-
-        let env = WasmerEnv {
-            wasmer_dir: temp.path().to_path_buf(),
-            registry: None,
-            cache_dir: None,
-            token: None,
-        };
-
-        assert_eq!(
-            env.registry_endpoint().unwrap().as_str(),
-            "https://registry.wasmer.io/graphql"
-        );
-        assert_eq!(env.token().unwrap(), "prod-token");
-        assert_eq!(env.cache_dir(), temp.path().join("cache"));
-    }
-
-    #[test]
-    fn override_token() {
-        let temp = TempDir::new().unwrap();
-        std::fs::write(temp.path().join("wasmer.toml"), WASMER_TOML).unwrap();
-
-        let env = WasmerEnv {
-            wasmer_dir: temp.path().to_path_buf(),
-            registry: None,
-            cache_dir: None,
-            token: Some("asdf".to_string()),
-        };
-
-        assert_eq!(
-            env.registry_endpoint().unwrap().as_str(),
-            "https://registry.wasmer.io/graphql"
-        );
-        assert_eq!(env.token().unwrap(), "asdf");
-        assert_eq!(env.cache_dir(), temp.path().join("cache"));
-    }
-
-    #[test]
-    fn override_registry() {
-        let temp = TempDir::new().unwrap();
-        std::fs::write(temp.path().join("wasmer.toml"), WASMER_TOML).unwrap();
-        let env = WasmerEnv {
-            wasmer_dir: temp.path().to_path_buf(),
-            registry: Some(Registry::from("wasmer.wtf")),
-            cache_dir: None,
-            token: None,
-        };
-
-        assert_eq!(
-            env.registry_endpoint().unwrap().as_str(),
-            "https://registry.wasmer.wtf/graphql"
-        );
-        assert_eq!(env.token().unwrap(), "dev-token");
-        assert_eq!(env.cache_dir(), temp.path().join("cache"));
-    }
-
-    #[test]
-    fn override_registry_and_token() {
-        let temp = TempDir::new().unwrap();
-        std::fs::write(temp.path().join("wasmer.toml"), WASMER_TOML).unwrap();
-
-        let env = WasmerEnv {
-            wasmer_dir: temp.path().to_path_buf(),
-            registry: Some(Registry::from("wasmer.wtf")),
-            cache_dir: None,
-            token: Some("asdf".to_string()),
-        };
-
-        assert_eq!(
-            env.registry_endpoint().unwrap().as_str(),
-            "https://registry.wasmer.wtf/graphql"
-        );
-        assert_eq!(env.token().unwrap(), "asdf");
-        assert_eq!(env.cache_dir(), temp.path().join("cache"));
-    }
-
-    #[test]
-    fn override_cache_dir() {
-        let temp = TempDir::new().unwrap();
-        std::fs::write(temp.path().join("wasmer.toml"), WASMER_TOML).unwrap();
-        let expected_cache_dir = temp.path().join("some-other-cache");
-
-        let env = WasmerEnv {
-            wasmer_dir: temp.path().to_path_buf(),
-            registry: None,
-            cache_dir: Some(expected_cache_dir.clone()),
-            token: None,
-        };
-
-        assert_eq!(
-            env.registry_endpoint().unwrap().as_str(),
-            "https://registry.wasmer.io/graphql"
-        );
-        assert_eq!(env.token().unwrap(), "prod-token");
-        assert_eq!(env.cache_dir(), expected_cache_dir);
-    }
-}
diff --git a/lib/sdk/Cargo.toml b/lib/sdk/Cargo.toml
new file mode 100644
index 0000000000..041f712712
--- /dev/null
+++ b/lib/sdk/Cargo.toml
@@ -0,0 +1,38 @@
+[package]
+name = "wasmer-sdk"
+description = "The Wasmer SDK - provides Wasmer and Wasmer Edge related functionality."
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+readme = "README.md"
+
+[dependencies]
+wasmer-backend-api = { path = "../backend-api", version = "=0.601.0" }
+wasmer-config = { path = "../config", version = "=0.601.0" }
+wasmer-package = { path = "../package", version = "=0.601.0" }
+
+reqwest = { workspace = true, default-features = false, features = ["json", "multipart", "gzip", "stream"] }
+tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
+bytes = { workspace = true }
+futures-util = { workspace = true }
+serde = { workspace = true, features = ["derive"] }
+serde_yaml = { workspace = true }
+thiserror = { workspace = true }
+anyhow = { workspace = true }
+sha2 = { workspace = true }
+semver = { workspace = true }
+toml = { workspace = true }
+bytesize = { workspace = true }
+walkdir = "2"
+zip = { version = "2.4", default-features = false, features = ["deflate"] }
+tracing = { workspace = true }
+ignore.workspace = true
+
+[dev-dependencies]
+rand = "0.9.1"
+tempfile = "3"
+url = "2"
diff --git a/lib/sdk/README.md b/lib/sdk/README.md
new file mode 100644
index 0000000000..a6f9a8222c
--- /dev/null
+++ b/lib/sdk/README.md
@@ -0,0 +1,13 @@
+# wasmer-sdk
+
+The wasmer-sdk provides convenient wrappers to work with the Wasmer ecosystem,
+including functionality for:
+
+* Building and publishing packages
+* Deploying apps
+* ...
+
+## Architecture Support
+
+This crate currently only works on native architectures, and does not support
+browser Webassembly yet. Support will likely added in the future.
diff --git a/lib/sdk/src/app/deploy.rs b/lib/sdk/src/app/deploy.rs
new file mode 100644
index 0000000000..da021a91ec
--- /dev/null
+++ b/lib/sdk/src/app/deploy.rs
@@ -0,0 +1,195 @@
+use std::time::Duration;
+
+use anyhow::Context as _;
+use reqwest;
+use thiserror::Error;
+use wasmer_backend_api::{
+    types::{DeployApp, DeployAppVersion, PublishDeployAppVars},
+    WasmerClient,
+};
+use wasmer_config::{app::AppConfigV1, package::PackageSource};
+
+use crate::package::publish::{
+    publish_package_directory, PackagePublishError, PublishOptions, PublishProgress, PublishWait,
+};
+
+/// When waiting for an app deployment.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum WaitMode {
+    /// Wait for the deployment to be created.
+    Deployed,
+    /// Wait until the deployment becomes reachable over the network.
+    Reachable,
+}
+
+/// Progress events during deployment.
+#[derive(Debug, Clone)]
+pub enum DeployProgress {
+    Publishing(PublishProgress),
+    Deploying,
+    Waiting(WaitMode),
+}
+
+/// Options for deploying an app.
+#[derive(Debug, Clone)]
+pub struct DeployOptions {
+    pub owner: Option<String>,
+    pub make_default: bool,
+    pub wait: WaitMode,
+    pub publish_package: bool,
+    pub package_namespace: Option<String>,
+    pub publish_timeout: Duration,
+}
+
+impl Default for DeployOptions {
+    fn default() -> Self {
+        Self {
+            owner: None,
+            make_default: true,
+            wait: WaitMode::Reachable,
+            publish_package: true,
+            package_namespace: None,
+            publish_timeout: Duration::from_secs(60 * 5),
+        }
+    }
+}
+
+/// Error that can occur during app deployment.
+#[derive(Debug, Error)]
+#[non_exhaustive]
+pub enum DeployError {
+    #[error("missing owner in configuration or options")]
+    MissingOwner,
+    #[error("missing app name in configuration")]
+    MissingName,
+    #[error("package publish error: {0}")]
+    Publish(#[from] PackagePublishError),
+    #[error("yaml error: {0}")]
+    Yaml(#[from] serde_yaml::Error),
+    #[error("backend API error: {0}")]
+    Api(#[from] anyhow::Error),
+    #[error("app http probe failed: {message}")]
+    AppHttpCheck { message: String },
+}
+
+/// Deploy an app based on the provided app configuration and options.
+pub async fn deploy_app<F>(
+    client: &WasmerClient,
+    mut config: AppConfigV1,
+    opts: DeployOptions,
+    mut progress: F,
+) -> Result<(DeployApp, DeployAppVersion), DeployError>
+where
+    F: FnMut(DeployProgress) + Send,
+{
+    let owner = opts
+        .owner
+        .clone()
+        .or_else(|| config.owner.clone())
+        .ok_or(DeployError::MissingOwner)?;
+
+    if opts.publish_package {
+        if let PackageSource::Path(ref path) = config.package {
+            let publish_opts = PublishOptions {
+                namespace: Some(
+                    opts.package_namespace
+                        .clone()
+                        .unwrap_or_else(|| owner.clone()),
+                ),
+                timeout: opts.publish_timeout,
+                wait: PublishWait::Container,
+                ..Default::default()
+            };
+            let ident = publish_package_directory(client, path.as_ref(), publish_opts, |e| {
+                progress(DeployProgress::Publishing(e));
+            })
+            .await?;
+            config.package = ident.into();
+        }
+    }
+
+    let name = config.name.clone().ok_or(DeployError::MissingName)?;
+
+    let config_value = config.clone().to_yaml_value()?;
+    let raw_config = serde_yaml::to_string(&config_value)?.trim().to_string() + "\n";
+
+    progress(DeployProgress::Deploying);
+    let version = wasmer_backend_api::query::publish_deploy_app(
+        client,
+        PublishDeployAppVars {
+            config: raw_config,
+            name: name.clone().into(),
+            owner: Some(owner.clone().into()),
+            make_default: Some(opts.make_default),
+        },
+    )
+    .await?;
+
+    progress(DeployProgress::Waiting(opts.wait));
+    wait_app(client, &version, opts.wait, opts.make_default).await
+}
+
+async fn wait_app(
+    client: &WasmerClient,
+    version: &DeployAppVersion,
+    wait: WaitMode,
+    make_default: bool,
+) -> Result<(DeployApp, DeployAppVersion), DeployError> {
+    const PROBE_TIMEOUT: Duration = Duration::from_secs(60 * 5);
+    use wasmer_config::app::HEADER_APP_VERSION_ID;
+
+    let app_id = version
+        .app
+        .as_ref()
+        .ok_or_else(|| DeployError::Api(anyhow::anyhow!("app field empty")))?
+        .id
+        .inner()
+        .to_string();
+
+    let app = wasmer_backend_api::query::get_app_by_id(client, app_id.clone())
+        .await
+        .map_err(DeployError::Api)?;
+
+    match wait {
+        WaitMode::Deployed => {}
+        WaitMode::Reachable => {
+            tokio::time::sleep(Duration::from_secs(2)).await;
+            let check_url = if make_default { &app.url } else { &version.url };
+            let http = reqwest::Client::builder()
+                .connect_timeout(Duration::from_secs(10))
+                .timeout(Duration::from_secs(90))
+                .redirect(reqwest::redirect::Policy::none())
+                .build()
+                .context("failed to build HTTP client")?;
+            let start = tokio::time::Instant::now();
+            let mut sleep_ms = 1_000u64;
+            loop {
+                if start.elapsed() > Duration::from_secs(60 * 5) {
+                    return Err(DeployError::AppHttpCheck {
+                        message: format!(
+                            "timed out waiting for app version '{}' to become reachable at '{}' (tried for {} seconds)",
+                            version.id.inner(),
+                            check_url,
+                            PROBE_TIMEOUT.as_secs(),
+                        ),
+                    });
+                }
+                if let Ok(res) = http.get(check_url).send().await {
+                    let header = res
+                        .headers()
+                        .get(HEADER_APP_VERSION_ID)
+                        .and_then(|v| v.to_str().ok())
+                        .unwrap_or("");
+                    if header == version.id.inner() {
+                        break;
+                    }
+                }
+                let to_sleep = Duration::from_millis(sleep_ms);
+                tokio::time::sleep(to_sleep).await;
+                sleep_ms = (sleep_ms * 2).min(10_000);
+            }
+        }
+    }
+
+    Ok((app, version.clone()))
+}
diff --git a/lib/sdk/src/app/deploy_remote_build.rs b/lib/sdk/src/app/deploy_remote_build.rs
new file mode 100644
index 0000000000..7f5830e493
--- /dev/null
+++ b/lib/sdk/src/app/deploy_remote_build.rs
@@ -0,0 +1,439 @@
+//! Functionality for deploying applications to Wasmer Edge through the
+//! "autobuild zip upload" flow, which just uploads a zip directory and
+//! lets the Wasmer backend handle building and deploying it.
+
+use std::{
+    path::{Path, PathBuf},
+    time::Duration,
+};
+
+use anyhow::{bail, Context as _};
+use futures_util::StreamExt;
+use reqwest::header::CONTENT_TYPE;
+use wasmer_backend_api::{
+    types::{AutoBuildDeployAppLogKind, AutobuildLog, DeployAppVersion, Id},
+    WasmerClient,
+};
+use wasmer_config::app::AppConfigV1;
+use zip::{write::SimpleFileOptions, CompressionMethod};
+
+use thiserror::Error;
+
+pub use wasmer_backend_api::types::BuildConfig;
+
+/// Options for remote deployments through [`deploy_app_remote`].
+#[derive(Debug, Clone)]
+pub struct DeployRemoteOpts {
+    pub app: AppConfigV1,
+    pub owner: Option<String>,
+}
+
+/// Events emitted during the remote deployment process.
+///
+/// Used by the `on_progress` callback in [`deploy_app_remote`].
+#[derive(Debug, Clone)]
+#[non_exhaustive]
+pub enum DeployRemoteEvent {
+    /// Starting creation of the archive file.
+    CreatingArchive {
+        path: PathBuf,
+    },
+    /// Archive file has been created.
+    ArchiveCreated {
+        file_count: usize,
+        archive_size: u64,
+    },
+    GeneratingUploadUrl,
+    UploadArchiveStart {
+        archive_size: u64,
+    },
+    DeterminingBuildConfiguration,
+    BuildConfigDetermined {
+        config: BuildConfig,
+    },
+    InitiatingBuild {
+        vars: wasmer_backend_api::types::DeployViaAutobuildVars,
+    },
+    StreamingAutobuildLogs {
+        build_id: String,
+    },
+    AutobuildLog {
+        log: AutobuildLog,
+    },
+    Finished,
+}
+
+/// Errors that can occur during remote deployments.
+#[derive(Debug, Error)]
+pub enum DeployRemoteError {
+    #[error("deployment directory '{0}' does not exist")]
+    MissingDeploymentDirectory(String),
+    #[error("owner must be specified for remote deployments")]
+    MissingOwner,
+    #[error("remote deployments require `app.yaml` to define either an app name or an app_id")]
+    MissingAppIdentifier,
+    #[error("remote deployment request was rejected by the API")]
+    RequestRejected,
+    #[error("remote deployment failed: {0}")]
+    DeploymentFailed(String),
+    // TODO: should not use anyhow here... but backend-api crate does.
+    #[error("backend API error: {0}")]
+    Api(anyhow::Error),
+    #[error(transparent)]
+    Http(#[from] reqwest::Error),
+    #[error("remote deployment completed but no app version was returned")]
+    MissingAppVersion,
+    #[error("remote deployment stream ended without a completion event")]
+    MissingCompletionEvent,
+    #[error("zip archive creation failed: {0}")]
+    ZipCreation(anyhow::Error),
+    #[error("unexpected error: {0}")]
+    Other(Box<dyn std::error::Error + Send + Sync>),
+}
+
+/// Deploy an application using the remote autobuild zip upload flow.
+///
+/// It will build a ZIP archive of the specified `base_dir`, upload it to Wasmer,
+/// and request an autobuild deployment.
+///
+/// The Wasmer backend will handle building and deploying the application.
+pub async fn deploy_app_remote<F>(
+    client: &WasmerClient,
+    opts: DeployRemoteOpts,
+    base_dir: &Path,
+    mut on_progress: F,
+) -> Result<DeployAppVersion, DeployRemoteError>
+where
+    F: FnMut(DeployRemoteEvent) + Send,
+{
+    if !base_dir.is_dir() {
+        return Err(DeployRemoteError::MissingDeploymentDirectory(
+            base_dir.display().to_string(),
+        ));
+    }
+
+    let app = opts.app;
+    let owner = opts
+        .owner
+        .clone()
+        .or_else(|| app.owner.clone())
+        .ok_or(DeployRemoteError::MissingOwner)?;
+
+    let app_name = app.name.clone();
+    let app_id = app.app_id.clone();
+    if app_name.is_none() && app_id.is_none() {
+        return Err(DeployRemoteError::MissingAppIdentifier);
+    }
+
+    on_progress(DeployRemoteEvent::CreatingArchive {
+        path: base_dir.to_path_buf(),
+    });
+
+    let archive = tokio::task::spawn_blocking({
+        let base_dir = base_dir.to_path_buf();
+        move || create_zip_archive(&base_dir)
+    })
+    .await
+    .map_err(|e| DeployRemoteError::Other(e.into()))?
+    .map_err(DeployRemoteError::ZipCreation)?;
+    on_progress(DeployRemoteEvent::ArchiveCreated {
+        file_count: archive.file_count,
+        archive_size: archive.bytes.len() as u64,
+    });
+
+    let UploadArchive { bytes, .. } = archive;
+
+    let base_for_filename = app_name.as_deref().or(app_id.as_deref()).unwrap();
+    let filename = format!("{}-upload.zip", sanitize_archive_name(base_for_filename));
+
+    on_progress(DeployRemoteEvent::GeneratingUploadUrl);
+
+    let signed_url = wasmer_backend_api::query::generate_upload_url(
+        client,
+        &filename,
+        app_name.as_deref(),
+        None,
+        Some(300),
+    )
+    .await
+    .map_err(DeployRemoteError::Api)?;
+
+    on_progress(DeployRemoteEvent::UploadArchiveStart {
+        archive_size: bytes.len() as u64,
+    });
+
+    let http_client = reqwest::Client::builder()
+        .connect_timeout(Duration::from_secs(10))
+        .build()
+        .map_err(|e| DeployRemoteError::Other(e.into()))?;
+
+    tracing::debug!("uploading archive to signed URL: {}", signed_url.url);
+    http_client
+        .put(&signed_url.url)
+        .header(CONTENT_TYPE, "application/zip")
+        .body(bytes)
+        .send()
+        .await?
+        .error_for_status()?;
+
+    let upload_url = signed_url.url;
+    on_progress(DeployRemoteEvent::DeterminingBuildConfiguration);
+    let config_res =
+        wasmer_backend_api::query::autobuild_config_for_zip_upload(client, &upload_url)
+            .await
+            .context("failed to query autobuild config for uploaded archive")
+            .map_err(DeployRemoteError::Api)?
+            .context("no autobuild config found for uploaded archive")
+            .map_err(DeployRemoteError::Api)?;
+    let config = config_res
+        .build_config
+        .context(
+            "Could not determine appropriate build config - project does not seem to be supported.",
+        )
+        .map_err(DeployRemoteError::Api)?;
+    tracing::debug!(?config, "determined build config");
+    on_progress(DeployRemoteEvent::BuildConfigDetermined {
+        config: config.clone(),
+    });
+
+    let app_id_value = app_id.as_ref().map(|id| Id::from(id.clone()));
+    let domains: Option<Vec<Option<String>>> = app
+        .domains
+        .clone()
+        .map(|d| d.into_iter().map(Some).collect::<Vec<_>>())
+        .filter(|d| !d.is_empty());
+
+    let vars = wasmer_backend_api::types::DeployViaAutobuildVars {
+        repo_url: None,
+        upload_url: Some(upload_url),
+        app_name: app_name.clone(),
+        app_id: app_id_value,
+        owner: Some(owner),
+        build_cmd: Some(String::new()),
+        install_cmd: Some(String::new()),
+        enable_database: Some(false),
+        secrets: Some(vec![]),
+        extra_data: None,
+        params: None,
+        managed: None,
+        kind: None,
+        wait_for_screenshot_generation: Some(false),
+        region: None,
+        branch: None,
+        allow_existing_app: Some(true),
+        jobs: None,
+        domains,
+        client_mutation_id: None,
+    };
+    on_progress(DeployRemoteEvent::InitiatingBuild { vars: vars.clone() });
+    let deploy_response = wasmer_backend_api::query::deploy_via_autobuild(client, vars)
+        .await
+        .map_err(DeployRemoteError::Api)?
+        .context("deployViaAutobuild mutation did not return data")
+        .map_err(DeployRemoteError::Api)?;
+
+    if !deploy_response.success {
+        return Err(DeployRemoteError::RequestRejected);
+    }
+
+    let build_id = deploy_response.build_id.0;
+
+    on_progress(DeployRemoteEvent::StreamingAutobuildLogs {
+        build_id: build_id.clone(),
+    });
+
+    let mut final_version: Option<DeployAppVersion> = None;
+    'OUTER: loop {
+        let mut stream = wasmer_backend_api::subscription::autobuild_deployment(client, &build_id)
+            .await
+            .map_err(DeployRemoteError::Api)?;
+
+        while let Some(event) = stream.next().await {
+            tracing::debug!(?event, "received autobuild event");
+            let event = event.map_err(|err| DeployRemoteError::Other(err.into()))?;
+            if let Some(data) = event.data {
+                if let Some(log) = data.autobuild_deployment {
+                    on_progress(DeployRemoteEvent::AutobuildLog { log: log.clone() });
+                    let message = log.message.clone();
+                    let kind = log.kind;
+
+                    match kind {
+                        AutoBuildDeployAppLogKind::Failed => {
+                            let msg = message.unwrap_or_else(|| "remote deployment failed".into());
+                            return Err(DeployRemoteError::DeploymentFailed(msg));
+                        }
+                        AutoBuildDeployAppLogKind::Complete => {
+                            let version = log
+                                .app_version
+                                .ok_or(DeployRemoteError::MissingAppVersion)?;
+
+                            final_version = Some(version);
+                            break 'OUTER;
+                        }
+                        _ => {}
+                    }
+                }
+            }
+        }
+
+        if final_version.is_some() {
+            break;
+        }
+        tracing::warn!("autobuild event stream ended, reconnecting...");
+    }
+
+    let version = final_version.ok_or(DeployRemoteError::MissingCompletionEvent)?;
+
+    on_progress(DeployRemoteEvent::Finished);
+
+    Ok(version)
+}
+
+struct UploadArchive {
+    bytes: Vec<u8>,
+    file_count: usize,
+}
+
+fn create_zip_archive(base_dir: &Path) -> Result<UploadArchive, anyhow::Error> {
+    let mut file_count = 0usize;
+    let mut writer = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
+
+    let walker = {
+        let mut b = ignore::WalkBuilder::new(base_dir);
+
+        b.standard_filters(true)
+            .ignore(true)
+            .git_ignore(true)
+            .git_exclude(true)
+            .git_global(true)
+            .require_git(true)
+            .parents(true)
+            .follow_links(false);
+
+        // Ignore .shipit directories, since they are for local use only.
+        let mut overrides = ignore::overrides::OverrideBuilder::new(".");
+        overrides.add("!.shipit").expect("valid override");
+        b.overrides(overrides.build()?);
+
+        b.build()
+    };
+
+    let entries = walker.into_iter();
+    for entry in entries {
+        let entry = entry?;
+
+        let ty = entry.file_type().ok_or_else(|| {
+            anyhow::anyhow!(
+                "failed to determine file type for '{}'",
+                entry.path().display()
+            )
+        })?;
+
+        let rel_path = entry.path().strip_prefix(base_dir)?;
+
+        if ty.is_symlink() {
+            bail!(
+                "cannot deploy projects containing symbolic links (found '{}')",
+                rel_path.display()
+            );
+        }
+
+        let rel_str = rel_path.to_string_lossy().replace('\\', "/");
+
+        if ty.is_dir() {
+            writer.add_directory(format!("{rel_str}/"), SimpleFileOptions::default())?;
+        } else if ty.is_file() {
+            file_count += 1;
+            writer.start_file(
+                rel_str,
+                SimpleFileOptions::default().compression_method(CompressionMethod::Deflated),
+            )?;
+            let mut file = std::fs::File::open(entry.path())?;
+            std::io::copy(&mut file, &mut writer)?;
+        }
+    }
+
+    let cursor = writer.finish()?;
+    let bytes = cursor.into_inner();
+
+    Ok(UploadArchive { bytes, file_count })
+}
+
+fn sanitize_archive_name(input: &str) -> String {
+    let slug = input
+        .chars()
+        .map(|c| {
+            if c.is_ascii_alphanumeric() {
+                c.to_ascii_lowercase()
+            } else {
+                '-'
+            }
+        })
+        .collect::<String>();
+
+    let slug = slug.trim_matches('-');
+
+    if slug.is_empty() {
+        "app".to_string()
+    } else {
+        slug.to_string()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::{collections::HashSet, fs, io::Cursor, path::Path};
+    use tempfile::TempDir;
+
+    #[test]
+    fn create_zip_archive_respects_ignore_files() -> anyhow::Result<()> {
+        let project = create_sample_project()?;
+        let archive = create_zip_archive(project.path())?;
+
+        let names = archive_file_names(&archive.bytes)?;
+
+        assert!(names.contains("app.yaml"));
+        assert!(names.contains("keep_dir/keep.txt"));
+        // .wasmerignore should *not* be taken into account for remote builds
+        assert!(names.contains("custom.txt"));
+        assert!(!names.contains("ignored.txt"));
+        assert!(!names.contains("ignored_dir/file.txt"));
+
+        Ok(())
+    }
+
+    fn archive_file_names(bytes: &[u8]) -> anyhow::Result<HashSet<String>> {
+        let cursor = Cursor::new(bytes);
+        let mut archive = zip::ZipArchive::new(cursor)?;
+        let mut names = HashSet::new();
+
+        for idx in 0..archive.len() {
+            let file = archive.by_index(idx)?;
+            names.insert(file.name().to_string());
+        }
+
+        Ok(names)
+    }
+
+    fn create_sample_project() -> anyhow::Result<TempDir> {
+        let dir = tempfile::tempdir()?;
+        populate_project(dir.path())?;
+        Ok(dir)
+    }
+
+    fn populate_project(base: &Path) -> anyhow::Result<()> {
+        fs::create_dir_all(base.join(".git"))?;
+        fs::write(base.join("app.yaml"), "name = \"demo\"\n")?;
+        fs::write(base.join(".gitignore"), "ignored.txt\nignored_dir/\n")?;
+        fs::write(base.join(".wasmerignore"), "custom.txt\n")?;
+        fs::write(base.join("ignored.txt"), "ignore me")?;
+        fs::write(base.join("custom.txt"), "ignore me too")?;
+        fs::write(base.join("keep.txt"), "keep me")?;
+        fs::create_dir_all(base.join("ignored_dir"))?;
+        fs::write(base.join("ignored_dir/file.txt"), "ignored dir file")?;
+        fs::create_dir_all(base.join("keep_dir"))?;
+        fs::write(base.join("keep_dir/keep.txt"), "keep dir file")?;
+        Ok(())
+    }
+}
diff --git a/lib/sdk/src/app/mod.rs b/lib/sdk/src/app/mod.rs
new file mode 100644
index 0000000000..2b945590be
--- /dev/null
+++ b/lib/sdk/src/app/mod.rs
@@ -0,0 +1,4 @@
+//! Provides tooling related to apps deployed on Wasmer Edge.
+
+pub mod deploy;
+pub mod deploy_remote_build;
diff --git a/lib/sdk/src/lib.rs b/lib/sdk/src/lib.rs
new file mode 100644
index 0000000000..49d25a06ae
--- /dev/null
+++ b/lib/sdk/src/lib.rs
@@ -0,0 +1,4 @@
+//! wasmer-sdk is a utility library for interacting with the Wasmer ecosystem.
+
+pub mod app;
+pub mod package;
diff --git a/lib/sdk/src/package/mod.rs b/lib/sdk/src/package/mod.rs
new file mode 100644
index 0000000000..ffd605679b
--- /dev/null
+++ b/lib/sdk/src/package/mod.rs
@@ -0,0 +1,3 @@
+//! Provides functionality for Wasmer packages.
+
+pub mod publish;
diff --git a/lib/sdk/src/package/publish.rs b/lib/sdk/src/package/publish.rs
new file mode 100644
index 0000000000..917c4684fa
--- /dev/null
+++ b/lib/sdk/src/package/publish.rs
@@ -0,0 +1,381 @@
+//! Provides package publishing functionality.
+
+use std::{
+    path::{Path, PathBuf},
+    time::Duration,
+};
+
+use anyhow::{self, Context as _};
+use futures_util::StreamExt;
+use semver::Version;
+use sha2::{Digest, Sha256};
+use thiserror::Error;
+use toml;
+
+use wasmer_backend_api::WasmerClient;
+use wasmer_config::package::{Manifest, NamedPackageId, PackageHash, PackageIdent};
+use wasmer_package::package::{Package, WalkBuilderFactory};
+
+/// Conditions that can be waited on after publishing a package.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum PublishWait {
+    /// Do not wait for the package to be processed.
+    None,
+    /// Wait until the container (webc) is available.
+    Container,
+    /// Wait until native executables are available.
+    NativeExecutables,
+    /// Wait until bindings are available.
+    Bindings,
+    /// Wait until everything is available.
+    All,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct WaitPackageState {
+    container: bool,
+    native_executables: bool,
+    bindings: bool,
+}
+
+impl WaitPackageState {
+    fn from_wait(w: PublishWait) -> Self {
+        match w {
+            PublishWait::None => Self {
+                container: false,
+                native_executables: false,
+                bindings: false,
+            },
+            PublishWait::Container => Self {
+                container: true,
+                native_executables: false,
+                bindings: false,
+            },
+            PublishWait::NativeExecutables => Self {
+                container: true,
+                native_executables: true,
+                bindings: false,
+            },
+            PublishWait::Bindings => Self {
+                container: true,
+                native_executables: false,
+                bindings: true,
+            },
+            PublishWait::All => Self {
+                container: true,
+                native_executables: true,
+                bindings: true,
+            },
+        }
+    }
+
+    fn is_any(&self) -> bool {
+        self.container || self.native_executables || self.bindings
+    }
+}
+
+/// Progress events generated during the publish process.
+#[derive(Debug, Clone)]
+pub enum PublishProgress {
+    Building,
+    Uploading { uploaded: u64, total: u64 },
+    Tagging,
+    Waiting(PublishWait),
+}
+
+/// Options controlling the publish process.
+#[derive(Debug, Clone)]
+pub struct PublishOptions {
+    pub namespace: Option<String>,
+    pub name: Option<String>,
+    pub version: Option<Version>,
+    pub timeout: Duration,
+    pub wait: PublishWait,
+    pub walker_factory: WalkBuilderFactory,
+}
+
+impl Default for PublishOptions {
+    fn default() -> Self {
+        Self {
+            namespace: None,
+            name: None,
+            version: None,
+            timeout: Duration::from_secs(60 * 5),
+            wait: PublishWait::None,
+            walker_factory: wasmer_package::package::wasmer_ignore_walker(),
+        }
+    }
+}
+
+/// Errors that may occur during package publishing.
+#[derive(Debug, Error)]
+#[non_exhaustive]
+pub enum PackagePublishError {
+    #[error("manifest not found at {0}")]
+    ManifestNotFound(PathBuf),
+    #[error("failed to read manifest: {0}")]
+    ManifestRead(#[from] std::io::Error),
+    #[error("failed to parse manifest: {0}")]
+    ManifestParse(#[from] toml::de::Error),
+    #[error("package build error: {0}")]
+    PackageBuild(#[from] wasmer_package::package::WasmerPackageError),
+    #[error("backend API error: {0}")]
+    Api(#[from] anyhow::Error),
+    #[error("unexpected error: {0}")]
+    Other(Box<dyn std::error::Error + Send + Sync>),
+}
+
+/// Publish a package described by the manifest at `manifest_path`.
+///
+/// `progress` will be called with updates about the publishing process.
+pub async fn publish_package_directory<F>(
+    client: &WasmerClient,
+    path: &Path,
+    opts: PublishOptions,
+    mut progress: F,
+) -> Result<PackageIdent, PackagePublishError>
+where
+    F: FnMut(PublishProgress) + Send,
+{
+    progress(PublishProgress::Building);
+
+    let manifest_path = if path.is_dir() {
+        path.join("wasmer.toml")
+    } else {
+        path.to_path_buf()
+    };
+
+    let (manifest_str, manifest, bytes, hash) = tokio::task::spawn_blocking({
+        let manifest_path = manifest_path.clone();
+        move || {
+            let manifest_str = std::fs::read_to_string(&manifest_path).map_err(|e| {
+                if e.kind() == std::io::ErrorKind::NotFound {
+                    PackagePublishError::ManifestNotFound(manifest_path.clone())
+                } else {
+                    PackagePublishError::ManifestRead(e)
+                }
+            })?;
+            let manifest: Manifest = toml::from_str(&manifest_str)?;
+
+            let package = Package::from_manifest_with_walker(&manifest_path, opts.walker_factory)?;
+            let bytes = package.serialize()?;
+            let hash_bytes: [u8; 32] = Sha256::digest(&bytes).into();
+            let hash = PackageHash::from_sha256_bytes(hash_bytes);
+
+            Ok::<_, PackagePublishError>((manifest_str, manifest, bytes, hash))
+        }
+    })
+    .await
+    .map_err(|e| PackagePublishError::Other(Box::new(e)))??;
+
+    let total = bytes.len() as u64;
+
+    // Determine namespace/name from opts or manifest
+    let (ns, name) = {
+        let manifest_pkg = manifest.package.as_ref();
+        let parsed = manifest_pkg.and_then(|p| p.name.as_deref());
+        let manifest_ns = parsed.and_then(|n| n.split('/').next());
+        let manifest_name = parsed.and_then(|n| n.split('/').nth(1));
+        let namespace = opts
+            .namespace
+            .clone()
+            .or_else(|| manifest_ns.map(|s| s.to_string()))
+            .ok_or_else(|| PackagePublishError::Api(anyhow::anyhow!("namespace missing")))?;
+        let name = opts
+            .name
+            .clone()
+            .or_else(|| manifest_name.map(|s| s.to_string()));
+        (namespace, name)
+    };
+
+    // Determine if push needed
+    let push_needed = wasmer_backend_api::query::get_package_release(client, &hash.to_string())
+        .await
+        .map_err(PackagePublishError::Api)?
+        .is_none();
+    if push_needed {
+        let hash_string = hash.to_string();
+        let signed_url = wasmer_backend_api::query::get_signed_url_for_package_upload(
+            client,
+            Some(60 * 30),
+            Some(hash_string.trim_start_matches("sha256:")),
+            None,
+            None,
+        )
+        .await
+        .map_err(PackagePublishError::Api)?
+        .ok_or_else(|| anyhow::anyhow!("backend did not return upload url"))?
+        .url;
+
+        // upload bytes in chunks
+        let http = reqwest::Client::builder()
+            .timeout(opts.timeout)
+            .build()
+            .map_err(|e| PackagePublishError::Api(e.into()))?;
+
+        let total_len = bytes.len();
+        let resp = http
+            .post(&signed_url)
+            .header(reqwest::header::CONTENT_LENGTH, "0")
+            .header(reqwest::header::CONTENT_TYPE, "application/octet-stream")
+            .header("x-goog-resumable", "start")
+            .send()
+            .await
+            .map_err(|e| PackagePublishError::Api(e.into()))?
+            .error_for_status()
+            .map_err(|e| PackagePublishError::Api(e.into()))?;
+
+        let session_url = resp
+            .headers()
+            .get(reqwest::header::LOCATION)
+            .ok_or_else(|| {
+                PackagePublishError::Api(anyhow::anyhow!(
+                    "upload server did not provide session URL"
+                ))
+            })?
+            .to_str()
+            .map_err(|e| PackagePublishError::Api(e.into()))?
+            .to_string();
+
+        progress(PublishProgress::Uploading { uploaded: 0, total });
+        let res = http
+            .put(&session_url)
+            .header(reqwest::header::CONTENT_TYPE, "application/octet-stream")
+            .header(reqwest::header::CONTENT_LENGTH, total_len)
+            .body(bytes)
+            .send()
+            .await
+            .map_err(|e| PackagePublishError::Api(e.into()))?
+            .error_for_status()
+            .map_err(|e| PackagePublishError::Api(e.into()))?;
+        drop(res);
+        progress(PublishProgress::Uploading {
+            uploaded: total,
+            total,
+        });
+
+        wasmer_backend_api::query::push_package_release(
+            client,
+            name.as_deref(),
+            &ns,
+            &session_url,
+            Some(manifest.package.as_ref().map_or(true, |p| p.private)),
+        )
+        .await
+        .map_err(PackagePublishError::Api)?
+        .ok_or_else(|| anyhow::anyhow!("push response empty"))?;
+    }
+
+    // Tagging
+    progress(PublishProgress::Tagging);
+    let package_release = wasmer_backend_api::query::get_package_release(client, &hash.to_string())
+        .await
+        .map_err(PackagePublishError::Api)?
+        .ok_or_else(|| anyhow::anyhow!("package not found after push"))?;
+    let version = opts
+        .version
+        .or_else(|| manifest.package.as_ref().and_then(|p| p.version.clone()))
+        .ok_or_else(|| PackagePublishError::Api(anyhow::anyhow!("package version missing")))?;
+
+    let package_name =
+        name.ok_or_else(|| PackagePublishError::Api(anyhow::anyhow!("package name missing")))?;
+    let id = NamedPackageId {
+        full_name: format!("{ns}/{package_name}"),
+        version,
+    };
+
+    let readme_contents =
+        if let Some(readme_rel) = manifest.package.as_ref().and_then(|p| p.readme.as_ref()) {
+            let parent = manifest_path.parent().ok_or_else(|| {
+                PackagePublishError::Api(anyhow::anyhow!(
+                    "manifest path '{}' has no parent directory",
+                    manifest_path.display()
+                ))
+            })?;
+            let readme_path = parent.join(readme_rel);
+            Some(
+                std::fs::read_to_string(&readme_path)
+                    .with_context(|| format!("failed to read README at {}", readme_path.display()))
+                    .map_err(PackagePublishError::Api)?,
+            )
+        } else {
+            None
+        };
+
+    wasmer_backend_api::query::tag_package_release(
+        client,
+        manifest
+            .package
+            .as_ref()
+            .and_then(|p| p.description.as_deref()),
+        manifest
+            .package
+            .as_ref()
+            .and_then(|p| p.homepage.as_deref()),
+        manifest.package.as_ref().and_then(|p| p.license.as_deref()),
+        manifest
+            .package
+            .as_ref()
+            .and_then(|p| p.license_file.as_ref())
+            .map(|p| p.to_string_lossy())
+            .as_deref(),
+        Some(&manifest_str),
+        &id.full_name,
+        Some(&ns),
+        &package_release.id,
+        Some(manifest.package.as_ref().map_or(true, |p| p.private)),
+        readme_contents.as_deref(),
+        manifest
+            .package
+            .as_ref()
+            .and_then(|p| p.repository.as_deref()),
+        &id.version.to_string(),
+    )
+    .await
+    .map_err(PackagePublishError::Api)?
+    .ok_or_else(|| anyhow::anyhow!("tag package failed"))?;
+
+    if let PublishWait::None = opts.wait {
+    } else {
+        progress(PublishProgress::Waiting(opts.wait));
+        wait_package(client, opts.wait, package_release.id.clone(), opts.timeout).await?;
+    }
+
+    Ok(PackageIdent::Named(id.into()))
+}
+
+async fn wait_package(
+    client: &WasmerClient,
+    to_wait: PublishWait,
+    package_version_id: wasmer_backend_api::types::Id,
+    timeout: Duration,
+) -> Result<(), anyhow::Error> {
+    if let PublishWait::None = to_wait {
+        return Ok(());
+    }
+
+    let mut stream =
+        wasmer_backend_api::subscription::package_version_ready(client, package_version_id.inner())
+            .await?;
+    let mut state = WaitPackageState::from_wait(to_wait);
+    let deadline = std::time::Instant::now() + timeout;
+    while state.is_any() {
+        if std::time::Instant::now() > deadline {
+            anyhow::bail!("timed out waiting for package version");
+        }
+        let data = tokio::time::timeout_at(deadline.into(), stream.next()).await?;
+        let data = match data {
+            Some(d) => d?,
+            None => break,
+        };
+        if let Some(msg) = data.data {
+            use wasmer_backend_api::types::PackageVersionState as S;
+            match msg.package_version_ready.state {
+                S::WebcGenerated => state.container = false,
+                S::BindingsGenerated => state.bindings = false,
+                S::NativeExesGenerated => state.native_executables = false,
+            }
+        }
+    }
+    Ok(())
+}
diff --git a/lib/sdk/tests/publish_integration.rs b/lib/sdk/tests/publish_integration.rs
new file mode 100644
index 0000000000..fedde04385
--- /dev/null
+++ b/lib/sdk/tests/publish_integration.rs
@@ -0,0 +1,71 @@
+use std::fs;
+use std::time::Duration;
+
+use rand::Rng as _;
+use semver::Version;
+use tempfile::tempdir;
+use url::Url;
+
+use wasmer_backend_api::WasmerClient;
+
+use wasmer_sdk::package::publish::{publish_package_directory, PublishOptions, PublishWait};
+
+/// Integration test for the package publishing logic.
+#[tokio::test]
+#[ignore]
+async fn publish_package_integration() -> anyhow::Result<()> {
+    // Use provided registry and token credentials.
+    let registry = std::env::var("WASMER_REGISTRY")
+        .unwrap_or_else(|_| "https://registry.wasmer.wtf/graphql".to_string());
+    let token = std::env::var("WASMER_TOKEN").unwrap();
+
+    // Construct the API client.
+    let registry_url = Url::parse(&registry)?;
+    let client = WasmerClient::new(registry_url, "sdk-integration-test")?.with_auth_token(token);
+
+    // Prepare a temporary directory for the package.
+    let tempdir = tempdir()?;
+    let path = tempdir.path();
+
+    let user = wasmer_backend_api::query::current_user(&client)
+        .await?
+        .expect("no current user");
+
+    // Generate a random number
+    let name = format!("t-{:010}", rand::rng().random_range(0u64..9999999999));
+
+    let manifest = r#"
+[dependencies]
+"wasmer/static-web-server" = "^1"
+
+[fs]
+"/public" = "public"
+
+[[command]]
+name = "webserver"
+module = "wasmer/static-web-server:webserver"
+runner = "https://webc.org/runner/wasi"
+
+[command.annotations.wasi]
+main-args = ["--root", "/public"]
+"#;
+
+    fs::write(path.join("wasmer.toml"), manifest)?;
+
+    std::fs::create_dir(path.join("public"))?;
+    fs::write(path.join("public/index.html"), "<h1>Hello, World!</h1>")?;
+
+    // Configure publishing options.
+    let opts = PublishOptions {
+        namespace: Some(user.username.clone()),
+        name: Some(name),
+        version: Some(Version::parse("0.0.1")?),
+        timeout: Duration::from_secs(180),
+        wait: PublishWait::None,
+        walker_factory: wasmer_package::package::wasmer_ignore_walker(),
+    };
+
+    // Execute the publish logic.
+    publish_package_directory(&client, path, opts, |_| {}).await?;
+    Ok(())
+}
diff --git a/lib/swift/.gitignore b/lib/swift/.gitignore
new file mode 100644
index 0000000000..a89976c057
--- /dev/null
+++ b/lib/swift/.gitignore
@@ -0,0 +1,3 @@
+/target
+/generated
+/WasmerSwift
diff --git a/lib/swift/Cargo.toml b/lib/swift/Cargo.toml
new file mode 100644
index 0000000000..a1ac910291
--- /dev/null
+++ b/lib/swift/Cargo.toml
@@ -0,0 +1,37 @@
+[package]
+name = "wasmer-swift"
+version = "0.601.0"
+edition = "2021"
+description = "Experimental wasmer bindings for swift"
+license = "MIT"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+crate-type = ["staticlib", "lib"]
+name = "wasmer_swift"
+
+[dependencies]
+thiserror.workspace = true
+tokio = { version = "1.28.1", features = ["rt"], default-features = false }
+uniffi = "0.27"
+virtual-fs = { path = "../virtual-fs", version = "=0.601.0", default-features = false, features = [
+	"webc-fs",
+] }
+wasmer = { version = "=6.1.0", path = "../api", default-features = false, features = [
+	"wamr",
+	"std",
+] }
+wasmer-wasix = { version = "=0.601.0", path = "../wasix", default-features = false, features = [
+	"sys",
+] }
+webc.workspace = true
+wasmer-package.workspace = true
+
+
+[build-dependencies]
+uniffi = { version = "0.27", features = ["build"] }
+
+[package.metadata.docs.rs]
+features = ["wasmer/sys", "wasmer/compiler"]
+rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/swift/build.rs b/lib/swift/build.rs
new file mode 100644
index 0000000000..145281cf96
--- /dev/null
+++ b/lib/swift/build.rs
@@ -0,0 +1,3 @@
+fn main() {
+    uniffi::generate_scaffolding("./src/lib.udl").unwrap();
+}
diff --git a/lib/swift/src/lib.rs b/lib/swift/src/lib.rs
new file mode 100644
index 0000000000..ff01475e7b
--- /dev/null
+++ b/lib/swift/src/lib.rs
@@ -0,0 +1,79 @@
+use std::sync::Arc;
+use tokio::runtime::Runtime;
+use virtual_fs::{AsyncReadExt, AsyncSeekExt};
+use wasmer_package::utils::from_bytes;
+use wasmer_wasix::{
+    bin_factory::BinaryPackage,
+    runners::{
+        wasi::{RuntimeOrEngine, WasiRunner},
+        Runner,
+    },
+    runtime::{package_loader::BuiltinPackageLoader, task_manager::tokio::TokioTaskManager},
+    PluggableRuntime,
+};
+
+uniffi::setup_scaffolding!();
+
+macro_rules! err {
+    ($e:expr) => {
+        match $e {
+            Ok(r) => r,
+            Err(e) => {
+                println!("{e}");
+                return Err(WasmerError::Err { e: e.to_string() });
+            }
+        }
+    };
+}
+
+#[derive(Debug, uniffi::Error, thiserror::Error)]
+pub enum WasmerError {
+    #[error("An error occurred during execution: {e:?}")]
+    Err { e: String },
+}
+
+#[uniffi::export]
+pub fn run_package(webc_bytes: Vec<u8>, args: Vec<String>) -> Result<String, WasmerError> {
+    let tokio_rt = Runtime::new().unwrap();
+    let _enter = tokio_rt.enter();
+    let container = err!(from_bytes(webc_bytes));
+    let tasks = TokioTaskManager::new(tokio_rt.handle().clone());
+    let tasks = Arc::new(tasks);
+    let mut rt = PluggableRuntime::new(Arc::clone(&tasks) as Arc<_>);
+    rt.set_package_loader(BuiltinPackageLoader::new());
+
+    let pkg = tokio_rt
+        .handle()
+        .block_on(async { BinaryPackage::from_webc(&container, &rt).await.unwrap() });
+
+    if pkg.entrypoint_cmd.is_none() {
+        return Ok(format!("This WEBC ({}) has no entrypoint!", pkg.id));
+    }
+
+    let entrypoint = pkg.entrypoint_cmd.clone().unwrap();
+
+    let mut stdout = virtual_fs::ArcFile::new(Box::<virtual_fs::BufferFile>::default());
+
+    let stdout_2 = stdout.clone();
+
+    let handle = std::thread::spawn(move || {
+        let _guard = tasks.runtime_handle().enter();
+        WasiRunner::new()
+            .with_args(args)
+            .with_stdin(Box::<virtual_fs::NullFile>::default())
+            .with_stdout(Box::new(stdout_2) as Box<_>)
+            .with_stderr(Box::<virtual_fs::NullFile>::default())
+            .run_command(&entrypoint, &pkg, RuntimeOrEngine::Runtime(Arc::new(rt)))
+    });
+
+    let _ = handle.join();
+
+    let mut output = Vec::new();
+
+    tokio_rt.handle().block_on(async {
+        stdout.rewind().await.unwrap();
+        stdout.read_to_end(&mut output).await.unwrap();
+    });
+
+    Ok(err!(String::from_utf8(output)))
+}
diff --git a/lib/swift/src/lib.udl b/lib/swift/src/lib.udl
new file mode 100644
index 0000000000..1ada0478ec
--- /dev/null
+++ b/lib/swift/src/lib.udl
@@ -0,0 +1,2 @@
+// Keep this namespace, even when empty - otherwise binding generation will throw an error!
+namespace wasmer_swift { };
diff --git a/lib/sys-utils/Cargo.toml b/lib/sys-utils/Cargo.toml
index d0c1ba6a01..5ce20af23b 100644
--- a/lib/sys-utils/Cargo.toml
+++ b/lib/sys-utils/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "wasmer-sys-utils"
-version = "0.27.0"
+version = "0.601.0"
 description = "Wasmer utilities for a sys environment."
 categories = ["wasm"]
 keywords = ["wasm", "webassembly"]
@@ -12,20 +12,24 @@ repository.workspace = true
 rust-version.workspace = true
 
 [dependencies]
-wasmer = { path = "../api", version = "=4.3.7", default-features = false, features = ["sys", "compiler"] }
-wasmer-vm = { path = "../vm", version = "=4.3.7" }
-wasmer-types = { path = "../types", version = "=4.3.7" }
-region = { version = "3.0" }
-tracing = "0.1.37"
+wasmer = { path = "../api", version = "=6.1.0", default-features = false, features = ["sys", "compiler"] }
+wasmer-vm = { path = "../vm", version = "=6.1.0" }
+wasmer-types = { path = "../types", version = "=6.1.0" }
+region.workspace = true
+tracing.workspace = true
 
 [target.'cfg(unix)'.dependencies]
 libc.workspace = true
 
 [dev-dependencies]
 wasmer-wasix.workspace = true
-wasmer = { path = "../api", version = "=4.3.7", default-features = false, features = ["sys", "compiler", "cranelift"] }
-tracing-subscriber = { version = "0.3.16", features = ["fmt"] }
-tracing = "0.1.37"
+wasmer = { path = "../api", version = "=6.1.0", default-features = false, features = ["sys", "compiler", "cranelift"] }
+tracing-subscriber = { workspace = true, features = ["fmt"] }
+tracing.workspace = true
 
 [package.metadata.docs.rs]
 rustc-args = ["--cfg", "docsrs"]
+
+[features]
+default = []
+tracing = []
diff --git a/lib/types/Cargo.toml b/lib/types/Cargo.toml
index d36bb7fafd..39ad74aaab 100644
--- a/lib/types/Cargo.toml
+++ b/lib/types/Cargo.toml
@@ -13,24 +13,26 @@ rust-version.workspace = true
 version.workspace = true
 
 [dependencies]
-serde = { version = "1.0", features = ["derive", "rc"], optional = true, default-features = false }
-serde_bytes = { version = "0.11", optional = true }
-thiserror = "1.0"
-more-asserts = "0.2"
-indexmap = { version = "1.6" }
-rkyv = { workspace = true }
-enum-iterator = "0.7.0"
-target-lexicon = { version = "0.12.2", default-features = false }
+serde = { workspace = true, features = ["derive", "rc"], optional = true }
+serde_bytes = { workspace = true, optional = true }
+thiserror.workspace = true
+more-asserts.workspace = true
+indexmap.workspace = true
+rkyv.workspace = true
+enum-iterator.workspace = true
+target-lexicon = { workspace = true}
 enumset.workspace = true
-bytecheck = "0.6.8"
+bytecheck.workspace = true
 xxhash-rust = { version = "0.8.8", features = ["xxh64"] }
-sha2 = { version = "0.10" }
-hex = { version = "^0.4" }
+sha2.workspace = true
+hex.workspace = true
+loupe = { workspace = true, optional = true }
+wasmparser = { workspace = true, default-features = false, optional = true }
 
 # `rand` uses `getrandom` transitively, and to be able to
 # compile the project for `js`, we need to enable this feature
 [dependencies.getrandom]
-version = "0.2.14"
+workspace = true
 features = ["js"]
 
 [dev-dependencies]
@@ -40,7 +42,9 @@ memoffset.workspace = true
 default = ["std"]
 std = []
 core = []
-enable-serde = ["serde", "serde/std", "serde_bytes", "indexmap/serde-1"]
+enable-serde = ["serde", "serde/std", "serde_bytes", "indexmap/serde"]
+artifact-size = ["dep:loupe"]
+detect-wasm-features = ["dep:wasmparser"]
 
 [package.metadata.docs.rs]
 rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/types/src/compilation/relocation.rs b/lib/types/src/compilation/relocation.rs
deleted file mode 100644
index 0b1b1331a1..0000000000
--- a/lib/types/src/compilation/relocation.rs
+++ /dev/null
@@ -1,229 +0,0 @@
-//! Relocation is the process of assigning load addresses for position-dependent
-//! code and data of a program and adjusting the code and data to reflect the
-//! assigned addresses.
-//!
-//! [Learn more](https://en.wikipedia.org/wiki/Relocation_(computing)).
-//!
-//! Each time a `Compiler` compiles a WebAssembly function (into machine code),
-//! it also attaches if there are any relocations that need to be patched into
-//! the generated machine code, so a given frontend (JIT or native) can
-//! do the corresponding work to run it.
-
-use super::section::SectionIndex;
-use crate::entity::PrimaryMap;
-use crate::lib::std::fmt;
-use crate::lib::std::vec::Vec;
-use crate::{Addend, CodeOffset};
-use crate::{LibCall, LocalFunctionIndex};
-use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
-#[cfg(feature = "enable-serde")]
-use serde::{Deserialize, Serialize};
-
-/// Relocation kinds for every ISA.
-#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[derive(
-    RkyvSerialize, RkyvDeserialize, Archive, rkyv::CheckBytes, Copy, Clone, Debug, PartialEq, Eq,
-)]
-#[archive(as = "Self")]
-#[repr(u8)]
-pub enum RelocationKind {
-    /// absolute 4-byte
-    Abs4,
-    /// absolute 8-byte
-    Abs8,
-    /// x86 PC-relative 4-byte
-    X86PCRel4,
-    /// x86 PC-relative 8-byte
-    X86PCRel8,
-    /// x86 call to PC-relative 4-byte
-    X86CallPCRel4,
-    /// x86 call to PLT-relative 4-byte
-    X86CallPLTRel4,
-    /// x86 GOT PC-relative 4-byte
-    X86GOTPCRel4,
-    /// Arm32 call target
-    Arm32Call,
-    /// Arm64 call target
-    Arm64Call,
-    /// Arm64 movk/z part 0
-    Arm64Movw0,
-    /// Arm64 movk/z part 1
-    Arm64Movw1,
-    /// Arm64 movk/z part 2
-    Arm64Movw2,
-    /// Arm64 movk/z part 3
-    Arm64Movw3,
-    /// RISC-V PC-relative high 20bit
-    RiscvPCRelHi20,
-    /// RISC-V PC-relative low 12bit, I-type
-    RiscvPCRelLo12I,
-    /// RISC-V call target
-    RiscvCall,
-    /// Elf x86_64 32 bit signed PC relative offset to two GOT entries for GD symbol.
-    ElfX86_64TlsGd,
-    // /// Mach-O x86_64 32 bit signed PC relative offset to a `__thread_vars` entry.
-    // MachOX86_64Tlv,
-}
-
-impl fmt::Display for RelocationKind {
-    /// Display trait implementation drops the arch, since its used in contexts where the arch is
-    /// already unambiguous, e.g. clif syntax with isa specified. In other contexts, use Debug.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Self::Abs4 => write!(f, "Abs4"),
-            Self::Abs8 => write!(f, "Abs8"),
-            Self::X86PCRel4 => write!(f, "PCRel4"),
-            Self::X86PCRel8 => write!(f, "PCRel8"),
-            Self::X86CallPCRel4 => write!(f, "CallPCRel4"),
-            Self::X86CallPLTRel4 => write!(f, "CallPLTRel4"),
-            Self::X86GOTPCRel4 => write!(f, "GOTPCRel4"),
-            Self::Arm32Call | Self::Arm64Call | Self::RiscvCall => write!(f, "Call"),
-            Self::Arm64Movw0 => write!(f, "Arm64MovwG0"),
-            Self::Arm64Movw1 => write!(f, "Arm64MovwG1"),
-            Self::Arm64Movw2 => write!(f, "Arm64MovwG2"),
-            Self::Arm64Movw3 => write!(f, "Arm64MovwG3"),
-            Self::ElfX86_64TlsGd => write!(f, "ElfX86_64TlsGd"),
-            Self::RiscvPCRelHi20 => write!(f, "RiscvPCRelHi20"),
-            Self::RiscvPCRelLo12I => write!(f, "RiscvPCRelLo12I"),
-            // Self::MachOX86_64Tlv => write!(f, "MachOX86_64Tlv"),
-        }
-    }
-}
-
-/// A record of a relocation to perform.
-#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, Clone, PartialEq, Eq)]
-#[archive_attr(derive(rkyv::CheckBytes, Debug))]
-pub struct Relocation {
-    /// The relocation kind.
-    pub kind: RelocationKind,
-    /// Relocation target.
-    pub reloc_target: RelocationTarget,
-    /// The offset where to apply the relocation.
-    pub offset: CodeOffset,
-    /// The addend to add to the relocation value.
-    pub addend: Addend,
-}
-
-/// Any struct that acts like a `Relocation`.
-#[allow(missing_docs)]
-pub trait RelocationLike {
-    fn kind(&self) -> RelocationKind;
-    fn reloc_target(&self) -> RelocationTarget;
-    fn offset(&self) -> CodeOffset;
-    fn addend(&self) -> Addend;
-
-    /// Given a function start address, provide the relocation relative
-    /// to that address.
-    ///
-    /// The function returns the relocation address and the delta.
-    fn for_address(&self, start: usize, target_func_address: u64) -> (usize, u64) {
-        match self.kind() {
-            RelocationKind::Abs8
-            | RelocationKind::Arm64Movw0
-            | RelocationKind::Arm64Movw1
-            | RelocationKind::Arm64Movw2
-            | RelocationKind::Arm64Movw3
-            | RelocationKind::RiscvPCRelLo12I => {
-                let reloc_address = start + self.offset() as usize;
-                let reloc_addend = self.addend() as isize;
-                let reloc_abs = target_func_address
-                    .checked_add(reloc_addend as u64)
-                    .unwrap();
-                (reloc_address, reloc_abs)
-            }
-            RelocationKind::X86PCRel4 => {
-                let reloc_address = start + self.offset() as usize;
-                let reloc_addend = self.addend() as isize;
-                let reloc_delta_u32 = (target_func_address as u32)
-                    .wrapping_sub(reloc_address as u32)
-                    .checked_add(reloc_addend as u32)
-                    .unwrap();
-                (reloc_address, reloc_delta_u32 as u64)
-            }
-            RelocationKind::X86PCRel8 => {
-                let reloc_address = start + self.offset() as usize;
-                let reloc_addend = self.addend() as isize;
-                let reloc_delta = target_func_address
-                    .wrapping_sub(reloc_address as u64)
-                    .checked_add(reloc_addend as u64)
-                    .unwrap();
-                (reloc_address, reloc_delta)
-            }
-            RelocationKind::X86CallPCRel4 | RelocationKind::X86CallPLTRel4 => {
-                let reloc_address = start + self.offset() as usize;
-                let reloc_addend = self.addend() as isize;
-                let reloc_delta_u32 = (target_func_address as u32)
-                    .wrapping_sub(reloc_address as u32)
-                    .wrapping_add(reloc_addend as u32);
-                (reloc_address, reloc_delta_u32 as u64)
-            }
-            RelocationKind::Arm64Call
-            | RelocationKind::RiscvCall
-            | RelocationKind::RiscvPCRelHi20 => {
-                let reloc_address = start + self.offset() as usize;
-                let reloc_addend = self.addend() as isize;
-                let reloc_delta_u32 = target_func_address
-                    .wrapping_sub(reloc_address as u64)
-                    .wrapping_add(reloc_addend as u64);
-                (reloc_address, reloc_delta_u32)
-            }
-            _ => panic!("Relocation kind unsupported"),
-        }
-    }
-}
-
-impl RelocationLike for Relocation {
-    fn kind(&self) -> RelocationKind {
-        self.kind
-    }
-
-    fn reloc_target(&self) -> RelocationTarget {
-        self.reloc_target
-    }
-
-    fn offset(&self) -> CodeOffset {
-        self.offset
-    }
-
-    fn addend(&self) -> Addend {
-        self.addend
-    }
-}
-
-impl RelocationLike for ArchivedRelocation {
-    fn kind(&self) -> RelocationKind {
-        self.kind
-    }
-
-    fn reloc_target(&self) -> RelocationTarget {
-        self.reloc_target
-    }
-
-    fn offset(&self) -> CodeOffset {
-        self.offset
-    }
-
-    fn addend(&self) -> Addend {
-        self.addend
-    }
-}
-
-/// Destination function. Can be either user function or some special one, like `memory.grow`.
-#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[derive(
-    RkyvSerialize, RkyvDeserialize, Archive, rkyv::CheckBytes, Debug, Copy, Clone, PartialEq, Eq,
-)]
-#[archive(as = "Self")]
-#[repr(u8)]
-pub enum RelocationTarget {
-    /// A relocation to a function defined locally in the wasm (not an imported one).
-    LocalFunc(LocalFunctionIndex),
-    /// A compiler-generated libcall.
-    LibCall(LibCall),
-    /// Custom sections generated by the compiler
-    CustomSection(SectionIndex),
-}
-
-/// Relocations to apply to function bodies.
-pub type Relocations = PrimaryMap<LocalFunctionIndex, Vec<Relocation>>;
diff --git a/lib/types/src/entity/boxed_slice.rs b/lib/types/src/entity/boxed_slice.rs
index eca12d8918..704457eb49 100644
--- a/lib/types/src/entity/boxed_slice.rs
+++ b/lib/types/src/entity/boxed_slice.rs
@@ -24,6 +24,22 @@ where
     unused: PhantomData<K>,
 }
 
+#[cfg(feature = "artifact-size")]
+impl<K, V> loupe::MemoryUsage for BoxedSlice<K, V>
+where
+    K: EntityRef,
+    V: loupe::MemoryUsage,
+{
+    fn size_of_val(&self, tracker: &mut dyn loupe::MemoryUsageTracker) -> usize {
+        std::mem::size_of_val(self)
+            + self
+                .elems
+                .iter()
+                .map(|value| value.size_of_val(tracker) - std::mem::size_of_val(value))
+                .sum::<usize>()
+    }
+}
+
 impl<K, V> BoxedSlice<K, V>
 where
     K: EntityRef,
diff --git a/lib/types/src/entity/iter.rs b/lib/types/src/entity/iter.rs
index d1456e48ef..29a30bad5f 100644
--- a/lib/types/src/entity/iter.rs
+++ b/lib/types/src/entity/iter.rs
@@ -41,13 +41,13 @@ impl<'a, K: EntityRef, V> Iterator for Iter<'a, K, V> {
     }
 }
 
-impl<'a, K: EntityRef, V> DoubleEndedIterator for Iter<'a, K, V> {
+impl<K: EntityRef, V> DoubleEndedIterator for Iter<'_, K, V> {
     fn next_back(&mut self) -> Option<Self::Item> {
         self.enumerate.next_back().map(|(i, v)| (K::new(i), v))
     }
 }
 
-impl<'a, K: EntityRef, V> ExactSizeIterator for Iter<'a, K, V> {}
+impl<K: EntityRef, V> ExactSizeIterator for Iter<'_, K, V> {}
 
 /// Iterate over all keys in order.
 pub struct IterMut<'a, K: EntityRef, V>
@@ -81,13 +81,13 @@ impl<'a, K: EntityRef, V> Iterator for IterMut<'a, K, V> {
     }
 }
 
-impl<'a, K: EntityRef, V> DoubleEndedIterator for IterMut<'a, K, V> {
+impl<K: EntityRef, V> DoubleEndedIterator for IterMut<'_, K, V> {
     fn next_back(&mut self) -> Option<Self::Item> {
         self.enumerate.next_back().map(|(i, v)| (K::new(i), v))
     }
 }
 
-impl<'a, K: EntityRef, V> ExactSizeIterator for IterMut<'a, K, V> {}
+impl<K: EntityRef, V> ExactSizeIterator for IterMut<'_, K, V> {}
 
 /// Iterate over all keys in order.
 pub struct IntoIter<K: EntityRef, V> {
diff --git a/lib/types/src/entity/mod.rs b/lib/types/src/entity/mod.rs
index f7de0b1cfe..f4b527124c 100644
--- a/lib/types/src/entity/mod.rs
+++ b/lib/types/src/entity/mod.rs
@@ -19,7 +19,7 @@ macro_rules! entity_impl {
     ($entity:ident) => {
         impl $crate::entity::EntityRef for $entity {
             fn new(index: usize) -> Self {
-                debug_assert!(index < ($crate::lib::std::u32::MAX as usize));
+                debug_assert!(index < (u32::MAX as usize));
                 $entity(index as u32)
             }
 
@@ -30,11 +30,11 @@ macro_rules! entity_impl {
 
         impl $crate::entity::packed_option::ReservedValue for $entity {
             fn reserved_value() -> $entity {
-                $entity($crate::lib::std::u32::MAX)
+                $entity(u32::MAX)
             }
 
             fn is_reserved_value(&self) -> bool {
-                self.0 == $crate::lib::std::u32::MAX
+                self.0 == u32::MAX
             }
         }
 
@@ -42,7 +42,7 @@ macro_rules! entity_impl {
             /// Create a new instance from a `u32`.
             #[allow(dead_code)]
             pub fn from_u32(x: u32) -> Self {
-                debug_assert!(x < $crate::lib::std::u32::MAX);
+                debug_assert!(x < u32::MAX);
                 $entity(x)
             }
 
diff --git a/lib/types/src/entity/primary_map.rs b/lib/types/src/entity/primary_map.rs
index a810791331..6a93f1509a 100644
--- a/lib/types/src/entity/primary_map.rs
+++ b/lib/types/src/entity/primary_map.rs
@@ -34,7 +34,6 @@ use serde::{Deserialize, Serialize};
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 #[derive(RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(rkyv::CheckBytes))]
 pub struct PrimaryMap<K, V>
 where
     K: EntityRef,
@@ -43,6 +42,22 @@ where
     pub(crate) unused: PhantomData<K>,
 }
 
+#[cfg(feature = "artifact-size")]
+impl<K, V> loupe::MemoryUsage for PrimaryMap<K, V>
+where
+    K: EntityRef,
+    V: loupe::MemoryUsage,
+{
+    fn size_of_val(&self, tracker: &mut dyn loupe::MemoryUsageTracker) -> usize {
+        std::mem::size_of_val(self)
+            + self
+                .elems
+                .iter()
+                .map(|value| value.size_of_val(tracker) - std::mem::size_of_val(value))
+                .sum::<usize>()
+    }
+}
+
 impl<K, V> PrimaryMap<K, V>
 where
     K: EntityRef,
diff --git a/lib/types/src/entity/secondary_map.rs b/lib/types/src/entity/secondary_map.rs
index 554bc4278a..4c96199664 100644
--- a/lib/types/src/entity/secondary_map.rs
+++ b/lib/types/src/entity/secondary_map.rs
@@ -28,7 +28,6 @@ use serde::{
 /// The map does not track if an entry for a key has been inserted or not. Instead it behaves as if
 /// all keys have a default entry from the beginning.
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(rkyv::CheckBytes))]
 pub struct SecondaryMap<K, V>
 where
     K: EntityRef,
@@ -39,6 +38,22 @@ where
     pub(crate) unused: PhantomData<K>,
 }
 
+#[cfg(feature = "artifact-size")]
+impl<K, V> loupe::MemoryUsage for SecondaryMap<K, V>
+where
+    K: EntityRef,
+    V: Clone + loupe::MemoryUsage,
+{
+    fn size_of_val(&self, tracker: &mut dyn loupe::MemoryUsageTracker) -> usize {
+        std::mem::size_of_val(self)
+            + self
+                .elems
+                .iter()
+                .map(|value| value.size_of_val(tracker) - std::mem::size_of_val(value))
+                .sum::<usize>()
+    }
+}
+
 /// Shared `SecondaryMap` implementation for all value types.
 impl<K, V> SecondaryMap<K, V>
 where
diff --git a/lib/types/src/error.rs b/lib/types/src/error.rs
index 67af12987e..e72e9cf42e 100644
--- a/lib/types/src/error.rs
+++ b/lib/types/src/error.rs
@@ -294,7 +294,7 @@ mod tests {
                 assert_eq!(name, "manipulator3000");
                 assert_eq!(message, "foo");
             }
-            err => panic!("Unexpected error: {:?}", err),
+            err => panic!("Unexpected error: {err:?}"),
         }
     }
 }
diff --git a/lib/types/src/features.rs b/lib/types/src/features.rs
index 54197762db..f298151298 100644
--- a/lib/types/src/features.rs
+++ b/lib/types/src/features.rs
@@ -1,15 +1,18 @@
 use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
 #[cfg(feature = "enable-serde")]
 use serde::{Deserialize, Serialize};
+#[cfg(feature = "detect-wasm-features")]
+use wasmparser::{Parser, Payload, Validator, WasmFeatures};
 
 /// Controls which experimental features will be enabled.
 /// Features usually have a corresponding [WebAssembly proposal].
 ///
 /// [WebAssembly proposal]: https://github.com/WebAssembly/proposals
-#[derive(Clone, Debug, Eq, PartialEq, rkyv::CheckBytes)]
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[derive(RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive(as = "Self")]
+#[rkyv(derive(Debug), compare(PartialEq))]
 pub struct Features {
     /// Threads proposal should be enabled
     pub threads: bool,
@@ -60,6 +63,42 @@ impl Features {
         }
     }
 
+    /// Create a new feature set with all features enabled.
+    pub fn all() -> Self {
+        Self {
+            threads: true,
+            reference_types: true,
+            simd: true,
+            bulk_memory: true,
+            multi_value: true,
+            tail_call: true,
+            module_linking: true,
+            multi_memory: true,
+            memory64: true,
+            exceptions: true,
+            relaxed_simd: true,
+            extended_const: true,
+        }
+    }
+
+    /// Create a new feature set with all features disabled.
+    pub fn none() -> Self {
+        Self {
+            threads: false,
+            reference_types: false,
+            simd: false,
+            bulk_memory: false,
+            multi_value: false,
+            tail_call: false,
+            module_linking: false,
+            multi_memory: false,
+            memory64: false,
+            exceptions: false,
+            relaxed_simd: false,
+            extended_const: false,
+        }
+    }
+
     /// Configures whether the WebAssembly threads proposal will be enabled.
     ///
     /// The [WebAssembly threads proposal][threads] is not currently fully
@@ -232,6 +271,195 @@ impl Features {
         self.memory64 = enable;
         self
     }
+
+    /// Configures whether the WebAssembly exception-handling proposal will be enabled.
+    ///
+    /// The [WebAssembly exception-handling proposal][eh] is not currently fully
+    /// standardized and is undergoing development. Support for this feature can
+    /// be enabled through this method for appropriate WebAssembly modules.
+    ///
+    /// This is `false` by default.
+    ///
+    /// [eh]: https://github.com/webassembly/exception-handling
+    pub fn exceptions(&mut self, enable: bool) -> &mut Self {
+        self.exceptions = enable;
+        self
+    }
+
+    /// Checks if this features set contains all the features required by another set
+    pub fn contains_features(&self, required: &Self) -> bool {
+        // Check all required features
+        (!required.simd || self.simd)
+            && (!required.bulk_memory || self.bulk_memory)
+            && (!required.reference_types || self.reference_types)
+            && (!required.threads || self.threads)
+            && (!required.multi_value || self.multi_value)
+            && (!required.exceptions || self.exceptions)
+            && (!required.tail_call || self.tail_call)
+            && (!required.module_linking || self.module_linking)
+            && (!required.multi_memory || self.multi_memory)
+            && (!required.memory64 || self.memory64)
+            && (!required.relaxed_simd || self.relaxed_simd)
+            && (!required.extended_const || self.extended_const)
+    }
+
+    #[cfg(feature = "detect-wasm-features")]
+    /// Detects required WebAssembly features from a module binary.
+    ///
+    /// This method analyzes a WebAssembly module's binary to determine which
+    /// features it requires. It does this by:
+    /// 1. Attempting to validate the module with different feature sets
+    /// 2. Analyzing validation errors to detect required features
+    /// 3. Parsing the module to detect certain common patterns
+    ///
+    /// # Arguments
+    ///
+    /// * `wasm_bytes` - The binary content of the WebAssembly module
+    ///
+    /// # Returns
+    ///
+    /// A new `Features` instance with the detected features enabled.
+    pub fn detect_from_wasm(wasm_bytes: &[u8]) -> Result<Self, wasmparser::BinaryReaderError> {
+        let mut features = Self::default();
+
+        // Simple test for exceptions - try to validate with exceptions disabled
+        let mut exceptions_test = WasmFeatures::default();
+        // Enable most features except exceptions
+        exceptions_test.set(WasmFeatures::BULK_MEMORY, true);
+        exceptions_test.set(WasmFeatures::REFERENCE_TYPES, true);
+        exceptions_test.set(WasmFeatures::SIMD, true);
+        exceptions_test.set(WasmFeatures::MULTI_VALUE, true);
+        exceptions_test.set(WasmFeatures::THREADS, true);
+        exceptions_test.set(WasmFeatures::TAIL_CALL, true);
+        exceptions_test.set(WasmFeatures::MULTI_MEMORY, true);
+        exceptions_test.set(WasmFeatures::MEMORY64, true);
+        exceptions_test.set(WasmFeatures::EXCEPTIONS, false);
+
+        let mut validator = Validator::new_with_features(exceptions_test);
+
+        if let Err(e) = validator.validate_all(wasm_bytes) {
+            let err_msg = e.to_string();
+            if err_msg.contains("exception") {
+                features.exceptions(true);
+            }
+        }
+
+        // Now try with all features enabled to catch anything we might have missed
+        let mut wasm_features = WasmFeatures::default();
+        wasm_features.set(WasmFeatures::EXCEPTIONS, true);
+        wasm_features.set(WasmFeatures::BULK_MEMORY, true);
+        wasm_features.set(WasmFeatures::REFERENCE_TYPES, true);
+        wasm_features.set(WasmFeatures::SIMD, true);
+        wasm_features.set(WasmFeatures::MULTI_VALUE, true);
+        wasm_features.set(WasmFeatures::THREADS, true);
+        wasm_features.set(WasmFeatures::TAIL_CALL, true);
+        wasm_features.set(WasmFeatures::MULTI_MEMORY, true);
+        wasm_features.set(WasmFeatures::MEMORY64, true);
+
+        let mut validator = Validator::new_with_features(wasm_features);
+        match validator.validate_all(wasm_bytes) {
+            Err(e) => {
+                // If validation fails due to missing feature support, check which feature it is
+                let err_msg = e.to_string().to_lowercase();
+
+                if err_msg.contains("exception") || err_msg.contains("try/catch") {
+                    features.exceptions(true);
+                }
+
+                if err_msg.contains("bulk memory") {
+                    features.bulk_memory(true);
+                }
+
+                if err_msg.contains("reference type") {
+                    features.reference_types(true);
+                }
+
+                if err_msg.contains("simd") {
+                    features.simd(true);
+                }
+
+                if err_msg.contains("multi value") || err_msg.contains("multiple values") {
+                    features.multi_value(true);
+                }
+
+                if err_msg.contains("thread") || err_msg.contains("shared memory") {
+                    features.threads(true);
+                }
+
+                if err_msg.contains("tail call") {
+                    features.tail_call(true);
+                }
+
+                if err_msg.contains("module linking") {
+                    features.module_linking(true);
+                }
+
+                if err_msg.contains("multi memory") {
+                    features.multi_memory(true);
+                }
+
+                if err_msg.contains("memory64") {
+                    features.memory64(true);
+                }
+            }
+            Ok(_) => {
+                // The module validated successfully with all features enabled,
+                // which means it could potentially use any of them.
+                // We'll do a more detailed analysis by parsing the module.
+            }
+        }
+
+        // A simple pass to detect certain common patterns
+        for payload in Parser::new(0).parse_all(wasm_bytes) {
+            let payload = payload?;
+            if let Payload::CustomSection(section) = payload {
+                let name = section.name();
+                // Exception handling has a custom section
+                if name.contains("exception") {
+                    features.exceptions(true);
+                }
+            }
+        }
+
+        Ok(features)
+    }
+
+    /// Extend this feature set with another set.
+    ///
+    /// Self will be modified to include all features that are required by
+    /// either set.
+    pub fn extend(&mut self, other: &Self) {
+        // Written this way to cause compile errors when new features are added.
+        let Self {
+            threads,
+            reference_types,
+            simd,
+            bulk_memory,
+            multi_value,
+            tail_call,
+            module_linking,
+            multi_memory,
+            memory64,
+            exceptions,
+            relaxed_simd,
+            extended_const,
+        } = other.clone();
+
+        *self = Self {
+            threads: self.threads || threads,
+            reference_types: self.reference_types || reference_types,
+            simd: self.simd || simd,
+            bulk_memory: self.bulk_memory || bulk_memory,
+            multi_value: self.multi_value || multi_value,
+            tail_call: self.tail_call || tail_call,
+            module_linking: self.module_linking || module_linking,
+            multi_memory: self.multi_memory || multi_memory,
+            memory64: self.memory64 || memory64,
+            exceptions: self.exceptions || exceptions,
+            relaxed_simd: self.relaxed_simd || relaxed_simd,
+            extended_const: self.extended_const || extended_const,
+        };
+    }
 }
 
 impl Default for Features {
@@ -265,6 +493,14 @@ mod test_features {
         );
     }
 
+    #[test]
+    fn features_extend() {
+        let all = Features::all();
+        let mut target = Features::none();
+        target.extend(&all);
+        assert_eq!(target, all);
+    }
+
     #[test]
     fn enable_threads() {
         let mut features = Features::new();
diff --git a/lib/types/src/indexes.rs b/lib/types/src/indexes.rs
index 3bf3883f3f..f931b31f29 100644
--- a/lib/types/src/indexes.rs
+++ b/lib/types/src/indexes.rs
@@ -1,10 +1,24 @@
 //! Helper functions and structures for the translation.
 use crate::entity::entity_impl;
-use core::u32;
 use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
 #[cfg(feature = "enable-serde")]
 use serde::{Deserialize, Serialize};
 
+/*
+ * [todo] xdoardo (on 2024/10/09)
+ *
+ * While updating rkyv from 0.7.x to 0.8.x it became unfeasible to represent archived
+ * version of some types as themselves (i.e. `rkyv(as = Self)`). This means that in cases
+ * like this one we can't simply return a reference to the underlying value.
+ *
+ * Hopefully as 0.8.x matures a bit more we can return to `rkyv(as = Self)`, making all
+ * of this faster and leaner. The missing bits for it are:
+ *
+ * 1. rkyv::rend::{u32_le, i32_le, u64_le, ..} should implement `serde::Serialize` and
+ *    `serde::Deserialize`.
+ *
+ */
+
 /// Index type of a function defined locally inside the WebAssembly module.
 #[derive(
     Copy,
@@ -18,25 +32,47 @@ use serde::{Deserialize, Serialize};
     RkyvSerialize,
     RkyvDeserialize,
     Archive,
-    rkyv::CheckBytes,
 )]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive(as = "Self")]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(derive(Debug, Hash, PartialEq, Eq), compare(PartialOrd, PartialEq))]
 pub struct LocalFunctionIndex(u32);
 entity_impl!(LocalFunctionIndex);
 
 /// Index type of a table defined locally inside the WebAssembly module.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct LocalTableIndex(u32);
 entity_impl!(LocalTableIndex);
 
 /// Index type of a memory defined locally inside the WebAssembly module.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct LocalMemoryIndex(u32);
 entity_impl!(LocalMemoryIndex);
 
+/// Index type of a tag defined locally inside the WebAssembly module.
+#[derive(
+    Copy,
+    Clone,
+    PartialEq,
+    Eq,
+    Hash,
+    PartialOrd,
+    Ord,
+    Debug,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(derive(Debug), compare(PartialOrd, PartialEq))]
+pub struct LocalTagIndex(u32);
+entity_impl!(LocalTagIndex);
+
 /// Index type of a global defined locally inside the WebAssembly module.
 #[derive(
     Copy,
@@ -50,10 +86,10 @@ entity_impl!(LocalMemoryIndex);
     RkyvSerialize,
     RkyvDeserialize,
     Archive,
-    rkyv::CheckBytes,
 )]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive(as = "Self")]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(derive(Debug), compare(PartialOrd, PartialEq))]
 pub struct LocalGlobalIndex(u32);
 entity_impl!(LocalGlobalIndex);
 
@@ -70,10 +106,13 @@ entity_impl!(LocalGlobalIndex);
     RkyvSerialize,
     RkyvDeserialize,
     Archive,
-    rkyv::CheckBytes,
 )]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive(as = "Self")]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(
+    derive(Debug, PartialOrd, Ord, PartialEq, Eq),
+    compare(PartialOrd, PartialEq)
+)]
 pub struct FunctionIndex(u32);
 entity_impl!(FunctionIndex);
 
@@ -90,13 +129,39 @@ entity_impl!(FunctionIndex);
     RkyvSerialize,
     RkyvDeserialize,
     Archive,
-    rkyv::CheckBytes,
 )]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive(as = "Self")]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(
+    derive(Debug, PartialOrd, Ord, PartialEq, Eq),
+    compare(PartialOrd, PartialEq)
+)]
 pub struct TableIndex(u32);
 entity_impl!(TableIndex);
 
+/// Index type of an event inside the WebAssembly module.
+#[derive(
+    Copy,
+    Clone,
+    PartialEq,
+    Eq,
+    Hash,
+    PartialOrd,
+    Ord,
+    Debug,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(
+    derive(Debug, PartialOrd, Ord, PartialEq, Eq),
+    compare(PartialOrd, PartialEq)
+)]
+pub struct TagIndex(u32);
+entity_impl!(TagIndex);
+
 /// Index type of a global variable (imported or local) inside the WebAssembly module.
 #[derive(
     Copy,
@@ -110,10 +175,10 @@ entity_impl!(TableIndex);
     RkyvSerialize,
     RkyvDeserialize,
     Archive,
-    rkyv::CheckBytes,
 )]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive(as = "Self")]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(derive(Debug), compare(PartialOrd, PartialEq))]
 pub struct GlobalIndex(u32);
 entity_impl!(GlobalIndex);
 
@@ -130,11 +195,11 @@ entity_impl!(GlobalIndex);
     RkyvSerialize,
     RkyvDeserialize,
     Archive,
-    rkyv::CheckBytes,
 )]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive(as = "Self")]
-pub struct MemoryIndex(u32);
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(derive(Debug), compare(PartialOrd, PartialEq))]
+pub struct MemoryIndex(pub(crate) u32);
 entity_impl!(MemoryIndex);
 
 /// Index type of a signature (imported or local) inside the WebAssembly module.
@@ -150,10 +215,10 @@ entity_impl!(MemoryIndex);
     RkyvSerialize,
     RkyvDeserialize,
     Archive,
-    rkyv::CheckBytes,
 )]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive(as = "Self")]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(derive(Debug), compare(PartialOrd, PartialEq))]
 pub struct SignatureIndex(u32);
 entity_impl!(SignatureIndex);
 
@@ -170,10 +235,13 @@ entity_impl!(SignatureIndex);
     RkyvSerialize,
     RkyvDeserialize,
     Archive,
-    rkyv::CheckBytes,
 )]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive(as = "Self")]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(
+    derive(Debug, PartialOrd, Ord, PartialEq, Eq),
+    compare(PartialOrd, PartialEq)
+)]
 pub struct DataIndex(u32);
 entity_impl!(DataIndex);
 
@@ -190,10 +258,13 @@ entity_impl!(DataIndex);
     RkyvSerialize,
     RkyvDeserialize,
     Archive,
-    rkyv::CheckBytes,
 )]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive(as = "Self")]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(
+    derive(Debug, PartialOrd, Ord, PartialEq, Eq),
+    compare(PartialOrd, PartialEq)
+)]
 pub struct ElemIndex(u32);
 entity_impl!(ElemIndex);
 
@@ -210,10 +281,10 @@ entity_impl!(ElemIndex);
     RkyvSerialize,
     RkyvDeserialize,
     Archive,
-    rkyv::CheckBytes,
 )]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive(as = "Self")]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(derive(Debug), compare(PartialOrd, PartialEq))]
 pub struct CustomSectionIndex(u32);
 entity_impl!(CustomSectionIndex);
 
@@ -230,10 +301,10 @@ entity_impl!(CustomSectionIndex);
     RkyvSerialize,
     RkyvDeserialize,
     Archive,
-    rkyv::CheckBytes,
 )]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive(as = "Self")]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(derive(Debug), compare(PartialOrd, PartialEq))]
 #[repr(u8)]
 pub enum ExportIndex {
     /// Function export.
@@ -242,26 +313,19 @@ pub enum ExportIndex {
     Table(TableIndex),
     /// Memory export.
     Memory(MemoryIndex),
+    /// An event definition.
+    Tag(TagIndex),
     /// Global export.
     Global(GlobalIndex),
 }
 
 /// An entity to import.
 #[derive(
-    Clone,
-    Debug,
-    Hash,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    RkyvSerialize,
-    RkyvDeserialize,
-    Archive,
-    rkyv::CheckBytes,
+    Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord, RkyvSerialize, RkyvDeserialize, Archive,
 )]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive(as = "Self")]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(derive(Debug), compare(PartialOrd, PartialEq))]
 #[repr(u8)]
 pub enum ImportIndex {
     /// Function import.
@@ -270,6 +334,20 @@ pub enum ImportIndex {
     Table(TableIndex),
     /// Memory import.
     Memory(MemoryIndex),
+    /// Tag import.
+    Tag(TagIndex),
     /// Global import.
     Global(GlobalIndex),
 }
+
+/// WebAssembly event.
+#[derive(
+    Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord, RkyvSerialize, RkyvDeserialize, Archive,
+)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(derive(Debug), compare(PartialOrd, PartialEq))]
+pub struct Tag {
+    /// The event signature type.
+    pub ty: u32,
+}
diff --git a/lib/types/src/initializers.rs b/lib/types/src/initializers.rs
index 4c8f177d94..131064a2d1 100644
--- a/lib/types/src/initializers.rs
+++ b/lib/types/src/initializers.rs
@@ -1,15 +1,21 @@
+/*
+ * ! Remove me once rkyv generates doc-comments for fields or generates an #[allow(missing_docs)]
+ * on their own.
+ */
+#![allow(missing_docs)]
+
 use crate::indexes::{FunctionIndex, GlobalIndex, MemoryIndex, TableIndex};
 use crate::lib::std::boxed::Box;
 
-use enumset::__internal::EnumSetTypeRepr;
-use rkyv::{Archive, CheckBytes, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
 #[cfg(feature = "enable-serde")]
 use serde::{Deserialize, Serialize};
 
 /// A WebAssembly table initializer.
-#[derive(Clone, Debug, Hash, PartialEq, Eq, RkyvSerialize, RkyvDeserialize, Archive)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[derive(Clone, Debug, Hash, PartialEq, Eq, RkyvSerialize, RkyvDeserialize, Archive)]
+#[rkyv(derive(Debug))]
 pub struct TableInitializer {
     /// The index of a table to initialize.
     pub table_index: TableIndex,
@@ -24,8 +30,9 @@ pub struct TableInitializer {
 /// A memory index and offset within that memory where a data initialization
 /// should be performed.
 #[derive(Clone, Debug, PartialEq, Eq, RkyvSerialize, RkyvDeserialize, Archive)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub struct DataInitializerLocation {
     /// The index of the memory to initialize.
     pub memory_index: MemoryIndex,
@@ -61,18 +68,18 @@ impl DataInitializerLocationLike for &DataInitializerLocation {
 
 impl DataInitializerLocationLike for &ArchivedDataInitializerLocation {
     fn memory_index(&self) -> MemoryIndex {
-        MemoryIndex::from_u32(self.memory_index.as_u32())
+        MemoryIndex::from_u32(rkyv::deserialize::<_, ()>(&self.memory_index).unwrap().0)
     }
 
     fn base(&self) -> Option<GlobalIndex> {
-        match self.base {
+        match &self.base {
             rkyv::option::ArchivedOption::None => None,
-            rkyv::option::ArchivedOption::Some(base) => Some(GlobalIndex::from_u32(base.as_u32())),
+            rkyv::option::ArchivedOption::Some(base) => rkyv::deserialize::<_, String>(base).ok(),
         }
     }
 
     fn offset(&self) -> usize {
-        self.offset.to_usize()
+        rkyv::deserialize::<_, ()>(&self.offset).unwrap()
     }
 }
 
@@ -89,9 +96,10 @@ pub struct DataInitializer<'data> {
 
 /// As `DataInitializer` but owning the data rather than
 /// holding a reference to it
-#[derive(Debug, Clone, PartialEq, Eq, RkyvSerialize, RkyvDeserialize, Archive)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[derive(Debug, Clone, PartialEq, Eq, RkyvSerialize, RkyvDeserialize, Archive)]
+#[rkyv(derive(Debug))]
 pub struct OwnedDataInitializer {
     /// The location where the initialization is to be performed.
     pub location: DataInitializerLocation,
diff --git a/lib/types/src/lib.rs b/lib/types/src/lib.rs
index 117f88408f..e9594a8851 100644
--- a/lib/types/src/lib.rs
+++ b/lib/types/src/lib.rs
@@ -37,7 +37,7 @@ pub mod lib {
     #[cfg(feature = "core")]
     pub mod std {
         pub use alloc::{borrow, boxed, format, iter, rc, slice, string, vec};
-        pub use core::{any, cell, cmp, convert, fmt, hash, marker, mem, ops, ptr, sync, u32};
+        pub use core::{any, cell, cmp, convert, fmt, hash, marker, mem, ops, ptr, sync};
     }
 
     /// Custom `std` module.
@@ -45,12 +45,11 @@ pub mod lib {
     pub mod std {
         pub use std::{
             any, borrow, boxed, cell, cmp, convert, fmt, format, hash, iter, marker, mem, ops, ptr,
-            rc, slice, string, sync, u32, vec,
+            rc, slice, string, sync, vec,
         };
     }
 }
 
-pub mod compilation;
 pub mod error;
 mod features;
 mod indexes;
@@ -63,6 +62,7 @@ mod serialize;
 mod stack;
 mod store_id;
 mod table;
+pub mod target;
 mod trapcode;
 mod types;
 mod units;
@@ -70,14 +70,6 @@ mod utils;
 mod value;
 mod vmoffsets;
 
-pub use crate::compilation::target::{
-    Aarch64Architecture, Architecture, BinaryFormat, CallingConvention, CpuFeature, Endianness,
-    Environment, OperatingSystem, PointerWidth, Target, Triple, Vendor,
-};
-pub use crate::serialize::{
-    ArchivedSerializableCompilation, ArchivedSerializableModule, MetadataHeader,
-    SerializableCompilation, SerializableModule,
-};
 pub use error::{
     CompileError, DeserializeError, ImportError, MemoryError, MiddlewareError,
     ParseCpuFeatureError, PreInstantiationError, SerializeError, WasmError, WasmResult,
@@ -88,8 +80,8 @@ pub mod entity;
 pub use crate::features::Features;
 pub use crate::indexes::{
     CustomSectionIndex, DataIndex, ElemIndex, ExportIndex, FunctionIndex, GlobalIndex, ImportIndex,
-    LocalFunctionIndex, LocalGlobalIndex, LocalMemoryIndex, LocalTableIndex, MemoryIndex,
-    SignatureIndex, TableIndex,
+    LocalFunctionIndex, LocalGlobalIndex, LocalMemoryIndex, LocalTableIndex, LocalTagIndex,
+    MemoryIndex, SignatureIndex, TableIndex, Tag, TagIndex,
 };
 pub use crate::initializers::{
     ArchivedDataInitializerLocation, ArchivedOwnedDataInitializer, DataInitializer,
@@ -99,46 +91,25 @@ pub use crate::initializers::{
 pub use crate::memory::{Memory32, Memory64, MemorySize};
 pub use crate::module::{ExportsIterator, ImportKey, ImportsIterator, ModuleInfo};
 pub use crate::module_hash::{HashAlgorithm, ModuleHash};
+pub use crate::types::{
+    ExportType, ExternType, FunctionType, GlobalInit, GlobalType, ImportType, MemoryType,
+    Mutability, TableType, TagKind, TagType, Type, V128,
+};
 pub use crate::units::{
     Bytes, PageCountOutOfRange, Pages, WASM_MAX_PAGES, WASM_MIN_PAGES, WASM_PAGE_SIZE,
 };
-pub use types::{
-    ExportType, ExternType, FunctionType, GlobalInit, GlobalType, ImportType, MemoryType,
-    Mutability, TableType, Type, V128,
-};
 pub use value::{RawValue, ValueType};
 
 pub use crate::libcalls::LibCall;
 pub use crate::memory::MemoryStyle;
 pub use crate::table::TableStyle;
+pub use serialize::MetadataHeader;
 // TODO: OnCalledAction is needed for asyncify. It will be refactored with https://github.com/wasmerio/wasmer/issues/3451
-pub use crate::trapcode::{OnCalledAction, TrapCode};
-pub use crate::vmoffsets::{TargetSharedSignatureIndex, VMBuiltinFunctionIndex, VMOffsets};
-
-pub use crate::utils::is_wasm;
-
-pub use crate::compilation::relocation::{
-    ArchivedRelocation, Relocation, RelocationKind, RelocationLike, RelocationTarget, Relocations,
-};
-pub use crate::compilation::section::{
-    ArchivedCustomSection, CustomSection, CustomSectionLike, CustomSectionProtection, SectionBody,
-    SectionIndex,
-};
-
-pub use crate::compilation::address_map::{FunctionAddressMap, InstructionAddressMap};
-pub use crate::compilation::function::{
-    ArchivedFunctionBody, Compilation, CompiledFunction, CompiledFunctionFrameInfo, CustomSections,
-    Dwarf, FunctionBody, FunctionBodyLike, Functions,
-};
-pub use crate::compilation::module::CompileModuleInfo;
-pub use crate::compilation::symbols::{Symbol, SymbolRegistry};
-pub use crate::compilation::unwind::{
-    ArchivedCompiledFunctionUnwindInfo, CompiledFunctionUnwindInfo, CompiledFunctionUnwindInfoLike,
-    CompiledFunctionUnwindInfoReference,
-};
-
 pub use crate::stack::{FrameInfo, SourceLoc, TrapInformation};
 pub use crate::store_id::StoreId;
+pub use crate::trapcode::{OnCalledAction, TrapCode};
+pub use crate::utils::is_wasm;
+pub use crate::vmoffsets::{TargetSharedSignatureIndex, VMBuiltinFunctionIndex, VMOffsets};
 
 /// Offset in bytes from the beginning of the function.
 pub type CodeOffset = u32;
diff --git a/lib/types/src/libcalls.rs b/lib/types/src/libcalls.rs
index 21222c588d..11a2895ce9 100644
--- a/lib/types/src/libcalls.rs
+++ b/lib/types/src/libcalls.rs
@@ -18,10 +18,10 @@ use std::fmt;
     RkyvSerialize,
     RkyvDeserialize,
     Archive,
-    rkyv::CheckBytes,
 )]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive(as = "Self")]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(derive(Debug, Hash, PartialEq, Eq), compare(PartialEq))]
 #[repr(u16)]
 pub enum LibCall {
     /// ceil.f32
@@ -135,6 +135,31 @@ pub enum LibCall {
 
     /// memory.atomic.botify for imported memories
     ImportedMemory32AtomicNotify,
+
+    /// throw
+    Throw,
+
+    /// rethrow
+    Rethrow,
+
+    /// alloc_exception
+    AllocException,
+
+    /// delete_exception
+    DeleteException,
+
+    /// read_exception
+    ReadException,
+
+    /// The personality function
+    EHPersonality,
+    /// The second stage of the EH personality function
+    EHPersonality2,
+
+    /// debug_usize
+    DebugUsize,
+    /// debug_str
+    DebugStr,
 }
 
 impl LibCall {
@@ -183,6 +208,15 @@ impl LibCall {
             Self::ImportedMemory32AtomicWait64 => "wasmer_vm_imported_memory32_atomic_wait64",
             Self::Memory32AtomicNotify => "wasmer_vm_memory32_atomic_notify",
             Self::ImportedMemory32AtomicNotify => "wasmer_vm_imported_memory32_atomic_notify",
+            Self::Throw => "wasmer_vm_throw",
+            Self::Rethrow => "wasmer_vm_rethrow",
+            Self::EHPersonality => "wasmer_eh_personality",
+            Self::EHPersonality2 => "wasmer_eh_personality2",
+            Self::AllocException => "wasmer_vm_alloc_exception",
+            Self::DeleteException => "wasmer_vm_delete_exception",
+            Self::ReadException => "wasmer_vm_read_exception",
+            Self::DebugUsize => "wasmer_vm_dbg_usize",
+            Self::DebugStr => "wasmer_vm_dbg_str",
         }
     }
 }
diff --git a/lib/types/src/memory.rs b/lib/types/src/memory.rs
index 5999f0c11c..643ecd307c 100644
--- a/lib/types/src/memory.rs
+++ b/lib/types/src/memory.rs
@@ -8,20 +8,10 @@ use std::iter::Sum;
 use std::ops::{Add, AddAssign};
 
 /// Implementation styles for WebAssembly linear memory.
-#[derive(
-    Debug,
-    Clone,
-    Copy,
-    PartialEq,
-    Eq,
-    Hash,
-    RkyvSerialize,
-    RkyvDeserialize,
-    Archive,
-    rkyv::CheckBytes,
-)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, RkyvSerialize, RkyvDeserialize, Archive)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive(as = "Self")]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(derive(Debug), compare(PartialEq))]
 #[repr(u8)]
 pub enum MemoryStyle {
     /// The actual memory can be resized and moved.
diff --git a/lib/types/src/module.rs b/lib/types/src/module.rs
index 5ddea198a5..93c02a48a0 100644
--- a/lib/types/src/module.rs
+++ b/lib/types/src/module.rs
@@ -8,16 +8,13 @@ use crate::entity::{EntityRef, PrimaryMap};
 use crate::{
     CustomSectionIndex, DataIndex, ElemIndex, ExportIndex, ExportType, ExternType, FunctionIndex,
     FunctionType, GlobalIndex, GlobalInit, GlobalType, ImportIndex, ImportType, LocalFunctionIndex,
-    LocalGlobalIndex, LocalMemoryIndex, LocalTableIndex, MemoryIndex, MemoryType, ModuleHash,
-    SignatureIndex, TableIndex, TableInitializer, TableType,
+    LocalGlobalIndex, LocalMemoryIndex, LocalTableIndex, LocalTagIndex, MemoryIndex, MemoryType,
+    ModuleHash, SignatureIndex, TableIndex, TableInitializer, TableType, TagIndex, TagType,
 };
 
 use indexmap::IndexMap;
-use rkyv::{
-    de::SharedDeserializeRegistry, ser::ScratchSpace, ser::Serializer,
-    ser::SharedSerializeRegistry, Archive, Archived, CheckBytes, Deserialize as RkyvDeserialize,
-    Fallible, Serialize as RkyvSerialize,
-};
+use rkyv::rancor::{Fallible, Source, Trace};
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
 #[cfg(feature = "enable-serde")]
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
@@ -27,7 +24,8 @@ use std::iter::ExactSizeIterator;
 use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
 
 #[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(derive(Debug))]
 pub struct ModuleId {
     id: usize,
 }
@@ -50,7 +48,7 @@ impl Default for ModuleId {
 /// Hash key of an import
 #[derive(Debug, Hash, Eq, PartialEq, Clone, Default, RkyvSerialize, RkyvDeserialize, Archive)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive_attr(derive(CheckBytes, PartialEq, Eq, Hash, Debug))]
+#[rkyv(derive(PartialOrd, Ord, PartialEq, Eq, Hash, Debug))]
 pub struct ImportKey {
     /// Module name
     pub module: String,
@@ -106,6 +104,7 @@ mod serde_imports {
 /// to make sure we don't break compatibility between versions.
 #[derive(Debug, Clone, Default)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 pub struct ModuleInfo {
     /// A unique identifier (within this process) for this module.
     ///
@@ -166,6 +165,9 @@ pub struct ModuleInfo {
     /// WebAssembly global variables (imported and local).
     pub globals: PrimaryMap<GlobalIndex, GlobalType>,
 
+    /// WebAssembly tag variables (imported and local).
+    pub tags: PrimaryMap<TagIndex, SignatureIndex>,
+
     /// Custom sections in the module.
     pub custom_sections: IndexMap<String, CustomSectionIndex>,
 
@@ -181,13 +183,16 @@ pub struct ModuleInfo {
     /// Number of imported memories in the module.
     pub num_imported_memories: usize,
 
+    /// Number of imported tags in the module.
+    pub num_imported_tags: usize,
+
     /// Number of imported globals in the module.
     pub num_imported_globals: usize,
 }
 
 /// Mirror version of ModuleInfo that can derive rkyv traits
 #[derive(Debug, RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub struct ArchivableModuleInfo {
     name: Option<String>,
     hash: Option<ModuleHash>,
@@ -204,10 +209,12 @@ pub struct ArchivableModuleInfo {
     tables: PrimaryMap<TableIndex, TableType>,
     memories: PrimaryMap<MemoryIndex, MemoryType>,
     globals: PrimaryMap<GlobalIndex, GlobalType>,
+    tags: PrimaryMap<TagIndex, SignatureIndex>,
     custom_sections: IndexMap<String, CustomSectionIndex>,
     custom_sections_data: PrimaryMap<CustomSectionIndex, Box<[u8]>>,
     num_imported_functions: usize,
     num_imported_tables: usize,
+    num_imported_tags: usize,
     num_imported_memories: usize,
     num_imported_globals: usize,
 }
@@ -230,10 +237,12 @@ impl From<ModuleInfo> for ArchivableModuleInfo {
             tables: it.tables,
             memories: it.memories,
             globals: it.globals,
+            tags: it.tags,
             custom_sections: it.custom_sections,
             custom_sections_data: it.custom_sections_data,
             num_imported_functions: it.num_imported_functions,
             num_imported_tables: it.num_imported_tables,
+            num_imported_tags: it.num_imported_tags,
             num_imported_memories: it.num_imported_memories,
             num_imported_globals: it.num_imported_globals,
         }
@@ -259,10 +268,12 @@ impl From<ArchivableModuleInfo> for ModuleInfo {
             tables: it.tables,
             memories: it.memories,
             globals: it.globals,
+            tags: it.tags,
             custom_sections: it.custom_sections,
             custom_sections_data: it.custom_sections_data,
             num_imported_functions: it.num_imported_functions,
             num_imported_tables: it.num_imported_tables,
+            num_imported_tags: it.num_imported_tags,
             num_imported_memories: it.num_imported_memories,
             num_imported_globals: it.num_imported_globals,
         }
@@ -279,26 +290,28 @@ impl Archive for ModuleInfo {
     type Archived = <ArchivableModuleInfo as Archive>::Archived;
     type Resolver = <ArchivableModuleInfo as Archive>::Resolver;
 
-    unsafe fn resolve(&self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived) {
-        ArchivableModuleInfo::from(self).resolve(pos, resolver, out)
+    fn resolve(&self, resolver: Self::Resolver, out: rkyv::Place<Self::Archived>) {
+        ArchivableModuleInfo::from(self).resolve(resolver, out)
     }
 }
 
-impl<S: Serializer + SharedSerializeRegistry + ScratchSpace + ?Sized> RkyvSerialize<S>
+impl<S: rkyv::ser::Allocator + rkyv::ser::Writer + Fallible + ?Sized> RkyvSerialize<S>
     for ModuleInfo
+where
+    <S as Fallible>::Error: rkyv::rancor::Source + rkyv::rancor::Trace,
 {
     fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
         ArchivableModuleInfo::from(self).serialize(serializer)
     }
 }
 
-impl<D: Fallible + ?Sized + SharedDeserializeRegistry> RkyvDeserialize<ModuleInfo, D>
-    for Archived<ModuleInfo>
+impl<D: Fallible + ?Sized> RkyvDeserialize<ModuleInfo, D> for ArchivedArchivableModuleInfo
+where
+    D::Error: Source + Trace,
 {
     fn deserialize(&self, deserializer: &mut D) -> Result<ModuleInfo, D::Error> {
-        let r: ArchivableModuleInfo =
-            RkyvDeserialize::<ArchivableModuleInfo, D>::deserialize(self, deserializer)?;
-        Ok(ModuleInfo::from(r))
+        let archived = RkyvDeserialize::<ArchivableModuleInfo, D>::deserialize(self, deserializer)?;
+        Ok(ModuleInfo::from(archived))
     }
 }
 
@@ -319,10 +332,12 @@ impl PartialEq for ModuleInfo {
             && self.tables == other.tables
             && self.memories == other.memories
             && self.globals == other.globals
+            && self.tags == other.tags
             && self.custom_sections == other.custom_sections
             && self.custom_sections_data == other.custom_sections_data
             && self.num_imported_functions == other.num_imported_functions
             && self.num_imported_tables == other.num_imported_tables
+            && self.num_imported_tags == other.num_imported_tags
             && self.num_imported_memories == other.num_imported_memories
             && self.num_imported_globals == other.num_imported_globals
     }
@@ -362,7 +377,7 @@ impl ModuleInfo {
     }
 
     /// Get the export types of the module
-    pub fn exports(&'_ self) -> ExportsIterator<impl Iterator<Item = ExportType> + '_> {
+    pub fn exports(&'_ self) -> ExportsIterator<Box<dyn Iterator<Item = ExportType> + '_>> {
         let iter = self.exports.iter().map(move |(name, export_index)| {
             let extern_type = match export_index {
                 ExportIndex::Function(i) => {
@@ -382,14 +397,23 @@ impl ModuleInfo {
                     let global_type = self.globals.get(*i).unwrap();
                     ExternType::Global(*global_type)
                 }
+                ExportIndex::Tag(i) => {
+                    let signature = self.tags.get(*i).unwrap();
+                    let tag_type = self.signatures.get(*signature).unwrap();
+
+                    ExternType::Tag(TagType {
+                        kind: crate::types::TagKind::Exception,
+                        params: tag_type.params().into(),
+                    })
+                }
             };
             ExportType::new(name, extern_type)
         });
-        ExportsIterator::new(iter, self.exports.len())
+        ExportsIterator::new(Box::new(iter), self.exports.len())
     }
 
     /// Get the import types of the module
-    pub fn imports(&'_ self) -> ImportsIterator<impl Iterator<Item = ImportType> + '_> {
+    pub fn imports(&'_ self) -> ImportsIterator<Box<dyn Iterator<Item = ImportType> + '_>> {
         let iter =
             self.imports
                 .iter()
@@ -412,22 +436,35 @@ impl ModuleInfo {
                             let global_type = self.globals.get(*i).unwrap();
                             ExternType::Global(*global_type)
                         }
+                        ImportIndex::Tag(i) => {
+                            let tag_type = self.tags.get(*i).unwrap();
+                            let func_type = self.signatures.get(*tag_type).unwrap();
+                            ExternType::Tag(TagType::from_fn_type(
+                                crate::TagKind::Exception,
+                                func_type.clone(),
+                            ))
+                        }
                     };
                     ImportType::new(module, field, extern_type)
                 });
-        ImportsIterator::new(iter, self.imports.len())
+        ImportsIterator::new(Box::new(iter), self.imports.len())
     }
 
     /// Get the custom sections of the module given a `name`.
-    pub fn custom_sections<'a>(&'a self, name: &'a str) -> impl Iterator<Item = Box<[u8]>> + 'a {
-        self.custom_sections
-            .iter()
-            .filter_map(move |(section_name, section_index)| {
-                if name != section_name {
-                    return None;
-                }
-                Some(self.custom_sections_data[*section_index].clone())
-            })
+    pub fn custom_sections<'a>(
+        &'a self,
+        name: &'a str,
+    ) -> Box<impl Iterator<Item = Box<[u8]>> + 'a> {
+        Box::new(
+            self.custom_sections
+                .iter()
+                .filter_map(move |(section_name, section_index)| {
+                    if name != section_name {
+                        return None;
+                    }
+                    Some(self.custom_sections_data[*section_index].clone())
+                }),
+        )
     }
 
     /// Convert a `LocalFunctionIndex` into a `FunctionIndex`.
@@ -505,6 +542,24 @@ impl ModuleInfo {
         index.index() < self.num_imported_globals
     }
 
+    /// Convert a `LocalTagIndex` into a `TagIndex`.
+    pub fn tag_index(&self, local_tag: LocalTagIndex) -> TagIndex {
+        TagIndex::new(self.num_imported_tags + local_tag.index())
+    }
+
+    /// Convert a `TagIndex` into a `LocalTagIndex`. Returns None if the
+    /// index is an imported tag.
+    pub fn local_tag_index(&self, tag: TagIndex) -> Option<LocalTagIndex> {
+        tag.index()
+            .checked_sub(self.num_imported_tags)
+            .map(LocalTagIndex::new)
+    }
+
+    /// Test whether the given tag index is for an imported tag.
+    pub fn is_imported_tag(&self, index: TagIndex) -> bool {
+        index.index() < self.num_imported_tags
+    }
+
     /// Get the Module name
     pub fn name(&self) -> String {
         match self.name {
diff --git a/lib/types/src/module_hash.rs b/lib/types/src/module_hash.rs
index 7c4e967f59..6d18a2497c 100644
--- a/lib/types/src/module_hash.rs
+++ b/lib/types/src/module_hash.rs
@@ -1,6 +1,6 @@
 use std::fmt::{self, Display, Formatter};
 
-use rkyv::{Archive, CheckBytes, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
 #[cfg(feature = "enable-serde")]
 use serde::{Deserialize, Serialize};
 use sha2::Digest;
@@ -28,7 +28,7 @@ pub enum HashAlgorithm {
     RkyvDeserialize,
     Archive,
 )]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub enum ModuleHash {
     /// xxhash
@@ -38,6 +38,16 @@ pub enum ModuleHash {
     Sha256([u8; 32]),
 }
 
+#[cfg(feature = "artifact-size")]
+impl loupe::MemoryUsage for ModuleHash {
+    fn size_of_val(&self, _tracker: &mut dyn loupe::MemoryUsageTracker) -> usize {
+        match self {
+            ModuleHash::XXHash(_) => 8 * 8,
+            ModuleHash::Sha256(_) => 8 * 32,
+        }
+    }
+}
+
 impl ModuleHash {
     /// Create a new [`ModuleHash`] from the raw xxhash hash.
     pub fn xxhash_from_bytes(key: [u8; 8]) -> Self {
@@ -63,7 +73,7 @@ impl ModuleHash {
         Ok(Self::sha256_from_bytes(hash))
     }
 
-    /// Generate a new [`ModuleCache`] based on the XXHash hash of some bytes.
+    /// Generate a new [`ModuleHash`] based on the XXHash hash of some bytes.
     pub fn xxhash(wasm: impl AsRef<[u8]>) -> Self {
         let wasm = wasm.as_ref();
 
@@ -72,7 +82,7 @@ impl ModuleHash {
         Self::XXHash(hash.to_ne_bytes())
     }
 
-    /// Generate a new [`ModuleCache`] based on the Sha256 hash of some bytes.
+    /// Generate a new [`ModuleHash`] based on the Sha256 hash of some bytes.
     pub fn sha256(wasm: impl AsRef<[u8]>) -> Self {
         let wasm = wasm.as_ref();
 
@@ -81,6 +91,13 @@ impl ModuleHash {
         Self::Sha256(hash)
     }
 
+    /// Generate a random [`ModuleHash`]. For when you don't care about caches.
+    pub fn random() -> Self {
+        let mut bytes = [0_u8; 8];
+        getrandom::getrandom(&mut bytes).unwrap();
+        Self::XXHash(bytes)
+    }
+
     /// Get the raw hash.
     pub fn as_bytes(&self) -> &[u8] {
         match self {
diff --git a/lib/types/src/serialize.rs b/lib/types/src/serialize.rs
index d98af1dac7..178ad2fea5 100644
--- a/lib/types/src/serialize.rs
+++ b/lib/types/src/serialize.rs
@@ -1,202 +1,4 @@
-use crate::entity::PrimaryMap;
-use crate::{
-    compilation::target::CpuFeature, CompileModuleInfo, CompiledFunctionFrameInfo, CustomSection,
-    DeserializeError, Dwarf, Features, FunctionBody, FunctionIndex, LocalFunctionIndex,
-    MemoryIndex, MemoryStyle, ModuleInfo, OwnedDataInitializer, Relocation, SectionIndex,
-    SerializeError, SignatureIndex, TableIndex, TableStyle,
-};
-use enumset::EnumSet;
-use rkyv::check_archived_value;
-use rkyv::{
-    archived_value, de::deserializers::SharedDeserializeMap, ser::serializers::AllocSerializer,
-    ser::Serializer as RkyvSerializer, Archive, CheckBytes, Deserialize as RkyvDeserialize,
-    Serialize as RkyvSerialize,
-};
-use std::convert::TryInto;
-use std::mem;
-
-/// The compilation related data for a serialized modules
-#[derive(Archive, Default, RkyvDeserialize, RkyvSerialize)]
-#[allow(missing_docs)]
-#[archive_attr(derive(CheckBytes, Debug))]
-pub struct SerializableCompilation {
-    pub function_bodies: PrimaryMap<LocalFunctionIndex, FunctionBody>,
-    pub function_relocations: PrimaryMap<LocalFunctionIndex, Vec<Relocation>>,
-    pub function_frame_info: PrimaryMap<LocalFunctionIndex, CompiledFunctionFrameInfo>,
-    pub function_call_trampolines: PrimaryMap<SignatureIndex, FunctionBody>,
-    pub dynamic_function_trampolines: PrimaryMap<FunctionIndex, FunctionBody>,
-    pub custom_sections: PrimaryMap<SectionIndex, CustomSection>,
-    pub custom_section_relocations: PrimaryMap<SectionIndex, Vec<Relocation>>,
-    // The section indices corresponding to the Dwarf debug info
-    pub debug: Option<Dwarf>,
-    // Custom section containing libcall trampolines.
-    pub libcall_trampolines: SectionIndex,
-    // Length of each libcall trampoline.
-    pub libcall_trampoline_len: u32,
-}
-
-impl SerializableCompilation {
-    /// Serialize a Compilation into bytes
-    /// The bytes will have the following format:
-    /// RKYV serialization (any length) + POS (8 bytes)
-    pub fn serialize(&self) -> Result<Vec<u8>, SerializeError> {
-        let mut serializer = AllocSerializer::<4096>::default();
-        let pos = serializer
-            .serialize_value(self)
-            .map_err(to_serialize_error)? as u64;
-        let mut serialized_data = serializer.into_serializer().into_inner();
-        serialized_data.extend_from_slice(&pos.to_le_bytes());
-        Ok(serialized_data.to_vec())
-    }
-}
-
-/// Serializable struct that is able to serialize from and to a `ArtifactInfo`.
-#[derive(Archive, RkyvDeserialize, RkyvSerialize)]
-#[allow(missing_docs)]
-#[archive_attr(derive(CheckBytes, Debug))]
-pub struct SerializableModule {
-    /// The main serializable compilation object
-    pub compilation: SerializableCompilation,
-    /// Compilation informations
-    pub compile_info: CompileModuleInfo,
-    /// Datas initializers
-    pub data_initializers: Box<[OwnedDataInitializer]>,
-    /// CPU Feature flags for this compilation
-    pub cpu_features: u64,
-}
-
-fn to_serialize_error(err: impl std::error::Error) -> SerializeError {
-    SerializeError::Generic(format!("{}", err))
-}
-
-impl SerializableModule {
-    /// Serialize a Module into bytes
-    /// The bytes will have the following format:
-    /// RKYV serialization (any length) + POS (8 bytes)
-    pub fn serialize(&self) -> Result<Vec<u8>, SerializeError> {
-        let mut serializer = AllocSerializer::<4096>::default();
-        let pos = serializer
-            .serialize_value(self)
-            .map_err(to_serialize_error)? as u64;
-        let mut serialized_data = serializer.into_serializer().into_inner();
-        serialized_data.extend_from_slice(&pos.to_le_bytes());
-        Ok(serialized_data.to_vec())
-    }
-
-    /// Deserialize a Module from a slice.
-    /// The slice must have the following format:
-    /// RKYV serialization (any length) + POS (8 bytes)
-    ///
-    /// # Safety
-    ///
-    /// This method is unsafe since it deserializes data directly
-    /// from memory.
-    /// Right now we are not doing any extra work for validation, but
-    /// `rkyv` has an option to do bytecheck on the serialized data before
-    /// serializing (via `rkyv::check_archived_value`).
-    pub unsafe fn deserialize_unchecked(metadata_slice: &[u8]) -> Result<Self, DeserializeError> {
-        let archived = Self::archive_from_slice(metadata_slice)?;
-        Self::deserialize_from_archive(archived)
-    }
-
-    /// Deserialize a Module from a slice.
-    /// The slice must have the following format:
-    /// RKYV serialization (any length) + POS (8 bytes)
-    ///
-    /// Unlike [`Self::deserialize`], this function will validate the data.
-    ///
-    /// # Safety
-    /// Unsafe because it loads executable code into memory.
-    /// The loaded bytes must be trusted.
-    pub unsafe fn deserialize(metadata_slice: &[u8]) -> Result<Self, DeserializeError> {
-        let archived = Self::archive_from_slice_checked(metadata_slice)?;
-        Self::deserialize_from_archive(archived)
-    }
-
-    /// # Safety
-    ///
-    /// This method is unsafe.
-    /// Please check `SerializableModule::deserialize` for more details.
-    pub unsafe fn archive_from_slice(
-        metadata_slice: &[u8],
-    ) -> Result<&ArchivedSerializableModule, DeserializeError> {
-        if metadata_slice.len() < 8 {
-            return Err(DeserializeError::Incompatible(
-                "invalid serialized data".into(),
-            ));
-        }
-        let mut pos: [u8; 8] = Default::default();
-        pos.copy_from_slice(&metadata_slice[metadata_slice.len() - 8..metadata_slice.len()]);
-        let pos: u64 = u64::from_le_bytes(pos);
-        Ok(archived_value::<Self>(
-            &metadata_slice[..metadata_slice.len() - 8],
-            pos as usize,
-        ))
-    }
-
-    /// Deserialize an archived module.
-    ///
-    /// In contrast to [`Self::deserialize`], this method performs validation
-    /// and is not unsafe.
-    pub fn archive_from_slice_checked(
-        metadata_slice: &[u8],
-    ) -> Result<&ArchivedSerializableModule, DeserializeError> {
-        if metadata_slice.len() < 8 {
-            return Err(DeserializeError::Incompatible(
-                "invalid serialized data".into(),
-            ));
-        }
-        let mut pos: [u8; 8] = Default::default();
-        pos.copy_from_slice(&metadata_slice[metadata_slice.len() - 8..metadata_slice.len()]);
-        let pos: u64 = u64::from_le_bytes(pos);
-        check_archived_value::<Self>(&metadata_slice[..metadata_slice.len() - 8], pos as usize)
-            .map_err(|err| DeserializeError::CorruptedBinary(err.to_string()))
-    }
-
-    /// Deserialize a compilation module from an archive
-    pub fn deserialize_from_archive(
-        archived: &ArchivedSerializableModule,
-    ) -> Result<Self, DeserializeError> {
-        let mut deserializer = SharedDeserializeMap::new();
-        RkyvDeserialize::deserialize(archived, &mut deserializer)
-            .map_err(|e| DeserializeError::CorruptedBinary(format!("{:?}", e)))
-    }
-
-    /// Create a `ModuleInfo` for instantiation
-    pub fn create_module_info(&self) -> ModuleInfo {
-        self.compile_info.module.as_ref().clone()
-    }
-
-    /// Returns the `ModuleInfo` for instantiation
-    pub fn module_info(&self) -> &ModuleInfo {
-        &self.compile_info.module
-    }
-
-    /// Returns the features for this Artifact
-    pub fn features(&self) -> &Features {
-        &self.compile_info.features
-    }
-
-    /// Returns the CPU features for this Artifact
-    pub fn cpu_features(&self) -> EnumSet<CpuFeature> {
-        EnumSet::from_u64(self.cpu_features)
-    }
-
-    /// Returns data initializers to pass to `VMInstance::initialize`
-    pub fn data_initializers(&self) -> &[OwnedDataInitializer] {
-        &self.data_initializers
-    }
-
-    /// Returns the memory styles associated with this `Artifact`.
-    pub fn memory_styles(&self) -> &PrimaryMap<MemoryIndex, MemoryStyle> {
-        &self.compile_info.memory_styles
-    }
-
-    /// Returns the table plans associated with this `Artifact`.
-    pub fn table_styles(&self) -> &PrimaryMap<TableIndex, TableStyle> {
-        &self.compile_info.table_styles
-    }
-}
+use crate::{lib::std::mem, DeserializeError};
 
 /// Metadata header which holds an ABI version and the length of the remaining
 /// metadata.
@@ -211,7 +13,7 @@ pub struct MetadataHeader {
 impl MetadataHeader {
     /// Current ABI version. Increment this any time breaking changes are made
     /// to the format of the serialized data.
-    pub const CURRENT_VERSION: u32 = 7;
+    pub const CURRENT_VERSION: u32 = 11;
 
     /// Magic number to identify wasmer metadata.
     const MAGIC: [u8; 8] = *b"WASMER\0\0";
diff --git a/lib/types/src/stack/sourceloc.rs b/lib/types/src/stack/sourceloc.rs
index e91586f407..85ca36cd79 100644
--- a/lib/types/src/stack/sourceloc.rs
+++ b/lib/types/src/stack/sourceloc.rs
@@ -21,10 +21,11 @@ use serde::{Deserialize, Serialize};
     derive(Serialize, Deserialize),
     serde(transparent)
 )]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[derive(RkyvSerialize, RkyvDeserialize, Archive)]
 #[repr(transparent)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, rkyv::CheckBytes)]
-#[archive(as = "Self")]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[rkyv(derive(Debug))]
 pub struct SourceLoc(u32);
 
 impl SourceLoc {
diff --git a/lib/types/src/stack/trap.rs b/lib/types/src/stack/trap.rs
index b13c14b7df..a7c2afed6a 100644
--- a/lib/types/src/stack/trap.rs
+++ b/lib/types/src/stack/trap.rs
@@ -7,10 +7,9 @@ use serde::{Deserialize, Serialize};
 
 /// Information about trap.
 #[cfg_attr(feature = "enable-serde", derive(Deserialize, Serialize))]
-#[derive(
-    RkyvSerialize, RkyvDeserialize, Archive, rkyv::CheckBytes, Clone, Copy, Debug, PartialEq, Eq,
-)]
-#[archive(as = "Self")]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive, Clone, Copy, Debug, PartialEq, Eq)]
+#[rkyv(derive(Debug), compare(PartialEq))]
 pub struct TrapInformation {
     /// The offset of the trapping instruction in native code. It is relative to the beginning of the function.
     pub code_offset: CodeOffset,
diff --git a/lib/types/src/store_id.rs b/lib/types/src/store_id.rs
index 414a4af1d0..7b6e380160 100644
--- a/lib/types/src/store_id.rs
+++ b/lib/types/src/store_id.rs
@@ -12,6 +12,13 @@ use std::{
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 pub struct StoreId(NonZeroUsize);
 
+#[cfg(feature = "artifact-size")]
+impl loupe::MemoryUsage for StoreId {
+    fn size_of_val(&self, _visited: &mut dyn loupe::MemoryUsageTracker) -> usize {
+        std::mem::size_of_val(self)
+    }
+}
+
 impl Default for StoreId {
     // Allocates a unique ID for a new context.
     fn default() -> Self {
diff --git a/lib/types/src/table.rs b/lib/types/src/table.rs
index 0b155d1f88..1aa1b1b324 100644
--- a/lib/types/src/table.rs
+++ b/lib/types/src/table.rs
@@ -1,15 +1,13 @@
-use bytecheck::CheckBytes;
 use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
 #[cfg(feature = "enable-serde")]
 use serde::{Deserialize, Serialize};
 
 /// Implementation styles for WebAssembly tables.
-#[derive(
-    Debug, Clone, Hash, PartialEq, Eq, RkyvSerialize, RkyvDeserialize, Archive, CheckBytes,
-)]
+#[derive(Debug, Clone, Hash, PartialEq, Eq, RkyvSerialize, RkyvDeserialize, Archive)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive(as = "Self")]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[repr(u8)]
+#[rkyv(derive(Debug))]
 pub enum TableStyle {
     /// Signatures are stored in the table and checked in the caller.
     CallerChecksSignature,
diff --git a/lib/types/src/compilation/target.rs b/lib/types/src/target.rs
similarity index 83%
rename from lib/types/src/compilation/target.rs
rename to lib/types/src/target.rs
index 0d3d98f144..53a2841728 100644
--- a/lib/types/src/compilation/target.rs
+++ b/lib/types/src/target.rs
@@ -11,7 +11,6 @@
 use crate::error::ParseCpuFeatureError;
 use enumset::{EnumSet, EnumSetType};
 use std::str::FromStr;
-use std::string::{String, ToString};
 pub use target_lexicon::{
     Aarch64Architecture, Architecture, BinaryFormat, CallingConvention, Endianness, Environment,
     OperatingSystem, PointerWidth, Triple, Vendor,
@@ -160,26 +159,29 @@ impl FromStr for CpuFeature {
     }
 }
 
-impl ToString for CpuFeature {
-    fn to_string(&self) -> String {
-        match self {
-            Self::SSE2 => "sse2",
-            Self::SSE3 => "sse3",
-            Self::SSSE3 => "ssse3",
-            Self::SSE41 => "sse4.1",
-            Self::SSE42 => "sse4.2",
-            Self::POPCNT => "popcnt",
-            Self::AVX => "avx",
-            Self::BMI1 => "bmi",
-            Self::BMI2 => "bmi2",
-            Self::AVX2 => "avx2",
-            Self::AVX512DQ => "avx512dq",
-            Self::AVX512VL => "avx512vl",
-            Self::AVX512F => "avx512f",
-            Self::LZCNT => "lzcnt",
-            Self::NEON => "neon",
-        }
-        .to_string()
+impl std::fmt::Display for CpuFeature {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Self::SSE2 => "sse2",
+                Self::SSE3 => "sse3",
+                Self::SSSE3 => "ssse3",
+                Self::SSE41 => "sse4.1",
+                Self::SSE42 => "sse4.2",
+                Self::POPCNT => "popcnt",
+                Self::AVX => "avx",
+                Self::BMI1 => "bmi",
+                Self::BMI2 => "bmi2",
+                Self::AVX2 => "avx2",
+                Self::AVX512DQ => "avx512dq",
+                Self::AVX512VL => "avx512vl",
+                Self::AVX512F => "avx512f",
+                Self::LZCNT => "lzcnt",
+                Self::NEON => "neon",
+            }
+        )
     }
 }
 
@@ -227,3 +229,13 @@ impl Default for Target {
         }
     }
 }
+
+/// User-suggested optimization that might be operated on the module when (and if) compiled.
+///
+// Note: This type is a copy of `wasmer_config::package::SuggestedCompilerOptimizations`, so to
+// avoid dependencies on `wasmer_config` for crates that already depend on `wasmer_types`.
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Default)]
+pub struct UserCompilerOptimizations {
+    /// Suggest the `pass_params` (also known as g0m0) optimization pass.
+    pub pass_params: Option<bool>,
+}
diff --git a/lib/types/src/trapcode.rs b/lib/types/src/trapcode.rs
index ae8066d89c..04efd035be 100644
--- a/lib/types/src/trapcode.rs
+++ b/lib/types/src/trapcode.rs
@@ -14,21 +14,12 @@ use thiserror::Error;
 ///
 /// All trap instructions have an explicit trap code.
 #[derive(
-    Clone,
-    Copy,
-    PartialEq,
-    Eq,
-    Debug,
-    Hash,
-    Error,
-    RkyvSerialize,
-    RkyvDeserialize,
-    Archive,
-    rkyv::CheckBytes,
+    Clone, Copy, PartialEq, Eq, Debug, Hash, Error, RkyvSerialize, RkyvDeserialize, Archive,
 )]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(derive(Debug), compare(PartialEq))]
 #[repr(u32)]
-#[archive(as = "Self")]
 pub enum TrapCode {
     /// The current stack space was exhausted.
     ///
@@ -69,6 +60,9 @@ pub enum TrapCode {
 
     /// An atomic memory access was attempted with an unaligned pointer.
     UnalignedAtomic = 10,
+
+    /// An exception was thrown but it was left uncaught.
+    UncaughtException = 11,
 }
 
 impl TrapCode {
@@ -86,6 +80,7 @@ impl TrapCode {
             Self::BadConversionToInteger => "invalid conversion to integer",
             Self::UnreachableCodeReached => "unreachable",
             Self::UnalignedAtomic => "unaligned atomic access",
+            Self::UncaughtException => "uncaught exception",
         }
     }
 }
@@ -104,6 +99,7 @@ impl Display for TrapCode {
             Self::BadConversionToInteger => "bad_toint",
             Self::UnreachableCodeReached => "unreachable",
             Self::UnalignedAtomic => "unalign_atom",
+            Self::UncaughtException => "uncaught_exception",
         };
         f.write_str(identifier)
     }
diff --git a/lib/types/src/types.rs b/lib/types/src/types.rs
index 3b9e4af215..91379d3fd8 100644
--- a/lib/types/src/types.rs
+++ b/lib/types/src/types.rs
@@ -6,7 +6,6 @@ use crate::lib::std::string::{String, ToString};
 use crate::lib::std::vec::Vec;
 use crate::units::Pages;
 
-use bytecheck::CheckBytes;
 use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
 #[cfg(feature = "enable-serde")]
 use serde::{Deserialize, Serialize};
@@ -18,8 +17,9 @@ use serde::{Deserialize, Serialize};
 /// A list of all possible value types in WebAssembly.
 #[derive(Copy, Debug, Clone, Eq, PartialEq, Hash)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[derive(RkyvSerialize, RkyvDeserialize, Archive, rkyv::CheckBytes)]
-#[archive(as = "Self")]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive)]
+#[rkyv(derive(Debug), compare(PartialEq))]
 #[repr(u8)]
 pub enum Type {
     /// Signed 32 bit integer.
@@ -36,6 +36,8 @@ pub enum Type {
     ExternRef, /* = 128 */
     /// A reference to a Wasm function.
     FuncRef,
+    /// A reference to a Wasm exception.
+    ExceptionRef,
 }
 
 impl Type {
@@ -50,23 +52,30 @@ impl Type {
 
     /// Returns true if `Type` matches either of the reference types.
     pub fn is_ref(self) -> bool {
-        matches!(self, Self::ExternRef | Self::FuncRef)
+        matches!(self, Self::ExternRef | Self::FuncRef | Self::ExceptionRef)
     }
 }
 
 impl fmt::Display for Type {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self)
+        write!(f, "{self:?}")
     }
 }
 
 /// The WebAssembly V128 type
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, CheckBytes)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 #[derive(RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive(as = "Self")]
+#[rkyv(derive(Debug), compare(PartialEq))]
 pub struct V128(pub(crate) [u8; 16]);
 
+#[cfg(feature = "artifact-size")]
+impl loupe::MemoryUsage for V128 {
+    fn size_of_val(&self, _tracker: &mut dyn loupe::MemoryUsageTracker) -> usize {
+        16 * 8
+    }
+}
+
 impl V128 {
     /// Get the bytes corresponding to the V128 value
     pub fn bytes(&self) -> &[u8; 16] {
@@ -121,6 +130,8 @@ pub enum ExternType {
     Table(TableType),
     /// This external type is the type of a WebAssembly memory.
     Memory(MemoryType),
+    /// This external type is the type of a WebAssembly tag.
+    Tag(TagType),
 }
 
 fn is_global_compatible(exported: GlobalType, imported: GlobalType) -> bool {
@@ -227,6 +238,7 @@ impl ExternType {
             (Self::Global(a), Self::Global(b)) => is_global_compatible(*a, *b),
             (Self::Table(a), Self::Table(b)) => is_table_compatible(a, b, runtime_size),
             (Self::Memory(a), Self::Memory(b)) => is_memory_compatible(a, b, runtime_size),
+            (Self::Tag(a), Self::Tag(b)) => a == b,
             // The rest of possibilities, are not compatible
             _ => false,
         }
@@ -241,8 +253,9 @@ impl ExternType {
 /// WebAssembly functions can have 0 or more parameters and results.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[derive(RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub struct FunctionType {
     /// The parameters of the function
     params: Box<[Type]>,
@@ -279,16 +292,16 @@ impl fmt::Display for FunctionType {
         let params = self
             .params
             .iter()
-            .map(|p| format!("{:?}", p))
+            .map(|p| format!("{p:?}"))
             .collect::<Vec<_>>()
             .join(", ");
         let results = self
             .results
             .iter()
-            .map(|p| format!("{:?}", p))
+            .map(|p| format!("{p:?}"))
             .collect::<Vec<_>>()
             .join(", ");
-        write!(f, "[{}] -> [{}]", params, results)
+        write!(f, "[{params}] -> [{results}]")
     }
 }
 
@@ -326,10 +339,10 @@ impl From<&Self> for FunctionType {
 }
 
 /// Indicator of whether a global is mutable or not
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, CheckBytes)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, RkyvSerialize, RkyvDeserialize, Archive)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[derive(RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive(as = "Self")]
+#[rkyv(derive(Debug), compare(PartialOrd, PartialEq))]
 #[repr(u8)]
 pub enum Mutability {
     /// The global is constant and its value does not change
@@ -365,10 +378,10 @@ impl From<Mutability> for bool {
 }
 
 /// WebAssembly global.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, CheckBytes)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, RkyvSerialize, RkyvDeserialize, Archive)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[derive(RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive(as = "Self")]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(derive(Debug), compare(PartialEq))]
 pub struct GlobalType {
     /// The type of the value stored in the global.
     pub ty: Type,
@@ -410,10 +423,10 @@ impl fmt::Display for GlobalType {
 }
 
 /// Globals are initialized via the `const` operators or by referring to another import.
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, RkyvSerialize, RkyvDeserialize, Archive)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[derive(RkyvSerialize, RkyvDeserialize, Archive, rkyv::CheckBytes)]
-#[archive(as = "Self")]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(derive(Debug), compare(PartialEq))]
 #[repr(u8)]
 pub enum GlobalInit {
     /// An `i32.const`.
@@ -437,6 +450,67 @@ pub enum GlobalInit {
     RefFunc(FunctionIndex),
 }
 
+// Tag Types
+
+/// The kind of a [`Tag`].
+///
+/// Currently, tags can only express exceptions.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive)]
+#[rkyv(derive(Debug))]
+pub enum TagKind {
+    /// This tag's event is an exception.
+    Exception,
+}
+
+/// The signature of a tag that is either implemented
+/// in a Wasm module or exposed to Wasm by the host.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive)]
+#[rkyv(derive(Debug))]
+pub struct TagType {
+    /// The kind of the tag.
+    pub kind: TagKind,
+    /// The parameters of the function
+    pub params: Box<[Type]>,
+}
+
+impl TagType {
+    /// Creates a new [`TagType`] with the given kind, parameter and return types.
+    pub fn new<Params>(kind: TagKind, params: Params) -> Self
+    where
+        Params: Into<Box<[Type]>>,
+    {
+        Self {
+            kind,
+            params: params.into(),
+        }
+    }
+
+    /// Parameter types.
+    pub fn params(&self) -> &[Type] {
+        &self.params
+    }
+
+    /// Create a new [`TagType`] with the given kind and the associated type.
+    pub fn from_fn_type(kind: TagKind, ty: FunctionType) -> Self {
+        Self {
+            kind,
+            params: ty.params().into(),
+        }
+    }
+}
+
+impl fmt::Display for TagType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "({:?}) {:?}", self.kind, self.params(),)
+    }
+}
+
 // Table Types
 
 /// A descriptor for a table in a WebAssembly module.
@@ -446,8 +520,9 @@ pub enum GlobalInit {
 /// which `call_indirect` can invoke other functions.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[derive(RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub struct TableType {
     /// The type of data stored in elements of the table.
     pub ty: Type,
@@ -487,8 +562,9 @@ impl fmt::Display for TableType {
 /// chunks of addressable memory.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[derive(RkyvSerialize, RkyvDeserialize, Archive)]
-#[archive_attr(derive(CheckBytes, Debug))]
+#[rkyv(derive(Debug))]
 pub struct MemoryType {
     /// The minimum number of pages in the memory.
     pub minimum: Pages,
diff --git a/lib/types/src/units.rs b/lib/types/src/units.rs
index 60e488b4a3..25b3a05565 100644
--- a/lib/types/src/units.rs
+++ b/lib/types/src/units.rs
@@ -21,20 +21,11 @@ pub const WASM_MIN_PAGES: u32 = 0x100;
 
 /// Units of WebAssembly pages (as specified to be 65,536 bytes).
 #[derive(
-    Copy,
-    Clone,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Hash,
-    RkyvSerialize,
-    RkyvDeserialize,
-    Archive,
-    rkyv::CheckBytes,
+    Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RkyvSerialize, RkyvDeserialize, Archive,
 )]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[archive(as = "Self")]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+#[rkyv(derive(Debug), compare(PartialEq, PartialOrd))]
 pub struct Pages(pub u32);
 
 impl Pages {
diff --git a/lib/types/src/vmoffsets.rs b/lib/types/src/vmoffsets.rs
index f48176d45e..1ca5e235e9 100644
--- a/lib/types/src/vmoffsets.rs
+++ b/lib/types/src/vmoffsets.rs
@@ -136,13 +136,50 @@ impl VMBuiltinFunctionIndex {
     pub const fn get_memory_atomic_notify_index() -> Self {
         Self(28)
     }
+
     /// Returns an index for wasm's imported `memory.atomic.notify` builtin function.
     pub const fn get_imported_memory_atomic_notify_index() -> Self {
         Self(29)
     }
+
+    /// Returns an index for wasm's imported `throw` builtin function.
+    pub const fn get_imported_throw_index() -> Self {
+        Self(30)
+    }
+
+    /// Returns an index for wasm's imported `rethrow` builtin function.
+    pub const fn get_imported_rethrow_index() -> Self {
+        Self(31)
+    }
+
+    /// Returns an index for wasm's imported `alloc_exception` builtin function.
+    pub const fn get_imported_alloc_exception_index() -> Self {
+        Self(32)
+    }
+
+    /// Returns an index for wasm's imported `delete_exception` builtin function.
+    pub const fn get_imported_delete_exception_index() -> Self {
+        Self(33)
+    }
+
+    /// Returns an index for wasm's imported `read_exception` builtin function.
+    pub const fn get_imported_read_exception_index() -> Self {
+        Self(34)
+    }
+
+    /// Returns an index for wasm's imported `debug_usize` builtin function.
+    pub const fn get_imported_debug_usize_index() -> Self {
+        Self(35)
+    }
+
+    /// Returns an index for wasm's imported `debug_str` builtin function.
+    pub const fn get_imported_debug_str_index() -> Self {
+        Self(36)
+    }
+
     /// Returns the total number of builtin functions.
     pub const fn builtin_functions_total_number() -> u32 {
-        30
+        37
     }
 
     /// Return the index as an u32 number.
@@ -163,7 +200,7 @@ fn cast_to_u32(sz: usize) -> u32 {
 /// Align an offset used in this module to a specific byte-width by rounding up
 #[inline]
 const fn align(offset: u32, width: u32) -> u32 {
-    (offset + (width - 1)) / width * width
+    offset.div_ceil(width) * width
 }
 
 /// This class computes offsets to fields within VMContext and other
@@ -180,6 +217,8 @@ pub struct VMOffsets {
     num_imported_tables: u32,
     /// The number of imported memories in the module.
     num_imported_memories: u32,
+    /// The number of tags in the module.
+    num_tag_ids: u32,
     /// The number of imported globals in the module.
     num_imported_globals: u32,
     /// The number of defined tables in the module.
@@ -193,6 +232,7 @@ pub struct VMOffsets {
     vmctx_imported_functions_begin: u32,
     vmctx_imported_tables_begin: u32,
     vmctx_imported_memories_begin: u32,
+    vmctx_tag_ids_begin: u32,
     vmctx_imported_globals_begin: u32,
     vmctx_tables_begin: u32,
     vmctx_memories_begin: u32,
@@ -214,6 +254,7 @@ impl VMOffsets {
             num_imported_functions: cast_to_u32(module.num_imported_functions),
             num_imported_tables: cast_to_u32(module.num_imported_tables),
             num_imported_memories: cast_to_u32(module.num_imported_memories),
+            num_tag_ids: cast_to_u32(module.tags.len()),
             num_imported_globals: cast_to_u32(module.num_imported_globals),
             num_local_tables: cast_to_u32(module.tables.len()),
             num_local_memories: cast_to_u32(module.memories.len()),
@@ -222,6 +263,7 @@ impl VMOffsets {
             vmctx_imported_functions_begin: 0,
             vmctx_imported_tables_begin: 0,
             vmctx_imported_memories_begin: 0,
+            vmctx_tag_ids_begin: 0,
             vmctx_imported_globals_begin: 0,
             vmctx_tables_begin: 0,
             vmctx_memories_begin: 0,
@@ -248,6 +290,7 @@ impl VMOffsets {
             num_imported_functions: 0,
             num_imported_tables: 0,
             num_imported_memories: 0,
+            num_tag_ids: 0,
             num_imported_globals: 0,
             num_local_tables: 0,
             num_local_memories: 0,
@@ -256,6 +299,7 @@ impl VMOffsets {
             vmctx_imported_functions_begin: 0,
             vmctx_imported_tables_begin: 0,
             vmctx_imported_memories_begin: 0,
+            vmctx_tag_ids_begin: 0,
             vmctx_imported_globals_begin: 0,
             vmctx_tables_begin: 0,
             vmctx_memories_begin: 0,
@@ -312,11 +356,19 @@ impl VMOffsets {
             self.num_imported_tables,
             u32::from(self.size_of_vmtable_import()),
         );
-        self.vmctx_imported_globals_begin = offset_by_aligned(
+
+        self.vmctx_tag_ids_begin = offset_by_aligned(
             self.vmctx_imported_memories_begin,
             self.num_imported_memories,
             u32::from(self.size_of_vmmemory_import()),
         );
+
+        self.vmctx_imported_globals_begin = offset_by_aligned(
+            self.vmctx_tag_ids_begin,
+            self.num_tag_ids,
+            u32::from(self.size_of_vmshared_tag_index()),
+        );
+
         self.vmctx_tables_begin = offset_by_aligned(
             self.vmctx_imported_globals_begin,
             self.num_imported_globals,
@@ -589,6 +641,14 @@ impl VMOffsets {
     }
 }
 
+/// Offsets for `VMSharedTagIndex`.
+impl VMOffsets {
+    /// Return the size of `VMSharedTagIndex`.
+    pub const fn size_of_vmshared_tag_index(&self) -> u8 {
+        4
+    }
+}
+
 /// Offsets for `VMContext`.
 impl VMOffsets {
     /// The offset of the `signature_ids` array.
@@ -618,6 +678,11 @@ impl VMOffsets {
         self.vmctx_imported_globals_begin
     }
 
+    /// The offset of the `tags` array.
+    pub fn vmctx_tag_ids_begin(&self) -> u32 {
+        self.vmctx_tag_ids_begin
+    }
+
     /// The offset of the `tables` array.
     pub fn vmctx_tables_begin(&self) -> u32 {
         self.vmctx_tables_begin
diff --git a/lib/virtual-fs/Cargo.toml b/lib/virtual-fs/Cargo.toml
index 8b7b41a3cb..aef86f9ca1 100644
--- a/lib/virtual-fs/Cargo.toml
+++ b/lib/virtual-fs/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "virtual-fs"
-version = "0.16.0"
+version = "0.601.0"
 description = "Wasmer Virtual FileSystem"
 authors.workspace = true
 edition.workspace = true
@@ -10,50 +10,65 @@ repository.workspace = true
 rust-version.workspace = true
 
 [dependencies]
+wasmer-package.workspace = true
+virtual-mio = { path = "../virtual-io", version = "0.601.0", default-features = false }
 dashmap.workspace = true
+derive_more.workspace = true
 dunce = "1.0.4"
-anyhow = { version = "1.0.66", optional = true }
-async-trait = { version = "^0.1" }
-bytes = "1"
-derivative = "2.2.0"
+anyhow = { workspace = true, optional = true }
+async-trait = { workspace = true }
+bytes.workspace = true
 filetime = { version = "0.2.18", optional = true }
 fs_extra = { version = "1.2.0", optional = true }
 futures = { version = "0.3" }
-indexmap = "1.9.2"
-lazy_static = "1.4"
+indexmap.workspace = true
 libc = { workspace = true, optional = true }
 pin-project-lite = "0.2.9"
 replace_with = "0.1.7"
-shared-buffer = { workspace = true }
+shared-buffer.workspace = true
 slab = { version = "0.4" }
-thiserror = "1"
-tokio = { version = "1", features = ["io-util", "sync", "macros"], default-features = false }
-tracing = { version = "0.1" }
+thiserror.workspace = true
+
+tokio = { workspace = true, features = [
+	"io-util",
+	"sync",
+	"macros",
+], default-features = false }
+tracing.workspace = true
 typetag = { version = "0.1", optional = true }
 webc = { workspace = true, optional = true, features = ["v1"] }
-serde = { version = "1.0", default-features = false, features = ["derive"], optional = true }
-
-[target.'cfg(not(all(target_arch = "wasm32", target_os = "unknown")))'.dependencies]
-getrandom = { version = "0.2" }
-
-[target.'cfg(all(target_arch = "wasm32", target_os = "unknown"))'.dependencies]
-getrandom = { version = "0.2", features = [ "js" ] }
+serde = { workspace = true, default-features = false, features = [
+	"derive",
+], optional = true }
+getrandom.workspace = true
+web-time = { version = "1.1", optional = true }
 
 [dev-dependencies]
-pretty_assertions = "1.3.0"
-tempfile = "3.6.0"
-tracing-test = "0.2.4"
-tokio = { version = "1", features = ["io-util", "rt"], default-features = false }
+pretty_assertions.workspace = true
+tempfile.workspace = true
+tracing-test.workspace = true
+tokio = { workspace = true, features = [
+	"io-util",
+	"rt",
+], default-features = false }
 
 [features]
 default = ["host-fs", "webc-fs", "static-fs"]
-host-fs = ["libc", "fs_extra", "filetime", "tokio/fs", "tokio/io-std", "tokio/rt"]
+host-fs = [
+	"libc",
+	"fs_extra",
+	"filetime",
+	"tokio/fs",
+	"tokio/io-std",
+	"tokio/rt",
+]
 webc-fs = ["webc", "anyhow"]
 static-fs = ["webc", "anyhow"]
 enable-serde = ["typetag", "serde"]
-no-time = []
+js = ["dep:web-time", "getrandom/js"]
 # Enables memory tracking/limiting functionality for the in-memory filesystem.
 tracking = []
+futures = []
 
 [package.metadata.docs.rs]
 rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/virtual-fs/src/arc_box_file.rs b/lib/virtual-fs/src/arc_box_file.rs
index b55a8b415e..ba28b080fc 100644
--- a/lib/virtual-fs/src/arc_box_file.rs
+++ b/lib/virtual-fs/src/arc_box_file.rs
@@ -8,15 +8,12 @@ use std::{
     task::{Context, Poll},
 };
 
-use derivative::Derivative;
 use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite};
 
 use crate::VirtualFile;
 
-#[derive(Derivative, Clone)]
-#[derivative(Debug)]
+#[derive(Debug, Clone)]
 pub struct ArcBoxFile {
-    #[derivative(Debug = "ignore")]
     inner: Arc<Mutex<Box<dyn VirtualFile + Send + Sync + 'static>>>,
 }
 
diff --git a/lib/virtual-fs/src/arc_file.rs b/lib/virtual-fs/src/arc_file.rs
index 088f6e5ce0..6059d70e14 100644
--- a/lib/virtual-fs/src/arc_file.rs
+++ b/lib/virtual-fs/src/arc_file.rs
@@ -2,7 +2,6 @@
 //! effectively this is a symbolic link without all the complex path redirection
 
 use crate::{ClonableVirtualFile, VirtualFile};
-use derivative::Derivative;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 use std::{
@@ -11,13 +10,11 @@ use std::{
 };
 use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite};
 
-#[derive(Derivative)]
-#[derivative(Debug)]
+#[derive(Debug)]
 pub struct ArcFile<T>
 where
     T: VirtualFile + Send + Sync + 'static,
 {
-    #[derivative(Debug = "ignore")]
     inner: Arc<Mutex<Box<T>>>,
 }
 
diff --git a/lib/virtual-fs/src/buffer_file.rs b/lib/virtual-fs/src/buffer_file.rs
index 9af66811cb..2810cfed9b 100644
--- a/lib/virtual-fs/src/buffer_file.rs
+++ b/lib/virtual-fs/src/buffer_file.rs
@@ -69,13 +69,13 @@ impl AsyncRead for BufferFile {
 
 impl VirtualFile for BufferFile {
     fn last_accessed(&self) -> u64 {
-        0
+        1_000_000_000 // 1 second after epoch, since zero times are bad!
     }
     fn last_modified(&self) -> u64 {
-        0
+        1_000_000_000
     }
     fn created_time(&self) -> u64 {
-        0
+        1_000_000_000
     }
     fn size(&self) -> u64 {
         self.data.get_ref().len() as u64
diff --git a/lib/virtual-fs/src/builder.rs b/lib/virtual-fs/src/builder.rs
index f07ad07a0f..0f74372236 100644
--- a/lib/virtual-fs/src/builder.rs
+++ b/lib/virtual-fs/src/builder.rs
@@ -122,6 +122,8 @@ impl RootFileSystemBuilder {
                 PathBuf::from("/dev/tty"),
                 self.tty.unwrap_or_else(|| Box::<NullFile>::default()),
             );
+
+            let _ = tmp.create_dir(Path::new("/dev/shm"));
         }
         tmp
     }
@@ -130,6 +132,7 @@ impl RootFileSystemBuilder {
 #[cfg(test)]
 mod test_builder {
     use crate::{FileSystem, RootFileSystemBuilder};
+    use std::path::Path;
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
     #[tokio::test]
@@ -198,5 +201,8 @@ mod test_builder {
             .open("/dev/stderr")
             .unwrap();
         assert_eq!(dev_stderr.get_special_fd().unwrap(), 2);
+
+        let dev_shm_metadata = root_fs.metadata(Path::new("/dev/shm")).unwrap();
+        assert!(dev_shm_metadata.is_dir());
     }
 }
diff --git a/lib/virtual-fs/src/combine_file.rs b/lib/virtual-fs/src/combine_file.rs
index 951de2e5a2..8c12b83c9f 100644
--- a/lib/virtual-fs/src/combine_file.rs
+++ b/lib/virtual-fs/src/combine_file.rs
@@ -1,11 +1,8 @@
-use derivative::Derivative;
-
 use super::*;
 
 use crate::VirtualFile;
 
-#[derive(Derivative)]
-#[derivative(Debug)]
+#[derive(Debug)]
 pub struct CombineFile {
     tx: Box<dyn VirtualFile + Send + Sync + 'static>,
     rx: Box<dyn VirtualFile + Send + Sync + 'static>,
diff --git a/lib/virtual-fs/src/cow_file.rs b/lib/virtual-fs/src/cow_file.rs
index 643dc2a055..b3f31b8661 100644
--- a/lib/virtual-fs/src/cow_file.rs
+++ b/lib/virtual-fs/src/cow_file.rs
@@ -1,12 +1,16 @@
 //! Used for /dev/zero - infinitely returns zero
 //! which is useful for commands like `dd if=/dev/zero of=bigfile.img size=1G`
 
+use derive_more::Debug;
 use replace_with::replace_with_or_abort;
-use std::io::{self, *};
 use std::pin::Pin;
 use std::task::{Context, Poll};
+use std::{
+    future::Future,
+    io::{self, *},
+};
 
-use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite, ReadBuf};
+use tokio::io::{AsyncRead, AsyncReadExt, AsyncSeek, AsyncSeekExt, AsyncWrite};
 
 use crate::{BufferFile, VirtualFile};
 
@@ -14,24 +18,21 @@ use crate::{BufferFile, VirtualFile};
 enum CowState {
     ReadOnly(Box<dyn VirtualFile + Send + Sync>),
     Copying {
-        pos: u64,
-        inner: Box<dyn VirtualFile + Send + Sync>,
+        #[debug(skip)]
+        future: Pin<Box<dyn Future<Output = io::Result<BufferFile>> + Send + Sync>>,
+        requested_size: Option<u64>,
+        requested_position: Option<SeekFrom>,
+        cached_size: u64,
     },
-    Copied,
+    Copied(BufferFile),
 }
+
 impl CowState {
-    fn as_ref(&self) -> Option<&(dyn VirtualFile + Send + Sync)> {
-        match self {
-            Self::ReadOnly(inner) => Some(inner.as_ref()),
-            Self::Copying { inner, .. } => Some(inner.as_ref()),
-            _ => None,
-        }
-    }
-    fn as_mut(&mut self) -> Option<&mut Box<dyn VirtualFile + Send + Sync>> {
+    fn inner_mut(&mut self) -> &mut (dyn VirtualFile + Send + Sync) {
         match self {
-            Self::ReadOnly(inner) => Some(inner),
-            Self::Copying { inner, .. } => Some(inner),
-            _ => None,
+            Self::ReadOnly(inner) => inner.as_mut(),
+            Self::Copying { .. } => panic!("Cannot access inner file while copying"),
+            Self::Copied(inner) => inner,
         }
     }
 }
@@ -42,7 +43,6 @@ pub struct CopyOnWriteFile {
     last_modified: u64,
     created_time: u64,
     state: CowState,
-    buf: BufferFile,
 }
 
 impl CopyOnWriteFile {
@@ -52,68 +52,94 @@ impl CopyOnWriteFile {
             last_modified: inner.last_modified(),
             created_time: inner.created_time(),
             state: CowState::ReadOnly(inner),
-            buf: BufferFile::default(),
         }
     }
-    fn poll_copy_progress(&mut self, cx: &mut Context) -> Poll<io::Result<()>> {
-        if let CowState::Copying { ref mut inner, pos } = &mut self.state {
-            let mut temp = [0u8; 8192];
-
-            while *pos < inner.size() {
-                let mut read_temp = ReadBuf::new(&mut temp);
 
-                if let Err(err) = Pin::new(inner.as_mut()).start_seek(SeekFrom::Start(*pos)) {
-                    return Poll::Ready(Err(err));
-                }
-                match Pin::new(inner.as_mut()).poll_complete(cx).map_ok(|_| ()) {
-                    Poll::Ready(Ok(())) => {}
-                    p => return p,
-                }
-                match Pin::new(inner.as_mut()).poll_read(cx, &mut read_temp) {
-                    Poll::Pending => return Poll::Pending,
-                    Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
-                    Poll::Ready(Ok(())) => {}
-                }
-                if read_temp.remaining() == 0 {
-                    return Poll::Pending;
-                }
-                *pos += read_temp.remaining() as u64;
+    async fn copy(mut inner: Box<dyn VirtualFile + Send + Sync>) -> io::Result<BufferFile> {
+        let initial_position = inner.seek(SeekFrom::Current(0)).await?;
+        inner.seek(SeekFrom::Start(0)).await?;
 
-                self.buf.data.write_all(read_temp.filled()).unwrap();
+        let mut buffer = [0u8; 8192];
+        let mut buffer_file = BufferFile::default();
+        loop {
+            let read_bytes = inner.read_buf(&mut &mut buffer[..]).await?;
+            if read_bytes == 0 {
+                break;
             }
-            self.state = CowState::Copied;
+            buffer_file.data.write_all(&buffer[0..read_bytes])?;
         }
-        Poll::Ready(Ok(()))
+
+        buffer_file.seek(SeekFrom::Start(initial_position)).await?;
+
+        Ok(buffer_file)
     }
-    fn poll_copy_start_and_progress(&mut self, cx: &mut Context) -> Poll<io::Result<()>> {
+
+    fn poll_copy_progress(&mut self, cx: &mut Context) -> Poll<io::Result<()>> {
+        match self.state {
+            CowState::Copying {
+                ref mut future,
+                requested_size,
+                requested_position,
+                ..
+            } => match future.as_mut().poll(cx) {
+                Poll::Ready(Ok(mut buf)) => {
+                    if let Some(requested_size) = requested_size {
+                        buf.set_len(requested_size)?;
+                    }
+                    if let Some(requested_position) = requested_position {
+                        Pin::new(&mut buf).start_seek(requested_position)?;
+                    }
+                    self.state = CowState::Copied(buf);
+                    Poll::Ready(Ok(()))
+                }
+                Poll::Ready(Err(e)) => Poll::Ready(Err(e)),
+                Poll::Pending => Poll::Pending,
+            },
+            _ => Poll::Ready(Ok(())),
+        }
+    }
+
+    fn start_copy(&mut self) {
         replace_with_or_abort(&mut self.state, |state| match state {
-            CowState::ReadOnly(inner) => CowState::Copying { pos: 0, inner },
+            CowState::ReadOnly(inner) => CowState::Copying {
+                cached_size: inner.size(),
+                requested_size: None,
+                requested_position: None,
+                future: Box::pin(Self::copy(inner)),
+            },
             state => state,
         });
+    }
+
+    fn poll_copy_start_and_progress(&mut self, cx: &mut Context) -> Poll<io::Result<()>> {
+        self.start_copy();
         self.poll_copy_progress(cx)
     }
 }
 
 impl AsyncSeek for CopyOnWriteFile {
     fn start_seek(mut self: Pin<&mut Self>, position: io::SeekFrom) -> io::Result<()> {
-        let data = Pin::new(&mut self.buf);
-        data.start_seek(position)?;
+        match self.state {
+            CowState::Copying {
+                ref mut requested_position,
+                ..
+            } => {
+                *requested_position = Some(position);
+                Ok(())
+            }
 
-        if let Some(inner) = self.state.as_mut() {
-            Pin::new(inner.as_mut()).start_seek(position)?;
+            _ => Pin::new(self.state.inner_mut()).start_seek(position),
         }
-
-        Ok(())
     }
 
     fn poll_complete(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
-        match self.state.as_mut() {
-            Some(inner) => Pin::new(inner.as_mut()).poll_complete(cx),
-            None => {
-                let data = Pin::new(&mut self.buf);
-                data.poll_complete(cx)
-            }
+        match self.poll_copy_progress(cx) {
+            Poll::Ready(Ok(())) => {}
+            Poll::Pending => return Poll::Pending,
+            Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
         }
+
+        Pin::new(self.state.inner_mut()).poll_complete(cx)
     }
 }
 
@@ -128,8 +154,7 @@ impl AsyncWrite for CopyOnWriteFile {
             Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
             Poll::Ready(Ok(())) => {}
         }
-        let data = Pin::new(&mut self.buf);
-        data.poll_write(cx, buf)
+        Pin::new(self.state.inner_mut()).poll_write(cx, buf)
     }
 
     fn poll_write_vectored(
@@ -142,8 +167,7 @@ impl AsyncWrite for CopyOnWriteFile {
             Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
             Poll::Ready(Ok(())) => {}
         }
-        let data = Pin::new(&mut self.buf);
-        data.poll_write_vectored(cx, bufs)
+        Pin::new(self.state.inner_mut()).poll_write_vectored(cx, bufs)
     }
 
     fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
@@ -151,8 +175,7 @@ impl AsyncWrite for CopyOnWriteFile {
             Poll::Ready(Ok(())) => {}
             p => return p,
         }
-        let data = Pin::new(&mut self.buf);
-        data.poll_flush(cx)
+        Pin::new(self.state.inner_mut()).poll_flush(cx)
     }
 
     fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
@@ -160,8 +183,7 @@ impl AsyncWrite for CopyOnWriteFile {
             Poll::Ready(Ok(())) => {}
             p => return p,
         }
-        let data = Pin::new(&mut self.buf);
-        data.poll_shutdown(cx)
+        Pin::new(self.state.inner_mut()).poll_shutdown(cx)
     }
 }
 
@@ -175,13 +197,7 @@ impl AsyncRead for CopyOnWriteFile {
             Poll::Ready(Ok(())) => {}
             p => return p,
         }
-        match self.state.as_mut() {
-            Some(inner) => Pin::new(inner.as_mut()).poll_read(cx, buf),
-            None => {
-                let data = Pin::new(&mut self.buf);
-                data.poll_read(cx, buf)
-            }
-        }
+        Pin::new(self.state.inner_mut()).poll_read(cx, buf)
     }
 }
 
@@ -189,12 +205,15 @@ impl VirtualFile for CopyOnWriteFile {
     fn last_accessed(&self) -> u64 {
         self.last_accessed
     }
+
     fn last_modified(&self) -> u64 {
         self.last_modified
     }
+
     fn created_time(&self) -> u64 {
         self.created_time
     }
+
     fn set_times(&mut self, atime: Option<u64>, mtime: Option<u64>) -> crate::Result<()> {
         if let Some(atime) = atime {
             self.last_accessed = atime;
@@ -205,34 +224,122 @@ impl VirtualFile for CopyOnWriteFile {
 
         Ok(())
     }
+
     fn size(&self) -> u64 {
-        match self.state.as_ref() {
-            Some(inner) => inner.size(),
-            None => self.buf.size(),
+        match &self.state {
+            CowState::ReadOnly(inner) => inner.size(),
+            CowState::Copying {
+                requested_size: Some(size),
+                ..
+            } => *size,
+            CowState::Copying { cached_size, .. } => *cached_size,
+            CowState::Copied(buffer_file) => buffer_file.size(),
         }
     }
+
     fn set_len(&mut self, new_size: u64) -> crate::Result<()> {
-        self.buf.set_len(new_size)
+        match self.state {
+            CowState::ReadOnly(_) => {
+                self.start_copy();
+                let CowState::Copying {
+                    ref mut requested_size,
+                    ..
+                } = self.state
+                else {
+                    unreachable!()
+                };
+                *requested_size = Some(new_size);
+            }
+
+            CowState::Copying {
+                ref mut requested_size,
+                ..
+            } => {
+                *requested_size = Some(new_size);
+            }
+
+            CowState::Copied(ref mut buf) => {
+                buf.set_len(new_size)?;
+            }
+        }
+
+        Ok(())
     }
+
     fn unlink(&mut self) -> crate::Result<()> {
-        self.buf.set_len(0)
+        // TODO: one can imagine interrupting an in-progress copy here
+        self.set_len(0)
     }
+
     fn poll_read_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
         match self.poll_copy_progress(cx) {
             Poll::Pending => return Poll::Pending,
             Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
             Poll::Ready(Ok(())) => {}
         }
-        match self.state.as_mut() {
-            Some(inner) => Pin::new(inner.as_mut()).poll_read_ready(cx),
-            None => {
-                let data: Pin<&mut BufferFile> = Pin::new(&mut self.buf);
-                data.poll_read_ready(cx)
-            }
-        }
+        Pin::new(self.state.inner_mut()).poll_read_ready(cx)
     }
 
     fn poll_write_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
         self.poll_copy_progress(cx).map_ok(|_| 8192)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // This is as weird a test as it gets, yes, but I'm (unashamedly!) cramming
+    // everything we know was wrong with the impl into this one test to save time.
+    #[tokio::test]
+    async fn cow_file_works() {
+        let mut data = Vec::with_capacity(16385);
+        for i in 0..16385 {
+            data.push(i as u8);
+        }
+        let inner = BufferFile {
+            data: Cursor::new(data),
+        };
+        let mut file = CopyOnWriteFile::new(Box::new(inner));
+
+        assert!(matches!(file.state, CowState::ReadOnly(_)));
+        assert_eq!(file.size(), 16385);
+        assert_ne!(file.created_time(), 0);
+        assert_ne!(file.last_accessed(), 0);
+        assert_ne!(file.last_modified(), 0);
+
+        let mut buf = [0u8; 4];
+        let read = file.read_exact(buf.as_mut()).await.unwrap();
+        assert_eq!(read, 4);
+        assert_eq!(buf, [0, 1, 2, 3]);
+        assert_eq!(file.seek(SeekFrom::Current(0)).await.unwrap(), 4);
+        assert!(matches!(file.state, CowState::ReadOnly { .. }));
+
+        // After this call, the file will "start" copying, but the actual
+        // future won't be polled until we try to read or write.
+        file.start_copy();
+        assert!(matches!(file.state, CowState::Copying { .. }));
+        assert_eq!(file.size(), 16385);
+
+        // The cached length should be returned while copying
+        file.set_len(16400).unwrap();
+        assert!(matches!(file.state, CowState::Copying { .. }));
+        assert_eq!(file.size(), 16400);
+
+        // Now try to read from the file, which will trigger the copy
+        let read = file.read_exact(buf.as_mut()).await.unwrap();
+        assert!(matches!(file.state, CowState::Copied { .. }));
+        assert_eq!(read, 4);
+        assert_eq!(buf, [4, 5, 6, 7]);
+        assert_eq!(file.seek(SeekFrom::Current(0)).await.unwrap(), 8);
+        assert_eq!(file.size(), 16400);
+
+        file.seek(SeekFrom::Start(16383)).await.unwrap();
+        let read = file.read_exact(buf.as_mut()).await.unwrap();
+        assert_eq!(read, 4);
+        // set_len should have filled the rest with zeroes
+        assert_eq!(buf, [(16383 % 256) as u8, (16384 % 256) as u8, 0, 0]);
+        assert_eq!(file.seek(SeekFrom::Current(0)).await.unwrap(), 16387);
+        assert!(matches!(file.state, CowState::Copied { .. }));
+    }
+}
diff --git a/lib/virtual-fs/src/dual_write_file.rs b/lib/virtual-fs/src/dual_write_file.rs
index bf71ad41e8..b6f590a11c 100644
--- a/lib/virtual-fs/src/dual_write_file.rs
+++ b/lib/virtual-fs/src/dual_write_file.rs
@@ -1,5 +1,3 @@
-use derivative::Derivative;
-
 use super::*;
 
 use crate::VirtualFile;
@@ -7,12 +5,11 @@ use crate::VirtualFile;
 /// Wraps a [`VirtualFile`], and also invokes a provided function for each write.
 ///
 /// Useful for debugging.
-#[derive(Derivative)]
-#[derivative(Debug)]
+#[derive(derive_more::Debug)]
 pub struct DualWriteFile {
     inner: Box<dyn VirtualFile + Send + Sync + 'static>,
-    #[derivative(Debug = "ignore")]
     #[allow(clippy::type_complexity)]
+    #[debug(ignore)]
     extra_write: Box<dyn FnMut(&[u8]) + Send + Sync + 'static>,
 }
 
diff --git a/lib/virtual-fs/src/host_fs.rs b/lib/virtual-fs/src/host_fs.rs
index 199ee9fb50..82bd50d137 100644
--- a/lib/virtual-fs/src/host_fs.rs
+++ b/lib/virtual-fs/src/host_fs.rs
@@ -351,10 +351,10 @@ impl crate::FileOpener for FileSystem {
 pub struct File {
     #[cfg_attr(feature = "enable-serde", serde(skip, default = "default_handle"))]
     handle: Handle,
-    #[cfg_attr(feature = "enable-serde", serde(skip_serializing))]
-    inner_std: fs::File,
     #[cfg_attr(feature = "enable-serde", serde(skip))]
     inner: tfs::File,
+    #[cfg_attr(feature = "enable-serde", serde(skip_serializing))]
+    inner_std: fs::File,
     pub host_path: PathBuf,
     #[cfg(feature = "enable-serde")]
     flags: u16,
@@ -635,6 +635,12 @@ impl AsyncSeek for File {
     }
 }
 
+impl Drop for File {
+    fn drop(&mut self) {
+        tracing::trace!(?self.host_path, "Closing host file");
+    }
+}
+
 /// A wrapper type around Stdout that implements `VirtualFile`.
 #[derive(Debug)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
@@ -1109,7 +1115,7 @@ mod tests {
         let cur_dir = read_dir_names(&fs, "/");
 
         if !cur_dir.contains(&"foo".to_string()) {
-            panic!("cur_dir does not contain foo: {:#?}", cur_dir);
+            panic!("cur_dir does not contain foo: {cur_dir:#?}");
         }
 
         assert!(
@@ -1270,7 +1276,7 @@ mod tests {
         let bar_dir = read_dir_names(&fs, bar);
 
         if !bar_dir.contains(&"qux".to_string()) {
-            println!("qux does not exist: {:?}", bar_dir)
+            println!("qux does not exist: {bar_dir:?}")
         }
 
         let qux_dir = read_dir_names(&fs, bar.join("qux"));
@@ -1287,7 +1293,7 @@ mod tests {
             "the /bar/hello2.txt file exists"
         );
 
-        assert_eq!(fs.create_dir(foo), Ok(()), "create ./foo again",);
+        assert_eq!(fs.create_dir(foo), Ok(()), "create ./foo again");
 
         assert_eq!(
             fs.rename(&bar.join("hello2.txt"), &foo.join("world2.txt"))
@@ -1481,7 +1487,7 @@ mod tests {
         assert!(next.metadata().unwrap().is_dir(), "checking entry #5");
 
         if let Some(s) = readdir.next() {
-            panic!("next: {:?}", s);
+            panic!("next: {s:?}");
         }
     }
 }
diff --git a/lib/virtual-fs/src/lib.rs b/lib/virtual-fs/src/lib.rs
index 6e9b443853..2f0017fa98 100644
--- a/lib/virtual-fs/src/lib.rs
+++ b/lib/virtual-fs/src/lib.rs
@@ -5,6 +5,7 @@
 extern crate pretty_assertions;
 
 use futures::future::BoxFuture;
+use shared_buffer::OwnedBuffer;
 use std::any::Any;
 use std::ffi::OsString;
 use std::fmt;
@@ -236,7 +237,7 @@ impl OpenOptionsConfig {
     }
 }
 
-impl<'a> fmt::Debug for OpenOptions<'a> {
+impl fmt::Debug for OpenOptions<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         self.conf.fmt(f)
     }
@@ -393,11 +394,34 @@ pub trait VirtualFile:
     ) -> BoxFuture<'_, std::io::Result<()>> {
         Box::pin(async move {
             let bytes_written = tokio::io::copy(&mut src, self).await?;
-            tracing::trace!(bytes_written, "Copying file into host filesystem",);
+            tracing::trace!(bytes_written, "Copying file into host filesystem");
             Ok(())
         })
     }
 
+    /// This method will copy a file from a source to this destination where
+    /// the default is to do a straight byte copy however file system implementors
+    /// may optimize this to cheaply clone and store the OwnedBuffer directly
+    fn copy_from_owned_buffer(&mut self, src: &OwnedBuffer) -> BoxFuture<'_, std::io::Result<()>> {
+        let src = src.clone();
+        Box::pin(async move {
+            let mut bytes = src.as_slice();
+            let bytes_written = tokio::io::copy(&mut bytes, self).await?;
+            tracing::trace!(bytes_written, "Copying file into host filesystem");
+            Ok(())
+        })
+    }
+
+    /// Get the full contents of this file as an [`OwnedBuffer`].
+    ///
+    /// **NOTE**: Only implement this if the file is already available in-memory
+    /// and can be cloned cheaply!
+    ///
+    /// Allows consumers to do zero-copy cloning of the underlying data.
+    fn as_owned_buffer(&self) -> Option<OwnedBuffer> {
+        None
+    }
+
     /// Polls the file for when there is data to be read
     fn poll_read_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>>;
 
diff --git a/lib/virtual-fs/src/mem_fs/file.rs b/lib/virtual-fs/src/mem_fs/file.rs
index 3c0f3837b4..cc12fd2c9f 100644
--- a/lib/virtual-fs/src/mem_fs/file.rs
+++ b/lib/virtual-fs/src/mem_fs/file.rs
@@ -3,6 +3,7 @@
 //! `FileHandle` can be used through the `VirtualFile` trait object.
 
 use futures::future::BoxFuture;
+use shared_buffer::OwnedBuffer;
 use tokio::io::AsyncRead;
 use tokio::io::{AsyncSeek, AsyncWrite};
 
@@ -11,7 +12,6 @@ use self::offloaded_file::OffloadWrite;
 use super::*;
 use crate::limiter::TrackedVec;
 use crate::{CopyOnWriteFile, FsError, Result, VirtualFile};
-use std::borrow::Cow;
 use std::cmp;
 use std::convert::TryInto;
 use std::fmt;
@@ -342,6 +342,38 @@ impl VirtualFile for FileHandle {
         })
     }
 
+    fn copy_from_owned_buffer(&mut self, src: &OwnedBuffer) -> BoxFuture<'_, std::io::Result<()>> {
+        let inner = self.filesystem.inner.clone();
+        let src = src.clone();
+        Box::pin(async move {
+            let mut fs = inner.write().unwrap();
+            let inode = fs.storage.get_mut(self.inode);
+            match inode {
+                Some(inode) => {
+                    let metadata = Metadata {
+                        ft: crate::FileType {
+                            file: true,
+                            ..Default::default()
+                        },
+                        accessed: 1,
+                        created: 1,
+                        modified: 1,
+                        len: src.len() as u64,
+                    };
+
+                    *inode = Node::ReadOnlyFile(ReadOnlyFileNode {
+                        inode: inode.inode(),
+                        name: inode.name().to_string_lossy().to_string().into(),
+                        file: ReadOnlyFile { buffer: src },
+                        metadata,
+                    });
+                    Ok(())
+                }
+                None => Err(std::io::ErrorKind::InvalidInput.into()),
+            }
+        })
+    }
+
     fn poll_read_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
         if !self.readable {
             return Poll::Ready(Err(io::Error::new(
@@ -475,6 +507,17 @@ impl VirtualFile for FileHandle {
         self.cursor = cursor;
         Ok(())
     }
+
+    fn as_owned_buffer(&self) -> Option<OwnedBuffer> {
+        let fs = self.filesystem.inner.read().ok()?;
+
+        let inode = fs.storage.get(self.inode)?;
+        match inode {
+            Node::ReadOnlyFile(f) => Some(f.file.buffer.clone()),
+            Node::CustomFile(f) => f.file.lock().ok()?.as_owned_buffer(),
+            _ => None,
+        }
+    }
 }
 
 #[cfg(test)]
@@ -680,8 +723,12 @@ impl AsyncRead for FileHandle {
             match inode {
                 Some(Node::File(node)) => {
                     let read = unsafe {
-                        node.file
-                            .read(std::mem::transmute(buf.unfilled_mut()), &mut cursor)
+                        node.file.read(
+                            std::mem::transmute::<&mut [std::mem::MaybeUninit<u8>], &mut [u8]>(
+                                buf.unfilled_mut(),
+                            ),
+                            &mut cursor,
+                        )
                     };
                     if let Ok(read) = &read {
                         unsafe { buf.assume_init(*read) };
@@ -691,8 +738,12 @@ impl AsyncRead for FileHandle {
                 }
                 Some(Node::OffloadedFile(node)) => {
                     let read = unsafe {
-                        node.file
-                            .read(std::mem::transmute(buf.unfilled_mut()), &mut cursor)
+                        node.file.read(
+                            std::mem::transmute::<&mut [std::mem::MaybeUninit<u8>], &mut [u8]>(
+                                buf.unfilled_mut(),
+                            ),
+                            &mut cursor,
+                        )
                     };
                     if let Ok(read) = &read {
                         unsafe { buf.assume_init(*read) };
@@ -702,8 +753,12 @@ impl AsyncRead for FileHandle {
                 }
                 Some(Node::ReadOnlyFile(node)) => {
                     let read = unsafe {
-                        node.file
-                            .read(std::mem::transmute(buf.unfilled_mut()), &mut cursor)
+                        node.file.read(
+                            std::mem::transmute::<&mut [std::mem::MaybeUninit<u8>], &mut [u8]>(
+                                buf.unfilled_mut(),
+                            ),
+                            &mut cursor,
+                        )
                     };
                     if let Ok(read) = &read {
                         unsafe { buf.assume_init(*read) };
@@ -1511,11 +1566,11 @@ impl File {
 /// Read only file that uses copy-on-write
 #[derive(Debug)]
 pub(super) struct ReadOnlyFile {
-    buffer: Cow<'static, [u8]>,
+    buffer: OwnedBuffer,
 }
 
 impl ReadOnlyFile {
-    pub(super) fn new(buffer: Cow<'static, [u8]>) -> Self {
+    pub(super) fn new(buffer: OwnedBuffer) -> Self {
         Self { buffer }
     }
 
diff --git a/lib/virtual-fs/src/mem_fs/file_opener.rs b/lib/virtual-fs/src/mem_fs/file_opener.rs
index 46be5e53b1..32d96120e3 100644
--- a/lib/virtual-fs/src/mem_fs/file_opener.rs
+++ b/lib/virtual-fs/src/mem_fs/file_opener.rs
@@ -1,14 +1,14 @@
 use super::filesystem::InodeResolution;
 use super::*;
 use crate::{FileType, FsError, Metadata, OpenOptionsConfig, Result, VirtualFile};
-use std::borrow::Cow;
+use shared_buffer::OwnedBuffer;
 use std::path::Path;
 use tracing::*;
 
 impl FileSystem {
     /// Inserts a readonly file into the file system that uses copy-on-write
     /// (this is required for zero-copy creation of the same file)
-    pub fn insert_ro_file(&self, path: &Path, contents: Cow<'static, [u8]>) -> Result<()> {
+    pub fn insert_ro_file(&self, path: &Path, contents: OwnedBuffer) -> Result<()> {
         let _ = crate::FileSystem::remove_file(self, path);
         let (inode_of_parent, maybe_inode_of_file, name_of_file) = self.insert_inode(path)?;
 
diff --git a/lib/virtual-fs/src/mem_fs/filesystem.rs b/lib/virtual-fs/src/mem_fs/filesystem.rs
index 65b34ce542..7a336fb89d 100644
--- a/lib/virtual-fs/src/mem_fs/filesystem.rs
+++ b/lib/virtual-fs/src/mem_fs/filesystem.rs
@@ -447,7 +447,7 @@ impl crate::FileSystem for FileSystem {
     }
 
     fn rename<'a>(&'a self, from: &'a Path, to: &'a Path) -> BoxFuture<'a, Result<()>> {
-        Box::pin(async {
+        Box::pin(async move {
             let name_of_to;
 
             // Read lock.
@@ -493,6 +493,7 @@ impl crate::FileSystem for FileSystem {
             };
 
             match (inode_of_from_parent, inode_of_to_parent) {
+                // Rename within this MemFS instance
                 (Either::Left(inode_of_from_parent), Either::Left(inode_of_to_parent)) => {
                     let fs = self.inner.read().map_err(|_| FsError::Lock)?;
 
@@ -572,16 +573,34 @@ impl crate::FileSystem for FileSystem {
 
                     Ok(())
                 }
-                (Either::Right((from_fs, from_path)), Either::Right((to_fs, to_path))) => {
-                    if Arc::ptr_eq(&from_fs, &to_fs) {
-                        let same_fs = from_fs;
 
-                        same_fs.rename(&from_path, &to_path).await
-                    } else {
-                        Err(FsError::InvalidInput)
+                // Rename within the same mounted FS instance
+                (Either::Right((from_fs, from_path)), Either::Right((to_fs, to_path)))
+                    if Arc::ptr_eq(&from_fs, &to_fs) =>
+                {
+                    let same_fs = from_fs;
+                    same_fs.rename(&from_path, &to_path).await
+                }
+
+                // Rename across file systems; we need to do a create and a delete
+                _ => {
+                    let mut from_file = self.new_open_options().read(true).open(from)?;
+                    let mut to_file = self
+                        .new_open_options()
+                        .create_new(true)
+                        .write(true)
+                        .open(to)?;
+                    tokio::io::copy(from_file.as_mut(), to_file.as_mut()).await?;
+                    if let Err(error) = self.remove_file(from) {
+                        tracing::warn!(
+                            ?from,
+                            ?to,
+                            ?error,
+                            "Failed to remove file after cross-FS rename"
+                        );
                     }
+                    Ok(())
                 }
-                _ => Err(FsError::InvalidInput),
             }
         })
     }
@@ -1132,8 +1151,9 @@ impl DirectoryMustBeEmpty {
 
 #[cfg(test)]
 mod test_filesystem {
-    use std::{borrow::Cow, path::Path};
+    use std::path::Path;
 
+    use shared_buffer::OwnedBuffer;
     use tokio::io::AsyncReadExt;
 
     use crate::{mem_fs::*, ops, DirEntry, FileSystem as FS, FileType, FsError};
@@ -1178,7 +1198,7 @@ mod test_filesystem {
             "creating the root which already exists",
         );
 
-        assert_eq!(fs.create_dir(path!("/foo")), Ok(()), "creating a directory",);
+        assert_eq!(fs.create_dir(path!("/foo")), Ok(()), "creating a directory");
 
         {
             let fs_inner = fs.inner.read().unwrap();
@@ -1281,7 +1301,7 @@ mod test_filesystem {
             "cannot remove a directory that doesn't exist",
         );
 
-        assert_eq!(fs.create_dir(path!("/foo")), Ok(()), "creating a directory",);
+        assert_eq!(fs.create_dir(path!("/foo")), Ok(()), "creating a directory");
 
         assert_eq!(
             fs.create_dir(path!("/foo/bar")),
@@ -1310,7 +1330,7 @@ mod test_filesystem {
             "removing a sub-directory",
         );
 
-        assert_eq!(fs.remove_dir(path!("/foo")), Ok(()), "removing a directory",);
+        assert_eq!(fs.remove_dir(path!("/foo")), Ok(()), "removing a directory");
 
         {
             let fs_inner = fs.inner.read().unwrap();
@@ -1923,13 +1943,13 @@ mod test_filesystem {
         let other = FileSystem::default();
         crate::ops::create_dir_all(&other, "/a/x").unwrap();
         other
-            .insert_ro_file(Path::new("/a/x/a.txt"), Cow::Borrowed(b"a"))
+            .insert_ro_file(Path::new("/a/x/a.txt"), OwnedBuffer::from_static(b"a"))
             .unwrap();
         other
-            .insert_ro_file(Path::new("/a/x/b.txt"), Cow::Borrowed(b"b"))
+            .insert_ro_file(Path::new("/a/x/b.txt"), OwnedBuffer::from_static(b"b"))
             .unwrap();
         other
-            .insert_ro_file(Path::new("/a/x/c.txt"), Cow::Borrowed(b"c"))
+            .insert_ro_file(Path::new("/a/x/c.txt"), OwnedBuffer::from_static(b"c"))
             .unwrap();
 
         let out = other.read_dir(Path::new("/")).unwrap();
diff --git a/lib/virtual-fs/src/mem_fs/mod.rs b/lib/virtual-fs/src/mem_fs/mod.rs
index 33ea3ef51a..036c98fe0a 100644
--- a/lib/virtual-fs/src/mem_fs/mod.rs
+++ b/lib/virtual-fs/src/mem_fs/mod.rs
@@ -7,7 +7,11 @@ mod stdio;
 use file::{File, FileHandle, ReadOnlyFile};
 pub use filesystem::FileSystem;
 pub use offloaded_file::OffloadBackingStore;
+#[cfg(not(feature = "js"))]
+use std::time::{SystemTime, UNIX_EPOCH};
 pub use stdio::{Stderr, Stdin, Stdout};
+#[cfg(feature = "js")]
+pub use web_time::{SystemTime, UNIX_EPOCH};
 
 use crate::Metadata;
 use std::{
@@ -54,6 +58,8 @@ struct ArcFileNode {
     metadata: Metadata,
 }
 
+// FIXME: this is broken!!! A `VirtualFile` stores its own offset,
+// so a file stored this way can only be read once!
 #[derive(Debug)]
 struct CustomFileNode {
     inode: Inode,
@@ -153,18 +159,10 @@ impl Node {
 }
 
 fn time() -> u64 {
-    #[cfg(not(feature = "no-time"))]
-    {
-        // SAFETY: It's very unlikely that the system returns a time that
-        // is before `UNIX_EPOCH` :-).
-        std::time::SystemTime::now()
-            .duration_since(std::time::SystemTime::UNIX_EPOCH)
-            .unwrap()
-            .as_nanos() as u64
-    }
-
-    #[cfg(feature = "no-time")]
-    {
-        0
-    }
+    // SAFETY: It's very unlikely that the system returns a time that
+    // is before `UNIX_EPOCH` :-).
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_nanos() as u64
 }
diff --git a/lib/virtual-fs/src/mem_fs/offloaded_file.rs b/lib/virtual-fs/src/mem_fs/offloaded_file.rs
index d22cccc774..b89d243d93 100644
--- a/lib/virtual-fs/src/mem_fs/offloaded_file.rs
+++ b/lib/virtual-fs/src/mem_fs/offloaded_file.rs
@@ -136,7 +136,7 @@ pub enum OffloadWrite<'a> {
     Buffer(&'a [u8]),
 }
 
-impl<'a> OffloadWrite<'a> {
+impl OffloadWrite<'_> {
     fn len(&self) -> usize {
         match self {
             OffloadWrite::MmapOffset { size, .. } => *size as usize,
diff --git a/lib/virtual-fs/src/mem_fs/stdio.rs b/lib/virtual-fs/src/mem_fs/stdio.rs
index 6153994529..a13f5d026d 100644
--- a/lib/virtual-fs/src/mem_fs/stdio.rs
+++ b/lib/virtual-fs/src/mem_fs/stdio.rs
@@ -204,11 +204,7 @@ mod test_read_write_seek {
             matches!(stdin.read_to_end(&mut buffer).await, Ok(3)),
             "reading bytes again from `stdin`",
         );
-        assert_eq!(
-            buffer,
-            &[b'b', b'a', b'r'],
-            "checking the bytes read from `stdin`"
-        );
+        assert_eq!(buffer, b"bar", "checking the bytes read from `stdin`");
 
         let mut buffer = [0; 1];
 
@@ -265,11 +261,7 @@ mod test_read_write_seek {
             matches!(stdout.write(b"qux").await, Ok(3)),
             "writing again into `stdout`",
         );
-        assert_eq!(
-            stdout.buf,
-            &[b'b', b'a', b'z', b'q', b'u', b'x'],
-            "checking the content of `stdout`",
-        );
+        assert_eq!(stdout.buf, b"bazqux", "checking the content of `stdout`");
     }
 
     #[tokio::test]
@@ -309,11 +301,7 @@ mod test_read_write_seek {
             matches!(stderr.write(b"qux").await, Ok(3)),
             "writing again into `stderr`",
         );
-        assert_eq!(
-            stderr.buf,
-            &[b'b', b'a', b'z', b'q', b'u', b'x'],
-            "checking the content of `stderr`",
-        );
+        assert_eq!(stderr.buf, b"bazqux", "checking the content of `stderr`");
     }
 
     #[tokio::test]
diff --git a/lib/virtual-fs/src/overlay_fs.rs b/lib/virtual-fs/src/overlay_fs.rs
index 90c1803ece..780b3fb860 100644
--- a/lib/virtual-fs/src/overlay_fs.rs
+++ b/lib/virtual-fs/src/overlay_fs.rs
@@ -823,7 +823,7 @@ where
         fn poll_copy_start_and_progress(&mut self, cx: &mut Context) -> Poll<io::Result<()>> {
             replace_with_or_abort(&mut self.state, |state| match state {
                 CowState::ReadOnly(inner) => {
-                    tracing::trace!("COW file touched, starting file clone",);
+                    tracing::trace!("COW file touched, starting file clone");
                     CowState::SeekingGet(inner)
                 }
                 state => state,
@@ -970,22 +970,33 @@ where
             mut self: Pin<&mut Self>,
             cx: &mut std::task::Context<'_>,
         ) -> Poll<Result<(), std::io::Error>> {
-            match self.poll_copy_start_and_progress(cx) {
+            match self.poll_copy_progress(cx) {
                 Poll::Ready(Ok(())) => {}
-                p => return p,
+                Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
+                Poll::Pending => return Poll::Pending,
+            }
+            // The file may actually be read-only and not support flush operations
+            // at all, and there's nothing to flush in read-only state anyway.
+            match self.state {
+                CowState::ReadOnly(_) => Poll::Ready(Ok(())),
+                _ => Pin::new(self.state.as_mut()).poll_flush(cx),
             }
-            Pin::new(self.state.as_mut()).poll_flush(cx)
         }
 
         fn poll_shutdown(
             mut self: Pin<&mut Self>,
             cx: &mut std::task::Context<'_>,
         ) -> Poll<Result<(), std::io::Error>> {
-            match self.poll_copy_start_and_progress(cx) {
+            match self.poll_copy_progress(cx) {
                 Poll::Ready(Ok(())) => {}
-                p => return p,
+                Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
+                Poll::Pending => return Poll::Pending,
+            }
+            // Same deal as flush above
+            match self.state {
+                CowState::ReadOnly(_) => Poll::Ready(Ok(())),
+                _ => Pin::new(self.state.as_mut()).poll_shutdown(cx),
             }
-            Pin::new(self.state.as_mut()).poll_shutdown(cx)
         }
     }
 
@@ -1082,7 +1093,7 @@ where
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         struct IterFilesystems<'a, S>(&'a S);
-        impl<'a, S> Debug for IterFilesystems<'a, S>
+        impl<S> Debug for IterFilesystems<'_, S>
         where
             S: for<'b> FileSystems<'b>,
         {
@@ -1285,7 +1296,7 @@ mod tests {
         f.set_len(0).unwrap();
         assert_eq!(f.write(b"Hi").await.unwrap(), 2);
         // Same with flushing
-        assert_eq!(f.flush().await.unwrap(), (),);
+        assert_eq!(f.flush().await.unwrap(), ());
 
         // if we now read it then the data should be different
         buf = String::new();
@@ -1538,6 +1549,39 @@ mod tests {
         )
     }
 
+    /// Make sure files that are never written are not copied to the primary,
+    /// even when opened with write permissions.
+    /// Regression test for https://github.com/wasmerio/wasmer/issues/5445
+    #[tokio::test]
+    async fn test_overlayfs_readonly_files_not_copied() {
+        let primary = MemFS::default();
+        let secondary = MemFS::default();
+        ops::create_dir_all(&secondary, "/secondary").unwrap();
+        ops::write(&secondary, "/secondary/file.txt", b"Hello, World!")
+            .await
+            .unwrap();
+
+        let fs = OverlayFileSystem::new(primary, [secondary]);
+
+        {
+            let mut f = fs
+                .new_open_options()
+                .read(true)
+                .write(true)
+                .open(Path::new("/secondary/file.txt"))
+                .unwrap();
+            let mut s = String::new();
+            f.read_to_string(&mut s).await.unwrap();
+            assert_eq!(s, "Hello, World!");
+
+            f.flush().await.unwrap();
+            f.shutdown().await.unwrap();
+        }
+
+        // Primary should not have the file
+        assert!(!ops::is_file(&fs.primary, "/secondary/file.txt"));
+    }
+
     // OLD tests that used WebcFileSystem.
     // Should be re-implemented with WebcVolumeFs
     // #[tokio::test]
diff --git a/lib/virtual-fs/src/pipe.rs b/lib/virtual-fs/src/pipe.rs
index f88d1489c8..88c53ae493 100644
--- a/lib/virtual-fs/src/pipe.rs
+++ b/lib/virtual-fs/src/pipe.rs
@@ -1,19 +1,28 @@
 use bytes::{Buf, Bytes};
-#[cfg(feature = "futures")]
-use futures::Future;
-use std::io::IoSlice;
-use std::io::{self, Read, Seek, SeekFrom};
-use std::ops::DerefMut;
 use std::pin::Pin;
 use std::sync::Arc;
 use std::sync::Mutex;
 use std::task::Context;
 use std::task::Poll;
-use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite};
-use tokio::sync::{mpsc, mpsc::error::TryRecvError};
+use std::{io::IoSlice, sync::MutexGuard};
+use std::{
+    io::{self, Read, Seek, SeekFrom},
+    sync::Weak,
+};
+use tokio::sync::mpsc;
+use tokio::{
+    io::{AsyncRead, AsyncSeek, AsyncWrite},
+    sync::mpsc::error::TryRecvError,
+};
+use virtual_mio::{InterestHandler, InterestType};
 
 use crate::{ArcFile, FsError, VirtualFile};
 
+// Each pipe end is separately cloneable. The overall pipe
+// remains open as long as at least one tx end and one rx
+// end are still alive.
+// As such, closing a pipe isn't a well-defined operation,
+// since more references to the ends may still be alive.
 #[derive(Debug, Clone)]
 pub struct Pipe {
     /// Transmit side of the pipe
@@ -25,37 +34,57 @@ pub struct Pipe {
 #[derive(Debug, Clone)]
 pub struct PipeTx {
     /// Sends bytes down the pipe
-    tx: Arc<Mutex<mpsc::UnboundedSender<Vec<u8>>>>,
+    tx: Option<mpsc::UnboundedSender<Vec<u8>>>,
+    rx_end: Weak<Mutex<PipeReceiver>>,
 }
 
 #[derive(Debug, Clone)]
 pub struct PipeRx {
     /// Receives bytes from the pipe
     /// Also, buffers the last read message from the pipe while its being consumed
-    rx: Arc<Mutex<PipeReceiver>>,
+    rx: Option<Arc<Mutex<PipeReceiver>>>,
 }
 
 impl PipeRx {
-    fn try_read(&mut self, buf: &mut [u8]) -> Option<usize> {
-        let max_size = buf.len();
+    // Tries to read from the internal buffer if data is available.
+    fn try_read_from_buffer(
+        rx: &mut MutexGuard<'_, PipeReceiver>,
+        max_len: usize,
+        // Should return how much actual data was read from the provided slice
+        write: impl FnOnce(&[u8]) -> Option<usize>,
+    ) -> Option<usize> {
+        rx.buffer.as_mut().and_then(|read_buffer| {
+            let buf_len = read_buffer.len();
+            if buf_len > 0 {
+                let mut read = buf_len.min(max_len);
+                let inner_buf = &read_buffer[..read];
+                // read = ?;
+                read = write(inner_buf)?;
+                read_buffer.advance(read);
+                Some(read)
+            } else {
+                None
+            }
+        })
+    }
+
+    pub fn close(&mut self) {
+        _ = self.rx.take();
+    }
 
-        let mut rx = self.rx.lock().unwrap();
+    pub fn try_read(&mut self, buf: &mut [u8]) -> Option<usize> {
+        let Some(ref mut rx) = self.rx else {
+            return Some(0);
+        };
+
+        let mut rx = rx.lock().unwrap();
         loop {
-            {
-                if let Some(read_buffer) = rx.buffer.as_mut() {
-                    let buf_len = read_buffer.len();
-                    if buf_len > 0 {
-                        let mut read = buf_len.min(max_size);
-                        let mut inner_buf = &read_buffer[..read];
-                        read = match Read::read(&mut inner_buf, buf) {
-                            Ok(a) => a,
-                            Err(_) => return None,
-                        };
-                        read_buffer.advance(read);
-                        return Some(read);
-                    }
-                }
-            }
+            if let Some(read) = Self::try_read_from_buffer(&mut rx, buf.len(), |mut read_buf| {
+                Read::read(&mut read_buf, buf).ok()
+            }) {
+                return Some(read);
+            };
+
             let data = {
                 match rx.chan.try_recv() {
                     Ok(a) => a,
@@ -70,28 +99,76 @@ impl PipeRx {
             rx.buffer.replace(Bytes::from(data));
         }
     }
+
+    pub fn poll_read_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        let Some(ref rx) = self.rx else {
+            return Poll::Ready(Err(std::io::Error::new(
+                std::io::ErrorKind::BrokenPipe,
+                "PipeRx is closed",
+            )));
+        };
+
+        let mut rx = rx.lock().unwrap();
+        loop {
+            {
+                if let Some(inner_buf) = rx.buffer.as_mut() {
+                    let buf_len = inner_buf.len();
+                    if buf_len > 0 {
+                        return Poll::Ready(Ok(buf_len));
+                    }
+                }
+            }
+
+            let mut pinned_rx = Pin::new(&mut rx.chan);
+            let data = match pinned_rx.poll_recv(cx) {
+                Poll::Ready(Some(a)) => a,
+                Poll::Ready(None) => return Poll::Ready(Ok(0)),
+                Poll::Pending => return Poll::Pending,
+            };
+
+            rx.buffer.replace(Bytes::from(data));
+        }
+    }
+
+    pub fn set_interest_handler(&self, interest_handler: Box<dyn InterestHandler>) {
+        let Some(ref rx) = self.rx else {
+            return;
+        };
+        let mut rx = rx.lock().unwrap();
+        rx.interest_handler.replace(interest_handler);
+    }
+
+    pub fn remove_interest_handler(&self) -> Option<Box<dyn InterestHandler>> {
+        let rx = self.rx.as_ref()?;
+        let mut rx = rx.lock().unwrap();
+        rx.interest_handler.take()
+    }
 }
 
 #[derive(Debug)]
 struct PipeReceiver {
+    // Note: Since we need to store the buffer alongside the
+    // actual receiver, we can't make use of an mpmc channel
     chan: mpsc::UnboundedReceiver<Vec<u8>>,
     buffer: Option<Bytes>,
+    interest_handler: Option<Box<dyn InterestHandler>>,
 }
 
 impl Pipe {
-    fn new() -> Self {
+    pub fn new() -> Self {
         let (tx, rx) = mpsc::unbounded_channel();
 
+        let recv = Arc::new(Mutex::new(PipeReceiver {
+            chan: rx,
+            buffer: None,
+            interest_handler: None,
+        }));
         Pipe {
             send: PipeTx {
-                tx: Arc::new(Mutex::new(tx)),
-            },
-            recv: PipeRx {
-                rx: Arc::new(Mutex::new(PipeReceiver {
-                    chan: rx,
-                    buffer: None,
-                })),
+                tx: Some(tx),
+                rx_end: Arc::downgrade(&recv),
             },
+            recv: PipeRx { rx: Some(recv) },
         }
     }
 
@@ -115,33 +192,53 @@ impl Pipe {
     pub fn try_read(&mut self, buf: &mut [u8]) -> Option<usize> {
         self.recv.try_read(buf)
     }
-}
 
-impl From<Pipe> for PipeTx {
-    fn from(val: Pipe) -> Self {
-        val.send
+    pub fn close(&mut self) {
+        self.send.close();
+        self.recv.close();
+    }
+
+    pub fn set_interest_handler(&self, interest_handler: Box<dyn InterestHandler>) {
+        self.recv.set_interest_handler(interest_handler);
     }
-}
 
-impl From<Pipe> for PipeRx {
-    fn from(val: Pipe) -> Self {
-        val.recv
+    pub fn remove_interest_handler(&self) -> Option<Box<dyn InterestHandler>> {
+        self.recv.remove_interest_handler()
     }
 }
 
-impl Pipe {
-    pub fn close(&self) {
-        self.send.close();
+impl Default for Pipe {
+    fn default() -> Self {
+        Self::new()
     }
 }
 
 impl PipeTx {
-    pub fn close(&self) {
-        // TODO: proper close() implementation - Propably want to store the writer in an Option<>
-        let (mut null_tx, _) = mpsc::unbounded_channel();
-        {
-            let mut guard = self.tx.lock().unwrap();
-            std::mem::swap(guard.deref_mut(), &mut null_tx);
+    pub fn close(&mut self) {
+        _ = self.tx.take();
+    }
+
+    pub fn poll_write_ready(self: Pin<&mut Self>) -> Poll<io::Result<usize>> {
+        let Some(ref tx) = self.tx else {
+            return Poll::Ready(Err(std::io::Error::new(
+                std::io::ErrorKind::BrokenPipe,
+                "PipeTx is closed",
+            )));
+        };
+
+        if tx.is_closed() {
+            Poll::Ready(Ok(0))
+        } else {
+            Poll::Ready(Ok(8192))
+        }
+    }
+
+    fn mark_other_end_readable(&self) {
+        if let Some(rx_end) = self.rx_end.upgrade() {
+            let mut guard = rx_end.lock().unwrap();
+            if let Some(interest_handler) = guard.interest_handler.as_mut() {
+                interest_handler.push_interest(InterestType::Readable);
+            }
         }
     }
 }
@@ -172,22 +269,21 @@ impl Read for Pipe {
 
 impl Read for PipeRx {
     fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
-        let max_size = buf.len();
+        let Some(ref mut rx) = self.rx else {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::BrokenPipe,
+                "PipeRx is closed",
+            ));
+        };
 
-        let mut rx = self.rx.lock().unwrap();
+        let mut rx = rx.lock().unwrap();
         loop {
-            {
-                if let Some(read_buffer) = rx.buffer.as_mut() {
-                    let buf_len = read_buffer.len();
-                    if buf_len > 0 {
-                        let mut read = buf_len.min(max_size);
-                        let mut inner_buf = &read_buffer[..read];
-                        read = Read::read(&mut inner_buf, buf)?;
-                        read_buffer.advance(read);
-                        return Ok(read);
-                    }
-                }
+            if let Some(read) = Self::try_read_from_buffer(&mut rx, buf.len(), |mut read_buf| {
+                Read::read(&mut read_buf, buf).ok()
+            }) {
+                return Ok(read);
             }
+
             let data = {
                 match rx.chan.blocking_recv() {
                     Some(a) => a,
@@ -225,9 +321,16 @@ impl std::io::Write for Pipe {
 
 impl std::io::Write for PipeTx {
     fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-        let tx = self.tx.lock().unwrap();
+        let Some(ref tx) = self.tx else {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::BrokenPipe,
+                "PipeTx is closed",
+            ));
+        };
+
         tx.send(buf.to_vec())
             .map_err(|_| Into::<std::io::Error>::into(std::io::ErrorKind::BrokenPipe))?;
+        self.mark_other_end_readable();
         Ok(buf.len())
     }
 
@@ -305,9 +408,18 @@ impl AsyncWrite for PipeTx {
         _cx: &mut Context<'_>,
         buf: &[u8],
     ) -> Poll<io::Result<usize>> {
-        let guard = self.tx.lock().unwrap();
-        match guard.send(buf.to_vec()) {
-            Ok(()) => Poll::Ready(Ok(buf.len())),
+        let Some(ref tx) = self.tx else {
+            return Poll::Ready(Err(std::io::Error::new(
+                std::io::ErrorKind::BrokenPipe,
+                "PipeTx is closed",
+            )));
+        };
+
+        match tx.send(buf.to_vec()) {
+            Ok(()) => {
+                self.mark_other_end_readable();
+                Poll::Ready(Ok(buf.len()))
+            }
             Err(_) => Poll::Ready(Err(Into::<std::io::Error>::into(
                 std::io::ErrorKind::BrokenPipe,
             ))),
@@ -318,7 +430,7 @@ impl AsyncWrite for PipeTx {
         Poll::Ready(Ok(()))
     }
 
-    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+    fn poll_shutdown(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
         self.close();
         Poll::Ready(Ok(()))
     }
@@ -337,24 +449,28 @@ impl AsyncRead for Pipe {
 
 impl AsyncRead for PipeRx {
     fn poll_read(
-        self: Pin<&mut Self>,
+        mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
         buf: &mut tokio::io::ReadBuf<'_>,
     ) -> Poll<io::Result<()>> {
-        let mut rx = self.rx.lock().unwrap();
+        let Some(ref mut rx) = self.rx else {
+            return Poll::Ready(Err(std::io::Error::new(
+                std::io::ErrorKind::BrokenPipe,
+                "PipeRx is closed",
+            )));
+        };
+
+        let mut rx = rx.lock().unwrap();
         loop {
+            if Self::try_read_from_buffer(&mut rx, buf.remaining(), |read_buf| {
+                buf.put_slice(read_buf);
+                Some(read_buf.len())
+            })
+            .is_some()
             {
-                if let Some(inner_buf) = rx.buffer.as_mut() {
-                    let buf_len = inner_buf.len();
-                    if buf_len > 0 {
-                        let read = buf_len.min(buf.remaining());
-                        buf.put_slice(&inner_buf[..read]);
-                        inner_buf.advance(read);
-                        return Poll::Ready(Ok(()));
-                    }
-                }
+                return Poll::Ready(Ok(()));
             }
-            let mut rx = Pin::new(rx.deref_mut());
+
             let data = match rx.chan.poll_recv(cx) {
                 Poll::Ready(Some(a)) => a,
                 Poll::Ready(None) => return Poll::Ready(Ok(())),
@@ -403,43 +519,22 @@ impl VirtualFile for Pipe {
     fn is_open(&self) -> bool {
         self.send
             .tx
-            .try_lock()
+            .as_ref()
             .map(|a| !a.is_closed())
-            .unwrap_or_else(|_| true)
+            .unwrap_or_else(|| false)
     }
 
     /// Polls the file for when there is data to be read
-    fn poll_read_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
-        let mut rx = self.recv.rx.lock().unwrap();
-        loop {
-            {
-                if let Some(inner_buf) = rx.buffer.as_mut() {
-                    let buf_len = inner_buf.len();
-                    if buf_len > 0 {
-                        return Poll::Ready(Ok(buf_len));
-                    }
-                }
-            }
-
-            let mut pinned_rx = Pin::new(&mut rx.chan);
-            let data = match pinned_rx.poll_recv(cx) {
-                Poll::Ready(Some(a)) => a,
-                Poll::Ready(None) => return Poll::Ready(Ok(0)),
-                Poll::Pending => return Poll::Pending,
-            };
-
-            rx.buffer.replace(Bytes::from(data));
-        }
+    fn poll_read_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Pin::new(&mut self.recv).poll_read_ready(cx)
     }
 
     /// Polls the file for when it is available for writing
-    fn poll_write_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
-        let tx = self.send.tx.lock().unwrap();
-        if tx.is_closed() {
-            Poll::Ready(Ok(0))
-        } else {
-            Poll::Ready(Ok(8192))
-        }
+    fn poll_write_ready(
+        mut self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut self.send).poll_write_ready()
     }
 }
 
diff --git a/lib/virtual-fs/src/union_fs.rs b/lib/virtual-fs/src/union_fs.rs
index 88d56ad061..5058dc1c42 100644
--- a/lib/virtual-fs/src/union_fs.rs
+++ b/lib/virtual-fs/src/union_fs.rs
@@ -520,7 +520,7 @@ mod tests {
     async fn test_create_dir() {
         let fs = gen_filesystem();
 
-        assert_eq!(fs.create_dir(Path::new("/")), Ok(()),);
+        assert_eq!(fs.create_dir(Path::new("/")), Ok(()));
 
         assert_eq!(fs.create_dir(Path::new("/test_create_dir")), Ok(()));
 
@@ -533,7 +533,7 @@ mod tests {
         let cur_dir = read_dir_names(&fs, "/test_create_dir");
 
         if !cur_dir.contains(&"foo".to_string()) {
-            panic!("cur_dir does not contain foo: {:#?}", cur_dir);
+            panic!("cur_dir does not contain foo: {cur_dir:#?}");
         }
 
         assert!(
@@ -644,7 +644,7 @@ mod tests {
             "renaming to a directory that has no parent",
         );
 
-        assert_eq!(fs.create_dir(Path::new("/test_rename")), Ok(()),);
+        assert_eq!(fs.create_dir(Path::new("/test_rename")), Ok(()));
         assert_eq!(fs.create_dir(Path::new("/test_rename/foo")), Ok(()));
         assert_eq!(fs.create_dir(Path::new("/test_rename/foo/qux")), Ok(()));
 
@@ -699,7 +699,7 @@ mod tests {
         let bar_dir = read_dir_names(&fs, "/test_rename/bar");
 
         if !bar_dir.contains(&"qux".to_string()) {
-            println!("qux does not exist: {:?}", bar_dir)
+            println!("qux does not exist: {bar_dir:?}")
         }
 
         let qux_dir = read_dir_names(&fs, "/test_rename/bar/qux");
@@ -913,7 +913,7 @@ mod tests {
             "creating `b.txt`",
         );
 
-        println!("fs: {:?}", fs);
+        println!("fs: {fs:?}");
 
         let readdir = fs.read_dir(Path::new("/test_readdir"));
 
@@ -923,7 +923,7 @@ mod tests {
 
         let next = readdir.next().unwrap().unwrap();
         assert!(next.path.ends_with("foo"), "checking entry #1");
-        println!("entry 1: {:#?}", next);
+        println!("entry 1: {next:#?}");
         assert!(next.file_type().unwrap().is_dir(), "checking entry #1");
 
         let next = readdir.next().unwrap().unwrap();
@@ -943,7 +943,7 @@ mod tests {
         assert!(next.file_type().unwrap().is_file(), "checking entry #5");
 
         if let Some(s) = readdir.next() {
-            panic!("next: {:?}", s);
+            panic!("next: {s:?}");
         }
 
         let _ = fs_extra::remove_items(&["./test_readdir"]);
diff --git a/lib/virtual-fs/src/webc_volume_fs.rs b/lib/virtual-fs/src/webc_volume_fs.rs
index 745a0570e3..b14309e262 100644
--- a/lib/virtual-fs/src/webc_volume_fs.rs
+++ b/lib/virtual-fs/src/webc_volume_fs.rs
@@ -10,8 +10,8 @@ use std::{
 use futures::future::BoxFuture;
 use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite};
 use webc::{
-    compat::{Container, SharedBytes, Volume},
-    PathSegmentError, PathSegments, ToPathSegments,
+    compat::SharedBytes, Container, Metadata as WebcMetadata, PathSegmentError, PathSegments,
+    ToPathSegments, Volume,
 };
 
 use crate::{
@@ -251,6 +251,10 @@ impl VirtualFile for File {
     ) -> Poll<std::io::Result<usize>> {
         Poll::Ready(Err(std::io::ErrorKind::PermissionDenied.into()))
     }
+
+    fn as_owned_buffer(&self) -> Option<SharedBytes> {
+        Some(self.content.get_ref().clone())
+    }
 }
 
 impl AsyncRead for File {
@@ -300,17 +304,19 @@ impl AsyncWrite for File {
     }
 }
 
-// HACK: timestamps are not present in webc v2, so we have to return
-// a stub modified time. previously we used to just return 0, but that
-// proved to cause problems with programs that interpret the value 0.
-// to circumvent this problem, we decided to return a non-zero value.
+// HACK: WebC v2 doesn't have timestamps, and WebC v3 files sometimes
+// have directories with a zero timestamp as well. Since some programs
+// interpret a zero timestamp as the absence of a value, we return
+// 1 second past epoch instead.
 fn get_modified(timestamps: Option<webc::Timestamps>) -> u64 {
-    timestamps.map(|t| t.modified()).unwrap_or(1)
+    let modified = timestamps.map(|t| t.modified()).unwrap_or_default();
+    // 1 billion nanoseconds = 1 second
+    modified.max(1_000_000_000)
 }
 
-fn compat_meta(meta: webc::compat::Metadata) -> Metadata {
+fn compat_meta(meta: WebcMetadata) -> Metadata {
     match meta {
-        webc::compat::Metadata::Dir { timestamps } => Metadata {
+        WebcMetadata::Dir { timestamps } => Metadata {
             ft: FileType {
                 dir: true,
                 ..Default::default()
@@ -318,7 +324,7 @@ fn compat_meta(meta: webc::compat::Metadata) -> Metadata {
             modified: get_modified(timestamps),
             ..Default::default()
         },
-        webc::compat::Metadata::File {
+        WebcMetadata::File {
             length, timestamps, ..
         } => Metadata {
             ft: FileType {
@@ -355,6 +361,7 @@ mod tests {
     use crate::DirEntry;
     use std::convert::TryFrom;
     use tokio::io::AsyncReadExt;
+    use wasmer_package::utils::from_bytes;
 
     const PYTHON_WEBC: &[u8] = include_bytes!("../../c-api/examples/assets/python-0.1.0.wasmer");
 
@@ -418,7 +425,7 @@ mod tests {
 
     #[test]
     fn mount_all_volumes_in_python() {
-        let container = Container::from_bytes(PYTHON_WEBC).unwrap();
+        let container = from_bytes(PYTHON_WEBC).unwrap();
 
         let fs = WebcVolumeFileSystem::mount_all(&container);
 
@@ -429,7 +436,7 @@ mod tests {
 
     #[test]
     fn read_dir() {
-        let container = Container::from_bytes(PYTHON_WEBC).unwrap();
+        let container = from_bytes(PYTHON_WEBC).unwrap();
         let volumes = container.volumes();
         let volume = volumes["atom"].clone();
 
@@ -501,7 +508,7 @@ mod tests {
 
     #[test]
     fn metadata() {
-        let container = Container::from_bytes(PYTHON_WEBC).unwrap();
+        let container = from_bytes(PYTHON_WEBC).unwrap();
         let volumes = container.volumes();
         let volume = volumes["atom"].clone();
 
@@ -553,7 +560,7 @@ mod tests {
 
     #[tokio::test]
     async fn file_opener() {
-        let container = Container::from_bytes(PYTHON_WEBC).unwrap();
+        let container = from_bytes(PYTHON_WEBC).unwrap();
         let volumes = container.volumes();
         let volume = volumes["atom"].clone();
 
@@ -596,7 +603,7 @@ mod tests {
 
     #[test]
     fn remove_dir_is_not_allowed() {
-        let container = Container::from_bytes(PYTHON_WEBC).unwrap();
+        let container = from_bytes(PYTHON_WEBC).unwrap();
         let volumes = container.volumes();
         let volume = volumes["atom"].clone();
 
@@ -618,7 +625,7 @@ mod tests {
 
     #[test]
     fn remove_file_is_not_allowed() {
-        let container = Container::from_bytes(PYTHON_WEBC).unwrap();
+        let container = from_bytes(PYTHON_WEBC).unwrap();
         let volumes = container.volumes();
         let volume = volumes["atom"].clone();
 
@@ -640,7 +647,7 @@ mod tests {
 
     #[test]
     fn create_dir_is_not_allowed() {
-        let container = Container::from_bytes(PYTHON_WEBC).unwrap();
+        let container = from_bytes(PYTHON_WEBC).unwrap();
         let volumes = container.volumes();
         let volume = volumes["atom"].clone();
 
@@ -662,7 +669,7 @@ mod tests {
 
     #[tokio::test]
     async fn rename_is_not_allowed() {
-        let container = Container::from_bytes(PYTHON_WEBC).unwrap();
+        let container = from_bytes(PYTHON_WEBC).unwrap();
         let volumes = container.volumes();
         let volume = volumes["atom"].clone();
 
diff --git a/lib/virtual-io/Cargo.toml b/lib/virtual-io/Cargo.toml
index 4d25ba0753..cb795457dd 100644
--- a/lib/virtual-io/Cargo.toml
+++ b/lib/virtual-io/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "virtual-mio"
-version = "0.3.1"
+version = "0.601.0"
 description = "Wasmer Virtual IO Engine powered by mio"
 authors.workspace = true
 edition.workspace = true
@@ -10,15 +10,19 @@ repository.workspace = true
 rust-version.workspace = true
 
 [dependencies]
-thiserror = "1"
-bytes = "1.1"
-async-trait = { version = "^0.1" }
-tracing = "0.1"
-mio = { version = "0.8", features = [ "os-poll" ], optional = true }
-socket2 = { version = "0.4", optional = true }
-derivative = { version = "^2" }
+thiserror.workspace = true
+bytes.workspace = true
+async-trait = { workspace = true }
+tracing.workspace = true
+
+mio = { workspace = true, features = ["os-poll"], optional = true }
+socket2 = { workspace = true, optional = true }
 futures = { version = "0.3" }
-serde = { version = "1.0", default-features = false, features = ["derive"] }
+serde = { workspace = true, default-features = false, features = ["derive"] }
+
+[dev-dependencies]
+mio = { workspace = true, features = ["os-poll", "os-ext"] }
 
 [features]
-sys = [ "mio", "socket2" ]
\ No newline at end of file
+sys = ["mio", "socket2"]
+js = []
diff --git a/lib/virtual-io/src/arc.rs b/lib/virtual-io/src/arc.rs
index 7abc45f58c..532ac6fb88 100644
--- a/lib/virtual-io/src/arc.rs
+++ b/lib/virtual-io/src/arc.rs
@@ -1,14 +1,10 @@
 use std::sync::Arc;
 use std::sync::Mutex;
 
-use derivative::Derivative;
-
 use crate::{InterestHandler, InterestType};
 
-#[derive(Derivative)]
-#[derivative(Debug)]
+#[derive(Debug)]
 struct ArcInterestHandlerState {
-    #[derivative(Debug = "ignore")]
     handler: Box<dyn InterestHandler + Send + Sync>,
 }
 
diff --git a/lib/virtual-io/src/guard.rs b/lib/virtual-io/src/guard.rs
index c74a2f1c49..71a11c319f 100644
--- a/lib/virtual-io/src/guard.rs
+++ b/lib/virtual-io/src/guard.rs
@@ -53,7 +53,7 @@ impl InterestGuard {
 
     pub fn interest(&mut self, interest: InterestType) {
         if let Some(selector) = self.selector.upgrade() {
-            selector.handle(self.token, |h| h.push_interest(interest));
+            selector.push_interest(self.token, interest);
         }
     }
 
diff --git a/lib/virtual-io/src/interest.rs b/lib/virtual-io/src/interest.rs
index 61763e99e0..7cf0529cdd 100644
--- a/lib/virtual-io/src/interest.rs
+++ b/lib/virtual-io/src/interest.rs
@@ -5,8 +5,6 @@ use std::{
     task::{Context, RawWaker, RawWakerVTable, Waker},
 };
 
-use derivative::Derivative;
-
 #[derive(Debug, Clone, Serialize, Deserialize, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum InterestType {
     Readable,
@@ -71,7 +69,7 @@ impl InterestHandler for SharedWakerInterestHandler {
     }
 }
 
-pub trait InterestHandler: Send + Sync {
+pub trait InterestHandler: Send + Sync + std::fmt::Debug {
     fn push_interest(&mut self, interest: InterestType);
 
     fn pop_interest(&mut self, interest: InterestType) -> bool;
@@ -101,10 +99,8 @@ pub fn handler_into_waker(
     })
 }
 
-#[derive(Derivative, Clone)]
-#[derivative(Debug)]
+#[derive(Debug, Clone)]
 pub struct InterestHandlerWaker {
-    #[derivative(Debug = "ignore")]
     handler: Arc<Mutex<Box<dyn InterestHandler + Send + Sync>>>,
     interest: InterestType,
 }
diff --git a/lib/virtual-io/src/selector.rs b/lib/virtual-io/src/selector.rs
index 3ea1b2f399..eff0b463d6 100644
--- a/lib/virtual-io/src/selector.rs
+++ b/lib/virtual-io/src/selector.rs
@@ -1,29 +1,108 @@
+use mio::{Registry, Token};
 use std::{
     collections::HashMap,
     io,
-    sync::{Arc, Mutex},
+    sync::{
+        atomic::{AtomicBool, AtomicUsize, Ordering},
+        Arc, Mutex,
+    },
 };
 
-use derivative::Derivative;
-use mio::{Registry, Token};
-
 use crate::{InterestHandler, InterestType};
 
-#[derive(Derivative)]
-#[derivative(Debug)]
-pub(crate) struct EngineInner {
-    seed: usize,
-    registry: Registry,
-    #[derivative(Debug = "ignore")]
-    lookup: HashMap<Token, Box<dyn InterestHandler + Send + Sync>>,
+pub enum SelectorModification {
+    Add {
+        handler: Box<dyn InterestHandler + Send + Sync>,
+        token: Token,
+    },
+    Remove {
+        token: Token,
+    },
+    Replace {
+        token: Token,
+        handler: Box<dyn InterestHandler + Send + Sync>,
+    },
+    PushInterest {
+        token: Token,
+        interest: InterestType,
+    },
 }
 
-#[derive(Derivative)]
-#[derivative(Debug)]
+impl SelectorModification {
+    /// Apply the modification to a handler lookup table
+    ///
+    /// This function must be called with care, as `SelectorModification::PushInterest` may trigger handler code.
+    fn apply(self, lookup: &mut HashMap<Token, Box<dyn InterestHandler + Send + Sync>>) {
+        match self {
+            SelectorModification::Add { token, handler } => {
+                lookup.insert(token, handler);
+            }
+            SelectorModification::Remove { token } => {
+                lookup.remove(&token);
+            }
+            SelectorModification::Replace { token, mut handler } => {
+                let last = lookup.remove(&token);
+
+                // If there was a previous handler, copy over its active interests
+                if let Some(last) = last {
+                    let interests = vec![
+                        InterestType::Readable,
+                        InterestType::Writable,
+                        InterestType::Closed,
+                        InterestType::Error,
+                    ];
+                    for interest in interests {
+                        if last.has_interest(interest) && !handler.has_interest(interest) {
+                            handler.push_interest(interest);
+                        }
+                    }
+                }
+
+                lookup.insert(token, handler);
+            }
+            SelectorModification::PushInterest { token, interest } => {
+                if let Some(handler) = lookup.get_mut(&token) {
+                    handler.push_interest(interest);
+                }
+            }
+        }
+    }
+}
+impl std::fmt::Debug for SelectorModification {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SelectorModification::Add { token, .. } => {
+                f.debug_struct("Add").field("token", token).finish()
+            }
+            SelectorModification::Remove { token, .. } => {
+                f.debug_struct("Remove").field("token", token).finish()
+            }
+            SelectorModification::Replace { token, .. } => {
+                f.debug_struct("Replace").field("token", token).finish()
+            }
+            SelectorModification::PushInterest { token, interest } => f
+                .debug_struct("PushInterest")
+                .field("token", token)
+                .field("interest", interest)
+                .finish(),
+        }
+    }
+}
+
+#[derive(Debug)]
 pub struct Selector {
-    token_close: Token,
-    inner: Mutex<EngineInner>,
-    closer: mio::Waker,
+    /// Set to true when exiting the poll loop
+    close_requested: AtomicBool,
+    token_wakeup: Token,
+    /// The core assumption here is that this will always be the innermost lock, so we will never deadlock
+    registry: Mutex<Registry>,
+    next_seed: AtomicUsize,
+    /// Waker to wake up the selectors own poll loop
+    wakeup: mio::Waker,
+    /// Queued up modifications that will be processed immediately after we get new events
+    ///
+    /// The core assumption here is that this will always be the innermost lock, so we will never deadlock
+    queued_modifications: Mutex<Vec<SelectorModification>>,
 }
 
 impl Selector {
@@ -34,14 +113,14 @@ impl Selector {
             .try_clone()
             .expect("the selector registry failed to clone");
 
+        let token_wakeup = Token(0);
         let engine = Arc::new(Selector {
-            closer: mio::Waker::new(poll.registry(), Token(0)).unwrap(),
-            token_close: Token(1),
-            inner: Mutex::new(EngineInner {
-                seed: 10,
-                lookup: Default::default(),
-                registry,
-            }),
+            wakeup: mio::Waker::new(poll.registry(), token_wakeup).unwrap(),
+            close_requested: false.into(),
+            token_wakeup,
+            next_seed: 10.into(),
+            registry: Mutex::new(registry),
+            queued_modifications: Mutex::new(Vec::new()),
         });
 
         {
@@ -55,7 +134,8 @@ impl Selector {
     }
 
     pub fn shutdown(&self) {
-        self.closer.wake().ok();
+        self.close_requested.store(true, Ordering::SeqCst);
+        self.wakeup.wake().ok();
     }
 
     #[must_use = "the token must be consumed"]
@@ -65,21 +145,17 @@ impl Selector {
         source: &mut dyn mio::event::Source,
         interests: mio::Interest,
     ) -> io::Result<Token> {
-        let mut guard = self.inner.lock().unwrap();
+        let token = self.new_token();
 
-        guard.seed = guard
-            .seed
-            .checked_add(1)
-            .expect("selector has ran out of token seeds");
-        let token = guard.seed;
-        let token = Token(token);
-        guard.lookup.insert(token, handler);
+        self.queue_modification(SelectorModification::Add { handler, token });
 
-        match source.register(&guard.registry, token, interests) {
+        // CONCURRENCY: This should never result in a deadlock, as long as source.deregister does not call remove or add again.
+        let inner_registry = self.registry.lock().unwrap();
+        match source.register(&inner_registry, token, interests) {
             Ok(()) => {}
             Err(err) if err.kind() == io::ErrorKind::AlreadyExists => {
-                source.deregister(&guard.registry).ok();
-                source.register(&guard.registry, token, interests)?;
+                source.deregister(&inner_registry).ok();
+                source.register(&inner_registry, token, interests)?;
             }
             Err(err) => return Err(err),
         };
@@ -92,72 +168,96 @@ impl Selector {
         token: Token,
         source: Option<&mut dyn mio::event::Source>,
     ) -> io::Result<()> {
-        let mut guard = self.inner.lock().unwrap();
-        guard.lookup.remove(&token);
-
+        self.queue_modification(SelectorModification::Remove { token });
+        // CONCURRENCY: This should never result in a deadlock, as long as source.deregister does not call remove or add again.
         if let Some(source) = source {
-            guard.registry.deregister(source)?;
+            let inner_registry = self.registry.lock().unwrap();
+            source.deregister(&inner_registry)?;
         }
         Ok(())
     }
 
-    pub fn handle<F>(&self, token: Token, f: F)
-    where
-        F: Fn(&mut Box<dyn InterestHandler + Send + Sync>),
-    {
-        let mut guard = self.inner.lock().unwrap();
-        if let Some(handler) = guard.lookup.get_mut(&token) {
-            f(handler)
-        }
+    pub fn push_interest(&self, token: Token, interest: InterestType) {
+        self.queue_modification(SelectorModification::PushInterest { token, interest });
     }
 
-    pub fn replace(&self, token: Token, mut handler: Box<dyn InterestHandler + Send + Sync>) {
-        let mut guard = self.inner.lock().unwrap();
+    pub fn replace(&self, token: Token, handler: Box<dyn InterestHandler + Send + Sync>) {
+        self.queue_modification(SelectorModification::Replace { token, handler });
+    }
 
-        let last = guard.lookup.remove(&token);
-        if let Some(last) = last {
-            let interests = vec![
-                InterestType::Readable,
-                InterestType::Writable,
-                InterestType::Closed,
-                InterestType::Error,
-            ];
-            for interest in interests {
-                if last.has_interest(interest) && !handler.has_interest(interest) {
-                    handler.push_interest(interest);
-                }
-            }
+    /// Generate a new unique token
+    #[must_use = "the token must be consumed"]
+    fn new_token(&self) -> Token {
+        Token(self.next_seed.fetch_add(1, Ordering::Relaxed))
+    }
+
+    /// Try to process a modification immediately, otherwise queue it up
+    fn queue_modification(&self, modification: SelectorModification) {
+        // Replace and PushInterest can cause external code to be called so it is a good idea to process them asap so they don't get delayed too long
+        let needs_wakeup = matches!(
+            &modification,
+            SelectorModification::PushInterest { .. } | SelectorModification::Replace { .. }
+        );
+
+        // CONCURRENCY: This will never deadlock as queued_modifications is always the innermost lock and we don't call any potentially blocking functions while holding the lock.
+        self.queued_modifications.lock().unwrap().push(modification);
+
+        if needs_wakeup {
+            self.wakeup.wake().ok();
         }
+    }
 
-        guard.lookup.insert(token, handler);
+    /// Drain the queued modifications queue and return the modifications
+    fn take_queued_modifications(&self) -> Vec<SelectorModification> {
+        // CONCURRENCY: This will never deadlock as queued_modifications is always the innermost lock and we don't call any potentially blocking functions while holding the lock.
+        self.queued_modifications
+            .lock()
+            .unwrap()
+            .drain(..)
+            .collect::<Vec<_>>()
     }
 
     fn run(engine: Arc<Selector>, mut poll: mio::Poll) {
         // The outer loop is used to release the scope of the
         // read lock whenever it needs to do so
         let mut events = mio::Events::with_capacity(128);
+        let mut handler_map: HashMap<Token, Box<dyn InterestHandler + Send + Sync>> =
+            HashMap::new();
         loop {
             // Wait for an event to trigger
-            poll.poll(&mut events, None).unwrap();
+            if let Err(e) = poll.poll(&mut events, None) {
+                // This can happen when a debugger is attached
+                #[cfg(debug_assertions)]
+                if e.kind() == std::io::ErrorKind::Interrupted {
+                    continue;
+                }
+                panic!("Unexpected error in selector poll loop: {e:?}");
+            }
+
+            // Handler changes that may be queued up between the poll completing and taking the queued modifications can be a problem but we can not eliminate that fully.
+
+            let queued_modifications = engine.take_queued_modifications();
+            for modification in queued_modifications {
+                modification.apply(&mut handler_map);
+            }
 
-            // Loop through all the events while under a guard lock
-            let mut guard = engine.inner.lock().unwrap();
             for event in events.iter() {
                 // If the event is already dropped then ignore it
                 let token = event.token();
 
-                // If its the close event then exit
-                if token == engine.token_close {
-                    return;
+                if token == engine.token_wakeup {
+                    if engine.close_requested.load(Ordering::SeqCst) {
+                        // If exiting was requested, exit the loop
+                        return;
+                    }
+                    // Just a wake up call, continue to process queued modifications
+                    continue;
                 }
 
                 // Get the handler
-                let handler = match guard.lookup.get_mut(&token) {
-                    Some(h) => h,
-                    None => {
-                        tracing::debug!(token = token.0, "orphaned event");
-                        continue;
-                    }
+                let Some(handler) = handler_map.get_mut(&token) else {
+                    tracing::debug!(token = token.0, "orphaned event");
+                    continue;
                 };
 
                 // Otherwise this is a waker we need to wake
@@ -181,3 +281,152 @@ impl Selector {
         }
     }
 }
+
+// Tests only run on unix because they depend on mio's unix pipe implementation
+#[cfg(all(unix, test))]
+mod tests {
+    use super::*;
+    use std::io::Write;
+    use std::sync::mpsc;
+    use std::thread;
+    use std::time::Duration;
+
+    #[derive(Debug)]
+    struct TestHandler {
+        success_sender: mpsc::Sender<()>,
+    }
+    impl InterestHandler for TestHandler {
+        fn push_interest(&mut self, _interest: InterestType) {
+            // Send if we received an interest
+            self.success_sender.send(()).unwrap();
+        }
+
+        fn pop_interest(&mut self, _interest: InterestType) -> bool {
+            false
+        }
+
+        fn has_interest(&self, interest: InterestType) -> bool {
+            interest == InterestType::Readable
+        }
+    }
+
+    #[derive(Debug)]
+    struct DeadlockingHandler {
+        selector: Arc<Selector>,
+        token: Arc<Mutex<Option<Token>>>,
+        success_sender: mpsc::Sender<()>,
+    }
+    impl InterestHandler for DeadlockingHandler {
+        fn push_interest(&mut self, _interest: InterestType) {
+            // This would deadlock without a queue
+            self.selector
+                .remove(self.token.lock().unwrap().unwrap().clone(), None)
+                .unwrap();
+            self.success_sender.send(()).unwrap();
+        }
+
+        fn pop_interest(&mut self, _interest: InterestType) -> bool {
+            false
+        }
+
+        fn has_interest(&self, interest: InterestType) -> bool {
+            interest == InterestType::Readable
+        }
+    }
+
+    #[test]
+    fn test_push_interest() {
+        let (mut sender, mut receiver) = mio::unix::pipe::new().unwrap();
+        let (success_sender, success_receiver) = std::sync::mpsc::channel();
+
+        let selector = Selector::new();
+
+        let handler = Box::new(TestHandler { success_sender });
+
+        let token = selector
+            .add(handler, &mut receiver, mio::Interest::READABLE)
+            .unwrap();
+
+        assert!(
+            success_receiver.try_recv().is_err(),
+            "Received success before sending data. Something is wrong"
+        );
+
+        thread::sleep(Duration::from_millis(10));
+
+        // Works once
+        sender.write(&[1, 2, 3]).unwrap();
+        sender.flush().unwrap();
+        thread::sleep(Duration::from_millis(10));
+        assert!(
+            success_receiver.try_recv().is_ok(),
+            "Did not receive success signal from handler"
+        );
+        assert!(
+            success_receiver.try_recv().is_err(),
+            "Did receive more than once from handler"
+        );
+        thread::sleep(Duration::from_millis(10));
+
+        // Works multiple times
+        sender.write(&[1, 2, 3]).unwrap();
+        sender.flush().unwrap();
+        thread::sleep(Duration::from_millis(10));
+        assert!(
+            success_receiver.try_recv().is_ok(),
+            "Did not receive success signal from handler"
+        );
+        assert!(
+            success_receiver.try_recv().is_err(),
+            "Did receive more than once from handler"
+        );
+        thread::sleep(Duration::from_millis(10));
+
+        // No signal after removing the handler
+        selector.remove(token, Some(&mut receiver)).unwrap();
+        sender.write(&[1, 2, 3]).unwrap();
+        sender.flush().unwrap();
+        thread::sleep(Duration::from_millis(10));
+        assert!(
+            success_receiver.try_recv().is_err(),
+            "Did receive even though the handler was removed"
+        );
+        thread::sleep(Duration::from_millis(10));
+
+        selector.shutdown();
+    }
+
+    #[test]
+    fn test_selector_no_deadlock_when_modifying_the_selector_from_push_interest() {
+        let (mut sender, mut receiver) = mio::unix::pipe::new().unwrap();
+        let (success_sender, success_receiver) = std::sync::mpsc::channel();
+
+        let selector = Selector::new();
+
+        // The deadlocking handler will try to remove itself from the selector when it receives an interest
+        let handler = Box::new(DeadlockingHandler {
+            selector: selector.clone(),
+            token: Default::default(),
+            success_sender,
+        });
+        let handler_token_arcmutex = handler.token.clone();
+
+        let token = selector
+            .add(handler, &mut receiver, mio::Interest::READABLE)
+            .unwrap();
+        handler_token_arcmutex.lock().unwrap().replace(token);
+
+        sender.write(&[1, 2, 3]).unwrap();
+        sender.flush().unwrap();
+
+        thread::sleep(Duration::from_millis(100));
+        selector.shutdown();
+        thread::sleep(Duration::from_millis(100));
+
+        let received_result = success_receiver.try_recv();
+        assert!(
+            received_result.is_ok(),
+            "Did not receive success signal from handler, deadlocked?"
+        );
+    }
+}
diff --git a/lib/virtual-io/src/waker.rs b/lib/virtual-io/src/waker.rs
index f9fe822635..ceed26bb15 100644
--- a/lib/virtual-io/src/waker.rs
+++ b/lib/virtual-io/src/waker.rs
@@ -34,12 +34,6 @@ impl InlineWaker {
         unsafe { Waker::from_raw(raw_waker) }
     }
 
-    #[cfg(not(feature = "js"))]
-    pub fn block_on<'a, A>(task: impl Future<Output = A> + 'a) -> A {
-        futures::executor::block_on(task)
-    }
-
-    #[cfg(feature = "js")]
     pub fn block_on<'a, A>(task: impl Future<Output = A> + 'a) -> A {
         // Create the waker
         let inline_waker = Self::new();
diff --git a/lib/virtual-net/Cargo.toml b/lib/virtual-net/Cargo.toml
index b7b01572ca..1ba32682e6 100644
--- a/lib/virtual-net/Cargo.toml
+++ b/lib/virtual-net/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "virtual-net"
-version = "0.8.0"
+version = "0.601.0"
 description = "Wasmer Virtual Networking"
 authors.workspace = true
 edition.workspace = true
@@ -10,30 +10,33 @@ repository.workspace = true
 rust-version.workspace = true
 
 [dependencies]
-thiserror = "1"
-bytes = "1.1"
-async-trait = { version = "^0.1" }
-tracing = "0.1"
-tokio = { version = "1", default-features = false, features = ["io-util"] }
+base64.workspace = true
+hyper = { workspace = true, optional = true }
+rkyv = { workspace = true, optional = true }
+
+ipnet = "2.10.1"
+iprange = "0.6.7"
+thiserror.workspace = true
+bytes.workspace = true
+async-trait = { workspace = true }
+tracing.workspace = true
+tokio = { workspace = true, default-features = false, features = ["io-util"] }
 libc = { workspace = true, optional = true }
-mio = { version = "0.8", optional = true, features = ["net"] }
-socket2 = { version = "0.4", optional = true }
-derivative = { version = "^2" }
-virtual-mio  = { path = "../virtual-io", version = "0.3.0", default-features = false }
-base64 = "0.21"
+mio = { workspace = true, optional = true }
+socket2 = { workspace = true, optional = true }
+derive_more.workspace = true
+virtual-mio = { path = "../virtual-io", version = "0.601.0", default-features = false }
 bincode = { version = "1.3" }
-serde = { version = "1.0", default-features = false, features = ["derive"] }
+serde = { workspace = true, default-features = false, features = ["derive"] }
 pin-project-lite = "0.2.9"
-futures-util = { version = "0.3" }
-anyhow = "1.0"
-tokio-serde = { version = "0.8", features = [ "bincode" ], optional = true }
+futures-util.workspace = true
+anyhow.workspace = true
+tokio-serde = { version = "0.9", features = ["bincode"], optional = true }
 tokio-util = { version = "0.7.8", features = ["codec"], optional = true }
 hyper-tungstenite = { version = "0.13", optional = true }
-hyper = { workspace = true, optional = true }
-tokio-tungstenite = { version = "0.21", optional = true }
-rkyv = { workspace = true, optional = true }
-bytecheck = { version = "0.6.8", optional = true }
-hyper-util = { version = "0.1.5", features = ["tokio"], optional = true }
+tokio-tungstenite = { workspace = true, optional = true }
+bytecheck = { workspace = true, optional = true }
+hyper-util = { workspace = true, features = ["tokio"], optional = true }
 
 [dependencies.smoltcp]
 version = "0.8"
@@ -41,20 +44,40 @@ default-features = false
 features = ["proto-ipv4", "std", "alloc"]
 
 [dev-dependencies]
-tokio = { version = "1", default-features = false, features = [ "macros", "rt-multi-thread" ] }
-tracing-test = { version = "0.2" }
+tokio = { workspace = true, default-features = false, features = [
+	"macros",
+	"rt-multi-thread",
+] }
+tracing-test.workspace = true
 serial_test = "2.0.0"
 
 [features]
-default = [ "host-net", "remote", "json", "messagepack", "cbor", "hyper", "tokio-tungstenite" ]
-host-net = [ "libc", "tokio/io-util", "virtual-mio/sys", "tokio/net", "tokio/rt", "socket2", "mio" ]
-remote = [ "libc", "tokio/io-util", "tokio/sync", "tokio-serde", "tokio-util" ]
-json = [ "tokio-serde/json" ]
-messagepack = [ "tokio-serde/messagepack" ]
-cbor = [ "tokio-serde/cbor" ]
-hyper = [ "hyper-tungstenite", "hyper-util", "dep:hyper" ]
-tokio-tungstenite = [ "dep:tokio-tungstenite" ]
-rkyv = [ "dep:rkyv", "dep:bytecheck" ]
+default = [
+	"host-net",
+	"remote",
+	"json",
+	"messagepack",
+	"cbor",
+	"hyper",
+	"tokio-tungstenite",
+]
+host-net = [
+	"libc",
+	"tokio/io-util",
+	"virtual-mio/sys",
+	"tokio/net",
+	"tokio/rt",
+	"socket2",
+	"mio",
+]
+remote = ["libc", "tokio/io-util", "tokio/sync", "tokio-serde", "tokio-util"]
+json = ["tokio-serde/json"]
+messagepack = ["tokio-serde/messagepack"]
+cbor = ["tokio-serde/cbor"]
+hyper = ["hyper-tungstenite", "hyper-util", "dep:hyper"]
+tokio-tungstenite = ["dep:tokio-tungstenite"]
+tokio = []
+rkyv = ["dep:rkyv", "dep:bytecheck"]
 
 [package.metadata.docs.rs]
 features = ["host-net", "remote"]
diff --git a/lib/virtual-net/src/client.rs b/lib/virtual-net/src/client.rs
index 5cb31ede64..7219fc574f 100644
--- a/lib/virtual-net/src/client.rs
+++ b/lib/virtual-net/src/client.rs
@@ -17,12 +17,12 @@ use std::time::Duration;
 
 use bytes::Buf;
 use bytes::BytesMut;
-use derivative::Derivative;
 use futures_util::future::BoxFuture;
 use futures_util::stream::FuturesOrdered;
 use futures_util::Sink;
 use futures_util::Stream;
 use futures_util::StreamExt;
+#[cfg(feature = "hyper")]
 use hyper_util::rt::tokio::TokioIo;
 use tokio::io::AsyncRead;
 use tokio::io::AsyncWrite;
@@ -529,12 +529,11 @@ struct SocketWithAddr {
 }
 type SocketMap<T> = HashMap<SocketId, T>;
 
-#[derive(Derivative)]
-#[derivative(Debug)]
+#[derive(derive_more::Debug)]
 struct RemoteCommon {
-    #[derivative(Debug = "ignore")]
+    #[debug(ignore)]
     tx: RemoteTx<MessageRequest>,
-    #[derivative(Debug = "ignore")]
+    #[debug(ignore)]
     rx: Mutex<RemoteRx<MessageResponse>>,
     request_seed: AtomicU64,
     requests: Mutex<HashMap<u64, RequestTx>>,
@@ -543,7 +542,7 @@ struct RemoteCommon {
     recv_with_addr_tx: Mutex<SocketMap<mpsc::Sender<DataWithAddr>>>,
     accept_tx: Mutex<SocketMap<mpsc::Sender<SocketWithAddr>>>,
     sent_tx: Mutex<SocketMap<mpsc::Sender<u64>>>,
-    #[derivative(Debug = "ignore")]
+    #[debug(ignore)]
     handlers: Mutex<SocketMap<Box<dyn virtual_mio::InterestHandler + Send + Sync>>>,
 
     // The stall guard will prevent reads while its held and there are background tasks running
@@ -1196,13 +1195,15 @@ impl VirtualRawSocket for RemoteSocket {
         }
     }
 
-    fn try_recv(&mut self, buf: &mut [std::mem::MaybeUninit<u8>]) -> Result<usize> {
+    fn try_recv(&mut self, buf: &mut [std::mem::MaybeUninit<u8>], peek: bool) -> Result<usize> {
         loop {
             if !self.rx_buffer.is_empty() {
                 let amt = self.rx_buffer.len().min(buf.len());
                 let buf: &mut [u8] = unsafe { std::mem::transmute(buf) };
                 buf[..amt].copy_from_slice(&self.rx_buffer[..amt]);
-                self.rx_buffer.advance(amt);
+                if !peek {
+                    self.rx_buffer.advance(amt);
+                }
                 return Ok(amt);
             }
             match self.rx_recv.try_recv() {
@@ -1254,7 +1255,15 @@ impl VirtualConnectionlessSocket for RemoteSocket {
     fn try_recv_from(
         &mut self,
         buf: &mut [std::mem::MaybeUninit<u8>],
+        peek: bool,
     ) -> Result<(usize, SocketAddr)> {
+        // FIXME: A proper peek implementation would require correct use of a
+        // buffer. We don't use this implementation AFAIK, so I'll skip over it
+        // for the time being.
+        if peek {
+            return Err(NetworkError::Unsupported);
+        }
+
         match self.rx_recv_with_addr.try_recv() {
             Ok(received) => {
                 let amt = buf.len().min(received.data.len());
@@ -1422,13 +1431,15 @@ impl VirtualConnectedSocket for RemoteSocket {
         self.io_socket_fire_and_forget(RequestType::Close)
     }
 
-    fn try_recv(&mut self, buf: &mut [std::mem::MaybeUninit<u8>]) -> Result<usize> {
+    fn try_recv(&mut self, buf: &mut [std::mem::MaybeUninit<u8>], peek: bool) -> Result<usize> {
         loop {
             if !self.rx_buffer.is_empty() {
                 let amt = self.rx_buffer.len().min(buf.len());
                 let buf: &mut [u8] = unsafe { std::mem::transmute(buf) };
                 buf[..amt].copy_from_slice(&self.rx_buffer[..amt]);
-                self.rx_buffer.advance(amt);
+                if !peek {
+                    self.rx_buffer.advance(amt);
+                }
                 return Ok(amt);
             }
             match self.rx_recv.try_recv() {
diff --git a/lib/virtual-net/src/composite.rs b/lib/virtual-net/src/composite.rs
index 6901bca32b..4a1eea08d8 100644
--- a/lib/virtual-net/src/composite.rs
+++ b/lib/virtual-net/src/composite.rs
@@ -2,13 +2,10 @@ use std::net::SocketAddr;
 use std::task::{Context, Poll};
 
 use crate::{Ipv4Addr, Ipv6Addr, NetworkError, VirtualIoSource, VirtualTcpListener};
-use derivative::Derivative;
 use virtual_mio::ArcInterestHandler;
 
-#[derive(Derivative)]
-#[derivative(Debug)]
+#[derive(Debug)]
 pub struct CompositeTcpListener {
-    #[derivative(Debug = "ignore")]
     ports: Vec<Box<dyn VirtualTcpListener + Sync>>,
 }
 
diff --git a/lib/virtual-net/src/host.rs b/lib/virtual-net/src/host.rs
index 0d14a1e267..2e4a8ab591 100644
--- a/lib/virtual-net/src/host.rs
+++ b/lib/virtual-net/src/host.rs
@@ -1,4 +1,5 @@
 #![allow(unused_variables)]
+use crate::ruleset::{Direction, Ruleset};
 use crate::{io_err_into_net_error, VirtualIoSource};
 #[allow(unused_imports)]
 use crate::{
@@ -7,7 +8,6 @@ use crate::{
     VirtualSocket, VirtualTcpListener, VirtualTcpSocket, VirtualUdpSocket,
 };
 use bytes::{Buf, BytesMut};
-use derivative::Derivative;
 use std::collections::VecDeque;
 use std::io::{self, Read, Write};
 use std::mem::MaybeUninit;
@@ -16,6 +16,9 @@ use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr};
 use std::os::fd::AsRawFd;
 #[cfg(not(target_os = "windows"))]
 use std::os::fd::RawFd;
+#[cfg(windows)]
+use std::os::windows::io::AsRawSocket;
+
 use std::sync::Arc;
 use std::task::Poll;
 use std::time::Duration;
@@ -26,11 +29,11 @@ use virtual_mio::{
     state_as_waker_map, HandlerGuardState, InterestGuard, InterestHandler, InterestType, Selector,
 };
 
-#[derive(Derivative)]
-#[derivative(Debug)]
+#[derive(Debug)]
 pub struct LocalNetworking {
     selector: Arc<Selector>,
     handle: Handle,
+    ruleset: Option<Ruleset>,
 }
 
 impl LocalNetworking {
@@ -38,6 +41,15 @@ impl LocalNetworking {
         Self {
             selector: Selector::new(),
             handle: Handle::current(),
+            ruleset: None,
+        }
+    }
+
+    pub fn with_ruleset(ruleset: Ruleset) -> Self {
+        Self {
+            selector: Selector::new(),
+            handle: Handle::current(),
+            ruleset: Some(ruleset),
         }
     }
 }
@@ -64,6 +76,13 @@ impl VirtualNetworking for LocalNetworking {
         reuse_port: bool,
         reuse_addr: bool,
     ) -> Result<Box<dyn VirtualTcpListener + Sync>> {
+        if let Some(ruleset) = self.ruleset.as_ref() {
+            if !ruleset.allows_socket(addr, Direction::Inbound) {
+                tracing::warn!(%addr, "listen_tcp blocked by firewall rule");
+                return Err(NetworkError::PermissionDenied);
+            }
+        }
+
         let listener = std::net::TcpListener::bind(addr)
             .map(|sock| {
                 sock.set_nonblocking(true).ok();
@@ -74,6 +93,7 @@ impl VirtualNetworking for LocalNetworking {
                     no_delay: None,
                     keep_alive: None,
                     backlog: Default::default(),
+                    ruleset: self.ruleset.clone(),
                 })
             })
             .map_err(io_err_into_net_error)?;
@@ -83,11 +103,40 @@ impl VirtualNetworking for LocalNetworking {
     async fn bind_udp(
         &self,
         addr: SocketAddr,
-        _reuse_port: bool,
-        _reuse_addr: bool,
+        reuse_port: bool,
+        reuse_addr: bool,
     ) -> Result<Box<dyn VirtualUdpSocket + Sync>> {
+        use socket2::{Domain, Socket, Type};
+
+        if let Some(ruleset) = self.ruleset.as_ref() {
+            if !ruleset.allows_socket(addr, Direction::Inbound) {
+                tracing::warn!(%addr, "bind_udp blocked by firewall rule");
+                return Err(NetworkError::PermissionDenied);
+            }
+        }
+
+        #[cfg(not(windows))]
+        let socket = {
+            let domain = if addr.is_ipv4() {
+                Domain::IPV4
+            } else {
+                Domain::IPV6
+            };
+            let std_sock = Socket::new(domain, Type::DGRAM, None).map_err(io_err_into_net_error)?;
+            std_sock
+                .set_nonblocking(true)
+                .map_err(io_err_into_net_error)?;
+            std_sock
+                .set_reuse_address(reuse_addr)
+                .map_err(io_err_into_net_error)?;
+            std_sock
+                .set_reuse_port(reuse_port)
+                .map_err(io_err_into_net_error)?;
+            std_sock.bind(&addr.into()).map_err(io_err_into_net_error)?;
+            mio::net::UdpSocket::from_std(std_sock.into())
+        };
+        #[cfg(windows)]
         let socket = mio::net::UdpSocket::bind(addr).map_err(io_err_into_net_error)?;
-        socket2::SockRef::from(&socket).set_nonblocking(true).ok();
 
         #[allow(unused_mut)]
         let mut ret = LocalUdpSocket {
@@ -96,6 +145,7 @@ impl VirtualNetworking for LocalNetworking {
             addr,
             handler_guard: HandlerGuardState::None,
             backlog: Default::default(),
+            ruleset: self.ruleset.clone(),
         };
 
         // In windows we can not poll the socket as it is not supported and hence
@@ -117,8 +167,15 @@ impl VirtualNetworking for LocalNetworking {
         _addr: SocketAddr,
         mut peer: SocketAddr,
     ) -> Result<Box<dyn VirtualTcpSocket + Sync>> {
+        if let Some(ruleset) = self.ruleset.as_ref() {
+            if !ruleset.allows_socket(peer, Direction::Outbound) {
+                tracing::warn!(%peer, "connect_tcp blocked by firewall rule");
+                return Err(NetworkError::PermissionDenied);
+            }
+        }
+
         let stream = mio::net::TcpStream::connect(peer).map_err(io_err_into_net_error)?;
-        socket2::SockRef::from(&stream).set_nonblocking(true).ok();
+
         if let Ok(p) = stream.peer_addr() {
             peer = p;
         }
@@ -132,22 +189,39 @@ impl VirtualNetworking for LocalNetworking {
         port: Option<u16>,
         dns_server: Option<IpAddr>,
     ) -> Result<Vec<IpAddr>> {
+        if let Some(ruleset) = self.ruleset.as_ref() {
+            if !ruleset.allows_domain(host) {
+                tracing::warn!(%host, "dns resolve blocked by firewall rule");
+                return Err(NetworkError::PermissionDenied);
+            }
+        }
+
         let host_to_lookup = if host.contains(':') {
             host.to_string()
         } else {
             format!("{}:{}", host, port.unwrap_or(0))
         };
-        self.handle
+        let addrs = self
+            .handle
             .spawn(tokio::net::lookup_host(host_to_lookup))
             .await
             .map_err(|_| NetworkError::IOError)?
             .map(|a| a.map(|a| a.ip()).collect::<Vec<_>>())
-            .map_err(io_err_into_net_error)
+            .map_err(io_err_into_net_error)?;
+
+        if let Some(ruleset) = self.ruleset.as_ref() {
+            if let Err(e) = ruleset.expand_domain(host, &addrs) {
+                tracing::debug!(err=%e, "ruleset expansion failed");
+            } else {
+                tracing::debug!(addrs=?addrs, domain = host, "ruleset expansion")
+            }
+        }
+
+        Ok(addrs)
     }
 }
 
-#[derive(Derivative)]
-#[derivative(Debug)]
+#[derive(Debug)]
 pub struct LocalTcpListener {
     stream: mio::net::TcpListener,
     selector: Arc<Selector>,
@@ -155,15 +229,20 @@ pub struct LocalTcpListener {
     no_delay: Option<bool>,
     keep_alive: Option<bool>,
     backlog: VecDeque<(Box<dyn VirtualTcpSocket + Sync>, SocketAddr)>,
+    ruleset: Option<Ruleset>,
 }
 
 impl LocalTcpListener {
     fn try_accept_internal(&mut self) -> Result<(Box<dyn VirtualTcpSocket + Sync>, SocketAddr)> {
         match self.stream.accept().map_err(io_err_into_net_error) {
             Ok((stream, addr)) => {
-                socket2::SockRef::from(&self.stream)
-                    .set_nonblocking(true)
-                    .ok();
+                if let Some(ruleset) = self.ruleset.as_ref() {
+                    if !ruleset.allows_socket(addr, Direction::Outbound) {
+                        tracing::warn!(%addr, "try_accept blocked by firewall rule");
+                        return Err(NetworkError::PermissionDenied);
+                    }
+                }
+
                 let mut socket = LocalTcpStream::new(self.selector.clone(), stream, addr);
                 if let Some(no_delay) = self.no_delay {
                     socket.set_nodelay(no_delay).ok();
@@ -333,6 +412,23 @@ impl LocalTcpStream {
 
         ret
     }
+
+    fn with_sock_ref<F, R>(&self, f: F) -> R
+    where
+        for<'a> F: FnOnce(socket2::SockRef<'a>) -> R,
+    {
+        #[cfg(not(windows))]
+        let r = socket2::SockRef::from(&self.stream);
+
+        #[cfg(windows)]
+        let b = unsafe {
+            std::os::windows::io::BorrowedSocket::borrow_raw(self.stream.as_raw_socket())
+        };
+        #[cfg(windows)]
+        let r = socket2::SockRef::from(&b);
+
+        f(r)
+    }
 }
 
 impl VirtualTcpSocket for LocalTcpStream {
@@ -363,15 +459,14 @@ impl VirtualTcpSocket for LocalTcpStream {
     }
 
     fn set_keepalive(&mut self, keepalive: bool) -> Result<()> {
-        socket2::SockRef::from(&self.stream)
-            .set_keepalive(true)
+        self.with_sock_ref(|s| s.set_keepalive(true))
             .map_err(io_err_into_net_error)?;
         Ok(())
     }
 
     fn keepalive(&self) -> Result<bool> {
-        let ret = socket2::SockRef::from(&self.stream)
-            .keepalive()
+        let ret = self
+            .with_sock_ref(|s| s.keepalive())
             .map_err(io_err_into_net_error)?;
         Ok(ret)
     }
@@ -444,15 +539,13 @@ impl VirtualTcpSocket for LocalTcpStream {
 
 impl VirtualConnectedSocket for LocalTcpStream {
     fn set_linger(&mut self, linger: Option<Duration>) -> Result<()> {
-        socket2::SockRef::from(&self.stream)
-            .set_linger(linger)
+        self.with_sock_ref(|s| s.set_linger(linger))
             .map_err(io_err_into_net_error)?;
         Ok(())
     }
 
     fn linger(&self) -> Result<Option<Duration>> {
-        socket2::SockRef::from(&self.stream)
-            .linger()
+        self.with_sock_ref(|s| s.linger())
             .map_err(io_err_into_net_error)
     }
 
@@ -477,16 +570,23 @@ impl VirtualConnectedSocket for LocalTcpStream {
         Ok(())
     }
 
-    fn try_recv(&mut self, buf: &mut [MaybeUninit<u8>]) -> Result<usize> {
+    fn try_recv(&mut self, buf: &mut [MaybeUninit<u8>], peek: bool) -> Result<usize> {
         let buf: &mut [u8] = unsafe { std::mem::transmute(buf) };
         if !self.buffer.is_empty() {
             let amt = buf.len().min(self.buffer.len());
             buf[..amt].copy_from_slice(&self.buffer[..amt]);
-            self.buffer.advance(amt);
+            if !peek {
+                self.buffer.advance(amt);
+            }
             return Ok(amt);
         }
 
-        self.stream.read(buf).map_err(io_err_into_net_error)
+        if peek {
+            self.stream.peek(buf)
+        } else {
+            self.stream.read(buf)
+        }
+        .map_err(io_err_into_net_error)
     }
 }
 
@@ -652,6 +752,26 @@ pub struct LocalUdpSocket {
     selector: Arc<Selector>,
     handler_guard: HandlerGuardState,
     backlog: VecDeque<(BytesMut, SocketAddr)>,
+    ruleset: Option<Ruleset>,
+}
+
+impl LocalUdpSocket {
+    fn with_sock_ref<F, R>(&self, f: F) -> R
+    where
+        for<'a> F: FnOnce(socket2::SockRef<'a>) -> R,
+    {
+        #[cfg(not(windows))]
+        let r = socket2::SockRef::from(&self.socket);
+
+        #[cfg(windows)]
+        let b = unsafe {
+            std::os::windows::io::BorrowedSocket::borrow_raw(self.socket.as_raw_socket())
+        };
+        #[cfg(windows)]
+        let r = socket2::SockRef::from(&b);
+
+        f(r)
+    }
 }
 
 impl VirtualUdpSocket for LocalUdpSocket {
@@ -702,14 +822,12 @@ impl VirtualUdpSocket for LocalUdpSocket {
     }
 
     fn join_multicast_v4(&mut self, multiaddr: Ipv4Addr, iface: Ipv4Addr) -> Result<()> {
-        socket2::SockRef::from(&self.socket)
-            .join_multicast_v4(&multiaddr, &iface)
+        self.with_sock_ref(|s| s.join_multicast_v4(&multiaddr, &iface))
             .map_err(io_err_into_net_error)
     }
 
     fn leave_multicast_v4(&mut self, multiaddr: Ipv4Addr, iface: Ipv4Addr) -> Result<()> {
-        socket2::SockRef::from(&self.socket)
-            .leave_multicast_v4(&multiaddr, &iface)
+        self.with_sock_ref(|s| s.leave_multicast_v4(&multiaddr, &iface))
             .map_err(io_err_into_net_error)
     }
 
@@ -735,6 +853,13 @@ impl VirtualUdpSocket for LocalUdpSocket {
 
 impl VirtualConnectionlessSocket for LocalUdpSocket {
     fn try_send_to(&mut self, data: &[u8], addr: SocketAddr) -> Result<usize> {
+        if let Some(ruleset) = self.ruleset.as_ref() {
+            if !ruleset.allows_socket(addr, Direction::Outbound) {
+                tracing::warn!(%addr, "try_send blocked by firewall rule");
+                return Err(NetworkError::PermissionDenied);
+            }
+        }
+
         let ret = self
             .socket
             .send_to(data, addr)
@@ -750,9 +875,18 @@ impl VirtualConnectionlessSocket for LocalUdpSocket {
         ret
     }
 
-    fn try_recv_from(&mut self, buf: &mut [MaybeUninit<u8>]) -> Result<(usize, SocketAddr)> {
+    fn try_recv_from(
+        &mut self,
+        buf: &mut [MaybeUninit<u8>],
+        peek: bool,
+    ) -> Result<(usize, SocketAddr)> {
         let buf: &mut [u8] = unsafe { std::mem::transmute(buf) };
-        self.socket.recv_from(buf).map_err(io_err_into_net_error)
+        if peek {
+            self.socket.peek_from(buf)
+        } else {
+            self.socket.recv_from(buf)
+        }
+        .map_err(io_err_into_net_error)
     }
 }
 
diff --git a/lib/virtual-net/src/lib.rs b/lib/virtual-net/src/lib.rs
index 782d84110d..ba556ff35b 100644
--- a/lib/virtual-net/src/lib.rs
+++ b/lib/virtual-net/src/lib.rs
@@ -1,5 +1,5 @@
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
-
+#![allow(clippy::multiple_bound_locations)]
 #[cfg(feature = "remote")]
 pub mod client;
 pub mod composite;
@@ -7,6 +7,7 @@ pub mod composite;
 pub mod host;
 pub mod loopback;
 pub mod meta;
+pub mod ruleset;
 #[cfg(feature = "remote")]
 pub mod rx_tx;
 #[cfg(feature = "remote")]
@@ -22,7 +23,7 @@ pub use composite::CompositeTcpListener;
 pub use loopback::LoopbackNetworking;
 use pin_project_lite::pin_project;
 #[cfg(feature = "rkyv")]
-use rkyv::{Archive, CheckBytes, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
 #[cfg(feature = "remote")]
 pub use server::{RemoteNetworkingServer, RemoteNetworkingServerDriver};
 use std::fmt;
@@ -55,7 +56,6 @@ pub type Result<T> = std::result::Result<T, NetworkError>;
 /// Represents an IP address and its netmask
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize, Deserialize)]
 #[cfg_attr(feature = "rkyv", derive(RkyvSerialize, RkyvDeserialize, Archive))]
-#[cfg_attr(feature = "rkyv", archive_attr(derive(CheckBytes)))]
 pub struct IpCidr {
     pub ip: IpAddr,
     pub prefix: u8,
@@ -64,7 +64,6 @@ pub struct IpCidr {
 /// Represents a routing entry in the routing table of the interface
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[cfg_attr(feature = "rkyv", derive(RkyvSerialize, RkyvDeserialize, Archive))]
-#[cfg_attr(feature = "rkyv", archive_attr(derive(CheckBytes)))]
 pub struct IpRoute {
     pub cidr: IpCidr,
     pub via_router: IpAddr,
@@ -257,7 +256,7 @@ impl<R: VirtualTcpListener + ?Sized> VirtualTcpListenerExt for R {
         {
             listener: &'a mut R,
         }
-        impl<'a, R> std::future::Future for Poller<'a, R>
+        impl<R> std::future::Future for Poller<'_, R>
         where
             R: VirtualTcpListener + ?Sized,
         {
@@ -335,14 +334,14 @@ pub trait VirtualConnectedSocket: VirtualSocket + fmt::Debug + Send + Sync + 'st
     fn close(&mut self) -> Result<()>;
 
     /// Tries to read a packet from the socket
-    fn try_recv(&mut self, buf: &mut [MaybeUninit<u8>]) -> Result<usize>;
+    fn try_recv(&mut self, buf: &mut [MaybeUninit<u8>], peek: bool) -> Result<usize>;
 }
 
 #[async_trait::async_trait]
 pub trait VirtualConnectedSocketExt: VirtualConnectedSocket {
     async fn send(&mut self, data: &[u8]) -> Result<usize>;
 
-    async fn recv(&mut self, buf: &mut [MaybeUninit<u8>]) -> Result<usize>;
+    async fn recv(&mut self, buf: &mut [MaybeUninit<u8>], peek: bool) -> Result<usize>;
 
     async fn flush(&mut self) -> Result<()>;
 }
@@ -359,7 +358,7 @@ impl<R: VirtualConnectedSocket + ?Sized> VirtualConnectedSocketExt for R {
                 data: &'b [u8],
             }
         }
-        impl<'a, 'b, R> std::future::Future for Poller<'a, 'b, R>
+        impl<R> std::future::Future for Poller<'_, '_, R>
         where
             R: VirtualConnectedSocket + ?Sized,
         {
@@ -381,7 +380,7 @@ impl<R: VirtualConnectedSocket + ?Sized> VirtualConnectedSocketExt for R {
         Poller { socket: self, data }.await
     }
 
-    async fn recv(&mut self, buf: &mut [MaybeUninit<u8>]) -> Result<usize> {
+    async fn recv(&mut self, buf: &mut [MaybeUninit<u8>], peek: bool) -> Result<usize> {
         pin_project! {
             struct Poller<'a, 'b, R: ?Sized>
             where
@@ -389,9 +388,10 @@ impl<R: VirtualConnectedSocket + ?Sized> VirtualConnectedSocketExt for R {
             {
                 socket: &'a mut R,
                 buf: &'b mut [MaybeUninit<u8>],
+                peek: bool,
             }
         }
-        impl<'a, 'b, R> std::future::Future for Poller<'a, 'b, R>
+        impl<R> std::future::Future for Poller<'_, '_, R>
         where
             R: VirtualConnectedSocket + ?Sized,
         {
@@ -403,14 +403,19 @@ impl<R: VirtualConnectedSocket + ?Sized> VirtualConnectedSocketExt for R {
                 if let Err(err) = this.socket.set_handler(handler) {
                     return Poll::Ready(Err(err));
                 }
-                match this.socket.try_recv(this.buf) {
+                match this.socket.try_recv(this.buf, *this.peek) {
                     Ok(ret) => Poll::Ready(Ok(ret)),
                     Err(NetworkError::WouldBlock) => Poll::Pending,
                     Err(err) => Poll::Ready(Err(err)),
                 }
             }
         }
-        Poller { socket: self, buf }.await
+        Poller {
+            socket: self,
+            buf,
+            peek,
+        }
+        .await
     }
 
     async fn flush(&mut self) -> Result<()> {
@@ -420,7 +425,7 @@ impl<R: VirtualConnectedSocket + ?Sized> VirtualConnectedSocketExt for R {
         {
             socket: &'a mut R,
         }
-        impl<'a, R> std::future::Future for Poller<'a, R>
+        impl<R> std::future::Future for Poller<'_, R>
         where
             R: VirtualConnectedSocket + ?Sized,
         {
@@ -449,14 +454,22 @@ pub trait VirtualConnectionlessSocket: VirtualSocket + fmt::Debug + Send + Sync
     fn try_send_to(&mut self, data: &[u8], addr: SocketAddr) -> Result<usize>;
 
     /// Recv a packet from the socket
-    fn try_recv_from(&mut self, buf: &mut [MaybeUninit<u8>]) -> Result<(usize, SocketAddr)>;
+    fn try_recv_from(
+        &mut self,
+        buf: &mut [MaybeUninit<u8>],
+        peek: bool,
+    ) -> Result<(usize, SocketAddr)>;
 }
 
 #[async_trait::async_trait]
 pub trait VirtualConnectionlessSocketExt: VirtualConnectionlessSocket {
     async fn send_to(&mut self, data: &[u8], addr: SocketAddr) -> Result<usize>;
 
-    async fn recv_from(&mut self, buf: &mut [MaybeUninit<u8>]) -> Result<(usize, SocketAddr)>;
+    async fn recv_from(
+        &mut self,
+        buf: &mut [MaybeUninit<u8>],
+        peek: bool,
+    ) -> Result<(usize, SocketAddr)>;
 }
 
 #[async_trait::async_trait]
@@ -472,7 +485,7 @@ impl<R: VirtualConnectionlessSocket + ?Sized> VirtualConnectionlessSocketExt for
                 addr: SocketAddr,
             }
         }
-        impl<'a, 'b, R> std::future::Future for Poller<'a, 'b, R>
+        impl<R> std::future::Future for Poller<'_, '_, R>
         where
             R: VirtualConnectionlessSocket + ?Sized,
         {
@@ -499,7 +512,11 @@ impl<R: VirtualConnectionlessSocket + ?Sized> VirtualConnectionlessSocketExt for
         .await
     }
 
-    async fn recv_from(&mut self, buf: &mut [MaybeUninit<u8>]) -> Result<(usize, SocketAddr)> {
+    async fn recv_from(
+        &mut self,
+        buf: &mut [MaybeUninit<u8>],
+        peek: bool,
+    ) -> Result<(usize, SocketAddr)> {
         pin_project! {
             struct Poller<'a, 'b, R: ?Sized>
             where
@@ -507,9 +524,10 @@ impl<R: VirtualConnectionlessSocket + ?Sized> VirtualConnectionlessSocketExt for
             {
                 socket: &'a mut R,
                 buf: &'b mut [MaybeUninit<u8>],
+                peek: bool,
             }
         }
-        impl<'a, 'b, R> std::future::Future for Poller<'a, 'b, R>
+        impl<R> std::future::Future for Poller<'_, '_, R>
         where
             R: VirtualConnectionlessSocket + ?Sized,
         {
@@ -521,14 +539,19 @@ impl<R: VirtualConnectionlessSocket + ?Sized> VirtualConnectionlessSocketExt for
                 if let Err(err) = this.socket.set_handler(handler) {
                     return Poll::Ready(Err(err));
                 }
-                match this.socket.try_recv_from(this.buf) {
+                match this.socket.try_recv_from(this.buf, *this.peek) {
                     Ok(ret) => Poll::Ready(Ok(ret)),
                     Err(NetworkError::WouldBlock) => Poll::Pending,
                     Err(err) => Poll::Ready(Err(err)),
                 }
             }
         }
-        Poller { socket: self, buf }.await
+        Poller {
+            socket: self,
+            buf,
+            peek,
+        }
+        .await
     }
 }
 
@@ -549,7 +572,7 @@ pub trait VirtualRawSocket: VirtualSocket + fmt::Debug + Send + Sync + 'static {
     fn try_flush(&mut self) -> Result<()>;
 
     /// Recv a packet from the socket
-    fn try_recv(&mut self, buf: &mut [MaybeUninit<u8>]) -> Result<usize>;
+    fn try_recv(&mut self, buf: &mut [MaybeUninit<u8>], peek: bool) -> Result<usize>;
 
     /// Tells the raw socket and its backing switch that all packets
     /// should be received by this socket even if they are not
diff --git a/lib/virtual-net/src/loopback.rs b/lib/virtual-net/src/loopback.rs
index 93a68b10ad..b59519790b 100644
--- a/lib/virtual-net/src/loopback.rs
+++ b/lib/virtual-net/src/loopback.rs
@@ -9,7 +9,6 @@ use crate::{
     InterestHandler, IpAddr, IpCidr, Ipv4Addr, Ipv6Addr, NetworkError, VirtualIoSource,
     VirtualNetworking, VirtualTcpListener, VirtualTcpSocket,
 };
-use derivative::Derivative;
 use virtual_mio::InterestType;
 
 const DEFAULT_MAX_BUFFER_SIZE: usize = 1_048_576;
@@ -136,10 +135,8 @@ impl VirtualNetworking for LoopbackNetworking {
     }
 }
 
-#[derive(Derivative)]
-#[derivative(Debug)]
+#[derive(Debug)]
 struct LoopbackTcpListenerState {
-    #[derivative(Debug = "ignore")]
     handler: Option<Box<dyn InterestHandler + Send + Sync>>,
     addr_local: SocketAddr,
     backlog: VecDeque<TcpSocketHalf>,
diff --git a/lib/virtual-net/src/ruleset.rs b/lib/virtual-net/src/ruleset.rs
new file mode 100644
index 0000000000..aa9f884e58
--- /dev/null
+++ b/lib/virtual-net/src/ruleset.rs
@@ -0,0 +1,1493 @@
+/// A [`Ruleset`] can be used to specify a whitelist and a blacklist in order to
+/// control the inbound and outbound traffic of a network.
+///
+/// ## Rule Specification
+/// Each rule can be expressed like:
+/// ```text
+/// <rule_kind>:<rule_action>=<rule_expr>
+///
+/// <rule_kind>: dns, ipv4, ipv6
+///
+/// <rule_action>: allow | deny
+///
+/// dns:
+/// <rule_expr>:
+/// {<domain_spec>}:{<port_spec>} (this will be expanded to an outbound IP rule)
+/// <domain_spec>: domain | domain glob | *
+///
+/// ipv4:
+/// <rule_expr>:
+/// <ipv4_specs>:<port_specs>/<in|out>
+/// <ipv4_specs>: <ipv4_spec> | {<ipv4_spec>,}
+/// <ipv4_spec>: ipv4 | ipv4_range | *
+///
+/// ipv6:
+/// <rule_expr>:
+/// <ipv6_specs>:<port_specs>/<in|out>
+/// <ipv6_specs>: <ipv6_spec> | {<ipv6_spec>,}
+/// <ipv6_spec>: ipv6 | ipv6_range | *
+///
+/// <port_specs>: <port_spec> | {<port_specs>,}
+/// <port_spec>: port | start_port-end_port | *
+/// ```
+///
+/// The current implementation supports:
+///
+/// ### Whitelisting and Blacklisting
+/// Each rule can be expressed as an `allow` (whitelist) or `deny` (blacklist). A socket or domain
+/// is only accessible if at least one rule whitelists it and no rule blacklists it.
+///
+/// ### Directional Filtering
+/// IP based rules can be either directional by specifying `/in` or `/out` postfixes to the rule,
+/// or bidirectional which is the default setting for these rules.
+///
+/// ### Rule Combination
+/// In order to prevent repetition, the parts before and after the `:` could hold multiple values.
+/// For example:
+/// ```text
+/// ipv4:deny={127.0.0.1/24, 192.168.1.1/24}:{80, 443}
+/// ```
+/// This is equivalent to:
+/// ```text
+/// ipv4:deny=127.0.0.1/24:80,
+/// ipv4:deny=127.0.0.1/24:443,
+/// ipv4:deny=192.168.1.1/24:80,
+/// ipv4:deny=192.168.1.1/24:443
+/// ```
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
+use std::ops::RangeInclusive;
+use std::str::FromStr;
+use std::sync::{Arc, RwLock};
+
+use ipnet::{Ipv4Net, Ipv6Net};
+use iprange::IpRange;
+
+/// Represents the errors that could happen during parsing the ruleset
+#[derive(Debug, thiserror::Error)]
+pub enum RuleParseError {
+    #[error("invalid connection direction: {0}")]
+    Direction(String),
+    #[error("failed to parse int: {0}")]
+    InvalidInteger(#[from] std::num::ParseIntError),
+    #[error("failed to parse IP range address: {0}")]
+    InvalidIpRange(#[from] ipnet::AddrParseError),
+    #[error("failed to parse IP address: {0}")]
+    InvalidIpAddr(#[from] std::net::AddrParseError),
+    #[error("missing colon in rule: {0}")]
+    MissingColon(String),
+    #[error("Single IPV6 entry is not enclosed in brackets: {0}")]
+    MalformedIpv6(String),
+    #[error("Invalid rule type: {0}. Rule type must be either dns, ipv4, or ipv6")]
+    InvalidRuleType(String),
+    #[error("Invalid rule action: {0}. Rule action must be either allow or deny")]
+    InvalidRuleAction(String),
+    #[error("Domain rule not found for: {0}")]
+    DomainRuleNotFound(String),
+    #[error("Domain rule already expanded: {0}")]
+    DomainAlreadyExpanded(String),
+}
+
+/// Represents the direction of the network traffic
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Direction {
+    Inbound,
+    Outbound,
+    Bidirectional,
+}
+
+impl Direction {
+    pub fn matches(&self, direction: Direction) -> bool {
+        *self == Direction::Bidirectional || *self == direction
+    }
+}
+
+impl FromStr for Direction {
+    type Err = RuleParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let direction = if s == "in" {
+            Direction::Inbound
+        } else if s == "out" {
+            Direction::Outbound
+        } else {
+            return Err(RuleParseError::Direction(s.to_string()));
+        };
+
+        Ok(direction)
+    }
+}
+
+/// Specification of a port rule
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum PortSpec {
+    /// All ports are allowed
+    All,
+    /// Allows a single port
+    Port(u16),
+    /// Allows a range of ports
+    PortRange(RangeInclusive<u16>),
+}
+
+impl PortSpec {
+    pub fn matches(&self, port: u16) -> bool {
+        match self {
+            PortSpec::All => true,
+            PortSpec::Port(allowed_port) => *allowed_port == port,
+            PortSpec::PortRange(allowed_port_range) => allowed_port_range.contains(&port),
+        }
+    }
+}
+
+impl FromStr for PortSpec {
+    type Err = RuleParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let rule = if s == "*" {
+            PortSpec::All
+        } else if s.contains('-') {
+            let (start, end) = s.split_once('-').unwrap();
+
+            let (start, end) = (start.parse()?, end.parse()?);
+
+            PortSpec::PortRange(start..=end)
+        } else {
+            PortSpec::Port(s.parse()?)
+        };
+
+        Ok(rule)
+    }
+}
+
+/// Specification of a domain
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum DomainSpec {
+    /// All domains
+    All,
+    /// A single domain like: example.com
+    Domain(String),
+    /// A domain glob like: *.example.com
+    DomainGlob(String),
+}
+
+impl DomainSpec {
+    pub fn matches(&self, domain: impl AsRef<str>) -> bool {
+        let domain = domain.as_ref();
+
+        match self {
+            DomainSpec::All => true,
+            DomainSpec::Domain(allowed_domain) => allowed_domain == domain,
+            DomainSpec::DomainGlob(domain_glob) => domain.ends_with(domain_glob),
+        }
+    }
+}
+
+impl FromStr for DomainSpec {
+    type Err = RuleParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let spec = if s == "*" {
+            DomainSpec::All
+        } else if let Some(glob) = s.strip_prefix('*') {
+            DomainSpec::DomainGlob(glob.to_string())
+        } else {
+            DomainSpec::Domain(s.to_string())
+        };
+
+        Ok(spec)
+    }
+}
+
+/// Represents a DNS rule
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DNSRule {
+    // The allowed domain
+    domain: DomainSpec,
+    // The allowed port
+    port: PortSpec,
+    // Indicates whether this rule has been expanded into
+    // a list of IP and port based rules
+    expanded: bool,
+}
+
+impl DNSRule {
+    /// Returns `true` if the `domain` is allowed by this rule
+    pub fn allows(&self, domain: impl AsRef<str>) -> bool {
+        self.domain.matches(domain)
+    }
+
+    /// Returns the allowed ports on the domains allowed by this rule
+    pub fn allowed_ports(&self) -> PortSpec {
+        self.port.clone()
+    }
+}
+
+/// Specification of an Ipv4
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum IPV4Spec {
+    /// All IPs
+    All,
+    /// A single IP
+    IP(Ipv4Addr),
+    /// An IP range in the format of `ip/mask`
+    IPRange(IpRange<Ipv4Net>),
+}
+
+impl IPV4Spec {
+    pub fn matches(&self, ip: impl Into<Ipv4Addr>) -> bool {
+        let ip = ip.into();
+
+        match self {
+            IPV4Spec::All => true,
+            IPV4Spec::IP(allowed_ip) => *allowed_ip == ip,
+            IPV4Spec::IPRange(allowed_ip_range) => allowed_ip_range.contains(&ip),
+        }
+    }
+}
+
+impl FromStr for IPV4Spec {
+    type Err = RuleParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let spec = if s == "*" {
+            IPV4Spec::All
+        } else if s.contains('/') {
+            let ip = Ipv4Net::from_str(s)?;
+            let mut ip_range = IpRange::<Ipv4Net>::new();
+            ip_range.add(ip);
+
+            IPV4Spec::IPRange(ip_range)
+        } else {
+            IPV4Spec::IP(s.parse()?)
+        };
+
+        Ok(spec)
+    }
+}
+
+/// Represents an Ipv4 rule
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct IPV4Rule {
+    // Allowed IPs
+    ip_spec: IPV4Spec,
+    // Allowed ports
+    port_spec: PortSpec,
+    // Allowed direction of the traffic
+    direction: Direction,
+}
+
+impl IPV4Rule {
+    pub fn is_allowed(&self, ip: impl Into<Ipv4Addr>, port: u16, dir: Direction) -> bool {
+        let ip = ip.into();
+
+        self.ip_spec.matches(ip) && self.port_spec.matches(port) && self.direction.matches(dir)
+    }
+}
+
+/// Specification of an Ipv6 address
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum IPV6Spec {
+    /// All IPs
+    All,
+    /// Single IP
+    IP(Ipv6Addr),
+    /// An IP range in the format of `ip/mask`
+    IPRange(IpRange<Ipv6Net>),
+}
+
+impl IPV6Spec {
+    pub fn matches(&self, ip: Ipv6Addr) -> bool {
+        match self {
+            IPV6Spec::All => true,
+            IPV6Spec::IP(allowed_ip) => *allowed_ip == ip,
+            IPV6Spec::IPRange(allowed_ip_range) => allowed_ip_range.contains(&ip),
+        }
+    }
+}
+
+impl FromStr for IPV6Spec {
+    type Err = RuleParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let spec = if s == "*" {
+            IPV6Spec::All
+        } else if s.contains('/') {
+            let ip = Ipv6Net::from_str(s)?;
+            let mut ip_range = IpRange::<Ipv6Net>::new();
+            ip_range.add(ip);
+
+            IPV6Spec::IPRange(ip_range)
+        } else {
+            IPV6Spec::IP(s.parse()?)
+        };
+
+        Ok(spec)
+    }
+}
+
+/// Represents an Ipv6 rule
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct IPV6Rule {
+    // Allowed IPs
+    ip_spec: IPV6Spec,
+    // Allowed ports
+    port_spec: PortSpec,
+    // Allowed direction of the traffic
+    direction: Direction,
+}
+
+impl IPV6Rule {
+    pub fn is_allowed(&self, ip: impl Into<Ipv6Addr>, port: u16, dir: Direction) -> bool {
+        let ip = ip.into();
+
+        self.ip_spec.matches(ip) && self.port_spec.matches(port) && self.direction.matches(dir)
+    }
+}
+
+/// Represents all supported rules
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Rule {
+    /// Allowed IPv4 traffic
+    IPV4(IPV4Rule),
+    /// Allowed IPv6 traffic
+    IPV6(IPV6Rule),
+    /// Allowed DNS queries
+    DNS(DNSRule),
+    /// Negative of a rule
+    Neg(Arc<Rule>),
+}
+
+impl Rule {
+    /// Returns `true` if this rule allows accessing `socket_addr` in the specific `direction`
+    pub fn allows_socket(&self, socket_addr: SocketAddr, direction: Direction) -> bool {
+        let ip = socket_addr.ip();
+        let port = socket_addr.port();
+
+        match (self, ip) {
+            (Rule::IPV4(rule), IpAddr::V4(ip)) => rule.is_allowed(ip, port, direction),
+            (Rule::IPV6(rule), IpAddr::V6(ip)) => rule.is_allowed(ip, port, direction),
+            _ => false,
+        }
+    }
+
+    /// Returns `true` if this rule allows querying the specific `domain`
+    pub fn allows_domain(&self, domain: impl AsRef<str>) -> bool {
+        if let Rule::DNS(rule) = self {
+            rule.allows(domain)
+        } else {
+            false
+        }
+    }
+
+    /// Returns `true` if this rule blocks accessing `socket_addr` in the specific `direction`
+    pub fn blocks_socket(&self, socket_addr: SocketAddr, direction: Direction) -> bool {
+        if let Rule::Neg(rule) = self {
+            rule.allows_socket(socket_addr, direction)
+        } else {
+            false
+        }
+    }
+
+    /// Returns `true` if this rule blocks querying the specific `domain`
+    pub fn blocks_domain(&self, domain: impl AsRef<str>) -> bool {
+        if let Rule::Neg(rule) = self {
+            rule.allows_domain(domain)
+        } else {
+            false
+        }
+    }
+
+    /// Returns allowed ports for the specified `domain` if this rule is a DNS rule
+    pub fn port_spec_of_domain(&mut self, domain: impl AsRef<str>) -> Option<PortSpec> {
+        if let Rule::DNS(rule) = self {
+            if rule.allows(domain) {
+                return Some(rule.allowed_ports());
+            }
+        }
+
+        None
+    }
+
+    /// Returns `true` if this rule is a DNS rule and has not been expanded yet
+    pub fn is_expandable(&self) -> bool {
+        if let Rule::DNS(rule) = self {
+            !rule.expanded
+        } else {
+            false
+        }
+    }
+
+    /// Sets the expanded state of this rule if its a DNS rule
+    pub fn set_expanded(&mut self, expanded: bool) {
+        if let Rule::DNS(rule) = self {
+            rule.expanded = expanded;
+        }
+    }
+}
+
+fn parse_enclosed(s: &str, left: char, right: char) -> Option<&str> {
+    match (s.find(left), s.rfind(right)) {
+        (Some(left_idx), Some(right_idx)) if left_idx < right_idx => {
+            Some(&s[left_idx + 1..right_idx])
+        }
+        _ => None,
+    }
+}
+
+fn parse_as_list<T: FromStr<Err = RuleParseError>>(s: &str) -> Result<Vec<T>, RuleParseError> {
+    let entries = if let Some(entries) = parse_enclosed(s, '{', '}') {
+        entries
+            .split(',')
+            .map(|s| s.trim().parse())
+            .collect::<Result<Vec<_>, _>>()?
+    } else {
+        let entry = T::from_str(s)?;
+
+        vec![entry]
+    };
+
+    Ok(entries)
+}
+
+fn parse_ipv4_rule(s: &str) -> Result<Vec<IPV4Rule>, RuleParseError> {
+    let (ips, ports_and_direction) = s
+        .split_once(':')
+        .ok_or_else(|| RuleParseError::MissingColon(s.to_string()))?;
+
+    let mut direction = Direction::Bidirectional;
+    let ports = if let Some((ports, dir)) = ports_and_direction.split_once('/') {
+        direction = dir.parse()?;
+
+        ports
+    } else {
+        ports_and_direction
+    };
+
+    let mut rules = Vec::new();
+    let ips = parse_as_list::<IPV4Spec>(ips)?;
+    let ports = parse_as_list::<PortSpec>(ports)?;
+
+    for ip in &ips {
+        for port in &ports {
+            rules.push(IPV4Rule {
+                ip_spec: ip.clone(),
+                port_spec: port.clone(),
+                direction,
+            });
+        }
+    }
+
+    Ok(rules)
+}
+
+fn parse_ipv6_rule(s: &str) -> Result<Vec<IPV6Rule>, RuleParseError> {
+    let (ips, ports_and_direction) = s
+        .rsplit_once(':')
+        .ok_or_else(|| RuleParseError::MissingColon(s.to_string()))?;
+
+    let mut direction = Direction::Bidirectional;
+    let ports = if let Some((ports, dir)) = ports_and_direction.split_once('/') {
+        direction = dir.parse()?;
+
+        ports
+    } else {
+        ports_and_direction
+    };
+
+    let mut rules = Vec::new();
+
+    let ips = if ips.contains('[') {
+        let ip = parse_enclosed(ips, '[', ']')
+            .ok_or_else(|| RuleParseError::MalformedIpv6(ips.to_string()))?;
+
+        vec![ip.parse::<IPV6Spec>()?]
+    } else {
+        parse_as_list::<IPV6Spec>(ips)?
+    };
+    let ports = parse_as_list::<PortSpec>(ports)?;
+
+    for ip in &ips {
+        for port in &ports {
+            rules.push(IPV6Rule {
+                ip_spec: ip.clone(),
+                port_spec: port.clone(),
+                direction,
+            });
+        }
+    }
+
+    Ok(rules)
+}
+
+fn parse_dns_rule(s: &str) -> Result<Vec<DNSRule>, RuleParseError> {
+    let (domains, ports) = s
+        .split_once(':')
+        .ok_or_else(|| RuleParseError::MissingColon(s.to_string()))?;
+
+    let mut rules = Vec::new();
+    let domains = parse_as_list::<DomainSpec>(domains)?;
+    let ports = parse_as_list::<PortSpec>(ports)?;
+
+    for domain in &domains {
+        for port in &ports {
+            rules.push(DNSRule {
+                domain: domain.clone(),
+                port: port.clone(),
+                expanded: false,
+            });
+        }
+    }
+
+    Ok(rules)
+}
+
+// Represents the rule type section in a rule segment
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum RuleType {
+    Dns,
+    IPV4,
+    IPV6,
+}
+
+impl RuleType {
+    // Receives a string as input and returns the parsed out rule type and the remaining string
+    // |-------------|---...
+    // rule_type ----^     ^
+    // rem ----------------'
+    pub fn consume_input(input: &str) -> Result<(Self, &str), RuleParseError> {
+        let pair = if let Some(rem) = input.strip_prefix("dns:") {
+            (RuleType::Dns, rem)
+        } else if let Some(rem) = input.strip_prefix("ipv4:") {
+            (RuleType::IPV4, rem)
+        } else if let Some(rem) = input.strip_prefix("ipv6:") {
+            (RuleType::IPV6, rem)
+        } else {
+            return Err(RuleParseError::InvalidRuleType(input.to_string()));
+        };
+
+        Ok(pair)
+    }
+}
+
+// Represents the rule action section in a [`RulesetSegment`]
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum RuleAction {
+    Allow,
+    Deny,
+}
+
+impl RuleAction {
+    // Receives a string as input and returns the parsed out rule action and the remaining string
+    // |----------|---------|---...
+    // rule_type -^         ^     ^
+    // rule_action ---------'     '
+    // rem -----------------------'
+    pub fn consume_input(input: &str) -> Result<(Self, &str), RuleParseError> {
+        let pair = if let Some(rem) = input.strip_prefix("allow=") {
+            (RuleAction::Allow, rem)
+        } else if let Some(rem) = input.strip_prefix("deny=") {
+            (RuleAction::Deny, rem)
+        } else {
+            return Err(RuleParseError::InvalidRuleAction(input.to_string()));
+        };
+
+        Ok(pair)
+    }
+}
+
+// Represents the rule expression section in a [`RulesetSegment`]
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct RuleExpr(String);
+
+impl RuleExpr {
+    // Receives a string as input and returns the parsed out rule expression and the remaining string
+    // |----------|---------|-----|---...
+    // rule_type -^         ^     ^     ^
+    // rule_action ---------'     '     '
+    // rule_expr -----------------'     '
+    // rem -----------------------------'
+    pub fn consume_input(input: &str) -> Result<(Self, &str), RuleParseError> {
+        let mut next_dns_entry = usize::MAX;
+        let mut next_ipv4_entry = usize::MAX;
+        let mut next_ipv6_entry = usize::MAX;
+
+        if let Some(idx) = input.find(",dns:") {
+            next_dns_entry = idx;
+        }
+
+        if let Some(idx) = input.find(",ipv4:") {
+            next_ipv4_entry = idx;
+        }
+
+        if let Some(idx) = input.find(",ipv6:") {
+            next_ipv6_entry = idx;
+        }
+
+        let next_entry = next_dns_entry
+            .min(next_ipv4_entry)
+            .min(next_ipv6_entry)
+            .min(input.len());
+
+        let (expr, rem) = input.split_at(next_entry);
+
+        let rem = rem.strip_prefix(',').unwrap_or(rem);
+
+        Ok((RuleExpr(expr.to_string()), rem))
+    }
+}
+
+// A ruleset is a series of comma separated ruleset segments:
+//     <rule1>, <rule2>, ...
+// each rule is consistent of three sections:
+//     <rule-type>:<rule-action>=<rule-expr>
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct RulesetSegment {
+    ty: RuleType,
+    action: RuleAction,
+    expr: RuleExpr,
+}
+
+fn parse_ruleset_segments(s: impl AsRef<str>) -> Result<Vec<RulesetSegment>, RuleParseError> {
+    let mut input = s.as_ref();
+    let mut segments = Vec::new();
+
+    while !input.is_empty() {
+        let (ty, remaining) = RuleType::consume_input(input)?;
+        let (action, remaining) = RuleAction::consume_input(remaining)?;
+        let (expr, remaining) = RuleExpr::consume_input(remaining)?;
+
+        segments.push(RulesetSegment { ty, action, expr });
+
+        input = remaining;
+    }
+
+    Ok(segments)
+}
+
+/// Represents a ruleset that can be used to specify a whitelist and a blacklist in order to
+/// control the inbound and outbound traffic of a network.
+#[derive(Debug, Clone)]
+pub struct Ruleset {
+    rules: Arc<RwLock<Vec<Rule>>>,
+}
+
+impl Ruleset {
+    /// Returns `true` if at least one rule allows accessing `socket_addr` in the specific `direction`
+    /// and no rule blocks it
+    pub fn allows_socket(&self, addr: impl Into<SocketAddr>, dir: Direction) -> bool {
+        let addr = addr.into();
+
+        let is_allowed = {
+            let ruleset = self.rules.read().unwrap();
+
+            let is_blacklisted = ruleset.iter().any(|r| r.blocks_socket(addr, dir));
+            if is_blacklisted {
+                return false;
+            }
+
+            ruleset.iter().any(|r| r.allows_socket(addr, dir))
+        };
+
+        is_allowed
+    }
+
+    /// Returns `true` if at least one rule allows querying the specific `domain` and no rule blocks it
+    pub fn allows_domain(&self, domain: impl AsRef<str>) -> bool {
+        let domain = domain.as_ref();
+
+        let is_allowed = {
+            let ruleset = self.rules.read().unwrap();
+
+            let is_blacklisted = ruleset.iter().any(|r| r.blocks_domain(domain));
+            if is_blacklisted {
+                return false;
+            }
+
+            ruleset.iter().any(|r| r.allows_domain(domain))
+        };
+
+        is_allowed
+    }
+
+    /// Expands the DNS rule that allows the specified `domain` into a list of IP based
+    /// rules with addresses specified by `addrs`
+    pub fn expand_domain(
+        &self,
+        domain: impl AsRef<str>,
+        addrs: impl AsRef<[IpAddr]>,
+    ) -> Result<(), RuleParseError> {
+        let mut ruleset = self.rules.write().unwrap();
+        let domain = domain.as_ref();
+
+        let mut already_expanded = false;
+        let port_spec = ruleset
+            .iter_mut()
+            .find_map(|rule| {
+                let port_spec = rule.port_spec_of_domain(domain);
+
+                if port_spec.is_some() {
+                    if rule.is_expandable() {
+                        rule.set_expanded(true);
+
+                        return port_spec;
+                    } else {
+                        already_expanded = true;
+                    }
+                }
+
+                None
+            })
+            .ok_or_else(|| {
+                if already_expanded {
+                    RuleParseError::DomainAlreadyExpanded(domain.to_string())
+                } else {
+                    RuleParseError::DomainRuleNotFound(domain.to_string())
+                }
+            })?;
+
+        for addr in addrs.as_ref() {
+            let rule = match addr {
+                IpAddr::V4(ip) => Rule::IPV4(IPV4Rule {
+                    ip_spec: IPV4Spec::IP(*ip),
+                    port_spec: port_spec.clone(),
+                    direction: Direction::Outbound,
+                }),
+                IpAddr::V6(ip) => Rule::IPV6(IPV6Rule {
+                    ip_spec: IPV6Spec::IP(*ip),
+                    port_spec: port_spec.clone(),
+                    direction: Direction::Outbound,
+                }),
+            };
+
+            ruleset.push(rule);
+        }
+
+        Ok(())
+    }
+}
+
+impl FromStr for Ruleset {
+    type Err = RuleParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let s: String = s.chars().filter(|c| !c.is_whitespace()).collect();
+        let mut rules = vec![];
+        for seg in parse_ruleset_segments(s)? {
+            let rule_type = &seg.ty;
+            let rule_action = &seg.action;
+            let rule_expr = &seg.expr;
+
+            let parsed_rules: Vec<Rule> = match rule_type {
+                RuleType::Dns => parse_dns_rule(&rule_expr.0)?
+                    .into_iter()
+                    .map(Rule::DNS)
+                    .collect(),
+                RuleType::IPV4 => parse_ipv4_rule(&rule_expr.0)?
+                    .into_iter()
+                    .map(Rule::IPV4)
+                    .collect(),
+                RuleType::IPV6 => parse_ipv6_rule(&rule_expr.0)?
+                    .into_iter()
+                    .map(Rule::IPV6)
+                    .collect(),
+            };
+
+            let parsed_rules = match rule_action {
+                RuleAction::Allow => parsed_rules,
+                RuleAction::Deny => parsed_rules
+                    .into_iter()
+                    .map(|rule| Rule::Neg(Arc::new(rule)))
+                    .collect(),
+            };
+
+            rules.extend(parsed_rules);
+        }
+
+        Ok(Self {
+            rules: Arc::new(RwLock::new(rules)),
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn all_ports_spec() {
+        let spec = PortSpec::from_str("*").unwrap();
+
+        assert!(spec.matches(80));
+    }
+
+    #[test]
+    fn port_spec() {
+        let spec = PortSpec::from_str("80").unwrap();
+
+        assert!(spec.matches(80));
+        assert!(!spec.matches(443));
+    }
+
+    #[test]
+    fn port_range_spec() {
+        let spec = PortSpec::from_str("80-85").unwrap();
+
+        assert!(!spec.matches(79));
+        assert!(spec.matches(80));
+        assert!(spec.matches(81));
+        assert!(spec.matches(82));
+        assert!(spec.matches(83));
+        assert!(spec.matches(84));
+        assert!(spec.matches(85));
+        assert!(!spec.matches(86));
+    }
+
+    #[test]
+    fn all_domains_spec() {
+        let spec = DomainSpec::from_str("*").unwrap();
+
+        assert!(spec.matches("example.com"));
+    }
+
+    #[test]
+    fn domain_spec() {
+        let spec = DomainSpec::from_str("example.com").unwrap();
+
+        assert!(spec.matches("example.com"));
+        assert!(!spec.matches("sub.example.com"));
+        assert!(!spec.matches("test.com"));
+    }
+
+    #[test]
+    fn domain_glob_spec() {
+        let spec = DomainSpec::from_str("*.example.com").unwrap();
+
+        assert!(!spec.matches("example.com"));
+        assert!(spec.matches("sub.example.com"));
+        assert!(spec.matches("another.sub.example.com"));
+        assert!(!spec.matches("test.com"));
+    }
+
+    #[test]
+    fn all_ipv4s_spec() {
+        let spec = IPV4Spec::from_str("*").unwrap();
+
+        assert!(spec.matches([127, 0, 0, 1]));
+    }
+
+    #[test]
+    fn ipv4_spec() {
+        let spec = IPV4Spec::from_str("127.0.0.1").unwrap();
+
+        assert!(spec.matches([127, 0, 0, 1]));
+        assert!(!spec.matches([192, 168, 1, 1]));
+    }
+
+    #[test]
+    fn ipv4_range_spec() {
+        let rule = IPV4Spec::from_str("192.168.1.0/24").unwrap();
+
+        let matches = vec![
+            "192.168.1.1",
+            "192.168.1.0",
+            "192.168.1.255",
+            "192.168.1.100",
+            "192.168.1.50",
+        ];
+
+        let non_matches = vec![
+            "192.168.2.0",
+            "192.167.1.1",
+            "10.0.0.1",
+            "172.16.0.1",
+            "192.168.0.255",
+        ];
+
+        for ip in matches {
+            let ip_addr: Ipv4Addr = ip.parse().unwrap();
+            assert!(rule.matches(ip_addr));
+        }
+
+        for ip in non_matches {
+            let ip_addr: Ipv4Addr = ip.parse().unwrap();
+            assert!(!rule.matches(ip_addr));
+        }
+    }
+
+    #[test]
+    fn all_ipv6s_spec() {
+        let spec = IPV6Spec::from_str("*").unwrap();
+
+        assert!(spec.matches("2001:db8::1".parse().unwrap()));
+    }
+
+    #[test]
+    fn ipv6_spec() {
+        let spec = IPV6Spec::from_str("2001:db8::1").unwrap();
+
+        assert!(spec.matches("2001:db8::1".parse().unwrap()));
+        assert!(!spec.matches("2001:db7::1".parse().unwrap()));
+    }
+
+    #[test]
+    fn ipv6_range_spec() {
+        let spec = IPV6Spec::from_str("2001:db8::/32").unwrap();
+
+        let matches = vec![
+            "2001:db8::1",
+            "2001:db8::",
+            "2001:db8:0:0:0:0:0:1234",
+            "2001:db8::abcd",
+            "2001:db8::ffff",
+        ];
+
+        let non_matches = vec![
+            "2001:db9::",
+            "2001:db7::1",
+            "2001:dead::1",
+            "fe80::1",
+            "::1",
+        ];
+
+        for ip in matches {
+            let ip_addr: Ipv6Addr = ip.parse().unwrap();
+            assert!(spec.matches(ip_addr));
+        }
+
+        for ip in non_matches {
+            let ip_addr: Ipv6Addr = ip.parse().unwrap();
+            assert!(!spec.matches(ip_addr));
+        }
+    }
+
+    #[test]
+    fn dns_rule_all() {
+        let rules = parse_dns_rule("*:*").unwrap();
+
+        assert_eq!(rules.len(), 1);
+        assert!(rules[0].allows("example.com"));
+        assert_eq!(rules[0].allowed_ports(), PortSpec::All);
+    }
+
+    #[test]
+    fn dns_rule_single_domain_and_port() {
+        let rules = parse_dns_rule("example.com:80").unwrap();
+
+        assert_eq!(rules.len(), 1);
+        assert!(rules[0].allows("example.com"));
+        assert_eq!(rules[0].allowed_ports(), PortSpec::Port(80));
+    }
+
+    #[test]
+    fn dns_rule_multiple_domain_and_ports() {
+        let mut rules = parse_dns_rule("{a.com, *.b.com}:{80, 100-200}").unwrap();
+
+        let rule1 = rules.pop().unwrap(); // *.b.com:100-200
+        let rule2 = rules.pop().unwrap(); // *.b.com:80
+        let rule3 = rules.pop().unwrap(); // a.com:100-200
+        let rule4 = rules.pop().unwrap(); // a.com:80
+
+        assert!(rules.is_empty());
+
+        assert!(rule1.allows("sub.b.com"));
+        assert!(!rule1.allows("b.com"));
+        assert!(!rule1.allows("a.com"));
+        assert_eq!(rule1.allowed_ports(), PortSpec::PortRange(100..=200));
+
+        assert!(rule2.allows("sub.b.com"));
+        assert!(!rule2.allows("b.com"));
+        assert!(!rule2.allows("a.com"));
+        assert_eq!(rule2.allowed_ports(), PortSpec::Port(80));
+
+        assert!(rule3.allows("a.com"));
+        assert!(!rule3.allows("sub.a.com"));
+        assert!(!rule3.allows("b.com"));
+        assert_eq!(rule3.allowed_ports(), PortSpec::PortRange(100..=200));
+
+        assert!(rule4.allows("a.com"));
+        assert!(!rule4.allows("sub.a.com"));
+        assert!(!rule4.allows("b.com"));
+        assert_eq!(rule4.allowed_ports(), PortSpec::Port(80));
+    }
+
+    #[test]
+    fn ipv4_rule_all() {
+        let rules = parse_ipv4_rule("*:*").unwrap();
+
+        assert_eq!(rules.len(), 1);
+        assert!(rules[0].is_allowed([127, 0, 0, 1], 80, Direction::Inbound));
+        assert!(rules[0].is_allowed([127, 0, 0, 1], 80, Direction::Outbound));
+    }
+
+    #[test]
+    fn ipv4_rule_single_ip_all_ports_inbound() {
+        let rules = parse_ipv4_rule("127.0.0.1:*/in").unwrap();
+
+        assert_eq!(rules.len(), 1);
+        assert!(rules[0].is_allowed([127, 0, 0, 1], 80, Direction::Inbound));
+        assert!(!rules[0].is_allowed([127, 0, 0, 1], 80, Direction::Outbound));
+        assert!(!rules[0].is_allowed([192, 168, 1, 2], 80, Direction::Inbound));
+        assert!(!rules[0].is_allowed([192, 168, 1, 2], 80, Direction::Outbound));
+    }
+
+    #[test]
+    fn ipv4_rule_ip_range_all_ports_outbound() {
+        let mut rules = parse_ipv4_rule("192.168.1.0/24:*/out").unwrap();
+
+        let ip_matches = vec![
+            "192.168.1.1",
+            "192.168.1.0",
+            "192.168.1.255",
+            "192.168.1.100",
+            "192.168.1.50",
+        ];
+
+        let ip_non_matches = vec![
+            "192.168.2.0",
+            "192.167.1.1",
+            "10.0.0.1",
+            "172.16.0.1",
+            "192.168.0.255",
+        ];
+
+        assert_eq!(rules.len(), 1);
+        let rule = rules.pop().unwrap();
+
+        for ip in &ip_matches {
+            let ip_addr: Ipv4Addr = ip.parse().unwrap();
+            assert!(rule.is_allowed(ip_addr, 8080, Direction::Outbound));
+        }
+        // direction is wrong
+        for ip in &ip_matches {
+            let ip_addr: Ipv4Addr = ip.parse().unwrap();
+            assert!(!rule.is_allowed(ip_addr, 8080, Direction::Inbound));
+        }
+        // ip is wrong
+        for ip in &ip_non_matches {
+            let ip_addr: Ipv4Addr = ip.parse().unwrap();
+            assert!(!rule.is_allowed(ip_addr, 8080, Direction::Inbound));
+        }
+    }
+
+    #[test]
+    fn ipv4_rule_all_ip_port_range_outbound() {
+        let rules = parse_ipv4_rule("*:80-90/out").unwrap();
+
+        assert_eq!(rules.len(), 1);
+        assert!(!rules[0].is_allowed([127, 0, 0, 1], 80, Direction::Inbound));
+        assert!(rules[0].is_allowed([127, 0, 0, 1], 80, Direction::Outbound));
+        assert!(rules[0].is_allowed([127, 0, 0, 1], 85, Direction::Outbound));
+        assert!(rules[0].is_allowed([127, 0, 0, 1], 90, Direction::Outbound));
+        assert!(!rules[0].is_allowed([127, 0, 0, 1], 443, Direction::Outbound));
+        assert!(!rules[0].is_allowed([192, 168, 1, 2], 80, Direction::Inbound));
+        assert!(rules[0].is_allowed([192, 168, 1, 2], 80, Direction::Outbound));
+    }
+
+    #[test]
+    fn multiple_ipv4_rules() {
+        let mut rules = parse_ipv4_rule("{127.0.0.1, 192.168.1.0/24}:{80, 8080}/in").unwrap();
+
+        let rule1 = rules.pop().unwrap(); // 192.168.1.0/24:8080/in
+        let rule2 = rules.pop().unwrap(); // 192.168.1.0/24:80/in
+        let rule3 = rules.pop().unwrap(); // 127.0.0.1:8080/in
+        let rule4 = rules.pop().unwrap(); // 127.0.0.1:80/in
+
+        assert!(rules.is_empty());
+
+        let ip_matches = vec![
+            "192.168.1.1",
+            "192.168.1.0",
+            "192.168.1.255",
+            "192.168.1.100",
+            "192.168.1.50",
+        ];
+
+        let ip_non_matches = vec![
+            "192.168.2.0",
+            "192.167.1.1",
+            "10.0.0.1",
+            "172.16.0.1",
+            "192.168.0.255",
+        ];
+
+        // rule1
+        for ip in &ip_matches {
+            let ip_addr: Ipv4Addr = ip.parse().unwrap();
+            assert!(rule1.is_allowed(ip_addr, 8080, Direction::Inbound));
+        }
+        // direction is wrong
+        for ip in &ip_matches {
+            let ip_addr: Ipv4Addr = ip.parse().unwrap();
+            assert!(!rule1.is_allowed(ip_addr, 8080, Direction::Outbound));
+        }
+        // port is wrong
+        for ip in &ip_matches {
+            let ip_addr: Ipv4Addr = ip.parse().unwrap();
+            assert!(!rule1.is_allowed(ip_addr, 80, Direction::Inbound));
+        }
+        // ip is wrong
+        for ip in &ip_non_matches {
+            let ip_addr: Ipv4Addr = ip.parse().unwrap();
+            assert!(!rule1.is_allowed(ip_addr, 8080, Direction::Inbound));
+        }
+
+        // rule2
+        for ip in &ip_matches {
+            let ip_addr: Ipv4Addr = ip.parse().unwrap();
+            assert!(rule2.is_allowed(ip_addr, 80, Direction::Inbound));
+        }
+        // direction is wrong
+        for ip in &ip_matches {
+            let ip_addr: Ipv4Addr = ip.parse().unwrap();
+            assert!(!rule2.is_allowed(ip_addr, 80, Direction::Outbound));
+        }
+        // port is wrong
+        for ip in &ip_matches {
+            let ip_addr: Ipv4Addr = ip.parse().unwrap();
+            assert!(!rule2.is_allowed(ip_addr, 8080, Direction::Inbound));
+        }
+        // ip is wrong
+        for ip in &ip_non_matches {
+            let ip_addr: Ipv4Addr = ip.parse().unwrap();
+            assert!(!rule2.is_allowed(ip_addr, 80, Direction::Inbound));
+        }
+
+        // rule3
+        assert!(rule3.is_allowed([127, 0, 0, 1], 8080, Direction::Inbound));
+        assert!(!rule3.is_allowed([192, 168, 1, 2], 8080, Direction::Inbound));
+        assert!(!rule3.is_allowed([127, 0, 0, 1], 80, Direction::Inbound));
+        assert!(!rule3.is_allowed([127, 0, 0, 1], 8080, Direction::Outbound));
+
+        // rule4
+        assert!(rule4.is_allowed([127, 0, 0, 1], 80, Direction::Inbound));
+        assert!(!rule4.is_allowed([192, 168, 1, 2], 80, Direction::Inbound));
+        assert!(!rule4.is_allowed([127, 0, 0, 1], 8080, Direction::Inbound));
+        assert!(!rule4.is_allowed([127, 0, 0, 1], 80, Direction::Outbound));
+    }
+
+    #[test]
+    fn ipv6_rule_all() {
+        let rules = parse_ipv6_rule("*:*").unwrap();
+
+        assert_eq!(rules.len(), 1);
+        assert!(rules[0].is_allowed(
+            "2001:db8::1".parse::<Ipv6Addr>().unwrap(),
+            80,
+            Direction::Inbound
+        ));
+        assert!(rules[0].is_allowed(
+            "2001:db8::1".parse::<Ipv6Addr>().unwrap(),
+            80,
+            Direction::Outbound
+        ));
+    }
+
+    #[test]
+    fn ipv6_rule_single_ip_and_port() {
+        let rules = parse_ipv6_rule("[2001:db8::1]:80").unwrap();
+
+        assert_eq!(rules.len(), 1);
+        assert!(rules[0].is_allowed(
+            "2001:db8::1".parse::<Ipv6Addr>().unwrap(),
+            80,
+            Direction::Inbound
+        ));
+        assert!(rules[0].is_allowed(
+            "2001:db8::1".parse::<Ipv6Addr>().unwrap(),
+            80,
+            Direction::Outbound
+        ));
+    }
+
+    #[test]
+    fn ipv6_rule_single_ip_all_ports_inbound() {
+        let rules = parse_ipv6_rule("[2001:db8::1]:*/in").unwrap();
+
+        assert_eq!(rules.len(), 1);
+        assert!(rules[0].is_allowed(
+            "2001:db8::1".parse::<Ipv6Addr>().unwrap(),
+            80,
+            Direction::Inbound
+        ));
+        assert!(!rules[0].is_allowed(
+            "2002:db8::1".parse::<Ipv6Addr>().unwrap(),
+            80,
+            Direction::Inbound
+        ));
+        assert!(!rules[0].is_allowed(
+            "2001:db8::1".parse::<Ipv6Addr>().unwrap(),
+            8080,
+            Direction::Outbound
+        ));
+    }
+
+    #[test]
+    fn ipv6_rule_ip_range_all_ports_outbound() {
+        let mut rules = parse_ipv6_rule("[2001:db8::/32]:*/out").unwrap();
+
+        let ip_matches = vec![
+            "2001:db8::1",
+            "2001:db8::",
+            "2001:db8:0:0:0:0:0:1234",
+            "2001:db8::abcd",
+            "2001:db8::ffff",
+        ];
+
+        let ip_non_matches = vec![
+            "2001:db9::",
+            "2001:db7::1",
+            "2001:dead::1",
+            "fe80::1",
+            "::1",
+        ];
+
+        assert_eq!(rules.len(), 1);
+        let rule = rules.pop().unwrap();
+
+        for ip in &ip_matches {
+            let ip_addr: Ipv6Addr = ip.parse().unwrap();
+            assert!(rule.is_allowed(ip_addr, 8080, Direction::Outbound));
+        }
+        // direction is wrong
+        for ip in &ip_matches {
+            let ip_addr: Ipv6Addr = ip.parse().unwrap();
+            assert!(!rule.is_allowed(ip_addr, 8080, Direction::Inbound));
+        }
+        // ip is wrong
+        for ip in &ip_non_matches {
+            let ip_addr: Ipv6Addr = ip.parse().unwrap();
+            assert!(!rule.is_allowed(ip_addr, 8080, Direction::Inbound));
+        }
+    }
+
+    #[test]
+    fn multiple_ipv6_rules() {
+        let mut rules = parse_ipv6_rule("{3001:db8::, 2001:db8::/32}:{80, 8080}/in").unwrap();
+
+        let rule1 = rules.pop().unwrap(); // [2001:db8::/32]:8080/in
+        let rule2 = rules.pop().unwrap(); // [2001:db8::/32]:80/in
+        let rule3 = rules.pop().unwrap(); // [3001:db8::]:8080/in
+        let rule4 = rules.pop().unwrap(); // [3001:db8::]:80/in
+
+        assert!(rules.is_empty());
+
+        let ip_matches = vec![
+            "2001:db8::1",
+            "2001:db8::",
+            "2001:db8:0:0:0:0:0:1234",
+            "2001:db8::abcd",
+            "2001:db8::ffff",
+        ];
+
+        let ip_non_matches = vec![
+            "2001:db9::",
+            "2001:db7::1",
+            "2001:dead::1",
+            "fe80::1",
+            "::1",
+        ];
+
+        // rule1
+        for ip in &ip_matches {
+            let ip_addr: Ipv6Addr = ip.parse().unwrap();
+            assert!(rule1.is_allowed(ip_addr, 8080, Direction::Inbound));
+        }
+        // direction is wrong
+        for ip in &ip_matches {
+            let ip_addr: Ipv6Addr = ip.parse().unwrap();
+            assert!(!rule1.is_allowed(ip_addr, 8080, Direction::Outbound));
+        }
+        // port is wrong
+        for ip in &ip_matches {
+            let ip_addr: Ipv6Addr = ip.parse().unwrap();
+            assert!(!rule1.is_allowed(ip_addr, 80, Direction::Inbound));
+        }
+        // ip is wrong
+        for ip in &ip_non_matches {
+            let ip_addr: Ipv6Addr = ip.parse().unwrap();
+            assert!(!rule1.is_allowed(ip_addr, 8080, Direction::Inbound));
+        }
+
+        // rule2
+        for ip in &ip_matches {
+            let ip_addr: Ipv6Addr = ip.parse().unwrap();
+            assert!(rule2.is_allowed(ip_addr, 80, Direction::Inbound));
+        }
+        // direction is wrong
+        for ip in &ip_matches {
+            let ip_addr: Ipv6Addr = ip.parse().unwrap();
+            assert!(!rule2.is_allowed(ip_addr, 80, Direction::Outbound));
+        }
+        // port is wrong
+        for ip in &ip_matches {
+            let ip_addr: Ipv6Addr = ip.parse().unwrap();
+            assert!(!rule2.is_allowed(ip_addr, 8080, Direction::Inbound));
+        }
+        // ip is wrong
+        for ip in &ip_non_matches {
+            let ip_addr: Ipv6Addr = ip.parse().unwrap();
+            assert!(!rule2.is_allowed(ip_addr, 80, Direction::Inbound));
+        }
+
+        // rule3
+        assert!(rule3.is_allowed(
+            "3001:db8::".parse::<Ipv6Addr>().unwrap(),
+            8080,
+            Direction::Inbound
+        ));
+        assert!(!rule3.is_allowed(
+            "4001:db8::".parse::<Ipv6Addr>().unwrap(),
+            8080,
+            Direction::Inbound
+        ));
+        assert!(!rule3.is_allowed(
+            "3001:db8::".parse::<Ipv6Addr>().unwrap(),
+            80,
+            Direction::Inbound
+        ));
+        assert!(!rule3.is_allowed(
+            "3001:db8::".parse::<Ipv6Addr>().unwrap(),
+            8080,
+            Direction::Outbound
+        ));
+
+        // rule4
+        assert!(rule4.is_allowed(
+            "3001:db8::".parse::<Ipv6Addr>().unwrap(),
+            80,
+            Direction::Inbound
+        ));
+        assert!(!rule4.is_allowed(
+            "4001:db8::".parse::<Ipv6Addr>().unwrap(),
+            80,
+            Direction::Inbound
+        ));
+        assert!(!rule4.is_allowed(
+            "3001:db8::".parse::<Ipv6Addr>().unwrap(),
+            8080,
+            Direction::Inbound
+        ));
+        assert!(!rule4.is_allowed(
+            "3001:db8::".parse::<Ipv6Addr>().unwrap(),
+            80,
+            Direction::Outbound
+        ));
+    }
+
+    #[test]
+    fn ruleset_dns() {
+        let ruleset = Ruleset::from_str("dns:allow={a.com, *.b.com}:{80, 8080}").unwrap();
+
+        assert!(ruleset.allows_domain("a.com"));
+        assert!(!ruleset.allows_domain("sub.a.com"));
+        assert!(!ruleset.allows_domain("b.com"));
+        assert!(ruleset.allows_domain("sub.b.com"));
+        assert!(ruleset.allows_domain("another.sub.b.com"));
+    }
+
+    #[test]
+    fn ruleset_ipv4() {
+        let ruleset =
+            Ruleset::from_str("ipv4:deny={127.0.0.1, 192.168.1.0/24}:{80, 8080}/in").unwrap();
+
+        let ip_matches = vec![
+            "192.168.1.1",
+            "192.168.1.0",
+            "192.168.1.255",
+            "192.168.1.100",
+            "192.168.1.50",
+        ];
+
+        for ip in &ip_matches {
+            let ip_addr: Ipv4Addr = ip.parse().unwrap();
+            assert!(!ruleset.allows_socket((ip_addr, 8080), Direction::Inbound));
+        }
+
+        assert!(!ruleset.allows_socket(([127, 0, 0, 1], 8080), Direction::Inbound));
+        assert!(!ruleset.allows_socket(([127, 0, 0, 1], 80), Direction::Inbound));
+    }
+
+    #[test]
+    fn ruleset_ipv6() {
+        let ruleset =
+            Ruleset::from_str("ipv6:allow={3001:db8::, 2001:db8::/32}:{80, 8080}/in").unwrap();
+
+        let ip_matches = vec![
+            "2001:db8::1",
+            "2001:db8::",
+            "2001:db8:0:0:0:0:0:1234",
+            "2001:db8::abcd",
+            "2001:db8::ffff",
+        ];
+
+        for ip in &ip_matches {
+            let ip_addr: Ipv6Addr = ip.parse().unwrap();
+            assert!(ruleset.allows_socket((ip_addr, 8080), Direction::Inbound));
+        }
+
+        assert!(ruleset.allows_socket(
+            ("3001:db8::".parse::<Ipv6Addr>().unwrap(), 8080),
+            Direction::Inbound
+        ));
+        assert!(ruleset.allows_socket(
+            ("3001:db8::".parse::<Ipv6Addr>().unwrap(), 8080),
+            Direction::Inbound
+        ));
+    }
+
+    #[test]
+    fn ruleset_full() {
+        let ruleset = Ruleset::from_str(
+            "dns:allow={a.com, *.b.com}:{80, 8080},
+            ipv4:deny={127.0.0.1, 192.168.1.0/24}:{80, 8080}/in,
+            ipv6:allow={3001:db8::, 2001:db8::/32}:{80, 8080}/in",
+        )
+        .unwrap();
+
+        // dns rules
+        assert!(ruleset.allows_domain("a.com"));
+        assert!(!ruleset.allows_domain("sub.a.com"));
+        assert!(!ruleset.allows_domain("b.com"));
+        assert!(ruleset.allows_domain("sub.b.com"));
+        assert!(ruleset.allows_domain("another.sub.b.com"));
+
+        // ipv4 rules
+        let ip_matches = vec![
+            "192.168.1.1",
+            "192.168.1.0",
+            "192.168.1.255",
+            "192.168.1.100",
+            "192.168.1.50",
+        ];
+
+        for ip in &ip_matches {
+            let ip_addr: Ipv4Addr = ip.parse().unwrap();
+            assert!(!ruleset.allows_socket((ip_addr, 8080), Direction::Inbound));
+        }
+
+        assert!(!ruleset.allows_socket(([127, 0, 0, 1], 8080), Direction::Inbound));
+        assert!(!ruleset.allows_socket(([127, 0, 0, 1], 80), Direction::Inbound));
+
+        // ipv6 rules
+        let ip_matches = vec![
+            "2001:db8::1",
+            "2001:db8::",
+            "2001:db8:0:0:0:0:0:1234",
+            "2001:db8::abcd",
+            "2001:db8::ffff",
+        ];
+
+        for ip in &ip_matches {
+            let ip_addr: Ipv6Addr = ip.parse().unwrap();
+            assert!(ruleset.allows_socket((ip_addr, 8080), Direction::Inbound));
+        }
+
+        assert!(ruleset.allows_socket(
+            ("3001:db8::".parse::<Ipv6Addr>().unwrap(), 8080),
+            Direction::Inbound
+        ));
+        assert!(ruleset.allows_socket(
+            ("3001:db8::".parse::<Ipv6Addr>().unwrap(), 8080),
+            Direction::Inbound
+        ));
+    }
+}
diff --git a/lib/virtual-net/src/rx_tx.rs b/lib/virtual-net/src/rx_tx.rs
index 6d8391b37b..9d5d978778 100644
--- a/lib/virtual-net/src/rx_tx.rs
+++ b/lib/virtual-net/src/rx_tx.rs
@@ -7,6 +7,7 @@ use std::{
 
 use crate::Result;
 use futures_util::{future::BoxFuture, Future, Sink, SinkExt, Stream};
+#[cfg(feature = "hyper")]
 use hyper_util::rt::tokio::TokioIo;
 use serde::Serialize;
 #[cfg(feature = "tokio-tungstenite")]
@@ -61,6 +62,7 @@ impl AsyncWrite for FailOnWrite {
 
 pub(crate) type StreamSink<T> = Pin<Box<dyn Sink<T, Error = std::io::Error> + Send + 'static>>;
 
+#[derive(derive_more::Debug)]
 pub(crate) enum RemoteTx<T>
 where
     T: Serialize,
@@ -71,6 +73,7 @@ where
         wakers: RemoteTxWakers,
     },
     Stream {
+        #[debug(ignore)]
         tx: Arc<tokio::sync::Mutex<StreamSink<T>>>,
         work: mpsc::UnboundedSender<BoxFuture<'static, ()>>,
         wakers: RemoteTxWakers,
@@ -503,6 +506,7 @@ where
     }
 }
 
+#[derive(derive_more::Debug)]
 pub(crate) enum RemoteRx<T>
 where
     T: serde::de::DeserializeOwned,
@@ -512,6 +516,7 @@ where
         wakers: RemoteTxWakers,
     },
     Stream {
+        #[debug(ignore)]
         rx: Pin<Box<dyn Stream<Item = std::io::Result<T>> + Send + 'static>>,
     },
     #[cfg(feature = "hyper")]
diff --git a/lib/virtual-net/src/server.rs b/lib/virtual-net/src/server.rs
index 73859d428e..fd834fe454 100644
--- a/lib/virtual-net/src/server.rs
+++ b/lib/virtual-net/src/server.rs
@@ -5,7 +5,6 @@ use crate::{
     VirtualNetworking, VirtualRawSocket, VirtualTcpListener, VirtualTcpSocket, VirtualUdpSocket,
 };
 use crate::{IpCidr, IpRoute, NetworkError, StreamSecurity, VirtualIcmpSocket};
-use derivative::Derivative;
 use futures_util::stream::FuturesOrdered;
 #[cfg(any(feature = "hyper", feature = "tokio-tungstenite"))]
 use futures_util::stream::{SplitSink, SplitStream};
@@ -17,6 +16,7 @@ use std::net::IpAddr;
 use std::task::Waker;
 use std::time::Duration;
 
+#[cfg(feature = "hyper")]
 use hyper_util::rt::tokio::TokioIo;
 use std::{
     collections::HashMap,
@@ -1222,6 +1222,7 @@ impl RemoteNetworkingServerDriver {
     }
 }
 
+#[derive(Debug)]
 enum RemoteAdapterSocket {
     TcpListener {
         socket: Box<dyn VirtualTcpListener + Sync + 'static>,
@@ -1455,7 +1456,7 @@ impl RemoteAdapterSocket {
                 Self::TcpSocket(this) => {
                     let mut chunk: [MaybeUninit<u8>; 10240] =
                         unsafe { MaybeUninit::uninit().assume_init() };
-                    match this.try_recv(&mut chunk) {
+                    match this.try_recv(&mut chunk, false) {
                         Ok(0) => {}
                         Ok(amt) => {
                             let chunk_unsafe: &mut [MaybeUninit<u8>] = &mut chunk[..amt];
@@ -1475,7 +1476,7 @@ impl RemoteAdapterSocket {
                 Self::UdpSocket(this) => {
                     let mut chunk: [MaybeUninit<u8>; 10240] =
                         unsafe { MaybeUninit::uninit().assume_init() };
-                    match this.try_recv_from(&mut chunk) {
+                    match this.try_recv_from(&mut chunk, false) {
                         Ok((0, _)) => {}
                         Ok((amt, addr)) => {
                             let chunk_unsafe: &mut [MaybeUninit<u8>] = &mut chunk[..amt];
@@ -1496,7 +1497,7 @@ impl RemoteAdapterSocket {
                 Self::IcmpSocket(this) => {
                     let mut chunk: [MaybeUninit<u8>; 10240] =
                         unsafe { MaybeUninit::uninit().assume_init() };
-                    match this.try_recv_from(&mut chunk) {
+                    match this.try_recv_from(&mut chunk, false) {
                         Ok((0, _)) => {}
                         Ok((amt, addr)) => {
                             let chunk_unsafe: &mut [MaybeUninit<u8>] = &mut chunk[..amt];
@@ -1517,7 +1518,7 @@ impl RemoteAdapterSocket {
                 Self::RawSocket(this) => {
                     let mut chunk: [MaybeUninit<u8>; 10240] =
                         unsafe { MaybeUninit::uninit().assume_init() };
-                    match this.try_recv(&mut chunk) {
+                    match this.try_recv(&mut chunk, false) {
                         Ok(0) => {}
                         Ok(amt) => {
                             let chunk_unsafe: &mut [MaybeUninit<u8>] = &mut chunk[..amt];
@@ -1615,14 +1616,10 @@ impl InterestHandler for RemoteAdapterHandler {
 
 type SocketMap<T> = HashMap<SocketId, T>;
 
-#[derive(Derivative)]
-#[derivative(Debug)]
+#[derive(Debug)]
 struct RemoteAdapterCommon {
-    #[derivative(Debug = "ignore")]
     tx: RemoteTx<MessageResponse>,
-    #[derivative(Debug = "ignore")]
     rx: Mutex<RemoteRx<MessageRequest>>,
-    #[derivative(Debug = "ignore")]
     sockets: Mutex<SocketMap<RemoteAdapterSocket>>,
     socket_accept: Mutex<SocketMap<SocketId>>,
     handler: RemoteAdapterHandler,
diff --git a/lib/virtual-net/src/tcp_pair.rs b/lib/virtual-net/src/tcp_pair.rs
index ee73b2989e..892dc289a2 100644
--- a/lib/virtual-net/src/tcp_pair.rs
+++ b/lib/virtual-net/src/tcp_pair.rs
@@ -213,7 +213,7 @@ impl SocketBuffer {
             this: &'a SocketBuffer,
             data: Bytes,
         }
-        impl<'a> Future for Poller<'a> {
+        impl Future for Poller<'_> {
             type Output = crate::Result<()>;
             fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
                 loop {
@@ -237,6 +237,7 @@ impl SocketBuffer {
     pub fn try_read(
         &self,
         buf: &mut [std::mem::MaybeUninit<u8>],
+        peek: bool,
         waker: Option<&Waker>,
     ) -> crate::Result<usize> {
         let mut state = self.state.lock().unwrap();
@@ -264,7 +265,11 @@ impl SocketBuffer {
 
         let buf: &mut [u8] = unsafe { std::mem::transmute(buf) };
         let amt = buf.len().min(state.buffer.len());
-        let amt = state.buffer.dequeue_slice(&mut buf[..amt]);
+        let amt = if peek {
+            state.buffer.read_allocated(0, &mut buf[..amt])
+        } else {
+            state.buffer.dequeue_slice(&mut buf[..amt])
+        };
 
         if let Some(handler) = state.pull_handler.as_mut() {
             handler.push_interest(InterestType::Writable);
@@ -324,7 +329,7 @@ impl AsyncRead for SocketBuffer {
         cx: &mut Context<'_>,
         buf: &mut tokio::io::ReadBuf<'_>,
     ) -> Poll<io::Result<()>> {
-        match self.try_read(unsafe { buf.unfilled_mut() }, Some(cx.waker())) {
+        match self.try_read(unsafe { buf.unfilled_mut() }, false, Some(cx.waker())) {
             Ok(amt) => {
                 unsafe { buf.assume_init(amt) };
                 buf.advance(amt);
@@ -457,8 +462,12 @@ impl VirtualConnectedSocket for TcpSocketHalf {
         Ok(())
     }
 
-    fn try_recv(&mut self, buf: &mut [std::mem::MaybeUninit<u8>]) -> crate::Result<usize> {
-        self.rx.try_read(buf, None)
+    fn try_recv(
+        &mut self,
+        buf: &mut [std::mem::MaybeUninit<u8>],
+        peek: bool,
+    ) -> crate::Result<usize> {
+        self.rx.try_read(buf, peek, None)
     }
 }
 
diff --git a/lib/vm/Cargo.toml b/lib/vm/Cargo.toml
index 0fcf37541f..19fdda81d6 100644
--- a/lib/vm/Cargo.toml
+++ b/lib/vm/Cargo.toml
@@ -15,40 +15,50 @@ version.workspace = true
 [dependencies]
 memoffset.workspace = true
 dashmap.workspace = true
-wasmer-types = { path = "../types", version = "=4.3.7" }
+wasmer-types = { path = "../types", version = "=6.1.0" }
 libc.workspace = true
-indexmap = { version = "1.6" }
-thiserror = "1.0"
-more-asserts = "0.2"
-cfg-if = "1.0"
-backtrace = "0.3"
-serde = { version = "1.0", features = ["derive", "rc"], optional = true }
-enum-iterator = "0.7.0"
+indexmap.workspace = true
+thiserror.workspace = true
+more-asserts.workspace = true
+cfg-if.workspace = true
+backtrace.workspace = true
+serde = { workspace = true, features = ["derive", "rc"], optional = true }
+enum-iterator.workspace = true
 scopeguard = "1.1.0"
-lazy_static = "1.4.0"
-region = { version = "3.0.2" }
-corosensei = { version = "0.1.2" }
-derivative = { version = "^2" }
+region.workspace = true
+corosensei = { version = "0.3.0" }
 fnv = "1.0.3"
 # - Optional shared dependencies.
-tracing = { version = "0.1", optional = true }
+tracing = { workspace = true, optional = true }
 crossbeam-queue = "0.3.8"
+loupe = { workspace = true, optional = true }
+
+[target.'cfg(any(target_family = "unix", all(target_family = "windows", target_env = "gnu")))'.dependencies]
+libunwind = "1.3.3"
 
 [target.'cfg(target_vendor = "apple")'.dependencies]
 mach2 = "0.4.2"
 
 [target.'cfg(target_os = "windows")'.dependencies]
-windows-sys = { version = "0.59", features = ["Win32_System_Diagnostics_Debug", "Win32_System_Threading", "Win32_System_Kernel", "Win32_System_Memory"] }
+windows-sys = { version = "0.59", features = [
+	"Win32_System_Diagnostics_Debug",
+	"Win32_System_Threading",
+	"Win32_System_Kernel",
+	"Win32_System_Memory",
+] }
 
 [build-dependencies]
 cc = "1.0"
+rustversion = "1.0"
 
 [badges]
 maintenance = { status = "actively-developed" }
 
 [features]
 default = []
-enable-serde = ["serde", "indexmap/serde-1", "wasmer-types/enable-serde" ]
+enable-serde = ["serde", "indexmap/serde", "wasmer-types/enable-serde"]
+artifact-size = ["dep:loupe", "wasmer-types/artifact-size"]
+sanitizer = ["corosensei/sanitizer"]
 
 [package.metadata.docs.rs]
 rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/vm/README.md b/lib/vm/README.md
index 7854b0eae2..1d628b17e1 100644
--- a/lib/vm/README.md
+++ b/lib/vm/README.md
@@ -1,4 +1,4 @@
-# `wasmer-vm` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE)
+# `wasmer-vm` [![Build Status](https://github.com/wasmerio/wasmer/actions/workflows/build.yml/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE)
 
 This crate contains the Wasmer VM runtime library, supporting the Wasm ABI used by wasmer.
 
diff --git a/lib/vm/build.rs b/lib/vm/build.rs
new file mode 100644
index 0000000000..69ea647830
--- /dev/null
+++ b/lib/vm/build.rs
@@ -0,0 +1,10 @@
+#[rustversion::since(1.89)]
+fn main() {
+    println!("cargo::rustc-cfg=missing_rust_probestack");
+    println!("cargo::rustc-check-cfg=cfg(missing_rust_probestack)");
+}
+
+#[rustversion::before(1.89)]
+fn main() {
+    println!("cargo::rustc-check-cfg=cfg(missing_rust_probestack)");
+}
diff --git a/lib/vm/src/exception_ref.rs b/lib/vm/src/exception_ref.rs
new file mode 100644
index 0000000000..f092fcf47c
--- /dev/null
+++ b/lib/vm/src/exception_ref.rs
@@ -0,0 +1,47 @@
+use std::any::Any;
+use wasmer_types::RawValue;
+
+use crate::store::InternalStoreHandle;
+
+/// Underlying object referenced by a `VMExceptionRef`.
+#[derive(Debug)]
+pub struct VMExceptionObj {
+    contents: Box<dyn Any + Send + Sync + 'static>,
+}
+
+impl VMExceptionObj {
+    /// Wraps the given value to expose it to Wasm code as an externref.
+    pub fn new(val: impl Any + Send + Sync + 'static) -> Self {
+        Self {
+            contents: Box::new(val),
+        }
+    }
+
+    #[allow(clippy::should_implement_trait)]
+    /// Returns a reference to the underlying value.
+    pub fn as_ref(&self) -> &(dyn Any + Send + Sync + 'static) {
+        &*self.contents
+    }
+}
+
+/// Represents an opaque reference to any data within WebAssembly.
+#[repr(transparent)]
+#[derive(Debug, Clone, Copy)]
+pub struct VMExceptionRef(pub InternalStoreHandle<VMExceptionObj>);
+
+impl VMExceptionRef {
+    /// Converts the [`VMExceptionRef`] into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        RawValue {
+            funcref: self.0.index(),
+        }
+    }
+
+    /// Extracts a `VMExceptionRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw` must be a valid `VMExceptionRef` instance.
+    pub unsafe fn from_raw(raw: RawValue) -> Option<Self> {
+        InternalStoreHandle::from_index(raw.externref).map(Self)
+    }
+}
diff --git a/lib/vm/src/export.rs b/lib/vm/src/export.rs
index 3a670b14b1..5d47e427b4 100644
--- a/lib/vm/src/export.rs
+++ b/lib/vm/src/export.rs
@@ -7,11 +7,11 @@ use crate::store::InternalStoreHandle;
 use crate::table::VMTable;
 use crate::vmcontext::VMFunctionKind;
 use crate::{MaybeInstanceOwned, VMCallerCheckedAnyfunc};
-use derivative::Derivative;
 use std::any::Any;
-use wasmer_types::FunctionType;
+use wasmer_types::{FunctionType, TagKind};
 
 /// The value of an export passed from one instance to another.
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 pub enum VMExtern {
     /// A function export value.
     Function(InternalStoreHandle<VMFunction>),
@@ -24,15 +24,16 @@ pub enum VMExtern {
 
     /// A global export value.
     Global(InternalStoreHandle<VMGlobal>),
+
+    /// A tag export value.
+    Tag(InternalStoreHandle<VMTag>),
 }
 
 /// A function export value.
-#[derive(Derivative)]
-#[derivative(Debug)]
+#[derive(Debug)]
 pub struct VMFunction {
     /// Pointer to the `VMCallerCheckedAnyfunc` which contains data needed to
     /// call the function and check its signature.
-    #[derivative(Debug = "ignore")]
     pub anyfunc: MaybeInstanceOwned<VMCallerCheckedAnyfunc>,
 
     /// The function type, used for compatibility checking.
@@ -43,6 +44,22 @@ pub struct VMFunction {
     pub kind: VMFunctionKind,
 
     /// Associated data owned by a host function.
-    #[derivative(Debug = "ignore")]
     pub host_data: Box<dyn Any>,
 }
+
+/// A tag export value.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct VMTag {
+    /// The kind of tag.
+    // Note: currently it can only be exception.
+    pub kind: TagKind,
+    /// The tag type, used for compatibility checking.
+    pub signature: FunctionType,
+}
+
+impl VMTag {
+    /// Create a new [`VMTag`].
+    pub fn new(kind: TagKind, signature: FunctionType) -> Self {
+        Self { kind, signature }
+    }
+}
diff --git a/lib/vm/src/extern_ref.rs b/lib/vm/src/extern_ref.rs
index 79f71b876b..b14760f9a9 100644
--- a/lib/vm/src/extern_ref.rs
+++ b/lib/vm/src/extern_ref.rs
@@ -1,14 +1,11 @@
-use derivative::Derivative;
 use std::any::Any;
 use wasmer_types::RawValue;
 
 use crate::store::InternalStoreHandle;
 
 /// Underlying object referenced by a `VMExternRef`.
-#[derive(Derivative)]
-#[derivative(Debug)]
+#[derive(Debug)]
 pub struct VMExternObj {
-    #[derivative(Debug = "ignore")]
     contents: Box<dyn Any + Send + Sync + 'static>,
 }
 
diff --git a/lib/vm/src/function_env.rs b/lib/vm/src/function_env.rs
index f2f8b72840..8f681b762d 100644
--- a/lib/vm/src/function_env.rs
+++ b/lib/vm/src/function_env.rs
@@ -1,12 +1,17 @@
-use derivative::Derivative;
 use std::any::Any;
 
 /// Underlying FunctionEnvironment used by a `VMFunction`.
-#[derive(Derivative)]
-#[derivative(Debug)]
 pub struct VMFunctionEnvironment {
-    #[derivative(Debug = "ignore")]
-    contents: Box<dyn Any + Send + 'static>,
+    /// The contents of the environment.
+    pub contents: Box<dyn Any + Send + 'static>,
+}
+
+impl std::fmt::Debug for VMFunctionEnvironment {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("VMFunctionEnvironment")
+            .field("contents", &(&*self.contents as *const _))
+            .finish()
+    }
 }
 
 impl VMFunctionEnvironment {
diff --git a/lib/vm/src/global.rs b/lib/vm/src/global.rs
index bddb55575e..1743f2c0aa 100644
--- a/lib/vm/src/global.rs
+++ b/lib/vm/src/global.rs
@@ -1,14 +1,11 @@
 use crate::{store::MaybeInstanceOwned, vmcontext::VMGlobalDefinition};
-use derivative::Derivative;
 use std::{cell::UnsafeCell, ptr::NonNull};
 use wasmer_types::GlobalType;
 
 /// A Global instance
-#[derive(Derivative)]
-#[derivative(Debug)]
+#[derive(Debug)]
 pub struct VMGlobal {
     ty: GlobalType,
-    #[derivative(Debug = "ignore")]
     vm_global_definition: MaybeInstanceOwned<VMGlobalDefinition>,
 }
 
diff --git a/lib/vm/src/instance/mod.rs b/lib/vm/src/instance/mod.rs
index fa61069f0d..db23937dc6 100644
--- a/lib/vm/src/instance/mod.rs
+++ b/lib/vm/src/instance/mod.rs
@@ -12,14 +12,15 @@ use crate::export::VMExtern;
 use crate::imports::Imports;
 use crate::store::{InternalStoreHandle, StoreObjects};
 use crate::table::TableElement;
-use crate::trap::{catch_traps, Trap, TrapCode};
+use crate::trap::{Trap, TrapCode};
 use crate::vmcontext::{
     memory32_atomic_check32, memory32_atomic_check64, memory_copy, memory_fill,
     VMBuiltinFunctionsArray, VMCallerCheckedAnyfunc, VMContext, VMFunctionContext,
     VMFunctionImport, VMFunctionKind, VMGlobalDefinition, VMGlobalImport, VMMemoryDefinition,
-    VMMemoryImport, VMSharedSignatureIndex, VMTableDefinition, VMTableImport, VMTrampoline,
+    VMMemoryImport, VMSharedSignatureIndex, VMSharedTagIndex, VMTableDefinition, VMTableImport,
+    VMTrampoline,
 };
-use crate::{FunctionBodyPtr, MaybeInstanceOwned, TrapHandlerFn, VMFunctionBody};
+use crate::{wasmer_call_trampoline, FunctionBodyPtr, MaybeInstanceOwned, TrapHandlerFn, VMTag};
 use crate::{LinearMemory, NotifyLocation};
 use crate::{VMConfig, VMFuncRef, VMFunction, VMGlobal, VMMemory, VMTable};
 pub use allocator::InstanceAllocator;
@@ -38,7 +39,8 @@ use wasmer_types::entity::{packed_option::ReservedValue, BoxedSlice, EntityRef,
 use wasmer_types::{
     DataIndex, DataInitializer, ElemIndex, ExportIndex, FunctionIndex, GlobalIndex, GlobalInit,
     LocalFunctionIndex, LocalGlobalIndex, LocalMemoryIndex, LocalTableIndex, MemoryError,
-    MemoryIndex, ModuleInfo, Pages, SignatureIndex, TableIndex, TableInitializer, VMOffsets,
+    MemoryIndex, ModuleInfo, Pages, SignatureIndex, TableIndex, TableInitializer, TagIndex,
+    VMOffsets,
 };
 
 /// A WebAssembly instance.
@@ -68,6 +70,9 @@ pub(crate) struct Instance {
     /// WebAssembly global data.
     globals: BoxedSlice<LocalGlobalIndex, InternalStoreHandle<VMGlobal>>,
 
+    /// WebAssembly tag data. Notably, this stores *all* tags, not just local ones.
+    tags: BoxedSlice<TagIndex, InternalStoreHandle<VMTag>>,
+
     /// Pointers to functions in executable memory.
     functions: BoxedSlice<LocalFunctionIndex, FunctionBodyPtr>,
 
@@ -183,6 +188,17 @@ impl Instance {
         unsafe { self.vmctx_plus_offset(self.offsets.vmctx_imported_globals_begin()) }
     }
 
+    /// Return the indexed `VMSharedTagIndex`.
+    pub(crate) fn shared_tag_ptr(&self, index: TagIndex) -> &VMSharedTagIndex {
+        let index = usize::try_from(index.as_u32()).unwrap();
+        unsafe { &*self.shared_tags_ptr().add(index) }
+    }
+
+    /// Return a pointer to the `VMSharedTagIndex`s.
+    pub(crate) fn shared_tags_ptr(&self) -> *mut VMSharedTagIndex {
+        unsafe { self.vmctx_plus_offset(self.offsets.vmctx_tag_ids_begin()) }
+    }
+
     /// Return the indexed `VMTableDefinition`.
     #[allow(dead_code)]
     fn table(&self, index: LocalTableIndex) -> VMTableDefinition {
@@ -355,13 +371,22 @@ impl Instance {
             }
         };
 
-        // Make the call.
+        let sig = self.module.functions[start_index];
+        let trampoline = self.function_call_trampolines[sig];
+        let mut values_vec = vec![];
+
         unsafe {
-            catch_traps(trap_handler, config, || {
-                mem::transmute::<*const VMFunctionBody, unsafe extern "C" fn(VMFunctionContext)>(
-                    callee_address,
-                )(callee_vmctx)
-            })
+            // Even though we already know the type of the function we need to call, in certain
+            // specific cases trampoline prepare callee arguments for specific optimizations, such
+            // as passing g0 and m0_base_ptr as paramters.
+            wasmer_call_trampoline(
+                trap_handler,
+                config,
+                callee_vmctx,
+                trampoline,
+                callee_address,
+                values_vec.as_mut_ptr(),
+            )
         }
     }
 
@@ -1022,9 +1047,15 @@ impl VMInstance {
         finished_memories: BoxedSlice<LocalMemoryIndex, InternalStoreHandle<VMMemory>>,
         finished_tables: BoxedSlice<LocalTableIndex, InternalStoreHandle<VMTable>>,
         finished_globals: BoxedSlice<LocalGlobalIndex, InternalStoreHandle<VMGlobal>>,
+        tags: BoxedSlice<TagIndex, InternalStoreHandle<VMTag>>,
         imports: Imports,
         vmshared_signatures: BoxedSlice<SignatureIndex, VMSharedSignatureIndex>,
     ) -> Result<Self, Trap> {
+        let vmctx_tags = tags
+            .values()
+            .map(|m| VMSharedTagIndex::new(m.index() as u32))
+            .collect::<PrimaryMap<TagIndex, _>>()
+            .into_boxed_slice();
         let vmctx_globals = finished_globals
             .values()
             .map(|m| m.get(context).vmglobal())
@@ -1051,6 +1082,7 @@ impl VMInstance {
                 offsets,
                 memories: finished_memories,
                 tables: finished_tables,
+                tags,
                 globals: finished_globals,
                 functions: finished_functions,
                 function_call_trampolines: finished_function_call_trampolines,
@@ -1082,6 +1114,11 @@ impl VMInstance {
         };
         let instance = handle.instance();
 
+        ptr::copy(
+            vmctx_tags.values().as_slice().as_ptr(),
+            instance.shared_tags_ptr(),
+            vmctx_tags.len(),
+        );
         ptr::copy(
             vmshared_signatures.values().as_slice().as_ptr(),
             instance.signature_ids_ptr(),
@@ -1253,6 +1290,11 @@ impl VMInstance {
                 };
                 VMExtern::Global(handle)
             }
+
+            ExportIndex::Tag(index) => {
+                let handle = instance.tags[index];
+                VMExtern::Tag(handle)
+            }
         }
     }
 
@@ -1399,14 +1441,25 @@ fn initialize_tables(instance: &mut Instance) -> Result<(), Trap> {
             return Err(Trap::lib(TrapCode::TableAccessOutOfBounds));
         }
 
-        for (i, func_idx) in init.elements.iter().enumerate() {
-            let anyfunc = instance.func_ref(*func_idx);
-            table
-                .set(
-                    u32::try_from(start + i).unwrap(),
-                    TableElement::FuncRef(anyfunc),
-                )
-                .unwrap();
+        if let wasmer_types::Type::FuncRef = table.ty().ty {
+            for (i, func_idx) in init.elements.iter().enumerate() {
+                let anyfunc = instance.func_ref(*func_idx);
+                table
+                    .set(
+                        u32::try_from(start + i).unwrap(),
+                        TableElement::FuncRef(anyfunc),
+                    )
+                    .unwrap();
+            }
+        } else {
+            for i in 0..init.elements.len() {
+                table
+                    .set(
+                        u32::try_from(start + i).unwrap(),
+                        TableElement::ExternRef(None),
+                    )
+                    .unwrap();
+            }
         }
     }
 
diff --git a/lib/vm/src/lib.rs b/lib/vm/src/lib.rs
index 726e304b8b..a8306e393e 100644
--- a/lib/vm/src/lib.rs
+++ b/lib/vm/src/lib.rs
@@ -1,9 +1,8 @@
 //! Runtime library support for Wasmer.
 
 #![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)]
-#![deny(trivial_numeric_casts, unused_extern_crates)]
 #![warn(unused_import_braces)]
-#![allow(clippy::new_without_default, clippy::vtable_address_comparisons)]
+#![allow(clippy::new_without_default, ambiguous_wide_pointer_comparisons)]
 #![warn(
     clippy::float_arithmetic,
     clippy::mut_mut,
@@ -15,6 +14,7 @@
 )]
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
 
+mod exception_ref;
 mod export;
 mod extern_ref;
 mod function_env;
@@ -35,6 +35,7 @@ pub mod libcalls;
 
 use std::ptr::NonNull;
 
+pub use crate::exception_ref::{VMExceptionObj, VMExceptionRef};
 pub use crate::export::*;
 pub use crate::extern_ref::{VMExternObj, VMExternRef};
 pub use crate::function_env::VMFunctionEnvironment;
@@ -56,8 +57,10 @@ pub use crate::trap::*;
 pub use crate::vmcontext::{
     VMCallerCheckedAnyfunc, VMContext, VMDynamicFunctionContext, VMFunctionContext,
     VMFunctionImport, VMFunctionKind, VMGlobalDefinition, VMGlobalImport, VMMemoryDefinition,
-    VMMemoryImport, VMSharedSignatureIndex, VMTableDefinition, VMTableImport, VMTrampoline,
+    VMMemoryImport, VMSharedSignatureIndex, VMSharedTagIndex, VMTableDefinition, VMTableImport,
+    VMTrampoline,
 };
+pub use store::StoreObject;
 pub use wasmer_types::LibCall;
 pub use wasmer_types::MemoryError;
 pub use wasmer_types::MemoryStyle;
@@ -90,6 +93,7 @@ pub struct VMFunctionBody(u8);
 
 /// A safe wrapper around `VMFunctionBody`.
 #[derive(Clone, Copy, Debug)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[repr(transparent)]
 pub struct FunctionBodyPtr(pub *const VMFunctionBody);
 
diff --git a/lib/vm/src/libcalls.rs b/lib/vm/src/libcalls.rs
index 04a2a9a1b7..087de16fc1 100644
--- a/lib/vm/src/libcalls.rs
+++ b/lib/vm/src/libcalls.rs
@@ -37,6 +37,12 @@
 
 #![allow(missing_docs)] // For some reason lint fails saying that `LibCall` is not documented, when it actually is
 
+use std::panic;
+mod eh;
+use eh::UwExceptionWrapper;
+pub(crate) use eh::WasmerException;
+pub use eh::{wasmer_eh_personality, wasmer_eh_personality2};
+
 use crate::probestack::PROBESTACK;
 use crate::table::{RawTableElement, TableElement};
 use crate::trap::{raise_lib_trap, Trap, TrapCode};
@@ -156,7 +162,7 @@ pub unsafe extern "C" fn wasmer_vm_memory32_grow(
         instance
             .memory_grow(memory_index, delta)
             .map(|pages| pages.0)
-            .unwrap_or(u32::max_value())
+            .unwrap_or(u32::MAX)
     })
 }
 
@@ -178,7 +184,7 @@ pub unsafe extern "C" fn wasmer_vm_imported_memory32_grow(
         instance
             .imported_memory_grow(memory_index, delta)
             .map(|pages| pages.0)
-            .unwrap_or(u32::max_value())
+            .unwrap_or(u32::MAX)
     })
 }
 
@@ -454,7 +460,7 @@ pub unsafe extern "C" fn wasmer_vm_table_grow(
 
         instance
             .table_grow(table_index, delta, init_value)
-            .unwrap_or(u32::max_value())
+            .unwrap_or(u32::MAX)
     })
 }
 
@@ -481,7 +487,7 @@ pub unsafe extern "C" fn wasmer_vm_imported_table_grow(
 
         instance
             .imported_table_grow(table_index, delta, init_value)
-            .unwrap_or(u32::max_value())
+            .unwrap_or(u32::MAX)
     })
 }
 
@@ -658,6 +664,90 @@ pub unsafe extern "C" fn wasmer_vm_raise_trap(trap_code: TrapCode) -> ! {
     raise_lib_trap(trap)
 }
 
+/// Implementation for throwing an exception.
+///
+/// # Safety
+///
+/// Calls libunwind to perform unwinding magic.
+#[no_mangle]
+pub unsafe extern "C-unwind" fn wasmer_vm_throw(
+    tag: u32,
+    vmctx: *mut VMContext,
+    data_ptr: usize,
+    data_size: u64,
+) -> ! {
+    eh::throw(tag, vmctx, data_ptr, data_size)
+}
+
+/// Implementation for throwing an exception.
+///
+/// # Safety
+///
+/// Calls libunwind to perform unwinding magic.
+#[no_mangle]
+pub unsafe extern "C-unwind" fn wasmer_vm_rethrow(exc: *mut UwExceptionWrapper) -> ! {
+    eh::rethrow(exc)
+}
+
+/// (debug) Print an usize.
+#[no_mangle]
+pub extern "C-unwind" fn wasmer_vm_dbg_usize(value: usize) {
+    #[allow(clippy::print_stdout)]
+    {
+        println!("wasmer_vm_dbg_usize: {value}");
+    }
+}
+
+/// (debug) Print a string.
+#[no_mangle]
+pub extern "C-unwind" fn wasmer_vm_dbg_str(ptr: usize, len: u32) {
+    #[allow(clippy::print_stdout)]
+    unsafe {
+        let str = std::str::from_utf8(std::slice::from_raw_parts(ptr as _, len as _))
+            .unwrap_or("wasmer_vm_dbg_str failed");
+        eprintln!("{str}");
+    }
+}
+
+/// Implementation for allocating an exception.
+#[no_mangle]
+pub extern "C-unwind" fn wasmer_vm_alloc_exception(size: usize) -> u64 {
+    Vec::<u8>::with_capacity(size).leak().as_ptr() as usize as u64
+}
+
+/// Implementation for deleting the data of an exception.
+///
+/// # Safety
+///
+/// `exception` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C-unwind" fn wasmer_vm_delete_exception(exception: *mut WasmerException) {
+    if !exception.is_null() {
+        let size = (*exception).data_size as usize;
+        let data = Vec::<u8>::from_raw_parts((*exception).data_ptr as *mut u8, size, size);
+        std::mem::drop(data);
+    }
+}
+
+/// Implementation for reading a [`WasmerException`] from a [`UwExceptionWrapper`].
+/// # Safety
+///
+/// `exception` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C-unwind" fn wasmer_vm_read_exception(
+    exception: *const UwExceptionWrapper,
+) -> *const WasmerException {
+    if !exception.is_null() {
+        if let Some(w) = (*exception).cause.downcast_ref() {
+            w as *const WasmerException
+        } else {
+            panic!()
+        }
+    } else {
+        std::ptr::null()
+    }
+}
+
 /// Probestack check
 ///
 /// # Safety
@@ -665,7 +755,7 @@ pub unsafe extern "C" fn wasmer_vm_raise_trap(trap_code: TrapCode) -> ! {
 /// This function does not follow the standard function ABI, and is called as
 /// part of the function prologue.
 #[no_mangle]
-pub static wasmer_vm_probestack: unsafe extern "C" fn() = PROBESTACK;
+pub static WASMER_VM_PROBESTACK: unsafe extern "C" fn() = PROBESTACK;
 
 /// Implementation of memory.wait32 for locally-defined 32-bit memories.
 ///
@@ -847,7 +937,7 @@ pub fn function_pointer(libcall: LibCall) -> usize {
         LibCall::ImportedMemory32Fill => wasmer_vm_imported_memory32_fill as usize,
         LibCall::Memory32Init => wasmer_vm_memory32_init as usize,
         LibCall::DataDrop => wasmer_vm_data_drop as usize,
-        LibCall::Probestack => wasmer_vm_probestack as usize,
+        LibCall::Probestack => WASMER_VM_PROBESTACK as usize,
         LibCall::RaiseTrap => wasmer_vm_raise_trap as usize,
         LibCall::Memory32AtomicWait32 => wasmer_vm_memory32_atomic_wait32 as usize,
         LibCall::ImportedMemory32AtomicWait32 => wasmer_vm_imported_memory32_atomic_wait32 as usize,
@@ -855,5 +945,14 @@ pub fn function_pointer(libcall: LibCall) -> usize {
         LibCall::ImportedMemory32AtomicWait64 => wasmer_vm_imported_memory32_atomic_wait64 as usize,
         LibCall::Memory32AtomicNotify => wasmer_vm_memory32_atomic_notify as usize,
         LibCall::ImportedMemory32AtomicNotify => wasmer_vm_imported_memory32_atomic_notify as usize,
+        LibCall::Throw => wasmer_vm_throw as usize,
+        LibCall::Rethrow => wasmer_vm_rethrow as usize,
+        LibCall::EHPersonality => wasmer_eh_personality as usize,
+        LibCall::EHPersonality2 => wasmer_eh_personality2 as usize,
+        LibCall::AllocException => wasmer_vm_alloc_exception as usize,
+        LibCall::DeleteException => wasmer_vm_delete_exception as usize,
+        LibCall::ReadException => wasmer_vm_read_exception as usize,
+        LibCall::DebugUsize => wasmer_vm_dbg_usize as usize,
+        LibCall::DebugStr => wasmer_vm_dbg_str as usize,
     }
 }
diff --git a/lib/vm/src/libcalls/eh/dwarf/eh.rs b/lib/vm/src/libcalls/eh/dwarf/eh.rs
new file mode 100644
index 0000000000..8ed7bd2086
--- /dev/null
+++ b/lib/vm/src/libcalls/eh/dwarf/eh.rs
@@ -0,0 +1,436 @@
+//! Parsing of GCC-style Language-Specific Data Area (LSDA)
+//! For details se*const ():
+//!  * <https://refspecs.linuxfoundation.org/LSB_3.0.0/LSB-PDA/LSB-PDA/ehframechpt.html>
+//!  * <https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/dwarfext.html>
+//!  * <https://itanium-cxx-abi.github.io/cxx-abi/exceptions.pdf>
+//!  * <https://www.airs.com/blog/archives/460>
+//!  * <https://www.airs.com/blog/archives/464>
+//!
+//! A reference implementation may be found in the GCC source tree
+//! (`<root>/libgcc/unwind-c.c` as of this writing).
+
+#![allow(non_upper_case_globals)]
+#![allow(clippy::transmutes_expressible_as_ptr_casts)]
+#![allow(clippy::comparison_chain)]
+#![allow(unused)]
+
+use core::{mem, ptr};
+
+use super::DwarfReader;
+
+pub const DW_EH_PE_omit: u8 = 0xFF;
+pub const DW_EH_PE_absptr: u8 = 0x00;
+
+pub const DW_EH_PE_uleb128: u8 = 0x01;
+pub const DW_EH_PE_udata2: u8 = 0x02;
+pub const DW_EH_PE_udata4: u8 = 0x03;
+pub const DW_EH_PE_udata8: u8 = 0x04;
+pub const DW_EH_PE_sleb128: u8 = 0x09;
+pub const DW_EH_PE_sdata2: u8 = 0x0A;
+pub const DW_EH_PE_sdata4: u8 = 0x0B;
+pub const DW_EH_PE_sdata8: u8 = 0x0C;
+
+pub const DW_EH_PE_pcrel: u8 = 0x10;
+pub const DW_EH_PE_textrel: u8 = 0x20;
+pub const DW_EH_PE_datarel: u8 = 0x30;
+pub const DW_EH_PE_funcrel: u8 = 0x40;
+pub const DW_EH_PE_aligned: u8 = 0x50;
+
+pub const DW_EH_PE_indirect: u8 = 0x80;
+
+#[derive(Copy, Clone)]
+pub struct EHContext<'a> {
+    pub ip: *const u8,                             // Current instruction pointer
+    pub func_start: *const u8,                     // Pointer to the current function
+    pub get_text_start: &'a dyn Fn() -> *const u8, // Get pointer to the code section
+    pub get_data_start: &'a dyn Fn() -> *const u8, // Get pointer to the data section
+}
+
+/// Landing pad.
+type LPad = *const u8;
+
+#[derive(Debug, Clone)]
+pub enum EHAction {
+    None,
+    CatchAll { lpad: LPad },
+    CatchSpecific { lpad: LPad, tags: Vec<u32> },
+    CatchSpecificOrAll { lpad: LPad, tags: Vec<u32> },
+    Terminate,
+}
+
+/// 32-bit ARM Darwin platforms uses SjLj exceptions.
+///
+/// The exception is watchOS armv7k (specifically that subarchitecture), which
+/// instead uses DWARF Call Frame Information (CFI) unwinding.
+///
+/// <https://github.com/llvm/llvm-project/blob/llvmorg-18.1.4/clang/lib/Driver/ToolChains/Darwin.cpp#L3107-L3119>
+pub const USING_SJLJ_EXCEPTIONS: bool = cfg!(all(
+    target_vendor = "apple",
+    not(target_os = "watchos"),
+    target_arch = "arm"
+));
+
+/* change to true to enable logging from the personality function */
+macro_rules! log {
+    ($e: expr) => {
+        if false {
+            eprintln!($e)
+        }
+
+    };
+
+    ($($e: expr),*) => {
+        if false {
+            eprintln!($($e),*)
+        }
+
+    };
+}
+
+pub unsafe fn find_eh_action(lsda: *const u8, context: &EHContext<'_>) -> Result<EHAction, ()> {
+    if lsda.is_null() {
+        return Ok(EHAction::None);
+    }
+
+    log!("(pers) Analysing LSDA at {lsda:?}");
+
+    let func_start = context.func_start;
+    let mut reader = DwarfReader::new(lsda);
+
+    let lpad_base = unsafe {
+        let lp_start_encoding = reader.read::<u8>();
+
+        log!("(pers) Read LP start encoding {lp_start_encoding:?}");
+        // base address for landing pad offsets
+        if lp_start_encoding != DW_EH_PE_omit {
+            read_encoded_pointer(&mut reader, context, lp_start_encoding)?
+        } else {
+            log!("(pers) (is omit)");
+            func_start
+        }
+    };
+    log!("(pers) read landingpad base: {lpad_base:?}");
+
+    let ttype_encoding = unsafe { reader.read::<u8>() };
+    log!("(pers) read ttype encoding: {ttype_encoding:?}");
+
+    // If no value for type_table_encoding was given it means that there's no
+    // type_table, therefore we can't possibly use this lpad.
+    if ttype_encoding == DW_EH_PE_omit {
+        log!("(pers) ttype is omit, returning None");
+        return Ok(EHAction::None);
+    }
+
+    let class_info = unsafe {
+        let offset = reader.read_uleb128();
+        log!("(pers) read class_info offset {offset:?}");
+        reader.ptr.wrapping_add(offset as _)
+    };
+    log!("(pers) read class_info sits at offset {class_info:?}");
+
+    let call_site_encoding = unsafe { reader.read::<u8>() };
+    log!("(pers) read call_site_encoding is {call_site_encoding:?}");
+
+    let action_table = unsafe {
+        let call_site_table_length = reader.read_uleb128();
+        log!("(pers) read call_site has length {call_site_table_length:?}");
+        reader.ptr.wrapping_add(call_site_table_length as usize)
+    };
+
+    log!("(pers) action table sits at offset {action_table:?}");
+    let ip = context.ip;
+
+    if !USING_SJLJ_EXCEPTIONS {
+        // read the callsite table
+        while reader.ptr < action_table {
+            unsafe {
+                // these are offsets rather than pointers;
+                let cs_start = read_encoded_offset(&mut reader, call_site_encoding)?;
+                let cs_len = read_encoded_offset(&mut reader, call_site_encoding)?;
+                let cs_lpad = read_encoded_offset(&mut reader, call_site_encoding)?;
+                let cs_action_entry = reader.read_uleb128();
+
+                log!("(pers) read cs_start is {cs_start:?}");
+                log!("(pers) read cs_len is {cs_len:?}");
+                log!("(pers) read cs_lpad is {cs_lpad:?}");
+                log!("(pers) read cs_ae is {cs_action_entry:?}");
+                // Callsite table is sorted by cs_start, so if we've passed the ip, we
+                // may stop searching.
+                if ip < func_start.wrapping_add(cs_start) {
+                    break;
+                }
+
+                if ip < func_start.wrapping_add(cs_start + cs_len) {
+                    log!(
+                        "(pers) found a matching call site: {func_start:?} <= {ip:?} <= {:?}",
+                        func_start.wrapping_add(cs_start + cs_len)
+                    );
+                    if cs_lpad == 0 {
+                        return Ok(EHAction::None);
+                    } else {
+                        let lpad = lpad_base.wrapping_add(cs_lpad);
+                        let mut catches = vec![];
+
+                        log!("(pers) lpad sits at {lpad:?}");
+
+                        if cs_action_entry == 0 {
+                            // We don't generate cleanup clauses, so this can't happen
+                            return Ok(EHAction::Terminate);
+                        }
+
+                        log!("(pers) read cs_action_entry: {cs_action_entry}");
+                        log!("(pers) action_table: {action_table:?}");
+
+                        // Convert 1-based byte offset into
+                        let mut action: *const u8 =
+                            action_table.wrapping_add((cs_action_entry - 1) as usize);
+
+                        log!("(pers) first action at: {action:?}");
+
+                        loop {
+                            let mut reader = DwarfReader::new(action);
+                            let ttype_index = reader.read_sleb128();
+                            log!(
+                                "(pers) ttype_index for action #{cs_action_entry}: {ttype_index:?}"
+                            );
+
+                            if ttype_index > 0 {
+                                if class_info.is_null() {
+                                    panic!();
+                                }
+
+                                let tag_ptr = {
+                                    let new_ttype_index = match ttype_encoding & 0x0f {
+                                        DW_EH_PE_absptr => {
+                                            ttype_index * (size_of::<*const u8>() as i64)
+                                        }
+                                        DW_EH_PE_sdata2 | DW_EH_PE_udata2 => ttype_index * 2,
+                                        DW_EH_PE_sdata4 | DW_EH_PE_udata4 => ttype_index * 4,
+                                        DW_EH_PE_sdata8 | DW_EH_PE_udata8 => ttype_index * 8,
+                                        _ => panic!(),
+                                    };
+
+                                    log!("(pers) new_ttype_index for action #{cs_action_entry}: {new_ttype_index:?}");
+
+                                    let i = class_info.wrapping_sub(new_ttype_index as usize);
+                                    log!("(pers) reading ttype info from {i:?}");
+                                    read_encoded_pointer(
+                                        &mut DwarfReader::new(i),
+                                        context,
+                                        ttype_encoding,
+                                    )
+                                };
+                                let tag_ptr = tag_ptr.unwrap();
+
+                                if tag_ptr.is_null() {
+                                    if catches.is_empty() {
+                                        // No specifics so far, so we definitely have a catch-all we should use
+                                        return Ok(EHAction::CatchAll { lpad });
+                                    } else {
+                                        // We do have catch clauses that *may* need to be used, so we must
+                                        // defer to phase 2 anyway, but this catch-all will be used if
+                                        // none of those clauses match, so we can return early.
+                                        return Ok(EHAction::CatchSpecificOrAll {
+                                            lpad,
+                                            tags: catches,
+                                        });
+                                    }
+                                }
+
+                                let tag = std::mem::transmute::<*const u8, *const u32>(tag_ptr)
+                                    .read_unaligned();
+
+                                log!("(pers) read tag {tag:?}");
+
+                                // Since we don't know what this tag corresponds to, we must defer
+                                // the decision to the second phase.
+                                catches.push(tag);
+                            } else if ttype_index == 0 {
+                                // We don't create cleanup clauses, so this can't happen
+                                return Ok(EHAction::Terminate);
+                            }
+
+                            let action_offset = reader.clone().read_sleb128();
+                            if action_offset == 0 {
+                                return Ok(if catches.is_empty() {
+                                    EHAction::None
+                                } else {
+                                    EHAction::CatchSpecific {
+                                        lpad,
+                                        tags: catches,
+                                    }
+                                });
+                            }
+
+                            action = reader.ptr.wrapping_add(action_offset as usize);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Ip is not present in the table. This indicates a nounwind call.
+        Ok(EHAction::Terminate)
+    } else {
+        todo!()
+    }
+}
+
+#[inline]
+fn get_encoding_size(encoding: u8) -> usize {
+    if encoding == DW_EH_PE_omit {
+        return 0;
+    }
+
+    match encoding & 0x0f {
+        DW_EH_PE_absptr => size_of::<usize>(),
+        DW_EH_PE_udata2 | DW_EH_PE_sdata2 => size_of::<u16>(),
+        DW_EH_PE_udata4 | DW_EH_PE_sdata4 => size_of::<u32>(),
+        DW_EH_PE_udata8 | DW_EH_PE_sdata8 => size_of::<u64>(),
+        _ => panic!(),
+    }
+}
+
+#[inline]
+fn round_up(unrounded: usize, align: usize) -> Result<usize, ()> {
+    if align.is_power_of_two() {
+        Ok((unrounded + align - 1) & !(align - 1))
+    } else {
+        Err(())
+    }
+}
+
+/// Reads an offset (`usize`) from `reader` whose encoding is described by `encoding`.
+///
+/// `encoding` must be a [DWARF Exception Header Encoding as described by the LSB spec][LSB-dwarf-ext].
+/// In addition the upper ("application") part must be zero.
+///
+/// # Errors
+/// Returns `Err` if `encoding`
+/// * is not a valid DWARF Exception Header Encoding,
+/// * is `DW_EH_PE_omit`, or
+/// * has a non-zero application part.
+///
+/// [LSB-dwarf-ext]: https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/dwarfext.html
+unsafe fn read_encoded_offset(reader: &mut DwarfReader, encoding: u8) -> Result<usize, ()> {
+    if encoding == DW_EH_PE_omit || encoding & 0xF0 != 0 {
+        return Err(());
+    }
+    let result = unsafe {
+        match encoding & 0x0F {
+            // despite the name, LLVM also uses absptr for offsets instead of pointers
+            DW_EH_PE_absptr => reader.read::<usize>(),
+            DW_EH_PE_uleb128 => reader.read_uleb128() as usize,
+            DW_EH_PE_udata2 => reader.read::<u16>() as usize,
+            DW_EH_PE_udata4 => reader.read::<u32>() as usize,
+            DW_EH_PE_udata8 => reader.read::<u64>() as usize,
+            DW_EH_PE_sleb128 => reader.read_sleb128() as usize,
+            DW_EH_PE_sdata2 => reader.read::<i16>() as usize,
+            DW_EH_PE_sdata4 => reader.read::<i32>() as usize,
+            DW_EH_PE_sdata8 => reader.read::<i64>() as usize,
+            _ => return Err(()),
+        }
+    };
+    Ok(result)
+}
+
+/// Reads a pointer from `reader` whose encoding is described by `encoding`.
+///
+/// `encoding` must be a [DWARF Exception Header Encoding as described by the LSB spec][LSB-dwarf-ext].
+///
+/// # Errors
+/// Returns `Err` if `encoding`
+/// * is not a valid DWARF Exception Header Encoding,
+/// * is `DW_EH_PE_omit`, or
+/// * combines `DW_EH_PE_absptr` or `DW_EH_PE_aligned` application part with an integer encoding
+///   (not `DW_EH_PE_absptr`) in the value format part.
+///
+/// [LSB-dwarf-ext]: https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/dwarfext.html
+unsafe fn read_encoded_pointer(
+    reader: &mut DwarfReader,
+    context: &EHContext<'_>,
+    encoding: u8,
+) -> Result<*const u8, ()> {
+    if encoding == DW_EH_PE_omit {
+        return Err(());
+    }
+
+    log!("(pers) About to read encoded pointer at {:?}", reader.ptr);
+
+    let base_ptr = match encoding & 0x70 {
+        DW_EH_PE_absptr => {
+            log!("(pers) encoding is: DW_EH_PE_absptr ({DW_EH_PE_absptr})");
+            core::ptr::null()
+        }
+        // relative to address of the encoded value, despite the name
+        DW_EH_PE_pcrel => {
+            log!("(pers) encoding is: DW_EH_PE_pcrel ({DW_EH_PE_pcrel})");
+            reader.ptr
+        }
+        DW_EH_PE_funcrel => {
+            log!("(pers) encoding is: DW_EH_PE_funcrel ({DW_EH_PE_funcrel})");
+            if context.func_start.is_null() {
+                return Err(());
+            }
+            context.func_start
+        }
+        DW_EH_PE_textrel => {
+            log!("(pers) encoding is: DW_EH_PE_textrel ({DW_EH_PE_textrel})");
+            (*context.get_text_start)()
+        }
+        DW_EH_PE_datarel => {
+            log!("(pers) encoding is: DW_EH_PE_textrel ({DW_EH_PE_datarel})");
+
+            (*context.get_data_start)()
+        }
+        // aligned means the value is aligned to the size of a pointer
+        DW_EH_PE_aligned => {
+            log!("(pers) encoding is: DW_EH_PE_textrel ({DW_EH_PE_aligned})");
+            reader.ptr = {
+                let this = reader.ptr;
+                let addr = round_up(
+                    {
+                        let this = reader.ptr;
+                        unsafe { mem::transmute::<*const (), usize>(this.cast::<()>()) }
+                    },
+                    mem::size_of::<*const u8>(),
+                )?;
+                // In the mean-time, this operation is defined to be "as if" it was
+                // a wrapping_offset, so we can emulate it as such. This should properly
+                // restore pointer provenance even under today's compiler.
+                let self_addr = unsafe { mem::transmute::<*const (), isize>(this.cast::<()>()) };
+                let dest_addr = addr as isize;
+                let offset = dest_addr.wrapping_sub(self_addr);
+
+                // This is the canonical desugaring of this operation
+                this.wrapping_byte_offset(offset)
+            };
+            core::ptr::null()
+        }
+        _ => return Err(()),
+    };
+
+    let mut ptr = if base_ptr.is_null() {
+        // any value encoding other than absptr would be nonsensical here;
+        // there would be no source of pointer provenance
+        if encoding & 0x0F != DW_EH_PE_absptr {
+            return Err(());
+        }
+        unsafe { reader.read::<*const u8>() }
+    } else {
+        log!("(pers) since base_ptr is not null, we must an offset");
+        let offset = unsafe { read_encoded_offset(reader, encoding & 0x0F)? };
+        log!("(pers) read offset is {offset:x?}");
+        base_ptr.wrapping_add(offset)
+    };
+
+    log!("(pers) about to read from {ptr:?}");
+
+    if encoding & DW_EH_PE_indirect != 0 {
+        ptr = unsafe { ptr.cast::<*const u8>().read_unaligned() };
+    }
+
+    log!("(pers) returning ptr value {ptr:?}");
+
+    Ok(ptr)
+}
diff --git a/lib/vm/src/libcalls/eh/dwarf/mod.rs b/lib/vm/src/libcalls/eh/dwarf/mod.rs
new file mode 100644
index 0000000000..e2ef3a8b5d
--- /dev/null
+++ b/lib/vm/src/libcalls/eh/dwarf/mod.rs
@@ -0,0 +1,69 @@
+//! Utilities for parsing DWARF-encoded data streams.
+//! See <http://www.dwarfstd.org>,
+//! DWARF-4 standard, Section 7 - "Data Representation"
+
+// This module is used only by x86_64-pc-windows-gnu for now, but we
+// are compiling it everywhere to avoid regressions.
+#![allow(unused)]
+#![forbid(unsafe_op_in_unsafe_fn)]
+
+pub mod eh;
+
+use core::mem;
+
+#[derive(Clone)]
+pub struct DwarfReader {
+    pub ptr: *const u8,
+}
+
+impl DwarfReader {
+    pub fn new(ptr: *const u8) -> Self {
+        Self { ptr }
+    }
+
+    /// Read a type T and then bump the pointer by that amount.
+    ///
+    /// DWARF streams are "packed", so all types must be read at align 1.
+    pub unsafe fn read<T: Copy>(&mut self) -> T {
+        unsafe {
+            let result = self.ptr.cast::<T>().read_unaligned();
+            self.ptr = self.ptr.byte_add(mem::size_of::<T>());
+            result
+        }
+    }
+
+    /// ULEB128 and SLEB128 encodings are defined in Section 7.6 - "Variable Length Data".
+    pub unsafe fn read_uleb128(&mut self) -> u64 {
+        let mut shift: usize = 0;
+        let mut result: u64 = 0;
+        let mut byte: u8;
+        loop {
+            byte = unsafe { self.read::<u8>() };
+            result |= ((byte & 0x7F) as u64) << shift;
+            shift += 7;
+            if byte & 0x80 == 0 {
+                break;
+            }
+        }
+        result
+    }
+
+    pub unsafe fn read_sleb128(&mut self) -> i64 {
+        let mut shift: u32 = 0;
+        let mut result: u64 = 0;
+        let mut byte: u8;
+        loop {
+            byte = unsafe { self.read::<u8>() };
+            result |= ((byte & 0x7F) as u64) << shift;
+            shift += 7;
+            if byte & 0x80 == 0 {
+                break;
+            }
+        }
+        // sign-extend
+        if shift < u64::BITS && (byte & 0x40) != 0 {
+            result |= (!0) << shift;
+        }
+        result as i64
+    }
+}
diff --git a/lib/vm/src/libcalls/eh/gcc.rs b/lib/vm/src/libcalls/eh/gcc.rs
new file mode 100644
index 0000000000..c79119344e
--- /dev/null
+++ b/lib/vm/src/libcalls/eh/gcc.rs
@@ -0,0 +1,298 @@
+//! Implementation of personality function and unwinding support for Wasmer.
+//!
+//! On a native platform, when an exception is thrown, the type info of the
+//! exception is known, and can be matched against the LSDA table within the
+//! personality function (e.g. __gxx_personality_v0 for Itanium ABI).
+//!
+//! However, in WASM, the exception "type" can change between compilation
+//! and instantiation because tags can be imported from other modules. Also,
+//! a single module can be instantiated many times, but all instances share
+//! the same code, differing only in their VMContext data. This means that,
+//! to be able to match the thrown exception against the expected tag in
+//! catch clauses, we need to go through the VMContext of the specific instance
+//! to which the stack frame belongs; nothing else can tell us exactly which
+//! instance we're currently looking at, including the IP which will be the
+//! same for all instances of the same module.
+//!
+//! To achieve this, we use a two-stage personality function. The first stage
+//! is the normal personality function which is called by libunwind; this
+//! function always catches the exception as long as it's a Wasmer exception,
+//! without looking at the specific tags. Afterwards, control is transferred
+//! to the module's landing pad, which can load its VMContext and pass it to
+//! the second stage of the personality function. Afterwards, the second stage
+//! can take the "local tag number" (the tag index as seen from the WASM
+//! module's point of view) from the LSDA and translate it to the unique tag
+//! within the Store, and match that against the thrown exception's tag.
+//!
+//! The throw function also uses the VMContext of its own instance to get the
+//! unique tag from the Store, and uses that as the final exception tag.
+//!
+//! It's important to note that we can't count on libunwind behaving properly
+//! if we make calls from the second stage of the personality function; this is
+//! why the first stage has to extract all the data necessary for the second
+//! stage and place it in the exception object. The second stage will clear
+//! out the data before returning, so further stack frames will not get stale
+//! data by mistake.
+
+use libunwind as uw;
+use wasmer_types::TagIndex;
+
+use crate::VMContext;
+
+use super::dwarf::eh::{self, EHAction, EHContext};
+
+// In case where multiple copies of std exist in a single process,
+// we use address of this static variable to distinguish an exception raised by
+// this copy and some other copy (which needs to be treated as foreign exception).
+static CANARY: u8 = 0;
+const WASMER_EXCEPTION_CLASS: uw::_Unwind_Exception_Class = u64::from_ne_bytes(*b"WMERWASM");
+
+const CATCH_ALL_TAG_VALUE: i32 = i32::MAX;
+// This constant is not reflected in the generated code, but the switch block
+// has a default action of rethrowing the exception, which this value should
+// trigger.
+const NO_MATCH_FOUND_TAG_VALUE: i32 = i32::MAX - 1;
+
+#[repr(C)]
+pub struct UwExceptionWrapper {
+    pub _uwe: uw::_Unwind_Exception,
+    pub canary: *const u8,
+    pub cause: Box<dyn std::any::Any + Send>,
+
+    // First stage -> second stage communication
+    pub current_frame_info: Option<Box<CurrentFrameInfo>>,
+}
+
+#[repr(C)]
+pub struct CurrentFrameInfo {
+    pub exception_tag: u32,
+    pub catch_tags: Vec<u32>,
+    pub has_catch_all: bool,
+}
+
+impl UwExceptionWrapper {
+    pub fn new(tag: u32, data_ptr: usize, data_size: u64) -> Self {
+        Self {
+            _uwe: uw::_Unwind_Exception {
+                exception_class: WASMER_EXCEPTION_CLASS,
+                exception_cleanup: None,
+                private_1: core::ptr::null::<u8>() as usize as _,
+                private_2: 0,
+            },
+            canary: &CANARY,
+            cause: Box::new(WasmerException {
+                tag,
+                data_ptr,
+                data_size,
+            }),
+            current_frame_info: None,
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Debug, thiserror::Error, Clone)]
+#[error("Uncaught exception in wasm code!")]
+pub struct WasmerException {
+    // This is the store-unique tag index.
+    pub tag: u32,
+    pub data_ptr: usize,
+    pub data_size: u64,
+}
+
+impl WasmerException {
+    pub fn new(tag: u32, data_ptr: usize, data_size: u64) -> Self {
+        Self {
+            tag,
+            data_ptr,
+            data_size,
+        }
+    }
+}
+
+#[cfg(target_arch = "x86_64")]
+const UNWIND_DATA_REG: (i32, i32) = (0, 1); // RAX, RDX
+
+#[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
+const UNWIND_DATA_REG: (i32, i32) = (0, 1); // R0, R1 / X0, X1
+
+#[cfg(any(target_arch = "riscv64", target_arch = "riscv32"))]
+const UNWIND_DATA_REG: (i32, i32) = (10, 11); // x10, x11
+
+#[cfg(target_arch = "loongarch64")]
+const UNWIND_DATA_REG: (i32, i32) = (4, 5); // a0, a1
+
+#[no_mangle]
+/// The implementation of Wasmer's personality function.
+///
+/// # Safety
+///
+/// Performs libunwind unwinding magic.
+pub unsafe extern "C" fn wasmer_eh_personality(
+    version: std::ffi::c_int,
+    actions: uw::_Unwind_Action,
+    exception_class: uw::_Unwind_Exception_Class,
+    exception_object: *mut uw::_Unwind_Exception,
+    context: *mut uw::_Unwind_Context,
+) -> uw::_Unwind_Reason_Code {
+    unsafe {
+        if version != 1 {
+            return uw::_Unwind_Reason_Code__URC_FATAL_PHASE1_ERROR;
+        }
+
+        let uw_exc = std::mem::transmute::<*mut uw::_Unwind_Exception, *mut UwExceptionWrapper>(
+            exception_object,
+        );
+
+        if exception_class != WASMER_EXCEPTION_CLASS {
+            return uw::_Unwind_Reason_Code__URC_CONTINUE_UNWIND;
+        }
+
+        let wasmer_exc = (*uw_exc).cause.downcast_ref::<WasmerException>();
+        let wasmer_exc = match wasmer_exc {
+            Some(e) => e,
+            None => {
+                return uw::_Unwind_Reason_Code__URC_CONTINUE_UNWIND;
+            }
+        };
+
+        let eh_action = match find_eh_action(context) {
+            Ok(action) => action,
+            Err(_) => {
+                return uw::_Unwind_Reason_Code__URC_FATAL_PHASE1_ERROR;
+            }
+        };
+
+        if actions as i32 & uw::_Unwind_Action__UA_SEARCH_PHASE as i32 != 0 {
+            match eh_action {
+                EHAction::None => uw::_Unwind_Reason_Code__URC_CONTINUE_UNWIND,
+                EHAction::CatchAll { .. }
+                | EHAction::CatchSpecific { .. }
+                | EHAction::CatchSpecificOrAll { .. } => uw::_Unwind_Reason_Code__URC_HANDLER_FOUND,
+                EHAction::Terminate => uw::_Unwind_Reason_Code__URC_FATAL_PHASE1_ERROR,
+            }
+        } else {
+            // For the catch-specific vs catch-specific-or-all case below, checked before
+            // we move eh_action out in the match
+            let has_catch_all = matches!(eh_action, EHAction::CatchSpecificOrAll { .. });
+
+            match eh_action {
+                EHAction::None => uw::_Unwind_Reason_Code__URC_CONTINUE_UNWIND,
+                EHAction::CatchAll { lpad } => {
+                    uw::_Unwind_SetGR(context, UNWIND_DATA_REG.0, uw_exc as _);
+                    // Zero means immediate catch-all
+                    uw::_Unwind_SetGR(context, UNWIND_DATA_REG.1, 0);
+                    uw::_Unwind_SetIP(context, lpad as usize as _);
+                    uw::_Unwind_Reason_Code__URC_INSTALL_CONTEXT
+                }
+                EHAction::CatchSpecific { lpad, tags }
+                | EHAction::CatchSpecificOrAll { lpad, tags } => {
+                    (*uw_exc).current_frame_info = Some(Box::new(CurrentFrameInfo {
+                        exception_tag: wasmer_exc.tag,
+                        catch_tags: tags,
+                        has_catch_all,
+                    }));
+                    uw::_Unwind_SetGR(context, UNWIND_DATA_REG.0, uw_exc as _);
+                    // One means enter phase 2
+                    uw::_Unwind_SetGR(context, UNWIND_DATA_REG.1, 1);
+                    uw::_Unwind_SetIP(context, lpad as usize as _);
+                    uw::_Unwind_Reason_Code__URC_INSTALL_CONTEXT
+                }
+                EHAction::Terminate => uw::_Unwind_Reason_Code__URC_FATAL_PHASE2_ERROR,
+            }
+        }
+    }
+}
+
+#[no_mangle]
+/// The second stage of the  personality function. See module level documentation
+/// for an explanation of the exact procedure used during unwinding.
+///
+/// # Safety
+///
+/// Does pointer accesses, which must be valid.
+pub unsafe extern "C" fn wasmer_eh_personality2(
+    vmctx: *mut VMContext,
+    exception_object: *mut UwExceptionWrapper,
+) -> i32 {
+    unsafe {
+        let Some(current_frame_info) = (*exception_object).current_frame_info.take() else {
+            // This should never happen
+            unreachable!("wasmer_eh_personality2 called without current_frame_info");
+        };
+
+        let instance = (*vmctx).instance();
+        for tag in current_frame_info.catch_tags {
+            let unique_tag = instance.shared_tag_ptr(TagIndex::from_u32(tag)).index();
+            if unique_tag == current_frame_info.exception_tag {
+                return tag as i32;
+            }
+        }
+
+        if current_frame_info.has_catch_all {
+            CATCH_ALL_TAG_VALUE
+        } else {
+            NO_MATCH_FOUND_TAG_VALUE
+        }
+    }
+}
+
+unsafe fn find_eh_action(context: *mut uw::_Unwind_Context) -> Result<EHAction, ()> {
+    unsafe {
+        let lsda = uw::_Unwind_GetLanguageSpecificData(context) as *const u8;
+        let mut ip_before_instr: std::ffi::c_int = 0;
+        let ip = uw::_Unwind_GetIPInfo(context, &mut ip_before_instr);
+        let eh_context = EHContext {
+            // The return address points 1 byte past the call instruction,
+            // which could be in the next IP range in LSDA range table.
+            //
+            // `ip = -1` has special meaning, so use wrapping sub to allow for that
+            ip: if ip_before_instr != 0 {
+                ip as _
+            } else {
+                ip.wrapping_sub(1) as _
+            },
+            func_start: uw::_Unwind_GetRegionStart(context) as *const _,
+            get_text_start: &|| uw::_Unwind_GetTextRelBase(context) as *const _,
+            get_data_start: &|| uw::_Unwind_GetDataRelBase(context) as *const _,
+        };
+        eh::find_eh_action(lsda, &eh_context)
+    }
+}
+
+pub unsafe fn throw(tag: u32, vmctx: *mut VMContext, data_ptr: usize, data_size: u64) -> ! {
+    // Look up the unique tag from the VMContext.
+    let unique_tag = (*vmctx)
+        .instance()
+        .shared_tag_ptr(TagIndex::from_u32(tag))
+        .index();
+
+    let exception = Box::new(UwExceptionWrapper::new(unique_tag, data_ptr, data_size));
+    let exception_param = Box::into_raw(exception) as *mut libunwind::_Unwind_Exception;
+
+    match uw::_Unwind_RaiseException(exception_param) {
+        libunwind::_Unwind_Reason_Code__URC_END_OF_STACK => {
+            crate::raise_lib_trap(crate::Trap::lib(wasmer_types::TrapCode::UncaughtException))
+        }
+        _ => {
+            unreachable!()
+        }
+    }
+}
+
+pub unsafe fn rethrow(exc: *mut UwExceptionWrapper) -> ! {
+    if exc.is_null() {
+        panic!();
+    }
+
+    match uw::_Unwind_Resume_or_Rethrow(std::mem::transmute::<
+        *mut UwExceptionWrapper,
+        *mut libunwind::_Unwind_Exception,
+    >(exc))
+    {
+        libunwind::_Unwind_Reason_Code__URC_END_OF_STACK => {
+            crate::raise_lib_trap(crate::Trap::lib(wasmer_types::TrapCode::UncaughtException))
+        }
+        _ => unreachable!(),
+    }
+}
diff --git a/lib/vm/src/libcalls/eh/mod.rs b/lib/vm/src/libcalls/eh/mod.rs
new file mode 100644
index 0000000000..d8d8127345
--- /dev/null
+++ b/lib/vm/src/libcalls/eh/mod.rs
@@ -0,0 +1,74 @@
+// Part of the logic, here, is borrowed as-is from rust's stdlib.
+
+mod dwarf;
+
+cfg_if::cfg_if! {
+    if #[cfg(any(target_env = "msvc", target_family = "wasm"))] {
+        // We have yet to figure this out.
+        #[repr(C)]
+        pub struct UwExceptionWrapper {
+            pub _uwe: (),
+            pub cause: Box<dyn std::any::Any + Send>,
+        }
+
+        impl UwExceptionWrapper {
+            pub fn new(tag: u64, data_ptr: usize, data_size: u64) -> Self {
+                Self {
+                    _uwe: (),
+                    cause: Box::new(WasmerException {
+                        tag,
+                        data_ptr,
+                        data_size,
+                    }),
+                }
+            }
+        }
+
+        #[repr(C)]
+        #[derive(Debug, thiserror::Error, Clone)]
+        #[error("Uncaught exception in wasm code!")]
+        pub struct WasmerException {
+            pub tag: u64,
+            pub data_ptr: usize,
+            pub data_size: u64,
+        }
+
+        pub fn wasmer_eh_personality() {
+            panic!()
+        }
+
+        pub fn wasmer_eh_personality2() {
+            panic!()
+        }
+
+        pub unsafe fn throw(
+            _tag: u32,
+            _vmctx: *mut crate::VMContext,
+            _data_ptr: usize,
+            _data_size: u64,
+        ) -> ! {
+            panic!()
+        }
+
+        pub fn rethrow(_exc: *mut UwExceptionWrapper) -> ! {
+            panic!()
+        }
+
+
+    } else if #[cfg(any(
+        all(target_family = "windows", target_env = "gnu"),
+        target_family = "unix",
+    ))] {
+        // gcc-like eh-personality mechanisms.
+        mod gcc;
+        pub use gcc::*;
+    } else {
+        // Targets that don't support unwinding.
+        // - os=none ("bare metal" targets)
+        // - os=uefi
+        // - os=espidf
+        // - os=hermit
+        // - nvptx64-nvidia-cuda
+        // - arch=avr
+    }
+}
diff --git a/lib/vm/src/memory.rs b/lib/vm/src/memory.rs
index 1052b61ef0..878ac7c5fb 100644
--- a/lib/vm/src/memory.rs
+++ b/lib/vm/src/memory.rs
@@ -71,7 +71,7 @@ impl WasmMmap {
         // Wasm linear memories are never allowed to grow beyond what is
         // indexable. If the memory has no maximum, enforce the greatest
         // limit here.
-        if new_pages >= Pages::max_value() {
+        if new_pages > Pages::max_value() {
             // Linear memory size would exceed the index range.
             return Err(MemoryError::CouldNotGrow {
                 current: self.size,
diff --git a/lib/vm/src/mmap.rs b/lib/vm/src/mmap.rs
index e08f49dc1e..4791ea15e8 100644
--- a/lib/vm/src/mmap.rs
+++ b/lib/vm/src/mmap.rs
@@ -98,7 +98,7 @@ impl Mmap {
 
             let len = file.metadata().map_err(|e| e.to_string())?.len() as usize;
             if len < mapping_size {
-                std::fs::write(&backing_file_accessible, format!("{}", len).as_bytes()).ok();
+                std::fs::write(&backing_file_accessible, format!("{len}").as_bytes()).ok();
 
                 file.set_len(mapping_size as u64)
                     .map_err(|e| e.to_string())?;
diff --git a/lib/vm/src/probestack/compiler_builtins.rs b/lib/vm/src/probestack/compiler_builtins.rs
new file mode 100644
index 0000000000..a16c1069f5
--- /dev/null
+++ b/lib/vm/src/probestack/compiler_builtins.rs
@@ -0,0 +1,358 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! This module defines the `__rust_probestack` intrinsic which is used in the
+//! implementation of "stack probes" on certain platforms.
+//!
+//! The purpose of a stack probe is to provide a static guarantee that if a
+//! thread has a guard page then a stack overflow is guaranteed to hit that
+//! guard page. If a function did not have a stack probe then there's a risk of
+//! having a stack frame *larger* than the guard page, so a function call could
+//! skip over the guard page entirely and then later hit maybe the heap or
+//! another thread, possibly leading to security vulnerabilities such as [The
+//! Stack Clash], for example.
+//!
+//! [The Stack Clash]: https://blog.qualys.com/securitylabs/2017/06/19/the-stack-clash
+//!
+//! The `__rust_probestack` is called in the prologue of functions whose stack
+//! size is larger than the guard page, for example larger than 4096 bytes on
+//! x86. This function is then responsible for "touching" all pages relevant to
+//! the stack to ensure that that if any of them are the guard page we'll hit
+//! them guaranteed.
+//!
+//! The precise ABI for how this function operates is defined by LLVM. There's
+//! no real documentation as to what this is, so you'd basically need to read
+//! the LLVM source code for reference. Often though the test cases can be
+//! illuminating as to the ABI that's generated, or just looking at the output
+//! of `llc`.
+//!
+//! Note that `#[naked]` is typically used here for the stack probe because the
+//! ABI corresponds to no actual ABI.
+//!
+//! Finally it's worth noting that at the time of this writing LLVM only has
+//! support for stack probes on x86 and x86_64. There's no support for stack
+//! probes on any other architecture like ARM or PowerPC64. LLVM I'm sure would
+//! be more than welcome to accept such a change!
+
+// Windows and Cygwin already has builtins to do this.
+#![cfg(not(any(windows, target_os = "cygwin")))]
+// We only define stack probing for these architectures today.
+#![cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+
+// SAFETY: defined in this module.
+// FIXME(extern_custom): the ABI is not correct.
+unsafe extern "C" {
+    pub fn __rust_probestack();
+}
+
+// A wrapper for our implementation of __rust_probestack, which allows us to
+// keep the assembly inline while controlling all CFI directives in the assembly
+// emitted for the function.
+//
+// This is the ELF version.
+#[cfg(not(any(target_vendor = "apple", target_os = "uefi")))]
+macro_rules! define_rust_probestack {
+    ($body: expr) => {
+        concat!(
+            "
+            .pushsection .text.__rust_probestack
+            .globl __rust_probestack
+            .type  __rust_probestack, @function
+            .hidden __rust_probestack
+        __rust_probestack:
+            ",
+            $body,
+            "
+            .size __rust_probestack, . - __rust_probestack
+            .popsection
+            "
+        )
+    };
+}
+
+#[cfg(all(target_os = "uefi", target_arch = "x86_64"))]
+macro_rules! define_rust_probestack {
+    ($body: expr) => {
+        concat!(
+            "
+            .globl __rust_probestack
+        __rust_probestack:
+            ",
+            $body
+        )
+    };
+}
+
+// Same as above, but for Mach-O. Note that the triple underscore
+// is deliberate
+#[cfg(target_vendor = "apple")]
+macro_rules! define_rust_probestack {
+    ($body: expr) => {
+        concat!(
+            "
+            .globl ___rust_probestack
+        ___rust_probestack:
+            ",
+            $body
+        )
+    };
+}
+
+// In UEFI x86 arch, triple underscore is deliberate.
+#[cfg(all(target_os = "uefi", target_arch = "x86"))]
+macro_rules! define_rust_probestack {
+    ($body: expr) => {
+        concat!(
+            "
+            .globl ___rust_probestack
+        ___rust_probestack:
+            ",
+            $body
+        )
+    };
+}
+
+// Our goal here is to touch each page between %rsp+8 and %rsp+8-%rax,
+// ensuring that if any pages are unmapped we'll make a page fault.
+//
+// FIXME(abi_custom): This function is unsafe because it uses a custom ABI,
+// it does not actually match `extern "C"`.
+//
+// The ABI here is that the stack frame size is located in `%rax`. Upon
+// return we're not supposed to modify `%rsp` or `%rax`.
+//
+// Any changes to this function should be replicated to the SGX version below.
+#[cfg(all(
+    target_arch = "x86_64",
+    not(all(target_env = "sgx", target_vendor = "fortanix"))
+))]
+core::arch::global_asm!(
+    define_rust_probestack!(
+        "
+    .cfi_startproc
+    pushq  %rbp
+    .cfi_adjust_cfa_offset 8
+    .cfi_offset %rbp, -16
+    movq   %rsp, %rbp
+    .cfi_def_cfa_register %rbp
+
+    mov    %rax,%r11        // duplicate %rax as we're clobbering %r11
+
+    // Main loop, taken in one page increments. We're decrementing rsp by
+    // a page each time until there's less than a page remaining. We're
+    // guaranteed that this function isn't called unless there's more than a
+    // page needed.
+    //
+    // Note that we're also testing against `8(%rsp)` to account for the 8
+    // bytes pushed on the stack orginally with our return address. Using
+    // `8(%rsp)` simulates us testing the stack pointer in the caller's
+    // context.
+
+    // It's usually called when %rax >= 0x1000, but that's not always true.
+    // Dynamic stack allocation, which is needed to implement unsized
+    // rvalues, triggers stackprobe even if %rax < 0x1000.
+    // Thus we have to check %r11 first to avoid segfault.
+    cmp    $0x1000,%r11
+    jna    3f
+2:
+    sub    $0x1000,%rsp
+    test   %rsp,8(%rsp)
+    sub    $0x1000,%r11
+    cmp    $0x1000,%r11
+    ja     2b
+
+3:
+    // Finish up the last remaining stack space requested, getting the last
+    // bits out of r11
+    sub    %r11,%rsp
+    test   %rsp,8(%rsp)
+
+    // Restore the stack pointer to what it previously was when entering
+    // this function. The caller will readjust the stack pointer after we
+    // return.
+    add    %rax,%rsp
+
+    leave
+    .cfi_def_cfa_register %rsp
+    .cfi_adjust_cfa_offset -8
+    ret
+    .cfi_endproc
+    "
+    ),
+    options(att_syntax)
+);
+
+// This function is the same as above, except that some instructions are
+// [manually patched for LVI].
+//
+// [manually patched for LVI]: https://software.intel.com/security-software-guidance/insights/deep-dive-load-value-injection#specialinstructions
+#[cfg(all(
+    target_arch = "x86_64",
+    all(target_env = "sgx", target_vendor = "fortanix")
+))]
+core::arch::global_asm!(
+    define_rust_probestack!(
+        "
+    .cfi_startproc
+    pushq  %rbp
+    .cfi_adjust_cfa_offset 8
+    .cfi_offset %rbp, -16
+    movq   %rsp, %rbp
+    .cfi_def_cfa_register %rbp
+
+    mov    %rax,%r11        // duplicate %rax as we're clobbering %r11
+
+    // Main loop, taken in one page increments. We're decrementing rsp by
+    // a page each time until there's less than a page remaining. We're
+    // guaranteed that this function isn't called unless there's more than a
+    // page needed.
+    //
+    // Note that we're also testing against `8(%rsp)` to account for the 8
+    // bytes pushed on the stack orginally with our return address. Using
+    // `8(%rsp)` simulates us testing the stack pointer in the caller's
+    // context.
+
+    // It's usually called when %rax >= 0x1000, but that's not always true.
+    // Dynamic stack allocation, which is needed to implement unsized
+    // rvalues, triggers stackprobe even if %rax < 0x1000.
+    // Thus we have to check %r11 first to avoid segfault.
+    cmp    $0x1000,%r11
+    jna    3f
+2:
+    sub    $0x1000,%rsp
+    test   %rsp,8(%rsp)
+    sub    $0x1000,%r11
+    cmp    $0x1000,%r11
+    ja     2b
+
+3:
+    // Finish up the last remaining stack space requested, getting the last
+    // bits out of r11
+    sub    %r11,%rsp
+    test   %rsp,8(%rsp)
+
+    // Restore the stack pointer to what it previously was when entering
+    // this function. The caller will readjust the stack pointer after we
+    // return.
+    add    %rax,%rsp
+
+    leave
+    .cfi_def_cfa_register %rsp
+    .cfi_adjust_cfa_offset -8
+    pop %r11
+    lfence
+    jmp *%r11
+    .cfi_endproc
+    "
+    ),
+    options(att_syntax)
+);
+
+#[cfg(all(target_arch = "x86", not(target_os = "uefi")))]
+// This is the same as x86_64 above, only translated for 32-bit sizes. Note
+// that on Unix we're expected to restore everything as it was, this
+// function basically can't tamper with anything.
+//
+// FIXME(abi_custom): This function is unsafe because it uses a custom ABI,
+// it does not actually match `extern "C"`.
+//
+// The ABI here is the same as x86_64, except everything is 32-bits large.
+core::arch::global_asm!(
+    define_rust_probestack!(
+        "
+    .cfi_startproc
+    push   %ebp
+    .cfi_adjust_cfa_offset 4
+    .cfi_offset %ebp, -8
+    mov    %esp, %ebp
+    .cfi_def_cfa_register %ebp
+    push   %ecx
+    mov    %eax,%ecx
+
+    cmp    $0x1000,%ecx
+    jna    3f
+2:
+    sub    $0x1000,%esp
+    test   %esp,8(%esp)
+    sub    $0x1000,%ecx
+    cmp    $0x1000,%ecx
+    ja     2b
+
+3:
+    sub    %ecx,%esp
+    test   %esp,8(%esp)
+
+    add    %eax,%esp
+    pop    %ecx
+    leave
+    .cfi_def_cfa_register %esp
+    .cfi_adjust_cfa_offset -4
+    ret
+    .cfi_endproc
+    "
+    ),
+    options(att_syntax)
+);
+
+#[cfg(all(target_arch = "x86", target_os = "uefi"))]
+// UEFI target is windows like target. LLVM will do _chkstk things like windows.
+// probestack function will also do things like _chkstk in MSVC.
+// So we need to sub %ax %sp in probestack when arch is x86.
+//
+// FIXME(abi_custom): This function is unsafe because it uses a custom ABI,
+// it does not actually match `extern "C"`.
+//
+// REF: Rust commit(74e80468347)
+// rust\src\llvm-project\llvm\lib\Target\X86\X86FrameLowering.cpp: 805
+// Comments in LLVM:
+//   MSVC x32's _chkstk and cygwin/mingw's _alloca adjust %esp themselves.
+//   MSVC x64's __chkstk and cygwin/mingw's ___chkstk_ms do not adjust %rsp
+//   themselves.
+core::arch::global_asm!(
+    define_rust_probestack!(
+        "
+    .cfi_startproc
+    push   %ebp
+    .cfi_adjust_cfa_offset 4
+    .cfi_offset %ebp, -8
+    mov    %esp, %ebp
+    .cfi_def_cfa_register %ebp
+    push   %ecx
+    push   %edx
+    mov    %eax,%ecx
+
+    cmp    $0x1000,%ecx
+    jna    3f
+2:
+    sub    $0x1000,%esp
+    test   %esp,8(%esp)
+    sub    $0x1000,%ecx
+    cmp    $0x1000,%ecx
+    ja     2b
+
+3:
+    sub    %ecx,%esp
+    test   %esp,8(%esp)
+    mov    4(%ebp),%edx
+    mov    %edx, 12(%esp)
+    add    %eax,%esp
+    pop    %edx
+    pop    %ecx
+    leave
+
+    sub   %eax, %esp
+    .cfi_def_cfa_register %esp
+    .cfi_adjust_cfa_offset -4
+    ret
+    .cfi_endproc
+    "
+    ),
+    options(att_syntax)
+);
diff --git a/lib/vm/src/probestack.rs b/lib/vm/src/probestack/mod.rs
similarity index 77%
rename from lib/vm/src/probestack.rs
rename to lib/vm/src/probestack/mod.rs
index 814ddf9c20..84dfd22fb8 100644
--- a/lib/vm/src/probestack.rs
+++ b/lib/vm/src/probestack/mod.rs
@@ -14,6 +14,11 @@
 //!
 //! [The Stack Clash]: https://blog.qualys.com/securitylabs/2017/06/19/the-stack-clash
 
+// Based on `compiler-builtins` crate with changes in `#[cfg(...)]`:
+// https://raw.githubusercontent.com/rust-lang/compiler-builtins/319637f544d9dda8fc3dd482d9979e0da135a258/compiler-builtins/src/probestack.rs
+#[cfg(missing_rust_probestack)]
+mod compiler_builtins;
+
 // A declaration for the stack probe function in Rust's standard library, for
 // catching callstack overflow.
 cfg_if::cfg_if! {
@@ -55,10 +60,17 @@ cfg_if::cfg_if! {
         /// A default probestack for other architectures
         pub const PROBESTACK: unsafe extern "C" fn() = empty_probestack;
     } else {
-        extern "C" {
-            pub fn __rust_probestack();
+        cfg_if::cfg_if! {
+            if #[cfg(not(missing_rust_probestack))] {
+                extern "C" {
+                    pub fn __rust_probestack();
+                }
+                /// The probestack based on the Rust probestack
+                pub static PROBESTACK: unsafe extern "C" fn() = __rust_probestack;
+            } else if #[cfg(missing_rust_probestack)] {
+                /// The probestack based on the Rust probestack
+                pub static PROBESTACK: unsafe extern "C" fn() = compiler_builtins::__rust_probestack;
+            }
         }
-        /// The probestack based on the Rust probestack
-        pub static PROBESTACK: unsafe extern "C" fn() = __rust_probestack;
     }
 }
diff --git a/lib/vm/src/sig_registry.rs b/lib/vm/src/sig_registry.rs
index 1ae661a7ed..71d5f4b23c 100644
--- a/lib/vm/src/sig_registry.rs
+++ b/lib/vm/src/sig_registry.rs
@@ -45,12 +45,12 @@ impl SignatureRegistry {
         match entry {
             hash_map::Entry::Occupied(entry) => *entry.get(),
             hash_map::Entry::Vacant(entry) => {
-                // Keep `signature_hash` len under 2**32 -- VMSharedSignatureIndex::new(std::u32::MAX)
+                // Keep `signature_hash` len under 2**32 -- VMSharedSignatureIndex::new(u32::MAX)
                 // is reserved for VMSharedSignatureIndex::default().
                 debug_assert_lt!(
                     len,
-                    std::u32::MAX as usize,
-                    "Invariant check: signature_hash.len() < std::u32::MAX"
+                    u32::MAX as usize,
+                    "Invariant check: signature_hash.len() < u32::MAX"
                 );
                 let sig_id = VMSharedSignatureIndex::new(u32::try_from(len).unwrap());
                 entry.insert(sig_id);
diff --git a/lib/vm/src/store.rs b/lib/vm/src/store.rs
index 8813ee26c1..019416d765 100644
--- a/lib/vm/src/store.rs
+++ b/lib/vm/src/store.rs
@@ -1,5 +1,6 @@
 use crate::{
-    VMExternObj, VMFunction, VMFunctionEnvironment, VMGlobal, VMInstance, VMMemory, VMTable,
+    VMExceptionObj, VMExternObj, VMFunction, VMFunctionEnvironment, VMGlobal, VMInstance, VMMemory,
+    VMTable, VMTag,
 };
 use core::slice::Iter;
 use std::{cell::UnsafeCell, fmt, marker::PhantomData, num::NonZeroUsize, ptr::NonNull};
@@ -8,7 +9,10 @@ use wasmer_types::StoreId;
 /// Trait to represent an object managed by a context. This is implemented on
 /// the VM types managed by the context.
 pub trait StoreObject: Sized {
+    /// List the objects in the store.
     fn list(ctx: &StoreObjects) -> &Vec<Self>;
+
+    /// List the objects in the store, mutably.
     fn list_mut(ctx: &mut StoreObjects) -> &mut Vec<Self>;
 }
 macro_rules! impl_context_object {
@@ -32,6 +36,8 @@ impl_context_object! {
     instances => VMInstance,
     memories => VMMemory,
     extern_objs => VMExternObj,
+    exceptions => VMExceptionObj,
+    tags => VMTag,
     function_environments => VMFunctionEnvironment,
 }
 
@@ -45,10 +51,40 @@ pub struct StoreObjects {
     functions: Vec<VMFunction>,
     instances: Vec<VMInstance>,
     extern_objs: Vec<VMExternObj>,
+    exceptions: Vec<VMExceptionObj>,
+    tags: Vec<VMTag>,
     function_environments: Vec<VMFunctionEnvironment>,
 }
 
 impl StoreObjects {
+    /// Create a new instance of [`Self`]
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        id: StoreId,
+        memories: Vec<VMMemory>,
+        tables: Vec<VMTable>,
+        globals: Vec<VMGlobal>,
+        functions: Vec<VMFunction>,
+        instances: Vec<VMInstance>,
+        extern_objs: Vec<VMExternObj>,
+        exceptions: Vec<VMExceptionObj>,
+        tags: Vec<VMTag>,
+        function_environments: Vec<VMFunctionEnvironment>,
+    ) -> Self {
+        Self {
+            id,
+            memories,
+            tables,
+            globals,
+            functions,
+            instances,
+            extern_objs,
+            function_environments,
+            exceptions,
+            tags,
+        }
+    }
+
     /// Returns the ID of this context.
     pub fn id(&self) -> StoreId {
         self.id
@@ -105,6 +141,7 @@ impl StoreObjects {
 ///
 /// Internally this is just an integer index into a context. A reference to the
 /// context must be passed in separately to access the actual object.
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 pub struct StoreHandle<T> {
     id: StoreId,
     internal: InternalStoreHandle<T>,
@@ -199,6 +236,13 @@ pub struct InternalStoreHandle<T> {
     marker: PhantomData<fn() -> T>,
 }
 
+#[cfg(feature = "artifact-size")]
+impl<T> loupe::MemoryUsage for InternalStoreHandle<T> {
+    fn size_of_val(&self, _tracker: &mut dyn loupe::MemoryUsageTracker) -> usize {
+        std::mem::size_of_val(&self)
+    }
+}
+
 impl<T> Clone for InternalStoreHandle<T> {
     fn clone(&self) -> Self {
         *self
diff --git a/lib/vm/src/table.rs b/lib/vm/src/table.rs
index 18f0b602de..9399623914 100644
--- a/lib/vm/src/table.rs
+++ b/lib/vm/src/table.rs
@@ -10,7 +10,6 @@ use crate::vmcontext::VMTableDefinition;
 use crate::Trap;
 use crate::VMExternRef;
 use crate::VMFuncRef;
-use derivative::Derivative;
 use std::cell::UnsafeCell;
 use std::convert::TryFrom;
 use std::fmt;
@@ -21,7 +20,7 @@ use wasmer_types::{TableType, TrapCode, Type as ValType};
 /// A reference stored in a table. Can be either an externref or a funcref.
 #[derive(Debug, Clone)]
 pub enum TableElement {
-    /// Opaque pointer to arbitrary host data.
+    /// Opaque pointer to arbitrary hostdata.
     ExternRef(Option<VMExternRef>),
     /// Pointer to function: contains enough information to call it.
     FuncRef(Option<VMFuncRef>),
@@ -70,17 +69,14 @@ impl Default for TableElement {
 }
 
 /// A table instance.
-#[derive(Derivative)]
-#[derivative(Debug)]
+#[derive(Debug)]
 pub struct VMTable {
-    #[derivative(Debug = "ignore")]
     vec: Vec<RawTableElement>,
     maximum: Option<u32>,
     /// The WebAssembly table description.
     table: TableType,
     /// Our chosen implementation style.
     style: TableStyle,
-    #[derivative(Debug = "ignore")]
     vm_table_definition: MaybeInstanceOwned<VMTableDefinition>,
 }
 
@@ -123,8 +119,7 @@ impl VMTable {
             ValType::FuncRef | ValType::ExternRef => (),
             ty => {
                 return Err(format!(
-                    "tables of types other than funcref or externref ({})",
-                    ty
+                    "tables of types other than funcref or externref ({ty})",
                 ))
             }
         };
@@ -196,7 +191,7 @@ impl VMTable {
     pub fn grow(&mut self, delta: u32, init_value: TableElement) -> Option<u32> {
         let size = self.size();
         let new_len = size.checked_add(delta)?;
-        if self.maximum.map_or(false, |max| new_len > max) {
+        if self.maximum.is_some_and(|max| new_len > max) {
             return None;
         }
         if new_len == size {
@@ -247,10 +242,7 @@ impl VMTable {
                     // This path should never be hit by the generated code due to Wasm
                     // validation.
                     (ty, v) => {
-                        panic!(
-                            "Attempted to set a table of type {} with the value {:?}",
-                            ty, v
-                        )
+                        panic!("Attempted to set a table of type {ty} with the value {v:?}")
                     }
                 };
 
@@ -315,7 +307,7 @@ impl VMTable {
     pub fn copy_on_write(&self) -> Result<Self, String> {
         let mut ret = Self::new(&self.table, &self.style)?;
         ret.copy(self, 0, 0, self.size())
-            .map_err(|trap| format!("failed to copy the table - {:?}", trap))?;
+            .map_err(|trap| format!("failed to copy the table - {trap:?}"))?;
         Ok(ret)
     }
 
diff --git a/lib/vm/src/threadconditions.rs b/lib/vm/src/threadconditions.rs
index cdf6938ec5..747b65ebce 100644
--- a/lib/vm/src/threadconditions.rs
+++ b/lib/vm/src/threadconditions.rs
@@ -87,7 +87,7 @@ impl ThreadConditions {
         }
 
         // fetch the notifier
-        if self.inner.map.len() >= 1 << 32 {
+        if self.inner.map.len() as u64 >= 1u64 << 32 {
             return Err(WaiterError::TooManyWaiters);
         }
         self.inner.map.entry(dst).or_default().push(NotifyWaiter {
diff --git a/lib/vm/src/trap/trap.rs b/lib/vm/src/trap/trap.rs
index fa8de9c939..843b4c7c0a 100644
--- a/lib/vm/src/trap/trap.rs
+++ b/lib/vm/src/trap/trap.rs
@@ -126,7 +126,7 @@ impl std::error::Error for Trap {
 impl fmt::Display for Trap {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::User(e) => write!(f, "{}", e),
+            Self::User(e) => write!(f, "{e}"),
             Self::Lib { .. } => write!(f, "lib"),
             Self::Wasm { .. } => write!(f, "wasm"),
             Self::OOM { .. } => write!(f, "Wasmer VM out of memory"),
diff --git a/lib/vm/src/trap/traphandlers.rs b/lib/vm/src/trap/traphandlers.rs
index 4ce892db0a..f3f7b9c995 100644
--- a/lib/vm/src/trap/traphandlers.rs
+++ b/lib/vm/src/trap/traphandlers.rs
@@ -1,11 +1,13 @@
 // This file contains code from external sources.
 // Attributions: https://github.com/wasmerio/wasmer/blob/main/docs/ATTRIBUTIONS.md
 
+#![allow(static_mut_refs)]
+
 //! WebAssembly trap handling, which is built on top of the lower-level
 //! signalhandling mechanisms.
 
 use crate::vmcontext::{VMFunctionContext, VMTrampoline};
-use crate::{Trap, VMFunctionBody};
+use crate::{Trap, VMContext, VMFunctionBody};
 use backtrace::Backtrace;
 use core::ptr::{read, read_unaligned};
 use corosensei::stack::DefaultStack;
@@ -21,7 +23,7 @@ use std::mem;
 use std::mem::MaybeUninit;
 use std::ptr::{self, NonNull};
 use std::sync::atomic::{compiler_fence, AtomicPtr, AtomicUsize, Ordering};
-use std::sync::Once;
+use std::sync::{LazyLock, Once};
 use wasmer_types::TrapCode;
 
 /// Configuration for the runtime VM
@@ -75,7 +77,7 @@ use libc::ucontext_t;
 
 /// Default stack size is 1MB.
 pub fn set_stack_size(size: usize) {
-    DEFAULT_STACK_SIZE.store(size.max(8 * 1024).min(100 * 1024 * 1024), Ordering::Relaxed);
+    DEFAULT_STACK_SIZE.store(size.clamp(8 * 1024, 100 * 1024 * 1024), Ordering::Relaxed);
 }
 
 cfg_if::cfg_if! {
@@ -234,7 +236,7 @@ cfg_if::cfg_if! {
                 libc::SIGBUS => &PREV_SIGBUS,
                 libc::SIGFPE => &PREV_SIGFPE,
                 libc::SIGILL => &PREV_SIGILL,
-                _ => panic!("unknown signal: {}", signum),
+                _ => panic!("unknown signal: {signum}"),
             };
             // We try to get the fault address associated to this signal
             let maybe_fault_address = match signum {
@@ -339,6 +341,9 @@ cfg_if::cfg_if! {
                 } else if #[cfg(all(target_os = "freebsd", target_arch = "aarch64"))] {
                     pc = context.uc_mcontext.mc_gpregs.gp_elr as usize;
                     sp = context.uc_mcontext.mc_gpregs.gp_sp as usize;
+                } else if #[cfg(all(target_os = "linux", target_arch = "loongarch64"))] {
+                    pc = context.uc_mcontext.__gregs[1] as usize;
+                    sp = context.uc_mcontext.__gregs[3] as usize;
                 } else {
                     compile_error!("Unsupported platform");
                 }
@@ -459,6 +464,14 @@ cfg_if::cfg_if! {
                     context.uc_mcontext.mc_gpregs.gp_x[1] = x1 as libc::register_t;
                     context.uc_mcontext.mc_gpregs.gp_x[29] = x29 as libc::register_t;
                     context.uc_mcontext.mc_gpregs.gp_x[30] = lr as libc::register_t;
+                } else if #[cfg(all(target_os = "linux", target_arch = "loongarch64"))] {
+                    let TrapHandlerRegs { pc, sp, a0, a1, fp, ra } = regs;
+                    context.uc_mcontext.__pc = pc;
+                    context.uc_mcontext.__gregs[1] = ra;
+                    context.uc_mcontext.__gregs[3] = sp;
+                    context.uc_mcontext.__gregs[4] = a0;
+                    context.uc_mcontext.__gregs[5] = a1;
+                    context.uc_mcontext.__gregs[22] = fp;
                 } else {
                     compile_error!("Unsupported platform");
                 }
@@ -672,10 +685,15 @@ pub unsafe fn wasmer_call_trampoline(
     callee: *const VMFunctionBody,
     values_vec: *mut u8,
 ) -> Result<(), Trap> {
-    catch_traps(trap_handler, config, || {
-        mem::transmute::<_, extern "C" fn(VMFunctionContext, *const VMFunctionBody, *mut u8)>(
-            trampoline,
-        )(vmctx, callee, values_vec);
+    catch_traps(trap_handler, config, move || {
+        mem::transmute::<
+            unsafe extern "C" fn(
+                *mut VMContext,
+                *const VMFunctionBody,
+                *mut wasmer_types::RawValue,
+            ),
+            extern "C" fn(VMFunctionContext, *const VMFunctionBody, *mut u8),
+        >(trampoline)(vmctx, callee, values_vec);
     })
 }
 
@@ -685,13 +703,13 @@ pub unsafe fn wasmer_call_trampoline(
 /// # Safety
 ///
 /// Highly unsafe since `closure` won't have any dtors run.
-pub unsafe fn catch_traps<F, R>(
+pub unsafe fn catch_traps<F, R: 'static>(
     trap_handler: Option<*const TrapHandlerFn<'static>>,
     config: &VMConfig,
     closure: F,
 ) -> Result<R, Trap>
 where
-    F: FnOnce() -> R,
+    F: FnOnce() -> R + 'static,
 {
     // Ensure that per-thread initialization is done.
     lazy_per_thread_init()?;
@@ -710,8 +728,8 @@ where
 // We also do per-thread signal stack initialization on the first time
 // TRAP_HANDLER is accessed.
 thread_local! {
-    static YIELDER: Cell<Option<NonNull<Yielder<(), UnwindReason>>>> = Cell::new(None);
-    static TRAP_HANDLER: AtomicPtr<TrapHandlerContext> = AtomicPtr::new(ptr::null_mut());
+    static YIELDER: Cell<Option<NonNull<Yielder<(), UnwindReason>>>> = const { Cell::new(None) };
+    static TRAP_HANDLER: AtomicPtr<TrapHandlerContext> = const { AtomicPtr::new(ptr::null_mut()) };
 }
 
 /// Read-only information that is used by signal handlers to handle and recover
@@ -914,7 +932,7 @@ unsafe fn unwind_with(reason: UnwindReason) -> ! {
 /// Runs the given function on a separate stack so that its stack usage can be
 /// bounded. Stack overflows and other traps can be caught and execution
 /// returned to the root of the stack.
-fn on_wasm_stack<F: FnOnce() -> T, T>(
+fn on_wasm_stack<F: FnOnce() -> T + 'static, T: 'static>(
     stack_size: usize,
     trap_handler: Option<*const TrapHandlerFn<'static>>,
     f: F,
@@ -923,16 +941,16 @@ fn on_wasm_stack<F: FnOnce() -> T, T>(
     // system calls. We therefore keep a cache of pre-allocated stacks which
     // allows them to be reused multiple times.
     // FIXME(Amanieu): We should refactor this to avoid the lock.
-    lazy_static::lazy_static! {
-        static ref STACK_POOL: crossbeam_queue::SegQueue<DefaultStack> = crossbeam_queue::SegQueue::new();
-    }
+    static STACK_POOL: LazyLock<crossbeam_queue::SegQueue<DefaultStack>> =
+        LazyLock::new(crossbeam_queue::SegQueue::new);
+
     let stack = STACK_POOL
         .pop()
         .unwrap_or_else(|| DefaultStack::new(stack_size).unwrap());
     let mut stack = scopeguard::guard(stack, |stack| STACK_POOL.push(stack));
 
     // Create a coroutine with a new stack to run the function on.
-    let mut coro = ScopedCoroutine::with_stack(&mut *stack, move |yielder, ()| {
+    let coro = ScopedCoroutine::with_stack(&mut *stack, move |yielder, ()| {
         // Save the yielder to TLS so that it can be used later.
         YIELDER.with(|cell| cell.set(Some(yielder.into())));
 
@@ -944,20 +962,22 @@ fn on_wasm_stack<F: FnOnce() -> T, T>(
         YIELDER.with(|cell| cell.set(None));
     }
 
-    // Set up metadata for the trap handler for the duration of the coroutine
-    // execution. This is restored to its previous value afterwards.
-    TrapHandlerContext::install(trap_handler, coro.trap_handler(), || {
-        match coro.resume(()) {
-            CoroutineResult::Yield(trap) => {
-                // This came from unwind_with which requires that there be only
-                // Wasm code on the stack.
-                unsafe {
-                    coro.force_reset();
+    coro.scope(|mut coro_ref| {
+        // Set up metadata for the trap handler for the duration of the coroutine
+        // execution. This is restored to its previous value afterwards.
+        TrapHandlerContext::install(trap_handler, coro_ref.trap_handler(), || {
+            match coro_ref.resume(()) {
+                CoroutineResult::Yield(trap) => {
+                    // This came from unwind_with which requires that there be only
+                    // Wasm code on the stack.
+                    unsafe {
+                        coro_ref.force_reset();
+                    }
+                    Err(trap)
                 }
-                Err(trap)
+                CoroutineResult::Return(result) => result,
             }
-            CoroutineResult::Return(result) => result,
-        }
+        })
     })
 }
 
diff --git a/lib/vm/src/vmcontext.rs b/lib/vm/src/vmcontext.rs
index c75d6b5f69..09f780c500 100644
--- a/lib/vm/src/vmcontext.rs
+++ b/lib/vm/src/vmcontext.rs
@@ -15,7 +15,6 @@ use crate::{VMBuiltinFunctionIndex, VMFunction};
 use std::convert::TryFrom;
 use std::ptr::{self, NonNull};
 use std::sync::atomic::{AtomicPtr, Ordering};
-use std::u32;
 use wasmer_types::RawValue;
 
 /// Union representing the first parameter passed when calling a function.
@@ -535,9 +534,28 @@ impl VMGlobalDefinition {
     }
 }
 
+/// A tag index, unique within the Store in which the instance was created.
+/// Usable for translating module-local tag indices to store-unique ones.
+#[repr(C)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
+pub struct VMSharedTagIndex(u32);
+
+impl VMSharedTagIndex {
+    /// Create a new `VMSharedTagIndex`.
+    pub fn new(value: u32) -> Self {
+        Self(value)
+    }
+
+    /// Get the inner value.
+    pub fn index(&self) -> u32 {
+        self.0
+    }
+}
+
 /// An index into the shared signature registry, usable for checking signatures
 /// at indirect calls.
 #[repr(C)]
+#[cfg_attr(feature = "artifact-size", derive(loupe::MemoryUsage))]
 #[derive(Debug, Eq, PartialEq, Clone, Copy, Hash)]
 pub struct VMSharedSignatureIndex(u32);
 
@@ -710,6 +728,22 @@ impl VMBuiltinFunctionsArray {
             wasmer_vm_memory32_atomic_notify as usize;
         ptrs[VMBuiltinFunctionIndex::get_imported_memory_atomic_notify_index().index() as usize] =
             wasmer_vm_imported_memory32_atomic_notify as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_throw_index().index() as usize] =
+            wasmer_vm_throw as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_rethrow_index().index() as usize] =
+            wasmer_vm_rethrow as usize;
+
+        ptrs[VMBuiltinFunctionIndex::get_imported_alloc_exception_index().index() as usize] =
+            wasmer_vm_alloc_exception as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_delete_exception_index().index() as usize] =
+            wasmer_vm_delete_exception as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_read_exception_index().index() as usize] =
+            wasmer_vm_read_exception as usize;
+
+        ptrs[VMBuiltinFunctionIndex::get_imported_debug_usize_index().index() as usize] =
+            wasmer_vm_dbg_usize as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_debug_str_index().index() as usize] =
+            wasmer_vm_dbg_str as usize;
 
         debug_assert!(ptrs.iter().cloned().all(|p| p != 0));
 
@@ -748,7 +782,7 @@ impl VMContext {
     }
 }
 
-///
+/// The type for tramplines in the VM.
 pub type VMTrampoline = unsafe extern "C" fn(
     *mut VMContext,        // callee vmctx
     *const VMFunctionBody, // function we're actually calling
diff --git a/lib/wai-bindgen-wasmer/Cargo.toml b/lib/wai-bindgen-wasmer/Cargo.toml
index 8393bef337..2d3f8f69e0 100644
--- a/lib/wai-bindgen-wasmer/Cargo.toml
+++ b/lib/wai-bindgen-wasmer/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "wai-bindgen-wasmer"
 description = "Generate WAI glue for a Rust Wasmer host"
-version = "0.27.0"
+version = "0.601.0"
 categories = ["wasm", "os"]
 keywords = ["wasm", "webassembly", "wasi", "sandbox", "ABI"]
 readme = "README.md"
@@ -13,14 +13,14 @@ repository.workspace = true
 rust-version.workspace = true
 
 [dependencies]
-anyhow = "1.0"
-async-trait = { version = "0.1.50", optional = true }
+anyhow.workspace = true
+async-trait = { workspace = true, optional = true }
 bitflags = "1.2"
-once_cell = "1.13"
-thiserror = "1.0"
+once_cell.workspace = true
+thiserror.workspace = true
 tracing-lib = { version = "0.1.26", optional = true, package = "tracing" }
 wai-bindgen-wasmer-impl = { version = "0.2.2" }
-wasmer = { version = "=4.3.7", path = "../api", default-features = false }
+wasmer = { version = "=6.1.0", path = "../api", default-features = false }
 
 [features]
 # Enables generated code to emit events via the `tracing` crate whenever wasm is
@@ -34,7 +34,7 @@ async = ["async-trait", "wai-bindgen-wasmer-impl/async"]
 
 # Wasmer features
 js = ["wasmer/js-default"]
-sys = ["wasmer/sys"]
+sys = ["wasmer/sys-default"]
 
 # Wasmer compiler (with `sys` feature only)
 cranelift = ["wasmer/cranelift"]
@@ -42,5 +42,5 @@ singlepass = ["wasmer/singlepass"]
 llvm = ["wasmer/llvm"]
 
 [package.metadata.docs.rs]
-features = ["wasmer/sys"]
+features = ["wasmer/sys", "wasmer/compiler"]
 rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/wai-bindgen-wasmer/src/lib.rs b/lib/wai-bindgen-wasmer/src/lib.rs
index aadf7ff777..5af1b4cd34 100644
--- a/lib/wai-bindgen-wasmer/src/lib.rs
+++ b/lib/wai-bindgen-wasmer/src/lib.rs
@@ -82,7 +82,7 @@ pub mod rt {
     }
 
     pub fn invalid_variant(name: &str) -> RuntimeError {
-        let msg = format!("invalid discriminant for `{}`", name);
+        let msg = format!("invalid discriminant for `{name}`");
         RuntimeError::new(msg)
     }
 
@@ -96,7 +96,7 @@ pub mod rt {
         T: std::ops::Not<Output = T> + std::ops::BitAnd<Output = T> + From<u8> + PartialEq + Copy,
     {
         if bits & !all != 0u8.into() {
-            let msg = format!("invalid flags specified for `{}`", name);
+            let msg = format!("invalid flags specified for `{name}`");
             Err(RuntimeError::new(msg))
         } else {
             Ok(mk(bits))
diff --git a/lib/wasi-types/Cargo.toml b/lib/wasi-types/Cargo.toml
index 1cecb8946c..fcdd175f71 100644
--- a/lib/wasi-types/Cargo.toml
+++ b/lib/wasi-types/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "wasmer-wasix-types"
-version = "0.27.0"
+version = "0.601.0"
 description = "WASI and WASIX types for Wasmer WebAssembly runtime"
 categories = ["wasm", "os"]
 keywords = ["wasm", "webassembly", "wasi", "sandbox", "ABI"]
@@ -15,22 +15,24 @@ rust-version.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-wasmer = { default-features = false, path = "../api", version = "=4.3.7" }
-wasmer-types = { path = "../types", version = "=4.3.7" }
-wasmer-derive = { path = "../derive", version = "=4.3.7" }
+wasmer = { default-features = false, path = "../api", version = "=6.1.0" }
+wasmer-types = { path = "../types", version = "=6.1.0" }
+wasmer-derive = { path = "../derive", version = "=6.1.0" }
 wai-bindgen-gen-rust = "0.2.1"
-wai-bindgen-rust = { version = "0.2.1", default-features = false, features = ["macros"] }
+wai-bindgen-rust = { version = "0.2.1", default-features = false, features = [
+	"macros",
+] }
 wai-bindgen-gen-rust-wasm = "0.2.1"
 wai-bindgen-gen-core = "0.2.1"
 wai-parser = "0.2.1"
-serde = { version = "1.0", features = ["derive"], optional = true }
-num_enum = "0.5.7"
+serde = { workspace = true, features = ["derive"], optional = true }
+num_enum.workspace = true
 bitflags = "1.3.0"
-cfg-if = "1.0.0"
-anyhow = "1.0.66"
-byteorder = "1.3"
-time = { version = "0.3", features = ["formatting"] }
-tracing = { version = "0.1.37" }
+cfg-if.workspace = true
+anyhow.workspace = true
+byteorder.workspace = true
+time = { workspace = true, features = ["formatting"] }
+tracing.workspace = true
 
 [dev-dependencies.pretty_assertions]
 version = "1.3.0"
@@ -39,5 +41,5 @@ version = "1.3.0"
 enable-serde = ["serde", "wasmer-types/serde"]
 
 [package.metadata.docs.rs]
-features = ["wasmer/sys"]
+features = ["wasmer/sys", "wasmer/compiler"]
 rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/wasi-types/src/types.rs b/lib/wasi-types/src/types.rs
index d9a41a41b1..5c4a646f65 100644
--- a/lib/wasi-types/src/types.rs
+++ b/lib/wasi-types/src/types.rs
@@ -41,7 +41,7 @@ pub mod file {
                 right_set.insert(cur_right.to_str().unwrap_or("INVALID RIGHT"));
             }
         }
-        println!("{:#?}", right_set);
+        println!("{right_set:#?}");
     }
 }
 
@@ -280,6 +280,9 @@ pub mod net {
     pub const __WASI_SOCK_RECV_INPUT_PEEK: RiFlags = 1 << 0;
     pub const __WASI_SOCK_RECV_INPUT_WAITALL: RiFlags = 1 << 1;
     pub const __WASI_SOCK_RECV_INPUT_DATA_TRUNCATED: RiFlags = 1 << 2;
+    pub const __WASI_SOCK_RECV_INPUT_DONT_WAIT: RiFlags = 1 << 3;
+
+    pub const __WASI_SOCK_SEND_INPUT_DONT_WAIT: SiFlags = 1 << 0;
 
     pub const __WASI_SOCK_RECV_OUTPUT_DATA_TRUNCATED: RoFlags = 1 << 0;
 
diff --git a/lib/wasi-types/src/wasi/bindings.rs b/lib/wasi-types/src/wasi/bindings.rs
index 8b07961d63..66631f234e 100644
--- a/lib/wasi-types/src/wasi/bindings.rs
+++ b/lib/wasi-types/src/wasi/bindings.rs
@@ -673,6 +673,22 @@ impl core::fmt::Debug for Advice {
         }
     }
 }
+wai_bindgen_rust::bitflags::bitflags! {
+    // Actual file descriptor flags. Note, WASI's fdflags actually represent
+    // file table flags, not fd flags... Hence the weird name.
+    #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+    pub struct Fdflagsext : u16 {
+        #[doc = " Close this file in the child process when spawning one."]
+        const CLOEXEC = 1 << 0;
+    }
+}
+impl Fdflagsext {
+    #[doc = " Convert from a raw integer, preserving any unknown bits. See"]
+    #[doc = " <https://github.com/bitflags/bitflags/issues/263#issuecomment-957088321>"]
+    pub fn from_bits_preserve(bits: u16) -> Self {
+        Self { bits }
+    }
+}
 wai_bindgen_rust::bitflags::bitflags! {
     #[doc = " File descriptor flags."]
     #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
@@ -2240,6 +2256,7 @@ impl core::fmt::Debug for OptionTimestamp {
 }
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq, num_enum :: TryFromPrimitive, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub enum Signal {
     Signone = 0,
     Sighup,
@@ -2273,6 +2290,7 @@ pub enum Signal {
     Sigpoll,
     Sigpwr,
     Sigsys,
+    Sigwakeup, // This is a host-side-only signal. Add new guest-side signals before this one.
 }
 impl core::fmt::Debug for Signal {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
@@ -2309,9 +2327,195 @@ impl core::fmt::Debug for Signal {
             Signal::Sigpoll => f.debug_tuple("Signal::Sigpoll").finish(),
             Signal::Sigpwr => f.debug_tuple("Signal::Sigpwr").finish(),
             Signal::Sigsys => f.debug_tuple("Signal::Sigsys").finish(),
+            Signal::Sigwakeup => f.debug_tuple("Signal::Sigwakeup").finish(),
+        }
+    }
+}
+
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Eq, num_enum :: TryFromPrimitive, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum Disposition {
+    Default,
+    Ignore,
+}
+impl core::fmt::Debug for Disposition {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Disposition::Default => f.debug_tuple("SigAction::Default").finish(),
+            Disposition::Ignore => f.debug_tuple("SigAction::Ignore").finish(),
+        }
+    }
+}
+
+#[doc = " A signal and its corresponding action."]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SignalDisposition {
+    pub sig: Signal,
+    pub disp: Disposition,
+}
+impl core::fmt::Debug for SignalDisposition {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("SignalAndAction")
+            .field("sig", &self.sig)
+            .field("act", &self.disp)
+            .finish()
+    }
+}
+
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Eq, num_enum :: TryFromPrimitive, Hash)]
+pub enum ProcSpawnFdOpName {
+    Close,
+    Dup2,
+    Open,
+    Chdir,
+    Fchdir,
+}
+impl core::fmt::Debug for ProcSpawnFdOpName {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            ProcSpawnFdOpName::Close => f.debug_tuple("ProcSpawnFdOpName::Close").finish(),
+            ProcSpawnFdOpName::Dup2 => f.debug_tuple("ProcSpawnFdOpName::Dup2").finish(),
+            ProcSpawnFdOpName::Open => f.debug_tuple("ProcSpawnFdOpName::Open").finish(),
+            ProcSpawnFdOpName::Chdir => f.debug_tuple("ProcSpawnFdOpName::Chdir").finish(),
+            ProcSpawnFdOpName::Fchdir => f.debug_tuple("ProcSpawnFdOpName::Fchdir").finish(),
         }
     }
 }
+
+#[doc = "  An FD operation performed during proc_spawn2, which is the backing syscall for posix_spawn."]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ProcSpawnFdOp<M: MemorySize> {
+    pub cmd: ProcSpawnFdOpName,
+    pub fd: Fd,
+    pub src_fd: Fd,
+    pub name: M::Offset,
+    pub name_len: M::Offset,
+    pub dirflags: LookupFlags,
+    pub oflags: Oflags,
+    pub fs_rights_base: Rights,
+    pub fs_rights_inheriting: Rights,
+    pub fdflags: Fdflags,
+    pub fdflagsext: Fdflagsext,
+}
+impl<M: MemorySize> core::fmt::Debug for ProcSpawnFdOp<M> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("ProcSpawnFdOp")
+            .field("cmd", &self.cmd)
+            .field("fd", &self.fd)
+            .field("src_fd", &self.src_fd)
+            .field("name", &self.name)
+            .field("name_len", &self.name_len)
+            .field("dirflags", &self.dirflags)
+            .field("oflags", &self.oflags)
+            .field("fs_rights_base", &self.fs_rights_base)
+            .field("fs_rights_inheriting", &self.fs_rights_inheriting)
+            .field("fdflags", &self.fdflags)
+            .field("fdflagsext", &self.fdflagsext)
+            .finish()
+    }
+}
+
+pub type DlHandle = u32;
+
+wai_bindgen_rust::bitflags::bitflags! {
+    pub struct DlFlags : u32 {
+        const LAZY = 1 << 0;
+        const NOW = 1 << 1;
+        const GLOBAL = 1 << 2;
+        const NOLOAD = 1 << 3;
+        const NODELETE = 1 << 4;
+        const DEEPBIND = 1 << 5;
+    }
+}
+impl DlFlags {
+    pub fn from_bits_preserve(bits: u32) -> Self {
+        Self { bits }
+    }
+}
+
+#[doc = " The type of a WASM value represented at runtime for use with the wasix closures API."]
+#[doc = ""]
+#[doc = " For now only number types are supported, but this may be extended in the future to include references"]
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Eq, num_enum :: TryFromPrimitive, Hash)]
+pub enum WasmValueType {
+    #[doc = " A i32 parameter."]
+    I32,
+    #[doc = " A i64 parameter."]
+    I64,
+    #[doc = " A f32 parameter."]
+    F32,
+    #[doc = " A f64 parameter."]
+    F64,
+    #[doc = " A v128 parameter."]
+    V128,
+}
+impl core::fmt::Debug for WasmValueType {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            WasmValueType::I32 => f.debug_tuple("WasmValueType::I32").finish(),
+            WasmValueType::I64 => f.debug_tuple("WasmValueType::I64").finish(),
+            WasmValueType::F32 => f.debug_tuple("WasmValueType::F32").finish(),
+            WasmValueType::F64 => f.debug_tuple("WasmValueType::F64").finish(),
+            WasmValueType::V128 => f.debug_tuple("WasmValueType::V128").finish(),
+        }
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for WasmValueType {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+impl TryFrom<wasmer::Type> for WasmValueType {
+    type Error = ();
+    fn try_from(value: wasmer::Type) -> Result<Self, Self::Error> {
+        match value {
+            wasmer::Type::I32 => Ok(Self::I32),
+            wasmer::Type::I64 => Ok(Self::I64),
+            wasmer::Type::F32 => Ok(Self::F32),
+            wasmer::Type::F64 => Ok(Self::F64),
+            wasmer::Type::V128 => Ok(Self::V128),
+            _ => Err(()),
+        }
+    }
+}
+impl From<WasmValueType> for wasmer::Type {
+    fn from(value: WasmValueType) -> Self {
+        match value {
+            WasmValueType::I32 => Self::I32,
+            WasmValueType::I64 => Self::I64,
+            WasmValueType::F32 => Self::F32,
+            WasmValueType::F64 => Self::F64,
+            WasmValueType::V128 => Self::V128,
+        }
+    }
+}
+
+#[doc = " A structure representing the reflection information for a function signature"]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ReflectionResult {
+    #[doc = " Whether the result is cacheable"]
+    pub cacheable: Bool,
+    #[doc = " Number of arguments the function takes"]
+    pub arguments: u16,
+    #[doc = " Number of results the function returns"]
+    pub results: u16,
+}
+
+unsafe impl wasmer_types::ValueType for ReflectionResult {
+    #[inline]
+    fn zero_padding_bytes(&self, bytes: &mut [MaybeUninit<u8>]) {
+        bytes[1].write(0);
+    }
+}
+
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct AddrUnspec {
@@ -2739,6 +2943,12 @@ unsafe impl wasmer::FromToNativeWasmType for Advice {
     }
 }
 
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Fdflagsext {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
 // TODO: if necessary, must be implemented in wit-bindgen
 unsafe impl ValueType for Fdflags {
     #[inline]
diff --git a/lib/wasi-types/src/wasi/bindings_manual.rs b/lib/wasi-types/src/wasi/bindings_manual.rs
index 4d93bf820c..5130cb2277 100644
--- a/lib/wasi-types/src/wasi/bindings_manual.rs
+++ b/lib/wasi-types/src/wasi/bindings_manual.rs
@@ -155,7 +155,7 @@ impl std::fmt::Display for Sockoption {
             Self::Type => "Sockoption::Type",
             Self::Proto => "Sockoption::Proto",
         };
-        write!(f, "{}", s)
+        write!(f, "{s}")
     }
 }
 
@@ -166,6 +166,25 @@ unsafe impl wasmer::FromToNativeWasmType for Fdflags {
     fn to_native(self) -> Self::Native {
         self.bits() as i32
     }
+
+    fn from_native(n: Self::Native) -> Self {
+        Self::from_bits_truncate(n as u16)
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        // TODO: find correct implementation
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl wasmer::FromToNativeWasmType for Fdflagsext {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self.bits() as i32
+    }
+
     fn from_native(n: Self::Native) -> Self {
         Self::from_bits_truncate(n as u16)
     }
@@ -372,3 +391,21 @@ unsafe impl wasmer::FromToNativeWasmType for JoinFlags {
         false
     }
 }
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl wasmer::FromToNativeWasmType for DlFlags {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self.bits() as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        Self::from_bits_truncate(n as u32)
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        // TODO: find correct implementation
+        false
+    }
+}
diff --git a/lib/wasi-types/src/wasi/wasix_manual.rs b/lib/wasi-types/src/wasi/wasix_manual.rs
index b8ee2e53d8..20f1a39cd1 100644
--- a/lib/wasi-types/src/wasi/wasix_manual.rs
+++ b/lib/wasi-types/src/wasi/wasix_manual.rs
@@ -5,8 +5,9 @@ use std::mem::MaybeUninit;
 use wasmer::{FromToNativeWasmType, MemorySize, ValueType};
 
 use super::{
-    Errno, ErrnoSignal, EventFdReadwrite, Eventtype, Fd, JoinStatusType, Signal,
-    Snapshot0SubscriptionClock, SubscriptionClock, SubscriptionFsReadwrite, Userdata,
+    Errno, ErrnoSignal, EventFdReadwrite, Eventtype, Fd, JoinStatusType, ProcSpawnFdOp, Signal,
+    SignalDisposition, Snapshot0SubscriptionClock, SubscriptionClock, SubscriptionFsReadwrite,
+    Userdata,
 };
 
 /// Thread local key
@@ -108,7 +109,31 @@ pub union EventUnion {
 #[repr(C)]
 pub struct StackSnapshot {
     pub user: u64,
-    pub hash: u128,
+    // The hash is defined as two u64s in wasix-libc, so we must do the same
+    // here to make sure the alignment and padding are the same.
+    pub hash_lower: u64,
+    pub hash_upper: u64,
+}
+
+impl StackSnapshot {
+    pub fn new(user: u64, hash: u128) -> Self {
+        Self {
+            user,
+            hash_lower: (hash & 0xffff_ffff_ffff_ffff) as u64,
+            hash_upper: (hash >> 64) as u64,
+        }
+    }
+
+    pub fn hash(&self) -> u128 {
+        ((self.hash_upper as u128) << 64) | (self.hash_lower as u128)
+    }
+}
+
+#[test]
+fn snapshot_hash_roundtrip() {
+    let hash = 0x1234_5678_90ab_cdef_0987_6543_fedc_ba12;
+    let snapshot = StackSnapshot::new(0, hash);
+    assert_eq!(snapshot.hash(), hash);
 }
 
 /// An event that occurred.
@@ -250,16 +275,11 @@ unsafe impl<M: MemorySize> ValueType for ThreadStart<M> {
 
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-pub enum ExitCode {
-    Errno(Errno),
-    Other(i32),
-}
+pub struct ExitCode(u16);
+
 impl ExitCode {
     pub fn raw(&self) -> i32 {
-        match self {
-            ExitCode::Errno(err) => err.to_native(),
-            ExitCode::Other(code) => *code,
-        }
+        self.0 as i32
     }
 
     pub fn is_success(&self) -> bool {
@@ -268,10 +288,7 @@ impl ExitCode {
 }
 impl core::fmt::Debug for ExitCode {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        match self {
-            ExitCode::Errno(a) => write!(f, "ExitCode::{}", a),
-            ExitCode::Other(a) => write!(f, "ExitCode::{}", a),
-        }
+        write!(f, "ExitCode::{}", self.0)
     }
 }
 impl core::fmt::Display for ExitCode {
@@ -298,35 +315,31 @@ unsafe impl wasmer::FromToNativeWasmType for ExitCode {
 
 impl From<Errno> for ExitCode {
     fn from(val: Errno) -> Self {
-        Self::Errno(val)
+        Self((val.to_native() % 256) as u16)
     }
 }
 
 impl From<i32> for ExitCode {
     fn from(val: i32) -> Self {
-        let err = Errno::from_native(val);
-        match err {
-            Errno::Unknown => Self::Other(val),
-            err => Self::Errno(err),
-        }
+        Self((val % 256) as u16)
+    }
+}
+
+impl From<u16> for ExitCode {
+    fn from(value: u16) -> Self {
+        Self(value)
     }
 }
 
 impl From<ExitCode> for Errno {
     fn from(code: ExitCode) -> Self {
-        match code {
-            ExitCode::Errno(err) => err,
-            ExitCode::Other(code) => Errno::from_native(code),
-        }
+        Errno::from_native(code.0 as i32)
     }
 }
 
 impl From<ExitCode> for i32 {
     fn from(val: ExitCode) -> Self {
-        match val {
-            ExitCode::Errno(err) => err.to_native(),
-            ExitCode::Other(code) => code,
-        }
+        val.0 as i32
     }
 }
 
@@ -493,3 +506,13 @@ where
     #[inline]
     fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
 }
+
+unsafe impl ValueType for SignalDisposition {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl<M: MemorySize> ValueType for ProcSpawnFdOp<M> {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
diff --git a/lib/wasi-types/src/wasix/mod.rs b/lib/wasi-types/src/wasix/mod.rs
index 8f601ed578..7a5bb83a26 100644
--- a/lib/wasi-types/src/wasix/mod.rs
+++ b/lib/wasi-types/src/wasix/mod.rs
@@ -26,4 +26,9 @@ pub struct WasiMemoryLayout {
     pub guard_size: u64,
     /// Total size of the stack
     pub stack_size: u64,
+    /// Pointer to the thread's TLS (Thread Local Storage) memory, only filled in when it's known.
+    /// This is mainly used by the dynamic linker; especially so since we can't even find the TLS
+    /// area for a non-PIE module that doesn't export its __tls_base. For DL modules, this is the
+    /// TLS base of the main module.
+    pub tls_base: Option<u64>,
 }
diff --git a/lib/wasix/Cargo.toml b/lib/wasix/Cargo.toml
index 0e8b2fb289..ac8254cd10 100644
--- a/lib/wasix/Cargo.toml
+++ b/lib/wasix/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "wasmer-wasix"
-version = "0.27.0"
+version = "0.601.0"
 description = "WASI and WASIX implementation library for Wasmer WebAssembly runtime"
 categories = ["wasm", "os"]
 keywords = ["wasm", "webassembly", "wasi", "sandbox", "ABI"]
@@ -13,105 +13,124 @@ repository.workspace = true
 rust-version.workspace = true
 
 [dependencies]
-wasmer-wasix-types = { path = "../wasi-types", version = "0.27.0", features = [ "enable-serde" ] }
-wasmer-types = { path = "../types", version = "=4.3.7", default-features = false }
-wasmer = { path = "../api", version = "=4.3.7", default-features = false, features = ["wat", "js-serializable-module"] }
-virtual-mio  = { path = "../virtual-io", version = "0.3.1", default-features = false }
-virtual-fs = { path = "../virtual-fs", version = "0.16.0", default-features = false, features = ["webc-fs"] }
-virtual-net = { path = "../virtual-net", version = "0.8.0", default-features = false, features = ["rkyv"] }
-wasmer-journal = { path = "../journal", version = "0.9.0", default-features = false }
-wasmer-emscripten = { path = "../emscripten", version = "=4.3.7", optional = true }
-wasmer-config = { version = "0.8.0", path = "../config" }
+wasmer-package.workspace = true
+wasmer-wasix-types = { path = "../wasi-types", version = "0.601.0", features = [
+	"enable-serde",
+] }
+wasmer-types = { path = "../types", version = "=6.1.0", default-features = false }
+wasmer = { path = "../api", version = "=6.1.0", default-features = false }
+virtual-mio = { path = "../virtual-io", version = "0.601.0", default-features = false }
+virtual-fs = { path = "../virtual-fs", version = "0.601.0", default-features = false, features = [
+	"webc-fs",
+] }
+virtual-net = { path = "../virtual-net", version = "0.601.0", default-features = false, features = [
+	"rkyv",
+] }
+wasmer-journal = { path = "../journal", version = "0.601.0", default-features = false }
+wasmer-config = { version = "0.601.0", path = "../config" }
 
 http.workspace = true
 dashmap.workspace = true
+base64.workspace = true
+webc.workspace = true
+serde_yaml.workspace = true
+rkyv.workspace = true
+shared-buffer.workspace = true
+hyper = { workspace = true, features = ["server"], optional = true }
+derive_more.workspace = true
+wasm-encoder.workspace = true
+
 xxhash-rust = { version = "0.8.8", features = ["xxh64"] }
 rusty_pool = { version = "0.7.0", optional = true }
-cfg-if = "1.0"
-thiserror = "1"
-tracing = { version = "0.1.37" }
-getrandom = "0.2"
+cfg-if.workspace = true
+thiserror.workspace = true
+tracing.workspace = true
+getrandom.workspace = true
 typetag = { version = "0.1", optional = true }
-serde = { version = "1.0", default-features = false, features = ["derive"] }
+serde = { workspace = true, default-features = false, features = ["derive"] }
 bincode = { version = "1.3" }
-chrono = { version = "^0.4.31", default-features = false, features = [ "wasmbind", "std", "clock" ], optional = true }
-derivative = { version = "^2" }
-bytes = "1"
-webc = { workspace = true }
-anyhow = { version = "1.0.66" }
-lazy_static = "1.4"
-sha2 = { version = "0.10" }
+chrono = { version = "^0.4.38", default-features = false, features = [
+	"wasmbind",
+	"std",
+	"clock",
+], optional = true }
+bytes.workspace = true
+anyhow.workspace = true
+sha2.workspace = true
 waker-fn = { version = "1.1" }
 cooked-waker = "^5"
 rand = "0.8"
-tokio = { version = "1", features = [
-    "sync",
-    "macros",
-    "time",
-    "rt",
+tokio = { workspace = true, features = [
+	"sync",
+	"macros",
+	"time",
+	"rt",
 ], default-features = false }
-tokio-stream = { version = "0.1", features = [ "sync" ] }
+tokio-stream = { version = "0.1", features = ["sync"] }
 futures = { version = "0.3" }
 # used by feature='os'
-async-trait = { version = "^0.1" }
+async-trait = { workspace = true }
 urlencoding = { version = "^2" }
 serde_derive = { version = "^1" }
-serde_json = { version = "^1" }
-serde_yaml.workspace = true
+serde_json.workspace = true
 weezl = { version = "^0.1" }
-hex = { version = "^0.4" }
+hex.workspace = true
 linked_hash_set = { version = "0.1" }
-heapless = "0.7.16"
-once_cell = "1.17.0"
+heapless = "0.8"
+once_cell.workspace = true
 pin-project = "1.0.12"
-semver = "1.0.17"
-tempfile = "3.6.0"
-num_enum = "0.5.7"
+semver.workspace = true
+tempfile.workspace = true
+num_enum.workspace = true
 # Used by the WCGI runner
-hyper = { workspace = true, features = ["server"], optional = true }
-wcgi = { version = "0.2.0", optional = true }
-wcgi-host = { version = "0.2.0", optional = true }
+wcgi = { version = "0.3.0", optional = true }
+wcgi-host = { version = "0.3.0", optional = true }
 tower-http = { version = "0.5.0", features = [
-    "trace",
-    "util",
-    "catch-panic",
-    "cors",
+	"trace",
+	"util",
+	"catch-panic",
+	"cors",
 ], optional = true }
 tower = { version = "0.4.13", features = ["make", "util"], optional = true }
-url = "2.3.1"
-rkyv = { workspace = true }
-bytecheck = "0.6.8"
-blake3 = "1.0"
-shared-buffer = { workspace = true }
-petgraph = "0.6.3"
-base64 = "0.21"
+url.workspace = true
+bytecheck.workspace = true
+blake3.workspace = true
+petgraph = "0.7.0"
 lz4_flex = { version = "0.11" }
-rayon = { version = "1.7.0", optional = true }
+rayon = { workspace = true, optional = true }
 wasm-bindgen = { version = "0.2.87", optional = true }
 js-sys = { version = "0.3.64", optional = true }
 wasm-bindgen-futures = { version = "0.4.37", optional = true }
 web-sys = { version = "0.3.64", features = [
-    "Request",
-    "RequestInit",
-    "Window",
-    "WorkerGlobalScope",
-    "RequestMode",
-    "Response",
-    "Headers",
+	"Request",
+	"RequestInit",
+	"Window",
+	"WorkerGlobalScope",
+	"RequestMode",
+	"Response",
+	"Headers",
+], optional = true }
+hyper-util = { workspace = true, features = [
+	"server",
+	"server-graceful",
+	"tokio",
+	"service",
+	"client",
 ], optional = true }
-ahash = "0.8.11"
-hyper-util = { version = "0.1.5", features = ["server", "server-graceful", "tokio", "service", "client"], optional = true }
-http-body-util = { version="0.1.1", optional = true }
-toml = "0.8"
+http-body-util = { workspace = true, optional = true }
+toml.workspace = true
 pin-utils = "0.1.0"
+wasmparser = { workspace = true }
+crossbeam-channel = "0.5.15"
+bus = "2.4.1"
 
-[target.'cfg(not(target_arch = "riscv64"))'.dependencies.reqwest]
+[target.'cfg(not(any(target_arch = "riscv64", target_arch = "loongarch64")))'.dependencies.reqwest]
 workspace = true
 default-features = false
 features = ["rustls-tls", "json", "stream", "socks", "blocking"]
 optional = true
 
-[target.'cfg(target_arch = "riscv64")'.dependencies.reqwest]
+[target.'cfg(any(target_arch = "riscv64", target_arch = "loongarch64"))'.dependencies.reqwest]
 workspace = true
 default-features = false
 features = ["native-tls", "json", "stream", "socks", "blocking"]
@@ -124,25 +143,41 @@ libc.workspace = true
 termios = { version = "0.3" }
 
 [target.'cfg(windows)'.dependencies]
-windows-sys = { version = "0.59", features = ["Win32_System_SystemInformation"] }
+windows-sys = { version = "0.59", features = [
+	"Win32_System_SystemInformation",
+] }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 terminal_size = { version = "0.3.0" }
 
 [dev-dependencies]
-wasmer = { path = "../api", version = "=4.3.7", default-features = false, features = ["wat", "js-serializable-module"] }
-tokio = { version = "1", features = [ "sync", "macros", "rt" ], default-features = false }
-pretty_assertions = "1.3.0"
-tracing-test = "0.2.4"
+wasmer = { path = "../api", version = "=6.1.0", default-features = false, features = [
+	"wat",
+	"js-serializable-module",
+] }
+tokio = { workspace = true, features = [
+	"sync",
+	"macros",
+	"rt",
+], default-features = false }
+pretty_assertions.workspace = true
+tracing-test.workspace = true
 wasm-bindgen-test = "0.3.0"
+env_logger = { version = "0.11.5", default-features = false }
+log.workspace = true
+assert-panic = "1.0.1"
 
 [target.'cfg(target_arch = "wasm32")'.dev-dependencies]
 wasm-bindgen-test = "0.3.0"
 tracing-wasm = "0.2"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
-tracing-subscriber = { version = "^0.3" }
-wasmer = { path = "../api", version = "=4.3.7", default-features = false, features = ["wat", "js-serializable-module", "cranelift"] }
+tracing-subscriber = { workspace = true}
+wasmer = { path = "../api", version = "=6.1.0", default-features = false, features = [
+	"wat",
+	"js-serializable-module",
+	"cranelift",
+] }
 
 [features]
 default = ["sys-default"]
@@ -150,24 +185,43 @@ default = ["sys-default"]
 time = ["tokio/time"]
 ctrlc = ["tokio/signal"]
 
-webc_runner_rt_wcgi = ["hyper", "hyper-util", "http-body-util", "wcgi", "wcgi-host", "tower", "tower-http"]
+webc_runner_rt_wcgi = [
+	"hyper",
+	"hyper-util",
+	"http-body-util",
+	"wcgi",
+	"wcgi-host",
+	"tower",
+	"tower-http",
+]
 webc_runner_rt_dcgi = ["webc_runner_rt_wcgi", "journal"]
-webc_runner_rt_dproxy = ["hyper", "hyper-util", "http-body-util", "tower", "tower-http", "journal"]
-webc_runner_rt_emscripten = ["wasmer-emscripten"]
-
-sys = ["webc/mmap", "time", "virtual-mio/sys"]
-sys-default = [
-    "sys",
-    "logging",
-    "host-fs",
-    "journal",
-    "sys-poll",
-    "sys-thread",
-    "host-vnet",
-    "host-threads",
-    "host-reqwest",
-    "ctrlc"
+webc_runner_rt_dproxy = [
+	"hyper",
+	"hyper-util",
+	"http-body-util",
+	"tower",
+	"tower-http",
+	"journal",
+]
+# the minimal sys implementation
+sys-minimal = ["wasmer/sys", "sys-thread", "tokio/fs"]
+sys = [
+	"webc/mmap",
+	"time",
+	"virtual-mio/sys",
+	"logging",
+	"host-fs",
+	"journal",
+	"sys-poll",
+	"sys-thread",
+	"host-vnet",
+	"host-threads",
+	"host-reqwest",
+	"ctrlc",
+	"wasmer/wat",
+	"wasmer/js-serializable-module",
 ]
+sys-default = ["sys", "wasmer/sys"]
 sys-poll = []
 extra-logging = []
 sys-thread = ["tokio/rt", "tokio/time", "tokio/rt-multi-thread", "rusty_pool"]
@@ -177,13 +231,17 @@ journal = ["tokio/fs", "wasmer-journal/log-file"]
 compiler = []
 
 js = [
-    "virtual-fs/no-time",
-    "getrandom/js",
-    "chrono",
-    "js-sys",
-    "wasm-bindgen",
-    "wasm-bindgen-futures",
-    "web-sys",
+	"virtual-fs/js",
+	"getrandom/js",
+	"chrono",
+	"js-sys",
+	"wasm-bindgen",
+	"wasm-bindgen-futures",
+	"web-sys",
+	"wasmer/js-default",
+	"wasmer/wasm-types-polyfill",
+	"wasmer/wat",
+	"wasmer/js-serializable-module",
 ]
 js-default = ["js"]
 test-js = ["js", "wasmer/wat"]
@@ -197,18 +255,19 @@ remote-vnet = ["virtual-net/remote"]
 logging = ["tracing/log"]
 disable-all-logging = ["tracing/release_max_level_off", "tracing/max_level_off"]
 enable-serde = [
-    "typetag",
-    "virtual-fs/enable-serde",
-    "wasmer-wasix-types/enable-serde",
+	"typetag",
+	"virtual-fs/enable-serde",
+	"wasmer-wasix-types/enable-serde",
+	"wasmer/enable-serde",
 ]
 
 [package.metadata.docs.rs]
 features = [
-    "wasmer/sys",
-    "webc_runner_rt_wcgi",
-    "webc_runner_rt_dcgi",
-    "webc_runner_rt_dproxy",
-    "webc_runner_rt_emscripten",
-    "sys-default",
+	"wasmer/sys",
+	"wasmer/compiler",
+	"webc_runner_rt_wcgi",
+	"webc_runner_rt_dcgi",
+	"webc_runner_rt_dproxy",
+	"sys-default",
 ]
 rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/wasix/README.md b/lib/wasix/README.md
index 74f875a968..a26e86eaa8 100644
--- a/lib/wasix/README.md
+++ b/lib/wasix/README.md
@@ -1,4 +1,4 @@
-# `wasmer-wasi` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE) [![crates.io](https://img.shields.io/crates/v/wasmer-wasi.svg)](https://crates.io/crates/wasmer-wasi)
+# `wasmer-wasi` [![Build Status](https://github.com/wasmerio/wasmer/actions/workflows/build.yml/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/main/LICENSE) [![crates.io](https://img.shields.io/crates/v/wasmer-wasi.svg)](https://crates.io/crates/wasmer-wasi)
 
 This crate provides the necessary imports to use WASI easily from Wasmer.
 [WebAssembly System Interface](https://github.com/WebAssembly/WASI)
@@ -8,7 +8,7 @@ is being standardized in the WebAssembly subgroup.
 Very succinctly, from the user perspective, WASI is a set of
 WebAssembly module _imports_ under a specific _namespace_ (which
 varies based on the WASI version). A program compiled for the
-`wasm32-wasi` target will be able to support standard I/O, file I/O,
+`wasm32-wasip1` target will be able to support standard I/O, file I/O,
 filesystem manipulation, memory management, time, string, environment
 variables, program startup etc.
 
@@ -47,7 +47,7 @@ fn main() {
 Then, let's compile it to a WebAssembly module with WASI support:
 
 ```sh
-$ rustc --target wasm32-wasi hello.rs
+$ rustc --target wasm32-wasip1 hello.rs
 ```
 
 Finally, let's execute it with the `wasmer` CLI:
@@ -60,27 +60,37 @@ Hello, Some("Gordon")
 … and programatically with the `wasmer` and the `wasmer-wasi` libraries:
 
 ```rust
-use wasmer::{Store, Module, Instance};
-use wasmer_wasix::WasiState;
+use std::io::Read;
+use wasmer::{Module, Store};
+use wasmer_wasix::{Pipe, WasiEnv};
 
+let wasm_path = "hello.wasm";
+
+// Let's declare the Wasm module with the text representation.
+let wasm_bytes = std::fs::read(wasm_path)?;
+
+// Create a Store.
 let mut store = Store::default();
-let module = Module::from_file(&store, "hello.wasm")?;
 
-// Create the `WasiEnv`.
-let wasi_env = WasiState::builder("command-name")
-    .args(&["Gordon"])
-    .finalize()?;
+println!("Compiling module...");
+// Let's compile the Wasm module.
+let module = Module::new(&store, wasm_bytes)?;
+
+let (stdout_tx, mut stdout_rx) = Pipe::channel();
+
+// Run the module.
+WasiEnv::builder("hello")
+     .args(&["Gordon"])
+    // .env("KEY", "Value")
+    .stdout(Box::new(stdout_tx))
+    .run_with_store(module, &mut store)?;
 
-// Generate an `ImportObject`.
-let mut wasi_thread = wasi_env.new_thread();
-let import_object = wasi_thread.import_object(&module)?;
+eprintln!("Run complete - reading output");
 
-// Let's instantiate the module with the imports.
-let instance = Instance::new(&module, &import_object)?;
+let mut buf = String::new();
+stdout_rx.read_to_string(&mut buf).unwrap();
 
-// Let's call the `_start` function, which is our `main` function in Rust.
-let start = instance.exports.get_function("_start")?;
-start.call(&[])?;
+eprintln!("Output: {buf}");
 ```
 
 Check the [fully working example using
diff --git a/lib/wasix/src/bin_factory/binary_package.rs b/lib/wasix/src/bin_factory/binary_package.rs
index 4fcf040541..6688c712b9 100644
--- a/lib/wasix/src/bin_factory/binary_package.rs
+++ b/lib/wasix/src/bin_factory/binary_package.rs
@@ -1,12 +1,15 @@
 use std::{path::Path, sync::Arc};
 
 use anyhow::Context;
-use derivative::*;
 use once_cell::sync::OnceCell;
 use sha2::Digest;
 use virtual_fs::FileSystem;
-use wasmer_config::package::{PackageHash, PackageId, PackageSource};
-use webc::{compat::SharedBytes, Container};
+use wasmer_config::package::{
+    PackageHash, PackageId, PackageSource, SuggestedCompilerOptimizations,
+};
+use wasmer_package::package::Package;
+use webc::compat::SharedBytes;
+use webc::Container;
 
 use crate::{
     runners::MappedDirectory,
@@ -15,14 +18,15 @@ use crate::{
 };
 use wasmer_types::ModuleHash;
 
-#[derive(Derivative, Clone)]
-#[derivative(Debug)]
+#[derive(derive_more::Debug, Clone)]
 pub struct BinaryPackageCommand {
     name: String,
     metadata: webc::metadata::Command,
-    #[derivative(Debug = "ignore")]
+    #[debug(ignore)]
     pub(crate) atom: SharedBytes,
     hash: ModuleHash,
+    features: Option<wasmer_types::Features>,
+    pub suggested_compiler_optimizations: SuggestedCompilerOptimizations,
 }
 
 impl BinaryPackageCommand {
@@ -31,12 +35,16 @@ impl BinaryPackageCommand {
         metadata: webc::metadata::Command,
         atom: SharedBytes,
         hash: ModuleHash,
+        features: Option<wasmer_types::Features>,
+        suggested_compiler_optimizations: SuggestedCompilerOptimizations,
     ) -> Self {
         Self {
             name,
             metadata,
             atom,
             hash,
+            features,
+            suggested_compiler_optimizations,
         }
     }
 
@@ -48,22 +56,30 @@ impl BinaryPackageCommand {
         &self.metadata
     }
 
-    /// Get a reference to this [`BinaryPackageCommand`]'s atom.
-    ///
-    /// The address of the returned slice is guaranteed to be stable and live as
-    /// long as the [`BinaryPackageCommand`].
-    pub fn atom(&self) -> &[u8] {
-        &self.atom
+    /// Get a reference to this [`BinaryPackageCommand`]'s atom as a cheap
+    /// clone of the internal OwnedBuffer.
+    pub fn atom(&self) -> SharedBytes {
+        self.atom.clone()
     }
 
     pub fn hash(&self) -> &ModuleHash {
         &self.hash
     }
+
+    /// Get the WebAssembly features required by this command's module
+    pub fn wasm_features(&self) -> Option<wasmer_types::Features> {
+        // Return only the pre-computed features from the container manifest
+        if let Some(features) = &self.features {
+            return Some(features.clone());
+        }
+
+        // If no annotations were found, return None
+        None
+    }
 }
 
 /// A WebAssembly package that has been loaded into memory.
-#[derive(Derivative, Clone)]
-#[derivative(Debug)]
+#[derive(Debug, Clone)]
 pub struct BinaryPackage {
     pub id: PackageId,
     /// Includes the ids of all the packages in the tree
@@ -96,7 +112,7 @@ impl BinaryPackage {
         let id = PackageId::Hash(PackageHash::from_sha256_bytes(hash));
 
         let manifest_path = dir.join("wasmer.toml");
-        let webc = webc::wasmer_package::Package::from_manifest(&manifest_path)?;
+        let webc = Package::from_manifest(&manifest_path)?;
         let container = Container::from(webc);
         let manifest = container.manifest();
 
@@ -205,10 +221,10 @@ impl BinaryPackage {
 
     /// Get the bytes for the entrypoint command.
     #[deprecated(
-        note = "Use BinaryPackage::get_entrypoint_cmd instead",
+        note = "Use BinaryPackage::get_entrypoint_command instead",
         since = "0.22.0"
     )]
-    pub fn entrypoint_bytes(&self) -> Option<&[u8]> {
+    pub fn entrypoint_bytes(&self) -> Option<SharedBytes> {
         self.get_entrypoint_command().map(|entry| entry.atom())
     }
 
@@ -224,6 +240,25 @@ impl BinaryPackage {
             }
         })
     }
+
+    pub fn infer_entrypoint(&self) -> Result<&str, anyhow::Error> {
+        if let Some(entrypoint) = self.entrypoint_cmd.as_deref() {
+            return Ok(entrypoint);
+        }
+
+        match self.commands.as_slice() {
+            [] => anyhow::bail!("The package doesn't contain any executable commands"),
+            [one] => Ok(one.name()),
+            [..] => {
+                let mut commands: Vec<_> = self.commands.iter().map(|cmd| cmd.name()).collect();
+                commands.sort();
+                anyhow::bail!(
+                    "Unable to determine the package's entrypoint. Please choose one of {:?}",
+                    commands,
+                );
+            }
+        }
+    }
 }
 
 #[cfg(test)]
@@ -231,6 +266,7 @@ mod tests {
     use sha2::Digest;
     use tempfile::TempDir;
     use virtual_fs::AsyncReadExt;
+    use wasmer_package::utils::from_disk;
 
     use crate::{
         runtime::{package_loader::BuiltinPackageLoader, task_manager::VirtualTaskManager},
@@ -278,12 +314,12 @@ mod tests {
                 .with_shared_http_client(runtime.http_client().unwrap().clone()),
         );
 
-        let pkg = webc::wasmer_package::Package::from_manifest(&manifest).unwrap();
+        let pkg = Package::from_manifest(&manifest).unwrap();
         let data = pkg.serialize().unwrap();
         let webc_path = temp.path().join("package.webc");
         std::fs::write(&webc_path, data).unwrap();
 
-        let pkg = BinaryPackage::from_webc(&Container::from_disk(&webc_path).unwrap(), &runtime)
+        let pkg = BinaryPackage::from_webc(&from_disk(&webc_path).unwrap(), &runtime)
             .await
             .unwrap();
 
@@ -328,9 +364,7 @@ mod tests {
         let atom_path = temp.path().join("foo.wasm");
         std::fs::write(&atom_path, b"").unwrap();
 
-        let webc: Container = webc::wasmer_package::Package::from_manifest(&manifest)
-            .unwrap()
-            .into();
+        let webc: Container = Package::from_manifest(&manifest).unwrap().into();
 
         let tasks = task_manager();
         let mut runtime = PluggableRuntime::new(tasks);
diff --git a/lib/wasix/src/bin_factory/exec.rs b/lib/wasix/src/bin_factory/exec.rs
index 2dd675796f..947d76b60e 100644
--- a/lib/wasix/src/bin_factory/exec.rs
+++ b/lib/wasix/src/bin_factory/exec.rs
@@ -6,6 +6,7 @@ use crate::{
         TaskJoinHandle,
     },
     runtime::{
+        module_cache::HashedModuleData,
         task_manager::{
             TaskWasm, TaskWasmRecycle, TaskWasmRecycleProperties, TaskWasmRunProperties,
         },
@@ -15,69 +16,80 @@ use crate::{
     RewindState, SpawnError, WasiError, WasiRuntimeError,
 };
 use tracing::*;
-use wasmer::{Function, Memory32, Memory64, Module, Store};
+use virtual_mio::InlineWaker;
+use wasmer::{Function, Memory32, Memory64, Module, RuntimeError, Store, Value};
 use wasmer_wasix_types::wasi::Errno;
 
-use super::BinaryPackage;
+use super::{BinaryPackage, BinaryPackageCommand};
 use crate::{Runtime, WasiEnv, WasiFunctionEnv};
 
 #[tracing::instrument(level = "trace", skip_all, fields(%name, package_id=%binary.id))]
 pub async fn spawn_exec(
     binary: BinaryPackage,
     name: &str,
-    _store: Store,
     env: WasiEnv,
     runtime: &Arc<dyn Runtime + Send + Sync + 'static>,
 ) -> Result<TaskJoinHandle, SpawnError> {
     spawn_union_fs(&env, &binary).await?;
 
-    let wasm = spawn_load_wasm(&env, &binary, name).await?;
+    let cmd = package_command_by_name(&binary, name)?;
+    let module = runtime.load_command_module(cmd).await?;
 
-    spawn_exec_wasm(wasm, name, env, runtime).await
+    // Free the space used by the binary, since we don't need it
+    // any longer
+    drop(binary);
+
+    spawn_exec_module(module, env, runtime)
 }
 
 #[tracing::instrument(level = "trace", skip_all, fields(%name))]
 pub async fn spawn_exec_wasm(
-    wasm: &[u8],
+    wasm: HashedModuleData,
     name: &str,
     env: WasiEnv,
     runtime: &Arc<dyn Runtime + Send + Sync + 'static>,
 ) -> Result<TaskJoinHandle, SpawnError> {
-    let module = spawn_load_module(&env, name, wasm, runtime).await?;
+    let module = spawn_load_module(name, wasm, runtime).await?;
 
     spawn_exec_module(module, env, runtime)
 }
 
-pub async fn spawn_load_wasm<'a>(
-    env: &WasiEnv,
-    binary: &'a BinaryPackage,
+pub fn package_command_by_name<'a>(
+    pkg: &'a BinaryPackage,
     name: &str,
-) -> Result<&'a [u8], SpawnError> {
-    let wasm = if let Some(cmd) = binary.get_command(name) {
-        cmd.atom.as_ref()
-    } else if let Some(cmd) = binary.get_entrypoint_command() {
-        &cmd.atom
+) -> Result<&'a BinaryPackageCommand, SpawnError> {
+    // If an explicit command is provided, use it.
+    // Otherwise, use the entrypoint.
+    // If no entrypoint exists, and the package has a single
+    // command, then use it. This is done for backwards
+    // compatibility.
+    let cmd = if let Some(cmd) = pkg.get_command(name) {
+        cmd
+    } else if let Some(cmd) = pkg.get_entrypoint_command() {
+        cmd
     } else {
-        tracing::error!(
-          command=name,
-          pkg=%binary.id,
-          "Unable to spawn a command because its package has no entrypoint",
-        );
-        env.on_exit(Some(Errno::Noexec.into())).await;
-        return Err(SpawnError::MissingEntrypoint {
-            package_id: binary.id.clone(),
-        });
+        match pkg.commands.as_slice() {
+            // Package only has a single command, so use it.
+            [first] => first,
+            // Package either has no command, or has multiple commands, which
+            // would make the choice ambiguous, so fail.
+            _ => {
+                return Err(SpawnError::MissingEntrypoint {
+                    package_id: pkg.id.clone(),
+                });
+            }
+        }
     };
-    Ok(wasm)
+
+    Ok(cmd)
 }
 
 pub async fn spawn_load_module(
-    env: &WasiEnv,
     name: &str,
-    wasm: &[u8],
+    wasm: HashedModuleData,
     runtime: &Arc<dyn Runtime + Send + Sync + 'static>,
 ) -> Result<Module, SpawnError> {
-    match runtime.load_module(wasm).await {
+    match runtime.load_hashed_module(wasm, None).await {
         Ok(module) => Ok(module),
         Err(err) => {
             tracing::error!(
@@ -85,7 +97,6 @@ pub async fn spawn_load_module(
                 error = &err as &dyn std::error::Error,
                 "Failed to compile the module",
             );
-            env.on_exit(Some(Errno::Noexec.into())).await;
             Err(err)
         }
     }
@@ -125,10 +136,18 @@ pub fn spawn_exec_module(
         let tasks_outer = tasks.clone();
 
         tasks_outer
-            .task_wasm(TaskWasm::new(Box::new(run_exec), env, module, true))
+            .task_wasm(
+                TaskWasm::new(Box::new(run_exec), env, module, true, true).with_pre_run(Box::new(
+                    |ctx, store| {
+                        Box::pin(async move {
+                            ctx.data(store).state.fs.close_cloexec_fds().await;
+                        })
+                    },
+                )),
+            )
             .map_err(|err| {
                 error!("wasi[{}]::failed to launch module - {}", pid, err);
-                SpawnError::UnknownError
+                SpawnError::Other(Box::new(err))
             })?
     };
 
@@ -167,7 +186,10 @@ pub fn run_exec(props: TaskWasmRunProperties) {
     // Perform the initialization
     let ctx = {
         // If this module exports an _initialize function, run that first.
-        if let Ok(initialize) = unsafe { ctx.data(&store).inner() }
+        if let Ok(initialize) = ctx
+            .data(&store)
+            .inner()
+            .main_module_instance_handles()
             .instance
             .exports
             .get_function("_initialize")
@@ -209,11 +231,13 @@ pub fn run_exec(props: TaskWasmRunProperties) {
 }
 
 fn get_start(ctx: &WasiFunctionEnv, store: &Store) -> Option<Function> {
-    unsafe { ctx.data(store).inner() }
+    ctx.data(store)
+        .inner()
+        .main_module_instance_handles()
         .instance
         .exports
         .get_function("_start")
-        .map(|a| a.clone())
+        .cloned()
         .ok()
 }
 
@@ -266,9 +290,7 @@ fn call_module(
     // Invoke the start function
     let ret = {
         // Call the module
-        let call_ret = if let Some(start) = get_start(&ctx, &store) {
-            start.call(&mut store, &[])
-        } else {
+        let Some(start) = get_start(&ctx, &store) else {
             debug!("wasi[{}]::exec-failed: missing _start function", pid);
             ctx.data(&store)
                 .blocking_on_exit(Some(Errno::Noexec.into()));
@@ -276,9 +298,29 @@ fn call_module(
             return;
         };
 
+        let mut call_ret = start.call(&mut store, &[]);
+
+        loop {
+            // Technically, it's an error for a vfork to return from main, but anyway...
+            match resume_vfork(&ctx, &mut store, &start, &call_ret) {
+                // A vfork was resumed, there may be another, so loop back
+                Ok(Some(ret)) => call_ret = ret,
+
+                // An error was encountered when restoring from the vfork, report it
+                Err(e) => {
+                    call_ret = Err(RuntimeError::user(Box::new(WasiError::Exit(e.into()))));
+                    break;
+                }
+
+                // No vfork, keep the call_ret value
+                Ok(None) => break,
+            }
+        }
+
         if let Err(err) = call_ret {
             match err.downcast::<WasiError>() {
                 Ok(WasiError::Exit(code)) if code.is_success() => Ok(Errno::Success),
+                Ok(WasiError::ThreadExit) => Ok(Errno::Success),
                 Ok(WasiError::Exit(code)) => {
                     runtime.on_taint(TaintReason::NonZeroExitCode(code));
                     Err(WasiError::Exit(code).into())
@@ -308,10 +350,15 @@ fn call_module(
                     return;
                 }
                 Ok(WasiError::UnknownWasiVersion) => {
-                    debug!("failed as wasi version is unknown",);
+                    debug!("failed as wasi version is unknown");
                     runtime.on_taint(TaintReason::UnknownWasiVersion);
                     Ok(Errno::Noexec)
                 }
+                Ok(WasiError::DlSymbolResolutionFailed(symbol)) => {
+                    debug!("failed as a needed DL symbol could not be resolved");
+                    runtime.on_taint(TaintReason::DlSymbolResolutionFailed(symbol.clone()));
+                    Err(WasiError::DlSymbolResolutionFailed(symbol).into())
+                }
                 Err(err) => {
                     runtime.on_taint(TaintReason::RuntimeError(err.clone()));
                     Err(WasiRuntimeError::from(err))
@@ -323,7 +370,14 @@ fn call_module(
     };
 
     let code = if let Err(err) = &ret {
-        err.as_exit_code().unwrap_or_else(|| Errno::Noexec.into())
+        match err.as_exit_code() {
+            Some(s) => s,
+            None => {
+                error!("{err}");
+                eprintln!("{err}");
+                Errno::Noexec.into()
+            }
+        }
     } else {
         Errno::Success.into()
     };
@@ -335,3 +389,98 @@ fn call_module(
     debug!("wasi[{pid}]::main() has exited with {code}");
     handle.thread.set_status_finished(ret.map(|a| a.into()));
 }
+
+#[allow(clippy::type_complexity)]
+fn resume_vfork(
+    ctx: &WasiFunctionEnv,
+    store: &mut Store,
+    start: &Function,
+    call_ret: &Result<Box<[Value]>, RuntimeError>,
+) -> Result<Option<Result<Box<[Value]>, RuntimeError>>, Errno> {
+    let (err, code) = match call_ret {
+        Ok(_) => (None, wasmer_wasix_types::wasi::ExitCode::from(0u16)),
+        Err(err) => match err.downcast_ref::<WasiError>() {
+            // If the child process is just deep sleeping, we don't restore the vfork
+            Some(WasiError::DeepSleep(..)) => return Ok(None),
+
+            Some(WasiError::Exit(code)) => (None, *code),
+            Some(WasiError::ThreadExit) => (None, wasmer_wasix_types::wasi::ExitCode::from(0u16)),
+            Some(WasiError::UnknownWasiVersion) => (None, Errno::Noexec.into()),
+            Some(WasiError::DlSymbolResolutionFailed(_)) => (None, Errno::Nolink.into()),
+            None => (
+                Some(WasiRuntimeError::from(err.clone())),
+                Errno::Unknown.into(),
+            ),
+        },
+    };
+
+    if let Some(mut vfork) = ctx.data_mut(store).vfork.take() {
+        if let Some(err) = err {
+            error!(%err, "Error from child process");
+            eprintln!("{err}");
+        }
+
+        InlineWaker::block_on(
+            unsafe { ctx.data(store).get_memory_and_wasi_state(store, 0) }
+                .1
+                .fs
+                .close_all(),
+        );
+
+        tracing::debug!(
+            pid = %ctx.data_mut(store).process.pid(),
+            vfork_pid = %vfork.env.process.pid(),
+            "Resuming from vfork after child process was terminated"
+        );
+
+        // Restore the WasiEnv to the point when we vforked
+        vfork.env.swap_inner(ctx.data_mut(store));
+        std::mem::swap(vfork.env.as_mut(), ctx.data_mut(store));
+        let mut child_env = *vfork.env;
+        child_env.owned_handles.push(vfork.handle);
+
+        // Terminate the child process
+        child_env.process.terminate(code);
+
+        // Jump back to the vfork point and current on execution
+        let child_pid = child_env.process.pid();
+        let rewind_stack = vfork.rewind_stack.freeze();
+        let store_data = vfork.store_data;
+
+        let ctx = ctx.env.clone().into_mut(store);
+        // Now rewind the previous stack and carry on from where we did the vfork
+        let rewind_result = if vfork.is_64bit {
+            crate::syscalls::rewind::<Memory64, _>(
+                ctx,
+                None,
+                rewind_stack,
+                store_data,
+                crate::syscalls::ForkResult {
+                    pid: child_pid.raw() as wasmer_wasix_types::wasi::Pid,
+                    ret: Errno::Success,
+                },
+            )
+        } else {
+            crate::syscalls::rewind::<Memory32, _>(
+                ctx,
+                None,
+                rewind_stack,
+                store_data,
+                crate::syscalls::ForkResult {
+                    pid: child_pid.raw() as wasmer_wasix_types::wasi::Pid,
+                    ret: Errno::Success,
+                },
+            )
+        };
+
+        match rewind_result {
+            Errno::Success => Ok(Some(start.call(store, &[]))),
+            err => {
+                warn!("fork failed - could not rewind the stack - errno={}", err);
+                Err(err)
+            }
+        }
+    } else {
+        Ok(None)
+    }
+}
diff --git a/lib/wasix/src/bin_factory/mod.rs b/lib/wasix/src/bin_factory/mod.rs
index 0cb8cee8e0..e97dbe9c72 100644
--- a/lib/wasix/src/bin_factory/mod.rs
+++ b/lib/wasix/src/bin_factory/mod.rs
@@ -8,11 +8,10 @@ use std::{
 };
 
 use anyhow::Context;
-use exec::spawn_exec_wasm;
+use shared_buffer::OwnedBuffer;
 use virtual_fs::{AsyncReadExt, FileSystem};
 use wasmer::FunctionEnvMut;
-use wasmer_wasix_types::wasi::Errno;
-use webc::Container;
+use wasmer_package::utils::from_bytes;
 
 mod binary_package;
 mod exec;
@@ -20,11 +19,13 @@ mod exec;
 pub use self::{
     binary_package::*,
     exec::{
-        run_exec, spawn_exec, spawn_exec_module, spawn_load_module, spawn_load_wasm, spawn_union_fs,
+        package_command_by_name, run_exec, spawn_exec, spawn_exec_module, spawn_exec_wasm,
+        spawn_load_module, spawn_union_fs,
     },
 };
 use crate::{
     os::{command::Commands, task::TaskJoinHandle},
+    runtime::module_cache::HashedModuleData,
     Runtime, SpawnError, WasiEnv,
 };
 
@@ -70,7 +71,6 @@ impl BinFactory {
     pub fn spawn<'a>(
         &'a self,
         name: String,
-        store: wasmer::Store,
         env: WasiEnv,
     ) -> Pin<Box<dyn Future<Output = Result<TaskJoinHandle, SpawnError>> + 'a>> {
         Box::pin(async move {
@@ -81,18 +81,21 @@ impl BinFactory {
                 .ok_or_else(|| SpawnError::BinaryNotFound {
                     binary: name.clone(),
                 });
-            if res.is_err() {
-                env.on_exit(Some(Errno::Noent.into())).await;
-            }
             let executable = res?;
 
             // Execute
             match executable {
                 Executable::Wasm(bytes) => {
-                    spawn_exec_wasm(&bytes, name.as_str(), env, &self.runtime).await
+                    let data = HashedModuleData::new(bytes.clone());
+                    spawn_exec_wasm(data, name.as_str(), env, &self.runtime).await
                 }
                 Executable::BinaryPackage(pkg) => {
-                    spawn_exec(pkg, name.as_str(), store, env, &self.runtime).await
+                    // Get the command that is going to be executed
+                    let cmd = package_command_by_name(&pkg, name.as_str())?;
+
+                    env.prepare_spawn(cmd);
+
+                    spawn_exec(pkg, name.as_str(), env, &self.runtime).await
                 }
             }
         })
@@ -102,15 +105,12 @@ impl BinFactory {
         &self,
         name: String,
         parent_ctx: Option<&FunctionEnvMut<'_, WasiEnv>>,
-        store: &mut Option<wasmer::Store>,
         builder: &mut Option<WasiEnv>,
     ) -> Result<TaskJoinHandle, SpawnError> {
         // We check for built in commands
         if let Some(parent_ctx) = parent_ctx {
             if self.commands.exists(name.as_str()) {
-                return self
-                    .commands
-                    .exec(parent_ctx, name.as_str(), store, builder);
+                return self.commands.exec(parent_ctx, name.as_str(), builder);
             }
         } else if self.commands.exists(name.as_str()) {
             tracing::warn!("builtin command without a parent ctx - {}", name);
@@ -173,7 +173,7 @@ impl BinFactory {
 }
 
 pub enum Executable {
-    Wasm(bytes::Bytes),
+    Wasm(OwnedBuffer),
     BinaryPackage(BinaryPackage),
 }
 
@@ -188,18 +188,35 @@ async fn load_executable_from_filesystem(
         .open(path)
         .context("Unable to open the file")?;
 
-    let mut data = Vec::with_capacity(f.size() as usize);
-    f.read_to_end(&mut data).await.context("Read failed")?;
+    // Fast path if the file is fully available in memory.
+    // Prevents redundant copying of the file data.
+    if let Some(buf) = f.as_owned_buffer() {
+        if wasmer_package::utils::is_container(buf.as_slice()) {
+            let bytes = buf.clone().into_bytes();
+            if let Ok(container) = from_bytes(bytes.clone()) {
+                let pkg = BinaryPackage::from_webc(&container, rt)
+                    .await
+                    .context("Unable to load the package")?;
+
+                return Ok(Executable::BinaryPackage(pkg));
+            }
+        }
 
-    let bytes: bytes::Bytes = data.into();
+        Ok(Executable::Wasm(buf))
+    } else {
+        let mut data = Vec::with_capacity(f.size() as usize);
+        f.read_to_end(&mut data).await.context("Read failed")?;
 
-    if let Ok(container) = Container::from_bytes(bytes.clone()) {
-        let pkg = BinaryPackage::from_webc(&container, rt)
-            .await
-            .context("Unable to load the package")?;
+        let bytes: bytes::Bytes = data.into();
 
-        Ok(Executable::BinaryPackage(pkg))
-    } else {
-        Ok(Executable::Wasm(bytes))
+        if let Ok(container) = from_bytes(bytes.clone()) {
+            let pkg = BinaryPackage::from_webc(&container, rt)
+                .await
+                .context("Unable to load the package")?;
+
+            Ok(Executable::BinaryPackage(pkg))
+        } else {
+            Ok(Executable::Wasm(OwnedBuffer::from_bytes(bytes)))
+        }
     }
 }
diff --git a/lib/wasix/src/capabilities.rs b/lib/wasix/src/capabilities.rs
index fb47c12208..e3c3b0ab1b 100644
--- a/lib/wasix/src/capabilities.rs
+++ b/lib/wasix/src/capabilities.rs
@@ -3,7 +3,7 @@ use std::time::Duration;
 use crate::http::HttpClientCapabilityV1;
 
 /// Defines capabilities for a Wasi environment.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Capabilities {
     pub insecure_allow_all: bool,
     pub http_client: HttpClientCapabilityV1,
@@ -40,7 +40,7 @@ impl Default for Capabilities {
 }
 
 /// Defines threading related permissions.
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Default, Clone, PartialEq, Eq, Hash)]
 pub struct CapabilityThreadingV1 {
     /// Maximum number of threads that can be spawned.
     ///
diff --git a/lib/wasix/src/fs/fd.rs b/lib/wasix/src/fs/fd.rs
index 06909f0053..9242616b74 100644
--- a/lib/wasix/src/fs/fd.rs
+++ b/lib/wasix/src/fs/fd.rs
@@ -2,32 +2,27 @@ use std::{
     borrow::Cow,
     collections::{HashMap, HashSet},
     path::PathBuf,
-    pin::Pin,
     sync::{atomic::AtomicU64, Arc, RwLock, RwLockReadGuard, RwLockWriteGuard},
-    task::Context,
 };
 
-use futures::Future;
 use serde_derive::{Deserialize, Serialize};
 use std::sync::Mutex as StdMutex;
 use tokio::sync::{watch, Mutex as AsyncMutex};
-use virtual_fs::{Pipe, VirtualFile};
-use wasmer_wasix_types::wasi::{EpollType, Fd as WasiFd, Fdflags, Filestat, Rights};
+use virtual_fs::{Pipe, PipeRx, PipeTx, VirtualFile};
+use wasmer_wasix_types::wasi::{EpollType, Fd as WasiFd, Fdflags, Fdflagsext, Filestat, Rights};
 
-use crate::{net::socket::InodeSocket, syscalls::EpollJoinWaker};
+use crate::net::socket::InodeSocket;
 
 use super::{
-    InodeGuard, InodeValFilePollGuard, InodeValFilePollGuardJoin, InodeValFilePollGuardMode,
-    InodeWeakGuard, NotificationInner,
+    InodeGuard, InodeValFilePollGuard, InodeValFilePollGuardMode, InodeWeakGuard, NotificationInner,
 };
 
 #[derive(Debug, Clone)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct Fd {
-    pub rights: Rights,
-    pub rights_inheriting: Rights,
-    pub flags: Fdflags,
-    pub offset: Arc<AtomicU64>,
+    #[cfg_attr(feature = "enable-serde", serde(flatten))]
+    pub inner: FdInner,
+
     /// Flags that determine how the [`Fd`] can be used.
     ///
     /// Used when reopening a [`VirtualFile`] during deserialization.
@@ -36,6 +31,18 @@ pub struct Fd {
     pub is_stdio: bool,
 }
 
+// This struct contains the bits of Fd that are safe to mutate, so that
+// FdList::get_mut can safely return mutable references.
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct FdInner {
+    pub rights: Rights,
+    pub rights_inheriting: Rights,
+    pub flags: Fdflags,         // This is file table related flags, not fd flags
+    pub offset: Arc<AtomicU64>, // This also belongs in the file table
+    pub fd_flags: Fdflagsext,   // This is the actual FD flags that belongs here
+}
+
 impl Fd {
     /// This [`Fd`] can be used with read system calls.
     pub const READ: u16 = 1;
@@ -62,7 +69,7 @@ impl Fd {
 pub struct InodeVal {
     pub stat: RwLock<Filestat>,
     pub is_preopened: bool,
-    pub name: Cow<'static, str>,
+    pub name: RwLock<Cow<'static, str>>,
     pub kind: RwLock<Kind>,
 }
 
@@ -100,48 +107,32 @@ pub struct EpollInterest {
 
 /// Guard the cleans up the selector registrations
 #[derive(Debug)]
-pub enum EpollJoinGuard {
-    Join {
-        join_guard: InodeValFilePollGuardJoin,
-        epoll_waker: Arc<EpollJoinWaker>,
-    },
-    Handler {
-        fd_guard: InodeValFilePollGuard,
-    },
+pub struct EpollJoinGuard {
+    pub(crate) fd_guard: InodeValFilePollGuard,
 }
 impl Drop for EpollJoinGuard {
     fn drop(&mut self) {
-        if let Self::Handler { fd_guard, .. } = self {
-            if let InodeValFilePollGuardMode::Socket { inner } = &mut fd_guard.mode {
+        match &self.fd_guard.mode {
+            InodeValFilePollGuardMode::File(_) => {
+                // Intentionally ignored, epoll doesn't work with files
+            }
+            InodeValFilePollGuardMode::Socket { inner } => {
                 let mut inner = inner.protected.write().unwrap();
                 inner.remove_handler();
             }
-        }
-    }
-}
-impl EpollJoinGuard {
-    pub fn is_spent(&self) -> bool {
-        match self {
-            Self::Join { join_guard, .. } => join_guard.is_spent(),
-            Self::Handler { .. } => false,
-        }
-    }
-    pub fn renew(&mut self) {
-        if let Self::Join {
-            join_guard,
-            epoll_waker,
-        } = self
-        {
-            let fd = join_guard.fd();
-            join_guard.reset();
-
-            let waker = epoll_waker.as_waker();
-            let mut cx = Context::from_waker(&waker);
-            if Pin::new(join_guard).poll(&mut cx).is_ready() {
-                tracing::trace!(fd, "join renew already woken");
-                waker.wake();
-            } else {
-                tracing::trace!(fd, "join waker reinstalled");
+            InodeValFilePollGuardMode::EventNotifications(inner) => {
+                inner.remove_interest_handler();
+            }
+            InodeValFilePollGuardMode::DuplexPipe { pipe } => {
+                let inner = pipe.write().unwrap();
+                inner.remove_interest_handler();
+            }
+            InodeValFilePollGuardMode::PipeRx { rx } => {
+                let inner = rx.write().unwrap();
+                inner.remove_interest_handler();
+            }
+            InodeValFilePollGuardMode::PipeTx { .. } => {
+                // Intentionally ignored, the sending end of a pipe can't have an interest handler
             }
         }
     }
@@ -173,8 +164,15 @@ pub enum Kind {
         socket: InodeSocket,
     },
     #[cfg_attr(feature = "enable-serde", serde(skip))]
-    Pipe {
-        /// Reference to the pipe
+    PipeTx {
+        tx: PipeTx,
+    },
+    #[cfg_attr(feature = "enable-serde", serde(skip))]
+    PipeRx {
+        rx: PipeRx,
+    },
+    #[cfg_attr(feature = "enable-serde", serde(skip))]
+    DuplexPipe {
         pipe: Pipe,
     },
     Epoll {
diff --git a/lib/wasix/src/fs/fd_list.rs b/lib/wasix/src/fs/fd_list.rs
new file mode 100644
index 0000000000..d9901ca676
--- /dev/null
+++ b/lib/wasix/src/fs/fd_list.rs
@@ -0,0 +1,703 @@
+//! A very simple data structure for holding the FDs a WASI process is using.
+//! Keeps track of the first unused (i.e. freed) FD, which is slightly faster
+//! than doing a linear search of the entire array each time.
+//! Note, The Unix spec requires newly allocated FDs to always be the
+//! lowest-numbered FD available.
+
+use super::fd::{Fd, FdInner};
+use wasmer_wasix_types::wasi::Fd as WasiFd;
+
+#[derive(Debug)]
+pub struct FdList {
+    fds: Vec<Option<Fd>>,
+    first_free: Option<usize>,
+}
+
+pub struct FdListIterator<'a> {
+    fds_iterator: core::slice::Iter<'a, Option<Fd>>,
+    idx: usize,
+}
+
+pub struct FdListIteratorMut<'a> {
+    fds_iterator: core::slice::IterMut<'a, Option<Fd>>,
+    idx: usize,
+}
+
+impl Default for FdList {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+// TODO: rename all functions to something more sensible after all code is migrated
+impl FdList {
+    pub fn new() -> Self {
+        Self {
+            fds: vec![],
+            first_free: None,
+        }
+    }
+
+    pub fn next_free_fd(&self) -> WasiFd {
+        match self.first_free {
+            Some(i) => i as WasiFd,
+            None => self.last_fd().map(|i| i + 1).unwrap_or(0),
+        }
+    }
+
+    pub fn last_fd(&self) -> Option<WasiFd> {
+        self.fds
+            .iter()
+            .rev()
+            .position(|fd| fd.is_some())
+            .map(|idx| (self.fds.len() - idx - 1) as WasiFd)
+    }
+
+    pub fn get(&self, idx: WasiFd) -> Option<&Fd> {
+        self.fds.get(idx as usize).and_then(|x| x.as_ref())
+    }
+
+    pub fn get_mut(&mut self, idx: WasiFd) -> Option<&mut FdInner> {
+        self.fds
+            .get_mut(idx as usize)
+            .and_then(|x| x.as_mut())
+            .map(|x| &mut x.inner)
+    }
+
+    pub fn insert_first_free(&mut self, fd: Fd) -> WasiFd {
+        fd.inode.acquire_handle();
+        match self.first_free {
+            Some(free) => {
+                assert!(self.fds[free].is_none());
+
+                self.fds[free] = Some(fd);
+
+                self.first_free = self.first_free_after(free as WasiFd + 1);
+
+                free as WasiFd
+            }
+            None => {
+                self.fds.push(Some(fd));
+                (self.fds.len() - 1) as WasiFd
+            }
+        }
+    }
+
+    pub fn insert_first_free_after(&mut self, fd: Fd, after_or_equal: WasiFd) -> WasiFd {
+        match self.first_free {
+            // We're shorter than `after`, need to extend the list regardless of whether we have holes
+            _ if self.fds.len() < after_or_equal as usize => {
+                if !self.insert(true, after_or_equal, fd) {
+                    panic!("Internal error in FdList - expected {after_or_equal} to be unoccupied since the list wasn't long enough");
+                }
+                after_or_equal
+            }
+
+            // First free hole is suitable, we can insert there
+            Some(free) if free >= after_or_equal as usize => self.insert_first_free(fd),
+
+            // No holes, and we're longer than `after`, so insert at the end
+            None if self.fds.len() >= after_or_equal as usize => self.insert_first_free(fd),
+
+            // Keeping the compiler happy
+            None => unreachable!("Both None cases were handled before"),
+
+            // If there's a hole but its index is too low, we need to search
+            Some(_) => {
+                // This is handled by insert or insert_first_free in every other case, but not this one
+                fd.inode.acquire_handle();
+
+                match self.first_free_after(after_or_equal) {
+                    // Found a suitable hole, and it's guaranteed to not be the first since
+                    // that's checked in the previous Some case, so filling it has no effect
+                    // on self.first_free
+                    Some(free) => {
+                        self.fds[free] = Some(fd);
+                        free as WasiFd
+                    }
+
+                    // No holes - insert at the end
+                    None => {
+                        self.fds.push(Some(fd));
+                        (self.fds.len() - 1) as WasiFd
+                    }
+                }
+            }
+        }
+    }
+
+    fn first_free_after(&self, after_or_equal: WasiFd) -> Option<usize> {
+        let skip = after_or_equal as usize;
+        self.fds
+            .iter()
+            .skip(skip)
+            .position(|fd| fd.is_none())
+            .map(|idx| idx + skip)
+    }
+
+    pub fn insert(&mut self, exclusive: bool, idx: WasiFd, fd: Fd) -> bool {
+        let idx = idx as usize;
+
+        if self.fds.len() <= idx {
+            if
+            // if we have a first_free, it has to be before the end of the list, so
+            // the only way for this to update first_free is if we don't have one at all
+            self.first_free.is_none() &&
+                // The target index must be at least len() + 1. If it's exactly len(),
+                // it won't create a hole
+                idx > self.fds.len()
+            {
+                self.first_free = Some(self.fds.len());
+            }
+
+            self.fds.resize(idx + 1, None);
+        }
+
+        if let Some(ref prev_fd) = self.fds[idx] {
+            if exclusive {
+                return false;
+            } else {
+                prev_fd.inode.drop_one_handle();
+            }
+        }
+
+        fd.inode.acquire_handle();
+        self.fds[idx] = Some(fd);
+
+        if self.first_free == Some(idx) {
+            self.first_free = self.first_free_after(idx as WasiFd + 1);
+        }
+
+        true
+    }
+
+    pub fn remove(&mut self, idx: WasiFd) -> Option<Fd> {
+        let idx = idx as usize;
+
+        let result = self.fds.get_mut(idx).and_then(|fd| fd.take());
+
+        if let Some(fd) = result.as_ref() {
+            match self.first_free {
+                None => self.first_free = Some(idx),
+                Some(x) if x > idx => self.first_free = Some(idx),
+                _ => (),
+            }
+
+            fd.inode.drop_one_handle();
+        }
+
+        result
+    }
+
+    pub fn clear(&mut self) {
+        for fd in &self.fds {
+            if let Some(fd) = fd.as_ref() {
+                fd.inode.drop_one_handle();
+            }
+        }
+
+        self.fds.clear();
+        self.first_free = None;
+    }
+
+    pub fn iter(&self) -> FdListIterator {
+        FdListIterator {
+            fds_iterator: self.fds.iter(),
+            idx: 0,
+        }
+    }
+
+    pub fn keys(&self) -> impl Iterator<Item = WasiFd> + '_ {
+        self.iter().map(|(key, _)| key)
+    }
+
+    pub fn iter_mut(&mut self) -> FdListIteratorMut {
+        FdListIteratorMut {
+            fds_iterator: self.fds.iter_mut(),
+            idx: 0,
+        }
+    }
+}
+
+impl Clone for FdList {
+    fn clone(&self) -> Self {
+        for fd in &self.fds {
+            if let Some(fd) = fd.as_ref() {
+                fd.inode.acquire_handle();
+            }
+        }
+
+        Self {
+            fds: self.fds.clone(),
+            first_free: self.first_free,
+        }
+    }
+}
+
+impl Drop for FdList {
+    fn drop(&mut self) {
+        self.clear();
+    }
+}
+
+impl<'a> Iterator for FdListIterator<'a> {
+    type Item = (WasiFd, &'a Fd);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            match self.fds_iterator.next() {
+                None => return None,
+
+                Some(None) => {
+                    self.idx += 1;
+                    continue;
+                }
+
+                Some(Some(fd)) => {
+                    let wasi_fd = self.idx as WasiFd;
+                    self.idx += 1;
+                    return Some((wasi_fd, fd));
+                }
+            }
+        }
+    }
+}
+
+impl<'a> Iterator for FdListIteratorMut<'a> {
+    type Item = (WasiFd, &'a mut FdInner);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            match self.fds_iterator.next() {
+                None => return None,
+
+                Some(None) => {
+                    self.idx += 1;
+                    continue;
+                }
+
+                Some(Some(fd)) => {
+                    let wasi_fd = self.idx as WasiFd;
+                    self.idx += 1;
+                    return Some((wasi_fd, &mut fd.inner));
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{
+        borrow::Cow,
+        sync::{
+            atomic::{AtomicI32, AtomicU64},
+            Arc, RwLock,
+        },
+    };
+
+    use assert_panic::assert_panic;
+    use wasmer_wasix_types::wasi::{Fdflags, Fdflagsext, Rights};
+
+    use crate::fs::{fd::FdInner, Inode, InodeGuard, InodeVal, Kind};
+
+    use super::{Fd, FdList, WasiFd};
+
+    fn useless_fd(n: u16) -> Fd {
+        Fd {
+            open_flags: 0,
+            inode: InodeGuard {
+                ino: Inode(0),
+                inner: Arc::new(InodeVal {
+                    is_preopened: false,
+                    kind: RwLock::new(Kind::Buffer { buffer: vec![] }),
+                    name: RwLock::new(Cow::Borrowed("")),
+                    stat: RwLock::new(Default::default()),
+                }),
+                open_handles: Arc::new(AtomicI32::new(0)),
+            },
+            is_stdio: false,
+            inner: FdInner {
+                offset: Arc::new(AtomicU64::new(0)),
+                rights: Rights::empty(),
+                rights_inheriting: Rights::empty(),
+                flags: Fdflags::from_bits_preserve(n),
+                fd_flags: Fdflagsext::empty(),
+            },
+        }
+    }
+
+    fn is_useless_fd(fd: &Fd, n: u16) -> bool {
+        fd.inner.flags.bits() == n
+    }
+
+    fn is_useless_fd_inner(fd_inner: &FdInner, n: u16) -> bool {
+        fd_inner.flags.bits() == n
+    }
+
+    fn assert_fds_match(l: &FdList, expected: &[(WasiFd, u16)]) {
+        let mut i = l.iter();
+
+        for e in expected {
+            let next = i.next().expect("Should have a next element");
+            assert_eq!(next.0, e.0);
+            assert!(is_useless_fd(next.1, e.1));
+        }
+
+        assert!(i.next().is_none());
+    }
+
+    #[test]
+    fn can_append_fds() {
+        let mut l = FdList::new();
+        l.insert_first_free(useless_fd(0));
+        l.insert_first_free(useless_fd(1));
+
+        assert_fds_match(&l, &[(0, 0), (1, 1)]);
+    }
+
+    #[test]
+    fn can_append_in_holes() {
+        let mut l = FdList::new();
+        l.insert_first_free(useless_fd(0));
+        l.insert_first_free(useless_fd(1));
+        l.insert_first_free(useless_fd(2));
+        l.insert_first_free(useless_fd(3));
+        l.remove(1);
+        l.remove(2);
+        l.insert_first_free(useless_fd(4));
+
+        assert_fds_match(&l, &[(0, 0), (1, 4), (3, 3)]);
+    }
+
+    #[test]
+    fn can_have_holes_in_different_places() {
+        let mut l = FdList::new();
+        l.insert_first_free(useless_fd(0));
+        l.insert_first_free(useless_fd(1));
+        l.insert_first_free(useless_fd(2));
+        l.insert_first_free(useless_fd(3));
+        l.insert_first_free(useless_fd(4));
+        l.remove(1);
+        l.remove(3);
+        l.insert_first_free(useless_fd(5));
+        l.insert_first_free(useless_fd(6));
+
+        assert_fds_match(&l, &[(0, 0), (1, 5), (2, 2), (3, 6), (4, 4)]);
+    }
+
+    #[test]
+    fn hole_moves_back_correctly() {
+        let mut l = FdList::new();
+        l.insert_first_free(useless_fd(0));
+        l.insert_first_free(useless_fd(1));
+        l.insert_first_free(useless_fd(2));
+        l.insert_first_free(useless_fd(3));
+        l.remove(3);
+        assert_eq!(l.first_free, Some(3));
+        l.remove(1);
+        assert_eq!(l.first_free, Some(1));
+        l.insert_first_free(useless_fd(4));
+
+        assert_fds_match(&l, &[(0, 0), (1, 4), (2, 2)]);
+    }
+
+    #[test]
+    fn insert_at_first_free_updates_first_free() {
+        let mut l = FdList::new();
+        l.insert_first_free(useless_fd(0));
+        l.insert_first_free(useless_fd(1));
+        l.insert_first_free(useless_fd(2));
+        l.insert_first_free(useless_fd(3));
+        l.remove(1);
+        l.remove(2);
+        assert!(l.insert(true, 1, useless_fd(4)));
+        assert_eq!(l.first_free, Some(2));
+
+        assert_fds_match(&l, &[(0, 0), (1, 4), (3, 3)]);
+    }
+
+    #[test]
+    fn next_and_last_fd_reported_correctly() {
+        let mut l = FdList::new();
+
+        assert_eq!(l.next_free_fd(), 0);
+        assert_eq!(l.last_fd(), None);
+
+        l.insert_first_free(useless_fd(0));
+        l.insert_first_free(useless_fd(1));
+
+        assert_eq!(l.next_free_fd(), 2);
+        assert_eq!(l.last_fd(), Some(1));
+
+        l.insert_first_free(useless_fd(2));
+        l.insert_first_free(useless_fd(3));
+
+        assert_eq!(l.next_free_fd(), 4);
+        assert_eq!(l.last_fd(), Some(3));
+
+        l.remove(3);
+
+        assert_eq!(l.next_free_fd(), 3);
+        assert_eq!(l.last_fd(), Some(2));
+
+        l.remove(1);
+
+        assert_eq!(l.next_free_fd(), 1);
+        assert_eq!(l.last_fd(), Some(2));
+    }
+
+    #[test]
+    fn get_works() {
+        let mut l = FdList::new();
+
+        l.insert_first_free(useless_fd(0));
+        l.insert_first_free(useless_fd(1));
+        l.insert_first_free(useless_fd(2));
+        l.insert_first_free(useless_fd(3));
+        l.insert_first_free(useless_fd(4));
+        l.remove(1);
+        l.remove(3);
+
+        assert!(l.get(1).is_none());
+        assert!(is_useless_fd(l.get(2).unwrap(), 2));
+
+        let at_4 = l.get_mut(4).unwrap();
+        assert!(is_useless_fd_inner(at_4, 4));
+        at_4.flags = Fdflags::from_bits_preserve(5); // Update the "useless FD" number without changing the InodeGuard
+        assert!(is_useless_fd(l.get(4).unwrap(), 5));
+
+        assert!(l.get(10).is_none());
+        assert!(l.get_mut(10).is_none());
+    }
+
+    #[test]
+    fn insert_at_works() {
+        let mut l = FdList::new();
+
+        l.insert_first_free(useless_fd(0));
+        l.insert_first_free(useless_fd(1));
+        l.insert_first_free(useless_fd(2));
+        l.remove(1);
+
+        assert!(l.insert(false, 2, useless_fd(3)));
+        assert!(is_useless_fd(l.get(2).unwrap(), 3));
+
+        assert!(!l.insert(true, 2, useless_fd(4)));
+        assert!(is_useless_fd(l.get(2).unwrap(), 3));
+
+        assert!(l.insert(true, 1, useless_fd(5)));
+        assert!(is_useless_fd(l.get(1).unwrap(), 5));
+    }
+
+    #[test]
+    fn insert_at_can_insert_beyond_end_of_list() {
+        let mut l = FdList::new();
+
+        l.insert_first_free(useless_fd(0));
+
+        assert!(l.insert(false, 1, useless_fd(1)));
+        assert!(is_useless_fd(l.get(1).unwrap(), 1));
+
+        // Extending by exactly one element shouldn't change first_free
+        assert_eq!(l.last_fd(), Some(1));
+        assert_eq!(l.next_free_fd(), 2);
+        assert!(l.first_free.is_none());
+
+        // Now create a hole
+        assert!(l.insert(false, 5, useless_fd(5)));
+        assert!(is_useless_fd(l.get(5).unwrap(), 5));
+
+        for i in 2..=4 {
+            assert!(l.get(i).is_none());
+        }
+
+        // Creating a hole should update first_free
+        assert_eq!(l.last_fd(), Some(5));
+        assert_eq!(l.next_free_fd(), 2);
+        assert_eq!(l.first_free, Some(2));
+    }
+
+    #[test]
+    fn insert_first_free_after_beyond_end_of_empty_list() {
+        let mut l = FdList::new();
+        assert_eq!(l.insert_first_free_after(useless_fd(1), 5), 5);
+        assert!(is_useless_fd(l.get(5).unwrap(), 1));
+    }
+
+    #[test]
+    fn insert_first_free_after_beyond_end_of_non_empty_list() {
+        let mut l = FdList::new();
+        l.insert(false, 0, useless_fd(0));
+        assert_eq!(l.insert_first_free_after(useless_fd(1), 5), 5);
+        assert!(is_useless_fd(l.get(5).unwrap(), 1));
+    }
+
+    #[test]
+    fn insert_first_free_after_beyond_end_of_non_empty_list_with_hole() {
+        let mut l = FdList::new();
+        l.insert(false, 0, useless_fd(0));
+        l.insert(false, 2, useless_fd(2));
+        assert_eq!(l.insert_first_free_after(useless_fd(1), 5), 5);
+        assert!(is_useless_fd(l.get(5).unwrap(), 1));
+    }
+
+    #[test]
+    fn insert_first_free_after_behind_hole() {
+        let mut l = FdList::new();
+        l.insert_first_free(useless_fd(0));
+        l.insert_first_free(useless_fd(1));
+        l.insert_first_free(useless_fd(2));
+        l.insert_first_free(useless_fd(3));
+        l.remove(2).unwrap();
+        assert_eq!(l.insert_first_free_after(useless_fd(5), 1), 2);
+        assert!(is_useless_fd(l.get(2).unwrap(), 5));
+    }
+
+    #[test]
+    fn insert_first_free_after_behind_end_without_hole() {
+        let mut l = FdList::new();
+        l.insert_first_free(useless_fd(0));
+        l.insert_first_free(useless_fd(1));
+        l.insert_first_free(useless_fd(2));
+        l.insert_first_free(useless_fd(3));
+        assert_eq!(l.insert_first_free_after(useless_fd(5), 2), 4);
+        assert!(is_useless_fd(l.get(4).unwrap(), 5));
+    }
+
+    #[test]
+    fn insert_first_free_after_between_hole_and_end_without_other_hole() {
+        let mut l = FdList::new();
+        l.insert_first_free(useless_fd(0));
+        l.insert_first_free(useless_fd(1));
+        l.insert_first_free(useless_fd(2));
+        l.insert_first_free(useless_fd(3));
+        l.insert_first_free(useless_fd(4));
+        l.remove(1).unwrap();
+        assert_eq!(l.insert_first_free_after(useless_fd(5), 2), 5);
+        assert!(is_useless_fd(l.get(5).unwrap(), 5));
+    }
+
+    #[test]
+    fn insert_first_free_after_between_hole_and_end_with_other_hole() {
+        let mut l = FdList::new();
+        l.insert_first_free(useless_fd(0));
+        l.insert_first_free(useless_fd(1));
+        l.insert_first_free(useless_fd(2));
+        l.insert_first_free(useless_fd(3));
+        l.insert_first_free(useless_fd(4));
+        l.remove(1).unwrap();
+        l.remove(3).unwrap();
+        assert_eq!(l.insert_first_free_after(useless_fd(5), 2), 3);
+        assert!(is_useless_fd(l.get(3).unwrap(), 5));
+    }
+
+    #[test]
+    fn remove_works() {
+        let mut l = FdList::new();
+
+        l.insert_first_free(useless_fd(0));
+        l.insert_first_free(useless_fd(1));
+        l.insert_first_free(useless_fd(2));
+
+        assert!(is_useless_fd(&l.remove(1).unwrap(), 1));
+        assert!(l.remove(1).is_none());
+        assert!(l.remove(100000).is_none());
+    }
+
+    #[test]
+    fn clear_works() {
+        let mut l = FdList::new();
+
+        l.insert_first_free(useless_fd(0));
+        l.insert_first_free(useless_fd(1));
+        l.insert_first_free(useless_fd(2));
+        l.remove(1);
+
+        l.clear();
+
+        assert_eq!(l.next_free_fd(), 0);
+        assert!(l.last_fd().is_none());
+        assert_eq!(l.fds.len(), 0);
+        assert!(l.first_free.is_none());
+    }
+
+    #[test]
+    fn iter_mut_works() {
+        let mut l = FdList::new();
+        l.insert_first_free(useless_fd(0));
+        l.insert_first_free(useless_fd(1));
+
+        let mut i = l.iter_mut();
+
+        let next = i.next().unwrap();
+        assert_eq!(next.0, 0);
+        assert!(is_useless_fd_inner(next.1, 0));
+        next.1.flags = Fdflags::from_bits_preserve(2); // Update the "useless FD" number without changing the InodeGuard
+
+        let next = i.next().unwrap();
+        assert_eq!(next.0, 1);
+        assert!(is_useless_fd_inner(next.1, 1));
+
+        assert!(i.next().is_none());
+
+        assert_fds_match(&l, &[(0, 2), (1, 1)]);
+    }
+
+    #[test]
+    fn open_handles_are_updated_correctly() {
+        let mut l = FdList::new();
+        l.insert_first_free(useless_fd(0));
+        l.insert_first_free(useless_fd(1));
+
+        let fd0 = l.get(0).unwrap().clone();
+        assert_eq!(fd0.inode.handle_count(), 1);
+
+        // Try removing an FD, should drop the handle
+        let fd1 = l.get(1).unwrap().clone();
+        assert_eq!(fd1.inode.handle_count(), 1);
+        l.remove(1).unwrap();
+        assert_eq!(fd1.inode.handle_count(), 0);
+
+        // Existing FDs should get a new handle when cloning the list
+        let mut l2 = l.clone();
+        assert_eq!(fd0.inode.handle_count(), 2);
+
+        {
+            // Dropping the list should drop open handles
+            let l3 = l2.clone();
+            assert_eq!(fd0.inode.handle_count(), 3);
+            drop(l3);
+            assert_eq!(fd0.inode.handle_count(), 2);
+        }
+
+        // Clearing the list should drop open handles
+        l.clear();
+        assert_eq!(fd0.inode.handle_count(), 1);
+
+        // Clear the last handle, should go back to zero
+        l2.clear();
+        assert_eq!(fd0.inode.handle_count(), 0);
+
+        assert_panic!(
+            fd0.inode.drop_one_handle(),
+            &str,
+            "InodeGuard handle dropped too many times"
+        );
+
+        assert_panic!(drop(fd0.inode.write()), String, contains "PoisonError");
+    }
+
+    #[test]
+    fn messing_with_inode_causes_panic() {
+        // We want to pin this behavior down, as not causing a panic
+        // can lead to inconsistencies
+        let mut l = FdList::new();
+        l.insert_first_free(useless_fd(0));
+
+        let fd = l.get(0).unwrap();
+        fd.inode.drop_one_handle();
+
+        assert_panic!(drop(l), &str, "InodeGuard handle dropped too many times");
+    }
+}
diff --git a/lib/wasix/src/fs/inode_guard.rs b/lib/wasix/src/fs/inode_guard.rs
index aca0e161c2..d59e060381 100644
--- a/lib/wasix/src/fs/inode_guard.rs
+++ b/lib/wasix/src/fs/inode_guard.rs
@@ -8,7 +8,7 @@ use std::{
 };
 
 use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite};
-use virtual_fs::{FsError, Pipe as VirtualPipe, VirtualFile};
+use virtual_fs::{FsError, Pipe, PipeRx, PipeTx, VirtualFile};
 use wasmer_wasix_types::{
     types::Eventtype,
     wasi::{self, EpollType},
@@ -28,7 +28,9 @@ pub(crate) enum InodeValFilePollGuardMode {
     File(Arc<RwLock<Box<dyn VirtualFile + Send + Sync + 'static>>>),
     EventNotifications(Arc<NotificationInner>),
     Socket { inner: Arc<InodeSocketInner> },
-    Pipe { pipe: Arc<RwLock<Box<VirtualPipe>>> },
+    PipeRx { rx: Arc<RwLock<Box<PipeRx>>> },
+    PipeTx { tx: Arc<RwLock<Box<PipeTx>>> },
+    DuplexPipe { pipe: Arc<RwLock<Box<Pipe>>> },
 }
 
 pub struct InodeValFilePollGuard {
@@ -56,7 +58,13 @@ impl InodeValFilePollGuard {
                 handle: Some(handle),
                 ..
             } => InodeValFilePollGuardMode::File(handle.clone()),
-            Kind::Pipe { pipe, .. } => InodeValFilePollGuardMode::Pipe {
+            Kind::PipeRx { rx } => InodeValFilePollGuardMode::PipeRx {
+                rx: Arc::new(RwLock::new(Box::new(rx.clone()))),
+            },
+            Kind::PipeTx { tx } => InodeValFilePollGuardMode::PipeTx {
+                tx: Arc::new(RwLock::new(Box::new(tx.clone()))),
+            },
+            Kind::DuplexPipe { pipe } => InodeValFilePollGuardMode::DuplexPipe {
                 pipe: Arc::new(RwLock::new(Box::new(pipe.clone()))),
             },
             _ => {
@@ -107,8 +115,14 @@ impl std::fmt::Debug for InodeValFilePollGuard {
                     _ => write!(f, "guard-socket(fd={}), peb={})", self.fd, self.peb),
                 }
             }
-            InodeValFilePollGuardMode::Pipe { .. } => {
-                write!(f, "guard-pipe(...)")
+            InodeValFilePollGuardMode::PipeRx { .. } => {
+                write!(f, "guard-pipe-rx(...)")
+            }
+            InodeValFilePollGuardMode::PipeTx { .. } => {
+                write!(f, "guard-pipe-tx(...)")
+            }
+            InodeValFilePollGuardMode::DuplexPipe { .. } => {
+                write!(f, "guard-duplex-pipe(...)")
             }
         }
     }
@@ -120,7 +134,6 @@ pub struct InodeValFilePollGuardJoin {
     fd: u32,
     peb: PollEventSet,
     subscription: Subscription,
-    spent: bool,
 }
 
 impl InodeValFilePollGuardJoin {
@@ -130,7 +143,6 @@ impl InodeValFilePollGuardJoin {
             fd: guard.fd,
             peb: guard.peb,
             subscription: guard.subscription,
-            spent: false,
         }
     }
     pub(crate) fn fd(&self) -> u32 {
@@ -139,20 +151,6 @@ impl InodeValFilePollGuardJoin {
     pub(crate) fn peb(&self) -> PollEventSet {
         self.peb
     }
-    pub fn is_spent(&self) -> bool {
-        self.spent
-    }
-    pub fn reset(&mut self) {
-        match &self.mode {
-            InodeValFilePollGuardMode::File(_) => {}
-            InodeValFilePollGuardMode::EventNotifications(inner) => {
-                inner.reset();
-            }
-            InodeValFilePollGuardMode::Socket { .. } => {}
-            InodeValFilePollGuardMode::Pipe { .. } => {}
-        }
-        self.spent = false;
-    }
 }
 
 pub const POLL_GUARD_MAX_RET: usize = 4;
@@ -200,7 +198,16 @@ impl Future for InodeValFilePollGuardJoin {
                     let mut guard = inner.protected.write().unwrap();
                     guard.poll_read_ready(cx)
                 }
-                InodeValFilePollGuardMode::Pipe { pipe } => {
+                InodeValFilePollGuardMode::PipeRx { rx } => {
+                    let mut guard = rx.write().unwrap();
+                    let rx = Pin::new(guard.as_mut());
+                    rx.poll_read_ready(cx)
+                }
+                InodeValFilePollGuardMode::PipeTx { .. } => Poll::Ready(Err(std::io::Error::new(
+                    std::io::ErrorKind::InvalidInput,
+                    "Cannot read from a pipe write end",
+                ))),
+                InodeValFilePollGuardMode::DuplexPipe { pipe } => {
                     let mut guard = pipe.write().unwrap();
                     let pipe = Pin::new(guard.as_mut());
                     pipe.poll_read_ready(cx)
@@ -290,7 +297,16 @@ impl Future for InodeValFilePollGuardJoin {
                     let mut guard = inner.protected.write().unwrap();
                     guard.poll_write_ready(cx)
                 }
-                InodeValFilePollGuardMode::Pipe { pipe } => {
+                InodeValFilePollGuardMode::PipeRx { .. } => Poll::Ready(Err(std::io::Error::new(
+                    std::io::ErrorKind::InvalidInput,
+                    "Cannot write to a pipe read end",
+                ))),
+                InodeValFilePollGuardMode::PipeTx { tx } => {
+                    let mut guard = tx.write().unwrap();
+                    let tx = Pin::new(guard.as_mut());
+                    tx.poll_write_ready()
+                }
+                InodeValFilePollGuardMode::DuplexPipe { pipe } => {
                     let mut guard = pipe.write().unwrap();
                     let pipe = Pin::new(guard.as_mut());
                     pipe.poll_write_ready(cx)
@@ -369,7 +385,6 @@ impl Future for InodeValFilePollGuardJoin {
             };
         }
         if !ret.is_empty() {
-            self.spent = true;
             return Poll::Ready(ret);
         }
         Poll::Pending
@@ -452,7 +467,7 @@ pub(crate) struct WasiStateFileGuard {
 impl WasiStateFileGuard {
     pub fn new(state: &WasiState, fd: wasi::Fd) -> Result<Option<Self>, FsError> {
         let fd_map = state.fs.fd_map.read().unwrap();
-        if let Some(fd) = fd_map.get(&fd) {
+        if let Some(fd) = fd_map.get(fd) {
             Ok(Some(Self {
                 inode: fd.inode.clone(),
             }))
diff --git a/lib/wasix/src/fs/mod.rs b/lib/wasix/src/fs/mod.rs
index 9ab56c8d7f..16cd1da0df 100644
--- a/lib/wasix/src/fs/mod.rs
+++ b/lib/wasix/src/fs/mod.rs
@@ -1,42 +1,49 @@
+// TODO: currently, hard links are broken in the presence or renames.
+// It is impossible to fix them with the current setup, since a hard
+// link must point to the actual file rather than its path, but the
+// only way we can get to a file on a FileSystem instance is by going
+// through its repective FileOpener and giving it a path as input.
+// TODO: refactor away the InodeVal type
+
 mod fd;
+mod fd_list;
 mod inode_guard;
 mod notification;
 
 use std::{
     borrow::{Borrow, Cow},
-    cmp::Reverse,
-    collections::{BinaryHeap, HashMap, HashSet, VecDeque},
+    collections::{HashMap, HashSet, VecDeque},
     ops::{Deref, DerefMut},
     path::{Component, Path, PathBuf},
     pin::Pin,
     sync::{
-        atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering},
+        atomic::{AtomicBool, AtomicI32, AtomicU64, Ordering},
         Arc, Mutex, RwLock, Weak,
     },
     task::{Context, Poll},
 };
 
+use self::fd_list::FdList;
 use crate::{
     net::socket::InodeSocketKind,
     state::{Stderr, Stdin, Stdout},
 };
-use ahash::AHashMap;
 use futures::{future::BoxFuture, Future, TryStreamExt};
 #[cfg(feature = "enable-serde")]
 use serde_derive::{Deserialize, Serialize};
-use tokio::{io::AsyncWriteExt, runtime::Handle};
+use tokio::io::AsyncWriteExt;
 use tracing::{debug, trace};
 use virtual_fs::{copy_reference, FileSystem, FsError, OpenOptions, VirtualFile};
 use wasmer_config::package::PackageId;
 use wasmer_wasix_types::{
     types::{__WASI_STDERR_FILENO, __WASI_STDIN_FILENO, __WASI_STDOUT_FILENO},
     wasi::{
-        Errno, Fd as WasiFd, Fdflags, Fdstat, Filesize, Filestat, Filetype, Preopentype, Prestat,
-        PrestatEnum, Rights, Socktype,
+        Errno, Fd as WasiFd, Fdflags, Fdflagsext, Fdstat, Filesize, Filestat, Filetype,
+        Preopentype, Prestat, PrestatEnum, Rights, Socktype,
     },
 };
 
-pub use self::fd::{EpollFd, EpollInterest, EpollJoinGuard, Fd, InodeVal, Kind};
+pub use self::fd::{EpollFd, EpollInterest, EpollJoinGuard, Fd, FdInner, InodeVal, Kind};
 pub(crate) use self::inode_guard::{
     InodeValFilePollGuard, InodeValFilePollGuardJoin, InodeValFilePollGuardMode,
     InodeValFileReadGuard, InodeValFileWriteGuard, WasiStateFileGuard, POLL_GUARD_MAX_RET,
@@ -76,6 +83,7 @@ const STDIN_DEFAULT_RIGHTS: Rights = {
             | Rights::FD_SYNC.bits()
             | Rights::FD_ADVISE.bits()
             | Rights::FD_FILESTAT_GET.bits()
+            | Rights::FD_FDSTAT_SET_FLAGS.bits()
             | Rights::POLL_FD_READWRITE.bits(),
     )
 };
@@ -88,6 +96,7 @@ const STDOUT_DEFAULT_RIGHTS: Rights = {
             | Rights::FD_WRITE.bits()
             | Rights::FD_ADVISE.bits()
             | Rights::FD_FILESTAT_GET.bits()
+            | Rights::FD_FDSTAT_SET_FLAGS.bits()
             | Rights::POLL_FD_READWRITE.bits(),
     )
 };
@@ -98,6 +107,7 @@ const STDERR_DEFAULT_RIGHTS: Rights = STDOUT_DEFAULT_RIGHTS;
 pub const MAX_SYMLINKS: u32 = 128;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct Inode(u64);
 
 impl Inode {
@@ -114,20 +124,85 @@ impl Inode {
 pub struct InodeGuard {
     ino: Inode,
     inner: Arc<InodeVal>,
+
+    // This exists because self.inner doesn't really represent the
+    // number of FDs referencing this InodeGuard. We need that number
+    // so we can know when to drop the file handle, which should result
+    // in the backing file (which may be a host file) getting closed.
+    open_handles: Arc<AtomicI32>,
 }
 impl InodeGuard {
     pub fn ino(&self) -> Inode {
         self.ino
     }
+
     pub fn downgrade(&self) -> InodeWeakGuard {
         InodeWeakGuard {
             ino: self.ino,
+            open_handles: self.open_handles.clone(),
             inner: Arc::downgrade(&self.inner),
         }
     }
+
     pub fn ref_cnt(&self) -> usize {
         Arc::strong_count(&self.inner)
     }
+
+    pub fn handle_count(&self) -> u32 {
+        self.open_handles.load(Ordering::SeqCst) as u32
+    }
+
+    pub fn acquire_handle(&self) {
+        let prev_handles = self.open_handles.fetch_add(1, Ordering::SeqCst);
+        trace!(ino = %self.ino.0, new_count = %(prev_handles + 1), "acquiring handle for InodeGuard");
+    }
+
+    pub fn drop_one_handle(&self) {
+        let prev_handles = self.open_handles.fetch_sub(1, Ordering::SeqCst);
+
+        trace!(ino = %self.ino.0, %prev_handles, "dropping handle for InodeGuard");
+
+        // If this wasn't the last handle, nothing else to do...
+        if prev_handles > 1 {
+            return;
+        }
+
+        // ... otherwise, drop the VirtualFile reference
+        let mut guard = self.inner.write();
+
+        // Must have at least one open handle before we can drop.
+        // This check happens after `inner` is locked so we can
+        // poison the lock and keep people from using this (possibly
+        // corrupt) InodeGuard.
+        if prev_handles != 1 {
+            panic!("InodeGuard handle dropped too many times");
+        }
+
+        // Re-check the open handles to account for race conditions
+        if self.open_handles.load(Ordering::SeqCst) != 0 {
+            return;
+        }
+
+        let ino = self.ino.0;
+        trace!(%ino, "InodeGuard has no more open handles");
+
+        match guard.deref_mut() {
+            Kind::File { handle, .. } if handle.is_some() => {
+                let file_ref_count = Arc::strong_count(handle.as_ref().unwrap());
+                trace!(%file_ref_count, %ino, "dropping file handle");
+                drop(handle.take().unwrap());
+            }
+            Kind::PipeRx { rx } => {
+                trace!(%ino, "closing pipe rx");
+                rx.close();
+            }
+            Kind::PipeTx { tx } => {
+                trace!(%ino, "closing pipe tx");
+                tx.close();
+            }
+            _ => (),
+        }
+    }
 }
 impl std::ops::Deref for InodeGuard {
     type Target = InodeVal;
@@ -139,6 +214,10 @@ impl std::ops::Deref for InodeGuard {
 #[derive(Debug, Clone)]
 pub struct InodeWeakGuard {
     ino: Inode,
+    // Needed for when we want to upgrade back. We don't exactly
+    // care too much when the AtomicI32 is dropped, so this is
+    // a strong reference to keep things simple.
+    open_handles: Arc<AtomicI32>,
     inner: Weak<InodeVal>,
 }
 impl InodeWeakGuard {
@@ -148,6 +227,7 @@ impl InodeWeakGuard {
     pub fn upgrade(&self) -> Option<InodeGuard> {
         Weak::upgrade(&self.inner).map(|inner| InodeGuard {
             ino: self.ino,
+            open_handles: self.open_handles.clone(),
             inner,
         })
     }
@@ -191,57 +271,48 @@ impl WasiInodes {
             guard.lookup.retain(|_, v| Weak::strong_count(v) > 0);
         }
 
-        InodeGuard { ino, inner: val }
+        let open_handles = Arc::new(AtomicI32::new(0));
+
+        InodeGuard {
+            ino,
+            open_handles,
+            inner: val,
+        }
     }
 
     /// Get the `VirtualFile` object at stdout
-    pub(crate) fn stdout(
-        fd_map: &RwLock<AHashMap<u32, Fd>>,
-    ) -> Result<InodeValFileReadGuard, FsError> {
+    pub(crate) fn stdout(fd_map: &RwLock<FdList>) -> Result<InodeValFileReadGuard, FsError> {
         Self::std_dev_get(fd_map, __WASI_STDOUT_FILENO)
     }
     /// Get the `VirtualFile` object at stdout mutably
-    pub(crate) fn stdout_mut(
-        fd_map: &RwLock<AHashMap<u32, Fd>>,
-    ) -> Result<InodeValFileWriteGuard, FsError> {
+    pub(crate) fn stdout_mut(fd_map: &RwLock<FdList>) -> Result<InodeValFileWriteGuard, FsError> {
         Self::std_dev_get_mut(fd_map, __WASI_STDOUT_FILENO)
     }
 
     /// Get the `VirtualFile` object at stderr
-    pub(crate) fn stderr(
-        fd_map: &RwLock<AHashMap<u32, Fd>>,
-    ) -> Result<InodeValFileReadGuard, FsError> {
+    pub(crate) fn stderr(fd_map: &RwLock<FdList>) -> Result<InodeValFileReadGuard, FsError> {
         Self::std_dev_get(fd_map, __WASI_STDERR_FILENO)
     }
     /// Get the `VirtualFile` object at stderr mutably
-    pub(crate) fn stderr_mut(
-        fd_map: &RwLock<AHashMap<u32, Fd>>,
-    ) -> Result<InodeValFileWriteGuard, FsError> {
+    pub(crate) fn stderr_mut(fd_map: &RwLock<FdList>) -> Result<InodeValFileWriteGuard, FsError> {
         Self::std_dev_get_mut(fd_map, __WASI_STDERR_FILENO)
     }
 
     /// Get the `VirtualFile` object at stdin
     /// TODO: Review why this is dead
     #[allow(dead_code)]
-    pub(crate) fn stdin(
-        fd_map: &RwLock<AHashMap<u32, Fd>>,
-    ) -> Result<InodeValFileReadGuard, FsError> {
+    pub(crate) fn stdin(fd_map: &RwLock<FdList>) -> Result<InodeValFileReadGuard, FsError> {
         Self::std_dev_get(fd_map, __WASI_STDIN_FILENO)
     }
     /// Get the `VirtualFile` object at stdin mutably
-    pub(crate) fn stdin_mut(
-        fd_map: &RwLock<AHashMap<u32, Fd>>,
-    ) -> Result<InodeValFileWriteGuard, FsError> {
+    pub(crate) fn stdin_mut(fd_map: &RwLock<FdList>) -> Result<InodeValFileWriteGuard, FsError> {
         Self::std_dev_get_mut(fd_map, __WASI_STDIN_FILENO)
     }
 
     /// Internal helper function to get a standard device handle.
     /// Expects one of `__WASI_STDIN_FILENO`, `__WASI_STDOUT_FILENO`, `__WASI_STDERR_FILENO`.
-    fn std_dev_get(
-        fd_map: &RwLock<AHashMap<u32, Fd>>,
-        fd: WasiFd,
-    ) -> Result<InodeValFileReadGuard, FsError> {
-        if let Some(fd) = fd_map.read().unwrap().get(&fd) {
+    fn std_dev_get(fd_map: &RwLock<FdList>, fd: WasiFd) -> Result<InodeValFileReadGuard, FsError> {
+        if let Some(fd) = fd_map.read().unwrap().get(fd) {
             let guard = fd.inode.read();
             if let Kind::File {
                 handle: Some(handle),
@@ -261,10 +332,10 @@ impl WasiInodes {
     /// Internal helper function to mutably get a standard device handle.
     /// Expects one of `__WASI_STDIN_FILENO`, `__WASI_STDOUT_FILENO`, `__WASI_STDERR_FILENO`.
     fn std_dev_get_mut(
-        fd_map: &RwLock<AHashMap<u32, Fd>>,
+        fd_map: &RwLock<FdList>,
         fd: WasiFd,
     ) -> Result<InodeValFileWriteGuard, FsError> {
-        if let Some(fd) = fd_map.read().unwrap().get(&fd) {
+        if let Some(fd) = fd_map.read().unwrap().get(fd) {
             let guard = fd.inode.read();
             if let Kind::File {
                 handle: Some(handle),
@@ -450,81 +521,18 @@ fn create_dir_all(fs: &dyn FileSystem, path: &Path) -> Result<(), virtual_fs::Fs
     Ok(())
 }
 
-/// This needs to be exposed so that the multiple use-cases are able
-/// to generated unique file descriptors and update the seed during
-/// journal restoration
-#[derive(Debug, Clone)]
-#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-pub struct WasiFdSeed {
-    next_fd: Arc<AtomicU32>,
-}
-
-impl Default for WasiFdSeed {
-    fn default() -> Self {
-        Self::new(3)
-    }
-}
-
-impl WasiFdSeed {
-    pub fn new(initial_val: u32) -> Self {
-        Self {
-            next_fd: Arc::new(AtomicU32::new(initial_val)),
-        }
-    }
-
-    pub fn fork(&self) -> Self {
-        Self {
-            next_fd: Arc::new(AtomicU32::new(self.next_fd.load(Ordering::SeqCst))),
-        }
-    }
-
-    pub fn next_val(&self) -> WasiFd {
-        self.next_fd.fetch_add(1, Ordering::SeqCst)
-    }
-
-    pub fn set_val(&self, val: WasiFd) {
-        self.next_fd.store(val, std::sync::atomic::Ordering::SeqCst)
-    }
-
-    pub fn cur_val(&self) -> WasiFd {
-        self.next_fd.load(Ordering::SeqCst)
-    }
-
-    pub fn clip_val(&self, fd: WasiFd) {
-        loop {
-            let existing = self.next_fd.load(Ordering::SeqCst);
-            if existing >= fd {
-                return;
-            }
-            if self
-                .next_fd
-                .compare_exchange(existing, fd, Ordering::SeqCst, Ordering::Relaxed)
-                .is_ok()
-            {
-                break;
-            }
-        }
-    }
-}
-
 /// Warning, modifying these fields directly may cause invariants to break and
 /// should be considered unsafe.  These fields may be made private in a future release
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct WasiFs {
     //pub repo: Repo,
     pub preopen_fds: RwLock<Vec<u32>>,
-    pub fd_map: Arc<RwLock<AHashMap<WasiFd, Fd>>>,
-    pub next_fd: WasiFdSeed,
-    // The Unix spec requires newly allocated FDs to always be the lowest-numbered
-    // FD available. We keep track of freed (i.e. closed) FDs in a min-heap to
-    // reuse them and fulfill this requirement.
-    // Note: BinaryHeap is a max-heap, we need Reverse to make it a min-heap.
-    pub freed_fds: Arc<RwLock<BinaryHeap<Reverse<WasiFd>>>>,
+    pub fd_map: RwLock<FdList>,
     pub current_dir: Mutex<String>,
     #[cfg_attr(feature = "enable-serde", serde(skip, default))]
     pub root_fs: WasiFsRoot,
     pub root_inode: InodeGuard,
-    pub has_unioned: Arc<Mutex<HashSet<PackageId>>>,
+    pub has_unioned: Mutex<HashSet<PackageId>>,
 
     // TODO: remove
     // using an atomic is a hack to enable customization after construction,
@@ -551,49 +559,60 @@ impl WasiFs {
 
     /// Forking the WasiState is used when either fork or vfork is called
     pub fn fork(&self) -> Self {
-        let fd_map = self.fd_map.read().unwrap().clone();
-        let freed_fds = self.freed_fds.read().unwrap().clone();
         Self {
             preopen_fds: RwLock::new(self.preopen_fds.read().unwrap().clone()),
-            fd_map: Arc::new(RwLock::new(fd_map)),
-            next_fd: self.next_fd.fork(),
-            freed_fds: Arc::new(RwLock::new(freed_fds)),
+            fd_map: RwLock::new(self.fd_map.read().unwrap().clone()),
             current_dir: Mutex::new(self.current_dir.lock().unwrap().clone()),
             is_wasix: AtomicBool::new(self.is_wasix.load(Ordering::Acquire)),
             root_fs: self.root_fs.clone(),
             root_inode: self.root_inode.clone(),
-            has_unioned: Arc::new(Mutex::new(HashSet::new())),
+            has_unioned: Mutex::new(self.has_unioned.lock().unwrap().clone()),
             init_preopens: self.init_preopens.clone(),
             init_vfs_preopens: self.init_vfs_preopens.clone(),
         }
     }
 
-    fn get_first_free_fd(&self) -> WasiFd {
-        let mut freed_fds = self.freed_fds.write().unwrap();
+    /// Closes all the file handles.
+    pub async fn close_cloexec_fds(&self) {
+        let to_close = {
+            if let Ok(map) = self.fd_map.read() {
+                map.iter()
+                    .filter_map(|(k, v)| {
+                        if v.inner.fd_flags.contains(Fdflagsext::CLOEXEC)
+                            && !v.is_stdio
+                            && !v.inode.is_preopened
+                        {
+                            tracing::trace!(fd = %k, "Closing FD due to CLOEXEC flag");
+                            Some(k)
+                        } else {
+                            None
+                        }
+                    })
+                    .collect::<HashSet<_>>()
+            } else {
+                HashSet::new()
+            }
+        };
 
-        match freed_fds.pop() {
-            Some(Reverse(fd)) => fd,
-            None => self.next_fd.next_val(),
-        }
-    }
+        let _ = tokio::join!(async {
+            for fd in &to_close {
+                self.flush(*fd).await.ok();
+                self.close_fd(*fd).ok();
+            }
+        });
 
-    /// We need to clear the freed FD list when the journal is replayed as it
-    /// will close lots of file descriptors which will fill the list. We clear
-    /// the list and allocate new FD's instead.
-    ///
-    /// This should only be used when the file descriptors are being managed
-    /// externally (e.g. journals)
-    pub(crate) fn clear_freed_fd_list(&self) {
-        let mut freed_fds = self.freed_fds.write().unwrap();
-        freed_fds.clear();
+        if let Ok(mut map) = self.fd_map.write() {
+            for fd in &to_close {
+                map.remove(*fd);
+            }
+        }
     }
 
     /// Closes all the file handles.
-    #[allow(clippy::await_holding_lock)]
     pub async fn close_all(&self) {
         let mut to_close = {
             if let Ok(map) = self.fd_map.read() {
-                map.keys().copied().collect::<HashSet<_>>()
+                map.keys().collect::<HashSet<_>>()
             } else {
                 HashSet::new()
             }
@@ -646,7 +665,7 @@ impl WasiFs {
 
     /// Converts a relative path into an absolute path
     pub(crate) fn relative_path_to_absolute(&self, mut path: String) -> String {
-        if path.starts_with("./") {
+        if !path.starts_with("/") {
             let current_dir = self.current_dir.lock().unwrap();
             path = format!("{}{}", current_dir.as_str(), &path[1..]);
             if path.contains("//") {
@@ -676,20 +695,18 @@ impl WasiFs {
         let root_inode = inodes.add_inode_val(InodeVal {
             stat: RwLock::new(stat),
             is_preopened: true,
-            name: "/".into(),
+            name: RwLock::new("/".into()),
             kind: RwLock::new(root_kind),
         });
 
         let wasi_fs = Self {
             preopen_fds: RwLock::new(vec![]),
-            fd_map: Arc::new(RwLock::new(AHashMap::new())),
-            next_fd: WasiFdSeed::default(),
-            freed_fds: Arc::new(RwLock::new(BinaryHeap::new())),
+            fd_map: RwLock::new(FdList::new()),
             current_dir: Mutex::new("/".to_string()),
             is_wasix: AtomicBool::new(false),
             root_fs: fs_backing,
             root_inode,
-            has_unioned: Arc::new(Mutex::new(HashSet::new())),
+            has_unioned: Mutex::new(HashSet::new()),
             init_preopens: Default::default(),
             init_vfs_preopens: Default::default(),
         };
@@ -711,6 +728,7 @@ impl WasiFs {
     ///   unlikely in pratice.  [Join the discussion](https://github.com/wasmerio/wasmer/issues/1219)
     ///   for what the newer, safer WASI FS APIs should look like.
     #[allow(dead_code)]
+    #[allow(clippy::too_many_arguments)]
     pub unsafe fn open_dir_all(
         &mut self,
         inodes: &WasiInodes,
@@ -719,6 +737,7 @@ impl WasiFs {
         rights: Rights,
         rights_inheriting: Rights,
         flags: Fdflags,
+        fd_flags: Fdflagsext,
     ) -> Result<WasiFd, FsError> {
         // TODO: check permissions here? probably not, but this should be
         // an explicit choice, so justify it in a comment when we remove this one
@@ -774,6 +793,7 @@ impl WasiFs {
             rights,
             rights_inheriting,
             flags,
+            fd_flags,
             Fd::READ | Fd::WRITE,
             cur_inode,
         )
@@ -783,6 +803,7 @@ impl WasiFs {
     /// Opens a user-supplied file in the directory specified with the
     /// name and flags given
     // dead code because this is an API for external use
+    // TODO: is this used anywhere? Is it even sound?
     #[allow(dead_code, clippy::too_many_arguments)]
     pub fn open_file_at(
         &mut self,
@@ -794,6 +815,7 @@ impl WasiFs {
         rights: Rights,
         rights_inheriting: Rights,
         flags: Fdflags,
+        fd_flags: Fdflagsext,
     ) -> Result<WasiFd, FsError> {
         // TODO: check permissions here? probably not, but this should be
         // an explicit choice, so justify it in a comment when we remove this one
@@ -810,7 +832,7 @@ impl WasiFs {
                 let kind = Kind::File {
                     handle: Some(Arc::new(RwLock::new(file))),
                     path: PathBuf::from(""),
-                    fd: Some(self.get_first_free_fd()),
+                    fd: None,
                 };
 
                 drop(guard);
@@ -831,8 +853,28 @@ impl WasiFs {
                     }
                 }
 
-                self.create_fd(rights, rights_inheriting, flags, open_flags, inode)
-                    .map_err(fs_error_from_wasi_err)
+                // Here, we clone the inode so we can use it to overwrite the fd field below.
+                let real_fd = self
+                    .create_fd(
+                        rights,
+                        rights_inheriting,
+                        flags,
+                        fd_flags,
+                        open_flags,
+                        inode.clone(),
+                    )
+                    .map_err(fs_error_from_wasi_err)?;
+
+                {
+                    let mut guard = inode.kind.write().unwrap();
+                    if let Kind::File { ref mut fd, .. } = *guard {
+                        *fd = Some(real_fd);
+                    } else {
+                        unreachable!("We just created a Kind::File");
+                    }
+                }
+
+                Ok(real_fd)
             }
             _ => Err(FsError::BaseNotDirectory),
         }
@@ -984,6 +1026,13 @@ impl WasiFs {
 
         // TODO: rights checks
         'path_iter: for (i, component) in path.components().enumerate() {
+            // Since we're resolving the path against the given inode, we want to
+            // assume '/a/b' to be the same as `a/b` relative to the inode, so
+            // we skip over the RootDir component.
+            if matches!(component, Component::RootDir) {
+                continue;
+            }
+
             // used to terminate symlink resolution properly
             let last_component = i + 1 == n_components;
             // for each component traverse file structure
@@ -1180,7 +1229,9 @@ impl WasiFs {
                     }
                     Kind::File { .. }
                     | Kind::Socket { .. }
-                    | Kind::Pipe { .. }
+                    | Kind::PipeRx { .. }
+                    | Kind::PipeTx { .. }
+                    | Kind::DuplexPipe { .. }
                     | Kind::EventNotifications { .. }
                     | Kind::Epoll { .. } => {
                         return Err(Errno::Notdir);
@@ -1256,7 +1307,7 @@ impl WasiFs {
             },
         }
 
-        impl<'a> BaseFdAndRelPath<'a> {
+        impl BaseFdAndRelPath<'_> {
             const fn max_seen(&self) -> usize {
                 match self {
                     Self::None => 0,
@@ -1268,7 +1319,14 @@ impl WasiFs {
         // for each preopened directory
         let preopen_fds = self.preopen_fds.read().unwrap();
         for po_fd in preopen_fds.deref() {
-            let po_inode = self.fd_map.read().unwrap()[po_fd].inode.clone();
+            let po_inode = self
+                .fd_map
+                .read()
+                .unwrap()
+                .get(*po_fd)
+                .unwrap()
+                .inode
+                .clone();
             let guard = po_inode.read();
             let po_path = match guard.deref() {
                 Kind::Dir { path, .. } => &**path,
@@ -1337,14 +1395,7 @@ impl WasiFs {
         follow_symlinks: bool,
     ) -> Result<InodeGuard, Errno> {
         let base_inode = self.get_fd_inode(base)?;
-        let start_inode =
-            if !base_inode.deref().name.starts_with('/') && self.is_wasix.load(Ordering::Acquire) {
-                let (cur_inode, _) = self.get_current_dir(inodes, base)?;
-                cur_inode
-            } else {
-                self.get_fd_inode(base)?
-            };
-        self.get_inode_at_path_inner(inodes, start_inode, path, 0, follow_symlinks)
+        self.get_inode_at_path_inner(inodes, base_inode, path, 0, follow_symlinks)
     }
 
     /// Returns the parent Dir or Root that the file at a given path is in and the file name
@@ -1376,16 +1427,19 @@ impl WasiFs {
             .fd_map
             .read()
             .unwrap()
-            .get(&fd)
+            .get(fd)
             .ok_or(Errno::Badf)
-            .map(|a| a.clone());
+            .cloned();
 
         if ret.is_err() && fd == VIRTUAL_ROOT_FD {
             Ok(Fd {
-                rights: ALL_RIGHTS,
-                rights_inheriting: ALL_RIGHTS,
-                flags: Fdflags::empty(),
-                offset: Arc::new(AtomicU64::new(0)),
+                inner: FdInner {
+                    rights: ALL_RIGHTS,
+                    rights_inheriting: ALL_RIGHTS,
+                    flags: Fdflags::empty(),
+                    offset: Arc::new(AtomicU64::new(0)),
+                    fd_flags: Fdflagsext::empty(),
+                },
                 open_flags: 0,
                 inode: self.root_inode.clone(),
                 is_stdio: false,
@@ -1403,7 +1457,7 @@ impl WasiFs {
         self.fd_map
             .read()
             .unwrap()
-            .get(&fd)
+            .get(fd)
             .ok_or(Errno::Badf)
             .map(|a| a.inode.clone())
     }
@@ -1474,9 +1528,9 @@ impl WasiFs {
                 },
                 _ => Filetype::Unknown,
             },
-            fs_flags: fd.flags,
-            fs_rights_base: fd.rights,
-            fs_rights_inheriting: fd.rights_inheriting, // TODO(lachlan): Is this right?
+            fs_flags: fd.inner.flags,
+            fs_rights_base: fd.inner.rights,
+            fs_rights_inheriting: fd.inner.rights_inheriting, // TODO(lachlan): Is this right?
         })
     }
 
@@ -1498,7 +1552,7 @@ impl WasiFs {
                 // REVIEW:
                 // no need for +1, because there is no 0 end-of-string marker
                 // john: removing the +1 seems cause regression issues
-                pr_name_len: inode_val.name.len() as u32 + 1,
+                pr_name_len: inode_val.name.read().unwrap().len() as u32 + 1,
             }
             .untagged(),
         }
@@ -1520,7 +1574,7 @@ impl WasiFs {
             }
             _ => {
                 let fd = self.get_fd(fd)?;
-                if !fd.rights.contains(Rights::FD_DATASYNC) {
+                if !fd.inner.rights.contains(Rights::FD_DATASYNC) {
                     return Err(Errno::Access);
                 }
 
@@ -1609,7 +1663,7 @@ impl WasiFs {
         inodes.add_inode_val(InodeVal {
             stat: RwLock::new(stat),
             is_preopened,
-            name,
+            name: RwLock::new(name),
             kind: RwLock::new(kind),
         })
     }
@@ -1618,99 +1672,123 @@ impl WasiFs {
         &self,
         rights: Rights,
         rights_inheriting: Rights,
-        flags: Fdflags,
+        fs_flags: Fdflags,
+        fd_flags: Fdflagsext,
         open_flags: u16,
         inode: InodeGuard,
     ) -> Result<WasiFd, Errno> {
-        let idx = self.get_first_free_fd();
         self.create_fd_ext(
             rights,
             rights_inheriting,
-            flags,
+            fs_flags,
+            fd_flags,
             open_flags,
             inode,
-            idx,
+            None,
             false,
-        )?;
-        Ok(idx)
+        )
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn with_fd(
         &self,
         rights: Rights,
         rights_inheriting: Rights,
-        flags: Fdflags,
+        fs_flags: Fdflags,
+        fd_flags: Fdflagsext,
         open_flags: u16,
         inode: InodeGuard,
         idx: WasiFd,
     ) -> Result<(), Errno> {
-        self.make_max_fd(idx + 1);
         self.create_fd_ext(
             rights,
             rights_inheriting,
-            flags,
+            fs_flags,
+            fd_flags,
             open_flags,
             inode,
-            idx,
+            Some(idx),
             true,
         )?;
         Ok(())
     }
 
-    pub fn make_max_fd(&self, fd: u32) {
-        self.next_fd.clip_val(fd);
-    }
-
     #[allow(clippy::too_many_arguments)]
     pub fn create_fd_ext(
         &self,
         rights: Rights,
         rights_inheriting: Rights,
-        flags: Fdflags,
+        fs_flags: Fdflags,
+        fd_flags: Fdflagsext,
         open_flags: u16,
         inode: InodeGuard,
-        idx: WasiFd,
+        idx: Option<WasiFd>,
         exclusive: bool,
-    ) -> Result<(), Errno> {
+    ) -> Result<WasiFd, Errno> {
         let is_stdio = matches!(
             idx,
-            __WASI_STDIN_FILENO | __WASI_STDOUT_FILENO | __WASI_STDERR_FILENO
+            Some(__WASI_STDIN_FILENO) | Some(__WASI_STDOUT_FILENO) | Some(__WASI_STDERR_FILENO)
         );
-        let mut guard = self.fd_map.write().unwrap();
-        if exclusive && guard.contains_key(&idx) {
-            return Err(Errno::Exist);
-        }
-        guard.insert(
-            idx,
-            Fd {
+        let fd = Fd {
+            inner: FdInner {
                 rights,
                 rights_inheriting,
-                flags,
+                flags: fs_flags,
                 offset: Arc::new(AtomicU64::new(0)),
-                open_flags,
-                inode,
-                is_stdio,
+                fd_flags,
             },
-        );
-        Ok(())
+            open_flags,
+            inode,
+            is_stdio,
+        };
+
+        let mut guard = self.fd_map.write().unwrap();
+
+        match idx {
+            Some(idx) => {
+                if guard.insert(exclusive, idx, fd) {
+                    Ok(idx)
+                } else {
+                    Err(Errno::Exist)
+                }
+            }
+            None => Ok(guard.insert_first_free(fd)),
+        }
     }
 
     pub fn clone_fd(&self, fd: WasiFd) -> Result<WasiFd, Errno> {
+        self.clone_fd_ext(fd, 0, None)
+    }
+
+    pub fn clone_fd_ext(
+        &self,
+        fd: WasiFd,
+        min_result_fd: WasiFd,
+        cloexec: Option<bool>,
+    ) -> Result<WasiFd, Errno> {
         let fd = self.get_fd(fd)?;
-        let idx = self.get_first_free_fd();
-        self.fd_map.write().unwrap().insert(
-            idx,
+        Ok(self.fd_map.write().unwrap().insert_first_free_after(
             Fd {
-                rights: fd.rights,
-                rights_inheriting: fd.rights_inheriting,
-                flags: fd.flags,
-                offset: fd.offset.clone(),
+                inner: FdInner {
+                    rights: fd.inner.rights,
+                    rights_inheriting: fd.inner.rights_inheriting,
+                    flags: fd.inner.flags,
+                    offset: fd.inner.offset.clone(),
+                    fd_flags: match cloexec {
+                        None => fd.inner.fd_flags,
+                        Some(cloexec) => {
+                            let mut f = fd.inner.fd_flags;
+                            f.set(Fdflagsext::CLOEXEC, cloexec);
+                            f
+                        }
+                    },
+                },
                 open_flags: fd.open_flags,
                 inode: fd.inode,
                 is_stdio: fd.is_stdio,
             },
-        );
-        Ok(idx)
+            min_result_fd,
+        ))
     }
 
     /// Low level function to remove an inode, that is it deletes the WASI FS's
@@ -1789,10 +1867,11 @@ impl WasiFs {
                 root_rights,
                 root_rights,
                 Fdflags::empty(),
+                Fdflagsext::empty(),
                 Fd::READ,
                 self.root_inode.clone(),
             )
-            .map_err(|e| format!("Could not create root fd: {}", e))?;
+            .map_err(|e| format!("Could not create root fd: {e}"))?;
         self.preopen_fds.write().unwrap().push(fd);
         Ok(())
     }
@@ -1825,23 +1904,26 @@ impl WasiFs {
                 .create_inode(inodes, kind, true, preopen_name.clone())
                 .map_err(|e| {
                     format!(
-                        "Failed to create inode for preopened dir (name `{}`): WASI error code: {}",
-                        preopen_name, e
+                        "Failed to create inode for preopened dir (name `{preopen_name}`): WASI error code: {e}",
                     )
                 })?;
             let fd_flags = Fd::READ;
             let fd = self
-                .create_fd(rights, rights, Fdflags::empty(), fd_flags, inode.clone())
-                .map_err(|e| format!("Could not open fd for file {:?}: {}", preopen_name, e))?;
+                .create_fd(
+                    rights,
+                    rights,
+                    Fdflags::empty(),
+                    Fdflagsext::empty(),
+                    fd_flags,
+                    inode.clone(),
+                )
+                .map_err(|e| format!("Could not open fd for file {preopen_name:?}: {e}"))?;
             {
                 let mut guard = self.root_inode.write();
                 if let Kind::Root { entries } = guard.deref_mut() {
                     let existing_entry = entries.insert(preopen_name.clone(), inode);
                     if existing_entry.is_some() && !ignore_duplicates {
-                        return Err(format!(
-                            "Found duplicate entry for alias `{}`",
-                            preopen_name
-                        ));
+                        return Err(format!("Found duplicate entry for alias `{preopen_name}`"));
                     }
                 }
             }
@@ -1864,7 +1946,7 @@ impl WasiFs {
             let cur_dir_metadata = self
                 .root_fs
                 .metadata(path)
-                .map_err(|e| format!("Could not get metadata for file {:?}: {}", path, e))?;
+                .map_err(|e| format!("Could not get metadata for file {path:?}: {e}"))?;
 
             let kind = if cur_dir_metadata.is_dir() {
                 Kind::Dir {
@@ -1928,10 +2010,7 @@ impl WasiFs {
                 self.create_inode(inodes, kind, true, path.to_string_lossy().into_owned())
             }
             .map_err(|e| {
-                format!(
-                    "Failed to create inode for preopened dir: WASI error code: {}",
-                    e
-                )
+                format!("Failed to create inode for preopened dir: WASI error code: {e}")
             })?;
             let fd_flags = {
                 let mut fd_flags = 0;
@@ -1948,8 +2027,15 @@ impl WasiFs {
                 fd_flags
             };
             let fd = self
-                .create_fd(rights, rights, Fdflags::empty(), fd_flags, inode.clone())
-                .map_err(|e| format!("Could not open fd for file {:?}: {}", path, e))?;
+                .create_fd(
+                    rights,
+                    rights,
+                    Fdflags::empty(),
+                    Fdflagsext::empty(),
+                    fd_flags,
+                    inode.clone(),
+                )
+                .map_err(|e| format!("Could not open fd for file {path:?}: {e}"))?;
             {
                 let mut guard = self.root_inode.write();
                 if let Kind::Root { entries } = guard.deref_mut() {
@@ -1960,7 +2046,7 @@ impl WasiFs {
                     };
                     let existing_entry = entries.insert(key.clone(), inode);
                     if existing_entry.is_some() && !ignore_duplicates {
-                        return Err(format!("Found duplicate entry for alias `{}`", key));
+                        return Err(format!("Found duplicate entry for alias `{key}`"));
                     }
                 }
             }
@@ -1995,19 +2081,23 @@ impl WasiFs {
             inodes.add_inode_val(InodeVal {
                 stat: RwLock::new(stat),
                 is_preopened: true,
-                name: name.to_string().into(),
+                name: RwLock::new(name.to_string().into()),
                 kind: RwLock::new(kind),
             })
         };
         self.fd_map.write().unwrap().insert(
+            false,
             raw_fd,
             Fd {
-                rights,
-                rights_inheriting: Rights::empty(),
-                flags: fd_flags,
+                inner: FdInner {
+                    rights,
+                    rights_inheriting: Rights::empty(),
+                    flags: fd_flags,
+                    offset: Arc::new(AtomicU64::new(0)),
+                    fd_flags: Fdflagsext::empty(),
+                },
                 // since we're not calling open on this, we don't need open flags
                 open_flags: 0,
-                offset: Arc::new(AtomicU64::new(0)),
                 inode,
                 is_stdio: true,
             },
@@ -2044,7 +2134,8 @@ impl WasiFs {
                 path_to_symlink,
                 ..
             } => {
-                let base_po_inode = &self.fd_map.read().unwrap()[base_po_dir].inode;
+                let guard = self.fd_map.read().unwrap();
+                let base_po_inode = &guard.get(*base_po_dir).unwrap().inode;
                 let guard = base_po_inode.read();
                 match guard.deref() {
                     Kind::Root { .. } => {
@@ -2081,12 +2172,9 @@ impl WasiFs {
     pub(crate) fn close_fd(&self, fd: WasiFd) -> Result<(), Errno> {
         let mut fd_map = self.fd_map.write().unwrap();
 
-        let pfd = fd_map.remove(&fd).ok_or(Errno::Badf);
+        let pfd = fd_map.remove(fd).ok_or(Errno::Badf);
         match pfd {
             Ok(fd_ref) => {
-                let mut freed_fds = self.freed_fds.write().unwrap();
-                freed_fds.push(Reverse(fd));
-
                 let inode = fd_ref.inode.ino().as_u64();
                 let ref_cnt = fd_ref.inode.ref_cnt();
                 if ref_cnt == 1 {
@@ -2110,7 +2198,16 @@ impl std::fmt::Debug for WasiFs {
         } else {
             write!(f, "current_dir=(locked) ")?;
         }
-        write!(f, "next_fd={} ", self.next_fd.cur_val())?;
+        if let Ok(guard) = self.fd_map.read() {
+            write!(
+                f,
+                "next_fd={} max_fd={:?} ",
+                guard.next_free_fd(),
+                guard.last_fd()
+            )?;
+        } else {
+            write!(f, "next_fd=(locked) max_fd=(locked) ")?;
+        }
         write!(f, "{:?}", self.root_fs)
     }
 }
@@ -2119,7 +2216,7 @@ impl std::fmt::Debug for WasiFs {
 pub fn default_fs_backing() -> Box<dyn virtual_fs::FileSystem + Send + Sync> {
     cfg_if::cfg_if! {
         if #[cfg(feature = "host-fs")] {
-            Box::new(virtual_fs::host_fs::FileSystem::new(Handle::current(), "/").unwrap())
+            Box::new(virtual_fs::host_fs::FileSystem::new(tokio::runtime::Handle::current(), "/").unwrap())
         } else if #[cfg(not(feature = "host-fs"))] {
             Box::<virtual_fs::mem_fs::FileSystem>::default()
         } else {
diff --git a/lib/wasix/src/fs/notification.rs b/lib/wasix/src/fs/notification.rs
index 218ec093b4..46fb4c0190 100644
--- a/lib/wasix/src/fs/notification.rs
+++ b/lib/wasix/src/fs/notification.rs
@@ -4,6 +4,8 @@ use std::{
     task::{Poll, Waker},
 };
 
+use virtual_mio::{InterestHandler, InterestType};
+
 #[derive(Debug)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 struct NotificationState {
@@ -17,6 +19,9 @@ struct NotificationState {
     /// All the registered wakers
     #[cfg_attr(feature = "enable-serde", serde(skip))]
     wakers: VecDeque<Waker>,
+    /// InterestHandler for use with epoll
+    #[cfg_attr(feature = "enable-serde", serde(skip))]
+    interest_handler: Option<Box<dyn InterestHandler>>,
 }
 
 impl NotificationState {
@@ -31,6 +36,9 @@ impl NotificationState {
         while let Some(waker) = self.wakers.pop_front() {
             waker.wake();
         }
+        if let Some(handler) = self.interest_handler.as_mut() {
+            handler.push_interest(InterestType::Readable);
+        }
     }
 
     fn inc(&mut self, val: u64) {
@@ -70,6 +78,7 @@ impl NotificationInner {
                 last_poll: u64::MAX,
                 is_semaphore,
                 wakers: Default::default(),
+                interest_handler: None,
             }),
         }
     }
@@ -111,4 +120,14 @@ impl NotificationInner {
         let mut state = self.state.lock().unwrap();
         state.last_poll = u64::MAX;
     }
+
+    pub fn set_interest_handler(&self, handler: Box<dyn InterestHandler>) {
+        let mut state = self.state.lock().unwrap();
+        state.interest_handler.replace(handler);
+    }
+
+    pub fn remove_interest_handler(&self) -> Option<Box<dyn InterestHandler>> {
+        let mut state = self.state.lock().unwrap();
+        state.interest_handler.take()
+    }
 }
diff --git a/lib/wasix/src/http/client.rs b/lib/wasix/src/http/client.rs
index 824834d527..81b64237d7 100644
--- a/lib/wasix/src/http/client.rs
+++ b/lib/wasix/src/http/client.rs
@@ -1,28 +1,28 @@
-use std::{collections::HashSet, ops::Deref, sync::Arc};
+use std::{collections::BTreeSet, ops::Deref, sync::Arc};
 
 use futures::future::BoxFuture;
 use http::{HeaderMap, Method, StatusCode};
 use url::Url;
 
 /// Defines http client permissions.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct HttpClientCapabilityV1 {
     pub allow_all: bool,
-    pub allowed_hosts: HashSet<String>,
+    pub allowed_hosts: BTreeSet<String>,
 }
 
 impl HttpClientCapabilityV1 {
     pub fn new() -> Self {
         Self {
             allow_all: false,
-            allowed_hosts: HashSet::new(),
+            allowed_hosts: Default::default(),
         }
     }
 
     pub fn new_allow_all() -> Self {
         Self {
             allow_all: true,
-            allowed_hosts: HashSet::new(),
+            allowed_hosts: Default::default(),
         }
     }
 
@@ -95,7 +95,7 @@ impl std::fmt::Debug for HttpRequest {
         } = self;
 
         f.debug_struct("HttpRequest")
-            .field("url", &format_args!("{}", url))
+            .field("url", &format_args!("{url}"))
             .field("method", method)
             .field("headers", headers)
             .field("body", &body.as_deref().map(String::from_utf8_lossy))
diff --git a/lib/wasix/src/http/reqwest.rs b/lib/wasix/src/http/reqwest.rs
index bece975b19..1959ea28c1 100644
--- a/lib/wasix/src/http/reqwest.rs
+++ b/lib/wasix/src/http/reqwest.rs
@@ -1,4 +1,4 @@
-use std::{env, time::Duration};
+use std::time::Duration;
 
 use anyhow::Context;
 use futures::{future::BoxFuture, TryStreamExt};
@@ -37,6 +37,7 @@ impl ReqwestHttpClient {
         self
     }
 
+    #[tracing::instrument(skip_all, fields(method=?request.method, url=%request.url))]
     async fn request(&self, request: HttpRequest) -> Result<HttpResponse, anyhow::Error> {
         let method = reqwest::Method::try_from(request.method.as_str())
             .with_context(|| format!("Invalid http method {}", request.method))?;
@@ -44,14 +45,16 @@ impl ReqwestHttpClient {
         // TODO: use persistent client?
         let builder = {
             let _guard = Handle::try_current().map_err(|_| self.handle.enter());
-            let mut builder = reqwest::ClientBuilder::new().connect_timeout(self.connect_timeout);
-            if let Some(proxy) = get_proxy()? {
-                builder = builder.proxy(proxy);
+            let mut builder = reqwest::ClientBuilder::new();
+            #[cfg(not(feature = "js"))]
+            {
+                builder = builder.connect_timeout(self.connect_timeout);
             }
             builder
         };
         let client = builder.build().context("failed to create reqwest client")?;
 
+        tracing::debug!("sending http request");
         let mut builder = client.request(method, request.url.as_str());
         for (header, val) in &request.headers {
             builder = builder.header(header, val);
@@ -70,8 +73,11 @@ impl ReqwestHttpClient {
 
         let status = response.status();
 
+        tracing::debug!(status=?status, "received http response");
+
         // Download the body.
-        let data = if let Some(timeout) = self.response_body_chunk_timeout {
+        #[cfg(not(feature = "js"))]
+        let data = if let Some(timeout_duration) = self.response_body_chunk_timeout {
             // Download the body with a chunk timeout.
             // The timeout prevents long stalls.
 
@@ -83,7 +89,7 @@ impl ReqwestHttpClient {
             // is kept. Only if no chunk was downloaded within the timeout a
             // timeout error is raised.
             'OUTER: loop {
-                let timeout = tokio::time::sleep(timeout);
+                let timeout = tokio::time::sleep(timeout_duration);
                 pin_utils::pin_mut!(timeout);
 
                 let mut chunk_count = 0;
@@ -111,9 +117,11 @@ impl ReqwestHttpClient {
 
                         _ = &mut timeout => {
                             if chunk_count == 0 {
+                                tracing::warn!(timeout= "timeout while downloading response body");
                                 return Err(anyhow::anyhow!("Timeout while downloading response body"));
                             } else {
-                                // Timeout, but chunks were still downloaded, so
+                                tracing::debug!(downloaded_body_size_bytes=%buf.len(), "download progress");
+                                // Timeout, but chunks were downloaded, so
                                 // just continue with a fresh timeout.
                                 continue 'OUTER;
                             }
@@ -126,6 +134,10 @@ impl ReqwestHttpClient {
         } else {
             response.bytes().await?.to_vec()
         };
+        #[cfg(feature = "js")]
+        let data = response.bytes().await?.to_vec();
+
+        tracing::debug!(body_size_bytes=%data.len(), "downloaded http response body");
 
         Ok(HttpResponse {
             status,
@@ -137,19 +149,26 @@ impl ReqwestHttpClient {
 }
 
 impl super::HttpClient for ReqwestHttpClient {
+    #[cfg(not(feature = "js"))]
     fn request(&self, request: HttpRequest) -> BoxFuture<'_, Result<HttpResponse, anyhow::Error>> {
         let client = self.clone();
         let f = async move { client.request(request).await };
         Box::pin(f)
     }
-}
-
-pub fn get_proxy() -> Result<Option<reqwest::Proxy>, anyhow::Error> {
-    if let Ok(scheme) = env::var("http_proxy").or_else(|_| env::var("HTTP_PROXY")) {
-        let proxy = reqwest::Proxy::all(scheme)?;
 
-        Ok(Some(proxy))
-    } else {
-        Ok(None)
+    #[cfg(feature = "js")]
+    fn request(&self, request: HttpRequest) -> BoxFuture<'_, Result<HttpResponse, anyhow::Error>> {
+        let client = self.clone();
+        let (sender, receiver) = futures::channel::oneshot::channel();
+        wasm_bindgen_futures::spawn_local(async move {
+            let result = client.request(request).await;
+            let _ = sender.send(result);
+        });
+        Box::pin(async move {
+            match receiver.await {
+                Ok(result) => result,
+                Err(e) => Err(anyhow::Error::new(e)),
+            }
+        })
     }
 }
diff --git a/lib/wasix/src/journal/effector/mod.rs b/lib/wasix/src/journal/effector/mod.rs
index 45fb3f7767..e1c5bd7b9f 100644
--- a/lib/wasix/src/journal/effector/mod.rs
+++ b/lib/wasix/src/journal/effector/mod.rs
@@ -7,8 +7,8 @@ pub(super) use wasmer_types::MemorySize;
 pub(super) use wasmer_wasix_types::{
     types::__wasi_ciovec_t,
     wasi::{
-        Advice, EpollCtl, EpollEventCtl, Errno, ExitCode, Fd, Fdflags, Filesize, Fstflags,
-        LookupFlags, Oflags, Rights, Snapshot0Clockid, Timestamp, Whence,
+        Advice, EpollCtl, EpollEventCtl, Errno, ExitCode, Fd, Fdflags, Fdflagsext, Filesize,
+        Fstflags, LookupFlags, Oflags, Rights, Snapshot0Clockid, Timestamp, Whence,
     },
 };
 
@@ -37,6 +37,7 @@ mod syscalls {
     mod fd_pipe;
     mod fd_renumber;
     mod fd_seek;
+    mod fd_set_fdflags;
     mod fd_set_flags;
     mod fd_set_rights;
     mod fd_set_size;
@@ -69,6 +70,7 @@ mod syscalls {
     mod sock_leave_ipv6_multicast;
     mod sock_listen;
     mod sock_open;
+    mod sock_pair;
     mod sock_send;
     mod sock_send_file;
     mod sock_send_to;
diff --git a/lib/wasix/src/journal/effector/process_exit.rs b/lib/wasix/src/journal/effector/process_exit.rs
index d57264e50f..f831073a8e 100644
--- a/lib/wasix/src/journal/effector/process_exit.rs
+++ b/lib/wasix/src/journal/effector/process_exit.rs
@@ -31,7 +31,12 @@ impl JournalEffector {
         }
 
         // Reset the memory back to a zero size
-        let memory = ctx.data_mut().inner().memory().clone();
+        let memory = ctx
+            .data()
+            .inner()
+            .main_module_instance_handles()
+            .memory()
+            .clone();
         memory.reset(ctx)?;
         Ok(())
     }
diff --git a/lib/wasix/src/journal/effector/syscalls/chdir.rs b/lib/wasix/src/journal/effector/syscalls/chdir.rs
index aa3041a156..d23dc733dc 100644
--- a/lib/wasix/src/journal/effector/syscalls/chdir.rs
+++ b/lib/wasix/src/journal/effector/syscalls/chdir.rs
@@ -6,7 +6,7 @@ impl JournalEffector {
     }
 
     pub fn apply_chdir(ctx: &mut FunctionEnvMut<'_, WasiEnv>, path: &str) -> anyhow::Result<()> {
-        crate::syscalls::chdir_internal(ctx, path).map_err(|err| {
+        crate::syscalls::chdir_internal(ctx.data(), path).map_err(|err| {
             anyhow::format_err!(
                 "snapshot restore error: failed to change directory (path={}) - {}",
                 path,
diff --git a/lib/wasix/src/journal/effector/syscalls/epoll_create.rs b/lib/wasix/src/journal/effector/syscalls/epoll_create.rs
index c25d9608bf..8c5ec8a730 100644
--- a/lib/wasix/src/journal/effector/syscalls/epoll_create.rs
+++ b/lib/wasix/src/journal/effector/syscalls/epoll_create.rs
@@ -15,12 +15,12 @@ impl JournalEffector {
             })?;
 
         let ret = crate::syscalls::fd_renumber_internal(ctx, ret_fd, fd);
-        if ret != Errno::Success {
+        if !matches!(ret, Ok(Errno::Success)) {
             bail!(
                 "journal restore error: failed renumber file descriptor after epoll create (from={}, to={}) - {}",
                 ret_fd,
                 fd,
-                ret
+                ret.unwrap_or(Errno::Unknown)
             );
         }
 
diff --git a/lib/wasix/src/journal/effector/syscalls/fd_close.rs b/lib/wasix/src/journal/effector/syscalls/fd_close.rs
index 4ec6691869..423b9d46cb 100644
--- a/lib/wasix/src/journal/effector/syscalls/fd_close.rs
+++ b/lib/wasix/src/journal/effector/syscalls/fd_close.rs
@@ -8,6 +8,8 @@ impl JournalEffector {
     pub fn apply_fd_close(ctx: &mut FunctionEnvMut<'_, WasiEnv>, fd: Fd) -> anyhow::Result<()> {
         let env = ctx.data();
         let (_, state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+        // FIXME: the journal should use the same logic as the fd_close syscall,
+        // NOT invent its own!!
         if let Err(err) = state.fs.close_fd(fd) {
             bail!(
                 "journal restore error: failed to close descriptor (fd={}) - {}",
diff --git a/lib/wasix/src/journal/effector/syscalls/fd_duplicate.rs b/lib/wasix/src/journal/effector/syscalls/fd_duplicate.rs
index a53be32d4c..6f96f2548e 100644
--- a/lib/wasix/src/journal/effector/syscalls/fd_duplicate.rs
+++ b/lib/wasix/src/journal/effector/syscalls/fd_duplicate.rs
@@ -5,12 +5,14 @@ impl JournalEffector {
         ctx: &mut FunctionEnvMut<'_, WasiEnv>,
         original_fd: Fd,
         copied_fd: Fd,
+        cloexec: bool,
     ) -> anyhow::Result<()> {
         Self::save_event(
             ctx,
-            JournalEntry::DuplicateFileDescriptorV1 {
+            JournalEntry::DuplicateFileDescriptorV2 {
                 original_fd,
                 copied_fd,
+                cloexec,
             },
         )
     }
@@ -19,8 +21,9 @@ impl JournalEffector {
         ctx: &mut FunctionEnvMut<'_, WasiEnv>,
         original_fd: Fd,
         copied_fd: Fd,
+        cloexec: bool,
     ) -> anyhow::Result<()> {
-        let ret_fd = crate::syscalls::fd_dup_internal(ctx, original_fd)
+        let ret_fd = crate::syscalls::fd_dup_internal(ctx, original_fd, 0, cloexec)
             .map_err(|err| {
                 anyhow::format_err!(
                     "journal restore error: failed to duplicate file descriptor (original={}, copied={}) - {}",
@@ -30,15 +33,18 @@ impl JournalEffector {
                 )
             })?;
 
-        let ret = crate::syscalls::fd_renumber_internal(ctx, ret_fd, copied_fd);
-        if ret != Errno::Success {
-            bail!(
-                "journal restore error: failed renumber file descriptor after duplicate (from={}, to={}) - {}",
-                ret_fd,
-                copied_fd,
-                ret
-            );
+        if ret_fd != copied_fd {
+            let ret = crate::syscalls::fd_renumber_internal(ctx, ret_fd, copied_fd);
+            if !matches!(ret, Ok(Errno::Success)) {
+                bail!(
+                    "journal restore error: failed renumber file descriptor after duplicate (from={}, to={}) - {}",
+                    ret_fd,
+                    copied_fd,
+                    ret.unwrap_or(Errno::Unknown)
+                );
+            }
         }
+
         Ok(())
     }
 }
diff --git a/lib/wasix/src/journal/effector/syscalls/fd_pipe.rs b/lib/wasix/src/journal/effector/syscalls/fd_pipe.rs
index b99575477d..99434b2f0a 100644
--- a/lib/wasix/src/journal/effector/syscalls/fd_pipe.rs
+++ b/lib/wasix/src/journal/effector/syscalls/fd_pipe.rs
@@ -3,18 +3,18 @@ use super::*;
 impl JournalEffector {
     pub fn save_fd_pipe(
         ctx: &mut FunctionEnvMut<'_, WasiEnv>,
-        fd1: Fd,
-        fd2: Fd,
+        read_fd: Fd,
+        write_fd: Fd,
     ) -> anyhow::Result<()> {
-        Self::save_event(ctx, JournalEntry::CreatePipeV1 { fd1, fd2 })
+        Self::save_event(ctx, JournalEntry::CreatePipeV1 { read_fd, write_fd })
     }
 
     pub fn apply_fd_pipe(
         ctx: &mut FunctionEnvMut<'_, WasiEnv>,
-        fd1: Fd,
-        fd2: Fd,
+        read_fd: Fd,
+        write_fd: Fd,
     ) -> anyhow::Result<()> {
-        crate::syscalls::fd_pipe_internal(ctx, Some(fd1), Some(fd2)).map_err(|err| {
+        crate::syscalls::fd_pipe_internal(ctx, Some(read_fd), Some(write_fd)).map_err(|err| {
             anyhow::format_err!("journal restore error: failed to create pipe - {}", err)
         })?;
 
diff --git a/lib/wasix/src/journal/effector/syscalls/fd_renumber.rs b/lib/wasix/src/journal/effector/syscalls/fd_renumber.rs
index c439d753f2..4ed119dcc1 100644
--- a/lib/wasix/src/journal/effector/syscalls/fd_renumber.rs
+++ b/lib/wasix/src/journal/effector/syscalls/fd_renumber.rs
@@ -21,12 +21,12 @@ impl JournalEffector {
         to: Fd,
     ) -> anyhow::Result<()> {
         let ret = crate::syscalls::fd_renumber_internal(ctx, from, to);
-        if ret != Errno::Success {
+        if !matches!(ret, Ok(Errno::Success)) {
             bail!(
                 "journal restore error: failed to renumber descriptor (from={}, to={}) - {}",
                 from,
                 to,
-                ret
+                ret.unwrap_or(Errno::Unknown)
             );
         }
         Ok(())
diff --git a/lib/wasix/src/journal/effector/syscalls/fd_set_fdflags.rs b/lib/wasix/src/journal/effector/syscalls/fd_set_fdflags.rs
new file mode 100644
index 0000000000..1dd347962e
--- /dev/null
+++ b/lib/wasix/src/journal/effector/syscalls/fd_set_fdflags.rs
@@ -0,0 +1,27 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_fd_set_fdflags(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        flags: Fdflagsext,
+    ) -> anyhow::Result<()> {
+        Self::save_event(ctx, JournalEntry::FileDescriptorSetFdFlagsV1 { fd, flags })
+    }
+
+    pub fn apply_fd_set_fdflags(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        flags: Fdflagsext,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::fd_fdflags_set_internal(ctx, fd, flags).map_err(|err| {
+            anyhow::format_err!(
+                "journal restore error: failed to set file flags (fd={}, flags={:?}) - {}",
+                fd,
+                flags,
+                err
+            )
+        })?;
+        Ok(())
+    }
+}
diff --git a/lib/wasix/src/journal/effector/syscalls/fd_write.rs b/lib/wasix/src/journal/effector/syscalls/fd_write.rs
index 689adc97a8..d6700c3c9a 100644
--- a/lib/wasix/src/journal/effector/syscalls/fd_write.rs
+++ b/lib/wasix/src/journal/effector/syscalls/fd_write.rs
@@ -46,7 +46,7 @@ impl JournalEffector {
     }
 
     pub fn apply_fd_write<M: MemorySize>(
-        ctx: &FunctionEnvMut<'_, WasiEnv>,
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
         fd: Fd,
         offset: u64,
         data: Cow<'_, [u8]>,
diff --git a/lib/wasix/src/journal/effector/syscalls/path_open.rs b/lib/wasix/src/journal/effector/syscalls/path_open.rs
index ccd7cdec98..476b91ab45 100644
--- a/lib/wasix/src/journal/effector/syscalls/path_open.rs
+++ b/lib/wasix/src/journal/effector/syscalls/path_open.rs
@@ -12,10 +12,11 @@ impl JournalEffector {
         fs_rights_base: Rights,
         fs_rights_inheriting: Rights,
         fs_flags: Fdflags,
+        fd_flags: Fdflagsext,
     ) -> anyhow::Result<()> {
         Self::save_event(
             ctx,
-            JournalEntry::OpenFileDescriptorV1 {
+            JournalEntry::OpenFileDescriptorV2 {
                 fd,
                 dirfd,
                 dirflags,
@@ -24,6 +25,7 @@ impl JournalEffector {
                 fs_rights_base,
                 fs_rights_inheriting,
                 fs_flags,
+                fd_flags,
             },
         )
     }
@@ -39,9 +41,10 @@ impl JournalEffector {
         fs_rights_base: Rights,
         fs_rights_inheriting: Rights,
         fs_flags: Fdflags,
+        fd_flags: Fdflagsext,
     ) -> anyhow::Result<()> {
         let res = crate::syscalls::path_open_internal(
-            ctx,
+            ctx.data(),
             dirfd,
             dirflags,
             path,
@@ -49,6 +52,7 @@ impl JournalEffector {
             fs_rights_base,
             fs_rights_inheriting,
             fs_flags,
+            fd_flags,
             Some(fd),
         );
         match res? {
diff --git a/lib/wasix/src/journal/effector/syscalls/sock_accept.rs b/lib/wasix/src/journal/effector/syscalls/sock_accept.rs
index 73b0c33454..e157c556cc 100644
--- a/lib/wasix/src/journal/effector/syscalls/sock_accept.rs
+++ b/lib/wasix/src/journal/effector/syscalls/sock_accept.rs
@@ -90,7 +90,9 @@ impl JournalEffector {
         }
 
         let rights = Rights::all_socket();
-        let ret = state.fs.with_fd(rights, rights, new_flags, 0, inode, fd);
+        let ret = state
+            .fs
+            .with_fd(rights, rights, new_flags, Fdflagsext::empty(), 0, inode, fd);
         ret.map_err(|err| {
             anyhow::format_err!(
                 "journal restore error: failed to create remote accepted socket - {}",
diff --git a/lib/wasix/src/journal/effector/syscalls/sock_connect.rs b/lib/wasix/src/journal/effector/syscalls/sock_connect.rs
index b5748d63c8..9130097f9c 100644
--- a/lib/wasix/src/journal/effector/syscalls/sock_connect.rs
+++ b/lib/wasix/src/journal/effector/syscalls/sock_connect.rs
@@ -74,7 +74,15 @@ impl JournalEffector {
         let rights = Rights::all_socket();
         state
             .fs
-            .with_fd(rights, rights, Fdflags::empty(), 0, inode, fd)
+            .with_fd(
+                rights,
+                rights,
+                Fdflags::empty(),
+                Fdflagsext::empty(),
+                0,
+                inode,
+                fd,
+            )
             .map_err(|err| {
                 anyhow::format_err!(
                     "journal restore error: failed to create remote connected socket - {}",
diff --git a/lib/wasix/src/journal/effector/syscalls/sock_pair.rs b/lib/wasix/src/journal/effector/syscalls/sock_pair.rs
new file mode 100644
index 0000000000..1dd2582413
--- /dev/null
+++ b/lib/wasix/src/journal/effector/syscalls/sock_pair.rs
@@ -0,0 +1,30 @@
+use super::*;
+
+impl JournalEffector {
+    // Note: since the current implementation uses a pipe, we don't store the
+    // socket properties (domain, address family, etc.) in the journal.
+    // Once the sock_pair syscall is fixed, we should create a SocketPairV2
+    // entry that stores the socket properties as well. This ensures
+    // forward-compatibility when that change is implemented.
+    pub fn save_sock_pair(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd1: Fd,
+        fd2: Fd,
+    ) -> anyhow::Result<()> {
+        Self::save_event(ctx, JournalEntry::SocketPairV1 { fd1, fd2 })
+    }
+
+    pub fn apply_sock_pair(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd1: Fd,
+        fd2: Fd,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::sock_pair_internal(ctx, Some(fd1), Some(fd2)).map_err(|err| {
+            anyhow::format_err!(
+                "journal restore error: failed to create socket pair - {}",
+                err
+            )
+        })?;
+        Ok(())
+    }
+}
diff --git a/lib/wasix/src/journal/effector/syscalls/sock_send_to.rs b/lib/wasix/src/journal/effector/syscalls/sock_send_to.rs
index f1e7608e5d..711cbb2bc4 100644
--- a/lib/wasix/src/journal/effector/syscalls/sock_send_to.rs
+++ b/lib/wasix/src/journal/effector/syscalls/sock_send_to.rs
@@ -48,7 +48,7 @@ impl JournalEffector {
     }
 
     pub fn apply_sock_send_to<M: MemorySize>(
-        ctx: &FunctionEnvMut<'_, WasiEnv>,
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
         sock: Fd,
         si_data: Cow<'_, [u8]>,
         si_flags: SiFlags,
diff --git a/lib/wasix/src/lib.rs b/lib/wasix/src/lib.rs
index 3f93f3c22d..2382fdbe9e 100644
--- a/lib/wasix/src/lib.rs
+++ b/lib/wasix/src/lib.rs
@@ -14,12 +14,21 @@
 //! [WASI plugin example](https://github.com/wasmerio/wasmer/blob/main/examples/plugin.rs)
 //! for an example of how to extend WASI using the WASI FS API.
 
-#[cfg(all(not(feature = "sys"), not(feature = "js")))]
-compile_error!("At least the `sys` or the `js` feature must be enabled. Please, pick one.");
+#[cfg(all(
+    not(feature = "sys"),
+    not(feature = "js"),
+    not(feature = "sys-minimal")
+))]
+compile_error!(
+    "At least the `sys` or the `js` or `sys-minimal` feature must be enabled. Please, pick one."
+);
 
-#[cfg(all(feature = "sys", feature = "js"))]
+#[cfg(any(
+    all(feature = "js", feature = "sys"),
+    all(feature = "js", feature = "sys-minimal")
+))]
 compile_error!(
-    "Cannot have both `sys` and `js` features enabled at the same time. Please, pick one."
+    "Cannot have both `sys` and `js` or `sys-minimal` and `sys` features enabled at the same time. Please, pick one."
 );
 
 #[cfg(all(feature = "sys", target_arch = "wasm32"))]
@@ -27,7 +36,7 @@ compile_error!("The `sys` feature must be enabled only for non-`wasm32` target."
 
 #[cfg(all(feature = "js", not(target_arch = "wasm32")))]
 compile_error!(
-    "The `js` feature must be enabled only for the `wasm32` target (either `wasm32-unknown-unknown` or `wasm32-wasi`)."
+    "The `js` feature must be enabled only for the `wasm32` target (either `wasm32-unknown-unknown` or `wasm32-wasip1`)."
 );
 
 #[cfg(all(test, target_arch = "wasm32"))]
@@ -96,8 +105,8 @@ pub use crate::{
     rewind::*,
     runtime::{task_manager::VirtualTaskManager, PluggableRuntime, Runtime},
     state::{
-        WasiEnv, WasiEnvBuilder, WasiEnvInit, WasiFunctionEnv, WasiInstanceHandles,
-        WasiStateCreationError, ALL_RIGHTS,
+        WasiEnv, WasiEnvBuilder, WasiEnvInit, WasiFunctionEnv, WasiModuleInstanceHandles,
+        WasiModuleTreeHandles, WasiStateCreationError, ALL_RIGHTS,
     },
     syscalls::{journal::wait_for_snapshot, rewind, rewind_ext, types, unwind},
     utils::is_wasix_module,
@@ -114,10 +123,14 @@ pub use crate::{
 pub enum WasiError {
     #[error("WASI exited with code: {0}")]
     Exit(ExitCode),
+    #[error("WASI thread exited")]
+    ThreadExit,
     #[error("WASI deep sleep: {0:?}")]
     DeepSleep(DeepSleepWork),
     #[error("The WASI version could not be determined")]
     UnknownWasiVersion,
+    #[error("Dynamically-linked symbol not found or has bad type: {0}")]
+    DlSymbolResolutionFailed(String),
 }
 
 pub type WasiResult<T> = Result<Result<T, Errno>, WasiError>;
@@ -221,7 +234,7 @@ impl std::fmt::Display for ExtendedFsError {
         write!(f, "fs error: {}", self.error)?;
 
         if let Some(msg) = &self.message {
-            write!(f, " | {}", msg)?;
+            write!(f, " | {msg}")?;
         }
 
         Ok(())
@@ -240,25 +253,28 @@ impl SpawnError {
     /// [`NotFound`]: SpawnError::NotFound
     #[must_use]
     pub fn is_not_found(&self) -> bool {
-        matches!(self, Self::NotFound { .. } | Self::MissingEntrypoint { .. })
+        matches!(
+            self,
+            Self::NotFound { .. } | Self::MissingEntrypoint { .. } | Self::BinaryNotFound { .. }
+        )
     }
 }
 
 #[derive(thiserror::Error, Debug)]
 pub enum WasiRuntimeError {
-    #[error("WASI state setup failed")]
+    #[error("WASI state setup failed: {0}")]
     Init(#[from] WasiStateCreationError),
-    #[error("Loading exports failed")]
+    #[error("Loading exports failed: {0}")]
     Export(#[from] wasmer::ExportError),
-    #[error("Instantiation failed")]
+    #[error("Instantiation failed: {0}")]
     Instantiation(#[from] wasmer::InstantiationError),
-    #[error("WASI error")]
+    #[error("WASI error: {0}")]
     Wasi(#[from] WasiError),
-    #[error("Process manager error")]
+    #[error("Process manager error: {0}")]
     ControlPlane(#[from] ControlPlaneError),
     #[error("{0}")]
     Runtime(#[from] RuntimeError),
-    #[error("Memory access error")]
+    #[error("Memory access error: {0}")]
     Thread(#[from] WasiThreadError),
     #[error("{0}")]
     Anyhow(#[from] Arc<anyhow::Error>),
@@ -318,8 +334,6 @@ pub(crate) fn run_wasi_func_start(
 pub struct WasiVFork {
     /// The unwound stack before the vfork occured
     pub rewind_stack: BytesMut,
-    /// The memory stack before the vfork occured
-    pub memory_stack: BytesMut,
     /// The mutable parts of the store
     pub store_data: Bytes,
     /// The environment before the vfork occured
@@ -328,16 +342,18 @@ pub struct WasiVFork {
     /// Handle of the thread we have forked (dropping this handle
     /// will signal that the thread is dead)
     pub handle: WasiThreadHandle,
+
+    is_64bit: bool,
 }
 
 impl Clone for WasiVFork {
     fn clone(&self) -> Self {
         Self {
             rewind_stack: self.rewind_stack.clone(),
-            memory_stack: self.memory_stack.clone(),
             store_data: self.store_data.clone(),
             env: Box::new(self.env.as_ref().clone()),
             handle: self.handle.clone(),
+            is_64bit: self.is_64bit,
         }
     }
 }
@@ -361,8 +377,7 @@ pub fn generate_import_object_from_env(
 
     let exports_wasi_generic = wasi_exports_generic(store, ctx);
 
-    #[allow(unused_mut)]
-    let mut imports_wasi_generic = imports! {
+    let imports_wasi_generic = imports! {
         "wasi" => exports_wasi_generic,
     };
 
@@ -494,9 +509,14 @@ fn wasix_exports_32(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>)
     let namespace = namespace! {
         "args_get" => Function::new_typed_with_env(&mut store, env, args_get::<Memory32>),
         "args_sizes_get" => Function::new_typed_with_env(&mut store, env, args_sizes_get::<Memory32>),
+        "call_dynamic" => Function::new_typed_with_env(&mut store, env, call_dynamic::<Memory32>),
+        "reflect_signature" => Function::new_typed_with_env(&mut store, env, reflect_signature::<Memory32>),
         "clock_res_get" => Function::new_typed_with_env(&mut store, env, clock_res_get::<Memory32>),
         "clock_time_get" => Function::new_typed_with_env(&mut store, env, clock_time_get::<Memory32>),
-        "clock_time_set" => Function::new_typed_with_env(&mut store, env, clock_time_set::<Memory32>),
+        "clock_time_set" => Function::new_typed_with_env(&mut store, env, clock_time_set),
+        "closure_prepare" => Function::new_typed_with_env(&mut store, env, closure_prepare::<Memory32>),
+        "closure_allocate" => Function::new_typed_with_env(&mut store, env, closure_allocate::<Memory32>),
+        "closure_free" => Function::new_typed_with_env(&mut store, env, closure_free),
         "environ_get" => Function::new_typed_with_env(&mut store, env, environ_get::<Memory32>),
         "environ_sizes_get" => Function::new_typed_with_env(&mut store, env, environ_sizes_get::<Memory32>),
         "epoll_create" => Function::new_typed_with_env(&mut store, env, epoll_create::<Memory32>),
@@ -520,6 +540,9 @@ fn wasix_exports_32(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>)
         "fd_readdir" => Function::new_typed_with_env(&mut store, env, fd_readdir::<Memory32>),
         "fd_renumber" => Function::new_typed_with_env(&mut store, env, fd_renumber),
         "fd_dup" => Function::new_typed_with_env(&mut store, env, fd_dup::<Memory32>),
+        "fd_dup2" => Function::new_typed_with_env(&mut store, env, fd_dup2::<Memory32>),
+        "fd_fdflags_get" => Function::new_typed_with_env(&mut store, env, fd_fdflags_get::<Memory32>),
+        "fd_fdflags_set" => Function::new_typed_with_env(&mut store, env, fd_fdflags_set),
         "fd_event" => Function::new_typed_with_env(&mut store, env, fd_event::<Memory32>),
         "fd_seek" => Function::new_typed_with_env(&mut store, env, fd_seek::<Memory32>),
         "fd_sync" => Function::new_typed_with_env(&mut store, env, fd_sync),
@@ -531,6 +554,7 @@ fn wasix_exports_32(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>)
         "path_filestat_set_times" => Function::new_typed_with_env(&mut store, env, path_filestat_set_times::<Memory32>),
         "path_link" => Function::new_typed_with_env(&mut store, env, path_link::<Memory32>),
         "path_open" => Function::new_typed_with_env(&mut store, env, path_open::<Memory32>),
+        "path_open2" => Function::new_typed_with_env(&mut store, env, path_open2::<Memory32>),
         "path_readlink" => Function::new_typed_with_env(&mut store, env, path_readlink::<Memory32>),
         "path_remove_directory" => Function::new_typed_with_env(&mut store, env, path_remove_directory::<Memory32>),
         "path_rename" => Function::new_typed_with_env(&mut store, env, path_rename::<Memory32>),
@@ -540,12 +564,17 @@ fn wasix_exports_32(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>)
         "proc_exit" => Function::new_typed_with_env(&mut store, env, proc_exit::<Memory32>),
         "proc_fork" => Function::new_typed_with_env(&mut store, env, proc_fork::<Memory32>),
         "proc_join" => Function::new_typed_with_env(&mut store, env, proc_join::<Memory32>),
-        "proc_signal" => Function::new_typed_with_env(&mut store, env, proc_signal::<Memory32>),
+        "proc_signal" => Function::new_typed_with_env(&mut store, env, proc_signal),
+        "proc_signals_get" => Function::new_typed_with_env(&mut store, env, proc_signals_get::<Memory32>),
+        "proc_signals_sizes_get" => Function::new_typed_with_env(&mut store, env, proc_signals_sizes_get::<Memory32>),
         "proc_exec" => Function::new_typed_with_env(&mut store, env, proc_exec::<Memory32>),
         "proc_exec2" => Function::new_typed_with_env(&mut store, env, proc_exec2::<Memory32>),
+        "proc_exec3" => Function::new_typed_with_env(&mut store, env, proc_exec3::<Memory32>),
         "proc_raise" => Function::new_typed_with_env(&mut store, env, proc_raise),
         "proc_raise_interval" => Function::new_typed_with_env(&mut store, env, proc_raise_interval),
+        "proc_snapshot" => Function::new_typed_with_env(&mut store, env, proc_snapshot::<Memory32>),
         "proc_spawn" => Function::new_typed_with_env(&mut store, env, proc_spawn::<Memory32>),
+        "proc_spawn2" => Function::new_typed_with_env(&mut store, env, proc_spawn2::<Memory32>),
         "proc_id" => Function::new_typed_with_env(&mut store, env, proc_id::<Memory32>),
         "proc_parent" => Function::new_typed_with_env(&mut store, env, proc_parent::<Memory32>),
         "random_get" => Function::new_typed_with_env(&mut store, env, random_get::<Memory32>),
@@ -553,6 +582,9 @@ fn wasix_exports_32(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>)
         "tty_set" => Function::new_typed_with_env(&mut store, env, tty_set::<Memory32>),
         "getcwd" => Function::new_typed_with_env(&mut store, env, getcwd::<Memory32>),
         "chdir" => Function::new_typed_with_env(&mut store, env, chdir::<Memory32>),
+        "dl_invalid_handle" => Function::new_typed_with_env(&mut store, env, dl_invalid_handle),
+        "dlopen" => Function::new_typed_with_env(&mut store, env, dlopen::<Memory32>),
+        "dlsym" => Function::new_typed_with_env(&mut store, env, dlsym::<Memory32>),
         "callback_signal" => Function::new_typed_with_env(&mut store, env, callback_signal::<Memory32>),
         "thread_spawn" => Function::new_typed_with_env(&mut store, env, thread_spawn_v2::<Memory32>),
         "thread_spawn_v2" => Function::new_typed_with_env(&mut store, env, thread_spawn_v2::<Memory32>),
@@ -585,6 +617,7 @@ fn wasix_exports_32(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>)
         "sock_addr_local" => Function::new_typed_with_env(&mut store, env, sock_addr_local::<Memory32>),
         "sock_addr_peer" => Function::new_typed_with_env(&mut store, env, sock_addr_peer::<Memory32>),
         "sock_open" => Function::new_typed_with_env(&mut store, env, sock_open::<Memory32>),
+        "sock_pair" => Function::new_typed_with_env(&mut store, env, sock_pair::<Memory32>),
         "sock_set_opt_flag" => Function::new_typed_with_env(&mut store, env, sock_set_opt_flag),
         "sock_get_opt_flag" => Function::new_typed_with_env(&mut store, env, sock_get_opt_flag::<Memory32>),
         "sock_set_opt_time" => Function::new_typed_with_env(&mut store, env, sock_set_opt_time::<Memory32>),
@@ -616,9 +649,14 @@ fn wasix_exports_64(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>)
     let namespace = namespace! {
         "args_get" => Function::new_typed_with_env(&mut store, env, args_get::<Memory64>),
         "args_sizes_get" => Function::new_typed_with_env(&mut store, env, args_sizes_get::<Memory64>),
+        "call_dynamic" => Function::new_typed_with_env(&mut store, env, call_dynamic::<Memory64>),
+        "reflect_signature" => Function::new_typed_with_env(&mut store, env, reflect_signature::<Memory64>),
         "clock_res_get" => Function::new_typed_with_env(&mut store, env, clock_res_get::<Memory64>),
         "clock_time_get" => Function::new_typed_with_env(&mut store, env, clock_time_get::<Memory64>),
-        "clock_time_set" => Function::new_typed_with_env(&mut store, env, clock_time_set::<Memory64>),
+        "clock_time_set" => Function::new_typed_with_env(&mut store, env, clock_time_set),
+        "closure_prepare" => Function::new_typed_with_env(&mut store, env, closure_prepare::<Memory64>),
+        "closure_allocate" => Function::new_typed_with_env(&mut store, env, closure_allocate::<Memory64>),
+        "closure_free" => Function::new_typed_with_env(&mut store, env, closure_free),
         "environ_get" => Function::new_typed_with_env(&mut store, env, environ_get::<Memory64>),
         "environ_sizes_get" => Function::new_typed_with_env(&mut store, env, environ_sizes_get::<Memory64>),
         "epoll_create" => Function::new_typed_with_env(&mut store, env, epoll_create::<Memory64>),
@@ -642,6 +680,9 @@ fn wasix_exports_64(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>)
         "fd_readdir" => Function::new_typed_with_env(&mut store, env, fd_readdir::<Memory64>),
         "fd_renumber" => Function::new_typed_with_env(&mut store, env, fd_renumber),
         "fd_dup" => Function::new_typed_with_env(&mut store, env, fd_dup::<Memory64>),
+        "fd_dup2" => Function::new_typed_with_env(&mut store, env, fd_dup2::<Memory64>),
+        "fd_fdflags_get" => Function::new_typed_with_env(&mut store, env, fd_fdflags_get::<Memory64>),
+        "fd_fdflags_set" => Function::new_typed_with_env(&mut store, env, fd_fdflags_set),
         "fd_event" => Function::new_typed_with_env(&mut store, env, fd_event::<Memory64>),
         "fd_seek" => Function::new_typed_with_env(&mut store, env, fd_seek::<Memory64>),
         "fd_sync" => Function::new_typed_with_env(&mut store, env, fd_sync),
@@ -653,6 +694,7 @@ fn wasix_exports_64(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>)
         "path_filestat_set_times" => Function::new_typed_with_env(&mut store, env, path_filestat_set_times::<Memory64>),
         "path_link" => Function::new_typed_with_env(&mut store, env, path_link::<Memory64>),
         "path_open" => Function::new_typed_with_env(&mut store, env, path_open::<Memory64>),
+        "path_open2" => Function::new_typed_with_env(&mut store, env, path_open2::<Memory64>),
         "path_readlink" => Function::new_typed_with_env(&mut store, env, path_readlink::<Memory64>),
         "path_remove_directory" => Function::new_typed_with_env(&mut store, env, path_remove_directory::<Memory64>),
         "path_rename" => Function::new_typed_with_env(&mut store, env, path_rename::<Memory64>),
@@ -662,12 +704,17 @@ fn wasix_exports_64(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>)
         "proc_exit" => Function::new_typed_with_env(&mut store, env, proc_exit::<Memory64>),
         "proc_fork" => Function::new_typed_with_env(&mut store, env, proc_fork::<Memory64>),
         "proc_join" => Function::new_typed_with_env(&mut store, env, proc_join::<Memory64>),
-        "proc_signal" => Function::new_typed_with_env(&mut store, env, proc_signal::<Memory64>),
+        "proc_signal" => Function::new_typed_with_env(&mut store, env, proc_signal),
+        "proc_signals_get" => Function::new_typed_with_env(&mut store, env, proc_signals_get::<Memory64>),
+        "proc_signals_sizes_get" => Function::new_typed_with_env(&mut store, env, proc_signals_sizes_get::<Memory64>),
         "proc_exec" => Function::new_typed_with_env(&mut store, env, proc_exec::<Memory64>),
         "proc_exec2" => Function::new_typed_with_env(&mut store, env, proc_exec2::<Memory64>),
+        "proc_exec3" => Function::new_typed_with_env(&mut store, env, proc_exec3::<Memory64>),
         "proc_raise" => Function::new_typed_with_env(&mut store, env, proc_raise),
         "proc_raise_interval" => Function::new_typed_with_env(&mut store, env, proc_raise_interval),
+        "proc_snapshot" => Function::new_typed_with_env(&mut store, env, proc_snapshot::<Memory64>),
         "proc_spawn" => Function::new_typed_with_env(&mut store, env, proc_spawn::<Memory64>),
+        "proc_spawn2" => Function::new_typed_with_env(&mut store, env, proc_spawn2::<Memory64>),
         "proc_id" => Function::new_typed_with_env(&mut store, env, proc_id::<Memory64>),
         "proc_parent" => Function::new_typed_with_env(&mut store, env, proc_parent::<Memory64>),
         "random_get" => Function::new_typed_with_env(&mut store, env, random_get::<Memory64>),
@@ -675,6 +722,9 @@ fn wasix_exports_64(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>)
         "tty_set" => Function::new_typed_with_env(&mut store, env, tty_set::<Memory64>),
         "getcwd" => Function::new_typed_with_env(&mut store, env, getcwd::<Memory64>),
         "chdir" => Function::new_typed_with_env(&mut store, env, chdir::<Memory64>),
+        "dl_invalid_handle" => Function::new_typed_with_env(&mut store, env, dl_invalid_handle),
+        "dlopen" => Function::new_typed_with_env(&mut store, env, dlopen::<Memory64>),
+        "dlsym" => Function::new_typed_with_env(&mut store, env, dlsym::<Memory64>),
         "callback_signal" => Function::new_typed_with_env(&mut store, env, callback_signal::<Memory64>),
         "thread_spawn" => Function::new_typed_with_env(&mut store, env, thread_spawn_v2::<Memory64>),
         "thread_spawn_v2" => Function::new_typed_with_env(&mut store, env, thread_spawn_v2::<Memory64>),
@@ -707,6 +757,7 @@ fn wasix_exports_64(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>)
         "sock_addr_local" => Function::new_typed_with_env(&mut store, env, sock_addr_local::<Memory64>),
         "sock_addr_peer" => Function::new_typed_with_env(&mut store, env, sock_addr_peer::<Memory64>),
         "sock_open" => Function::new_typed_with_env(&mut store, env, sock_open::<Memory64>),
+        "sock_pair" => Function::new_typed_with_env(&mut store, env, sock_pair::<Memory64>),
         "sock_set_opt_flag" => Function::new_typed_with_env(&mut store, env, sock_set_opt_flag),
         "sock_get_opt_flag" => Function::new_typed_with_env(&mut store, env, sock_get_opt_flag::<Memory64>),
         "sock_set_opt_time" => Function::new_typed_with_env(&mut store, env, sock_set_opt_time::<Memory64>),
@@ -733,27 +784,13 @@ fn wasix_exports_64(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>)
     namespace
 }
 
-pub type InstanceInitializer =
-    Box<dyn FnOnce(&wasmer::Instance, &dyn wasmer::AsStoreRef) -> Result<(), anyhow::Error>>;
-
-type ModuleInitializer =
-    Box<dyn FnOnce(&wasmer::Instance, &dyn wasmer::AsStoreRef) -> Result<(), anyhow::Error>>;
-
-/// No-op module initializer.
-fn stub_initializer(
-    _instance: &wasmer::Instance,
-    _store: &dyn wasmer::AsStoreRef,
-) -> Result<(), anyhow::Error> {
-    Ok(())
-}
-
 // TODO: split function into two variants, one for JS and one for sys.
 // (this will make code less messy)
 fn import_object_for_all_wasi_versions(
     _module: &wasmer::Module,
     store: &mut impl AsStoreMut,
     env: &FunctionEnv<WasiEnv>,
-) -> (Imports, ModuleInitializer) {
+) -> Imports {
     let exports_wasi_generic = wasi_exports_generic(store, env);
     let exports_wasi_unstable = wasi_unstable_exports(store, env);
     let exports_wasi_snapshot_preview1 = wasi_snapshot_preview1_exports(store, env);
@@ -770,9 +807,7 @@ fn import_object_for_all_wasi_versions(
         "wasix_64v1" => exports_wasix_64v1,
     };
 
-    let init = Box::new(stub_initializer) as ModuleInitializer;
-
-    (imports, init)
+    imports
 }
 
 /// Combines a state generating function with the import list for legacy WASI
diff --git a/lib/wasix/src/macros.rs b/lib/wasix/src/macros.rs
index fa2df0dfab..4f0d5a0092 100644
--- a/lib/wasix/src/macros.rs
+++ b/lib/wasix/src/macros.rs
@@ -103,3 +103,29 @@ macro_rules! get_input_str_bus_ok {
         wasi_try_mem_bus_ok!($data.read_utf8_string($memory, $len))
     }};
 }
+
+macro_rules! wasi_dl_err {
+    ($err:expr, $memory:ident, $err_buf:ident, $err_buf_len:ident) => {
+        wasi_try_mem_ok!(write_dl_error(
+            $err,
+            &$memory,
+            $err_buf,
+            $err_buf_len.into()
+        ));
+
+        // Doesn't matter which errno we return, since the actual code is ignored.
+        return Ok(Errno::Unknown);
+    };
+}
+
+macro_rules! wasi_try_dl {
+    ($expr:expr, $fmt:tt, $memory:ident, $err_buf:ident, $err_buf_len:ident) => {
+        match $expr {
+            Ok(o) => o,
+            Err(err) => {
+                let err = format!($fmt, err);
+                wasi_dl_err!(&err, $memory, $err_buf, $err_buf_len);
+            }
+        }
+    };
+}
diff --git a/lib/wasix/src/net/mod.rs b/lib/wasix/src/net/mod.rs
index 76600a3c86..1ce815a1f6 100644
--- a/lib/wasix/src/net/mod.rs
+++ b/lib/wasix/src/net/mod.rs
@@ -1,5 +1,5 @@
 use std::{
-    intrinsics::transmute,
+    mem::transmute,
     net::{IpAddr, Ipv4Addr, Ipv6Addr},
     time::Duration,
 };
@@ -30,7 +30,7 @@ pub(crate) fn read_ip<M: MemorySize>(
     Ok(match addr.tag {
         Addressfamily::Inet4 => IpAddr::V4(Ipv4Addr::new(o[0], o[1], o[2], o[3])),
         Addressfamily::Inet6 => {
-            let [a, b, c, d, e, f, g, h] = unsafe { transmute::<_, [u16; 8]>(o) };
+            let [a, b, c, d, e, f, g, h] = unsafe { transmute::<[u8; 16], [u16; 8]>(o) };
             IpAddr::V6(Ipv6Addr::new(a, b, c, d, e, f, g, h))
         }
         _ => return Err(Errno::Inval),
@@ -55,7 +55,7 @@ pub(crate) fn read_ip_v6<M: MemorySize>(
     let addr_ptr = ptr.deref(memory);
     let addr = addr_ptr.read().map_err(crate::mem_error_to_wasi)?;
 
-    let [a, b, c, d, e, f, g, h] = unsafe { transmute::<_, [u16; 8]>(addr.segs) };
+    let [a, b, c, d, e, f, g, h] = unsafe { transmute::<[u8; 16], [u16; 8]>(addr.segs) };
     Ok(Ipv6Addr::new(a, b, c, d, e, f, g, h))
 }
 
@@ -110,7 +110,7 @@ pub(crate) fn read_cidr<M: MemorySize>(
                     o[0], o[1], o[2], o[3], o[4], o[5], o[6], o[7], o[8], o[9], o[10], o[11],
                     o[12], o[13], o[14], o[15],
                 ];
-                unsafe { transmute::<_, [u16; 8]>(o) }
+                unsafe { transmute::<[u8; 16], [u16; 8]>(o) }
             };
             IpCidr {
                 ip: IpAddr::V6(Ipv6Addr::new(a, b, c, d, e, f, g, h)),
@@ -250,7 +250,7 @@ pub(crate) fn read_route<M: MemorySize>(
                             o[0], o[1], o[2], o[3], o[4], o[5], o[6], o[7], o[8], o[9], o[10],
                             o[11], o[12], o[13], o[14], o[15],
                         ];
-                        unsafe { transmute::<_, [u16; 8]>(o) }
+                        unsafe { transmute::<[u8; 16], [u16; 8]>(o) }
                     };
                     IpCidr {
                         ip: IpAddr::V6(Ipv6Addr::new(a, b, c, d, e, f, g, h)),
@@ -265,7 +265,7 @@ pub(crate) fn read_route<M: MemorySize>(
             match route.via_router.tag {
                 Addressfamily::Inet4 => IpAddr::V4(Ipv4Addr::new(o[0], o[1], o[2], o[3])),
                 Addressfamily::Inet6 => {
-                    let [a, b, c, d, e, f, g, h] = unsafe { transmute::<_, [u16; 8]>(o) };
+                    let [a, b, c, d, e, f, g, h] = unsafe { transmute::<[u8; 16], [u16; 8]>(o) };
                     IpAddr::V6(Ipv6Addr::new(a, b, c, d, e, f, g, h))
                 }
                 _ => return Err(Errno::Inval),
diff --git a/lib/wasix/src/net/socket.rs b/lib/wasix/src/net/socket.rs
index 73832318ee..c22cad56e3 100644
--- a/lib/wasix/src/net/socket.rs
+++ b/lib/wasix/src/net/socket.rs
@@ -4,12 +4,11 @@ use std::{
     mem::MaybeUninit,
     net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
     pin::Pin,
-    sync::{Arc, RwLock},
+    sync::{Arc, RwLock, RwLockWriteGuard},
     task::{Context, Poll},
     time::Duration,
 };
 
-use derivative::Derivative;
 #[cfg(feature = "enable-serde")]
 use serde_derive::{Deserialize, Serialize};
 use virtual_mio::InterestHandler;
@@ -33,8 +32,7 @@ pub enum InodeHttpSocketType {
     Headers,
 }
 
-#[derive(Derivative)]
-#[derivative(Debug)]
+#[derive(Debug)]
 pub struct SocketProperties {
     pub family: Addressfamily,
     pub ty: Socktype,
@@ -51,7 +49,6 @@ pub struct SocketProperties {
     pub read_timeout: Option<Duration>,
     pub accept_timeout: Option<Duration>,
     pub connect_timeout: Option<Duration>,
-    #[derivative(Debug = "ignore")]
     pub handler: Option<Box<dyn InterestHandler + Send + Sync>>,
 }
 
@@ -236,6 +233,35 @@ impl InodeSocket {
         inner.poll_read_ready(cx)
     }
 
+    // When a sendto or connect call comes in for a UDP "pre-socket", it must be bound to
+    // an ephemeral port automatically.
+    // Apparently, clippy fails to recognize the write-locked guard being passed into
+    // the other function, hence the `allow` attribute.
+    #[allow(clippy::await_holding_lock, clippy::readonly_write_lock)]
+    pub async fn auto_bind_udp(
+        &self,
+        tasks: &dyn VirtualTaskManager,
+        net: &dyn VirtualNetworking,
+    ) -> Result<Option<InodeSocket>, Errno> {
+        let timeout = self
+            .opt_time(TimeType::BindTimeout)
+            .ok()
+            .flatten()
+            .unwrap_or(Duration::from_secs(30));
+        let inner = self.inner.protected.write().unwrap();
+        match &inner.kind {
+            InodeSocketKind::PreSocket { props, .. } if props.ty == Socktype::Dgram => {
+                let addr = match props.family {
+                    Addressfamily::Inet4 => SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0),
+                    Addressfamily::Inet6 => SocketAddr::new(IpAddr::V6(Ipv6Addr::UNSPECIFIED), 0),
+                    _ => return Err(Errno::Notsup),
+                };
+                Self::bind_internal(tasks, net, addr, timeout, inner).await
+            }
+            _ => Ok(None),
+        }
+    }
+
     pub async fn bind(
         &self,
         tasks: &dyn VirtualTaskManager,
@@ -247,9 +273,20 @@ impl InodeSocket {
             .ok()
             .flatten()
             .unwrap_or(Duration::from_secs(30));
+        let inner = self.inner.protected.write().unwrap();
+        Self::bind_internal(tasks, net, set_addr, timeout, inner).await
+    }
 
+    // The lock is dropped before awaiting, but clippy doesn't realize it
+    #[allow(clippy::await_holding_lock)]
+    async fn bind_internal(
+        tasks: &dyn VirtualTaskManager,
+        net: &dyn VirtualNetworking,
+        set_addr: SocketAddr,
+        timeout: Duration,
+        mut inner: RwLockWriteGuard<'_, InodeSocketProtected>,
+    ) -> Result<Option<InodeSocket>, Errno> {
         let socket = {
-            let mut inner = self.inner.protected.write().unwrap();
             match &mut inner.kind {
                 InodeSocketKind::PreSocket { props, addr, .. } => {
                     match props.family {
@@ -286,7 +323,6 @@ impl InodeSocket {
                         Socktype::Dgram => {
                             let reuse_port = props.reuse_port;
                             let reuse_addr = props.reuse_addr;
-                            drop(inner);
 
                             net.bind_udp(addr, reuse_port, reuse_addr)
                         }
@@ -332,7 +368,6 @@ impl InodeSocket {
                         Socktype::Dgram => {
                             let reuse_port = props.reuse_port;
                             let reuse_addr = props.reuse_addr;
-                            drop(inner);
 
                             net.bind_udp(addr, reuse_port, reuse_addr)
                         }
@@ -343,6 +378,8 @@ impl InodeSocket {
             }
         };
 
+        drop(inner);
+
         tokio::select! {
             socket = socket => {
                 let socket = socket.map_err(net_error_into_wasi_err)?;
@@ -459,7 +496,7 @@ impl InodeSocket {
             nonblocking: bool,
             handler_registered: bool,
         }
-        impl<'a> Drop for SocketAccepter<'a> {
+        impl Drop for SocketAccepter<'_> {
             fn drop(&mut self) {
                 if self.handler_registered {
                     let mut inner = self.sock.inner.protected.write().unwrap();
@@ -467,7 +504,7 @@ impl InodeSocket {
                 }
             }
         }
-        impl<'a> Future for SocketAccepter<'a> {
+        impl Future for SocketAccepter<'_> {
             type Output = Result<(Box<dyn VirtualTcpSocket + Sync>, SocketAddr), Errno>;
             fn poll(
                 mut self: Pin<&mut Self>,
@@ -1081,7 +1118,7 @@ impl InodeSocket {
             nonblocking: bool,
             handler_registered: bool,
         }
-        impl<'a, 'b> Drop for SocketSender<'a, 'b> {
+        impl Drop for SocketSender<'_, '_> {
             fn drop(&mut self) {
                 if self.handler_registered {
                     let mut inner = self.inner.protected.write().unwrap();
@@ -1089,7 +1126,7 @@ impl InodeSocket {
                 }
             }
         }
-        impl<'a, 'b> Future for SocketSender<'a, 'b> {
+        impl Future for SocketSender<'_, '_> {
             type Output = Result<usize, Errno>;
             fn poll(
                 mut self: Pin<&mut Self>,
@@ -1169,7 +1206,7 @@ impl InodeSocket {
             nonblocking: bool,
             handler_registered: bool,
         }
-        impl<'a, 'b> Drop for SocketSender<'a, 'b> {
+        impl Drop for SocketSender<'_, '_> {
             fn drop(&mut self) {
                 if self.handler_registered {
                     let mut inner = self.inner.protected.write().unwrap();
@@ -1177,7 +1214,7 @@ impl InodeSocket {
                 }
             }
         }
-        impl<'a, 'b> Future for SocketSender<'a, 'b> {
+        impl Future for SocketSender<'_, '_> {
             type Output = Result<usize, Errno>;
             fn poll(
                 mut self: Pin<&mut Self>,
@@ -1244,14 +1281,16 @@ impl InodeSocket {
         buf: &mut [MaybeUninit<u8>],
         timeout: Option<Duration>,
         nonblocking: bool,
+        peek: bool,
     ) -> Result<usize, Errno> {
         struct SocketReceiver<'a, 'b> {
             inner: &'a InodeSocketInner,
             data: &'b mut [MaybeUninit<u8>],
             nonblocking: bool,
+            peek: bool,
             handler_registered: bool,
         }
-        impl<'a, 'b> Drop for SocketReceiver<'a, 'b> {
+        impl Drop for SocketReceiver<'_, '_> {
             fn drop(&mut self) {
                 if self.handler_registered {
                     let mut inner = self.inner.protected.write().unwrap();
@@ -1259,26 +1298,29 @@ impl InodeSocket {
                 }
             }
         }
-        impl<'a, 'b> Future for SocketReceiver<'a, 'b> {
+        impl Future for SocketReceiver<'_, '_> {
             type Output = Result<usize, Errno>;
             fn poll(
                 mut self: Pin<&mut Self>,
                 cx: &mut std::task::Context<'_>,
             ) -> Poll<Self::Output> {
                 loop {
+                    let peek = self.peek;
                     let mut inner = self.inner.protected.write().unwrap();
                     let res = match &mut inner.kind {
-                        InodeSocketKind::Raw(socket) => socket.try_recv(self.data),
-                        InodeSocketKind::TcpStream { socket, .. } => socket.try_recv(self.data),
+                        InodeSocketKind::Raw(socket) => socket.try_recv(self.data, peek),
+                        InodeSocketKind::TcpStream { socket, .. } => {
+                            socket.try_recv(self.data, peek)
+                        }
                         InodeSocketKind::UdpSocket { socket, peer } => {
                             if let Some(peer) = peer {
-                                match socket.try_recv_from(self.data) {
+                                match socket.try_recv_from(self.data, peek) {
                                     Ok((amt, addr)) if addr == *peer => Ok(amt),
                                     Ok(_) => Err(NetworkError::WouldBlock),
                                     Err(err) => Err(err),
                                 }
                             } else {
-                                match socket.try_recv_from(self.data) {
+                                match socket.try_recv_from(self.data, peek) {
                                     Ok((amt, _)) => Ok(amt),
                                     Err(err) => Err(err),
                                 }
@@ -1320,6 +1362,7 @@ impl InodeSocket {
             inner: &self.inner,
             data: buf,
             nonblocking,
+            peek,
             handler_registered: false,
         };
         if let Some(timeout) = timeout {
@@ -1338,14 +1381,16 @@ impl InodeSocket {
         buf: &mut [MaybeUninit<u8>],
         timeout: Option<Duration>,
         nonblocking: bool,
+        peek: bool,
     ) -> Result<(usize, SocketAddr), Errno> {
         struct SocketReceiver<'a, 'b> {
             inner: &'a InodeSocketInner,
             data: &'b mut [MaybeUninit<u8>],
             nonblocking: bool,
+            peek: bool,
             handler_registered: bool,
         }
-        impl<'a, 'b> Drop for SocketReceiver<'a, 'b> {
+        impl Drop for SocketReceiver<'_, '_> {
             fn drop(&mut self) {
                 if self.handler_registered {
                     let mut inner = self.inner.protected.write().unwrap();
@@ -1353,18 +1398,19 @@ impl InodeSocket {
                 }
             }
         }
-        impl<'a, 'b> Future for SocketReceiver<'a, 'b> {
+        impl Future for SocketReceiver<'_, '_> {
             type Output = Result<(usize, SocketAddr), Errno>;
             fn poll(
                 mut self: Pin<&mut Self>,
                 cx: &mut std::task::Context<'_>,
             ) -> Poll<Self::Output> {
+                let peek = self.peek;
                 let mut inner = self.inner.protected.write().unwrap();
                 loop {
                     let res = match &mut inner.kind {
-                        InodeSocketKind::Icmp(socket) => socket.try_recv_from(self.data),
+                        InodeSocketKind::Icmp(socket) => socket.try_recv_from(self.data, peek),
                         InodeSocketKind::UdpSocket { socket, .. } => {
-                            socket.try_recv_from(self.data)
+                            socket.try_recv_from(self.data, peek)
                         }
                         InodeSocketKind::RemoteSocket {
                             is_dead, peer_addr, ..
@@ -1402,6 +1448,7 @@ impl InodeSocket {
             inner: &self.inner,
             data: buf,
             nonblocking,
+            peek,
             handler_registered: false,
         };
         if let Some(timeout) = timeout {
diff --git a/lib/wasix/src/os/command/builtins/cmd_wasmer.rs b/lib/wasix/src/os/command/builtins/cmd_wasmer.rs
index c0a0536907..46bb1cfb11 100644
--- a/lib/wasix/src/os/command/builtins/cmd_wasmer.rs
+++ b/lib/wasix/src/os/command/builtins/cmd_wasmer.rs
@@ -1,11 +1,15 @@
-use std::{any::Any, sync::Arc};
+use std::{any::Any, path::PathBuf, sync::Arc};
 
 use crate::{
+    bin_factory::spawn_exec_wasm,
     os::task::{OwnedTaskStatus, TaskJoinHandle},
-    runtime::task_manager::InlineWaker,
+    runtime::{module_cache::HashedModuleData, task_manager::InlineWaker},
     SpawnError,
 };
-use wasmer::{FunctionEnvMut, Store};
+use shared_buffer::OwnedBuffer;
+use virtual_fs::{AsyncReadExt, FileSystem};
+use wasmer::FunctionEnvMut;
+use wasmer_package::utils::from_bytes;
 use wasmer_wasix_types::wasi::Errno;
 
 use crate::{
@@ -47,12 +51,17 @@ impl CmdWasmer {
     }
 }
 
+#[derive(Debug, Clone)]
+enum Executable {
+    Wasm(OwnedBuffer),
+    BinaryPackage(BinaryPackage),
+}
+
 impl CmdWasmer {
-    async fn run<'a>(
+    async fn run(
         &self,
-        parent_ctx: &FunctionEnvMut<'a, WasiEnv>,
+        parent_ctx: &FunctionEnvMut<'_, WasiEnv>,
         name: &str,
-        store: &mut Option<Store>,
         config: &mut Option<WasiEnv>,
         what: Option<String>,
         mut args: Vec<String>,
@@ -63,31 +72,77 @@ impl CmdWasmer {
         }
 
         if let Some(what) = what {
-            let store = store.take().ok_or(SpawnError::UnknownError)?;
             let mut env = config.take().ok_or(SpawnError::UnknownError)?;
 
             // Set the arguments of the environment by replacing the state
             let mut state = env.state.fork();
             args.insert(0, what.clone());
-            state.args = args;
+            state.args = std::sync::Mutex::new(args);
             env.state = Arc::new(state);
 
-            if let Ok(binary) = self.get_package(&what).await {
-                // Now run the module
-                spawn_exec(binary, name, store, env, &self.runtime).await
+            let file_path = if what.starts_with('/') {
+                PathBuf::from(&what)
             } else {
-                let _ = unsafe {
-                    stderr_write(
-                        parent_ctx,
-                        format!("package not found - {}\r\n", what).as_bytes(),
-                    )
-                }
-                .await;
+                // convert relative path to absolute path
+                let cwd = env.state.fs.current_dir.lock().unwrap().clone();
+
+                PathBuf::from(cwd).join(&what)
+            };
+
+            let fs = env.fs_root();
+            let f = fs.new_open_options().read(true).open(&file_path);
+            let executable = if let Ok(mut file) = f {
+                let mut data = Vec::with_capacity(file.size() as usize);
+                file.read_to_end(&mut data).await.unwrap();
 
-                let handle = OwnedTaskStatus::new_finished_with_code(Errno::Noent.into()).handle();
-                Ok(handle)
+                let bytes: bytes::Bytes = data.into();
+
+                if let Ok(container) = from_bytes(bytes.clone()) {
+                    let pkg = BinaryPackage::from_webc(&container, &*self.runtime)
+                        .await
+                        .unwrap();
+
+                    Executable::BinaryPackage(pkg)
+                } else {
+                    Executable::Wasm(OwnedBuffer::from_bytes(bytes))
+                }
+            } else if let Ok(pkg) = self.get_package(&what).await {
+                Executable::BinaryPackage(pkg)
+            } else {
+                let _ = unsafe { stderr_write(parent_ctx, HELP_RUN.as_bytes()) }.await;
+                let handle =
+                    OwnedTaskStatus::new_finished_with_code(Errno::Success.into()).handle();
+                return Ok(handle);
+            };
+
+            match executable {
+                Executable::BinaryPackage(binary) => {
+                    // Infer the command that is going to be executed
+                    let cmd_name: &str =
+                        binary
+                            .infer_entrypoint()
+                            .map_err(|_| SpawnError::MissingEntrypoint {
+                                package_id: binary.id.clone(),
+                            })?;
+
+                    let cmd = binary
+                        .get_command(cmd_name)
+                        .ok_or_else(|| SpawnError::NotFound {
+                            message: format!("{cmd_name} command in package: {}", binary.id),
+                        })?;
+
+                    env.prepare_spawn(cmd);
+
+                    env.use_package_async(&binary).await.unwrap();
+
+                    // Now run the module
+                    spawn_exec(binary, name, env, &self.runtime).await
+                }
+                Executable::Wasm(bytes) => {
+                    let data = HashedModuleData::new(bytes);
+                    spawn_exec_wasm(data, name, env, &self.runtime).await
+                }
             }
-            // Get the binary
         } else {
             let _ = unsafe { stderr_write(parent_ctx, HELP_RUN.as_bytes()) }.await;
             let handle = OwnedTaskStatus::new_finished_with_code(Errno::Success.into()).handle();
@@ -125,12 +180,11 @@ impl VirtualCommand for CmdWasmer {
         &self,
         parent_ctx: &FunctionEnvMut<'_, WasiEnv>,
         name: &str,
-        store: &mut Option<Store>,
         env: &mut Option<WasiEnv>,
     ) -> Result<TaskJoinHandle, SpawnError> {
         // Read the command we want to run
         let env_inner = env.as_ref().ok_or(SpawnError::UnknownError)?;
-        let args = env_inner.state.args.clone();
+        let args = env_inner.state.args.lock().unwrap().clone();
         let mut args = args.iter().map(|s| s.as_str());
         let _alias = args.next();
         let cmd = args.next();
@@ -141,7 +195,7 @@ impl VirtualCommand for CmdWasmer {
                 Some("run") => {
                     let what = args.next().map(|a| a.to_string());
                     let args = args.map(|a| a.to_string()).collect();
-                    self.run(parent_ctx, name, store, env, what, args).await
+                    self.run(parent_ctx, name, env, what, args).await
                 }
                 Some("--help") | None => {
                     unsafe { stderr_write(parent_ctx, HELP.as_bytes()) }
@@ -154,7 +208,7 @@ impl VirtualCommand for CmdWasmer {
                 Some(what) => {
                     let what = Some(what.to_string());
                     let args = args.map(|a| a.to_string()).collect();
-                    self.run(parent_ctx, name, store, env, what, args).await
+                    self.run(parent_ctx, name, env, what, args).await
                 }
             }
         };
diff --git a/lib/wasix/src/os/command/mod.rs b/lib/wasix/src/os/command/mod.rs
index d5ecc590b9..7c9343d384 100644
--- a/lib/wasix/src/os/command/mod.rs
+++ b/lib/wasix/src/os/command/mod.rs
@@ -2,7 +2,7 @@ pub mod builtins;
 
 use std::{collections::HashMap, sync::Arc};
 
-use wasmer::{FunctionEnvMut, Store};
+use wasmer::FunctionEnvMut;
 use wasmer_wasix_types::wasi::Errno;
 
 use crate::{
@@ -27,7 +27,6 @@ where
         &self,
         parent_ctx: &FunctionEnvMut<'_, WasiEnv>,
         path: &str,
-        store: &mut Option<Store>,
         config: &mut Option<WasiEnv>,
     ) -> Result<TaskJoinHandle, SpawnError>;
 }
@@ -86,17 +85,16 @@ impl Commands {
         &self,
         parent_ctx: &FunctionEnvMut<'_, WasiEnv>,
         path: &str,
-        store: &mut Option<Store>,
         builder: &mut Option<WasiEnv>,
     ) -> Result<TaskJoinHandle, SpawnError> {
         let path = path.to_string();
         if let Some(cmd) = self.commands.get(&path) {
-            cmd.exec(parent_ctx, path.as_str(), store, builder)
+            cmd.exec(parent_ctx, path.as_str(), builder)
         } else {
             unsafe {
                 InlineWaker::block_on(stderr_write(
                     parent_ctx,
-                    format!("wasm command unknown - {}\r\n", path).as_bytes(),
+                    format!("wasm command unknown - {path}\r\n").as_bytes(),
                 ))
             }
             .ok();
diff --git a/lib/wasix/src/os/console/mod.rs b/lib/wasix/src/os/console/mod.rs
index ca63393c32..ec987b6be4 100644
--- a/lib/wasix/src/os/console/mod.rs
+++ b/lib/wasix/src/os/console/mod.rs
@@ -12,7 +12,7 @@ use std::{
     sync::{atomic::AtomicBool, Arc, Mutex},
 };
 
-use derivative::*;
+use futures::future::Either;
 use linked_hash_set::LinkedHashSet;
 use tokio::sync::{mpsc, RwLock};
 #[allow(unused_imports, dead_code)]
@@ -31,12 +31,12 @@ use crate::{
     bin_factory::{spawn_exec, BinFactory, BinaryPackage},
     capabilities::Capabilities,
     os::task::{control_plane::WasiControlPlane, process::WasiProcess},
+    runners::wasi::{PackageOrHash, RuntimeOrEngine},
     runtime::task_manager::InlineWaker,
     Runtime, SpawnError, WasiEnv, WasiEnvBuilder, WasiRuntimeError,
 };
 
-#[derive(Derivative)]
-#[derivative(Debug)]
+#[derive(Debug)]
 pub struct Console {
     user_agent: Option<String>,
     boot_cmd: String,
@@ -231,8 +231,8 @@ impl Console {
             .prepare_webc_env(
                 prog,
                 &wasi_opts,
-                Some(&pkg),
-                self.runtime.clone(),
+                PackageOrHash::Package(&pkg),
+                RuntimeOrEngine::Runtime(self.runtime.clone()),
                 Some(root_fs),
             )
             // TODO: better error conversion
@@ -250,12 +250,9 @@ impl Console {
         if let Err(err) = env.uses(self.uses.clone()) {
             let mut stderr = self.stderr.clone();
             InlineWaker::block_on(async {
-                virtual_fs::AsyncWriteExt::write_all(
-                    &mut stderr,
-                    format!("{}\r\n", err).as_bytes(),
-                )
-                .await
-                .ok();
+                virtual_fs::AsyncWriteExt::write_all(&mut stderr, format!("{err}\r\n").as_bytes())
+                    .await
+                    .ok();
             });
             tracing::debug!("failed to load used dependency - {}", err);
             return Err(SpawnError::BadRequest);
@@ -280,8 +277,7 @@ impl Console {
 
         // Build the config
         // Run the binary
-        let store = self.runtime.new_store();
-        let process = InlineWaker::block_on(spawn_exec(pkg, prog, store, env, &self.runtime))?;
+        let process = InlineWaker::block_on(spawn_exec(pkg, prog, env, &self.runtime))?;
 
         // Return the process
         Ok((process, wasi_process))
@@ -338,8 +334,7 @@ mod tests {
         let tm = TokioTaskManager::new(tokio_rt);
         let mut rt = PluggableRuntime::new(Arc::new(tm));
         let client = rt.http_client().unwrap().clone();
-        rt.set_engine(Some(wasmer::Engine::default()))
-            .set_package_loader(BuiltinPackageLoader::new().with_shared_http_client(client));
+        rt.set_package_loader(BuiltinPackageLoader::new().with_shared_http_client(client));
 
         let env: HashMap<String, String> = [("MYENV1".to_string(), "VAL1".to_string())]
             .into_iter()
@@ -366,7 +361,6 @@ mod tests {
                 )
                 .await?;
 
-                stdin_tx.close();
                 std::mem::drop(stdin_tx);
 
                 let res = handle.wait_finished().await?;
@@ -393,8 +387,7 @@ mod tests {
         let tm = TokioTaskManager::new(tokio_rt);
         let mut rt = PluggableRuntime::new(Arc::new(tm));
         let client = rt.http_client().unwrap().clone();
-        rt.set_engine(Some(wasmer::Engine::default()))
-            .set_package_loader(BuiltinPackageLoader::new().with_shared_http_client(client));
+        rt.set_package_loader(BuiltinPackageLoader::new().with_shared_http_client(client));
 
         let cmd = "wasmer-tests/python-env-dump --help";
 
diff --git a/lib/wasix/src/os/console/txt/about_wasmer.md b/lib/wasix/src/os/console/txt/about_wasmer.md
index 8d0922893f..c6d8fe05fb 100644
--- a/lib/wasix/src/os/console/txt/about_wasmer.md
+++ b/lib/wasix/src/os/console/txt/about_wasmer.md
@@ -7,8 +7,8 @@ IoT devices.
 Features:
 • Secure by default. No file, network, or environment access, unless
   explicitly enabled.
-• Supports WASI and Emscripten out of the box.
+• Supports WASI out of the box.
 • Fast. Run WebAssembly at near-native speeds.
 • Embeddable in multiple programming languages
 • Compliant with latest WebAssembly Proposals (SIMD, Reference Types,
-  Threads, ...)
\ No newline at end of file
+  Threads, ...)
diff --git a/lib/wasix/src/os/task/control_plane.rs b/lib/wasix/src/os/task/control_plane.rs
index 0845b075c0..6f88ee67c2 100644
--- a/lib/wasix/src/os/task/control_plane.rs
+++ b/lib/wasix/src/os/task/control_plane.rs
@@ -213,7 +213,7 @@ pub enum ControlPlaneError {
 mod tests {
     use wasmer_wasix_types::wasix::ThreadStartType;
 
-    use crate::{os::task::thread::WasiMemoryLayout, utils::xxhash_random};
+    use crate::os::task::thread::WasiMemoryLayout;
 
     use super::*;
 
@@ -226,7 +226,7 @@ mod tests {
             enable_exponential_cpu_backoff: None,
         });
 
-        let p1 = p.new_process(xxhash_random()).unwrap();
+        let p1 = p.new_process(ModuleHash::random()).unwrap();
         let _t1 = p1
             .new_thread(WasiMemoryLayout::default(), ThreadStartType::MainThread)
             .unwrap();
@@ -235,7 +235,7 @@ mod tests {
             .unwrap();
 
         assert_eq!(
-            p.new_process(xxhash_random()).unwrap_err(),
+            p.new_process(ModuleHash::random()).unwrap_err(),
             ControlPlaneError::TaskLimitReached { max: 2 }
         );
     }
@@ -249,7 +249,7 @@ mod tests {
             enable_exponential_cpu_backoff: None,
         });
 
-        let p1 = p.new_process(xxhash_random()).unwrap();
+        let p1 = p.new_process(ModuleHash::random()).unwrap();
 
         for _ in 0..10 {
             let _thread = p1
@@ -265,7 +265,7 @@ mod tests {
             .unwrap();
 
         assert_eq!(
-            p.new_process(xxhash_random()).unwrap_err(),
+            p.new_process(ModuleHash::random()).unwrap_err(),
             ControlPlaneError::TaskLimitReached { max: 2 }
         );
     }
diff --git a/lib/wasix/src/os/task/process.rs b/lib/wasix/src/os/task/process.rs
index 0a408ad511..abc78f6e20 100644
--- a/lib/wasix/src/os/task/process.rs
+++ b/lib/wasix/src/os/task/process.rs
@@ -171,6 +171,9 @@ pub struct WasiProcessInner {
     /// If true then the journaling will be disabled after the
     /// next snapshot is taken
     pub disable_journaling_after_checkpoint: bool,
+    /// If true then the process will stop running after the
+    /// next snapshot is taken
+    pub stop_running_after_checkpoint: bool,
     /// List of situations that the process will checkpoint on
     #[cfg(feature = "journal")]
     pub snapshot_on: HashSet<SnapshotTrigger>,
@@ -309,6 +312,14 @@ impl WasiProcessInner {
                 ctx.data().thread.set_checkpointing(false);
                 trace!("checkpoint finished");
 
+                if guard.stop_running_after_checkpoint {
+                    trace!("will stop running now");
+                    // Need to stop recording journal events so we don't also record the
+                    // thread and process exit events
+                    ctx.data_mut().enable_journal = false;
+                    return OnCalledAction::Finish;
+                }
+
                 // Rewind the stack and carry on
                 return match rewind_ext::<M>(
                     &mut ctx,
@@ -427,6 +438,7 @@ impl WasiProcess {
                 #[cfg(feature = "journal")]
                 snapshot_memory_hash: Default::default(),
                 disable_journaling_after_checkpoint: false,
+                stop_running_after_checkpoint: false,
                 backoff: WasiProcessCpuBackoff::new(max_cpu_backoff_time, max_cpu_cool_off_time),
             }),
             Condvar::new(),
@@ -544,6 +556,11 @@ impl WasiProcess {
         Ok(WasiThreadHandle::new(ctrl, &self.inner))
     }
 
+    pub fn all_threads(&self) -> Vec<WasiThreadId> {
+        let inner = self.inner.0.lock().unwrap();
+        inner.threads.keys().cloned().collect()
+    }
+
     /// Gets a reference to a particular thread
     pub fn get_thread(&self, tid: &WasiThreadId) -> Option<WasiThread> {
         let inner = self.inner.0.lock().unwrap();
@@ -595,6 +612,21 @@ impl WasiProcess {
         self.wait_for_checkpoint_finish()
     }
 
+    /// Takes a snapshot of the process and shuts it down after the snapshot
+    /// is taken.
+    ///
+    /// Note: If you ignore the returned future the checkpoint will still
+    /// occur but it will execute asynchronously
+    pub fn snapshot_and_stop(
+        &self,
+        trigger: SnapshotTrigger,
+    ) -> std::pin::Pin<Box<dyn futures::Future<Output = ()> + Send + Sync>> {
+        let mut guard = self.inner.0.lock().unwrap();
+        guard.stop_running_after_checkpoint = true;
+        guard.checkpoint = WasiProcessCheckpoint::Snapshot { trigger };
+        self.wait_for_checkpoint_finish()
+    }
+
     /// Takes a snapshot of the process
     ///
     /// Note: If you ignore the returned future the checkpoint will still
@@ -614,6 +646,12 @@ impl WasiProcess {
         guard.disable_journaling_after_checkpoint = true;
     }
 
+    /// Stop running once a checkpoint is taken
+    pub fn stop_running_after_checkpoint(&self) {
+        let mut guard = self.inner.0.lock().unwrap();
+        guard.stop_running_after_checkpoint = true;
+    }
+
     /// Wait for the checkout process to finish
     #[cfg(not(feature = "journal"))]
     pub fn wait_for_checkpoint(
diff --git a/lib/wasix/src/os/task/thread.rs b/lib/wasix/src/os/task/thread.rs
index 6724634940..eba37607b1 100644
--- a/lib/wasix/src/os/task/thread.rs
+++ b/lib/wasix/src/os/task/thread.rs
@@ -17,6 +17,7 @@ use wasmer_wasix_types::{
 
 use crate::{
     os::task::process::{WasiProcessId, WasiProcessInner},
+    state::LinkError,
     syscalls::HandleRewindType,
     WasiRuntimeError,
 };
@@ -318,6 +319,7 @@ impl WasiThread {
     pub fn set_or_get_exit_code_for_signal(&self, sig: Signal) -> ExitCode {
         let default_exitcode: ExitCode = match sig {
             Signal::Sigquit | Signal::Sigabrt => Errno::Success.into(),
+            Signal::Sigpipe => Errno::Pipe.into(),
             _ => Errno::Intr.into(),
         };
         // This will only set the status code if its not already set
@@ -372,7 +374,7 @@ impl WasiThread {
         struct SignalPoller<'a> {
             thread: &'a WasiThread,
         }
-        impl<'a> std::future::Future for SignalPoller<'a> {
+        impl std::future::Future for SignalPoller<'_> {
             type Output = ();
             fn poll(
                 self: std::pin::Pin<&mut Self>,
@@ -403,6 +405,13 @@ impl WasiThread {
         }
     }
 
+    pub fn signals_subscribe(&self, waker: &Waker) {
+        let mut guard = self.state.signals.lock().unwrap();
+        if !guard.1.iter().any(|w| w.will_wake(waker)) {
+            guard.1.push(waker.clone());
+        }
+    }
+
     /// Returns all the signals that are waiting to be processed
     pub fn has_signals_or_subscribe(&self, waker: &Waker) -> bool {
         let mut guard = self.state.signals.lock().unwrap();
@@ -617,7 +626,9 @@ pub enum WasiThreadError {
     MemoryCreateFailed(MemoryError),
     #[error("{0}")]
     ExportError(ExportError),
-    #[error("Failed to create the instance")]
+    #[error("Linker error: {0}")]
+    LinkError(Arc<LinkError>),
+    #[error("Failed to create the instance - {0}")]
     // Note: Boxed so we can keep the error size down
     InstanceCreateFailed(Box<InstantiationError>),
     #[error("Initialization function failed - {0}")]
@@ -634,6 +645,7 @@ impl From<WasiThreadError> for Errno {
             WasiThreadError::MethodNotFound => Errno::Inval,
             WasiThreadError::MemoryCreateFailed(_) => Errno::Nomem,
             WasiThreadError::ExportError(_) => Errno::Noexec,
+            WasiThreadError::LinkError(_) => Errno::Noexec,
             WasiThreadError::InstanceCreateFailed(_) => Errno::Noexec,
             WasiThreadError::InitFailed(_) => Errno::Noexec,
             WasiThreadError::InvalidWasmContext => Errno::Noexec,
diff --git a/lib/wasix/src/os/tty/mod.rs b/lib/wasix/src/os/tty/mod.rs
index dc2ed6cf84..6755d9fb8b 100644
--- a/lib/wasix/src/os/tty/mod.rs
+++ b/lib/wasix/src/os/tty/mod.rs
@@ -3,7 +3,6 @@ use std::{
     sync::{Arc, Mutex},
 };
 
-use derivative::*;
 use futures::future::BoxFuture;
 use virtual_fs::{AsyncWriteExt, NullFile, VirtualFile};
 use wasmer_wasix_types::wasi::{Signal, Snapshot0Clockid};
@@ -113,8 +112,7 @@ impl TtyOptions {
     }
 }
 
-#[derive(Derivative)]
-#[derivative(Debug)]
+#[derive(Debug)]
 pub struct Tty {
     stdin: Box<dyn VirtualFile + Send + Sync + 'static>,
     stdout: Box<dyn VirtualFile + Send + Sync + 'static>,
@@ -444,7 +442,7 @@ impl Default for WasiTtyState {
 }
 
 /// Provides access to a TTY.
-pub trait TtyBridge {
+pub trait TtyBridge: std::fmt::Debug {
     /// Resets the values
     fn reset(&self);
 
diff --git a/lib/wasix/src/os/tty/tty_sys.rs b/lib/wasix/src/os/tty/tty_sys.rs
index d269ff9403..5b661ca394 100644
--- a/lib/wasix/src/os/tty/tty_sys.rs
+++ b/lib/wasix/src/os/tty/tty_sys.rs
@@ -72,10 +72,9 @@ mod sys_terminal_size {
     }
 }
 
-#[allow(unused_mut)]
+#[allow(unused_mut, unused_imports)]
 #[cfg(all(unix, not(target_os = "ios")))]
 mod sys {
-    #![allow(unused_imports)]
     use {
         libc::{
             c_int, tcsetattr, termios, ECHO, ECHOCTL, ECHOE, ECHOK, ECHONL, ICANON, ICRNL, IEXTEN,
diff --git a/lib/wasix/src/runners/dcgi/callbacks.rs b/lib/wasix/src/runners/dcgi/callbacks.rs
index 87b430b5c3..fe8604c495 100644
--- a/lib/wasix/src/runners/dcgi/callbacks.rs
+++ b/lib/wasix/src/runners/dcgi/callbacks.rs
@@ -1,16 +1,12 @@
 use std::sync::Arc;
 
-use derivative::Derivative;
-
 use super::*;
 use crate::runners::wcgi::{self, CreateEnvConfig, CreateEnvResult, RecycleEnvConfig};
 use virtual_fs::NullFile;
 use wasmer_wasix_types::types::{__WASI_STDERR_FILENO, __WASI_STDIN_FILENO, __WASI_STDOUT_FILENO};
 
-#[derive(Derivative, Clone)]
-#[derivative(Debug)]
+#[derive(Debug, Clone)]
 pub struct DcgiCallbacks {
-    #[derivative(Debug = "ignore")]
     inner: Arc<dyn wcgi::Callbacks>,
     factory: DcgiInstanceFactory,
 }
diff --git a/lib/wasix/src/runners/dcgi/factory.rs b/lib/wasix/src/runners/dcgi/factory.rs
index 9e10a74f09..6496f9ee9b 100644
--- a/lib/wasix/src/runners/dcgi/factory.rs
+++ b/lib/wasix/src/runners/dcgi/factory.rs
@@ -1,6 +1,5 @@
 use std::sync::{Arc, Mutex};
 
-use derivative::Derivative;
 use virtual_fs::Pipe;
 use wasmer_wasix_types::types::{__WASI_STDERR_FILENO, __WASI_STDIN_FILENO, __WASI_STDOUT_FILENO};
 
@@ -20,8 +19,7 @@ struct State {
 
 /// This factory will store and reuse instances between invocations thus
 /// allowing for the instances to be stateful.
-#[derive(Derivative, Clone, Default)]
-#[derivative(Debug)]
+#[derive(Debug, Clone, Default)]
 pub struct DcgiInstanceFactory {
     state: Arc<Mutex<State>>,
 }
diff --git a/lib/wasix/src/runners/dcgi/handler.rs b/lib/wasix/src/runners/dcgi/handler.rs
index b6415eb811..f3dcb83cde 100644
--- a/lib/wasix/src/runners/dcgi/handler.rs
+++ b/lib/wasix/src/runners/dcgi/handler.rs
@@ -53,9 +53,10 @@ impl Deref for Handler {
     }
 }
 
-#[derive(derivative::Derivative, Clone)]
-#[derivative(Debug)]
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
 pub(crate) struct SharedState {
+    #[allow(dead_code)]
     pub(crate) inner: Arc<wcgi::SharedState>,
     factory: DcgiInstanceFactory,
     master_lock: Arc<tokio::sync::Mutex<()>>,
diff --git a/lib/wasix/src/runners/dcgi/runner.rs b/lib/wasix/src/runners/dcgi/runner.rs
index a1204a22fa..4229c98dab 100644
--- a/lib/wasix/src/runners/dcgi/runner.rs
+++ b/lib/wasix/src/runners/dcgi/runner.rs
@@ -74,9 +74,7 @@ impl crate::runners::Runner for DcgiRunner {
         // file system changes as it is unable to run the main function more than
         // once due to limitations in the runtime
         let journals = runtime
-            .journals()
-            .clone()
-            .into_iter()
+            .writable_journals()
             .map(|journal| {
                 let journal = FilteredJournalBuilder::new()
                     .with_ignore_memory(true)
@@ -89,7 +87,7 @@ impl crate::runners::Runner for DcgiRunner {
                 Arc::new(journal) as Arc<DynJournal>
             })
             .collect::<Vec<_>>();
-        let runtime = OverriddenRuntime::new(runtime).with_journals(journals);
+        let runtime = OverriddenRuntime::new(runtime).with_writable_journals(journals);
         let runtime = Arc::new(runtime) as Arc<DynRuntime>;
 
         //We now pass the runtime to the handlers
@@ -167,10 +165,7 @@ impl Config {
 
     /// Set callbacks that will be triggered at various points in the runner's
     /// lifecycle.
-    pub fn callbacks(
-        &mut self,
-        callbacks: impl wcgi::Callbacks + Send + Sync + 'static,
-    ) -> &mut Self {
+    pub fn callbacks(&mut self, callbacks: impl wcgi::Callbacks + 'static) -> &mut Self {
         self.inner.callbacks(callbacks);
         self
     }
@@ -194,26 +189,45 @@ impl Config {
         self.inner.capabilities()
     }
 
+    #[cfg(feature = "journal")]
     pub fn add_snapshot_trigger(&mut self, on: crate::journal::SnapshotTrigger) {
         self.inner.add_snapshot_trigger(on);
     }
 
+    #[cfg(feature = "journal")]
     pub fn add_default_snapshot_triggers(&mut self) -> &mut Self {
         self.inner.add_default_snapshot_triggers();
         self
     }
 
+    #[cfg(feature = "journal")]
     pub fn has_snapshot_trigger(&self, on: crate::journal::SnapshotTrigger) -> bool {
         self.inner.has_snapshot_trigger(on)
     }
 
+    #[cfg(feature = "journal")]
     pub fn with_snapshot_interval(&mut self, period: std::time::Duration) -> &mut Self {
         self.inner.with_snapshot_interval(period);
         self
     }
 
-    pub fn add_journal(&mut self, journal: Arc<crate::journal::DynJournal>) -> &mut Self {
-        self.inner.add_journal(journal);
+    #[cfg(feature = "journal")]
+    pub fn with_stop_running_after_snapshot(&mut self, stop_running: bool) {
+        self.inner.with_stop_running_after_snapshot(stop_running);
+    }
+
+    #[cfg(feature = "journal")]
+    pub fn add_read_only_journal(
+        &mut self,
+        journal: Arc<crate::journal::DynReadableJournal>,
+    ) -> &mut Self {
+        self.inner.add_read_only_journal(journal);
+        self
+    }
+
+    #[cfg(feature = "journal")]
+    pub fn add_writable_journal(&mut self, journal: Arc<crate::journal::DynJournal>) -> &mut Self {
+        self.inner.add_writable_journal(journal);
         self
     }
 }
diff --git a/lib/wasix/src/runners/dproxy/factory.rs b/lib/wasix/src/runners/dproxy/factory.rs
index 1833a781ca..cf7ccddec9 100644
--- a/lib/wasix/src/runners/dproxy/factory.rs
+++ b/lib/wasix/src/runners/dproxy/factory.rs
@@ -5,7 +5,6 @@ use std::{
     time::Instant,
 };
 
-use derivative::Derivative;
 use hyper_util::rt::TokioExecutor;
 use wasmer_journal::{DynJournal, RecombinedJournal};
 
@@ -26,8 +25,7 @@ struct State {
 
 /// This factory will store and reuse instances between invocations thus
 /// allowing for the instances to be stateful.
-#[derive(Derivative, Clone, Default)]
-#[derivative(Debug)]
+#[derive(Debug, Clone, Default)]
 pub struct DProxyInstanceFactory {
     state: Arc<Mutex<State>>,
 }
@@ -60,17 +58,14 @@ impl DProxyInstanceFactory {
         // DProxy is able to resume execution of the stateful workload using memory
         // snapshots hence the journals it stores are complete journals
         let journals = runtime
-            .journals()
-            .clone()
-            .into_iter()
+            .writable_journals()
             .map(|journal| {
-                let tx = journal.clone();
                 let rx = journal.as_restarted()?;
-                let combined = RecombinedJournal::new(tx, rx);
+                let combined = RecombinedJournal::new(journal, rx);
                 anyhow::Result::Ok(Arc::new(combined) as Arc<DynJournal>)
             })
             .collect::<anyhow::Result<Vec<_>>>()?;
-        let mut runtime = OverriddenRuntime::new(runtime).with_journals(journals);
+        let mut runtime = OverriddenRuntime::new(runtime).with_writable_journals(journals);
 
         // We attach a composite networking to the runtime which includes a loopback
         // networking implementation connected to a socket manager
@@ -107,7 +102,7 @@ impl DProxyInstanceFactory {
             .task_dedicated(Box::new(move || {
                 #[cfg(feature = "sys")]
                 let _guard = handle.enter();
-                if let Err(err) = runner.run_command(&command_name, &pkg, runtime) {
+                if let Err(err) = Runner::run_command(&mut runner, &command_name, &pkg, runtime) {
                     tracing::error!("Instance Exited: {}", err);
                 } else {
                     tracing::info!("Instance Exited: Nominal");
diff --git a/lib/wasix/src/runners/dproxy/handler.rs b/lib/wasix/src/runners/dproxy/handler.rs
index 0d83d053eb..7cc283b88c 100644
--- a/lib/wasix/src/runners/dproxy/handler.rs
+++ b/lib/wasix/src/runners/dproxy/handler.rs
@@ -14,12 +14,10 @@ use crate::Runtime;
 use super::factory::DProxyInstanceFactory;
 use super::Config;
 
-#[derive(derivative::Derivative)]
-#[derivative(Debug)]
+#[derive(Debug)]
 pub struct SharedState {
     pub(crate) config: Config,
     pub(crate) command_name: String,
-    #[derivative(Debug = "ignore")]
     pub(crate) runtime: Arc<dyn Runtime + Send + Sync>,
     pub(crate) factory: DProxyInstanceFactory,
 }
diff --git a/lib/wasix/src/runners/dproxy/networking.rs b/lib/wasix/src/runners/dproxy/networking.rs
index 8e46f1ce52..2e288e3e6d 100644
--- a/lib/wasix/src/runners/dproxy/networking.rs
+++ b/lib/wasix/src/runners/dproxy/networking.rs
@@ -1,3 +1,4 @@
+use std::sync::LazyLock;
 use std::{
     net::{IpAddr, SocketAddr},
     sync::{Arc, Mutex},
@@ -26,9 +27,7 @@ pub struct LocalWithLoopbackNetworking {
 
 impl LocalWithLoopbackNetworking {
     pub fn new() -> Self {
-        lazy_static::lazy_static! {
-            static ref LOCAL_NETWORKING: Arc<LocalNetworking> = Arc::new(LocalNetworking::default());
-        }
+        static LOCAL_NETWORKING: LazyLock<Arc<LocalNetworking>> = LazyLock::new(Arc::default);
         Self {
             local_listening: Default::default(),
             inner_networking: LOCAL_NETWORKING.clone(),
diff --git a/lib/wasix/src/runners/dproxy/runner.rs b/lib/wasix/src/runners/dproxy/runner.rs
index 446d63fa7a..3ff2865c82 100644
--- a/lib/wasix/src/runners/dproxy/runner.rs
+++ b/lib/wasix/src/runners/dproxy/runner.rs
@@ -101,7 +101,7 @@ impl crate::runners::Runner for DProxyRunner {
                             let fut = graceful.watch(conn);
                             futs.push(async move {
                                 if let Err(e) = fut.await {
-                                    eprintln!("Error serving connection: {:?}", e);
+                                    eprintln!("Error serving connection: {e:?}");
                                 }
                             });
                         },
diff --git a/lib/wasix/src/runners/dproxy/socket_manager.rs b/lib/wasix/src/runners/dproxy/socket_manager.rs
index 658832fde1..801a96e485 100644
--- a/lib/wasix/src/runners/dproxy/socket_manager.rs
+++ b/lib/wasix/src/runners/dproxy/socket_manager.rs
@@ -9,17 +9,15 @@ use std::{
     time::Duration,
 };
 
-use derivative::Derivative;
 use tokio::sync::broadcast;
 use virtual_net::{tcp_pair::TcpSocketHalf, LoopbackNetworking};
 
 pub type PollListeningFn =
     Arc<dyn Fn(&mut Context<'_>) -> Poll<SocketAddr> + Send + Sync + 'static>;
 
-#[derive(Derivative)]
-#[derivative(Debug)]
+#[derive(derive_more::Debug)]
 pub struct SocketManager {
-    #[derivative(Debug = "ignore")]
+    #[debug(ignore)]
     poll_listening: PollListeningFn,
     loopback_networking: LoopbackNetworking,
     proxy_connect_init_timeout: Duration,
diff --git a/lib/wasix/src/runners/emscripten.rs b/lib/wasix/src/runners/emscripten.rs
deleted file mode 100644
index 7e7810118b..0000000000
--- a/lib/wasix/src/runners/emscripten.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-//! WebC container support for running Emscripten modules
-
-use std::sync::Arc;
-
-use anyhow::{anyhow, Context, Error};
-use serde::{Deserialize, Serialize};
-use wasmer::{FunctionEnv, Instance, Module, Store};
-use wasmer_emscripten::{
-    generate_emscripten_env, is_emscripten_module, run_emscripten_instance, EmEnv,
-    EmscriptenGlobals,
-};
-use webc::metadata::{annotations::Emscripten, Command};
-
-use crate::{bin_factory::BinaryPackage, Runtime};
-
-#[derive(Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub struct EmscriptenRunner {
-    args: Vec<String>,
-}
-
-impl EmscriptenRunner {
-    /// Constructs a new `EmscriptenRunner` given an `Store`
-    pub fn new() -> Self {
-        EmscriptenRunner::default()
-    }
-
-    /// Returns the current arguments for this `EmscriptenRunner`
-    pub fn get_args(&self) -> Vec<String> {
-        self.args.clone()
-    }
-
-    /// Builder method to provide CLI args to the runner
-    pub fn with_args(mut self, args: Vec<String>) -> Self {
-        self.set_args(args);
-        self
-    }
-
-    /// Set the CLI args
-    pub fn set_args(&mut self, args: Vec<String>) {
-        self.args = args;
-    }
-}
-
-impl crate::runners::Runner for EmscriptenRunner {
-    fn can_run_command(command: &Command) -> Result<bool, Error> {
-        Ok(command
-            .runner
-            .starts_with(webc::metadata::annotations::EMSCRIPTEN_RUNNER_URI))
-    }
-
-    #[allow(unreachable_code, unused_variables)]
-    fn run_command(
-        &mut self,
-        command_name: &str,
-        pkg: &BinaryPackage,
-        runtime: Arc<dyn Runtime + Send + Sync>,
-    ) -> Result<(), Error> {
-        let cmd = pkg
-            .get_command(command_name)
-            .with_context(|| format!("The package doesn't contain a \"{command_name}\" command"))?;
-        let Emscripten { main_args, .. } =
-            cmd.metadata().annotation("emscripten")?.unwrap_or_default();
-
-        let mut module = runtime.load_module_sync(cmd.atom())?;
-        module.set_name(command_name);
-
-        let mut store = runtime.new_store();
-        let (mut globals, env) = prepare_emscripten_env(&mut store, &module, command_name)?;
-
-        exec_module(
-            &mut store,
-            &module,
-            &mut globals,
-            env,
-            command_name,
-            main_args.unwrap_or_default(),
-        )?;
-
-        Ok(())
-    }
-}
-
-fn prepare_emscripten_env(
-    store: &mut Store,
-    module: &Module,
-    name: &str,
-) -> Result<(EmscriptenGlobals, FunctionEnv<EmEnv>), anyhow::Error> {
-    if !is_emscripten_module(module) {
-        return Err(anyhow!("Atom {name:?} is not an emscripten module"));
-    }
-
-    let env = FunctionEnv::new(store, EmEnv::new());
-    let emscripten_globals = EmscriptenGlobals::new(store, &env, module);
-    let emscripten_globals = emscripten_globals.map_err(|e| anyhow!("{}", e))?;
-    env.as_mut(store)
-        .set_data(&emscripten_globals.data, Default::default());
-
-    Ok((emscripten_globals, env))
-}
-
-fn exec_module(
-    store: &mut Store,
-    module: &Module,
-    globals: &mut EmscriptenGlobals,
-    em_env: FunctionEnv<EmEnv>,
-    name: &str,
-    args: Vec<String>,
-) -> Result<(), anyhow::Error> {
-    let import_object = generate_emscripten_env(store, &em_env, globals);
-
-    let mut instance = Instance::new(store, module, &import_object)
-        .map_err(|e| anyhow!("Cant instantiate emscripten module {name:?}: {e}"))?;
-
-    run_emscripten_instance(
-        &mut instance,
-        em_env.into_mut(store),
-        globals,
-        name,
-        args.iter().map(|arg| arg.as_str()).collect(),
-        None,
-    )?;
-
-    Ok(())
-}
diff --git a/lib/wasix/src/runners/mod.rs b/lib/wasix/src/runners/mod.rs
index 25ccfc939f..03ad7ec9b8 100644
--- a/lib/wasix/src/runners/mod.rs
+++ b/lib/wasix/src/runners/mod.rs
@@ -4,8 +4,6 @@ mod runner;
 pub mod dcgi;
 #[cfg(feature = "webc_runner_rt_dproxy")]
 pub mod dproxy;
-#[cfg(feature = "webc_runner_rt_emscripten")]
-pub mod emscripten;
 pub mod wasi;
 mod wasi_common;
 #[cfg(feature = "webc_runner_rt_wcgi")]
@@ -59,7 +57,7 @@ mod response_tracing {
             _latency: std::time::Duration,
             span: &tracing::Span,
         ) {
-            span.record("status_code", &tracing::field::display(response.status()));
+            span.record("status_code", tracing::field::display(response.status()));
             tracing::info!("response generated")
         }
     }
diff --git a/lib/wasix/src/runners/wasi.rs b/lib/wasix/src/runners/wasi.rs
index 7713b80f6d..9daf461c81 100644
--- a/lib/wasix/src/runners/wasi.rs
+++ b/lib/wasix/src/runners/wasi.rs
@@ -5,18 +5,18 @@ use std::{path::PathBuf, sync::Arc};
 use anyhow::{Context, Error};
 use tracing::Instrument;
 use virtual_fs::{ArcBoxFile, FileSystem, TmpFileSystem, VirtualFile};
-use wasmer::{Extern, Module};
+use wasmer::{Engine, Module};
+use wasmer_types::ModuleHash;
 use webc::metadata::{annotations::Wasi, Command};
 
 use crate::{
     bin_factory::BinaryPackage,
     capabilities::Capabilities,
-    journal::{DynJournal, SnapshotTrigger},
+    journal::{DynJournal, DynReadableJournal, SnapshotTrigger},
     runners::{wasi_common::CommonWasiOptions, MappedDirectory, MountedDirectory},
     runtime::task_manager::VirtualTaskManagerExt,
     Runtime, WasiEnvBuilder, WasiError, WasiRuntimeError,
 };
-use wasmer_types::ModuleHash;
 
 use super::wasi_common::{MappedCommand, MAPPED_CURRENT_DIR_DEFAULT_PATH};
 
@@ -28,12 +28,36 @@ pub struct WasiRunner {
     stderr: Option<ArcBoxFile>,
 }
 
+pub enum PackageOrHash<'a> {
+    Package(&'a BinaryPackage),
+    Hash(ModuleHash),
+}
+
+pub enum RuntimeOrEngine {
+    Runtime(Arc<dyn Runtime + Send + Sync>),
+    Engine(Engine),
+}
+
 impl WasiRunner {
     /// Constructs a new `WasiRunner`.
     pub fn new() -> Self {
         WasiRunner::default()
     }
 
+    /// Returns the current entry function for this `WasiRunner`
+    pub fn entry_function(&self) -> Option<String> {
+        self.wasi.entry_function.clone()
+    }
+
+    /// Builder method to set the name of the entry function for this `WasiRunner`
+    pub fn with_entry_function<S>(&mut self, entry_function: S) -> &mut Self
+    where
+        S: Into<String>,
+    {
+        self.wasi.entry_function = Some(entry_function.into());
+        self
+    }
+
     /// Returns the current arguments for this `WasiRunner`
     pub fn get_args(&self) -> Vec<String> {
         self.wasi.args.clone()
@@ -155,11 +179,13 @@ impl WasiRunner {
         self
     }
 
+    #[cfg(feature = "journal")]
     pub fn with_snapshot_trigger(&mut self, on: SnapshotTrigger) -> &mut Self {
         self.wasi.snapshot_on.push(on);
         self
     }
 
+    #[cfg(feature = "journal")]
     pub fn with_default_snapshot_triggers(&mut self) -> &mut Self {
         for on in crate::journal::DEFAULT_SNAPSHOT_TRIGGERS {
             if !self.has_snapshot_trigger(on) {
@@ -169,10 +195,12 @@ impl WasiRunner {
         self
     }
 
+    #[cfg(feature = "journal")]
     pub fn has_snapshot_trigger(&self, on: SnapshotTrigger) -> bool {
         self.wasi.snapshot_on.iter().any(|t| *t == on)
     }
 
+    #[cfg(feature = "journal")]
     pub fn with_snapshot_interval(&mut self, period: std::time::Duration) -> &mut Self {
         if !self.has_snapshot_trigger(SnapshotTrigger::PeriodicInterval) {
             self.with_snapshot_trigger(SnapshotTrigger::PeriodicInterval);
@@ -181,8 +209,26 @@ impl WasiRunner {
         self
     }
 
-    pub fn with_journal(&mut self, journal: Arc<DynJournal>) -> &mut Self {
-        self.wasi.journals.push(journal);
+    #[cfg(feature = "journal")]
+    pub fn with_stop_running_after_snapshot(&mut self, stop_running: bool) -> &mut Self {
+        self.wasi.stop_running_after_snapshot = stop_running;
+        self
+    }
+
+    #[cfg(feature = "journal")]
+    pub fn with_read_only_journal(&mut self, journal: Arc<DynReadableJournal>) -> &mut Self {
+        self.wasi.read_only_journals.push(journal);
+        self
+    }
+
+    #[cfg(feature = "journal")]
+    pub fn with_writable_journal(&mut self, journal: Arc<DynJournal>) -> &mut Self {
+        self.wasi.writable_journals.push(journal);
+        self
+    }
+
+    pub fn with_skip_stdio_during_bootstrap(&mut self, skip: bool) -> &mut Self {
+        self.wasi.skip_stdio_during_bootstrap = skip;
         self
     }
 
@@ -201,31 +247,28 @@ impl WasiRunner {
         self
     }
 
-    /// Add an item to the list of importable items provided to the instance.
-    pub fn with_import(
-        &mut self,
-        namespace: impl Into<String>,
-        name: impl Into<String>,
-        value: impl Into<Extern>,
-    ) -> &mut Self {
-        self.with_imports([((namespace, name), value)])
-    }
+    fn ensure_tokio_runtime() -> Option<tokio::runtime::Runtime> {
+        #[cfg(feature = "sys-thread")]
+        {
+            if tokio::runtime::Handle::try_current().is_ok() {
+                return None;
+            }
 
-    /// Add multiple import functions.
-    ///
-    /// This method will accept a [`&Imports`][wasmer::Imports] object.
-    pub fn with_imports<I, S1, S2, E>(&mut self, imports: I) -> &mut Self
-    where
-        I: IntoIterator<Item = ((S1, S2), E)>,
-        S1: Into<String>,
-        S2: Into<String>,
-        E: Into<Extern>,
-    {
-        let imports = imports
-            .into_iter()
-            .map(|((ns, n), e)| ((ns.into(), n.into()), e.into()));
-        self.wasi.additional_imports.extend(imports);
-        self
+            let rt = tokio::runtime::Builder::new_multi_thread()
+                .enable_all()
+                .build()
+                .expect(
+                    "Failed to build a multi-threaded tokio runtime. This is necessary \
+                for WASIX to work. You can provide a tokio runtime by building one \
+                yourself and entering it before using WasiRunner.",
+                );
+            Some(rt)
+        }
+
+        #[cfg(not(feature = "sys-thread"))]
+        {
+            None
+        }
     }
 
     #[tracing::instrument(level = "debug", skip_all)]
@@ -233,21 +276,46 @@ impl WasiRunner {
         &self,
         program_name: &str,
         wasi: &Wasi,
-        pkg: Option<&BinaryPackage>,
-        runtime: Arc<dyn Runtime + Send + Sync>,
+        pkg_or_hash: PackageOrHash,
+        runtime_or_engine: RuntimeOrEngine,
         root_fs: Option<TmpFileSystem>,
     ) -> Result<WasiEnvBuilder, anyhow::Error> {
-        let mut builder = WasiEnvBuilder::new(program_name).runtime(runtime);
+        let mut builder = WasiEnvBuilder::new(program_name);
 
-        let container_fs = if let Some(pkg) = pkg {
-            builder.add_webc(pkg.clone());
-            builder.set_module_hash(pkg.hash());
-            builder.include_packages(pkg.package_ids.clone());
-            Some(Arc::clone(&pkg.webc_fs))
-        } else {
-            None
+        match runtime_or_engine {
+            RuntimeOrEngine::Runtime(runtime) => {
+                builder.set_runtime(runtime);
+            }
+            RuntimeOrEngine::Engine(engine) => {
+                builder.set_engine(engine);
+            }
+        }
+
+        let container_fs = match pkg_or_hash {
+            PackageOrHash::Package(pkg) => {
+                builder.add_webc(pkg.clone());
+                builder.set_module_hash(pkg.hash());
+                builder.include_packages(pkg.package_ids.clone());
+                Some(Arc::clone(&pkg.webc_fs))
+            }
+            PackageOrHash::Hash(hash) => {
+                builder.set_module_hash(hash);
+                None
+            }
         };
 
+        if self.wasi.is_home_mapped {
+            builder.set_current_dir(MAPPED_CURRENT_DIR_DEFAULT_PATH);
+        }
+
+        if let Some(current_dir) = &self.wasi.current_dir {
+            builder.set_current_dir(current_dir.clone());
+        }
+
+        if let Some(cwd) = &wasi.cwd {
+            builder.set_current_dir(cwd);
+        }
+
         self.wasi
             .prepare_webc_env(&mut builder, container_fs, wasi, root_fs)?;
 
@@ -261,25 +329,29 @@ impl WasiRunner {
             builder.set_stderr(Box::new(stderr.clone()));
         }
 
-        if self.wasi.is_home_mapped {
-            builder.set_current_dir(MAPPED_CURRENT_DIR_DEFAULT_PATH);
-        }
-
         Ok(builder)
     }
 
     pub fn run_wasm(
         &self,
-        runtime: Arc<dyn Runtime + Send + Sync>,
+        runtime_or_engine: RuntimeOrEngine,
         program_name: &str,
-        module: &Module,
+        module: Module,
         module_hash: ModuleHash,
-        asyncify: bool,
     ) -> Result<(), Error> {
+        // Just keep the runtime and enter guard alive until we're done running the module
+        let tokio_runtime = Self::ensure_tokio_runtime();
+        let _guard = tokio_runtime.as_ref().map(|rt| rt.enter());
+
         let wasi = webc::metadata::annotations::Wasi::new(program_name);
-        let mut store = runtime.new_store();
 
-        let mut builder = self.prepare_webc_env(program_name, &wasi, None, runtime, None)?;
+        let mut builder = self.prepare_webc_env(
+            program_name,
+            &wasi,
+            PackageOrHash::Hash(module_hash),
+            runtime_or_engine,
+            None,
+        )?;
 
         #[cfg(feature = "ctrlc")]
         {
@@ -288,48 +360,80 @@ impl WasiRunner {
 
         #[cfg(feature = "journal")]
         {
-            for trigger in self.wasi.snapshot_on.iter().cloned() {
-                builder.add_snapshot_trigger(trigger);
+            for journal in self.wasi.read_only_journals.iter().cloned() {
+                builder.add_read_only_journal(journal);
+            }
+            for journal in self.wasi.writable_journals.iter().cloned() {
+                builder.add_writable_journal(journal);
             }
-            if self.wasi.snapshot_on.is_empty() && !self.wasi.journals.is_empty() {
+
+            if !self.wasi.snapshot_on.is_empty() {
+                for trigger in self.wasi.snapshot_on.iter().cloned() {
+                    builder.add_snapshot_trigger(trigger);
+                }
+            } else if !self.wasi.writable_journals.is_empty() {
                 for on in crate::journal::DEFAULT_SNAPSHOT_TRIGGERS {
                     builder.add_snapshot_trigger(on);
                 }
             }
+
             if let Some(period) = self.wasi.snapshot_interval {
-                if self.wasi.journals.is_empty() {
+                if self.wasi.writable_journals.is_empty() {
                     return Err(anyhow::format_err!(
-                            "If you specify a snapshot interval then you must also specify a journal file"
+                            "If you specify a snapshot interval then you must also specify a writable journal file"
                         ));
                 }
                 builder.with_snapshot_interval(period);
             }
-        }
 
-        if asyncify {
-            builder.run_with_store_async(module.clone(), module_hash, store)?;
-        } else {
-            builder.run_with_store_ext(module.clone(), module_hash, &mut store)?;
+            builder.with_stop_running_after_snapshot(self.wasi.stop_running_after_snapshot);
+            builder.with_skip_stdio_during_bootstrap(self.wasi.skip_stdio_during_bootstrap);
         }
 
-        Ok(())
-    }
-}
+        let env = builder.build()?;
+        let runtime = env.runtime.clone();
+        let tasks = runtime.task_manager().clone();
 
-impl crate::runners::Runner for WasiRunner {
-    fn can_run_command(command: &Command) -> Result<bool, Error> {
-        Ok(command
-            .runner
-            .starts_with(webc::metadata::annotations::WASI_RUNNER_URI))
+        let mut task_handle =
+            crate::bin_factory::spawn_exec_module(module, env, &runtime).context("Spawn failed")?;
+
+        #[cfg(feature = "ctrlc")]
+        task_handle.install_ctrlc_handler();
+        let task_handle = async move { task_handle.wait_finished().await }.in_current_span();
+
+        let result = tasks.spawn_and_block_on(task_handle)?;
+        let exit_code = result
+            .map_err(|err| {
+                // We do our best to recover the error
+                let msg = err.to_string();
+                let weak = Arc::downgrade(&err);
+                Arc::into_inner(err).unwrap_or_else(|| {
+                    weak.upgrade()
+                        .map(|err| wasi_runtime_error_to_owned(&err))
+                        .unwrap_or_else(|| {
+                            WasiRuntimeError::Anyhow(Arc::new(anyhow::format_err!("{}", msg)))
+                        })
+                })
+            })
+            .context("Unable to wait for the process to exit")?;
+
+        if exit_code.raw() == 0 {
+            Ok(())
+        } else {
+            Err(WasiRuntimeError::Wasi(crate::WasiError::Exit(exit_code)).into())
+        }
     }
 
-    #[tracing::instrument(skip_all)]
-    fn run_command(
+    pub fn run_command(
         &mut self,
         command_name: &str,
         pkg: &BinaryPackage,
-        runtime: Arc<dyn Runtime + Send + Sync>,
+        runtime_or_engine: RuntimeOrEngine,
     ) -> Result<(), Error> {
+        // Just keep the runtime and enter guard alive until we're done running the module
+        let tokio_runtime = Self::ensure_tokio_runtime();
+        let _guard = tokio_runtime.as_ref().map(|rt| rt.enter());
+
         let cmd = pkg
             .get_command(command_name)
             .with_context(|| format!("The package doesn't contain a \"{command_name}\" command"))?;
@@ -338,37 +442,68 @@ impl crate::runners::Runner for WasiRunner {
             .annotation("wasi")?
             .unwrap_or_else(|| Wasi::new(command_name));
 
+        let exec_name = if let Some(exec_name) = wasi.exec_name.as_ref() {
+            exec_name
+        } else {
+            command_name
+        };
+
         #[allow(unused_mut)]
-        let mut env = self
-            .prepare_webc_env(command_name, &wasi, Some(pkg), Arc::clone(&runtime), None)
+        let mut builder = self
+            .prepare_webc_env(
+                exec_name,
+                &wasi,
+                PackageOrHash::Package(pkg),
+                runtime_or_engine,
+                None,
+            )
             .context("Unable to prepare the WASI environment")?;
 
         #[cfg(feature = "journal")]
         {
-            for journal in self.wasi.journals.clone() {
-                env.add_journal(journal);
+            for journal in self.wasi.read_only_journals.iter().cloned() {
+                builder.add_read_only_journal(journal);
+            }
+            for journal in self.wasi.writable_journals.iter().cloned() {
+                builder.add_writable_journal(journal);
             }
 
-            for snapshot_trigger in self.wasi.snapshot_on.iter().cloned() {
-                env.add_snapshot_trigger(snapshot_trigger);
+            if !self.wasi.snapshot_on.is_empty() {
+                for trigger in self.wasi.snapshot_on.iter().cloned() {
+                    builder.add_snapshot_trigger(trigger);
+                }
+            } else if !self.wasi.writable_journals.is_empty() {
+                for on in crate::journal::DEFAULT_SNAPSHOT_TRIGGERS {
+                    builder.add_snapshot_trigger(on);
+                }
             }
-        }
 
-        if let Some(cwd) = &wasi.cwd {
-            env.set_current_dir(cwd);
-        }
+            if let Some(period) = self.wasi.snapshot_interval {
+                if self.wasi.writable_journals.is_empty() {
+                    return Err(anyhow::format_err!(
+                            "If you specify a snapshot interval then you must also specify a journal file"
+                        ));
+                }
+                builder.with_snapshot_interval(period);
+            }
 
-        let env = env.build()?;
-        let store = runtime.new_store();
+            builder.with_stop_running_after_snapshot(self.wasi.stop_running_after_snapshot);
+        }
 
+        let env = builder.build()?;
+        let runtime = env.runtime.clone();
         let command_name = command_name.to_string();
         let tasks = runtime.task_manager().clone();
         let pkg = pkg.clone();
 
+        // Wrapping the call to `spawn_and_block_on` in a call to `spawn_await` could help to prevent deadlocks
+        // because then blocking in here won't block the tokio runtime
+        //
+        // See run_wasm above for a possible fix
         let exit_code = tasks.spawn_and_block_on(
             async move {
                 let mut task_handle =
-                    crate::bin_factory::spawn_exec(pkg, &command_name, store, env, &runtime)
+                    crate::bin_factory::spawn_exec(pkg, &command_name, env, &runtime)
                         .await
                         .context("Spawn failed")?;
 
@@ -384,38 +519,7 @@ impl crate::runners::Runner for WasiRunner {
                         let weak = Arc::downgrade(&err);
                         Arc::into_inner(err).unwrap_or_else(|| {
                             weak.upgrade()
-                                .map(|err| match err.as_ref() {
-                                    WasiRuntimeError::Init(a) => WasiRuntimeError::Init(a.clone()),
-                                    WasiRuntimeError::Export(a) => {
-                                        WasiRuntimeError::Export(a.clone())
-                                    }
-                                    WasiRuntimeError::Instantiation(a) => {
-                                        WasiRuntimeError::Instantiation(a.clone())
-                                    }
-                                    WasiRuntimeError::Wasi(WasiError::Exit(a)) => {
-                                        WasiRuntimeError::Wasi(WasiError::Exit(*a))
-                                    }
-                                    WasiRuntimeError::Wasi(WasiError::UnknownWasiVersion) => {
-                                        WasiRuntimeError::Wasi(WasiError::UnknownWasiVersion)
-                                    }
-                                    WasiRuntimeError::Wasi(WasiError::DeepSleep(_)) => {
-                                        WasiRuntimeError::Anyhow(Arc::new(anyhow::format_err!(
-                                            "deep-sleep"
-                                        )))
-                                    }
-                                    WasiRuntimeError::ControlPlane(a) => {
-                                        WasiRuntimeError::ControlPlane(a.clone())
-                                    }
-                                    WasiRuntimeError::Runtime(a) => {
-                                        WasiRuntimeError::Runtime(a.clone())
-                                    }
-                                    WasiRuntimeError::Thread(a) => {
-                                        WasiRuntimeError::Thread(a.clone())
-                                    }
-                                    WasiRuntimeError::Anyhow(a) => {
-                                        WasiRuntimeError::Anyhow(a.clone())
-                                    }
-                                })
+                                .map(|err| wasi_runtime_error_to_owned(&err))
                                 .unwrap_or_else(|| {
                                     WasiRuntimeError::Anyhow(Arc::new(anyhow::format_err!(
                                         "{}", msg
@@ -436,6 +540,49 @@ impl crate::runners::Runner for WasiRunner {
     }
 }
 
+impl crate::runners::Runner for WasiRunner {
+    fn can_run_command(command: &Command) -> Result<bool, Error> {
+        Ok(command
+            .runner
+            .starts_with(webc::metadata::annotations::WASI_RUNNER_URI))
+    }
+
+    #[tracing::instrument(skip_all)]
+    fn run_command(
+        &mut self,
+        command_name: &str,
+        pkg: &BinaryPackage,
+        runtime: Arc<dyn Runtime + Send + Sync>,
+    ) -> Result<(), Error> {
+        self.run_command(command_name, pkg, RuntimeOrEngine::Runtime(runtime))
+    }
+}
+
+fn wasi_runtime_error_to_owned(err: &WasiRuntimeError) -> WasiRuntimeError {
+    match err {
+        WasiRuntimeError::Init(a) => WasiRuntimeError::Init(a.clone()),
+        WasiRuntimeError::Export(a) => WasiRuntimeError::Export(a.clone()),
+        WasiRuntimeError::Instantiation(a) => WasiRuntimeError::Instantiation(a.clone()),
+        WasiRuntimeError::Wasi(WasiError::Exit(a)) => WasiRuntimeError::Wasi(WasiError::Exit(*a)),
+        WasiRuntimeError::Wasi(WasiError::ThreadExit) => {
+            WasiRuntimeError::Wasi(WasiError::ThreadExit)
+        }
+        WasiRuntimeError::Wasi(WasiError::UnknownWasiVersion) => {
+            WasiRuntimeError::Wasi(WasiError::UnknownWasiVersion)
+        }
+        WasiRuntimeError::Wasi(WasiError::DeepSleep(_)) => {
+            WasiRuntimeError::Anyhow(Arc::new(anyhow::format_err!("deep-sleep")))
+        }
+        WasiRuntimeError::Wasi(WasiError::DlSymbolResolutionFailed(symbol)) => {
+            WasiRuntimeError::Wasi(WasiError::DlSymbolResolutionFailed(symbol.clone()))
+        }
+        WasiRuntimeError::ControlPlane(a) => WasiRuntimeError::ControlPlane(a.clone()),
+        WasiRuntimeError::Runtime(a) => WasiRuntimeError::Runtime(a.clone()),
+        WasiRuntimeError::Thread(a) => WasiRuntimeError::Thread(a.clone()),
+        WasiRuntimeError::Anyhow(a) => WasiRuntimeError::Anyhow(a.clone()),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -448,4 +595,102 @@ mod tests {
         assert_send::<WasiRunner>();
         assert_sync::<WasiRunner>();
     }
+
+    #[cfg(all(feature = "host-fs", feature = "sys"))]
+    #[tokio::test]
+    async fn test_volume_mount_without_webcs() {
+        use std::sync::Arc;
+
+        let root_fs = virtual_fs::RootFileSystemBuilder::new().build();
+
+        let tokrt = tokio::runtime::Handle::current();
+
+        let hostdir = virtual_fs::host_fs::FileSystem::new(tokrt.clone(), "/").unwrap();
+        let hostdir_dyn: Arc<dyn virtual_fs::FileSystem + Send + Sync> = Arc::new(hostdir);
+
+        root_fs
+            .mount("/host".into(), &hostdir_dyn, "/".into())
+            .unwrap();
+
+        let envb = crate::runners::wasi::WasiRunner::new();
+
+        let annotations = webc::metadata::annotations::Wasi::new("test");
+
+        let tm = Arc::new(crate::runtime::task_manager::tokio::TokioTaskManager::new(
+            tokrt.clone(),
+        ));
+        let rt = crate::PluggableRuntime::new(tm);
+
+        let envb = envb
+            .prepare_webc_env(
+                "test",
+                &annotations,
+                PackageOrHash::Hash(ModuleHash::random()),
+                RuntimeOrEngine::Runtime(Arc::new(rt)),
+                Some(root_fs),
+            )
+            .unwrap();
+
+        let init = envb.build_init().unwrap();
+
+        let fs = &init.state.fs.root_fs;
+
+        fs.read_dir(std::path::Path::new("/host")).unwrap();
+    }
+
+    #[cfg(all(feature = "host-fs", feature = "sys"))]
+    #[tokio::test]
+    async fn test_volume_mount_with_webcs() {
+        use std::sync::Arc;
+
+        use wasmer_package::utils::from_bytes;
+
+        let root_fs = virtual_fs::RootFileSystemBuilder::new().build();
+
+        let tokrt = tokio::runtime::Handle::current();
+
+        let hostdir = virtual_fs::host_fs::FileSystem::new(tokrt.clone(), "/").unwrap();
+        let hostdir_dyn: Arc<dyn virtual_fs::FileSystem + Send + Sync> = Arc::new(hostdir);
+
+        root_fs
+            .mount("/host".into(), &hostdir_dyn, "/".into())
+            .unwrap();
+
+        let envb = crate::runners::wasi::WasiRunner::new();
+
+        let annotations = webc::metadata::annotations::Wasi::new("test");
+
+        let tm = Arc::new(crate::runtime::task_manager::tokio::TokioTaskManager::new(
+            tokrt.clone(),
+        ));
+        let mut rt = crate::PluggableRuntime::new(tm);
+        rt.set_package_loader(crate::runtime::package_loader::BuiltinPackageLoader::new());
+
+        let webc_path = std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap()).join("../../tests/integration/cli/tests/webc/wasmer-tests--volume-static-webserver@0.1.0.webc");
+        let webc_data = std::fs::read(webc_path).unwrap();
+        let container = from_bytes(webc_data).unwrap();
+
+        let binpkg = crate::bin_factory::BinaryPackage::from_webc(&container, &rt)
+            .await
+            .unwrap();
+
+        let mut envb = envb
+            .prepare_webc_env(
+                "test",
+                &annotations,
+                PackageOrHash::Package(&binpkg),
+                RuntimeOrEngine::Runtime(Arc::new(rt)),
+                Some(root_fs),
+            )
+            .unwrap();
+
+        envb = envb.preopen_dir("/host").unwrap();
+
+        let init = envb.build_init().unwrap();
+
+        let fs = &init.state.fs.root_fs;
+
+        fs.read_dir(std::path::Path::new("/host")).unwrap();
+        fs.read_dir(std::path::Path::new("/settings")).unwrap();
+    }
 }
diff --git a/lib/wasix/src/runners/wasi_common.rs b/lib/wasix/src/runners/wasi_common.rs
index 82b2135f98..c585d8bd78 100644
--- a/lib/wasix/src/runners/wasi_common.rs
+++ b/lib/wasix/src/runners/wasi_common.rs
@@ -5,17 +5,15 @@ use std::{
 };
 
 use anyhow::{Context, Error};
-use derivative::Derivative;
 use futures::future::BoxFuture;
 use tokio::runtime::Handle;
 use virtual_fs::{FileSystem, FsError, OverlayFileSystem, RootFileSystemBuilder, TmpFileSystem};
-use wasmer::Imports;
 use webc::metadata::annotations::Wasi as WasiAnnotation;
 
 use crate::{
     bin_factory::BinaryPackage,
     capabilities::Capabilities,
-    journal::{DynJournal, SnapshotTrigger},
+    journal::{DynJournal, DynReadableJournal, SnapshotTrigger},
     WasiEnvBuilder,
 };
 
@@ -29,9 +27,9 @@ pub struct MappedCommand {
     pub target: String,
 }
 
-#[derive(Derivative, Default, Clone)]
-#[derivative(Debug)]
+#[derive(Debug, Default, Clone)]
 pub(crate) struct CommonWasiOptions {
+    pub(crate) entry_function: Option<String>,
     pub(crate) args: Vec<String>,
     pub(crate) env: HashMap<String, String>,
     pub(crate) forward_host_env: bool,
@@ -41,12 +39,13 @@ pub(crate) struct CommonWasiOptions {
     pub(crate) is_tmp_mapped: bool,
     pub(crate) injected_packages: Vec<BinaryPackage>,
     pub(crate) capabilities: Capabilities,
-    #[derivative(Debug = "ignore")]
-    pub(crate) journals: Vec<Arc<DynJournal>>,
+    pub(crate) read_only_journals: Vec<Arc<DynReadableJournal>>,
+    pub(crate) writable_journals: Vec<Arc<DynJournal>>,
     pub(crate) snapshot_on: Vec<SnapshotTrigger>,
     pub(crate) snapshot_interval: Option<std::time::Duration>,
+    pub(crate) stop_running_after_snapshot: bool,
+    pub(crate) skip_stdio_during_bootstrap: bool,
     pub(crate) current_dir: Option<PathBuf>,
-    pub(crate) additional_imports: Imports,
 }
 
 impl CommonWasiOptions {
@@ -57,6 +56,10 @@ impl CommonWasiOptions {
         wasi: &WasiAnnotation,
         root_fs: Option<TmpFileSystem>,
     ) -> Result<(), anyhow::Error> {
+        if let Some(ref entry_function) = self.entry_function {
+            builder.set_entry_function(entry_function);
+        }
+
         let root_fs = root_fs.unwrap_or_else(|| {
             RootFileSystemBuilder::default()
                 .with_tmp(!self.is_tmp_mapped)
@@ -64,13 +67,15 @@ impl CommonWasiOptions {
         });
         let fs = prepare_filesystem(root_fs, &self.mounts, container_fs)?;
 
-        builder.add_preopen_dir("/")?;
-
+        // TODO: What's a preopen for '.' supposed to mean anyway? Why do we need it?
         if self.mounts.iter().all(|m| m.guest != ".") {
             // The user hasn't mounted "." to anything, so let's map it to "/"
-            builder.add_map_dir(".", "/")?;
+            let path = builder.get_current_dir().unwrap_or(PathBuf::from("/"));
+            builder.add_map_dir(".", path)?;
         }
 
+        builder.add_preopen_dir("/")?;
+
         builder.set_fs(Box::new(fs));
 
         for pkg in &self.injected_packages {
@@ -88,7 +93,22 @@ impl CommonWasiOptions {
 
         *builder.capabilities_mut() = self.capabilities.clone();
 
-        builder.add_imports(&self.additional_imports);
+        #[cfg(feature = "journal")]
+        {
+            for journal in &self.read_only_journals {
+                builder.add_read_only_journal(journal.clone());
+            }
+            for journal in &self.writable_journals {
+                builder.add_writable_journal(journal.clone());
+            }
+            for trigger in &self.snapshot_on {
+                builder.add_snapshot_trigger(*trigger);
+            }
+            if let Some(interval) = self.snapshot_interval {
+                builder.with_snapshot_interval(interval);
+            }
+            builder.with_stop_running_after_snapshot(self.stop_running_after_snapshot);
+        }
 
         Ok(())
     }
@@ -380,7 +400,7 @@ mod tests {
 
     use tempfile::TempDir;
     use virtual_fs::{DirEntry, FileType, Metadata, WebcVolumeFileSystem};
-    use webc::Container;
+    use wasmer_package::utils::from_bytes;
 
     use super::*;
 
@@ -457,7 +477,7 @@ mod tests {
             guest: "/home".to_string(),
             host: sub_dir,
         })];
-        let container = Container::from_bytes(PYTHON).unwrap();
+        let container = from_bytes(PYTHON).unwrap();
         let webc_fs = WebcVolumeFileSystem::mount_all(&container);
 
         let root_fs = RootFileSystemBuilder::default().build();
diff --git a/lib/wasix/src/runners/wcgi/callbacks.rs b/lib/wasix/src/runners/wcgi/callbacks.rs
index 80fb68955b..9d95d4f399 100644
--- a/lib/wasix/src/runners/wcgi/callbacks.rs
+++ b/lib/wasix/src/runners/wcgi/callbacks.rs
@@ -36,7 +36,7 @@ pub struct RecycleEnvConfig {
 /// Callbacks that are triggered at various points in the lifecycle of a runner
 /// and any WebAssembly instances it may start.
 #[async_trait::async_trait]
-pub trait Callbacks: Send + Sync + 'static {
+pub trait Callbacks: std::fmt::Debug + Send + Sync + 'static {
     /// A callback that is called whenever the server starts.
     fn started(&self, _abort: AbortHandle) {}
 
@@ -57,6 +57,7 @@ pub trait Callbacks: Send + Sync + 'static {
     }
 }
 
+#[derive(Debug)]
 pub struct NoOpWcgiCallbacks;
 
 impl Callbacks for NoOpWcgiCallbacks {}
diff --git a/lib/wasix/src/runners/wcgi/handler.rs b/lib/wasix/src/runners/wcgi/handler.rs
index 5d4c5b5f89..265cfc9d92 100644
--- a/lib/wasix/src/runners/wcgi/handler.rs
+++ b/lib/wasix/src/runners/wcgi/handler.rs
@@ -126,7 +126,7 @@ impl Handler {
         // threading, etc...
         task_manager
             .task_wasm(
-                TaskWasm::new(Box::new(run_exec), env, module, false)
+                TaskWasm::new(Box::new(run_exec), env, module, false, false)
                     //.with_optional_memory(spawn_type)
                     .with_recycle(Box::new(recycle)),
             )
@@ -205,7 +205,7 @@ impl Handler {
 
         let chunks = futures::stream::try_unfold(res_body_receiver, |mut r| async move {
             match r.fill_buf().await {
-                Ok(chunk) if chunk.is_empty() => Ok(None),
+                Ok([]) => Ok(None),
                 Ok(chunk) => {
                     let chunk: bytes::Bytes = chunk.to_vec().into();
                     r.consume(chunk.len());
@@ -292,7 +292,7 @@ async fn consume_stderr(
     // able to show users the partial result.
     loop {
         match stderr.fill_buf().await {
-            Ok(chunk) if chunk.is_empty() => {
+            Ok([]) => {
                 // EOF - the instance's side of the pipe was closed.
                 break;
             }
@@ -318,19 +318,16 @@ async fn consume_stderr(
 
 pub type SetupBuilder = Arc<dyn Fn(&mut WasiEnvBuilder) -> Result<(), anyhow::Error> + Send + Sync>;
 
-#[derive(derivative::Derivative)]
-#[derivative(Debug)]
+#[derive(derive_more::Debug)]
 pub(crate) struct SharedState {
     pub(crate) module: Module,
     pub(crate) module_hash: ModuleHash,
     pub(crate) dialect: CgiDialect,
     pub(crate) program_name: String,
     pub(crate) propagate_stderr: bool,
-    #[derivative(Debug = "ignore")]
+    #[debug(ignore)]
     pub(crate) setup_builder: SetupBuilder,
-    #[derivative(Debug = "ignore")]
     pub(crate) callbacks: Arc<dyn Callbacks>,
-    #[derivative(Debug = "ignore")]
     pub(crate) runtime: Arc<dyn Runtime + Send + Sync>,
 }
 
diff --git a/lib/wasix/src/runners/wcgi/runner.rs b/lib/wasix/src/runners/wcgi/runner.rs
index f1ddc8f637..62acb54a96 100644
--- a/lib/wasix/src/runners/wcgi/runner.rs
+++ b/lib/wasix/src/runners/wcgi/runner.rs
@@ -62,7 +62,7 @@ impl WcgiRunner {
             .annotation("wasi")?
             .unwrap_or_else(|| Wasi::new(command_name));
 
-        let module = runtime.load_module_sync(cmd.atom())?;
+        let module = runtime.load_command_module_sync(cmd)?;
 
         let Wcgi { dialect, .. } = metadata.annotation("wcgi")?.unwrap_or_default();
         let dialect = match dialect {
@@ -154,7 +154,7 @@ impl WcgiRunner {
                         let fut = graceful.watch(conn);
                         futs.push(async move {
                             if let Err(e) = fut.await {
-                                eprintln!("Error serving connection: {:?}", e);
+                                eprintln!("Error serving connection: {e:?}");
                             }
                         });
                     },
@@ -193,19 +193,17 @@ impl crate::runners::Runner for WcgiRunner {
             command_name,
             pkg,
             false,
-            CgiDialect::Wcgi,
+            CgiDialect::Rfc3875,
             Arc::clone(&runtime),
         )?;
         self.run_command_with_handler(handler, runtime)
     }
 }
 
-#[derive(derivative::Derivative)]
-#[derivative(Debug)]
+#[derive(Debug)]
 pub struct Config {
     pub(crate) wasi: CommonWasiOptions,
     pub(crate) addr: SocketAddr,
-    #[derivative(Debug = "ignore")]
     pub(crate) callbacks: Arc<dyn Callbacks>,
 }
 
@@ -273,7 +271,7 @@ impl Config {
 
     /// Set callbacks that will be triggered at various points in the runner's
     /// lifecycle.
-    pub fn callbacks(&mut self, callbacks: impl Callbacks + Send + Sync + 'static) -> &mut Self {
+    pub fn callbacks(&mut self, callbacks: impl Callbacks + 'static) -> &mut Self {
         self.callbacks = Arc::new(callbacks);
         self
     }
@@ -327,8 +325,22 @@ impl Config {
     }
 
     #[cfg(feature = "journal")]
-    pub fn add_journal(&mut self, journal: Arc<crate::journal::DynJournal>) -> &mut Self {
-        self.wasi.journals.push(journal);
+    pub fn with_stop_running_after_snapshot(&mut self, stop_running: bool) {
+        self.wasi.stop_running_after_snapshot = stop_running;
+    }
+
+    #[cfg(feature = "journal")]
+    pub fn add_read_only_journal(
+        &mut self,
+        journal: Arc<crate::journal::DynReadableJournal>,
+    ) -> &mut Self {
+        self.wasi.read_only_journals.push(journal);
+        self
+    }
+
+    #[cfg(feature = "journal")]
+    pub fn add_writable_journal(&mut self, journal: Arc<crate::journal::DynJournal>) -> &mut Self {
+        self.wasi.writable_journals.push(journal);
         self
     }
 }
diff --git a/lib/wasix/src/runtime/mod.rs b/lib/wasix/src/runtime/mod.rs
index 85943ed657..7fd6616fe9 100644
--- a/lib/wasix/src/runtime/mod.rs
+++ b/lib/wasix/src/runtime/mod.rs
@@ -3,9 +3,11 @@ pub mod package_loader;
 pub mod resolver;
 pub mod task_manager;
 
-pub use self::task_manager::{SpawnMemoryType, VirtualTaskManager};
+pub use self::task_manager::{SpawnType, VirtualTaskManager};
 use self::{module_cache::CacheError, task_manager::InlineWaker};
-use wasmer_types::ModuleHash;
+use module_cache::HashedModuleData;
+use wasmer_config::package::SuggestedCompilerOptimizations;
+use wasmer_types::target::UserCompilerOptimizations as WasmerSuggestedCompilerOptimizations;
 
 use std::{
     fmt,
@@ -13,15 +15,15 @@ use std::{
     sync::{Arc, Mutex},
 };
 
-use derivative::Derivative;
 use futures::future::BoxFuture;
 use virtual_net::{DynVirtualNetworking, VirtualNetworking};
-use wasmer::{Module, RuntimeError};
+use wasmer::{CompileError, Engine, Module, RuntimeError};
 use wasmer_wasix_types::wasi::ExitCode;
 
 #[cfg(feature = "journal")]
-use crate::journal::DynJournal;
+use crate::journal::{DynJournal, DynReadableJournal};
 use crate::{
+    bin_factory::BinaryPackageCommand,
     http::{DynHttpClient, HttpClient},
     os::TtyBridge,
     runtime::{
@@ -37,6 +39,7 @@ pub enum TaintReason {
     UnknownWasiVersion,
     NonZeroExitCode(ExitCode),
     RuntimeError(RuntimeError),
+    DlSymbolResolutionFailed(String),
 }
 
 /// Runtime components used when running WebAssembly programs.
@@ -73,8 +76,19 @@ where
     fn source(&self) -> Arc<dyn Source + Send + Sync>;
 
     /// Get a [`wasmer::Engine`] for module compilation.
-    fn engine(&self) -> wasmer::Engine {
-        wasmer::Engine::default()
+    fn engine(&self) -> Engine {
+        Engine::default()
+    }
+
+    fn engine_with_suggested_opts(
+        &self,
+        suggested_opts: &SuggestedCompilerOptimizations,
+    ) -> Result<Engine, CompileError> {
+        let mut engine = self.engine();
+        engine.with_opts(&WasmerSuggestedCompilerOptimizations {
+            pass_params: suggested_opts.pass_params,
+        })?;
+        Ok(engine)
     }
 
     /// Create a new [`wasmer::Store`].
@@ -98,33 +112,104 @@ where
         None
     }
 
-    /// Load a a Webassembly module, trying to use a pre-compiled version if possible.
-    fn load_module<'a>(&'a self, wasm: &'a [u8]) -> BoxFuture<'a, Result<Module, SpawnError>> {
-        let engine = self.engine();
+    /// Load the module for a command.
+    ///
+    /// Will load the module from the cache if possible, otherwise will compile.
+    ///
+    /// NOTE: This always be preferred over [`Self::load_module`] to avoid
+    /// re-hashing the module!
+    fn load_command_module(
+        &self,
+        cmd: &BinaryPackageCommand,
+    ) -> BoxFuture<'_, Result<Module, SpawnError>> {
         let module_cache = self.module_cache();
-        let hash = ModuleHash::xxhash(wasm);
+        let data = HashedModuleData::from_command(cmd);
+
+        let engine = match self.engine_with_suggested_opts(&cmd.suggested_compiler_optimizations) {
+            Ok(engine) => engine,
+            Err(error) => {
+                return Box::pin(async move {
+                    Err(SpawnError::CompileError {
+                        module_hash: *data.hash(),
+                        error,
+                    })
+                })
+            }
+        };
 
-        let task = async move { load_module(&engine, &module_cache, wasm, hash).await };
+        let task = async move { load_module(&engine, &module_cache, &data).await };
 
         Box::pin(task)
     }
 
-    /// Load a a Webassembly module, trying to use a pre-compiled version if possible.
+    /// Sync version of [`Self::load_command_module`].
+    fn load_command_module_sync(&self, cmd: &BinaryPackageCommand) -> Result<Module, SpawnError> {
+        InlineWaker::block_on(self.load_command_module(cmd))
+    }
+
+    /// Load a WebAssembly module from raw bytes.
     ///
-    /// Non-async version of [`Self::load_module`].
+    /// Will load the module from the cache if possible, otherwise will compile.
+    #[deprecated(
+        since = "0.601.0",
+        note = "Use `load_command_module` or `load_hashed_module` instead - this method can have high overhead"
+    )]
+    fn load_module<'a>(&'a self, wasm: &'a [u8]) -> BoxFuture<'a, Result<Module, SpawnError>> {
+        let engine = self.engine();
+        let module_cache = self.module_cache();
+        let data = HashedModuleData::new(wasm.to_vec());
+        let task = async move { load_module(&engine, &module_cache, &data).await };
+        Box::pin(task)
+    }
+
+    /// Synchronous version of [`Self::load_module`].
+    #[deprecated(
+        since = "0.601.0",
+        note = "Use `load_command_module` or `load_hashed_module` instead - this method can have high overhead"
+    )]
     fn load_module_sync(&self, wasm: &[u8]) -> Result<Module, SpawnError> {
+        #[allow(deprecated)]
         InlineWaker::block_on(self.load_module(wasm))
     }
 
+    /// Load a WebAssembly module from pre-hashed data.
+    ///
+    /// Will load the module from the cache if possible, otherwise will compile.
+    fn load_hashed_module(
+        &self,
+        module: HashedModuleData,
+        engine: Option<&Engine>,
+    ) -> BoxFuture<'_, Result<Module, SpawnError>> {
+        let engine = engine.cloned().unwrap_or_else(|| self.engine());
+        let module_cache = self.module_cache();
+        let task = async move { load_module(&engine, &module_cache, &module).await };
+        Box::pin(task)
+    }
+
+    /// Synchronous version of [`Self::load_hashed_module`].
+    fn load_hashed_module_sync(
+        &self,
+        wasm: HashedModuleData,
+        engine: Option<&Engine>,
+    ) -> Result<Module, SpawnError> {
+        InlineWaker::block_on(self.load_hashed_module(wasm, engine))
+    }
+
     /// Callback thats invokes whenever the instance is tainted, tainting can occur
     /// for multiple reasons however the most common is a panic within the process
     fn on_taint(&self, _reason: TaintReason) {}
 
-    /// The list of journals which will be used to restore the state of the
+    /// The list of all read-only journals which will be used to restore the state of the
     /// runtime at a particular point in time
     #[cfg(feature = "journal")]
-    fn journals(&self) -> &'_ Vec<Arc<DynJournal>> {
-        &EMPTY_JOURNAL_LIST
+    fn read_only_journals<'a>(&'a self) -> Box<dyn Iterator<Item = Arc<DynReadableJournal>> + 'a> {
+        Box::new(std::iter::empty())
+    }
+
+    /// The list of writable journals which will be appended to
+    #[cfg(feature = "journal")]
+    fn writable_journals<'a>(&'a self) -> Box<dyn Iterator<Item = Arc<DynJournal>> + 'a> {
+        Box::new(std::iter::empty())
     }
 
     /// The snapshot capturer takes and restores snapshots of the WASM process at specific
@@ -137,20 +222,17 @@ where
 
 pub type DynRuntime = dyn Runtime + Send + Sync;
 
-#[cfg(feature = "journal")]
-static EMPTY_JOURNAL_LIST: Vec<Arc<DynJournal>> = Vec::new();
-
 /// Load a a Webassembly module, trying to use a pre-compiled version if possible.
 ///
 // This function exists to provide a reusable baseline implementation for
 // implementing [`Runtime::load_module`], so custom logic can be added on top.
 #[tracing::instrument(level = "debug", skip_all)]
 pub async fn load_module(
-    engine: &wasmer::Engine,
+    engine: &Engine,
     module_cache: &(dyn ModuleCache + Send + Sync),
-    wasm: &[u8],
-    wasm_hash: ModuleHash,
+    module: &HashedModuleData,
 ) -> Result<Module, crate::SpawnError> {
+    let wasm_hash = *module.hash();
     let result = module_cache.load(wasm_hash, engine).await;
 
     match result {
@@ -165,11 +247,13 @@ pub async fn load_module(
         }
     }
 
-    let module = Module::new(&engine, wasm).map_err(|err| crate::SpawnError::CompileError {
-        module_hash: wasm_hash,
-        error: err,
-    })?;
+    let module =
+        Module::new(&engine, module.wasm()).map_err(|err| crate::SpawnError::CompileError {
+            module_hash: wasm_hash,
+            error: err,
+        })?;
 
+    // TODO: pass a [`HashedModule`] struct that is safe by construction.
     if let Err(e) = module_cache.save(wasm_hash, engine, &module).await {
         tracing::warn!(
             %wasm_hash,
@@ -205,21 +289,20 @@ impl TtyBridge for DefaultTty {
     }
 }
 
-#[derive(Clone, Derivative)]
-#[derivative(Debug)]
+#[derive(Debug, Clone)]
 pub struct PluggableRuntime {
     pub rt: Arc<dyn VirtualTaskManager>,
     pub networking: DynVirtualNetworking,
     pub http_client: Option<DynHttpClient>,
     pub package_loader: Arc<dyn PackageLoader + Send + Sync>,
     pub source: Arc<dyn Source + Send + Sync>,
-    pub engine: Option<wasmer::Engine>,
+    pub engine: Engine,
     pub module_cache: Arc<dyn ModuleCache + Send + Sync>,
-    #[derivative(Debug = "ignore")]
     pub tty: Option<Arc<dyn TtyBridge + Send + Sync>>,
     #[cfg(feature = "journal")]
-    #[derivative(Debug = "ignore")]
-    pub journals: Vec<Arc<DynJournal>>,
+    pub read_only_journals: Vec<Arc<DynReadableJournal>>,
+    #[cfg(feature = "journal")]
+    pub writable_journals: Vec<Arc<DynJournal>>,
 }
 
 impl PluggableRuntime {
@@ -237,7 +320,7 @@ impl PluggableRuntime {
 
         let loader = UnsupportedPackageLoader;
 
-        let mut source = MultiSource::new();
+        let mut source = MultiSource::default();
         if let Some(client) = &http_client {
             source.add_source(BackendSource::new(
                 BackendSource::WASMER_PROD_ENDPOINT.parse().unwrap(),
@@ -249,13 +332,15 @@ impl PluggableRuntime {
             rt,
             networking,
             http_client,
-            engine: None,
+            engine: Default::default(),
             tty: None,
             source: Arc::new(source),
             package_loader: Arc::new(loader),
             module_cache: Arc::new(module_cache::in_memory()),
             #[cfg(feature = "journal")]
-            journals: Vec::new(),
+            read_only_journals: Vec::new(),
+            #[cfg(feature = "journal")]
+            writable_journals: Vec::new(),
         }
     }
 
@@ -267,7 +352,7 @@ impl PluggableRuntime {
         self
     }
 
-    pub fn set_engine(&mut self, engine: Option<wasmer::Engine>) -> &mut Self {
+    pub fn set_engine(&mut self, engine: Engine) -> &mut Self {
         self.engine = engine;
         self
     }
@@ -285,14 +370,14 @@ impl PluggableRuntime {
         self
     }
 
-    pub fn set_source(&mut self, source: impl Source + Send + Sync + 'static) -> &mut Self {
+    pub fn set_source(&mut self, source: impl Source + Send + 'static) -> &mut Self {
         self.source = Arc::new(source);
         self
     }
 
     pub fn set_package_loader(
         &mut self,
-        package_loader: impl PackageLoader + Send + Sync + 'static,
+        package_loader: impl PackageLoader + 'static,
     ) -> &mut Self {
         self.package_loader = Arc::new(package_loader);
         self
@@ -307,8 +392,14 @@ impl PluggableRuntime {
     }
 
     #[cfg(feature = "journal")]
-    pub fn add_journal(&mut self, journal: Arc<DynJournal>) -> &mut Self {
-        self.journals.push(journal);
+    pub fn add_read_only_journal(&mut self, journal: Arc<DynReadableJournal>) -> &mut Self {
+        self.read_only_journals.push(journal);
+        self
+    }
+
+    #[cfg(feature = "journal")]
+    pub fn add_writable_journal(&mut self, journal: Arc<DynJournal>) -> &mut Self {
+        self.writable_journals.push(journal);
         self
     }
 }
@@ -330,19 +421,12 @@ impl Runtime for PluggableRuntime {
         Arc::clone(&self.source)
     }
 
-    fn engine(&self) -> wasmer::Engine {
-        if let Some(engine) = self.engine.clone() {
-            engine
-        } else {
-            wasmer::Engine::default()
-        }
+    fn engine(&self) -> Engine {
+        self.engine.clone()
     }
 
     fn new_store(&self) -> wasmer::Store {
-        self.engine
-            .clone()
-            .map(wasmer::Store::new)
-            .unwrap_or_default()
+        wasmer::Store::new(self.engine.clone())
     }
 
     fn task_manager(&self) -> &Arc<dyn VirtualTaskManager> {
@@ -358,20 +442,24 @@ impl Runtime for PluggableRuntime {
     }
 
     #[cfg(feature = "journal")]
-    fn journals(&self) -> &'_ Vec<Arc<DynJournal>> {
-        &self.journals
+    fn read_only_journals<'a>(&'a self) -> Box<dyn Iterator<Item = Arc<DynReadableJournal>> + 'a> {
+        Box::new(self.read_only_journals.iter().cloned())
+    }
+
+    #[cfg(feature = "journal")]
+    fn writable_journals<'a>(&'a self) -> Box<dyn Iterator<Item = Arc<DynJournal>> + 'a> {
+        Box::new(self.writable_journals.iter().cloned())
     }
 
     #[cfg(feature = "journal")]
     fn active_journal(&self) -> Option<&DynJournal> {
-        self.journals.iter().last().map(|a| a.as_ref())
+        self.writable_journals.iter().last().map(|a| a.as_ref())
     }
 }
 
 /// Runtime that allows for certain things to be overridden
 /// such as the active journals
-#[derive(Clone, Derivative)]
-#[derivative(Debug)]
+#[derive(Clone, Debug)]
 pub struct OverriddenRuntime {
     inner: Arc<DynRuntime>,
     task_manager: Option<Arc<dyn VirtualTaskManager>>,
@@ -379,13 +467,13 @@ pub struct OverriddenRuntime {
     http_client: Option<DynHttpClient>,
     package_loader: Option<Arc<dyn PackageLoader + Send + Sync>>,
     source: Option<Arc<dyn Source + Send + Sync>>,
-    engine: Option<wasmer::Engine>,
+    engine: Option<Engine>,
     module_cache: Option<Arc<dyn ModuleCache + Send + Sync>>,
-    #[derivative(Debug = "ignore")]
     tty: Option<Arc<dyn TtyBridge + Send + Sync>>,
     #[cfg(feature = "journal")]
-    #[derivative(Debug = "ignore")]
-    journals: Option<Vec<Arc<DynJournal>>>,
+    pub read_only_journals: Option<Vec<Arc<DynReadableJournal>>>,
+    #[cfg(feature = "journal")]
+    pub writable_journals: Option<Vec<Arc<DynJournal>>>,
 }
 
 impl OverriddenRuntime {
@@ -401,7 +489,9 @@ impl OverriddenRuntime {
             module_cache: None,
             tty: None,
             #[cfg(feature = "journal")]
-            journals: None,
+            read_only_journals: None,
+            #[cfg(feature = "journal")]
+            writable_journals: None,
         }
     }
 
@@ -433,7 +523,7 @@ impl OverriddenRuntime {
         self
     }
 
-    pub fn with_engine(mut self, engine: wasmer::Engine) -> Self {
+    pub fn with_engine(mut self, engine: Engine) -> Self {
         self.engine.replace(engine);
         self
     }
@@ -443,15 +533,20 @@ impl OverriddenRuntime {
         self
     }
 
-    #[cfg(feature = "journal")]
     pub fn with_tty(mut self, tty: Arc<dyn TtyBridge + Send + Sync>) -> Self {
         self.tty.replace(tty);
         self
     }
 
     #[cfg(feature = "journal")]
-    pub fn with_journals(mut self, journals: Vec<Arc<DynJournal>>) -> Self {
-        self.journals.replace(journals);
+    pub fn with_read_only_journals(mut self, journals: Vec<Arc<DynReadableJournal>>) -> Self {
+        self.read_only_journals.replace(journals);
+        self
+    }
+
+    #[cfg(feature = "journal")]
+    pub fn with_writable_journals(mut self, journals: Vec<Arc<DynJournal>>) -> Self {
+        self.writable_journals.replace(journals);
         self
     }
 }
@@ -497,7 +592,7 @@ impl Runtime for OverriddenRuntime {
         }
     }
 
-    fn engine(&self) -> wasmer::Engine {
+    fn engine(&self) -> Engine {
         if let Some(engine) = self.engine.clone() {
             engine
         } else {
@@ -530,41 +625,78 @@ impl Runtime for OverriddenRuntime {
     }
 
     #[cfg(feature = "journal")]
-    fn journals(&self) -> &'_ Vec<Arc<DynJournal>> {
-        if let Some(journals) = self.journals.as_ref() {
-            journals
+    fn read_only_journals<'a>(&'a self) -> Box<dyn Iterator<Item = Arc<DynReadableJournal>> + 'a> {
+        if let Some(journals) = self.read_only_journals.as_ref() {
+            Box::new(journals.iter().cloned())
         } else {
-            self.inner.journals()
+            self.inner.read_only_journals()
+        }
+    }
+
+    #[cfg(feature = "journal")]
+    fn writable_journals<'a>(&'a self) -> Box<dyn Iterator<Item = Arc<DynJournal>> + 'a> {
+        if let Some(journals) = self.writable_journals.as_ref() {
+            Box::new(journals.iter().cloned())
+        } else {
+            self.inner.writable_journals()
         }
     }
 
     #[cfg(feature = "journal")]
     fn active_journal(&self) -> Option<&'_ DynJournal> {
-        if let Some(journals) = self.journals.as_ref() {
+        if let Some(journals) = self.writable_journals.as_ref() {
             journals.iter().last().map(|a| a.as_ref())
         } else {
             self.inner.active_journal()
         }
     }
 
-    fn load_module<'a>(&'a self, wasm: &'a [u8]) -> BoxFuture<'a, Result<Module, SpawnError>> {
-        if self.engine.is_some() || self.module_cache.is_some() {
-            let engine = self.engine();
-            let module_cache = self.module_cache();
-            let hash = ModuleHash::xxhash(wasm);
-
-            let task = async move { load_module(&engine, &module_cache, wasm, hash).await };
+    fn load_module<'a>(&'a self, data: &[u8]) -> BoxFuture<'a, Result<Module, SpawnError>> {
+        #[allow(deprecated)]
+        if let (Some(engine), Some(module_cache)) = (&self.engine, self.module_cache.clone()) {
+            let engine = engine.clone();
+            let hashed_data = HashedModuleData::new(data.to_vec());
+            let task = async move { load_module(&engine, &module_cache, &hashed_data).await };
             Box::pin(task)
         } else {
-            self.inner.load_module(wasm)
+            let data = data.to_vec();
+            Box::pin(async move { self.inner.load_module(&data).await })
         }
     }
 
     fn load_module_sync(&self, wasm: &[u8]) -> Result<Module, SpawnError> {
+        #[allow(deprecated)]
         if self.engine.is_some() || self.module_cache.is_some() {
             InlineWaker::block_on(self.load_module(wasm))
         } else {
             self.inner.load_module_sync(wasm)
         }
     }
+
+    fn load_hashed_module(
+        &self,
+        data: HashedModuleData,
+        engine: Option<&Engine>,
+    ) -> BoxFuture<'_, Result<Module, SpawnError>> {
+        if self.engine.is_some() || self.module_cache.is_some() {
+            let engine = self.engine();
+            let module_cache = self.module_cache();
+            let task = async move { load_module(&engine, &module_cache, &data).await };
+            Box::pin(task)
+        } else {
+            self.inner.load_hashed_module(data, engine)
+        }
+    }
+
+    fn load_hashed_module_sync(
+        &self,
+        wasm: HashedModuleData,
+        engine: Option<&Engine>,
+    ) -> Result<Module, SpawnError> {
+        if self.engine.is_some() || self.module_cache.is_some() {
+            InlineWaker::block_on(self.load_hashed_module(wasm, engine))
+        } else {
+            self.inner.load_hashed_module_sync(wasm, engine)
+        }
+    }
 }
diff --git a/lib/wasix/src/runtime/module_cache/fallback.rs b/lib/wasix/src/runtime/module_cache/fallback.rs
index 905643ce6c..3d02837b4e 100644
--- a/lib/wasix/src/runtime/module_cache/fallback.rs
+++ b/lib/wasix/src/runtime/module_cache/fallback.rs
@@ -85,6 +85,14 @@ where
         Err(primary_error)
     }
 
+    async fn contains(&self, key: ModuleHash, engine: &Engine) -> Result<bool, CacheError> {
+        if self.primary.contains(key, engine).await? {
+            return Ok(true);
+        }
+
+        self.fallback.contains(key, engine).await
+    }
+
     async fn save(
         &self,
         key: ModuleHash,
@@ -156,6 +164,10 @@ mod tests {
             }
         }
 
+        async fn contains(&self, key: ModuleHash, engine: &Engine) -> Result<bool, CacheError> {
+            self.inner.contains(key, engine).await
+        }
+
         async fn save(
             &self,
             key: ModuleHash,
diff --git a/lib/wasix/src/runtime/module_cache/filesystem.rs b/lib/wasix/src/runtime/module_cache/filesystem.rs
index 5528ff2261..a58403c13e 100644
--- a/lib/wasix/src/runtime/module_cache/filesystem.rs
+++ b/lib/wasix/src/runtime/module_cache/filesystem.rs
@@ -7,7 +7,6 @@ use wasmer::{Engine, Module};
 
 use crate::runtime::module_cache::{CacheError, ModuleCache, ModuleHash};
 use crate::runtime::task_manager::tokio::TokioTaskManager;
-use crate::runtime::task_manager::VirtualTaskManagerExt;
 
 /// A cache that saves modules to a folder on the host filesystem using
 /// [`Module::serialize()`].
@@ -38,54 +37,119 @@ impl FileSystemCache {
     }
 }
 
+/// Loads a module from the filesystem cache.
+///
+/// A tokio reactor must be available
+#[tracing::instrument(level = "debug", skip_all, fields(? path))]
+async fn tokio_load(path: PathBuf, engine: Engine) -> Result<Module, CacheError> {
+    let bytes = read_file(&path).await?;
+    let deserialized = tokio::task::spawn_blocking(move || deserialize(&bytes, &engine))
+        .await
+        .unwrap();
+    match deserialized {
+        Ok(m) => {
+            tracing::debug!("Cache hit!");
+            Ok(m)
+        }
+        Err(e) => {
+            tracing::debug!(
+                path=%path.display(),
+                error=&e as &dyn std::error::Error,
+                "Deleting the cache file because the artifact couldn't be deserialized",
+            );
+
+            if let Err(e) = std::fs::remove_file(&path) {
+                tracing::warn!(
+                    path=%path.display(),
+                    error=&e as &dyn std::error::Error,
+                    "Unable to remove the corrupted cache file",
+                );
+            }
+            Err(e)
+        }
+    }
+}
+
+/// Checks if the path exists in the filesystem cache.
+///
+/// A tokio reactor must be available
+async fn tokio_contains(path: PathBuf) -> Result<bool, CacheError> {
+    tokio::fs::try_exists(&path)
+        .await
+        .map_err(|e| CacheError::FileRead {
+            path: path.clone(),
+            error: e,
+        })
+}
+
+/// Saves the module to the filesystem cache.
+///
+/// A tokio reactor must be available
+#[tracing::instrument(level = "debug", skip_all, fields(? path))]
+async fn tokio_save(path: PathBuf, module: Module) -> Result<(), CacheError> {
+    let parent = path
+        .parent()
+        .expect("Unreachable - always created by joining onto cache_dir");
+
+    if let Err(e) = tokio::fs::create_dir_all(parent).await {
+        tracing::warn!(
+            dir=%parent.display(),
+            error=&e as &dyn std::error::Error,
+            "Unable to create the cache directory",
+        );
+    }
+
+    // TODO: NamedTempFile is blocking and we should use the appropriate tokio function instead.
+    // Note: We save to a temporary file and persist() it at the end so
+    // concurrent readers won't see a partially written module.
+    let (file, temp) = NamedTempFile::new_in(parent)
+        .map_err(CacheError::other)?
+        .into_parts();
+
+    let mut file = tokio::fs::File::from_std(file);
+
+    let serialized = tokio::task::spawn_blocking(move || module.serialize())
+        .await
+        .unwrap()?;
+
+    let mut writer = tokio::io::BufWriter::new(&mut file);
+    if let Err(error) = writer.write_all(&serialized).await {
+        return Err(CacheError::FileWrite { path, error });
+    }
+    if let Err(error) = writer.flush().await {
+        return Err(CacheError::FileWrite { path, error });
+    }
+
+    temp.persist(&path).map_err(CacheError::other)?;
+    tracing::debug!(path=%path.display(), "Saved to disk");
+
+    Ok(())
+}
+
 #[async_trait::async_trait]
 impl ModuleCache for FileSystemCache {
     #[tracing::instrument(level = "debug", skip_all, fields(% key))]
     async fn load(&self, key: ModuleHash, engine: &Engine) -> Result<Module, CacheError> {
-        let path = self.path(key, engine.deterministic_id());
+        let path = self.path(key, &engine.deterministic_id());
+        let engine = engine.clone();
+
+        // Use the bundled tokio runtime instead of the given async runtime
+        // This is necessary because this function can also be called with a futures_executor
+        self.task_manager
+            .runtime_handle()
+            .spawn(tokio_load(path, engine))
+            .await
+            .unwrap()
+    }
+
+    async fn contains(&self, key: ModuleHash, engine: &Engine) -> Result<bool, CacheError> {
+        let path = self.path(key, &engine.deterministic_id());
 
+        // Use the bundled tokio runtime instead of the given async runtime
+        // This is necessary because this function can also be called with a futures_executor
         self.task_manager
             .runtime_handle()
-            .spawn({
-                let task_manager = self.task_manager.clone();
-                let engine = engine.clone();
-
-                async move {
-                    let bytes = read_file(&path).await?;
-
-                    task_manager
-                    .spawn_await({
-
-                        move || match deserialize(&bytes, &engine) {
-                            Ok(m) => {
-                                tracing::debug!("Cache hit!");
-                                Ok(m)
-                            }
-                            Err(e) => {
-                                tracing::debug!(
-                                    %key,
-                                    path=%path.display(),
-                                    error=&e as &dyn std::error::Error,
-                                    "Deleting the cache file because the artifact couldn't be deserialized",
-                                );
-
-                                if let Err(e) = std::fs::remove_file(&path) {
-                                    tracing::warn!(
-                                        %key,
-                                        path=%path.display(),
-                                        error=&e as &dyn std::error::Error,
-                                        "Unable to remove the corrupted cache file",
-                                    );
-                                }
-
-                                Err(e)
-                            }
-                        }
-                    })
-                    .await
-                    .unwrap()
-                }
-            })
+            .spawn(tokio_contains(path))
             .await
             .unwrap()
     }
@@ -97,54 +161,14 @@ impl ModuleCache for FileSystemCache {
         engine: &Engine,
         module: &Module,
     ) -> Result<(), CacheError> {
-        let path = self.path(key, engine.deterministic_id());
+        let path = self.path(key, &engine.deterministic_id());
+        let module = module.clone();
 
+        // Use the bundled tokio runtime instead of the given async runtime
+        // This is necessary because this function can also be called with a futures_executor
         self.task_manager
             .runtime_handle()
-            .spawn({
-                let task_manager = self.task_manager.clone();
-                let module = module.clone();
-
-                async move {
-                    let parent = path
-                        .parent()
-                        .expect("Unreachable - always created by joining onto cache_dir");
-
-                    if let Err(e) = tokio::fs::create_dir_all(parent).await {
-                        tracing::warn!(
-                            dir=%parent.display(),
-                            error=&e as &dyn std::error::Error,
-                            "Unable to create the cache directory",
-                        );
-                    }
-
-                    // Note: We save to a temporary file and persist() it at the end so
-                    // concurrent readers won't see a partially written module.
-                    let (file, temp) = NamedTempFile::new_in(parent)
-                        .map_err(CacheError::other)?
-                        .into_parts();
-
-                    let mut file = tokio::fs::File::from_std(file);
-
-                    let serialized = task_manager
-                        .spawn_await(move || module.serialize())
-                        .await
-                        .unwrap()?;
-
-                    let mut writer = tokio::io::BufWriter::new(&mut file);
-                    if let Err(error) = writer.write_all(&serialized).await {
-                        return Err(CacheError::FileWrite { path, error });
-                    }
-                    if let Err(error) = writer.flush().await {
-                        return Err(CacheError::FileWrite { path, error });
-                    }
-
-                    temp.persist(&path).map_err(CacheError::other)?;
-                    tracing::debug!(path=%path.display(), "Saved to disk");
-
-                    Ok(())
-                }
-            })
+            .spawn(tokio_save(path, module))
             .await
             .unwrap()
     }
@@ -221,7 +245,7 @@ mod tests {
         let module = Module::new(&engine, ADD_WAT).unwrap();
         let cache = FileSystemCache::new(temp.path(), create_tokio_task_manager());
         let key = ModuleHash::xxhash_from_bytes([0; 8]);
-        let expected_path = cache.path(key, engine.deterministic_id());
+        let expected_path = cache.path(key, &engine.deterministic_id());
 
         cache.save(key, &engine, &module).await.unwrap();
 
@@ -262,7 +286,7 @@ mod tests {
         let module = Module::new(&engine, ADD_WAT).unwrap();
         let key = ModuleHash::xxhash_from_bytes([0; 8]);
         let cache = FileSystemCache::new(temp.path(), create_tokio_task_manager());
-        let expected_path = cache.path(key, engine.deterministic_id());
+        let expected_path = cache.path(key, &engine.deterministic_id());
         std::fs::create_dir_all(expected_path.parent().unwrap()).unwrap();
         let serialized = module.serialize().unwrap();
         std::fs::write(&expected_path, &serialized).unwrap();
@@ -285,7 +309,7 @@ mod tests {
         let module = Module::new(&engine, ADD_WAT).unwrap();
         let key = ModuleHash::xxhash_from_bytes([0; 8]);
         let cache = FileSystemCache::new(temp.path(), create_tokio_task_manager());
-        let expected_path = cache.path(key, engine.deterministic_id());
+        let expected_path = cache.path(key, &engine.deterministic_id());
         std::fs::create_dir_all(expected_path.parent().unwrap()).unwrap();
         let serialized = module.serialize().unwrap();
         let mut encoder = weezl::encode::Encoder::new(weezl::BitOrder::Msb, 8);
diff --git a/lib/wasix/src/runtime/module_cache/hashed_module.rs b/lib/wasix/src/runtime/module_cache/hashed_module.rs
new file mode 100644
index 0000000000..092899456a
--- /dev/null
+++ b/lib/wasix/src/runtime/module_cache/hashed_module.rs
@@ -0,0 +1,64 @@
+use shared_buffer::OwnedBuffer;
+use wasmer_types::ModuleHash;
+
+use crate::bin_factory::BinaryPackageCommand;
+
+/// A wrapper around Webassembly code and its hash.
+///
+/// Allows passing around WASM code and it's hash without the danger of
+/// using a wrong hash.
+///
+/// Safe by construction: can only be created from a [`BinaryCommand`], which
+/// already has the hash embedded, or from bytes that will be hashed in the
+/// constructor.
+///
+/// Can be cloned cheaply.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct HashedModuleData {
+    hash: ModuleHash,
+    wasm: OwnedBuffer,
+}
+
+impl HashedModuleData {
+    pub fn new(bytes: impl Into<OwnedBuffer>) -> Self {
+        Self::new_sha256(bytes)
+    }
+
+    pub fn new_sha256(bytes: impl Into<OwnedBuffer>) -> Self {
+        let wasm = bytes.into();
+        let hash = ModuleHash::sha256(&wasm);
+        Self { hash, wasm }
+    }
+
+    /// Create new [`HashedModuleData`] from the given bytes, hashing the
+    /// the bytes into a [`ModuleHash`] with xxhash.
+    pub fn new_xxhash(bytes: impl Into<OwnedBuffer>) -> Self {
+        let wasm = bytes.into();
+        let hash = ModuleHash::xxhash(&wasm);
+        Self { hash, wasm }
+    }
+
+    /// Create new [`HashedModuleData`] from the given [`BinaryPackageCommand`].
+    ///
+    /// This is very cheap, as the hash is already available in the command.
+    pub fn from_command(command: &BinaryPackageCommand) -> Self {
+        Self {
+            hash: *command.hash(),
+            wasm: command.atom(),
+        }
+    }
+
+    /// Get the module hash.
+    pub fn hash(&self) -> &ModuleHash {
+        &self.hash
+    }
+
+    /// Get the WASM code.
+    pub fn wasm(&self) -> &OwnedBuffer {
+        &self.wasm
+    }
+
+    pub fn into_parts(self) -> (ModuleHash, OwnedBuffer) {
+        (self.hash, self.wasm)
+    }
+}
diff --git a/lib/wasix/src/runtime/module_cache/mod.rs b/lib/wasix/src/runtime/module_cache/mod.rs
index d786be8c40..ba1d5242fb 100644
--- a/lib/wasix/src/runtime/module_cache/mod.rs
+++ b/lib/wasix/src/runtime/module_cache/mod.rs
@@ -31,6 +31,8 @@
 //! caching strategies. For example, you could use the [`FallbackCache`] to
 //! chain a fast in-memory cache with a slower file-based cache as a fallback.
 
+mod hashed_module;
+
 mod fallback;
 #[cfg(feature = "sys-thread")]
 mod filesystem;
@@ -40,6 +42,7 @@ mod types;
 
 pub use self::{
     fallback::FallbackCache,
+    hashed_module::HashedModuleData,
     shared::SharedCache,
     thread_local::ThreadLocalCache,
     types::{CacheError, ModuleCache},
diff --git a/lib/wasix/src/runtime/module_cache/shared.rs b/lib/wasix/src/runtime/module_cache/shared.rs
index 305e80ff65..214c158f73 100644
--- a/lib/wasix/src/runtime/module_cache/shared.rs
+++ b/lib/wasix/src/runtime/module_cache/shared.rs
@@ -20,7 +20,7 @@ impl SharedCache {
 impl ModuleCache for SharedCache {
     #[tracing::instrument(level = "debug", skip_all, fields(%key))]
     async fn load(&self, key: ModuleHash, engine: &Engine) -> Result<Module, CacheError> {
-        let key = (key, engine.deterministic_id().to_string());
+        let key = (key, engine.deterministic_id());
 
         match self.modules.get(&key) {
             Some(m) => {
@@ -32,6 +32,11 @@ impl ModuleCache for SharedCache {
         }
     }
 
+    async fn contains(&self, key: ModuleHash, engine: &Engine) -> Result<bool, CacheError> {
+        let key = (key, engine.deterministic_id().to_string());
+        Ok(self.modules.contains_key(&key))
+    }
+
     #[tracing::instrument(level = "debug", skip_all, fields(%key))]
     async fn save(
         &self,
diff --git a/lib/wasix/src/runtime/module_cache/thread_local.rs b/lib/wasix/src/runtime/module_cache/thread_local.rs
index c23744ae19..30ba38e6ac 100644
--- a/lib/wasix/src/runtime/module_cache/thread_local.rs
+++ b/lib/wasix/src/runtime/module_cache/thread_local.rs
@@ -31,7 +31,7 @@ impl ThreadLocalCache {
 impl ModuleCache for ThreadLocalCache {
     #[tracing::instrument(level = "debug", skip_all, fields(%key))]
     async fn load(&self, key: ModuleHash, engine: &Engine) -> Result<Module, CacheError> {
-        match self.lookup(key, engine.deterministic_id()) {
+        match self.lookup(key, &engine.deterministic_id()) {
             Some(m) => {
                 tracing::debug!("Cache hit!");
                 Ok(m)
@@ -40,6 +40,11 @@ impl ModuleCache for ThreadLocalCache {
         }
     }
 
+    async fn contains(&self, key: ModuleHash, engine: &Engine) -> Result<bool, CacheError> {
+        let exists = self.lookup(key, &engine.deterministic_id()).is_some();
+        Ok(exists)
+    }
+
     #[tracing::instrument(level = "debug", skip_all, fields(%key))]
     async fn save(
         &self,
@@ -47,7 +52,7 @@ impl ModuleCache for ThreadLocalCache {
         engine: &Engine,
         module: &Module,
     ) -> Result<(), CacheError> {
-        self.insert(key, module, engine.deterministic_id());
+        self.insert(key, module, &engine.deterministic_id());
         Ok(())
     }
 }
diff --git a/lib/wasix/src/runtime/module_cache/types.rs b/lib/wasix/src/runtime/module_cache/types.rs
index 79494f0e3b..2cb1bc96cd 100644
--- a/lib/wasix/src/runtime/module_cache/types.rs
+++ b/lib/wasix/src/runtime/module_cache/types.rs
@@ -26,6 +26,9 @@ pub trait ModuleCache: Debug {
     /// Load a module based on its hash.
     async fn load(&self, key: ModuleHash, engine: &Engine) -> Result<Module, CacheError>;
 
+    /// Check if a module is present in the cache.
+    async fn contains(&self, key: ModuleHash, engine: &Engine) -> Result<bool, CacheError>;
+
     /// Save a module so it can be retrieved with [`ModuleCache::load()`] at a
     /// later time.
     ///
@@ -79,6 +82,10 @@ where
         (**self).load(key, engine).await
     }
 
+    async fn contains(&self, key: ModuleHash, engine: &Engine) -> Result<bool, CacheError> {
+        (**self).contains(key, engine).await
+    }
+
     async fn save(
         &self,
         key: ModuleHash,
diff --git a/lib/wasix/src/runtime/package_loader/builtin_loader.rs b/lib/wasix/src/runtime/package_loader/builtin_loader.rs
index be4ed7de8e..c5e0931b89 100644
--- a/lib/wasix/src/runtime/package_loader/builtin_loader.rs
+++ b/lib/wasix/src/runtime/package_loader/builtin_loader.rs
@@ -11,10 +11,12 @@ use bytes::Bytes;
 use http::{HeaderMap, Method};
 use tempfile::NamedTempFile;
 use url::Url;
-use webc::{
-    compat::{Container, ContainerError},
-    DetectError,
+use wasmer_package::{
+    package::WasmerPackageError,
+    utils::{from_bytes, from_disk},
 };
+use webc::DetectError;
+use webc::{Container, ContainerError};
 
 use crate::{
     bin_factory::BinaryPackage,
@@ -78,6 +80,10 @@ impl BuiltinPackageLoader {
         }
     }
 
+    pub fn cache(&self) -> Option<&FileSystemCache> {
+        self.cache.as_ref()
+    }
+
     pub fn validate_cache(
         &self,
         mode: CacheValidationMode,
@@ -369,7 +375,7 @@ impl PackageLoader for BuiltinPackageLoader {
 
         // The sad path - looks like we don't have a filesystem cache so we'll
         // need to keep the whole thing in memory.
-        let container = crate::spawn_blocking(move || Container::from_bytes(bytes)).await??;
+        let container = crate::spawn_blocking(move || from_bytes(bytes)).await??;
         // We still want to cache it in memory, of course
         self.in_memory.save(&container, summary.dist.webc_sha256);
         Ok(container)
@@ -417,13 +423,17 @@ pub enum CacheValidationMode {
 // FIXME: This implementation will block the async runtime and should use
 // some sort of spawn_blocking() call to run it in the background.
 #[derive(Debug)]
-struct FileSystemCache {
+pub struct FileSystemCache {
     cache_dir: PathBuf,
 }
 
 impl FileSystemCache {
     const FILE_SUFFIX: &'static str = ".bin";
 
+    fn temp_dir(&self) -> PathBuf {
+        self.cache_dir.join("__temp__")
+    }
+
     /// Validate that the cached image file names correspond to their actual
     /// file content hashes.
     fn validate_hashes(&self) -> Result<Vec<(PathBuf, ImageHashMismatchError)>, anyhow::Error> {
@@ -487,18 +497,16 @@ impl FileSystemCache {
 
         let container = crate::spawn_blocking({
             let path = path.clone();
-            move || Container::from_disk(path)
+            move || from_disk(path)
         })
         .await?;
         match container {
             Ok(c) => Ok(Some(c)),
-            Err(ContainerError::Open { error, .. })
-            | Err(ContainerError::Read { error, .. })
-            | Err(ContainerError::Detect(DetectError::Io(error)))
-                if error.kind() == ErrorKind::NotFound =>
-            {
-                Ok(None)
-            }
+            Err(WasmerPackageError::ContainerError(ContainerError::Open { error, .. }))
+            | Err(WasmerPackageError::ContainerError(ContainerError::Read { error, .. }))
+            | Err(WasmerPackageError::ContainerError(ContainerError::Detect(DetectError::Io(
+                error,
+            )))) if error.kind() == ErrorKind::NotFound => Ok(None),
             Err(e) => {
                 let msg = format!("Unable to read \"{}\"", path.display());
                 Err(Error::new(e).context(msg))
@@ -506,20 +514,25 @@ impl FileSystemCache {
         }
     }
 
-    async fn save(&self, webc: Bytes, dist: &DistributionInfo) -> Result<(), Error> {
+    async fn save(&self, webc: Bytes, dist: &DistributionInfo) -> Result<PathBuf, Error> {
         let path = self.path(&dist.webc_sha256);
         let dist = dist.clone();
+        let temp_dir = self.temp_dir();
 
+        let path2 = path.clone();
         crate::spawn_blocking(move || {
-            let parent = path.parent().expect("Always within cache_dir");
+            // Keep files in a temporary directory until they are fully written
+            // to prevent temp files being included in [`Self::scan`] or `[Self::retain]`.
 
-            std::fs::create_dir_all(parent)
-                .with_context(|| format!("Unable to create \"{}\"", parent.display()))?;
+            std::fs::create_dir_all(&temp_dir)
+                .with_context(|| format!("Unable to create directory '{}'", temp_dir.display()))?;
 
-            let mut temp = NamedTempFile::new_in(parent)?;
+            let mut temp = NamedTempFile::new_in(&temp_dir)?;
             temp.write_all(&webc)?;
             temp.flush()?;
             temp.as_file_mut().sync_all()?;
+
+            // Move the temporary file to the final location.
             temp.persist(&path)?;
 
             tracing::debug!(
@@ -533,7 +546,7 @@ impl FileSystemCache {
         })
         .await??;
 
-        Ok(())
+        Ok(path2)
     }
 
     #[tracing::instrument(level = "debug", skip_all)]
@@ -568,6 +581,97 @@ impl FileSystemCache {
 
         self.cache_dir.join(filename)
     }
+
+    /// Scan all the cached webc files and invoke the callback for each.
+    pub async fn scan<S, F>(&self, state: S, callback: F) -> Result<S, Error>
+    where
+        S: Send + 'static,
+        F: Fn(&mut S, &std::fs::DirEntry) -> Result<(), Error> + Send + 'static,
+    {
+        let cache_dir = self.cache_dir.clone();
+        tokio::task::spawn_blocking(move || -> Result<S, anyhow::Error> {
+            let mut state = state;
+
+            let iter = match std::fs::read_dir(&cache_dir) {
+                Ok(v) => v,
+                Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
+                    // path does not exist, so nothing to scan.
+                    return Ok(state);
+                }
+                Err(err) => {
+                    return Err(err).with_context(|| {
+                        format!("Could not read image cache dir: '{}'", cache_dir.display())
+                    });
+                }
+            };
+
+            for res in iter {
+                let entry = res?;
+                if !entry.file_type()?.is_file() {
+                    continue;
+                }
+
+                callback(&mut state, &entry)?;
+            }
+
+            Ok(state)
+        })
+        .await?
+        .context("tokio runtime failed")
+    }
+
+    /// Remove entries from the cache that do not pass the callback.
+    pub async fn retain<S, F>(&self, state: S, filter: F) -> Result<S, Error>
+    where
+        S: Send + 'static,
+        F: Fn(&mut S, &std::fs::DirEntry) -> Result<bool, anyhow::Error> + Send + 'static,
+    {
+        let cache_dir = self.cache_dir.clone();
+        tokio::task::spawn_blocking(move || {
+            let iter = match std::fs::read_dir(&cache_dir) {
+                Ok(v) => v,
+                Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
+                    // path does not exist, so nothing to scan.
+                    return Ok(state);
+                }
+                Err(err) => {
+                    return Err(err).with_context(|| {
+                        format!("Could not read image cache dir: '{}'", cache_dir.display())
+                    });
+                }
+            };
+
+            let mut state = state;
+            for res in iter {
+                let entry = res?;
+                if !entry.file_type()?.is_file() {
+                    continue;
+                }
+
+                if !filter(&mut state, &entry)? {
+                    tracing::debug!(
+                        path=%entry.path().display(),
+                        "Removing cached image file - does not pass the filter",
+                    );
+                    match std::fs::remove_file(entry.path()) {
+                        Ok(()) => {}
+                        Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
+                        Err(fs_err) => {
+                            tracing::warn!(
+                                path=%entry.path().display(),
+                                ?fs_err,
+                                "Could not delete cached image file",
+                            );
+                        }
+                    }
+                }
+            }
+
+            Ok(state)
+        })
+        .await?
+        .context("tokio runtime failed")
+    }
 }
 
 #[derive(Debug, Default)]
@@ -704,7 +808,7 @@ mod test {
         let path = dir.path();
 
         let contents = "fail";
-        let correct_hash = WebcHash::sha256(&contents);
+        let correct_hash = WebcHash::sha256(contents);
         let used_hash =
             WebcHash::parse_hex("0000a28ea38a000f3a3328cb7fabe330638d3258affe1a869e3f92986222d997")
                 .unwrap();
@@ -723,4 +827,90 @@ mod test {
 
         assert_eq!(file_path.exists(), false);
     }
+
+    #[tokio::test]
+    async fn test_file_cache_scan_retain() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path();
+
+        let cache = FileSystemCache {
+            cache_dir: path.to_path_buf(),
+        };
+
+        {
+            let state = cache
+                .scan(0u64, |state: &mut u64, _entry| {
+                    *state += 1;
+                    Ok(())
+                })
+                .await
+                .unwrap();
+
+            assert_eq!(state, 0);
+        }
+
+        let path1 = cache
+            .save(
+                Bytes::from_static(b"test1"),
+                &DistributionInfo {
+                    webc: Url::parse("file:///test1.webc").unwrap(),
+                    webc_sha256: WebcHash::sha256(b"test1"),
+                },
+            )
+            .await
+            .unwrap();
+        let path2 = cache
+            .save(
+                Bytes::from_static(b"test2"),
+                &DistributionInfo {
+                    webc: Url::parse("file:///test2.webc").unwrap(),
+                    webc_sha256: WebcHash::sha256(b"test2"),
+                },
+            )
+            .await
+            .unwrap();
+
+        {
+            let path1 = path1.clone();
+            let path2 = path2.clone();
+            let state = cache
+                .scan(0u64, move |state: &mut u64, entry| {
+                    *state += 1;
+                    assert!(entry.path() == path1 || entry.path() == path2);
+                    Ok(())
+                })
+                .await
+                .unwrap();
+
+            assert_eq!(state, 2);
+        }
+
+        {
+            let path1 = path1.clone();
+            let state = cache
+                .retain(0u64, move |state: &mut u64, entry| {
+                    *state += 1;
+                    Ok(entry.path() == path1)
+                })
+                .await
+                .unwrap();
+            assert_eq!(state, 2);
+        }
+
+        assert!(path1.exists());
+        assert!(!path2.exists(), "Path 2 should have been deleted");
+
+        {
+            let path1 = path1.clone();
+            let state = cache
+                .scan(0u64, move |state: &mut u64, entry| {
+                    *state += 1;
+                    assert!(entry.path() == path1);
+                    Ok(())
+                })
+                .await
+                .unwrap();
+            assert_eq!(state, 1);
+        }
+    }
 }
diff --git a/lib/wasix/src/runtime/package_loader/load_package_tree.rs b/lib/wasix/src/runtime/package_loader/load_package_tree.rs
index 2f46600050..743fb8ac39 100644
--- a/lib/wasix/src/runtime/package_loader/load_package_tree.rs
+++ b/lib/wasix/src/runtime/package_loader/load_package_tree.rs
@@ -10,11 +10,10 @@ use futures::{future::BoxFuture, StreamExt, TryStreamExt};
 use once_cell::sync::OnceCell;
 use petgraph::visit::EdgeRef;
 use virtual_fs::{FileSystem, OverlayFileSystem, UnionFileSystem, WebcVolumeFileSystem};
-use wasmer_config::package::PackageId;
-use webc::{
-    compat::{Container, Volume},
-    metadata::annotations::Atom as AtomAnnotation,
-};
+use wasmer_config::package::{PackageId, SuggestedCompilerOptimizations};
+use wasmer_package::utils::wasm_annotations_to_features;
+use webc::metadata::annotations::Atom as AtomAnnotation;
+use webc::{Container, Volume};
 
 use crate::{
     bin_factory::{BinaryPackage, BinaryPackageCommand},
@@ -29,6 +28,26 @@ use crate::{
 
 use super::to_module_hash;
 
+/// Convert WebAssembly feature annotations to a Features object
+fn wasm_annotation_to_features(
+    wasm_annotation: &webc::metadata::annotations::Wasm,
+) -> Option<wasmer_types::Features> {
+    Some(wasm_annotations_to_features(&wasm_annotation.features))
+}
+
+/// Extract WebAssembly features from atom metadata if available
+fn extract_features_from_atom_metadata(
+    atom_metadata: &webc::metadata::Atom,
+) -> Option<wasmer_types::Features> {
+    if let Ok(Some(wasm_annotation)) = atom_metadata
+        .annotation::<webc::metadata::annotations::Wasm>(webc::metadata::annotations::Wasm::KEY)
+    {
+        wasm_annotation_to_features(&wasm_annotation)
+    } else {
+        None
+    }
+}
+
 /// The maximum number of packages that will be loaded in parallel.
 const MAX_PARALLEL_DOWNLOADS: usize = 32;
 
@@ -182,16 +201,59 @@ fn load_binary_command(
         )
     })?;
 
-    let cmd = BinaryPackageCommand::new(command_name.to_string(), cmd.clone(), atom, hash);
+    // Get WebAssembly features from manifest atom annotations
+    let features = if let Some(atom_metadata) = webc.manifest().atoms.get(&atom_name) {
+        extract_features_from_atom_metadata(atom_metadata)
+    } else {
+        None
+    };
+
+    let suggested_compiler_optimizations =
+        if let Some(atom_metadata) = webc.manifest().atoms.get(&atom_name) {
+            extract_suggested_compiler_opts_from_atom_metadata(atom_metadata)
+        } else {
+            wasmer_config::package::SuggestedCompilerOptimizations::default()
+        };
+
+    let cmd = BinaryPackageCommand::new(
+        command_name.to_string(),
+        cmd.clone(),
+        atom,
+        hash,
+        features,
+        suggested_compiler_optimizations,
+    );
 
     Ok(Some(cmd))
 }
 
+fn extract_suggested_compiler_opts_from_atom_metadata(
+    atom_metadata: &webc::metadata::Atom,
+) -> wasmer_config::package::SuggestedCompilerOptimizations {
+    let mut ret = SuggestedCompilerOptimizations::default();
+
+    if let Some(sco) = atom_metadata
+        .annotations
+        .get(SuggestedCompilerOptimizations::KEY)
+    {
+        if let Some((_, v)) = sco.as_map().and_then(|v| {
+            v.iter().find(|(k, _)| {
+                k.as_text()
+                    .is_some_and(|v| v == SuggestedCompilerOptimizations::PASS_PARAMS_KEY)
+            })
+        }) {
+            ret.pass_params = v.as_bool()
+        }
+    }
+
+    ret
+}
+
 fn atom_name_for_command(
     command_name: &str,
     cmd: &webc::metadata::Command,
 ) -> Result<Option<AtomAnnotation>, anyhow::Error> {
-    use webc::metadata::annotations::{EMSCRIPTEN_RUNNER_URI, WASI_RUNNER_URI, WCGI_RUNNER_URI};
+    use webc::metadata::annotations::{WASI_RUNNER_URI, WCGI_RUNNER_URI};
 
     if let Some(atom) = cmd
         .atom()
@@ -200,7 +262,7 @@ fn atom_name_for_command(
         return Ok(Some(atom));
     }
 
-    if [WASI_RUNNER_URI, WCGI_RUNNER_URI, EMSCRIPTEN_RUNNER_URI]
+    if [WASI_RUNNER_URI, WCGI_RUNNER_URI]
         .iter()
         .any(|uri| cmd.runner.starts_with(uri))
     {
@@ -247,11 +309,28 @@ fn legacy_atom_hack(
 
     let hash = to_module_hash(webc.manifest().atom_signature(&name)?);
 
+    // Get WebAssembly features from manifest atom annotations
+    let features = if let Some(atom_metadata) = webc.manifest().atoms.get(&name) {
+        extract_features_from_atom_metadata(atom_metadata)
+    } else {
+        None
+    };
+
+    // Get WebAssembly features from manifest atom annotations
+    let suggested_opts_from_manifest = if let Some(atom_metadata) = webc.manifest().atoms.get(&name)
+    {
+        extract_suggested_compiler_opts_from_atom_metadata(atom_metadata)
+    } else {
+        SuggestedCompilerOptimizations::default()
+    };
+
     Ok(Some(BinaryPackageCommand::new(
         command_name.to_string(),
         metadata.clone(),
         atom,
         hash,
+        features,
+        suggested_opts_from_manifest,
     )))
 }
 
@@ -334,8 +413,8 @@ fn filesystem(
         )));
     }
 
-    let mut found_v2 = false;
-    let mut found_v3 = false;
+    let mut found_v2 = None;
+    let mut found_v3 = None;
 
     for ResolvedFileSystemMapping { package, .. } in &pkg.filesystem {
         let container = packages.get(package).with_context(|| {
@@ -345,14 +424,23 @@ fn filesystem(
             )
         })?;
 
-        found_v2 |= container.version() == webc::Version::V2;
-        found_v3 |= container.version() == webc::Version::V3;
+        if container.version() == webc::Version::V2 && found_v2.is_none() {
+            found_v2 = Some(package.clone());
+        }
+        if container.version() == webc::Version::V3 && found_v3.is_none() {
+            found_v3 = Some(package.clone());
+        }
     }
 
-    if found_v3 && !found_v2 {
-        filesystem_v3(packages, pkg, root_is_local_dir)
-    } else {
-        filesystem_v2(packages, pkg, root_is_local_dir)
+    match (found_v2, found_v3) {
+        (None, Some(_)) => filesystem_v3(packages, pkg, root_is_local_dir),
+        (Some(_), None) => filesystem_v2(packages, pkg, root_is_local_dir),
+        (Some(v2), Some(v3)) => {
+            anyhow::bail!(
+                "Mix of webc v2 and v3 in the same dependency tree is not supported; v2: {v2}, v3: {v3}"
+            )
+        }
+        (None, None) => anyhow::bail!("Internal error: no packages found in tree"),
     }
 }
 
diff --git a/lib/wasix/src/runtime/package_loader/types.rs b/lib/wasix/src/runtime/package_loader/types.rs
index 3eeb1cbf70..9488f62b0a 100644
--- a/lib/wasix/src/runtime/package_loader/types.rs
+++ b/lib/wasix/src/runtime/package_loader/types.rs
@@ -1,7 +1,7 @@
 use std::{fmt::Debug, ops::Deref};
 
 use anyhow::Error;
-use webc::compat::Container;
+use webc::Container;
 
 use crate::{
     bin_factory::BinaryPackage,
diff --git a/lib/wasix/src/runtime/package_loader/unsupported.rs b/lib/wasix/src/runtime/package_loader/unsupported.rs
index c0c245ff21..a16477ddab 100644
--- a/lib/wasix/src/runtime/package_loader/unsupported.rs
+++ b/lib/wasix/src/runtime/package_loader/unsupported.rs
@@ -1,5 +1,5 @@
 use anyhow::Error;
-use webc::compat::Container;
+use webc::Container;
 
 use crate::{
     bin_factory::BinaryPackage,
diff --git a/lib/wasix/src/runtime/resolver/backend_source.rs b/lib/wasix/src/runtime/resolver/backend_source.rs
index 00fd3491b5..89e4a2016a 100644
--- a/lib/wasix/src/runtime/resolver/backend_source.rs
+++ b/lib/wasix/src/runtime/resolver/backend_source.rs
@@ -217,7 +217,7 @@ impl BackendSource {
     async fn query_by_hash(
         &self,
         hash: &PackageHash,
-    ) -> Result<Option<PackageSummary>, QueryError> {
+    ) -> Result<Option<PackageSummary>, anyhow::Error> {
         // FIXME: implementing caching!
 
         let Some(data) = self.query_graphql_by_hash(hash).await? else {
@@ -241,22 +241,31 @@ impl Source for BackendSource {
             ),
             PackageSource::Ident(PackageIdent::Hash(hash)) => {
                 // TODO: implement caching!
-                match self.query_by_hash(hash).await? {
-                    Some(summary) => return Ok(vec![summary]),
-                    None => {
+                match self.query_by_hash(hash).await {
+                    Ok(Some(summary)) => return Ok(vec![summary]),
+                    Ok(None) => {
                         return Err(QueryError::NoMatches {
+                            query: package.clone(),
                             archived_versions: Vec::new(),
                         });
                     }
+                    Err(error) => {
+                        return Err(QueryError::new_other(error, package));
+                    }
                 }
             }
-            _ => return Err(QueryError::Unsupported),
+            _ => {
+                return Err(QueryError::Unsupported {
+                    query: package.clone(),
+                })
+            }
         };
 
         if let Some(cache) = &self.cache {
             match cache.lookup_cached_query(&package_name) {
                 Ok(Some(cached)) => {
                     if let Ok(cached) = matching_package_summaries(
+                        package,
                         cached,
                         &version_constraint,
                         self.preferred_webc_version,
@@ -276,7 +285,10 @@ impl Source for BackendSource {
             }
         }
 
-        let response = self.query_graphql_named(&package_name).await?;
+        let response = self
+            .query_graphql_named(&package_name)
+            .await
+            .map_err(|error| QueryError::new_other(error, package))?;
 
         if let Some(cache) = &self.cache {
             if let Err(e) = cache.update(&package_name, &response) {
@@ -288,11 +300,18 @@ impl Source for BackendSource {
             }
         }
 
-        matching_package_summaries(response, &version_constraint, self.preferred_webc_version)
+        matching_package_summaries(
+            package,
+            response,
+            &version_constraint,
+            self.preferred_webc_version,
+        )
     }
 }
 
+#[allow(clippy::result_large_err)]
 fn matching_package_summaries(
+    query: &PackageSource,
     response: WebQuery,
     version_constraint: &VersionReq,
     preferred_webc_version: webc::Version,
@@ -304,7 +323,12 @@ fn matching_package_summaries(
         package_name,
         versions,
         ..
-    } = response.data.get_package.ok_or(QueryError::NotFound)?;
+    } = response
+        .data
+        .get_package
+        .ok_or_else(|| QueryError::NotFound {
+            query: query.clone(),
+        })?;
     let mut archived_versions = Vec::new();
 
     for pkg_version in versions {
@@ -349,7 +373,10 @@ fn matching_package_summaries(
     }
 
     if summaries.is_empty() {
-        Err(QueryError::NoMatches { archived_versions })
+        Err(QueryError::NoMatches {
+            query: query.clone(),
+            archived_versions,
+        })
     } else {
         Ok(summaries)
     }
@@ -395,7 +422,7 @@ fn decode_summary(
         };
 
     let id = PackageId::Named(NamedPackageId {
-        full_name: format!("{}/{}", namespace, package_name),
+        full_name: format!("{namespace}/{package_name}"),
         version: pkg_version
             .version
             .parse()
diff --git a/lib/wasix/src/runtime/resolver/filesystem_source.rs b/lib/wasix/src/runtime/resolver/filesystem_source.rs
index 471fa18b9b..0b977e37e6 100644
--- a/lib/wasix/src/runtime/resolver/filesystem_source.rs
+++ b/lib/wasix/src/runtime/resolver/filesystem_source.rs
@@ -1,6 +1,6 @@
 use anyhow::Context;
 use wasmer_config::package::{PackageHash, PackageId, PackageSource};
-use webc::compat::Container;
+use wasmer_package::utils::from_disk;
 
 use crate::runtime::resolver::{
     DistributionInfo, PackageInfo, PackageSummary, QueryError, Source, WebcHash,
@@ -10,29 +10,14 @@ use crate::runtime::resolver::{
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub struct FileSystemSource {}
 
-#[async_trait::async_trait]
-impl Source for FileSystemSource {
-    #[tracing::instrument(level = "debug", skip_all, fields(%package))]
-    async fn query(&self, package: &PackageSource) -> Result<Vec<PackageSummary>, QueryError> {
-        let path = match package {
-            PackageSource::Path(path) => {
-                let path = std::path::PathBuf::from(path);
-                path.canonicalize().with_context(|| {
-                    format!(
-                        "Unable to get the canonical form for \"{}\"",
-                        path.display()
-                    )
-                })?
-            }
-            _ => return Err(QueryError::Unsupported),
-        };
-
-        let webc_sha256 = crate::block_in_place(|| WebcHash::for_file(&path))
+impl FileSystemSource {
+    async fn load_path(path: &std::path::Path) -> Result<Vec<PackageSummary>, anyhow::Error> {
+        let webc_sha256 = crate::block_in_place(|| WebcHash::for_file(path))
             .with_context(|| format!("Unable to hash \"{}\"", path.display()))?;
-        let container = crate::block_in_place(|| Container::from_disk(&path))
+        let container = crate::block_in_place(|| from_disk(path))
             .with_context(|| format!("Unable to parse \"{}\"", path.display()))?;
 
-        let url = crate::runtime::resolver::utils::url_from_file_path(&path)
+        let url = crate::runtime::resolver::utils::url_from_file_path(path)
             .ok_or_else(|| anyhow::anyhow!("Unable to turn \"{}\" into a URL", path.display()))?;
 
         let id = PackageInfo::package_id_from_manifest(container.manifest())
@@ -52,3 +37,32 @@ impl Source for FileSystemSource {
         Ok(vec![summary])
     }
 }
+
+#[async_trait::async_trait]
+impl Source for FileSystemSource {
+    #[tracing::instrument(level = "debug", skip_all, fields(%package))]
+    async fn query(&self, package: &PackageSource) -> Result<Vec<PackageSummary>, QueryError> {
+        let path = match package {
+            PackageSource::Path(path) => {
+                let path = std::path::PathBuf::from(path);
+                path.canonicalize()
+                    .with_context(|| {
+                        format!(
+                            "Unable to get the canonical form for \"{}\"",
+                            path.display()
+                        )
+                    })
+                    .map_err(|error| QueryError::new_other(error, package))?
+            }
+            _ => {
+                return Err(QueryError::Unsupported {
+                    query: package.clone(),
+                })
+            }
+        };
+
+        Self::load_path(&path)
+            .await
+            .map_err(|error| QueryError::new_other(error, package))
+    }
+}
diff --git a/lib/wasix/src/runtime/resolver/in_memory_source.rs b/lib/wasix/src/runtime/resolver/in_memory_source.rs
index 03553b2c04..1e97b0da0c 100644
--- a/lib/wasix/src/runtime/resolver/in_memory_source.rs
+++ b/lib/wasix/src/runtime/resolver/in_memory_source.rs
@@ -68,9 +68,20 @@ impl InMemorySource {
     }
 
     /// Add a new [`PackageSummary`] to the [`InMemorySource`].
+    ///
+    /// Named packages are also made accessible by their hash.
     pub fn add(&mut self, summary: PackageSummary) {
         match summary.pkg.id.clone() {
             PackageId::Named(ident) => {
+                // Also add the package as a hashed package.
+                let pkg_hash = PackageHash::Sha256(wasmer_config::hash::Sha256Hash(
+                    summary.dist.webc_sha256.as_bytes(),
+                ));
+                self.hash_packages
+                    .entry(pkg_hash)
+                    .or_insert_with(|| summary.clone());
+
+                // Add the named package.
                 let summaries = self
                     .named_packages
                     .entry(ident.full_name.clone())
@@ -107,6 +118,17 @@ impl InMemorySource {
             PackageId::Hash(hash) => self.hash_packages.get(hash),
         }
     }
+
+    pub fn is_empty(&self) -> bool {
+        self.named_packages.is_empty() && self.hash_packages.is_empty()
+    }
+
+    /// Returns the number of packages in the source.
+    pub fn len(&self) -> usize {
+        // Only need to count the hash packages,
+        // as the named packages are also always added as hashed.
+        self.hash_packages.len()
+    }
 }
 
 #[async_trait::async_trait]
@@ -135,13 +157,16 @@ impl Source for InMemorySource {
 
                         if matches.is_empty() {
                             return Err(QueryError::NoMatches {
+                                query: package.clone(),
                                 archived_versions: Vec::new(),
                             });
                         }
 
                         Ok(matches)
                     }
-                    None => Err(QueryError::NotFound),
+                    None => Err(QueryError::NotFound {
+                        query: package.clone(),
+                    }),
                 }
             }
             PackageSource::Ident(PackageIdent::Hash(hash)) => self
@@ -149,9 +174,12 @@ impl Source for InMemorySource {
                 .get(hash)
                 .map(|x| vec![x.clone()])
                 .ok_or_else(|| QueryError::NoMatches {
+                    query: package.clone(),
                     archived_versions: Vec::new(),
                 }),
-            PackageSource::Url(_) | PackageSource::Path(_) => Err(QueryError::Unsupported),
+            PackageSource::Url(_) | PackageSource::Path(_) => Err(QueryError::Unsupported {
+                query: package.clone(),
+            }),
         }
     }
 }
diff --git a/lib/wasix/src/runtime/resolver/inputs.rs b/lib/wasix/src/runtime/resolver/inputs.rs
index db0cea3b03..2e54f7252c 100644
--- a/lib/wasix/src/runtime/resolver/inputs.rs
+++ b/lib/wasix/src/runtime/resolver/inputs.rs
@@ -2,7 +2,7 @@ use std::{
     fmt::{self, Display, Formatter},
     fs::File,
     io::{BufRead, BufReader, Read},
-    path::{Path, PathBuf},
+    path::Path,
 };
 
 use anyhow::Error;
@@ -10,10 +10,8 @@ use semver::VersionReq;
 use sha2::{Digest, Sha256};
 use url::Url;
 use wasmer_config::package::{NamedPackageId, PackageHash, PackageId, PackageSource};
-use webc::{
-    metadata::{annotations::Wapm as WapmAnnotations, Manifest, UrlOrManifest},
-    Container,
-};
+use wasmer_package::utils::from_disk;
+use webc::metadata::{annotations::Wapm as WapmAnnotations, Manifest, UrlOrManifest};
 
 /// A dependency constraint.
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -53,7 +51,7 @@ impl PackageSummary {
 
     pub fn from_webc_file(path: impl AsRef<Path>) -> Result<PackageSummary, Error> {
         let path = path.as_ref().canonicalize()?;
-        let container = Container::from_disk(&path)?;
+        let container = from_disk(&path)?;
         let webc_sha256 = WebcHash::for_file(&path)?;
         let url = crate::runtime::resolver::utils::url_from_file_path(&path).ok_or_else(|| {
             anyhow::anyhow!("Unable to turn \"{}\" into a file:// URL", path.display())
@@ -290,9 +288,9 @@ impl WebcHash {
         Ok(Self(hash))
     }
 
-    pub fn for_file(path: &PathBuf) -> Result<Self, std::io::Error> {
+    pub fn for_file(path: &Path) -> Result<Self, std::io::Error> {
         // check for a hash at the file location
-        let mut path_hash = path.clone();
+        let mut path_hash = path.to_owned();
         path_hash.set_extension("webc.sha256");
         if let Ok(mut file) = File::open(&path_hash) {
             let mut hash = Vec::new();
diff --git a/lib/wasix/src/runtime/resolver/multi_source.rs b/lib/wasix/src/runtime/resolver/multi_source.rs
index 2dc3af3c4c..815dc168a9 100644
--- a/lib/wasix/src/runtime/resolver/multi_source.rs
+++ b/lib/wasix/src/runtime/resolver/multi_source.rs
@@ -24,15 +24,21 @@ pub struct MultiSource {
     strategy: MultiSourceStrategy,
 }
 
+impl Default for MultiSource {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl MultiSource {
-    pub const fn new() -> Self {
+    pub fn new() -> Self {
         MultiSource {
             sources: Vec::new(),
             strategy: MultiSourceStrategy::default(),
         }
     }
 
-    pub fn add_source(&mut self, source: impl Source + Send + Sync + 'static) -> &mut Self {
+    pub fn add_source(&mut self, source: impl Source + Send + 'static) -> &mut Self {
         self.add_shared_source(Arc::new(source))
     }
 
@@ -51,19 +57,52 @@ impl MultiSource {
 impl Source for MultiSource {
     #[tracing::instrument(level = "debug", skip_all, fields(%package))]
     async fn query(&self, package: &PackageSource) -> Result<Vec<PackageSummary>, QueryError> {
+        let mut output = Vec::<PackageSummary>::new();
+
         for source in &self.sources {
             match source.query(package).await {
-                Ok(summaries) => return Ok(summaries),
-                Err(QueryError::Unsupported) if self.strategy.continue_if_unsupported => continue,
-                Err(QueryError::NotFound) if self.strategy.continue_if_not_found => continue,
-                Err(QueryError::NoMatches { .. }) if self.strategy.continue_if_no_matches => {
+                Ok(mut summaries) => {
+                    if self.strategy.merge_results {
+                        // Extend matches, but skip already found versions.
+                        summaries.retain(|new| {
+                            !output.iter().any(|existing| new.pkg.id == existing.pkg.id)
+                        });
+                        output.extend(summaries);
+                    } else {
+                        return Ok(summaries);
+                    }
+                }
+                Err(QueryError::Unsupported { .. })
+                    if self.strategy.continue_if_unsupported || self.strategy.merge_results =>
+                {
                     continue
                 }
+                Err(QueryError::NotFound { .. })
+                    if self.strategy.continue_if_not_found || self.strategy.merge_results =>
+                {
+                    continue
+                }
+                Err(QueryError::NoMatches { .. })
+                    if self.strategy.continue_if_no_matches || self.strategy.merge_results =>
+                {
+                    continue
+                }
+                // Generic errors do not respect the `merge_results` strategy
+                // flag, because unexpected errors should be bubbled to the
+                // caller.
                 Err(e) => return Err(e),
             }
         }
 
-        Err(QueryError::NotFound)
+        if !output.is_empty() {
+            output.sort_by(|a, b| a.pkg.id.cmp(&b.pkg.id));
+
+            Ok(output)
+        } else {
+            Err(QueryError::NotFound {
+                query: package.clone(),
+            })
+        }
     }
 }
 
@@ -86,20 +125,66 @@ pub struct MultiSourceStrategy {
     ///
     /// This flag is **disabled** by default.
     pub continue_if_no_matches: bool,
+
+    /// Merge results from all sources into a single result.
+    ///
+    /// True by default.
+    pub merge_results: bool,
 }
 
-impl MultiSourceStrategy {
-    pub const fn default() -> Self {
+impl Default for MultiSourceStrategy {
+    fn default() -> Self {
         MultiSourceStrategy {
             continue_if_unsupported: true,
             continue_if_not_found: true,
             continue_if_no_matches: true,
+            merge_results: true,
         }
     }
 }
 
-impl Default for MultiSourceStrategy {
-    fn default() -> Self {
-        MultiSourceStrategy::default()
+#[cfg(test)]
+mod tests {
+    use wasmer_config::package::PackageId;
+
+    use super::super::{DistributionInfo, InMemorySource, PackageInfo, WebcHash};
+    use super::*;
+
+    /// Test that the `MultiSource` can merge results from multiple sources.
+    #[tokio::test]
+    async fn test_multi_source_merge() {
+        let id1 = PackageId::new_named("ns/pkg", "0.0.1".parse().unwrap());
+        let pkg1 = PackageSummary {
+            pkg: PackageInfo {
+                id: id1.clone(),
+                commands: Vec::new(),
+                entrypoint: None,
+                dependencies: Vec::new(),
+                filesystem: Vec::new(),
+            },
+            dist: DistributionInfo {
+                webc: "https://example.com/ns/pkg/0.0.1".parse().unwrap(),
+                webc_sha256: WebcHash([0u8; 32]),
+            },
+        };
+
+        let id2 = PackageId::new_named("ns/pkg", "0.0.2".parse().unwrap());
+        let mut pkg2 = pkg1.clone();
+        pkg2.pkg.id = id2.clone();
+
+        let mut mem1 = InMemorySource::new();
+        mem1.add(pkg1);
+
+        let mut mem2 = InMemorySource::new();
+        mem2.add(pkg2);
+
+        let mut multi = MultiSource::new();
+        multi.add_source(mem1);
+        multi.add_source(mem2);
+
+        let summaries = multi.query(&"ns/pkg".parse().unwrap()).await.unwrap();
+        assert_eq!(summaries.len(), 2);
+        assert_eq!(summaries[0].pkg.id, id1);
+        assert_eq!(summaries[1].pkg.id, id2);
     }
 }
diff --git a/lib/wasix/src/runtime/resolver/resolve.rs b/lib/wasix/src/runtime/resolver/resolve.rs
index 833f7ace1c..fd54312883 100644
--- a/lib/wasix/src/runtime/resolver/resolve.rs
+++ b/lib/wasix/src/runtime/resolver/resolve.rs
@@ -59,7 +59,7 @@ fn registry_error_message(specifier: &PackageSource) -> String {
         }
         PackageSource::Url(url) => format!("Unable to resolve \"{url}\""),
         PackageSource::Path(path) => {
-            format!("Unable to load \"{}\" from disk", path)
+            format!("Unable to load \"{path}\" from disk")
         }
     }
 }
@@ -421,7 +421,7 @@ mod tests {
         }
 
         fn finish(&self) -> MultiSource {
-            let mut registry = MultiSource::new();
+            let mut registry = MultiSource::default();
             registry.add_source(self.0.clone());
             registry
         }
@@ -449,7 +449,7 @@ mod tests {
         summary: PackageSummary,
     }
 
-    impl<'builder> AddPackageVersion<'builder> {
+    impl AddPackageVersion<'_> {
         fn with_dependency(&mut self, name: &str, version_constraint: &str) -> &mut Self {
             self.with_aliased_dependency(name, name, version_constraint)
         }
@@ -520,7 +520,7 @@ mod tests {
         }
     }
 
-    impl<'builder> Drop for AddPackageVersion<'builder> {
+    impl Drop for AddPackageVersion<'_> {
         fn drop(&mut self) {
             let summary = self.summary.clone();
             self.builder.add(summary);
@@ -592,7 +592,7 @@ mod tests {
         dependencies: BTreeMap<String, PackageId>,
     }
 
-    impl<'source, 'builder> DependencyGraphEntryBuilder<'source, 'builder> {
+    impl DependencyGraphEntryBuilder<'_, '_> {
         fn with_dependency(&mut self, id: &PackageId) -> &mut Self {
             let name = &id.as_named().unwrap().full_name;
             self.with_aliased_dependency(name, id)
@@ -605,7 +605,7 @@ mod tests {
         }
     }
 
-    impl<'source, 'builder> Drop for DependencyGraphEntryBuilder<'source, 'builder> {
+    impl Drop for DependencyGraphEntryBuilder<'_, '_> {
         fn drop(&mut self) {
             self.builder
                 .dependencies
diff --git a/lib/wasix/src/runtime/resolver/source.rs b/lib/wasix/src/runtime/resolver/source.rs
index a3bb5b8d74..1992750f1c 100644
--- a/lib/wasix/src/runtime/resolver/source.rs
+++ b/lib/wasix/src/runtime/resolver/source.rs
@@ -1,4 +1,7 @@
-use std::fmt::{Debug, Display};
+use std::{
+    fmt::{Debug, Display},
+    sync::Arc,
+};
 
 use wasmer_config::package::{PackageIdent, PackageSource};
 
@@ -34,9 +37,13 @@ pub trait Source: Sync + Debug {
                     left_version.cmp(&right_version)
                 })
                 .ok_or(QueryError::NoMatches {
+                    query: pkg.clone(),
                     archived_versions: Vec::new(),
                 }),
-            _ => candidates.into_iter().next().ok_or(QueryError::NotFound),
+            _ => candidates
+                .into_iter()
+                .next()
+                .ok_or_else(|| QueryError::NotFound { query: pkg.clone() }),
         }
     }
 }
@@ -52,46 +59,76 @@ where
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub enum QueryError {
-    Unsupported,
-    NotFound,
+    Unsupported {
+        query: PackageSource,
+    },
+    NotFound {
+        query: PackageSource,
+    },
     NoMatches {
+        query: PackageSource,
         archived_versions: Vec<semver::Version>,
     },
-    Timeout,
-    Other(anyhow::Error),
+    Timeout {
+        query: PackageSource,
+    },
+    Other {
+        query: PackageSource,
+        // Arc to make it cloneable
+        // Cloning is important for some use-cases.
+        error: Arc<anyhow::Error>,
+    },
 }
 
-impl From<anyhow::Error> for QueryError {
-    fn from(value: anyhow::Error) -> Self {
-        Self::Other(value)
+impl QueryError {
+    pub fn query(&self) -> &PackageSource {
+        match self {
+            Self::Unsupported { query }
+            | Self::NotFound { query }
+            | Self::NoMatches { query, .. }
+            | Self::Timeout { query }
+            | Self::Other { query, .. } => query,
+        }
+    }
+
+    pub fn new_other(err: anyhow::Error, query: &PackageSource) -> Self {
+        Self::Other {
+            query: query.clone(),
+            error: Arc::new(err),
+        }
     }
 }
 
 impl Display for QueryError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "failed to query package '{}': ", self.query())?;
+
         match self {
-            Self::Unsupported => f.write_str("This type of package specifier isn't supported"),
-            Self::NotFound => f.write_str("Not found"),
-            Self::Timeout => f.write_str("Timed out"),
-            Self::NoMatches { archived_versions } => match archived_versions.as_slice() {
+            Self::Unsupported { .. } => f.write_str("unsupported package specifier"),
+            Self::NotFound { .. } => f.write_str("not found"),
+            Self::Timeout { .. } => f.write_str("timeout"),
+            Self::NoMatches {
+                query: _,
+                archived_versions,
+            } => match archived_versions.as_slice() {
                 [] => f.write_str(
-                    "The package was found, but no published versions matched the constraint",
+                    "the package was found, but no published versions matched the constraint",
                 ),
                 [version] => write!(
                     f,
-                    "The only version satisfying the constraint, {version}, is archived"
+                    "the only version satisfying the constraint, {version}, is archived"
                 ),
                 [first, rest @ ..] => {
                     let num_others = rest.len();
                     write!(
                         f,
-                        "Unable to satisfy the request. Version {first}, and {num_others} are all archived"
+                        "unable to satisfy the request - version {first}, and {num_others} are all archived"
                     )
                 }
             },
-            Self::Other(e) => Display::fmt(e, f),
+            Self::Other { error: e, query: _ } => Display::fmt(e, f),
         }
     }
 }
@@ -99,8 +136,11 @@ impl Display for QueryError {
 impl std::error::Error for QueryError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         match self {
-            Self::Other(e) => Some(&**e),
-            Self::Unsupported | Self::NotFound | Self::NoMatches { .. } | Self::Timeout => None,
+            Self::Other { error, query: _ } => Some(&***error),
+            Self::Unsupported { .. }
+            | Self::NotFound { .. }
+            | Self::NoMatches { .. }
+            | Self::Timeout { .. } => None,
         }
     }
 }
diff --git a/lib/wasix/src/runtime/resolver/web_source.rs b/lib/wasix/src/runtime/resolver/web_source.rs
index 0660e752d9..110893fe1c 100644
--- a/lib/wasix/src/runtime/resolver/web_source.rs
+++ b/lib/wasix/src/runtime/resolver/web_source.rs
@@ -12,7 +12,7 @@ use sha2::{Digest, Sha256};
 use tempfile::NamedTempFile;
 use url::Url;
 use wasmer_config::package::{PackageHash, PackageId, PackageSource};
-use webc::compat::Container;
+use wasmer_package::utils::from_disk;
 
 use crate::{
     http::{HttpClient, HttpRequest},
@@ -224,17 +224,8 @@ impl WebSource {
 
         Ok((body, etag))
     }
-}
-
-#[async_trait::async_trait]
-impl Source for WebSource {
-    #[tracing::instrument(level = "debug", skip_all, fields(%package))]
-    async fn query(&self, package: &PackageSource) -> Result<Vec<PackageSummary>, QueryError> {
-        let url = match package {
-            PackageSource::Url(url) => url,
-            _ => return Err(QueryError::Unsupported),
-        };
 
+    async fn load_url(&self, url: &Url) -> Result<Vec<PackageSummary>, anyhow::Error> {
         let local_path = self
             .get_locally_cached_file(url)
             .await
@@ -245,7 +236,7 @@ impl Source for WebSource {
 
         // Note: We want to use Container::from_disk() rather than the bytes
         // our HTTP client gave us because then we can use memory-mapped files
-        let container = crate::block_in_place(|| Container::from_disk(&local_path))
+        let container = crate::block_in_place(|| from_disk(&local_path))
             .with_context(|| format!("Unable to load \"{}\"", local_path.display()))?;
 
         let id = PackageInfo::package_id_from_manifest(container.manifest())?
@@ -263,6 +254,25 @@ impl Source for WebSource {
     }
 }
 
+#[async_trait::async_trait]
+impl Source for WebSource {
+    #[tracing::instrument(level = "debug", skip_all, fields(%package))]
+    async fn query(&self, package: &PackageSource) -> Result<Vec<PackageSummary>, QueryError> {
+        let url = match package {
+            PackageSource::Url(url) => url,
+            _ => {
+                return Err(QueryError::Unsupported {
+                    query: package.clone(),
+                })
+            }
+        };
+
+        self.load_url(url)
+            .await
+            .map_err(|error| QueryError::new_other(error, package))
+    }
+}
+
 fn sha256(bytes: &[u8]) -> String {
     let mut hasher = Sha256::default();
     hasher.update(bytes);
diff --git a/lib/wasix/src/runtime/task_manager/mod.rs b/lib/wasix/src/runtime/task_manager/mod.rs
index cf9c071c16..0b490f608d 100644
--- a/lib/wasix/src/runtime/task_manager/mod.rs
+++ b/lib/wasix/src/runtime/task_manager/mod.rs
@@ -7,20 +7,22 @@ use std::task::{Context, Poll};
 use std::{pin::Pin, time::Duration};
 
 use bytes::Bytes;
-use derivative::Derivative;
+use derive_more::Debug;
 use futures::future::BoxFuture;
 use futures::{Future, TryFutureExt};
-use wasmer::{AsStoreMut, AsStoreRef, Memory, MemoryType, Module, Store, StoreMut, StoreRef};
+use wasmer::{
+    AsStoreMut, AsStoreRef, FunctionEnv, Memory, MemoryType, Module, Store, StoreMut, StoreRef,
+};
 use wasmer_wasix_types::wasi::{Errno, ExitCode};
 
-use crate::os::task::thread::WasiThreadError;
 use crate::syscalls::AsyncifyFuture;
 use crate::{capture_store_snapshot, StoreSnapshot, WasiEnv, WasiFunctionEnv, WasiThread};
+use crate::{os::task::thread::WasiThreadError, state::Linker};
 
 pub use virtual_mio::waker::*;
 
 #[derive(Debug)]
-pub enum SpawnMemoryType<'a> {
+pub enum SpawnType<'a> {
     CreateMemory,
     CreateMemoryOfType(MemoryType),
     // TODO: is there a way to get rid of the memory reference
@@ -30,6 +32,21 @@ pub enum SpawnMemoryType<'a> {
     // has been copied, this makes sure its not modified until
     // its been properly copied
     CopyMemory(Memory, StoreRef<'a>),
+    #[debug("NewLinkerInstanceGroup(..)")]
+    NewLinkerInstanceGroup(Linker, FunctionEnv<WasiEnv>, StoreMut<'a>),
+}
+
+/// Describes whether a new memory should be created (and, in case, its type) or if it was already
+/// created and the store it belongs to.
+///
+/// # Note
+///
+/// This type is necessary for now because we can't pass a [`wasmer::StoreRef`] between threads, so this
+/// conceptually is a Send-able [`SpawnMemoryType`].
+pub enum SpawnMemoryTypeOrStore {
+    New,
+    Type(wasmer::MemoryType),
+    StoreAndMemory(wasmer::Store, Option<wasmer::Memory>),
 }
 
 pub type WasmResumeTask = dyn FnOnce(WasiFunctionEnv, Store, Bytes) + Send + 'static;
@@ -39,8 +56,7 @@ pub type WasmResumeTrigger = dyn FnOnce() -> Pin<Box<dyn Future<Output = Result<
     + Sync;
 
 /// The properties passed to the task
-#[derive(Derivative)]
-#[derivative(Debug)]
+#[derive(derive_more::Debug)]
 pub struct TaskWasmRunProperties {
     pub ctx: WasiFunctionEnv,
     pub store: Store,
@@ -49,10 +65,16 @@ pub struct TaskWasmRunProperties {
     /// (if the trigger returns an ExitCode then the WASM process will be terminated without resuming)
     pub trigger_result: Option<Result<Bytes, ExitCode>>,
     /// The instance will be recycled back to this function when the WASM run has finished
-    #[derivative(Debug = "ignore")]
+    #[debug(ignore)]
     pub recycle: Option<Box<TaskWasmRecycle>>,
 }
 
+pub type TaskWasmPreRun = dyn (for<'a> FnOnce(
+        &'a mut WasiFunctionEnv,
+        &'a mut Store,
+    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>>)
+    + Send;
+
 /// Callback that will be invoked
 pub type TaskWasmRun = dyn FnOnce(TaskWasmRunProperties) + Send + 'static;
 
@@ -71,19 +93,27 @@ pub struct TaskWasmRecycleProperties {
 pub type TaskWasmRecycle = dyn FnOnce(TaskWasmRecycleProperties) + Send + 'static;
 
 /// Represents a WASM task that will be executed on a dedicated thread
-pub struct TaskWasm<'a, 'b> {
+pub struct TaskWasm<'a> {
     pub run: Box<TaskWasmRun>,
     pub recycle: Option<Box<TaskWasmRecycle>>,
     pub env: WasiEnv,
     pub module: Module,
-    pub globals: Option<&'b StoreSnapshot>,
-    pub spawn_type: SpawnMemoryType<'a>,
+    pub globals: Option<StoreSnapshot>,
+    pub spawn_type: SpawnType<'a>,
     pub trigger: Option<Box<WasmResumeTrigger>>,
     pub update_layout: bool,
+    pub call_initialize: bool,
+    pub pre_run: Option<Box<TaskWasmPreRun>>,
 }
 
-impl<'a, 'b> TaskWasm<'a, 'b> {
-    pub fn new(run: Box<TaskWasmRun>, env: WasiEnv, module: Module, update_layout: bool) -> Self {
+impl<'a> TaskWasm<'a> {
+    pub fn new(
+        run: Box<TaskWasmRun>,
+        env: WasiEnv,
+        module: Module,
+        update_layout: bool,
+        call_initialize: bool,
+    ) -> Self {
         let shared_memory = module.imports().memories().next().map(|a| *a.ty());
         Self {
             run,
@@ -91,28 +121,30 @@ impl<'a, 'b> TaskWasm<'a, 'b> {
             module,
             globals: None,
             spawn_type: match shared_memory {
-                Some(ty) => SpawnMemoryType::CreateMemoryOfType(ty),
-                None => SpawnMemoryType::CreateMemory,
+                Some(ty) => SpawnType::CreateMemoryOfType(ty),
+                None => SpawnType::CreateMemory,
             },
             trigger: None,
             update_layout,
+            call_initialize,
             recycle: None,
+            pre_run: None,
         }
     }
 
-    pub fn with_memory(mut self, spawn_type: SpawnMemoryType<'a>) -> Self {
+    pub fn with_memory(mut self, spawn_type: SpawnType<'a>) -> Self {
         self.spawn_type = spawn_type;
         self
     }
 
-    pub fn with_optional_memory(mut self, spawn_type: Option<SpawnMemoryType<'a>>) -> Self {
+    pub fn with_optional_memory(mut self, spawn_type: Option<SpawnType<'a>>) -> Self {
         if let Some(spawn_type) = spawn_type {
             self.spawn_type = spawn_type;
         }
         self
     }
 
-    pub fn with_globals(mut self, snapshot: &'b StoreSnapshot) -> Self {
+    pub fn with_globals(mut self, snapshot: StoreSnapshot) -> Self {
         self.globals.replace(snapshot);
         self
     }
@@ -122,8 +154,13 @@ impl<'a, 'b> TaskWasm<'a, 'b> {
         self
     }
 
-    pub fn with_recycle(mut self, trigger: Box<TaskWasmRecycle>) -> Self {
-        self.recycle.replace(trigger);
+    pub fn with_recycle(mut self, recycle: Box<TaskWasmRecycle>) -> Self {
+        self.recycle.replace(recycle);
+        self
+    }
+
+    pub fn with_pre_run(mut self, pre_run: Box<TaskWasmPreRun>) -> Self {
+        self.pre_run.replace(pre_run);
         self
     }
 }
@@ -151,10 +188,11 @@ pub trait VirtualTaskManager: std::fmt::Debug + Send + Sync + 'static {
     fn build_memory(
         &self,
         mut store: &mut StoreMut,
-        spawn_type: SpawnMemoryType,
+        spawn_type: &SpawnType,
     ) -> Result<Option<Memory>, WasiThreadError> {
         match spawn_type {
-            SpawnMemoryType::CreateMemoryOfType(mut ty) => {
+            SpawnType::CreateMemoryOfType(ty) => {
+                let mut ty = *ty;
                 ty.shared = true;
 
                 // Note: If memory is shared, maximum needs to be set in the
@@ -171,7 +209,7 @@ pub trait VirtualTaskManager: std::fmt::Debug + Send + Sync + 'static {
                 })?;
                 Ok(Some(mem))
             }
-            SpawnMemoryType::ShareMemory(mem, old_store) => {
+            SpawnType::ShareMemory(mem, old_store) => {
                 let mem = mem.share_in_store(&old_store, store).map_err(|err| {
                     tracing::warn!(
                         error = &err as &dyn std::error::Error,
@@ -181,7 +219,7 @@ pub trait VirtualTaskManager: std::fmt::Debug + Send + Sync + 'static {
                 })?;
                 Ok(Some(mem))
             }
-            SpawnMemoryType::CopyMemory(mem, old_store) => {
+            SpawnType::CopyMemory(mem, old_store) => {
                 let mem = mem.copy_to_store(&old_store, store).map_err(|err| {
                     tracing::warn!(
                         error = &err as &dyn std::error::Error,
@@ -191,7 +229,7 @@ pub trait VirtualTaskManager: std::fmt::Debug + Send + Sync + 'static {
                 })?;
                 Ok(Some(mem))
             }
-            SpawnMemoryType::CreateMemory => Ok(None),
+            SpawnType::CreateMemory | SpawnType::NewLinkerInstanceGroup(..) => Ok(None),
         }
     }
 
@@ -269,7 +307,7 @@ where
     fn build_memory(
         &self,
         store: &mut StoreMut,
-        spawn_type: SpawnMemoryType,
+        spawn_type: &SpawnType,
     ) -> Result<Option<Memory>, WasiThreadError> {
         (**self).build_memory(store, spawn_type)
     }
@@ -348,8 +386,12 @@ impl dyn VirtualTaskManager {
 
         let snapshot = capture_store_snapshot(&mut store.as_store_mut());
         let env = ctx.data(&store);
-        let module = env.inner().module_clone();
-        let memory = env.inner().memory_clone();
+        let env_inner = env.inner();
+        let handles = env_inner
+            .static_module_instance_handles()
+            .ok_or(WasiThreadError::Unsupported)?;
+        let module = handles.module_clone();
+        let memory = handles.memory_clone();
         let thread = env.thread.clone();
         let env = env.clone();
 
@@ -372,9 +414,10 @@ impl dyn VirtualTaskManager {
                 env.clone(),
                 module,
                 false,
+                false,
             )
-            .with_memory(SpawnMemoryType::ShareMemory(memory, store.as_store_ref()))
-            .with_globals(&snapshot)
+            .with_memory(SpawnType::ShareMemory(memory, store.as_store_ref()))
+            .with_globals(snapshot)
             .with_trigger(Box::new(move || {
                 Box::pin(async move {
                     let mut poller = AsyncifyPollerOwned {
diff --git a/lib/wasix/src/runtime/task_manager/tokio.rs b/lib/wasix/src/runtime/task_manager/tokio.rs
index c524134c6e..9946d1784b 100644
--- a/lib/wasix/src/runtime/task_manager/tokio.rs
+++ b/lib/wasix/src/runtime/task_manager/tokio.rs
@@ -3,10 +3,13 @@ use std::{num::NonZeroUsize, pin::Pin, sync::Arc, time::Duration};
 
 use futures::{future::BoxFuture, Future};
 use tokio::runtime::{Handle, Runtime};
+use virtual_mio::InlineWaker;
+use wasmer::AsStoreMut;
 
+use crate::runtime::SpawnType;
 use crate::{os::task::thread::WasiThreadError, WasiFunctionEnv};
 
-use super::{TaskWasm, TaskWasmRunProperties, VirtualTaskManager};
+use super::{SpawnMemoryTypeOrStore, TaskWasm, TaskWasmRunProperties, VirtualTaskManager};
 
 #[derive(Debug, Clone)]
 pub enum RuntimeOrHandle {
@@ -110,15 +113,6 @@ impl Default for TokioTaskManager {
     }
 }
 
-#[allow(dead_code)]
-struct TokioRuntimeGuard<'g> {
-    #[allow(unused)]
-    inner: tokio::runtime::EnterGuard<'g>,
-}
-impl<'g> Drop for TokioRuntimeGuard<'g> {
-    fn drop(&mut self) {}
-}
-
 impl VirtualTaskManager for TokioTaskManager {
     /// See [`VirtualTaskManager::sleep_now`].
     fn sleep_now(&self, time: Duration) -> Pin<Box<dyn Future<Output = ()> + Send + Sync>> {
@@ -146,21 +140,84 @@ impl VirtualTaskManager for TokioTaskManager {
 
     /// See [`VirtualTaskManager::task_wasm`].
     fn task_wasm(&self, task: TaskWasm) -> Result<(), WasiThreadError> {
-        // Create the context on a new store
         let run = task.run;
         let recycle = task.recycle;
-        let (ctx, mut store) = WasiFunctionEnv::new_with_store(
-            task.module,
-            task.env,
-            task.globals,
-            task.spawn_type,
-            task.update_layout,
-        )?;
-
-        // If we have a trigger then we first need to run
-        // the poller to completion
+        let env = task.env;
+        let pre_run = task.pre_run;
+
+        let make_memory: SpawnMemoryTypeOrStore = match &task.spawn_type {
+            SpawnType::CreateMemory | SpawnType::NewLinkerInstanceGroup(..) => {
+                SpawnMemoryTypeOrStore::New
+            }
+            SpawnType::CreateMemoryOfType(t) => SpawnMemoryTypeOrStore::Type(*t),
+            SpawnType::ShareMemory(_, _) | SpawnType::CopyMemory(_, _) => {
+                let mut store = env.runtime().new_store();
+                let memory = self.build_memory(&mut store.as_store_mut(), &task.spawn_type)?;
+                SpawnMemoryTypeOrStore::StoreAndMemory(store, memory)
+            }
+        };
+
+        // This should actually run in the blocking thread, just like the task itself.
+        // See the comment below for why we can't do it there yet.
+        //
+        // For now block_in_place at least ensures that we don't block the async runtime
+        let ret = tokio::task::block_in_place(move || {
+            if let SpawnType::NewLinkerInstanceGroup(linker, func_env, mut store) = task.spawn_type
+            {
+                WasiFunctionEnv::new_with_store(
+                    task.module,
+                    env,
+                    task.globals,
+                    make_memory,
+                    task.update_layout,
+                    task.call_initialize,
+                    Some((linker, &mut func_env.into_mut(&mut store))),
+                )
+            } else {
+                WasiFunctionEnv::new_with_store(
+                    task.module,
+                    env,
+                    task.globals,
+                    make_memory,
+                    task.update_layout,
+                    task.call_initialize,
+                    None,
+                )
+            }
+        });
+
         if let Some(trigger) = task.trigger {
             tracing::trace!("spawning task_wasm trigger in async pool");
+            // In principle, we'd need to create this in the `pool.execute` function below, that is
+            //
+            // ```
+            // 227: pool.execute(move || {
+            // ...:      let (ctx, mut store) = WasiFunctionEnv::new_with_store(
+            // ...:      ...
+            // ```
+            //
+            // However, in the loop spawned below we need to have a `FunctionEnvMut<WasiEnv>`, which
+            // must be created with a mutable reference to the store. We can't, however since
+            // ```
+            // pool.execute(move || {
+            //      let (ctx, mut store) = WasiFunctionEnv::new_with_store(
+            //      ...
+            //      tx.send(store.as_store_mut())
+            // ```
+            // or
+            // ```
+            // pool.execute(move || {
+            //      let (ctx, mut store) = WasiFunctionEnv::new_with_store(
+            //      ...
+            //      tx.send(ctx.env.clone().into_mut(&mut store.as_store_mut()))
+            // ```
+            // Since the reference would outlive the owned value.
+            //
+            // So, we create the store (and memory, and instance) outside the execution thread (the
+            // pool's one), and let it fail for runtimes that don't support entities created in a
+            // thread that's not the one in which execution happens in; this until we can clone
+            // stores.
+            let (mut ctx, mut store) = ret?;
 
             let mut trigger = trigger();
             let pool = self.pool.clone();
@@ -173,7 +230,14 @@ impl VirtualTaskManager for TokioTaskManager {
                         _ = env.thread.wait_for_signal() => {
                             tracing::debug!("wait-for-signal(triggered)");
                             let mut ctx = ctx.env.clone().into_mut(&mut store);
-                            if let Err(err) = crate::WasiEnv::process_signals_and_exit(&mut ctx) {
+                            if let Err(err) =
+                                crate::WasiEnv::do_pending_link_operations(
+                                    &mut ctx,
+                                    false
+                                ).and_then(|()|
+                                    crate::WasiEnv::process_signals_and_exit(&mut ctx)
+                                )
+                            {
                                 match err {
                                     crate::WasiError::Exit(code) => Err(code),
                                     err => {
@@ -194,6 +258,10 @@ impl VirtualTaskManager for TokioTaskManager {
                     };
                 };
 
+                if let Some(pre_run) = pre_run {
+                    pre_run(&mut ctx, &mut store).await;
+                }
+
                 // Build the task that will go on the callback
                 pool.execute(move || {
                     // Invoke the callback
@@ -208,9 +276,25 @@ impl VirtualTaskManager for TokioTaskManager {
         } else {
             tracing::trace!("spawning task_wasm in blocking thread");
 
+            let (sx, rx) = std::sync::mpsc::channel();
+
             // Run the callback on a dedicated thread
             self.pool.execute(move || {
                 tracing::trace!("task_wasm started in blocking thread");
+                let (mut ctx, mut store) = match ret {
+                    Ok(x) => {
+                        sx.send(Ok(())).unwrap();
+                        x
+                    }
+                    Err(c) => {
+                        sx.send(Err(c)).unwrap();
+                        return;
+                    }
+                };
+
+                if let Some(pre_run) = pre_run {
+                    InlineWaker::block_on(pre_run(&mut ctx, &mut store));
+                }
 
                 // Invoke the callback
                 run(TaskWasmRunProperties {
@@ -220,6 +304,9 @@ impl VirtualTaskManager for TokioTaskManager {
                     recycle,
                 });
             });
+
+            rx.recv()
+                .map_err(|_| WasiThreadError::InvalidWasmContext)??;
         }
         Ok(())
     }
diff --git a/lib/wasix/src/state/builder.rs b/lib/wasix/src/state/builder.rs
index b35bf444d1..d7e5977178 100644
--- a/lib/wasix/src/state/builder.rs
+++ b/lib/wasix/src/state/builder.rs
@@ -9,28 +9,27 @@ use std::{
 use rand::Rng;
 use thiserror::Error;
 use virtual_fs::{ArcFile, FileSystem, FsError, TmpFileSystem, VirtualFile};
-use wasmer::{AsStoreMut, Extern, Imports, Instance, Module, Store};
+use wasmer::{AsStoreMut, Engine, Instance, Module};
 use wasmer_config::package::PackageId;
 
 #[cfg(feature = "journal")]
-use crate::journal::{DynJournal, SnapshotTrigger};
+use crate::journal::{DynJournal, DynReadableJournal, SnapshotTrigger};
 use crate::{
     bin_factory::{BinFactory, BinaryPackage},
     capabilities::Capabilities,
     fs::{WasiFs, WasiFsRoot, WasiInodes},
     os::task::control_plane::{ControlPlaneConfig, ControlPlaneError, WasiControlPlane},
     state::WasiState,
-    syscalls::{
-        rewind_ext2,
-        types::{__WASI_STDERR_FILENO, __WASI_STDIN_FILENO, __WASI_STDOUT_FILENO},
-    },
-    utils::xxhash_random,
-    Runtime, WasiEnv, WasiError, WasiFunctionEnv, WasiRuntimeError,
+    syscalls::types::{__WASI_STDERR_FILENO, __WASI_STDIN_FILENO, __WASI_STDOUT_FILENO},
+    Runtime, WasiEnv, WasiFunctionEnv, WasiRuntimeError, WasiThreadError,
 };
 use wasmer_types::ModuleHash;
+use wasmer_wasix_types::wasi::SignalDisposition;
 
 use super::env::WasiEnvInit;
 
+// FIXME: additional import support was broken and has been removed. We need to re-introduce
+// it in a way that works with multi-threaded WASIX apps.
 /// Builder API for configuring a [`WasiEnv`] environment needed to run WASI modules.
 ///
 /// Usage:
@@ -49,10 +48,14 @@ use super::env::WasiEnvInit;
 /// ```
 #[derive(Default)]
 pub struct WasiEnvBuilder {
+    /// Name of entry function. Defaults to running `_start` if not specified.
+    pub(super) entry_function: Option<String>,
     /// Command line arguments.
     pub(super) args: Vec<String>,
     /// Environment variables.
     pub(super) envs: Vec<(String, Vec<u8>)>,
+    /// Signals that should get their handler overridden.
+    pub(super) signals: Vec<SignalDisposition>,
     /// Pre-opened directories that will be accessible from WASI.
     pub(super) preopens: Vec<PreopenedDir>,
     /// Pre-opened virtual directories that will be accessible from WASI.
@@ -64,6 +67,7 @@ pub struct WasiEnvBuilder {
     pub(super) stderr: Option<Box<dyn VirtualFile + Send + Sync + 'static>>,
     pub(super) stdin: Option<Box<dyn VirtualFile + Send + Sync + 'static>>,
     pub(super) fs: Option<WasiFsRoot>,
+    pub(super) engine: Option<Engine>,
     pub(super) runtime: Option<Arc<dyn crate::Runtime + Send + Sync + 'static>>,
     pub(super) current_dir: Option<PathBuf>,
 
@@ -78,7 +82,6 @@ pub struct WasiEnvBuilder {
     pub(super) map_commands: HashMap<String, PathBuf>,
 
     pub(super) capabilites: Capabilities,
-    pub(super) additional_imports: Imports,
 
     #[cfg(feature = "journal")]
     pub(super) snapshot_on: Vec<SnapshotTrigger>,
@@ -87,7 +90,15 @@ pub struct WasiEnvBuilder {
     pub(super) snapshot_interval: Option<std::time::Duration>,
 
     #[cfg(feature = "journal")]
-    pub(super) journals: Vec<Arc<DynJournal>>,
+    pub(super) stop_running_after_snapshot: bool,
+
+    #[cfg(feature = "journal")]
+    pub(super) read_only_journals: Vec<Arc<DynReadableJournal>>,
+
+    #[cfg(feature = "journal")]
+    pub(super) writable_journals: Vec<Arc<DynJournal>>,
+
+    pub(super) skip_stdio_during_bootstrap: bool,
 
     #[cfg(feature = "ctrlc")]
     pub(super) attach_ctrl_c: bool,
@@ -97,14 +108,17 @@ impl std::fmt::Debug for WasiEnvBuilder {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         // TODO: update this when stable
         f.debug_struct("WasiEnvBuilder")
+            .field("entry_function", &self.entry_function)
             .field("args", &self.args)
             .field("envs", &self.envs)
+            .field("signals", &self.signals)
             .field("preopens", &self.preopens)
             .field("uses", &self.uses)
             .field("setup_fs_fn exists", &self.setup_fs_fn.is_some())
             .field("stdout_override exists", &self.stdout.is_some())
             .field("stderr_override exists", &self.stderr.is_some())
             .field("stdin_override exists", &self.stdin.is_some())
+            .field("engine_override_exists", &self.engine.is_some())
             .field("runtime_override_exists", &self.runtime.is_some())
             .finish()
     }
@@ -140,7 +154,7 @@ pub enum WasiStateCreationError {
 fn validate_mapped_dir_alias(alias: &str) -> Result<(), WasiStateCreationError> {
     if !alias.bytes().all(|b| b != b'\0') {
         return Err(WasiStateCreationError::MappedDirAliasFormattingError(
-            format!("Alias \"{}\" contains a nul byte", alias),
+            format!("Alias \"{alias}\" contains a nul byte"),
         ));
     }
 
@@ -160,6 +174,14 @@ impl WasiEnvBuilder {
         }
     }
 
+    /// Attaches a ctrl-c handler which will send signals to the
+    /// process rather than immediately termiante it
+    #[cfg(feature = "ctrlc")]
+    pub fn attach_ctrl_c(mut self) -> Self {
+        self.attach_ctrl_c = true;
+        self
+    }
+
     /// Add an environment variable pair.
     ///
     /// Both the key and value of an environment variable must not
@@ -174,14 +196,6 @@ impl WasiEnvBuilder {
         self
     }
 
-    /// Attaches a ctrl-c handler which will send signals to the
-    /// process rather than immediately termiante it
-    #[cfg(feature = "ctrlc")]
-    pub fn attach_ctrl_c(mut self) -> Self {
-        self.attach_ctrl_c = true;
-        self
-    }
-
     /// Add an environment variable pair.
     ///
     /// Both the key and value of an environment variable must not
@@ -240,6 +254,62 @@ impl WasiEnvBuilder {
         &mut self.envs
     }
 
+    /// Add a signal handler override.
+    pub fn signal(mut self, sig_action: SignalDisposition) -> Self {
+        self.add_signal(sig_action);
+        self
+    }
+
+    /// Add a signal handler override.
+    pub fn add_signal(&mut self, sig_action: SignalDisposition) {
+        self.signals.push(sig_action);
+    }
+
+    /// Add multiple signal handler overrides.
+    pub fn signals<I>(mut self, signal_pairs: I) -> Self
+    where
+        I: IntoIterator<Item = SignalDisposition>,
+    {
+        self.add_signals(signal_pairs);
+
+        self
+    }
+
+    /// Add multiple signal handler overrides.
+    pub fn add_signals<I>(&mut self, signal_pairs: I)
+    where
+        I: IntoIterator<Item = SignalDisposition>,
+    {
+        for sig in signal_pairs {
+            self.add_signal(sig);
+        }
+    }
+
+    /// Get a reference to the configured signal handler overrides.
+    pub fn get_signals(&self) -> &[SignalDisposition] {
+        &self.signals
+    }
+
+    /// Get a mutable reference to the configured signalironment variables.
+    pub fn get_signals_mut(&mut self) -> &mut Vec<SignalDisposition> {
+        &mut self.signals
+    }
+
+    pub fn entry_function<S>(mut self, entry_function: S) -> Self
+    where
+        S: AsRef<str>,
+    {
+        self.set_entry_function(entry_function);
+        self
+    }
+
+    pub fn set_entry_function<S>(&mut self, entry_function: S)
+    where
+        S: AsRef<str>,
+    {
+        self.entry_function = Some(entry_function.as_ref().to_owned());
+    }
+
     /// Add an argument.
     ///
     /// Arguments must not contain the nul (0x0) byte
@@ -336,7 +406,7 @@ impl WasiEnvBuilder {
     /// Adds packages that is already included in the [`WasiEnvBuilder`] filesystem.
     /// These packages will not be merged to the final filesystem since they are already included.
     pub fn include_packages(&mut self, pkg_ids: impl IntoIterator<Item = PackageId>) -> &mut Self {
-        self.included_packages.extend(pkg_ids.into_iter());
+        self.included_packages.extend(pkg_ids);
 
         self
     }
@@ -547,6 +617,16 @@ impl WasiEnvBuilder {
         Ok(self)
     }
 
+    /// Specifies one or more journal files that Wasmer will use to restore
+    /// the state of the WASM process.
+    ///
+    /// The state of the WASM process and its sandbox will be reapplied use
+    /// the journals in the order that you specify here.
+    #[cfg(feature = "journal")]
+    pub fn add_read_only_journal(&mut self, journal: Arc<DynReadableJournal>) {
+        self.read_only_journals.push(journal);
+    }
+
     /// Specifies one or more journal files that Wasmer will use to restore
     /// the state of the WASM process.
     ///
@@ -557,8 +637,12 @@ impl WasiEnvBuilder {
     /// and opened for read and write. New journal events will be written to this
     /// file
     #[cfg(feature = "journal")]
-    pub fn add_journal(&mut self, journal: Arc<DynJournal>) {
-        self.journals.push(journal);
+    pub fn add_writable_journal(&mut self, journal: Arc<DynJournal>) {
+        self.writable_journals.push(journal);
+    }
+
+    pub fn get_current_dir(&mut self) -> Option<PathBuf> {
+        self.current_dir.clone()
     }
 
     pub fn set_current_dir(&mut self, dir: impl Into<PathBuf>) {
@@ -639,6 +723,17 @@ impl WasiEnvBuilder {
         self
     }
 
+    /// Sets the wasmer engine and overrides the default; only used if
+    /// a runtime override is not provided.
+    pub fn engine(mut self, engine: Engine) -> Self {
+        self.set_engine(engine);
+        self
+    }
+
+    pub fn set_engine(&mut self, engine: Engine) {
+        self.engine = Some(engine);
+    }
+
     /// Sets the WASI runtime implementation and overrides the default
     /// implementation
     pub fn runtime(mut self, runtime: Arc<dyn Runtime + Send + Sync>) -> Self {
@@ -673,49 +768,13 @@ impl WasiEnvBuilder {
         self.snapshot_interval.replace(interval);
     }
 
-    /// Add an item to the list of importable items provided to the instance.
-    pub fn import(
-        mut self,
-        namespace: impl Into<String>,
-        name: impl Into<String>,
-        value: impl Into<Extern>,
-    ) -> Self {
-        self.add_imports([((namespace, name), value)]);
-        self
-    }
-
-    /// Add an item to the list of importable items provided to the instance.
-    pub fn add_import(
-        &mut self,
-        namespace: impl Into<String>,
-        name: impl Into<String>,
-        value: impl Into<Extern>,
-    ) {
-        self.add_imports([((namespace, name), value)]);
-    }
-
-    pub fn add_imports<I, S1, S2, E>(&mut self, imports: I)
-    where
-        I: IntoIterator<Item = ((S1, S2), E)>,
-        S1: Into<String>,
-        S2: Into<String>,
-        E: Into<Extern>,
-    {
-        let imports = imports
-            .into_iter()
-            .map(|((ns, n), e)| ((ns.into(), n.into()), e.into()));
-        self.additional_imports.extend(imports);
+    #[cfg(feature = "journal")]
+    pub fn with_stop_running_after_snapshot(&mut self, stop_running: bool) {
+        self.stop_running_after_snapshot = stop_running;
     }
 
-    pub fn imports<I, S1, S2, E>(mut self, imports: I) -> Self
-    where
-        I: IntoIterator<Item = ((S1, S2), E)>,
-        S1: Into<String>,
-        S2: Into<String>,
-        E: Into<Extern>,
-    {
-        self.add_imports(imports);
-        self
+    pub fn with_skip_stdio_during_bootstrap(&mut self, skip: bool) {
+        self.skip_stdio_during_bootstrap = skip;
     }
 
     /// Consumes the [`WasiEnvBuilder`] and produces a [`WasiEnvInit`], which
@@ -752,16 +811,13 @@ impl WasiEnvBuilder {
             }) {
                 Some(InvalidCharacter::Nul) => {
                     return Err(WasiStateCreationError::EnvironmentVariableFormatError(
-                        format!("found nul byte in env var key \"{}\" (key=value)", env_key),
+                        format!("found nul byte in env var key \"{env_key}\" (key=value)"),
                     ))
                 }
 
                 Some(InvalidCharacter::Equal) => {
                     return Err(WasiStateCreationError::EnvironmentVariableFormatError(
-                        format!(
-                            "found equal sign in env var key \"{}\" (key=value)",
-                            env_key
-                        ),
+                        format!("found equal sign in env var key \"{env_key}\" (key=value)"),
                     ))
                 }
 
@@ -778,13 +834,6 @@ impl WasiEnvBuilder {
             }
         }
 
-        // TODO: must be used! (runtime was removed from env, must ensure configured runtime is used)
-        // // Get a reference to the runtime
-        // let runtime = self
-        //     .runtime
-        //     .clone()
-        //     .unwrap_or_else(|| Arc::new(PluggableRuntimeImplementation::default()));
-
         // Determine the STDIN
         let stdin: Box<dyn VirtualFile + Send + Sync + 'static> = self
             .stdin
@@ -867,11 +916,12 @@ impl WasiEnvBuilder {
             fs: wasi_fs,
             secret: rand::thread_rng().gen::<[u8; 32]>(),
             inodes,
-            args: self.args.clone(),
+            args: std::sync::Mutex::new(self.args.clone()),
             preopen: self.vfs_preopens.clone(),
             futexs: Default::default(),
             clock_offset: Default::default(),
             envs: std::sync::Mutex::new(conv_env_vars(self.envs)),
+            signals: std::sync::Mutex::new(self.signals.iter().map(|s| (s.sig, s.disp)).collect()),
         };
 
         let runtime = self.runtime.unwrap_or_else(|| {
@@ -879,9 +929,26 @@ impl WasiEnvBuilder {
             {
                 #[allow(unused_mut)]
                 let mut runtime = crate::runtime::PluggableRuntime::new(Arc::new(crate::runtime::task_manager::tokio::TokioTaskManager::default()));
+                runtime.set_engine(
+                    self
+                        .engine
+                        .as_ref()
+                        .expect(
+                            "Neither a runtime nor an engine was provided to WasiEnvBuilder. \
+                            This is not supported because it means the module that's going to \
+                            run with the resulting WasiEnv will have been loaded using a \
+                            different engine than the one that will exist within the WasiEnv. \
+                            Use either `set_runtime` or `set_engine` before calling `build_init`.",
+                        )
+                        .clone()
+                );
+                #[cfg(feature = "journal")]
+                for journal in self.read_only_journals.clone() {
+                    runtime.add_read_only_journal(journal);
+                }
                 #[cfg(feature = "journal")]
-                for journal in self.journals.clone() {
-                    runtime.add_journal(journal);
+                for journal in self.writable_journals.clone() {
+                    runtime.add_writable_journal(journal);
                 }
                 Arc::new(runtime)
             }
@@ -918,14 +985,17 @@ impl WasiEnvBuilder {
             process: None,
             thread: None,
             #[cfg(feature = "journal")]
-            call_initialize: self.journals.is_empty(),
+            call_initialize: self.read_only_journals.is_empty()
+                && self.writable_journals.is_empty(),
             #[cfg(not(feature = "journal"))]
             call_initialize: true,
             can_deep_sleep: false,
             extra_tracing: true,
             #[cfg(feature = "journal")]
             snapshot_on: self.snapshot_on,
-            additional_imports: self.additional_imports,
+            #[cfg(feature = "journal")]
+            stop_running_after_snapshot: self.stop_running_after_snapshot,
+            skip_stdio_during_bootstrap: self.skip_stdio_during_bootstrap,
         };
 
         Ok(init)
@@ -933,7 +1003,7 @@ impl WasiEnvBuilder {
 
     #[allow(clippy::result_large_err)]
     pub fn build(self) -> Result<WasiEnv, WasiRuntimeError> {
-        let module_hash = self.module_hash.unwrap_or_else(xxhash_random);
+        let module_hash = self.module_hash.unwrap_or_else(ModuleHash::random);
         let init = self.build_init()?;
         WasiEnv::from_init(init, module_hash)
     }
@@ -948,7 +1018,7 @@ impl WasiEnvBuilder {
         self,
         store: &mut impl AsStoreMut,
     ) -> Result<WasiFunctionEnv, WasiRuntimeError> {
-        let module_hash = self.module_hash.unwrap_or_else(xxhash_random);
+        let module_hash = self.module_hash.unwrap_or_else(ModuleHash::random);
         let init = self.build_init()?;
         let env = WasiEnv::from_init(init, module_hash)?;
         let func_env = WasiFunctionEnv::new(store, env);
@@ -966,7 +1036,7 @@ impl WasiEnvBuilder {
         module: Module,
         store: &mut impl AsStoreMut,
     ) -> Result<(Instance, WasiFunctionEnv), WasiRuntimeError> {
-        self.instantiate_ext(module, xxhash_random(), store)
+        self.instantiate_ext(module, ModuleHash::random(), store)
     }
 
     #[allow(clippy::result_large_err)]
@@ -977,115 +1047,18 @@ impl WasiEnvBuilder {
         store: &mut impl AsStoreMut,
     ) -> Result<(Instance, WasiFunctionEnv), WasiRuntimeError> {
         let init = self.build_init()?;
-        WasiEnv::instantiate(init, module, module_hash, store)
-    }
-
-    #[allow(clippy::result_large_err)]
-    pub fn run(self, module: Module) -> Result<(), WasiRuntimeError> {
-        self.run_ext(module, xxhash_random())
-    }
-
-    #[allow(clippy::result_large_err)]
-    pub fn run_ext(self, module: Module, module_hash: ModuleHash) -> Result<(), WasiRuntimeError> {
-        let mut store = wasmer::Store::default();
-        self.run_with_store_ext(module, module_hash, &mut store)
-    }
-
-    #[allow(clippy::result_large_err)]
-    #[tracing::instrument(level = "debug", skip_all)]
-    pub fn run_with_store(self, module: Module, store: &mut Store) -> Result<(), WasiRuntimeError> {
-        self.run_with_store_ext(module, xxhash_random(), store)
-    }
-
-    #[allow(clippy::result_large_err)]
-    pub fn run_with_store_ext(
-        self,
-        module: Module,
-        module_hash: ModuleHash,
-        store: &mut Store,
-    ) -> Result<(), WasiRuntimeError> {
-        // If no handle or runtime exists then create one
-        #[cfg(feature = "sys-thread")]
-        let _guard = if tokio::runtime::Handle::try_current().is_err() {
-            let runtime = tokio::runtime::Builder::new_multi_thread()
-                .enable_all()
-                .build()
-                .unwrap();
-            Some(runtime)
-        } else {
-            None
-        };
-        #[cfg(feature = "sys-thread")]
-        let _guard = _guard.as_ref().map(|r| r.enter());
-
-        if self.capabilites.threading.enable_asynchronous_threading {
-            tracing::warn!(
-                "The enable_asynchronous_threading capability is enabled. Use WasiEnvBuilder::run_with_store_async() to avoid spurious errors.",
-            );
-        }
-
-        let (instance, env) = self.instantiate_ext(module, module_hash, store)?;
-
-        // Bootstrap the process
-        // Unsafe: The bootstrap must be executed in the same thread that runs the
-        //         actual WASM code
-        let rewind_state = unsafe { env.bootstrap(store)? };
-        if rewind_state.is_some() {
-            let mut ctx = env.env.clone().into_mut(store);
-            rewind_ext2(&mut ctx, rewind_state)
-                .map_err(|exit| WasiRuntimeError::Wasi(WasiError::Exit(exit)))?;
-        }
-
-        let start = instance.exports.get_function("_start")?;
-        env.data(&store).thread.set_status_running();
-
-        let result = crate::run_wasi_func_start(start, store);
-        let (result, exit_code) = super::wasi_exit_code(result);
-
-        let pid = env.data(&store).pid();
-        let tid = env.data(&store).tid();
-        tracing::trace!(
-            %pid,
-            %tid,
-            %exit_code,
-            error=result.as_ref().err().map(|e| e as &dyn std::error::Error),
-            "main exit",
-        );
-
-        env.on_exit(store, Some(exit_code));
-
-        result
-    }
-
-    /// Start the WASI executable with async threads enabled.
-    #[allow(clippy::result_large_err)]
-    #[tracing::instrument(level = "debug", skip_all)]
-    pub fn run_with_store_async(
-        self,
-        module: Module,
-        module_hash: ModuleHash,
-        mut store: Store,
-    ) -> Result<(), WasiRuntimeError> {
-        #[cfg(feature = "ctrlc")]
-        let attach_ctrl_c = self.attach_ctrl_c;
-
-        let (_, env) = self.instantiate_ext(module, module_hash, &mut store)?;
-
-        // Install the ctrl-c handler
-        #[cfg(feature = "ctrlc")]
-        if attach_ctrl_c {
-            tokio::spawn({
-                let process = env.data(&store).process.clone();
-                async move {
-                    while tokio::signal::ctrl_c().await.is_ok() {
-                        process.signal_process(wasmer_wasix_types::wasi::Signal::Sigint);
-                    }
-                }
-            });
-        }
-
-        env.run_async(store)?;
-        Ok(())
+        let call_init = init.call_initialize;
+        let env = WasiEnv::from_init(init, module_hash)?;
+        let memory = module
+            .imports()
+            .find_map(|i| match i.ty() {
+                wasmer::ExternType::Memory(ty) => Some(*ty),
+                _ => None,
+            })
+            .map(|ty| wasmer::Memory::new(store, ty))
+            .transpose()
+            .map_err(WasiThreadError::MemoryCreateFailed)?;
+        Ok(env.instantiate(module, store, memory, true, call_init, None)?)
     }
 }
 
@@ -1242,22 +1215,23 @@ mod test {
             "nul in key must be invalid"
         );
 
-        // `=` in the value is valid.
+        // `\0` in the value is invalid.
         assert!(
             WasiEnvBuilder::new("test_prog")
-                .env("HOME", "/home/home=home")
+                .env("HOME", "/home/home\0")
                 .build_init()
-                .is_ok(),
-            "equal sign in the value must be valid"
+                .is_err(),
+            "nul in value must be invalid"
         );
 
-        // `\0` in the value is invalid.
+        // `=` in the value is valid.
         assert!(
             WasiEnvBuilder::new("test_prog")
-                .env("HOME", "/home/home\0")
+                .env("HOME", "/home/home=home")
+                .engine(Engine::default())
                 .build_init()
-                .is_err(),
-            "nul in value must be invalid"
+                .is_ok(),
+            "equal sign in the value must be valid"
         );
     }
 
diff --git a/lib/wasix/src/state/env.rs b/lib/wasix/src/state/env.rs
index 452109aa71..b16dbdb6d6 100644
--- a/lib/wasix/src/state/env.rs
+++ b/lib/wasix/src/state/env.rs
@@ -2,18 +2,18 @@ use std::{
     collections::HashMap,
     ops::Deref,
     path::{Path, PathBuf},
+    str,
     sync::Arc,
     time::Duration,
 };
 
-use derivative::Derivative;
 use futures::future::BoxFuture;
 use rand::Rng;
-use virtual_fs::{FileSystem, FsError, StaticFile, VirtualFile};
+use virtual_fs::{FileSystem, FsError, VirtualFile};
 use virtual_net::DynVirtualNetworking;
 use wasmer::{
-    AsStoreMut, AsStoreRef, FunctionEnvMut, Global, Imports, Instance, Memory, MemoryType,
-    MemoryView, Module, TypedFunction,
+    AsStoreMut, AsStoreRef, ExportError, FunctionEnvMut, Instance, Memory, MemoryType, MemoryView,
+    Module,
 };
 use wasmer_config::package::PackageSource;
 use wasmer_wasix_types::{
@@ -21,11 +21,12 @@ use wasmer_wasix_types::{
     wasi::{Errno, ExitCode, Snapshot0Clockid},
     wasix::ThreadStartType,
 };
+use webc::metadata::annotations::Wasi;
 
 #[cfg(feature = "journal")]
 use crate::journal::{DynJournal, JournalEffector, SnapshotTrigger};
 use crate::{
-    bin_factory::{BinFactory, BinaryPackage},
+    bin_factory::{BinFactory, BinaryPackage, BinaryPackageCommand},
     capabilities::Capabilities,
     fs::{WasiFsRoot, WasiInodes},
     import_object_for_all_wasi_versions,
@@ -34,214 +35,15 @@ use crate::{
         process::{WasiProcess, WasiProcessId},
         thread::{WasiMemoryLayout, WasiThread, WasiThreadHandle, WasiThreadId},
     },
-    runtime::{task_manager::InlineWaker, SpawnMemoryType},
+    runtime::task_manager::InlineWaker,
     syscalls::platform_clock_time_get,
     Runtime, VirtualTaskManager, WasiControlPlane, WasiEnvBuilder, WasiError, WasiFunctionEnv,
-    WasiResult, WasiRuntimeError, WasiStateCreationError, WasiVFork,
+    WasiResult, WasiRuntimeError, WasiStateCreationError, WasiThreadError, WasiVFork,
 };
 use wasmer_types::ModuleHash;
 
-pub(crate) use super::handles::*;
-use super::WasiState;
-
-/// Various [`TypedFunction`] and [`Global`] handles for an active WASI(X) instance.
-///
-/// Used to access and modify runtime state.
-// TODO: make fields private
-#[derive(Derivative, Clone)]
-#[derivative(Debug)]
-pub struct WasiInstanceHandles {
-    // TODO: the two fields below are instance specific, while all others are module specific.
-    // Should be split up.
-    /// Represents a reference to the memory
-    pub(crate) memory: Memory,
-    pub(crate) instance: wasmer::Instance,
-
-    /// Points to the current location of the memory stack pointer
-    pub(crate) stack_pointer: Option<Global>,
-
-    /// Points to the end of the data section
-    pub(crate) data_end: Option<Global>,
-
-    /// Points to the lower end of the stack
-    pub(crate) stack_low: Option<Global>,
-
-    /// Points to the higher end of the stack
-    pub(crate) stack_high: Option<Global>,
-
-    /// Main function that will be invoked (name = "_start")
-    #[derivative(Debug = "ignore")]
-    pub(crate) start: Option<TypedFunction<(), ()>>,
-
-    /// Function thats invoked to initialize the WASM module (name = "_initialize")
-    #[derivative(Debug = "ignore")]
-    // TODO: review allow...
-    #[allow(dead_code)]
-    pub(crate) initialize: Option<TypedFunction<(), ()>>,
-
-    /// Represents the callback for spawning a thread (name = "wasi_thread_start")
-    /// (due to limitations with i64 in browsers the parameters are broken into i32 pairs)
-    /// [this takes a user_data field]
-    #[derivative(Debug = "ignore")]
-    pub(crate) thread_spawn: Option<TypedFunction<(i32, i32), ()>>,
-
-    /// Represents the callback for signals (name = "__wasm_signal")
-    /// Signals are triggered asynchronously at idle times of the process
-    #[derivative(Debug = "ignore")]
-    pub(crate) signal: Option<TypedFunction<i32, ()>>,
-
-    /// Flag that indicates if the signal callback has been set by the WASM
-    /// process - if it has not been set then the runtime behaves differently
-    /// when a CTRL-C is pressed.
-    pub(crate) signal_set: bool,
-
-    /// Flag that indicates if the stack capture exports are being used by
-    /// this WASM process which means that it will be using asyncify
-    pub(crate) has_stack_checkpoint: bool,
-
-    /// asyncify_start_unwind(data : i32): call this to start unwinding the
-    /// stack from the current location. "data" must point to a data
-    /// structure as described above (with fields containing valid data).
-    #[derivative(Debug = "ignore")]
-    // TODO: review allow...
-    #[allow(dead_code)]
-    pub(crate) asyncify_start_unwind: Option<TypedFunction<i32, ()>>,
-
-    /// asyncify_stop_unwind(): call this to note that unwinding has
-    /// concluded. If no other code will run before you start to rewind,
-    /// this is not strictly necessary, however, if you swap between
-    /// coroutines, or even just want to run some normal code during a
-    /// "sleep", then you must call this at the proper time. Otherwise,
-    /// the code will think it is still unwinding when it should not be,
-    /// which means it will keep unwinding in a meaningless way.
-    #[derivative(Debug = "ignore")]
-    // TODO: review allow...
-    #[allow(dead_code)]
-    pub(crate) asyncify_stop_unwind: Option<TypedFunction<(), ()>>,
-
-    /// asyncify_start_rewind(data : i32): call this to start rewinding the
-    /// stack vack up to the location stored in the provided data. This prepares
-    /// for the rewind; to start it, you must call the first function in the
-    /// call stack to be unwound.
-    #[derivative(Debug = "ignore")]
-    // TODO: review allow...
-    #[allow(dead_code)]
-    pub(crate) asyncify_start_rewind: Option<TypedFunction<i32, ()>>,
-
-    /// asyncify_stop_rewind(): call this to note that rewinding has
-    /// concluded, and normal execution can resume.
-    #[derivative(Debug = "ignore")]
-    // TODO: review allow...
-    #[allow(dead_code)]
-    pub(crate) asyncify_stop_rewind: Option<TypedFunction<(), ()>>,
-
-    /// asyncify_get_state(): call this to get the current value of the
-    /// internal "__asyncify_state" variable as described above.
-    /// It can be used to distinguish between unwinding/rewinding and normal
-    /// calls, so that you know when to start an asynchronous operation and
-    /// when to propagate results back.
-    #[allow(dead_code)]
-    #[derivative(Debug = "ignore")]
-    pub(crate) asyncify_get_state: Option<TypedFunction<(), i32>>,
-}
-
-impl WasiInstanceHandles {
-    pub fn new(memory: Memory, store: &impl AsStoreRef, instance: Instance) -> Self {
-        let has_stack_checkpoint = instance
-            .module()
-            .imports()
-            .any(|f| f.name() == "stack_checkpoint");
-        WasiInstanceHandles {
-            memory,
-            stack_pointer: instance
-                .exports
-                .get_global("__stack_pointer")
-                .map(|a| a.clone())
-                .ok(),
-            data_end: instance
-                .exports
-                .get_global("__data_end")
-                .map(|a| a.clone())
-                .ok(),
-            stack_low: instance
-                .exports
-                .get_global("__stack_low")
-                .map(|a| a.clone())
-                .ok(),
-            stack_high: instance
-                .exports
-                .get_global("__stack_high")
-                .map(|a| a.clone())
-                .ok(),
-            start: instance.exports.get_typed_function(store, "_start").ok(),
-            initialize: instance
-                .exports
-                .get_typed_function(store, "_initialize")
-                .ok(),
-            thread_spawn: instance
-                .exports
-                .get_typed_function(store, "wasi_thread_start")
-                .ok(),
-            signal: instance
-                .exports
-                .get_typed_function(&store, "__wasm_signal")
-                .ok(),
-            has_stack_checkpoint,
-            signal_set: false,
-            asyncify_start_unwind: instance
-                .exports
-                .get_typed_function(store, "asyncify_start_unwind")
-                .ok(),
-            asyncify_stop_unwind: instance
-                .exports
-                .get_typed_function(store, "asyncify_stop_unwind")
-                .ok(),
-            asyncify_start_rewind: instance
-                .exports
-                .get_typed_function(store, "asyncify_start_rewind")
-                .ok(),
-            asyncify_stop_rewind: instance
-                .exports
-                .get_typed_function(store, "asyncify_stop_rewind")
-                .ok(),
-            asyncify_get_state: instance
-                .exports
-                .get_typed_function(store, "asyncify_get_state")
-                .ok(),
-            instance,
-        }
-    }
-
-    pub fn module(&self) -> &Module {
-        self.instance.module()
-    }
-
-    pub fn module_clone(&self) -> Module {
-        self.instance.module().clone()
-    }
-
-    /// Providers safe access to the memory
-    /// (it must be initialized before it can be used)
-    pub fn memory_view<'a>(&'a self, store: &'a (impl AsStoreRef + ?Sized)) -> MemoryView<'a> {
-        self.memory.view(store)
-    }
-
-    /// Providers safe access to the memory
-    /// (it must be initialized before it can be used)
-    pub fn memory(&self) -> &Memory {
-        &self.memory
-    }
-
-    /// Copy the lazy reference so that when it's initialized during the
-    /// export phase, all the other references get a copy of it
-    pub fn memory_clone(&self) -> Memory {
-        self.memory.clone()
-    }
-
-    pub fn instance(&self) -> &Instance {
-        &self.instance
-    }
-}
+pub use super::handles::*;
+use super::{conv_env_vars, Linker, WasiState};
 
 /// Data required to construct a [`WasiEnv`].
 #[derive(Debug)]
@@ -268,13 +70,16 @@ pub struct WasiEnvInit {
     /// Indicates if extra tracing should be output
     pub extra_tracing: bool,
 
-    /// Additional functionality provided to the WASIX instance, besides the
-    /// normal WASIX syscalls.
-    pub additional_imports: Imports,
-
     /// Indicates triggers that will cause a snapshot to be taken
     #[cfg(feature = "journal")]
     pub snapshot_on: Vec<SnapshotTrigger>,
+
+    /// Stop running after the first snapshot is taken
+    #[cfg(feature = "journal")]
+    pub stop_running_after_snapshot: bool,
+
+    /// Skip writes to stdout and stderr when bootstrapping from a journal
+    pub skip_stdio_during_bootstrap: bool,
 }
 
 impl WasiEnvInit {
@@ -295,8 +100,9 @@ impl WasiEnvInit {
                 clock_offset: std::sync::Mutex::new(
                     self.state.clock_offset.lock().unwrap().clone(),
                 ),
-                args: self.state.args.clone(),
+                args: std::sync::Mutex::new(self.state.args.lock().unwrap().clone()),
                 envs: std::sync::Mutex::new(self.state.envs.lock().unwrap().deref().clone()),
+                signals: std::sync::Mutex::new(self.state.signals.lock().unwrap().deref().clone()),
                 preopen: self.state.preopen.clone(),
             },
             runtime: self.runtime.clone(),
@@ -313,7 +119,9 @@ impl WasiEnvInit {
             extra_tracing: false,
             #[cfg(feature = "journal")]
             snapshot_on: self.snapshot_on.clone(),
-            additional_imports: self.additional_imports.clone(),
+            #[cfg(feature = "journal")]
+            stop_running_after_snapshot: self.stop_running_after_snapshot,
+            skip_stdio_during_bootstrap: self.skip_stdio_during_bootstrap,
         }
     }
 }
@@ -359,6 +167,9 @@ pub struct WasiEnv {
     /// (and hence it should not record new events)
     pub replaying_journal: bool,
 
+    /// Should stdio be skipped when bootstrapping this module from an existing journal?
+    pub skip_stdio_during_bootstrap: bool,
+
     /// Flag that indicates the cleanup of the environment is to be disabled
     /// (this is normally used so that the instance can be reused later on)
     pub(crate) disable_fs_cleanup: bool,
@@ -395,6 +206,7 @@ impl Clone for WasiEnv {
             enable_journal: self.enable_journal,
             enable_exponential_cpu_backoff: self.enable_exponential_cpu_backoff,
             replaying_journal: self.replaying_journal,
+            skip_stdio_during_bootstrap: self.skip_stdio_during_bootstrap,
             disable_fs_cleanup: self.disable_fs_cleanup,
         }
     }
@@ -435,6 +247,7 @@ impl WasiEnv {
             enable_journal: self.enable_journal,
             enable_exponential_cpu_backoff: self.enable_exponential_cpu_backoff,
             replaying_journal: false,
+            skip_stdio_during_bootstrap: self.skip_stdio_during_bootstrap,
             disable_fs_cleanup: self.disable_fs_cleanup,
         };
         Ok((new_env, handle))
@@ -451,7 +264,10 @@ impl WasiEnv {
     /// Returns true if this WASM process will need and try to use
     /// asyncify while its running which normally means.
     pub fn will_use_asyncify(&self) -> bool {
-        self.enable_deep_sleep || unsafe { self.inner().has_stack_checkpoint }
+        self.inner()
+            .static_module_instance_handles()
+            .map(|handles| self.enable_deep_sleep || handles.has_stack_checkpoint)
+            .unwrap_or(false)
     }
 
     /// Re-initializes this environment so that it can be executed again
@@ -466,7 +282,6 @@ impl WasiEnv {
                 map.clear();
             }
             self.state.fs.preopen_fds.write().unwrap().clear();
-            self.state.fs.next_fd.set_val(3);
             *self.state.fs.current_dir.lock().unwrap() = "/".to_string();
 
             // We need to rebuild the basic file descriptors
@@ -503,7 +318,7 @@ impl WasiEnv {
     }
 
     /// Returns true if this module is capable of deep sleep
-    /// (needs asyncify to unwind and rewin)
+    /// (needs asyncify to unwind and rewind)
     ///
     /// # Safety
     ///
@@ -513,10 +328,14 @@ impl WasiEnv {
         if !self.control_plane.config().enable_asynchronous_threading {
             return false;
         }
-        let inner = self.inner();
-        inner.asyncify_get_state.is_some()
-            && inner.asyncify_start_rewind.is_some()
-            && inner.asyncify_start_unwind.is_some()
+        self.inner()
+            .static_module_instance_handles()
+            .map(|handles| {
+                handles.asyncify_get_state.is_some()
+                    && handles.asyncify_start_rewind.is_some()
+                    && handles.asyncify_start_unwind.is_some()
+            })
+            .unwrap_or(false)
     }
 
     /// Returns true if this thread can go into a deep sleep
@@ -537,7 +356,9 @@ impl WasiEnv {
 
         #[cfg(feature = "journal")]
         {
-            process.inner.0.lock().unwrap().snapshot_on = init.snapshot_on.into_iter().collect();
+            let mut guard = process.inner.0.lock().unwrap();
+            guard.snapshot_on = init.snapshot_on.into_iter().collect();
+            guard.stop_running_after_checkpoint = init.stop_running_after_snapshot;
         }
 
         let layout = WasiMemoryLayout::default();
@@ -562,6 +383,7 @@ impl WasiEnv {
             #[cfg(not(feature = "journal"))]
             enable_journal: false,
             replaying_journal: false,
+            skip_stdio_during_bootstrap: init.skip_stdio_during_bootstrap,
             enable_deep_sleep: init.capabilities.threading.enable_asynchronous_threading,
             enable_exponential_cpu_backoff: init
                 .capabilities
@@ -588,56 +410,81 @@ impl WasiEnv {
     // FIXME: use custom error type
     #[allow(clippy::result_large_err)]
     pub(crate) fn instantiate(
-        mut init: WasiEnvInit,
+        self,
         module: Module,
-        module_hash: ModuleHash,
         store: &mut impl AsStoreMut,
-    ) -> Result<(Instance, WasiFunctionEnv), WasiRuntimeError> {
-        let call_initialize = init.call_initialize;
-        let spawn_type = init.memory_ty.take();
-
-        if init.extra_tracing {
-            for import in module.imports() {
-                tracing::trace!("import {}.{}", import.module(), import.name());
-            }
-        }
-
-        let additional_imports = init.additional_imports.clone();
-
-        let env = Self::from_init(init, module_hash)?;
-        let pid = env.process.pid();
+        memory: Option<Memory>,
+        update_layout: bool,
+        call_initialize: bool,
+        parent_linker_and_ctx: Option<(Linker, &mut FunctionEnvMut<WasiEnv>)>,
+    ) -> Result<(Instance, WasiFunctionEnv), WasiThreadError> {
+        let pid = self.process.pid();
 
         let mut store = store.as_store_mut();
+        let engine = self.runtime().engine();
+        let mut func_env = WasiFunctionEnv::new(&mut store, self);
+
+        let is_dl = super::linker::is_dynamically_linked(&module);
+        if is_dl {
+            let linker = match parent_linker_and_ctx {
+                Some((linker, ctx)) => linker.create_instance_group(ctx, &mut store, &mut func_env),
+                None => {
+                    // FIXME: should we be storing envs as raw byte arrays?
+                    let ld_library_path_owned;
+                    let ld_library_path = {
+                        let envs = func_env.data(&store).state.envs.lock().unwrap();
+                        ld_library_path_owned = match envs
+                            .iter()
+                            .find_map(|env| env.strip_prefix(b"LD_LIBRARY_PATH="))
+                        {
+                            Some(path) => path
+                                .split(|b| *b == b':')
+                                .filter_map(|p| str::from_utf8(p).ok())
+                                .map(PathBuf::from)
+                                .collect::<Vec<_>>(),
+                            None => vec![],
+                        };
+                        ld_library_path_owned
+                            .iter()
+                            .map(AsRef::as_ref)
+                            .collect::<Vec<_>>()
+                    };
+
+                    // TODO: make stack size configurable
+                    Linker::new(
+                        engine,
+                        &module,
+                        &mut store,
+                        memory,
+                        &mut func_env,
+                        8 * 1024 * 1024,
+                        &ld_library_path,
+                    )
+                }
+            };
 
-        let tasks = env.runtime.task_manager().clone();
-        let mut func_env = WasiFunctionEnv::new(&mut store, env);
-
-        // Determine if shared memory needs to be created and imported
-        let shared_memory = module.imports().memories().next().map(|a| *a.ty());
-
-        // Determine if we are going to create memory and import it or just rely on self creation of memory
-        let spawn_type = if let Some(t) = spawn_type {
-            SpawnMemoryType::CreateMemoryOfType(t)
-        } else {
-            match shared_memory {
-                Some(ty) => SpawnMemoryType::CreateMemoryOfType(ty),
-                None => SpawnMemoryType::CreateMemory,
+            match linker {
+                Ok((_, linked_module)) => {
+                    return Ok((linked_module.instance, func_env));
+                }
+                Err(e) => {
+                    tracing::error!(
+                        %pid,
+                        error = &e as &dyn std::error::Error,
+                        "Failed to link DL main module",
+                    );
+                    func_env
+                        .data(&store)
+                        .blocking_on_exit(Some(Errno::Noexec.into()));
+                    return Err(WasiThreadError::LinkError(Arc::new(e)));
+                }
             }
-        };
-        let memory = tasks.build_memory(&mut store, spawn_type)?;
+        }
 
         // Let's instantiate the module with the imports.
-        let (mut import_object, instance_init_callback) =
+        let mut import_object =
             import_object_for_all_wasi_versions(&module, &mut store, &func_env.env);
 
-        for ((namespace, name), value) in &additional_imports {
-            // Note: We don't want to let downstream users override WASIX
-            // syscalls
-            if !import_object.exists(&namespace, &name) {
-                import_object.define(&namespace, &name, value);
-            }
-        }
-
         let imported_memory = if let Some(memory) = memory {
             import_object.define("env", "memory", memory.clone());
             Some(memory)
@@ -657,17 +504,49 @@ impl WasiEnv {
                 func_env
                     .data(&store)
                     .blocking_on_exit(Some(Errno::Noexec.into()));
-                return Err(err.into());
+                return Err(WasiThreadError::InstanceCreateFailed(Box::new(err)));
             }
         };
 
-        // Run initializers.
-        instance_init_callback(&instance, &store).unwrap();
+        let handles = match imported_memory {
+            Some(memory) => WasiModuleTreeHandles::Static(WasiModuleInstanceHandles::new(
+                memory,
+                &store,
+                instance.clone(),
+                None,
+            )),
+            None => {
+                let exported_memory = instance
+                    .exports
+                    .iter()
+                    .filter_map(|(_, export)| {
+                        if let wasmer::Extern::Memory(memory) = export {
+                            Some(memory.clone())
+                        } else {
+                            None
+                        }
+                    })
+                    .next()
+                    .ok_or(WasiThreadError::ExportError(ExportError::Missing(
+                        "No imported or exported memory found".to_owned(),
+                    )))?;
+                WasiModuleTreeHandles::Static(WasiModuleInstanceHandles::new(
+                    exported_memory,
+                    &store,
+                    instance.clone(),
+                    None,
+                ))
+            }
+        };
 
         // Initialize the WASI environment
-        if let Err(err) =
-            func_env.initialize_with_memory(&mut store, instance.clone(), imported_memory, true)
-        {
+        if let Err(err) = func_env.initialize_handles_and_layout(
+            &mut store,
+            instance.clone(),
+            handles,
+            None,
+            update_layout,
+        ) {
             tracing::error!(
                 %pid,
                 error = &err as &dyn std::error::Error,
@@ -676,7 +555,7 @@ impl WasiEnv {
             func_env
                 .data(&store)
                 .blocking_on_exit(Some(Errno::Noexec.into()));
-            return Err(err.into());
+            return Err(WasiThreadError::ExportError(err));
         }
 
         // If this module exports an _initialize function, run that first.
@@ -686,7 +565,9 @@ impl WasiEnv {
                     func_env
                         .data(&store)
                         .blocking_on_exit(Some(Errno::Noexec.into()));
-                    return Err(err);
+                    return Err(WasiThreadError::InitFailed(Arc::new(anyhow::Error::from(
+                        err,
+                    ))));
                 }
             }
         }
@@ -721,14 +602,36 @@ impl WasiEnv {
         self.process.active_threads()
     }
 
+    /// Called by most (if not all) syscalls to process pending operations that are
+    /// cross-cutting, such as signals, thread/process exit, DL operations, etc.
+    pub fn do_pending_operations(ctx: &mut FunctionEnvMut<'_, Self>) -> Result<(), WasiError> {
+        Self::do_pending_link_operations(ctx, true)?;
+        _ = Self::process_signals_and_exit(ctx)?;
+        Ok(())
+    }
+
+    pub fn do_pending_link_operations(
+        ctx: &mut FunctionEnvMut<'_, Self>,
+        fast: bool,
+    ) -> Result<(), WasiError> {
+        if let Some(linker) = ctx.data().inner().linker().cloned() {
+            if let Err(e) = linker.do_pending_link_operations(ctx, fast) {
+                tracing::warn!(err = ?e, "Failed to process pending link operations");
+                return Err(WasiError::Exit(Errno::Noexec.into()));
+            }
+        }
+        Ok(())
+    }
+
     /// Porcesses any signals that are batched up or any forced exit codes
     pub fn process_signals_and_exit(ctx: &mut FunctionEnvMut<'_, Self>) -> WasiResult<bool> {
         // If a signal handler has never been set then we need to handle signals
         // differently
         let env = ctx.data();
-        let inner = env
+        let env_inner = env
             .try_inner()
             .ok_or_else(|| WasiError::Exit(Errno::Fault.into()))?;
+        let inner = env_inner.main_module_instance_handles();
         if !inner.signal_set {
             let signals = env.thread.pop_signals();
             if !signals.is_empty() {
@@ -737,6 +640,7 @@ impl WasiEnv {
                         || sig == Signal::Sigquit
                         || sig == Signal::Sigkill
                         || sig == Signal::Sigabrt
+                        || sig == Signal::Sigpipe
                     {
                         let exit_code = env.thread.set_or_get_exit_code_for_signal(sig);
                         return Err(WasiError::Exit(exit_code));
@@ -761,9 +665,10 @@ impl WasiEnv {
         // If a signal handler has never been set then we need to handle signals
         // differently
         let env = ctx.data();
-        let inner = env
+        let env_inner = env
             .try_inner()
             .ok_or_else(|| WasiError::Exit(Errno::Fault.into()))?;
+        let inner = env_inner.main_module_instance_handles();
         if !inner.signal_set {
             return Ok(Ok(false));
         }
@@ -785,9 +690,10 @@ impl WasiEnv {
         mut signals: Vec<Signal>,
     ) -> Result<bool, WasiError> {
         let env = ctx.data();
-        let inner = env
+        let env_inner = env
             .try_inner()
             .ok_or_else(|| WasiError::Exit(Errno::Fault.into()))?;
+        let inner = env_inner.main_module_instance_handles();
         if let Some(handler) = inner.signal.clone() {
             // We might also have signals that trigger on timers
             let mut now = 0;
@@ -818,6 +724,11 @@ impl WasiEnv {
             }
 
             for signal in signals {
+                // Skip over Sigwakeup, which is host-side-only
+                if matches!(signal, Signal::Sigwakeup) {
+                    continue;
+                }
+
                 tracing::trace!(
                     pid=%ctx.data().pid(),
                     ?signal,
@@ -890,14 +801,20 @@ impl WasiEnv {
 
     /// Providers safe access to the initialized part of WasiEnv
     /// (it must be initialized before it can be used)
-    /// This has been marked as unsafe as it will panic if its executed
-    /// on the wrong thread or before the inner is set
-    pub(crate) unsafe fn inner(&self) -> WasiInstanceGuard<'_> {
+    pub(crate) fn inner(&self) -> WasiInstanceGuard<'_> {
         self.inner.get().expect(
             "You must initialize the WasiEnv before using it and can not pass it between threads",
         )
     }
 
+    /// Provides safe access to the initialized part of WasiEnv
+    /// (it must be initialized before it can be used)
+    pub(crate) fn inner_mut(&mut self) -> WasiInstanceGuardMut<'_> {
+        self.inner.get_mut().expect(
+            "You must initialize the WasiEnv before using it and can not pass it between threads",
+        )
+    }
+
     /// Providers safe access to the initialized part of WasiEnv
     pub(crate) fn try_inner(&self) -> Option<WasiInstanceGuard<'_>> {
         self.inner.get()
@@ -905,6 +822,7 @@ impl WasiEnv {
 
     /// Providers safe access to the initialized part of WasiEnv
     /// (it must be initialized before it can be used)
+    #[allow(dead_code)]
     pub(crate) fn try_inner_mut(&mut self) -> Option<WasiInstanceGuardMut<'_>> {
         self.inner.get_mut()
     }
@@ -913,7 +831,7 @@ impl WasiEnv {
     /// creating the instance and eventually should be moved out
     /// of the WasiEnv)
     #[doc(hidden)]
-    pub(crate) fn set_inner(&mut self, handles: WasiInstanceHandles) {
+    pub(crate) fn set_inner(&mut self, handles: WasiModuleTreeHandles) {
         self.inner.set(handles)
     }
 
@@ -925,22 +843,38 @@ impl WasiEnv {
         std::mem::swap(&mut self.inner, &mut other.inner);
     }
 
-    /// Tries to clone the instance from this environment
+    /// Helper function to ensure the module isn't dynamically linked, needed since
+    /// we only support a subset of WASIX functionality for dynamically linked modules.
+    /// Specifically, anything that requires asyncify is not supported right now.
+    pub(crate) fn ensure_static_module(&self) -> Result<(), ()> {
+        self.inner.get().unwrap().ensure_static_module()
+    }
+
+    /// Tries to clone the instance from this environment, but only if it's a static
+    /// module, since dynamically linked modules are made up of multiple instances.
     pub fn try_clone_instance(&self) -> Option<Instance> {
-        self.inner.get().map(|i| i.instance.clone())
+        let guard = self.inner.get();
+        match guard {
+            Some(guard) => guard
+                .static_module_instance_handles()
+                .map(|instance| instance.instance.clone()),
+            None => None,
+        }
     }
 
     /// Providers safe access to the memory
     /// (it must be initialized before it can be used)
-    pub(crate) fn try_memory(&self) -> Option<WasiInstanceGuardMemory<'_>> {
+    pub fn try_memory(&self) -> Option<WasiInstanceGuardMemory<'_>> {
         self.try_inner().map(|i| i.memory())
     }
 
     /// Providers safe access to the memory
     /// (it must be initialized before it can be used)
+    ///
+    /// # Safety
     /// This has been marked as unsafe as it will panic if its executed
     /// on the wrong thread or before the inner is set
-    pub(crate) unsafe fn memory(&self) -> WasiInstanceGuardMemory<'_> {
+    pub unsafe fn memory(&self) -> WasiInstanceGuardMemory<'_> {
         self.try_memory().expect(
             "You must initialize the WasiEnv before using it and can not pass it between threads",
         )
@@ -948,7 +882,7 @@ impl WasiEnv {
 
     /// Providers safe access to the memory
     /// (it must be initialized before it can be used)
-    pub(crate) fn try_memory_view<'a>(
+    pub fn try_memory_view<'a>(
         &self,
         store: &'a (impl AsStoreRef + ?Sized),
     ) -> Option<MemoryView<'a>> {
@@ -957,12 +891,11 @@ impl WasiEnv {
 
     /// Providers safe access to the memory
     /// (it must be initialized before it can be used)
+    ///
+    /// # Safety
     /// This has been marked as unsafe as it will panic if its executed
     /// on the wrong thread or before the inner is set
-    pub(crate) unsafe fn memory_view<'a>(
-        &self,
-        store: &'a (impl AsStoreRef + ?Sized),
-    ) -> MemoryView<'a> {
+    pub unsafe fn memory_view<'a>(&self, store: &'a (impl AsStoreRef + ?Sized)) -> MemoryView<'a> {
         self.try_memory_view(store).expect(
             "You must initialize the WasiEnv before using it and can not pass it between threads",
         )
@@ -972,7 +905,8 @@ impl WasiEnv {
     /// export phase, all the other references get a copy of it
     #[allow(dead_code)]
     pub(crate) fn try_memory_clone(&self) -> Option<Memory> {
-        self.try_inner().map(|i| i.memory_clone())
+        self.try_inner()
+            .map(|i| i.main_module_instance_handles().memory_clone())
     }
 
     /// Get the WASI state
@@ -1051,7 +985,7 @@ impl WasiEnv {
         &'a self,
         store: &'a impl AsStoreRef,
         _mem_index: u32,
-    ) -> (MemoryView<'a>, &WasiState) {
+    ) -> (MemoryView<'a>, &'a WasiState) {
         let memory = self.memory_view(store);
         let state = self.state.deref();
         (memory, state)
@@ -1066,7 +1000,7 @@ impl WasiEnv {
         &'a self,
         store: &'a impl AsStoreRef,
         _mem_index: u32,
-    ) -> (MemoryView<'a>, &WasiState, &WasiInodes) {
+    ) -> (MemoryView<'a>, &'a WasiState, &'a WasiInodes) {
         let memory = self.memory_view(store);
         let state = self.state.deref();
         let inodes = &state.inodes;
@@ -1079,6 +1013,10 @@ impl WasiEnv {
         (state, inodes)
     }
 
+    pub fn use_package(&self, pkg: &BinaryPackage) -> Result<(), WasiStateCreationError> {
+        InlineWaker::block_on(self.use_package_async(pkg))
+    }
+
     /// Make all the commands in a [`BinaryPackage`] available to the WASI
     /// instance.
     ///
@@ -1090,13 +1028,16 @@ impl WasiEnv {
     ///
     /// [cmd-atom]: crate::bin_factory::BinaryPackageCommand::atom()
     /// [pkg-fs]: crate::bin_factory::BinaryPackage::webc_fs
-    pub fn use_package(&self, pkg: &BinaryPackage) -> Result<(), WasiStateCreationError> {
+    pub async fn use_package_async(
+        &self,
+        pkg: &BinaryPackage,
+    ) -> Result<(), WasiStateCreationError> {
         tracing::trace!(package=%pkg.id, "merging package dependency into wasi environment");
         let root_fs = &self.state.fs.root_fs;
 
         // We first need to merge the filesystem in the package into the
         // main file system, if it has not been merged already.
-        if let Err(e) = InlineWaker::block_on(self.state.fs.conditional_union(pkg)) {
+        if let Err(e) = self.state.fs.conditional_union(pkg).await {
             tracing::warn!(
                 error = &e as &dyn std::error::Error,
                 "Unable to merge the package's filesystem into the main one",
@@ -1107,33 +1048,32 @@ impl WasiEnv {
 
         if !pkg.commands.is_empty() {
             let _ = root_fs.create_dir(Path::new("/bin"));
+            let _ = root_fs.create_dir(Path::new("/usr"));
+            let _ = root_fs.create_dir(Path::new("/usr/bin"));
 
             for command in &pkg.commands {
                 let path = format!("/bin/{}", command.name());
+                let path2 = format!("/usr/bin/{}", command.name());
                 let path = Path::new(path.as_str());
+                let path2 = Path::new(path2.as_str());
 
-                // FIXME(Michael-F-Bryan): This is pretty sketchy.
-                // We should be using some sort of reference-counted
-                // pointer to some bytes that are either on the heap
-                // or from a memory-mapped file. However, that's not
-                // possible here because things like memfs and
-                // WasiEnv are expecting a Cow<'static, [u8]>. It's
-                // too hard to refactor those at the moment, and we
-                // were pulling the same trick before by storing an
-                // "ownership" object in the BinaryPackageCommand,
-                // so as long as packages aren't removed from the
-                // module cache it should be fine.
-                // See https://github.com/wasmerio/wasmer/issues/3875
-                let atom: &'static [u8] = unsafe { std::mem::transmute(command.atom()) };
+                let atom = command.atom();
 
                 match root_fs {
                     WasiFsRoot::Sandbox(root_fs) => {
-                        // As a short-cut, when we are using a TmpFileSystem
-                        // we can (unsafely) add the file to the filesystem
-                        // without any copying.
                         if let Err(err) = root_fs
                             .new_open_options_ext()
-                            .insert_ro_file(path, atom.into())
+                            .insert_ro_file(path, atom.clone())
+                        {
+                            tracing::debug!(
+                                "failed to add package [{}] command [{}] - {}",
+                                pkg.id,
+                                command.name(),
+                                err
+                            );
+                            continue;
+                        }
+                        if let Err(err) = root_fs.new_open_options_ext().insert_ro_file(path2, atom)
                         {
                             tracing::debug!(
                                 "failed to add package [{}] command [{}] - {}",
@@ -1145,10 +1085,17 @@ impl WasiEnv {
                         }
                     }
                     WasiFsRoot::Backing(fs) => {
+                        // FIXME: we're counting on the fs being a mem_fs here. Otherwise, memory
+                        // usage will be very high.
                         let mut f = fs.new_open_options().create(true).write(true).open(path)?;
-                        if let Err(e) =
-                            InlineWaker::block_on(f.copy_reference(Box::new(StaticFile::new(atom))))
-                        {
+                        if let Err(e) = f.copy_from_owned_buffer(&atom).await {
+                            tracing::warn!(
+                                error = &e as &dyn std::error::Error,
+                                "Unable to copy file reference",
+                            );
+                        }
+                        let mut f = fs.new_open_options().create(true).write(true).open(path2)?;
+                        if let Err(e) = f.copy_from_owned_buffer(&atom).await {
                             tracing::warn!(
                                 error = &e as &dyn std::error::Error,
                                 "Unable to copy file reference",
@@ -1185,15 +1132,13 @@ impl WasiEnv {
         for package_name in uses {
             let specifier = package_name.parse::<PackageSource>().map_err(|e| {
                 WasiStateCreationError::WasiIncludePackageError(format!(
-                    "package_name={package_name}, {}",
-                    e
+                    "package_name={package_name}, {e}",
                 ))
             })?;
             let pkg = InlineWaker::block_on(BinaryPackage::from_registry(&specifier, rt)).map_err(
                 |e| {
                     WasiStateCreationError::WasiIncludePackageError(format!(
-                        "package_name={package_name}, {}",
-                        e
+                        "package_name={package_name}, {e}",
                     ))
                 },
             )?;
@@ -1212,6 +1157,7 @@ impl WasiEnv {
         #[allow(unused_imports)]
         use std::path::Path;
 
+        use shared_buffer::OwnedBuffer;
         #[allow(unused_imports)]
         use virtual_fs::FileSystem;
 
@@ -1225,12 +1171,23 @@ impl WasiEnv {
                     err
                 ))
             })?;
-            let file: std::borrow::Cow<'static, [u8]> = file.into();
+            let file = OwnedBuffer::from(file);
 
             if let WasiFsRoot::Sandbox(root_fs) = &self.state.fs.root_fs {
                 let _ = root_fs.create_dir(Path::new("/bin"));
+                let _ = root_fs.create_dir(Path::new("/usr"));
+                let _ = root_fs.create_dir(Path::new("/usr/bin"));
 
-                let path = format!("/bin/{}", command);
+                let path = format!("/bin/{command}");
+                let path = Path::new(path.as_str());
+                if let Err(err) = root_fs
+                    .new_open_options_ext()
+                    .insert_ro_file(path, file.clone())
+                {
+                    tracing::debug!("failed to add atom command [{}] - {}", command, err);
+                    continue;
+                }
+                let path = format!("/usr/bin/{command}");
                 let path = Path::new(path.as_str());
                 if let Err(err) = root_fs.new_open_options_ext().insert_ro_file(path, file) {
                     tracing::debug!("failed to add atom command [{}] - {}", command, err);
@@ -1246,32 +1203,33 @@ impl WasiEnv {
 
     /// Cleans up all the open files (if this is the main thread)
     #[allow(clippy::await_holding_lock)]
-    pub fn blocking_on_exit(&self, exit_code: Option<ExitCode>) {
-        let cleanup = self.on_exit(exit_code);
+    pub fn blocking_on_exit(&self, process_exit_code: Option<ExitCode>) {
+        let cleanup = self.on_exit(process_exit_code);
         InlineWaker::block_on(cleanup);
     }
 
     /// Cleans up all the open files (if this is the main thread)
     #[allow(clippy::await_holding_lock)]
-    pub fn on_exit(&self, exit_code: Option<ExitCode>) -> BoxFuture<'static, ()> {
+    pub fn on_exit(&self, process_exit_code: Option<ExitCode>) -> BoxFuture<'static, ()> {
         const CLEANUP_TIMEOUT: Duration = Duration::from_secs(10);
 
         // If snap-shooting is enabled then we should record an event that the thread has exited.
         #[cfg(feature = "journal")]
         if self.should_journal() && self.has_active_journal() {
-            if let Err(err) = JournalEffector::save_thread_exit(self, self.tid(), exit_code) {
+            if let Err(err) = JournalEffector::save_thread_exit(self, self.tid(), process_exit_code)
+            {
                 tracing::warn!("failed to save snapshot event for thread exit - {}", err);
             }
 
             if self.thread.is_main() {
-                if let Err(err) = JournalEffector::save_process_exit(self, exit_code) {
+                if let Err(err) = JournalEffector::save_process_exit(self, process_exit_code) {
                     tracing::warn!("failed to save snapshot event for process exit - {}", err);
                 }
             }
         }
 
-        // If this is the main thread then also close all the files
-        if self.thread.is_main() {
+        // If the process wants to exit, also close all files and terminate it
+        if let Some(process_exit_code) = process_exit_code {
             let process = self.process.clone();
             let disable_fs_cleanup = self.disable_fs_cleanup;
             let pid = self.pid();
@@ -1297,11 +1255,50 @@ impl WasiEnv {
                 }
 
                 // Terminate the process
-                let exit_code = exit_code.unwrap_or_else(|| Errno::Canceled.into());
-                process.terminate(exit_code);
+                process.terminate(process_exit_code);
             })
         } else {
             Box::pin(async {})
         }
     }
+
+    pub fn prepare_spawn(&self, cmd: &BinaryPackageCommand) {
+        if let Ok(Some(Wasi {
+            main_args,
+            env: env_vars,
+            exec_name,
+            ..
+        })) = cmd.metadata().wasi()
+        {
+            if let Some(env_vars) = env_vars {
+                let env_vars = env_vars
+                    .into_iter()
+                    .map(|env_var| {
+                        let (k, v) = env_var.split_once('=').unwrap();
+
+                        (k.to_string(), v.as_bytes().to_vec())
+                    })
+                    .collect::<Vec<_>>();
+
+                let env_vars = conv_env_vars(env_vars);
+
+                self.state
+                    .envs
+                    .lock()
+                    .unwrap()
+                    .extend_from_slice(env_vars.as_slice());
+            }
+
+            if let Some(main_args) = main_args {
+                let mut args: std::sync::MutexGuard<'_, Vec<String>> =
+                    self.state.args.lock().unwrap();
+                // Insert main-args before user args
+                args.splice(1..1, main_args);
+            }
+
+            if let Some(exec_name) = exec_name {
+                self.state.args.lock().unwrap()[0] = exec_name;
+            }
+        }
+    }
 }
diff --git a/lib/wasix/src/state/func_env.rs b/lib/wasix/src/state/func_env.rs
index 5de4602234..4d3a2e29f4 100644
--- a/lib/wasix/src/state/func_env.rs
+++ b/lib/wasix/src/state/func_env.rs
@@ -1,23 +1,24 @@
-use std::sync::Arc;
-
 use tracing::trace;
 use wasmer::{
-    AsStoreMut, AsStoreRef, ExportError, FunctionEnv, Imports, Instance, Memory, Module, Store,
+    AsStoreMut, AsStoreRef, ExportError, FunctionEnv, FunctionEnvMut, Imports, Instance, Memory,
+    Module, Store,
 };
-use wasmer_wasix_types::wasi::ExitCode;
+use wasmer_wasix_types::{wasi::ExitCode, wasix::WasiMemoryLayout};
 
 #[allow(unused_imports)]
 use crate::os::task::thread::RewindResultType;
 #[cfg(feature = "journal")]
 use crate::syscalls::restore_snapshot;
 use crate::{
-    import_object_for_all_wasi_versions,
-    runtime::SpawnMemoryType,
-    state::WasiInstanceHandles,
+    runtime::task_manager::SpawnMemoryTypeOrStore,
+    state::WasiModuleTreeHandles,
     utils::{get_wasi_version, get_wasi_versions, store::restore_store_snapshot},
-    RewindStateOption, StoreSnapshot, WasiEnv, WasiError, WasiRuntimeError, WasiThreadError,
+    RewindStateOption, StoreSnapshot, WasiEnv, WasiError, WasiModuleInstanceHandles,
+    WasiRuntimeError, WasiThreadError,
 };
 
+use super::Linker;
+
 /// The default stack size for WASIX - the number itself is the default that compilers
 /// have used in the past when compiling WASM apps.
 ///
@@ -41,45 +42,54 @@ impl WasiFunctionEnv {
     pub fn new_with_store(
         module: Module,
         env: WasiEnv,
-        store_snapshot: Option<&StoreSnapshot>,
-        spawn_type: SpawnMemoryType,
+        store_snapshot: Option<StoreSnapshot>,
+        spawn_type: SpawnMemoryTypeOrStore,
         update_layout: bool,
+        call_initialize: bool,
+        parent_linker_and_ctx: Option<(Linker, &mut FunctionEnvMut<WasiEnv>)>,
     ) -> Result<(Self, Store), WasiThreadError> {
         // Create a new store and put the memory object in it
         // (but only if it has imported memory)
-        let mut store = env.runtime.new_store();
-        let memory = env
-            .tasks()
-            .build_memory(&mut store.as_store_mut(), spawn_type)?;
-
-        // Build the context object and import the memory
-        let mut ctx = WasiFunctionEnv::new(&mut store, env);
-        let (mut import_object, init) =
-            import_object_for_all_wasi_versions(&module, &mut store, &ctx.env);
-        if let Some(memory) = memory.clone() {
-            import_object.define("env", "memory", memory);
-        }
-
-        let instance = Instance::new(&mut store, &module, &import_object).map_err(|err| {
-            tracing::warn!("failed to create instance - {}", err);
-            WasiThreadError::InstanceCreateFailed(Box::new(err))
-        })?;
+        let (memory, store): (Option<wasmer::Memory>, Option<wasmer::Store>) = match spawn_type {
+            SpawnMemoryTypeOrStore::New => (None, None),
+            SpawnMemoryTypeOrStore::Type(mut ty) => {
+                ty.shared = true;
+
+                let mut store = env.runtime.new_store();
+
+                // Note: If memory is shared, maximum needs to be set in the
+                // browser otherwise creation will fail.
+                let _ = ty.maximum.get_or_insert(wasmer_types::Pages::max_value());
+
+                let mem = Memory::new(&mut store, ty).map_err(|err| {
+                    tracing::error!(
+                        error = &err as &dyn std::error::Error,
+                        memory_type=?ty,
+                        "could not create memory",
+                    );
+                    WasiThreadError::MemoryCreateFailed(err)
+                })?;
+                (Some(mem), Some(store))
+            }
+            SpawnMemoryTypeOrStore::StoreAndMemory(s, m) => (m, Some(s)),
+        };
 
-        init(&instance, &store).map_err(|err| {
-            tracing::warn!("failed to init instance - {}", err);
-            WasiThreadError::InitFailed(Arc::new(err))
-        })?;
+        let mut store = store.unwrap_or_else(|| env.runtime().new_store());
 
-        // Initialize the WASI environment
-        ctx.initialize_with_memory(&mut store, instance, memory, update_layout)
-            .map_err(|err| {
-                tracing::warn!("failed initialize environment - {}", err);
-                WasiThreadError::ExportError(err)
-            })?;
+        let (_, ctx) = env.instantiate(
+            module,
+            &mut store,
+            memory,
+            update_layout,
+            call_initialize,
+            parent_linker_and_ctx,
+        )?;
 
+        // FIXME: shouldn't this happen _before_ instantiating, so the startup code in the instance
+        // has access to the globals?
         // Set all the globals
         if let Some(snapshot) = store_snapshot {
-            restore_store_snapshot(&mut store, snapshot);
+            restore_store_snapshot(&mut store, &snapshot);
         }
 
         Ok((ctx, store))
@@ -113,54 +123,62 @@ impl WasiFunctionEnv {
     /// (this must be executed before attempting to use it)
     /// (as the stores can not by themselves be passed between threads we can store the module
     ///  in a thread-local variables and use it later - for multithreading)
+    // FIXME: this probably doesn't work with WASIX modules, since they import their memories?
     pub fn initialize(
         &mut self,
         store: &mut impl AsStoreMut,
         instance: Instance,
     ) -> Result<(), ExportError> {
-        self.initialize_with_memory(store, instance, None, true)
+        let exported_memory = instance
+            .exports
+            .iter()
+            .filter_map(|(_, export)| {
+                if let wasmer::Extern::Memory(memory) = export {
+                    Some(memory.clone())
+                } else {
+                    None
+                }
+            })
+            .next()
+            .ok_or_else(|| ExportError::Missing("No exported memory found".to_string()))?;
+
+        self.initialize_handles_and_layout(
+            store,
+            instance.clone(),
+            WasiModuleTreeHandles::Static(WasiModuleInstanceHandles::new(
+                exported_memory,
+                store,
+                instance,
+                None,
+            )),
+            None,
+            true,
+        )
     }
 
     /// Initializes the WasiEnv using the instance exports and a provided optional memory
     /// (this must be executed before attempting to use it)
     /// (as the stores can not by themselves be passed between threads we can store the module
     ///  in a thread-local variables and use it later - for multithreading)
-    pub fn initialize_with_memory(
+    // FIXME: Move this code to somewhere that makes sense (in WasiEnv?)
+    pub fn initialize_handles_and_layout(
         &mut self,
         store: &mut impl AsStoreMut,
         instance: Instance,
-        memory: Option<Memory>,
+        handles: WasiModuleTreeHandles,
+        stack_layout: Option<WasiMemoryLayout>,
         update_layout: bool,
     ) -> Result<(), ExportError> {
         let is_wasix_module = crate::utils::is_wasix_module(instance.module());
 
-        let exported_memory = instance
-            .exports
-            .iter()
-            .filter_map(|(_, export)| {
-                if let wasmer::Extern::Memory(memory) = export {
-                    Some(memory.clone())
-                } else {
-                    None
-                }
-            })
-            .next();
-        let memory = match (exported_memory, memory) {
-            (Some(memory), _) => memory,
-            (None, Some(memory)) => memory,
-            (None, None) => {
-                return Err(ExportError::Missing(
-                    "No imported or exported memory found".to_string(),
-                ))
-            }
-        };
-
-        let new_inner = WasiInstanceHandles::new(memory, store, instance);
+        let new_inner = handles;
 
-        let stack_pointer = new_inner.stack_pointer.clone();
-        let data_end = new_inner.data_end.clone();
-        let stack_low = new_inner.stack_low.clone();
-        let stack_high = new_inner.stack_high.clone();
+        let main_module_handles = new_inner.main_module_instance_handles();
+        let stack_pointer = main_module_handles.stack_pointer.clone();
+        let data_end = main_module_handles.data_end.clone();
+        let stack_low = main_module_handles.stack_low.clone();
+        let stack_high = main_module_handles.stack_high.clone();
+        let tls_base = main_module_handles.tls_base.clone();
 
         let env = self.data_mut(store);
         env.set_inner(new_inner);
@@ -169,74 +187,102 @@ impl WasiFunctionEnv {
 
         // If the stack offset and size is not set then do so
         if update_layout {
-            // Set the base stack
-            let stack_base = if let Some(stack_high) = stack_high {
-                match stack_high.get(store) {
-                    wasmer::Value::I32(a) => a as u64,
-                    wasmer::Value::I64(a) => a as u64,
-                    _ => DEFAULT_STACK_BASE,
-                }
-            } else if let Some(stack_pointer) = stack_pointer {
-                match stack_pointer.get(store) {
-                    wasmer::Value::I32(a) => a as u64,
-                    wasmer::Value::I64(a) => a as u64,
-                    _ => DEFAULT_STACK_BASE,
-                }
-            } else {
-                DEFAULT_STACK_BASE
-            };
+            let new_layout = match stack_layout {
+                Some(layout) => layout,
+                None => {
+                    // Set the base stack
+                    let stack_upper = if let Some(stack_high) = stack_high {
+                        match stack_high.get(store) {
+                            wasmer::Value::I32(a) => a as u64,
+                            wasmer::Value::I64(a) => a as u64,
+                            _ => DEFAULT_STACK_BASE,
+                        }
+                    } else if let Some(stack_pointer) = stack_pointer {
+                        match stack_pointer.get(store) {
+                            wasmer::Value::I32(a) => a as u64,
+                            wasmer::Value::I64(a) => a as u64,
+                            _ => DEFAULT_STACK_BASE,
+                        }
+                    } else {
+                        DEFAULT_STACK_BASE
+                    };
 
-            if stack_base == 0 {
-                return Err(ExportError::Missing(
-                    "stack_high or stack_pointer is not set to the upper stack range".to_string(),
-                ));
-            }
+                    if stack_upper == 0 {
+                        return Err(ExportError::Missing(
+                            "stack_high or stack_pointer is not set to the upper stack range"
+                                .to_string(),
+                        ));
+                    }
+
+                    let mut stack_lower = if let Some(stack_low) = stack_low {
+                        match stack_low.get(store) {
+                            wasmer::Value::I32(a) => a as u64,
+                            wasmer::Value::I64(a) => a as u64,
+                            _ => 0,
+                        }
+                    } else if let Some(data_end) = data_end {
+                        let data_end = match data_end.get(store) {
+                            wasmer::Value::I32(a) => a as u64,
+                            wasmer::Value::I64(a) => a as u64,
+                            _ => 0,
+                        };
+                        // It's possible for the data section to be above the stack, we check for that here and
+                        // if it is, we'll assume the stack starts at address 0
+                        if data_end >= stack_upper {
+                            0
+                        } else {
+                            data_end
+                        }
+                    } else {
+                        // clang-16 and higher generate the `__stack_low` global, and it can be exported with
+                        // `-Wl,--export=__stack_low`. clang-15 generates `__data_end`, which should be identical
+                        // and can be exported if `__stack_low` is not available.
+                        if self.data(store).will_use_asyncify() {
+                            tracing::warn!("Missing both __stack_low and __data_end exports, unwinding may cause memory corruption");
+                        }
+                        0
+                    };
 
-            let mut stack_lower = if let Some(stack_low) = stack_low {
-                match stack_low.get(store) {
-                    wasmer::Value::I32(a) => a as u64,
-                    wasmer::Value::I64(a) => a as u64,
-                    _ => 0,
-                }
-            } else if let Some(data_end) = data_end {
-                let data_end = match data_end.get(store) {
-                    wasmer::Value::I32(a) => a as u64,
-                    wasmer::Value::I64(a) => a as u64,
-                    _ => 0,
-                };
-                // It's possible for the data section to be above the stack, we check for that here and
-                // if it is, we'll assume the stack starts at address 0
-                if data_end >= stack_base {
-                    0
-                } else {
-                    data_end
-                }
-            } else {
-                // clang-16 and higher generate the `__stack_low` global, and it can be exported with
-                // `-Wl,--export=__stack_low`. clang-15 generates `__data_end`, which should be identical
-                // and can be exported if `__stack_low` is not available.
-                if self.data(store).will_use_asyncify() {
-                    tracing::warn!("Missing both __stack_low and __data_end exports, unwinding may cause memory corruption");
-                }
-                0
-            };
+                    if stack_lower >= stack_upper {
+                        if self.data(store).will_use_asyncify() {
+                            tracing::warn!(
+                                "Detected lower end of stack to be above higher end, ignoring stack_lower; \
+                                unwinding may cause memory corruption"
+                            );
+                        }
+                        stack_lower = 0;
+                    }
+
+                    // Note: the TLS base global may not be initialized at the point when this
+                    // code runs, so we take a zero value to mean it wasn't initialized and we
+                    // don't know it. It's never actually zero for statically-linked, non-PIE
+                    // modules.
+                    let tls_base = if let Some(tls_base) = tls_base {
+                        match tls_base.get(store) {
+                            wasmer::Value::I32(a) => a as u64,
+                            wasmer::Value::I64(a) => a as u64,
+                            _ => 0,
+                        }
+                    } else {
+                        0
+                    };
 
-            if stack_lower >= stack_base {
-                if self.data(store).will_use_asyncify() {
-                    tracing::warn!(
-                        "Detected lower end of stack to be above higher end, ignoring stack_lower; \
-                        unwinding may cause memory corruption"
-                    );
+                    WasiMemoryLayout {
+                        stack_lower,
+                        stack_upper,
+                        stack_size: stack_upper - stack_lower,
+                        guard_size: 0,
+                        tls_base: if tls_base == 0 { None } else { Some(tls_base) },
+                    }
                 }
-                stack_lower = 0;
-            }
+            };
 
             // Update the stack layout which is need for asyncify
             let env = self.data_mut(store);
             let tid = env.tid();
             let layout = &mut env.layout;
-            layout.stack_upper = stack_base;
-            layout.stack_lower = stack_lower;
+            layout.stack_upper = new_layout.stack_upper;
+            layout.stack_lower = new_layout.stack_lower;
             layout.stack_size = layout.stack_upper - layout.stack_lower;
 
             // Replace the thread object itself
@@ -284,15 +330,23 @@ impl WasiFunctionEnv {
     /// This function should only be called from within a syscall
     /// as it can potentially execute local thread variable cleanup
     /// code
-    pub fn on_exit(&self, store: &mut impl AsStoreMut, exit_code: Option<ExitCode>) {
+    pub fn on_exit(&self, store: &mut impl AsStoreMut, process_exit_code: Option<ExitCode>) {
         trace!(
             "wasi[{}:{}]::on_exit",
             self.data(store).pid(),
             self.data(store).tid()
         );
 
+        if let Some(linker) = self.data(store).inner().linker().cloned() {
+            // Note: this call will also process pending dl operations, hence unblocking
+            // other threads that may be waiting for this one to pick the operation up
+            if let Err(e) = linker.shutdown_instance_group(&mut self.env.clone().into_mut(store)) {
+                tracing::warn!("Failed to shutdown linker instance group: {e:?}");
+            }
+        }
+
         // Cleans up all the open files (if this is the main thread)
-        self.data(store).blocking_on_exit(exit_code);
+        self.data(store).blocking_on_exit(process_exit_code);
     }
 
     /// Bootstraps this main thread and context with any journals that
@@ -319,14 +373,40 @@ impl WasiFunctionEnv {
         {
             // If there are journals we need to restore then do so (this will
             // prevent the initialization function from running
-            let restore_journals = self.data(&store).runtime.journals().clone();
-            if !restore_journals.is_empty() {
+            let restore_ro_journals = self
+                .data(&store)
+                .runtime
+                .read_only_journals()
+                .collect::<Vec<_>>();
+            let restore_w_journals = self
+                .data(&store)
+                .runtime
+                .writable_journals()
+                .collect::<Vec<_>>();
+            if !restore_ro_journals.is_empty() || !restore_w_journals.is_empty() {
                 tracing::trace!("replaying journal=true");
                 self.data_mut(&mut store).replaying_journal = true;
 
-                for journal in restore_journals {
+                for journal in restore_ro_journals {
+                    let ctx = self.env.clone().into_mut(&mut store);
+                    let rewind = match restore_snapshot(ctx, journal.as_ref(), true) {
+                        Ok(r) => r,
+                        Err(err) => {
+                            tracing::trace!("replaying journal=false (err={:?})", err);
+                            self.data_mut(&mut store).replaying_journal = false;
+                            return Err(err);
+                        }
+                    };
+                    rewind_state = rewind.map(|rewind| (rewind, RewindResultType::RewindRestart));
+                }
+
+                for journal in restore_w_journals {
                     let ctx = self.env.clone().into_mut(&mut store);
-                    let rewind = match restore_snapshot(ctx, journal, true) {
+                    let rewind = match restore_snapshot(
+                        ctx,
+                        journal.as_ref().as_dyn_readable_journal(),
+                        true,
+                    ) {
                         Ok(r) => r,
                         Err(err) => {
                             tracing::trace!("replaying journal=false (err={:?})", err);
@@ -358,8 +438,7 @@ impl WasiFunctionEnv {
                 )
                 .map_err(|err| {
                     WasiRuntimeError::Runtime(wasmer::RuntimeError::new(format!(
-                        "journal failed to save the module initialization event - {}",
-                        err
+                        "journal failed to save the module initialization event - {err}"
                     )))
                 })?;
             } else {
@@ -371,8 +450,7 @@ impl WasiFunctionEnv {
                 )
                 .map_err(|err| {
                     WasiRuntimeError::Runtime(wasmer::RuntimeError::new(format!(
-                        "journal failed to save clear ethereal event - {}",
-                        err
+                        "journal failed to save clear ethereal event - {err}",
                     )))
                 })?;
             }
diff --git a/lib/wasix/src/state/handles/global.rs b/lib/wasix/src/state/handles/global.rs
index a3313f95a2..8d195bb7b1 100644
--- a/lib/wasix/src/state/handles/global.rs
+++ b/lib/wasix/src/state/handles/global.rs
@@ -1,25 +1,25 @@
 #![cfg_attr(feature = "js", allow(unused))]
 use wasmer::Memory;
 
-use crate::WasiInstanceHandles;
+use crate::WasiModuleTreeHandles;
 
-pub(crate) type WasiInstanceGuard<'a> = &'a WasiInstanceHandles;
-pub(crate) type WasiInstanceGuardMut<'a> = &'a mut WasiInstanceHandles;
+pub(crate) type WasiInstanceGuard<'a> = &'a WasiModuleTreeHandles;
+pub(crate) type WasiInstanceGuardMut<'a> = &'a mut WasiModuleTreeHandles;
 pub(crate) type WasiInstanceGuardMemory<'a> = &'a Memory;
 
 /// This pointer provides global access to some instance handles
 #[derive(Debug, Clone, Default)]
 pub(crate) struct WasiInstanceHandlesPointer {
-    inner: Option<WasiInstanceHandles>,
+    inner: Option<WasiModuleTreeHandles>,
 }
 impl WasiInstanceHandlesPointer {
-    pub fn get(&self) -> Option<&WasiInstanceHandles> {
+    pub fn get(&self) -> Option<&WasiModuleTreeHandles> {
         self.inner.as_ref()
     }
-    pub fn get_mut(&mut self) -> Option<&mut WasiInstanceHandles> {
+    pub fn get_mut(&mut self) -> Option<&mut WasiModuleTreeHandles> {
         self.inner.as_mut()
     }
-    pub fn set(&mut self, val: WasiInstanceHandles) {
+    pub fn set(&mut self, val: WasiModuleTreeHandles) {
         self.inner.replace(val);
     }
     #[allow(dead_code)]
diff --git a/lib/wasix/src/state/handles/mod.rs b/lib/wasix/src/state/handles/mod.rs
index 77a67014e8..26e000dede 100644
--- a/lib/wasix/src/state/handles/mod.rs
+++ b/lib/wasix/src/state/handles/mod.rs
@@ -1,7 +1,370 @@
 mod global;
 mod thread_local;
 
-#[cfg(feature = "sys")]
+#[cfg(any(feature = "sys", feature = "sys-minimal"))]
 pub(crate) use global::*;
 #[cfg(feature = "js")]
 pub(crate) use thread_local::*;
+
+use tracing::{error, trace};
+use wasmer::{
+    AsStoreMut, AsStoreRef, Function, Global, Instance, Memory, MemoryView, Module, Table,
+    TypedFunction, Value,
+};
+use wasmer_wasix_types::wasi::Errno;
+
+use super::Linker;
+
+/// Various [`TypedFunction`] and [`Global`] handles for an active WASI(X) instance.
+///
+/// Used to access and modify runtime state.
+// TODO: make fields private
+#[derive(Debug, Clone)]
+pub struct WasiModuleInstanceHandles {
+    // TODO: the two fields below are instance specific, while all others are module specific.
+    // Should be split up.
+    /// Represents a reference to the memory
+    pub(crate) memory: Memory,
+    pub(crate) instance: wasmer::Instance,
+
+    /// Points to the indirect function table
+    pub(crate) indirect_function_table: Option<Table>,
+
+    /// Points to the current location of the memory stack pointer
+    pub(crate) stack_pointer: Option<Global>,
+
+    /// Points to the end of the data section
+    pub(crate) data_end: Option<Global>,
+
+    /// Points to the lower end of the stack
+    pub(crate) stack_low: Option<Global>,
+
+    /// Points to the higher end of the stack
+    pub(crate) stack_high: Option<Global>,
+
+    /// Points to the start of the TLS area
+    pub(crate) tls_base: Option<Global>,
+
+    /// Main function that will be invoked (name = "_start")
+    pub(crate) start: Option<TypedFunction<(), ()>>,
+
+    /// Function thats invoked to initialize the WASM module (name = "_initialize")
+    // TODO: review allow...
+    #[allow(dead_code)]
+    pub(crate) initialize: Option<TypedFunction<(), ()>>,
+
+    /// Represents the callback for spawning a thread (name = "wasi_thread_start")
+    /// (due to limitations with i64 in browsers the parameters are broken into i32 pairs)
+    /// [this takes a user_data field]
+    pub(crate) thread_spawn: Option<TypedFunction<(i32, i32), ()>>,
+
+    /// Represents the callback for signals (name = "__wasm_signal")
+    /// Signals are triggered asynchronously at idle times of the process
+    // TODO: why is this here? It can exist in WasiEnv
+    pub(crate) signal: Option<TypedFunction<i32, ()>>,
+
+    /// Flag that indicates if the signal callback has been set by the WASM
+    /// process - if it has not been set then the runtime behaves differently
+    /// when a CTRL-C is pressed.
+    pub(crate) signal_set: bool,
+
+    /// Flag that indicates if the stack capture exports are being used by
+    /// this WASM process which means that it will be using asyncify
+    pub(crate) has_stack_checkpoint: bool,
+
+    /// asyncify_start_unwind(data : i32): call this to start unwinding the
+    /// stack from the current location. "data" must point to a data
+    /// structure as described above (with fields containing valid data).
+    // TODO: review allow...
+    #[allow(dead_code)]
+    pub(crate) asyncify_start_unwind: Option<TypedFunction<i32, ()>>,
+
+    /// asyncify_stop_unwind(): call this to note that unwinding has
+    /// concluded. If no other code will run before you start to rewind,
+    /// this is not strictly necessary, however, if you swap between
+    /// coroutines, or even just want to run some normal code during a
+    /// "sleep", then you must call this at the proper time. Otherwise,
+    /// the code will think it is still unwinding when it should not be,
+    /// which means it will keep unwinding in a meaningless way.
+    // TODO: review allow...
+    #[allow(dead_code)]
+    pub(crate) asyncify_stop_unwind: Option<TypedFunction<(), ()>>,
+
+    /// asyncify_start_rewind(data : i32): call this to start rewinding the
+    /// stack vack up to the location stored in the provided data. This prepares
+    /// for the rewind; to start it, you must call the first function in the
+    /// call stack to be unwound.
+    // TODO: review allow...
+    #[allow(dead_code)]
+    pub(crate) asyncify_start_rewind: Option<TypedFunction<i32, ()>>,
+
+    /// asyncify_stop_rewind(): call this to note that rewinding has
+    /// concluded, and normal execution can resume.
+    // TODO: review allow...
+    #[allow(dead_code)]
+    pub(crate) asyncify_stop_rewind: Option<TypedFunction<(), ()>>,
+
+    /// asyncify_get_state(): call this to get the current value of the
+    /// internal "__asyncify_state" variable as described above.
+    /// It can be used to distinguish between unwinding/rewinding and normal
+    /// calls, so that you know when to start an asynchronous operation and
+    /// when to propagate results back.
+    #[allow(dead_code)]
+    pub(crate) asyncify_get_state: Option<TypedFunction<(), i32>>,
+}
+
+impl WasiModuleInstanceHandles {
+    pub fn new(
+        memory: Memory,
+        store: &impl AsStoreRef,
+        instance: Instance,
+        indirect_function_table: Option<Table>,
+    ) -> Self {
+        let has_stack_checkpoint = instance
+            .module()
+            .imports()
+            .any(|f| f.name() == "stack_checkpoint");
+        Self {
+            memory,
+            indirect_function_table: indirect_function_table.or_else(|| {
+                instance
+                    .exports
+                    .get_table("__indirect_function_table")
+                    .cloned()
+                    .ok()
+            }),
+            stack_pointer: instance.exports.get_global("__stack_pointer").cloned().ok(),
+            data_end: instance.exports.get_global("__data_end").cloned().ok(),
+            stack_low: instance.exports.get_global("__stack_low").cloned().ok(),
+            stack_high: instance.exports.get_global("__stack_high").cloned().ok(),
+            tls_base: instance.exports.get_global("__tls_base").cloned().ok(),
+            start: instance.exports.get_typed_function(store, "_start").ok(),
+            initialize: instance
+                .exports
+                .get_typed_function(store, "_initialize")
+                .ok(),
+            thread_spawn: instance
+                .exports
+                .get_typed_function(store, "wasi_thread_start")
+                .ok(),
+            signal: instance
+                .exports
+                .get_typed_function(&store, "__wasm_signal")
+                .ok(),
+            has_stack_checkpoint,
+            signal_set: false,
+            asyncify_start_unwind: instance
+                .exports
+                .get_typed_function(store, "asyncify_start_unwind")
+                .ok(),
+            asyncify_stop_unwind: instance
+                .exports
+                .get_typed_function(store, "asyncify_stop_unwind")
+                .ok(),
+            asyncify_start_rewind: instance
+                .exports
+                .get_typed_function(store, "asyncify_start_rewind")
+                .ok(),
+            asyncify_stop_rewind: instance
+                .exports
+                .get_typed_function(store, "asyncify_stop_rewind")
+                .ok(),
+            asyncify_get_state: instance
+                .exports
+                .get_typed_function(store, "asyncify_get_state")
+                .ok(),
+            instance,
+        }
+    }
+
+    pub fn module(&self) -> &Module {
+        self.instance.module()
+    }
+
+    pub fn module_clone(&self) -> Module {
+        self.instance.module().clone()
+    }
+
+    /// Providers safe access to the memory
+    /// (it must be initialized before it can be used)
+    pub fn memory_view<'a>(&'a self, store: &'a (impl AsStoreRef + ?Sized)) -> MemoryView<'a> {
+        self.memory.view(store)
+    }
+
+    /// Providers safe access to the memory
+    /// (it must be initialized before it can be used)
+    pub fn memory(&self) -> &Memory {
+        &self.memory
+    }
+
+    /// Copy the lazy reference so that when it's initialized during the
+    /// export phase, all the other references get a copy of it
+    pub fn memory_clone(&self) -> Memory {
+        self.memory.clone()
+    }
+
+    pub fn instance(&self) -> &Instance {
+        &self.instance
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum WasiModuleTreeHandles {
+    Static(WasiModuleInstanceHandles),
+    Dynamic {
+        linker: Linker,
+        main_module_instance_handles: WasiModuleInstanceHandles,
+    },
+}
+
+#[derive(thiserror::Error, Debug, Clone)]
+pub enum FunctionLookupError {
+    #[error("No function found at the requested index `{0}`")]
+    /// Function not found at the index
+    Empty(u32),
+    #[error("Table index `{0}` out of bounds")]
+    /// Table index out of bounds
+    OutOfBounds(u32),
+    #[error("The table does not contain functions")]
+    /// The table does not contain functions
+    NotAFunctionTable,
+    #[error("No indirect function table available")]
+    /// No indirect function table available
+    NoIndirectFunctionTable,
+}
+impl From<FunctionLookupError> for Errno {
+    fn from(e: FunctionLookupError) -> Self {
+        match e {
+            FunctionLookupError::Empty(_) => Errno::Inval,
+            FunctionLookupError::OutOfBounds(_) => Errno::Inval,
+            FunctionLookupError::NotAFunctionTable => Errno::Inval,
+            FunctionLookupError::NoIndirectFunctionTable => Errno::Notsup,
+        }
+    }
+}
+
+impl WasiModuleTreeHandles {
+    /// Can be used to get the `WasiModuleInstanceHandles` of the main module.
+    /// If access to the side modules' instance handles is required, one must go
+    /// through the `Linker` to retrieve the one they need.
+    pub(crate) fn main_module_instance_handles(&self) -> &WasiModuleInstanceHandles {
+        match self {
+            WasiModuleTreeHandles::Static(ref handles) => handles,
+            WasiModuleTreeHandles::Dynamic {
+                ref main_module_instance_handles,
+                ..
+            } => main_module_instance_handles,
+        }
+    }
+
+    /// See comments on `main_module_instance_handles`.
+    pub(crate) fn main_module_instance_handles_mut(&mut self) -> &mut WasiModuleInstanceHandles {
+        match self {
+            WasiModuleTreeHandles::Static(ref mut handles) => handles,
+            WasiModuleTreeHandles::Dynamic {
+                ref mut main_module_instance_handles,
+                ..
+            } => main_module_instance_handles,
+        }
+    }
+
+    /// Helper function to get the instance handles of a static module, or fail otherwise.
+    /// See comments on ensure_static_module for more details.
+    pub(crate) fn static_module_instance_handles(&self) -> Option<&WasiModuleInstanceHandles> {
+        match self {
+            WasiModuleTreeHandles::Static(ref handles) => Some(handles),
+            WasiModuleTreeHandles::Dynamic { .. } => None,
+        }
+    }
+
+    /// See comments on `static_module_instance_handles`.
+    #[allow(dead_code)]
+    pub(crate) fn static_module_instance_handles_mut(
+        &mut self,
+    ) -> Option<&mut WasiModuleInstanceHandles> {
+        match self {
+            WasiModuleTreeHandles::Static(ref mut handles) => Some(handles),
+            WasiModuleTreeHandles::Dynamic { .. } => None,
+        }
+    }
+
+    /// Helper function to ensure the module isn't dynamically linked, needed since
+    /// we only support a subset of WASIX functionality for dynamically linked modules.
+    /// Specifically, anything that requires asyncify is not supported right now.
+    pub(crate) fn ensure_static_module(&self) -> Result<(), ()> {
+        match self {
+            WasiModuleTreeHandles::Static(_) => Ok(()),
+            _ => Err(()),
+        }
+    }
+
+    /// Providers safe access to the memory
+    /// (it must be initialized before it can be used)
+    pub fn memory_view<'a>(&'a self, store: &'a (impl AsStoreRef + ?Sized)) -> MemoryView<'a> {
+        self.main_module_instance_handles().memory.view(store)
+    }
+
+    /// Providers safe access to the memory
+    /// (it must be initialized before it can be used)
+    pub fn memory(&self) -> &Memory {
+        &self.main_module_instance_handles().memory
+    }
+
+    /// Copy the lazy reference so that when it's initialized during the
+    /// export phase, all the other references get a copy of it
+    pub fn memory_clone(&self) -> Memory {
+        self.main_module_instance_handles().memory.clone()
+    }
+
+    pub fn linker(&self) -> Option<&Linker> {
+        match self {
+            Self::Static(_) => None,
+            Self::Dynamic { linker, .. } => Some(linker),
+        }
+    }
+
+    /// Helper function to look up a function in the indirect function table
+    ///
+    /// * Returns an Errno if an error occurred.
+    /// * Returns `Ok(None)` if the index is out of bounds.
+    /// * Returns `Ok(Some(None))` if there is no function at the index.
+    /// * Returns `Ok(Some(Some(function)))` if there is a function at the index.
+    pub fn indirect_function_table_lookup(
+        &self,
+        store: &mut impl AsStoreMut,
+        index: u32,
+    ) -> Result<Function, FunctionLookupError> {
+        let value = self
+            .main_module_instance_handles()
+            .indirect_function_table
+            .as_ref()
+            .ok_or(FunctionLookupError::NoIndirectFunctionTable)?
+            .get(store, index);
+        let Some(value) = value else {
+            trace!(
+                function_id = index,
+                "Function not found in indirect function table"
+            );
+            return Err(FunctionLookupError::OutOfBounds(index));
+        };
+        let Value::FuncRef(funcref) = value else {
+            error!("Function table contains something other than a funcref");
+            return Err(FunctionLookupError::NotAFunctionTable);
+        };
+        let Some(funcref) = funcref else {
+            trace!(function_id = index, "No function at the supplied index");
+            return Err(FunctionLookupError::Empty(index));
+        };
+        Ok(funcref)
+    }
+
+    /// Check if an indirect_function_table entry is reserved for closures.
+    ///
+    /// Returns false if the entry is not reserved for closures.
+    pub fn is_closure(&self, function_id: u32) -> bool {
+        match self {
+            WasiModuleTreeHandles::Static(_) => false,
+            WasiModuleTreeHandles::Dynamic { linker, .. } => linker.is_closure(function_id),
+        }
+    }
+}
diff --git a/lib/wasix/src/state/handles/thread_local.rs b/lib/wasix/src/state/handles/thread_local.rs
index f7dc80c7e4..fd01509bf3 100644
--- a/lib/wasix/src/state/handles/thread_local.rs
+++ b/lib/wasix/src/state/handles/thread_local.rs
@@ -1,4 +1,4 @@
-#![cfg_attr(feature = "sys", allow(unused))]
+#![cfg_attr(any(feature = "sys", feature = "sys-minimal"), allow(unused))]
 use std::cell::{Ref, RefCell, RefMut};
 use std::ops::{Deref, DerefMut};
 use std::{
@@ -9,11 +9,11 @@ use std::{
 
 use wasmer::Memory;
 
-use crate::WasiInstanceHandles;
+use crate::WasiModuleTreeHandles;
 
 static LOCAL_INSTANCE_SEED: AtomicU64 = AtomicU64::new(1);
 thread_local! {
-    static THREAD_LOCAL_INSTANCE_HANDLES: RefCell<HashMap<u64, Rc<RefCell<WasiInstanceHandles>>>>
+    static THREAD_LOCAL_INSTANCE_HANDLES: RefCell<HashMap<u64, Rc<RefCell<WasiModuleTreeHandles>>>>
         = RefCell::new(HashMap::new());
 }
 
@@ -23,12 +23,12 @@ thread_local! {
 pub(crate) struct WasiInstanceGuard<'a> {
     // the order is very important as the first value is
     // dropped before the reference count is dropped
-    borrow: Ref<'static, WasiInstanceHandles>,
+    borrow: Ref<'static, WasiModuleTreeHandles>,
     _pointer: &'a WasiInstanceHandlesPointer,
-    _inner: Rc<RefCell<WasiInstanceHandles>>,
+    _inner: Rc<RefCell<WasiModuleTreeHandles>>,
 }
-impl<'a> Deref for WasiInstanceGuard<'a> {
-    type Target = WasiInstanceHandles;
+impl Deref for WasiInstanceGuard<'_> {
+    type Target = WasiModuleTreeHandles;
     fn deref(&self) -> &Self::Target {
         self.borrow.deref()
     }
@@ -41,18 +41,18 @@ impl<'a> Deref for WasiInstanceGuard<'a> {
 pub(crate) struct WasiInstanceGuardMut<'a> {
     // the order is very important as the first value is
     // dropped before the reference count is dropped
-    borrow: RefMut<'static, WasiInstanceHandles>,
+    borrow: RefMut<'static, WasiModuleTreeHandles>,
     _pointer: &'a WasiInstanceHandlesPointer,
-    _inner: Rc<RefCell<WasiInstanceHandles>>,
+    _inner: Rc<RefCell<WasiModuleTreeHandles>>,
 }
-impl<'a> Deref for WasiInstanceGuardMut<'a> {
-    type Target = WasiInstanceHandles;
+impl Deref for WasiInstanceGuardMut<'_> {
+    type Target = WasiModuleTreeHandles;
 
     fn deref(&self) -> &Self::Target {
         self.borrow.deref()
     }
 }
-impl<'a> DerefMut for WasiInstanceGuardMut<'a> {
+impl DerefMut for WasiInstanceGuardMut<'_> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         self.borrow.deref_mut()
     }
@@ -81,8 +81,8 @@ impl WasiInstanceHandlesPointer {
                 THREAD_LOCAL_INSTANCE_HANDLES.with(|map| {
                     let map = map.borrow();
                     if let Some(inner) = map.get(id) {
-                        let borrow: Ref<WasiInstanceHandles> = inner.borrow();
-                        let borrow: Ref<'static, WasiInstanceHandles> =
+                        let borrow: Ref<WasiModuleTreeHandles> = inner.borrow();
+                        let borrow: Ref<'static, WasiModuleTreeHandles> =
                             unsafe { std::mem::transmute(borrow) };
                         Some(WasiInstanceGuard {
                             borrow,
@@ -103,8 +103,8 @@ impl WasiInstanceHandlesPointer {
                 THREAD_LOCAL_INSTANCE_HANDLES.with(|map| {
                     let map = map.borrow_mut();
                     if let Some(inner) = map.get(&id) {
-                        let borrow: RefMut<WasiInstanceHandles> = inner.borrow_mut();
-                        let borrow: RefMut<'static, WasiInstanceHandles> =
+                        let borrow: RefMut<WasiModuleTreeHandles> = inner.borrow_mut();
+                        let borrow: RefMut<'static, WasiModuleTreeHandles> =
                             unsafe { std::mem::transmute(borrow) };
                         Some(WasiInstanceGuardMut {
                             borrow,
@@ -118,7 +118,7 @@ impl WasiInstanceHandlesPointer {
             })
             .next()
     }
-    pub fn set(&mut self, val: WasiInstanceHandles) {
+    pub fn set(&mut self, val: WasiModuleTreeHandles) {
         self.clear();
 
         let id = LOCAL_INSTANCE_SEED.fetch_add(1, Ordering::SeqCst);
@@ -151,7 +151,7 @@ pub(crate) struct WasiInstanceGuardMemory<'a> {
     borrow: &'a Memory,
     _guard: WasiInstanceGuard<'a>,
 }
-impl<'a> Deref for WasiInstanceGuardMemory<'a> {
+impl Deref for WasiInstanceGuardMemory<'_> {
     type Target = Memory;
     fn deref(&self) -> &Self::Target {
         self.borrow
@@ -159,7 +159,7 @@ impl<'a> Deref for WasiInstanceGuardMemory<'a> {
 }
 impl<'a> WasiInstanceGuard<'a> {
     pub fn memory(self) -> WasiInstanceGuardMemory<'a> {
-        let borrow: &Memory = &self.memory;
+        let borrow: &Memory = (*self).memory();
         let borrow: &'a Memory = unsafe { std::mem::transmute(borrow) };
         WasiInstanceGuardMemory {
             borrow,
diff --git a/lib/wasix/src/state/linker.rs b/lib/wasix/src/state/linker.rs
new file mode 100644
index 0000000000..0cb2c21914
--- /dev/null
+++ b/lib/wasix/src/state/linker.rs
@@ -0,0 +1,4295 @@
+// TODO: The linker *can* exist in the runtime, since technically, there's nothing that
+// prevents us from having a non-WASIX linker. However, there is currently no use-case
+// for a non-WASIX linker, so we'll refrain from making it generic for the time being.
+
+//! Linker for loading and linking dynamic modules at runtime. The linker is designed to
+//! work with output from clang (version 19 was used at the time of creating this code).
+//! Note that dynamic linking of WASM modules is considered unstable in clang/LLVM, so
+//! this code may need to be updated for future versions of clang.
+//!
+//! The linker doesn't care about where code exists and how modules call each other, but
+//! the way we have found to be most effective is:
+//!     * The main module carries with it all of wasix-libc, and exports everything
+//!     * Side module don't link wasix-libc in, instead importing it from the main module
+//!
+//! This way, we only need one instance of wasix-libc, and one instance of all the static
+//! data that it requires to function. Indeed, if there were multiple instances of its
+//! static data, it would more than likely just break completely; one needs only imagine
+//! what would happen if there were multiple memory allocators (malloc) running at the same
+//! time. Emscripten (the only WASM runtime that supports dynamic linking, at the time of
+//! this writing) takes the same approach.
+//!
+//! While locating modules by relative or absolute paths is possible, it is recommended
+//! to put every side module into /lib, where they can be located by name as well as by
+//! path.
+//!
+//! The linker starts from a dynamically-linked main module. It scans the dylink.0 section
+//! for memory and table-related information and the list of needed modules. The module
+//! tree requires a memory, an indirect function table, and stack-related parameters
+//! (including the __stack_pointer global), which are created. Since dynamically-linked
+//! modules use PIC (position-independent code), the stack is not fixed and can be resized
+//! at runtime.
+//!
+//! After the memory, function table and stack are created, the linker proceeds to load in
+//! needed modules. Needed modules are always loaded in and initialized before modules that
+//! asked for them, since it is expected that the needed module needs to be usable before
+//! the module that needs it can be initialized.
+//!
+//! However, we also need to support circular dependencies between the modules; the most
+//! common case is when the main needs a side module and imports function from it, and the
+//! side imports wasix-libc functions from the main. To support this, the linker generates
+//! stub functions for all the imports that cannot be resolved when a module is being
+//! loaded in. The stub functions will then resolve the function once (and only once) at
+//! runtime when they're first called. This *does*, however, mean that link errors can happen
+//! at runtime, after the linker has reported successful linking of the modules. Such errors
+//! are turned into a [`WasiError::DlSymbolResolutionFailed`] error and will terminate
+//! execution completely.
+//!
+//! # Threading Support
+//!
+//! The linker supports the concept of "Instance Groups", which are multiple instances
+//! of the same module tree. This corresponds very closely to WASIX threads, but is
+//! named an instance group so as to keep the logic decoupled from the threading logic
+//! in WASIX.
+//!
+//! Each instance group has its own store, indirect function table, and stack pointer,
+//! but shares its memory with every other instance group. Note that even though the
+//! underlying memory is the same, we need to create a new [`Memory`] instance
+//! for each group via [`Memory::share_in_store`]. Also, when placing a symbol
+//! in the function table, the linker always updates all function tables at the same
+//! time. This is because function "pointers" can be passed across instance groups
+//! (read: sent to other threads) by the guest code, so all function tables should
+//! have exactly the same content at all times.
+//!
+//! One important aspect of instance groups is that they do *not* share the same store;
+//! this lets us put different instance groups on different OS threads. However, this
+//! also means that one call to [`Linker::load_module`], etc. cannot update every
+//! instance group as each one has its own function table. To make the linker work
+//! across threads, we need a "stop-the-world" lock on every instance group. The group
+//! the load/resolve request originates from sets a flag, which other instance
+//! groups are required to check periodically by calling [`Linker::do_pending_link_operations`].
+//! Once all instance groups are stopped in that function, the original can proceed to
+//! perform the operation, and report its results to all other instance groups so they
+//! can make the same changes to their function table as well.
+//!
+//! In WASIX, the periodic check is performed at the start of most (but not all) syscalls.
+//! This means a thread that doesn't make any syscalls can potentially block all other
+//! threads if a DL operation is performed. This also means that two instance groups
+//! cannot co-exist on the same OS thread, as the first one will block the OS thread
+//! and the second can't enter the "lock" again to let the first continue its work.
+//!
+//! To also get cooperation from threads that are waiting in a syscall, a
+//! [`Signal::Sigwakeup`](wasmer_wasix_types::wasi::Signal::Sigwakeup) signal is sent to
+//! all threads when a DL operation needs to be synchronized.
+//!
+//! # About TLS
+//!
+//! Each instance of each group gets its own TLS area, so there are 4 cases to consider:
+//!     * Main instance of main module: TLS area will be allocated by the compiler, and be
+//!       placed at the start of the memory region requested by the `dylink.0` section.
+//!     * Main instance of side modules: Almost same as main module, but tls_base will be
+//!       non-zero because side modules get a non-zero memory_base. It is very important
+//!       to note that the main instance of a side module lives in the instance group
+//!       that initially loads it in. This **does not** have to be the main instance
+//!       group.
+//!     * Other instances of main module: Each worker thread gets its TLS area
+//!       allocated by the code in pthread_create, and a pointer to the TLS area is passed
+//!       through the thread start args. This pointer is read by the code in thread_spawn,
+//!       and passed through to us as part of the environment's memory layout.
+//!     * Other instances of side modules: This is where the linker comes in. When the
+//!       new instance is created, the linker will call its `__wasix_init_tls` function,
+//!       which is responsible for setting up the TLS area for the thread.
+//!
+//! Since we only want to call `__wasix_init_tls` for non-main instances of side modules,
+//! it is enough to call it only within [`InstanceGroupState::instantiate_side_module_from_linker`].
+//!
+//! # Module Loading
+//!
+//! Module loading happens as an orchestrated effort between the shared linker state, the
+//! state of the instance group that started (or "instigated") the operation, and other
+//! instance groups. Access to a set of instances is required for resolution of exports,
+//! which is why the linker state alone (which only stores modules) is not enough.
+//!
+//! Even though most (if not all) operations require access to both the shared linker state
+//! and a/the instance group state, they're separated into three sets:
+//!     * Operations that deal with metadata exist as impls on [`LinkerState`]. These take
+//!       a (read-only) instance group state for export resolution, as well as a
+//!       [`StoreRef`](wasmer::StoreRef). They're guaranteed not to alter the store or the
+//!       instance group state.
+//!     * Operations that deal with the actual instances (instantiating, putting symbols in the
+//!       function table, etc.) and are started by the instigating group exist as impls on
+//!       [`InstanceGroupState`] that also take a mutable reference to the shared linker state, and
+//!       require it to be locked for writing. These operations can and will update the linker state,
+//!       mainly to store symbol resolution records.
+//!     * Operations that deal with replicating changes to instances from another thread also exits
+//!       as impls on [`InstanceGroupState`], but take a read-only reference to the shared linker
+//!       state. This is important because all the information needed for replicating the change to
+//!       the instigating group's instances should already be in the linker state. See
+//!       [`InstanceGroupState::populate_imports_from_linker`] and
+//!       [`InstanceGroupState::instantiate_side_module_from_linker`] for the two most important ones.
+//!
+//! Module loading generally works by going through these steps:
+//!     * [`LinkerState::load_module_tree`] loads modules (and their needed modules) and assigns
+//!       module handles
+//!     * Then, for each new module:
+//!         * Memory and table space is allocated
+//!         * Imports are resolved (see next section)
+//!         * The module is instantiated
+//!     * After all modules have been instantiated, pending imports (resulting from circular
+//!       dependencies) are resolved
+//!     * Finally, module initializers are called
+//!
+//! ## Symbol resolution
+//!
+//! To support replicating operations from the instigating group to other groups, symbol resolution
+//! happens in 3 steps:
+//!     * [`LinkerState::resolve_symbols`] goes through the imports of a soon-to-be-loaded module,
+//!       recording the imports as [`NeededSymbolResolutionKey`]s and creating
+//!       [`InProgressSymbolResolution`]s in response to each one.
+//!     * [`InstanceGroupState::populate_imports_from_link_state`] then goes through the results
+//!       and resolves each import to its final value, while also recording enough information (in the
+//!       shape of [`SymbolResolutionResult`]s) for other groups to resolve the symbol from their own
+//!       instances.
+//!     * Finally, instances are created and finalized, and initializers are called.
+//!
+//! ## Stub functions
+//!
+//! As noted above, stub functions are generated in response to circular dependencies. The stub
+//! functions do take previous symbol resolution records into account, so that the stub corresponding
+//! to a single import cannot resolve to different exports in different groups. If no such record is
+//! found, then a new record is created by the stub function. However, there's a catch.
+//!
+//! It must be noted that, during initialization, the shared linker state has to remain write-locked
+//! so as to prevent other threads from starting another operation (the replication logic only works
+//! with one active operation at a time). Stub functions need a write lock on the shared linker state
+//! to store new resolution records, and as such, they can't store resolution records if they're
+//! called in response to a module's initialization routines. This can happen easily if:
+//! * A side module is needed by the main
+//! * That side module accesses any libc functions, such as printing something to stdout.
+//!
+//! To work around this, stub functions only *try* to lock the shared linker state, and if they can't,
+//! they won't store anything. A follow-up call to the stub function can resolve the symbol again,
+//! store it for use by further calls to the function, and also create a resolution record. This does
+//! create a few hard-to-reach edge cases:
+//!     * If the symbol happens to resolve differently between the two calls to the stub, unpredictable
+//!       behavior can happen; however, this is impossible in the current implementation.
+//!     * If the shared state is locked by a different instance group, then the stub won't store its
+//!       lookup results anyway, even though it could have if it had waited.
+//!
+//! ## Locating side modules
+//!
+//! Side modules are located according to these steps:
+//!     * If the name contains a slash (/), it is treated as a relative or absolute path.   
+//!     * Otherwise, the name is searched for in `/lib`, `/usr/lib` and `/usr/local/lib`.
+//!       LD_LIBRARY_PATH is not supported yet.
+//!
+//! # Building dynamically-linked modules
+//!
+//! Note that building modules that conform the specific requirements of this linker requires
+//! careful configuration of clang. A PIC sysroot is required. The steps to build a main
+//! module are:
+//!
+//! ```bash
+//! clang-19 \
+//!   --target=wasm32-wasi --sysroot=/path/to/sysroot32-pic \
+//!   -matomics -mbulk-memory -mmutable-globals -pthread \
+//!   -mthread-model posix -ftls-model=local-exec \
+//!   -fno-trapping-math -D_WASI_EMULATED_MMAN -D_WASI_EMULATED_SIGNAL \
+//!   -D_WASI_EMULATED_PROCESS_CLOCKS \
+//!   # PIC is required for all modules, main and side
+//!   -fPIC \
+//!   # We need to compile to an object file we can manually link in the next step
+//!   -c main.c -o main.o
+//!
+//! wasm-ld-19 \
+//!   # To link needed side modules, assuming `libsidewasm.so` exists in the current directory:
+//!   -L. -lsidewasm \
+//!   -L/path/to/sysroot32-pic/lib \
+//!   -L/path/to/sysroot32-pic/lib/wasm32-wasi \
+//!   # Make wasm-ld search everywhere and export everything, needed for wasix-libc functions to
+//!   # be exported correctly from the main module
+//!   --whole-archive --export-all \
+//!   # The object file from the last step
+//!   main.o \
+//!   # The crt1.o file contains the _start and _main_void functions
+//!   /path/to/sysroot32-pic/lib/wasm32-wasi/crt1.o \
+//!   # Statically link the sysroot's libraries
+//!   -lc -lresolv -lrt -lm -lpthread -lwasi-emulated-mman \
+//!   # The usual linker config for wasix modules
+//!   --import-memory --shared-memory --extra-features=atomics,bulk-memory,mutable-globals \
+//!   --export=__wasm_signal --export=__tls_size --export=__tls_align \
+//!   --export=__tls_base --export=__wasm_call_ctors --export-if-defined=__wasm_apply_data_relocs \
+//!   # Again, PIC is very important, as well as producing a location-independent executable with -pie
+//!   --experimental-pic -pie \
+//!   -o main.wasm
+//! ```
+//!
+//! And the steps to build a side module are:
+//!
+//! ```bash
+//! clang-19 \
+//!   --target=wasm32-wasi --sysroot=/path/to/sysroot32-pic \
+//!   -matomics -mbulk-memory -mmutable-globals -pthread \
+//!   -mthread-model posix -ftls-model=local-exec \
+//!   -fno-trapping-math -D_WASI_EMULATED_MMAN -D_WASI_EMULATED_SIGNAL \
+//!   -D_WASI_EMULATED_PROCESS_CLOCKS \
+//!   # We need PIC
+//!   -fPIC \
+//!   # Make it export everything that's not hidden explicitly
+//!   -fvisibility=default \
+//!   -c side.c -o side.o
+//!
+//! wasm-ld-19 \
+//!   # Note: we don't link against wasix-libc, so no -lc etc., because we want
+//!   # those symbols to be imported.
+//!   --extra-features=atomics,bulk-memory,mutable-globals \
+//!   --export=__wasm_call_ctors --export-if-defined=__wasm_apply_data_relocs \
+//!   # Need PIC
+//!   --experimental-pic \
+//!   # Import everything that's undefined, including wasix-libc functions
+//!   --unresolved-symbols=import-dynamic \
+//!   # build a shared library
+//!   -shared \
+//!   # Import a shared memory
+//!   --shared-memory \
+//!   # Conform to the libxxx.so naming so clang can find it via -lxxx
+//!   -o libsidewasm.so side.o
+//! ```
+
+#![allow(clippy::result_large_err)]
+
+use std::{
+    borrow::Cow,
+    collections::{BTreeMap, HashMap},
+    ffi::OsStr,
+    ops::{Deref, DerefMut},
+    path::{Path, PathBuf},
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc, Barrier, Mutex, MutexGuard, RwLock, RwLockWriteGuard, TryLockError,
+    },
+};
+
+use bus::Bus;
+use derive_more::Debug;
+use shared_buffer::OwnedBuffer;
+use tracing::trace;
+use virtual_fs::{AsyncReadExt, FileSystem, FsError};
+use virtual_mio::InlineWaker;
+use wasmer::{
+    AsStoreMut, AsStoreRef, Engine, ExportError, Exportable, Extern, ExternType, Function,
+    FunctionEnv, FunctionEnvMut, FunctionType, Global, GlobalType, ImportType, Imports, Instance,
+    InstantiationError, Memory, MemoryError, Module, RuntimeError, StoreMut, Table, Tag, Type,
+    Value, WasmTypeList, WASM_PAGE_SIZE,
+};
+use wasmer_wasix_types::wasix::WasiMemoryLayout;
+
+use crate::{
+    fs::WasiFsRoot, import_object_for_all_wasi_versions, runtime::module_cache::HashedModuleData,
+    Runtime, SpawnError, WasiEnv, WasiError, WasiFs, WasiFunctionEnv, WasiModuleTreeHandles,
+    WasiProcess, WasiThreadId,
+};
+
+use super::{WasiModuleInstanceHandles, WasiState};
+
+// Module handle 1 is always the main module. Side modules get handles starting from the next one after the main module.
+pub static MAIN_MODULE_HANDLE: ModuleHandle = ModuleHandle(1);
+static INVALID_MODULE_HANDLE: ModuleHandle = ModuleHandle(u32::MAX);
+
+static MAIN_MODULE_MEMORY_BASE: u64 = 0;
+// Need to keep the zeroth index null to catch null function pointers at runtime
+static MAIN_MODULE_TABLE_BASE: u64 = 1;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ModuleHandle(u32);
+
+impl From<ModuleHandle> for u32 {
+    fn from(handle: ModuleHandle) -> Self {
+        handle.0
+    }
+}
+
+impl From<u32> for ModuleHandle {
+    fn from(handle: u32) -> Self {
+        ModuleHandle(handle)
+    }
+}
+
+const DEFAULT_RUNTIME_PATH: [&str; 3] = ["/lib", "/usr/lib", "/usr/local/lib"];
+
+struct AllocatedPage {
+    // The base_ptr is mutable, and will move forward as memory is allocated from the page.
+    base_ptr: u32,
+
+    // The amount of memory remaining until the end of the allocated region. Despite the
+    // name of this struct, the region does not have to be only one page.
+    remaining: u32,
+}
+
+// Used to allocate and manage memory for dynamic modules that are loaded in or
+// out, since each module may request a specific amount of memory to be allocated
+// for it before starting it up.
+// TODO: Only supports Memory32, should implement proper Memory64 support
+struct MemoryAllocator {
+    allocated_pages: Vec<AllocatedPage>,
+}
+
+impl MemoryAllocator {
+    pub fn new() -> Self {
+        Self {
+            allocated_pages: vec![],
+        }
+    }
+
+    pub fn allocate(
+        &mut self,
+        memory: &Memory,
+        store: &mut impl AsStoreMut,
+        size: u32,
+        alignment: u32,
+    ) -> Result<u32, MemoryError> {
+        match self.allocate_in_existing_pages(size, alignment) {
+            Some(base_ptr) => Ok(base_ptr),
+            None => self.allocate_new_page(memory, store, size),
+        }
+    }
+
+    // Finds a page which has enough free memory for the request, and allocates in it.
+    // Returns the address of the allocated region if one was found.
+    fn allocate_in_existing_pages(&mut self, size: u32, alignment: u32) -> Option<u32> {
+        // A type to hold intermediate search results. The idea is to allocate on the page
+        // that has the least amount of free space, so we can later satisfy larger allocation
+        // requests without having to allocate entire new pages.
+        struct CandidatePage {
+            index: usize,
+            base_ptr: u32,
+            to_add: u32,
+            remaining_free: u32,
+        }
+
+        impl PartialEq for CandidatePage {
+            fn eq(&self, other: &Self) -> bool {
+                self.remaining_free == other.remaining_free
+            }
+        }
+
+        impl Eq for CandidatePage {}
+
+        impl PartialOrd for CandidatePage {
+            fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+                Some(self.cmp(other))
+            }
+        }
+
+        impl Ord for CandidatePage {
+            fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+                self.remaining_free.cmp(&other.remaining_free)
+            }
+        }
+
+        let mut candidates = std::collections::BinaryHeap::new();
+
+        for (index, page) in self.allocated_pages.iter().enumerate() {
+            // Offset for proper alignment
+            let offset = if page.base_ptr % alignment == 0 {
+                0
+            } else {
+                alignment - (page.base_ptr % alignment)
+            };
+
+            if page.remaining >= offset + size {
+                candidates.push(std::cmp::Reverse(CandidatePage {
+                    index,
+                    base_ptr: page.base_ptr + offset,
+                    to_add: offset + size,
+                    remaining_free: page.remaining - offset - size,
+                }));
+            }
+        }
+
+        candidates.pop().map(|elected| {
+            let page = &mut self.allocated_pages[elected.0.index];
+
+            trace!(
+                free = page.remaining,
+                base_ptr = elected.0.base_ptr,
+                "Found existing memory page with sufficient space"
+            );
+
+            page.base_ptr += elected.0.to_add;
+            page.remaining -= elected.0.to_add;
+            elected.0.base_ptr
+        })
+    }
+
+    fn allocate_new_page(
+        &mut self,
+        memory: &Memory,
+        store: &mut impl AsStoreMut,
+        size: u32,
+    ) -> Result<u32, MemoryError> {
+        // No need to account for alignment here, as pages are already 64k-aligned
+        let to_grow = size.div_ceil(WASM_PAGE_SIZE as u32);
+        let pages = memory.grow(store, to_grow)?;
+
+        let base_ptr = pages.0 * WASM_PAGE_SIZE as u32;
+        let total_allocated = to_grow * WASM_PAGE_SIZE as u32;
+
+        // The initial size bytes are already allocated, rest goes into the list
+        if total_allocated > size {
+            self.allocated_pages.push(AllocatedPage {
+                base_ptr: base_ptr + size,
+                remaining: total_allocated - size,
+            });
+        }
+
+        trace!(
+            page_count = to_grow,
+            size,
+            base_ptr,
+            "Allocated new memory page(s) to accommodate requested memory"
+        );
+
+        Ok(base_ptr)
+    }
+}
+
+#[derive(thiserror::Error, Debug)]
+pub enum LinkError {
+    #[error("Cannot access linker through a dead instance group")]
+    InstanceGroupIsDead,
+
+    #[error("Main module is missing a required import: {0}")]
+    MissingMainModuleImport(String),
+
+    #[error("Failed to spawn module: {0}")]
+    SpawnError(#[from] SpawnError),
+
+    #[error("Failed to instantiate module: {0}")]
+    InstantiationError(#[from] InstantiationError),
+
+    #[error("Memory allocation error: {0}")]
+    MemoryAllocationError(#[from] MemoryError),
+
+    #[error("Failed to allocate function table indices: {0}")]
+    TableAllocationError(RuntimeError),
+
+    #[error("Failed to find shared library {0}: {1}")]
+    SharedLibraryMissing(String, LocateModuleError),
+
+    #[error("Module is not a dynamic library")]
+    NotDynamicLibrary,
+
+    #[error("Failed to parse dylink.0 section: {0}")]
+    Dylink0SectionParseError(#[from] wasmparser::BinaryReaderError),
+
+    #[error("Unresolved global '{0}'.{1} due to: {2}")]
+    UnresolvedGlobal(String, String, Box<ResolveError>),
+
+    #[error("Failed to update global {0} due to: {1}")]
+    GlobalUpdateFailed(String, RuntimeError),
+
+    #[error("Expected global to be of type I32 or I64: '{0}'.{1}")]
+    NonIntegerGlobal(String, String),
+
+    #[error("Bad known import: '{0}'.{1} of type {2:?}")]
+    BadImport(String, String, ExternType),
+
+    #[error(
+        "Import could not be satisfied because of type mismatch: '{0}'.{1}, expected {2:?}, found {3:?}"
+    )]
+    ImportTypeMismatch(String, String, ExternType, ExternType),
+
+    #[error("Expected import to be a function: '{0}'.{1}")]
+    ImportMustBeFunction(&'static str, String),
+
+    #[error("Expected export {0} to be a function, found: {1:?}")]
+    ExportMustBeFunction(String, ExternType),
+
+    #[error("Failed to initialize instance: {0}")]
+    InitializationError(anyhow::Error),
+
+    #[error("Initialization function has invalid signature: {0}")]
+    InitFuncWithInvalidSignature(String),
+
+    #[error("Initialization function {0} failed to run: {1}")]
+    InitFunctionFailed(String, RuntimeError),
+
+    #[error("Failed to initialize WASI(X) module handles: {0}")]
+    MainModuleHandleInitFailed(ExportError),
+
+    #[error("Dynamic function index {0} was not allocated via `allocate_function`")]
+    DynamicFunctionIndexNotAllocated(u32),
+}
+
+#[derive(Debug)]
+pub enum LocateModuleError {
+    Single(FsError),
+    Multiple(Vec<(PathBuf, FsError)>),
+}
+
+impl std::fmt::Display for LocateModuleError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            LocateModuleError::Single(e) => std::fmt::Display::fmt(&e, f),
+            LocateModuleError::Multiple(errors) => {
+                for (path, error) in errors {
+                    write!(f, "\n    {}: {}", path.display(), error)?;
+                }
+                Ok(())
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+enum PartiallyResolvedExport {
+    Function(Function),
+    Global(u64),
+    Tls {
+        // The offset relative to the TLS area of the instance. Kept so we
+        // can re-resolve for other instance groups.
+        offset: u64,
+        // The final address of the symbol for the current instance group.
+        final_addr: u64,
+    },
+}
+
+pub enum ResolvedExport {
+    Function { func_ptr: u64 },
+
+    // Contains the offset of the global in memory, with memory_base/tls_base accounted for
+    // See: https://github.com/WebAssembly/tool-conventions/blob/main/DynamicLinking.md#exports
+    Global { data_ptr: u64 },
+}
+
+#[derive(thiserror::Error, Debug)]
+pub enum ResolveError {
+    #[error("Linker not initialized")]
+    NotInitialized,
+
+    #[error("Invalid module handle")]
+    InvalidModuleHandle,
+
+    #[error("Missing export")]
+    MissingExport,
+
+    #[error("Invalid export type: {0:?}")]
+    InvalidExportType(ExternType),
+
+    #[error("Failed to allocate function table indices: {0}")]
+    TableAllocationError(RuntimeError),
+
+    #[error("Cannot access linker through a dead instance group")]
+    InstanceGroupIsDead,
+
+    #[error("Failed to perform pending DL operation: {0}")]
+    PendingDlOperationFailed(#[from] LinkError),
+
+    #[error(
+        "Tried to resolve a tls symbol from a module that did not initialize thread local storage"
+    )]
+    TlsSymbolWithoutTls,
+}
+
+#[derive(Debug, Clone)]
+pub struct DylinkInfo {
+    pub mem_info: wasmparser::MemInfo,
+    pub needed: Vec<String>,
+    pub import_metadata: HashMap<(String, String), wasmparser::SymbolFlags>,
+    pub export_metadata: HashMap<String, wasmparser::SymbolFlags>,
+    pub runtime_path: Vec<String>,
+}
+
+pub struct LinkedMainModule {
+    pub instance: Instance,
+    pub memory: Memory,
+    pub indirect_function_table: Table,
+    pub stack_low: u64,
+    pub stack_high: u64,
+}
+
+#[derive(Debug)]
+enum UnresolvedGlobal {
+    // A GOT.mem entry, should be resolved to an exported global from another module.
+    Mem(NeededSymbolResolutionKey, Global),
+    // A GOT.func entry, should be resolved to the address of an exported function
+    // from another module (e.g. an index into __indirect_function_table).
+    Func(NeededSymbolResolutionKey, Global),
+}
+
+impl UnresolvedGlobal {
+    fn key(&self) -> &NeededSymbolResolutionKey {
+        match self {
+            Self::Func(key, _) => key,
+            Self::Mem(key, _) => key,
+        }
+    }
+
+    fn global(&self) -> &Global {
+        match self {
+            Self::Func(_, global) => global,
+            Self::Mem(_, global) => global,
+        }
+    }
+
+    fn import_module(&self) -> &str {
+        match self {
+            Self::Func(..) => "GOT.func",
+            Self::Mem(..) => "GOT.mem",
+        }
+    }
+}
+
+#[derive(Debug)]
+struct PendingFunctionResolutionFromLinkerState {
+    resolved_from: ModuleHandle,
+    name: String,
+    function_table_index: u32,
+}
+
+#[derive(Debug)]
+struct PendingTlsPointer {
+    global: Global,
+    resolved_from: ModuleHandle,
+    offset: u64,
+}
+
+// Used only when processing a module load operation from another instance group.
+// Note: Non-TLS globals are constant across instance groups, and thus we store
+// their value, feeding it into new instance groups directly. In the case of TLS
+// symbols, they need to get new values based on each specific instance's __tls_base,
+// so they need to be tracked.
+// __wasm_apply_data_relocs operates on memory addresses, and so it needs to run
+// only once. __wasm_apply_tls_relocs does need to run once per instance group, but
+// it's run as part of __wasm_init_tls, which itself is called by __wasix_init_tls.
+// In either case, there's no need to call any relocation functions when spawning
+// further instances of a module that was already loaded and instantiated once.
+#[derive(Debug, Default)]
+struct PendingResolutionsFromLinker {
+    functions: Vec<PendingFunctionResolutionFromLinkerState>,
+    tls: Vec<PendingTlsPointer>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct NeededSymbolResolutionKey {
+    module_handle: ModuleHandle,
+    // Corresponds to the first identifier, such as env in env.memory. Both "module"
+    // names come from the WASM spec, unfortunately, so we can't change them.
+    // We only resolve from a well-known set of modules, namely "env", "GOT.mem" and
+    // "GOT.func", so this doesn't need to be an owned string.
+    import_module: String,
+    import_name: String,
+}
+
+#[derive(Debug)]
+enum InProgressSymbolResolution {
+    Function(ModuleHandle),
+    StubFunction(FunctionType),
+    // May or may not be a TLS symbol.
+    MemGlobal(ModuleHandle),
+    FuncGlobal(ModuleHandle),
+    UnresolvedMemGlobal,
+    UnresolvedFuncGlobal,
+}
+
+#[derive(Debug)]
+struct InProgressModuleLoad {
+    handle: ModuleHandle,
+    module: Module,
+    dylink_info: DylinkInfo,
+}
+
+#[derive(Default, Debug)]
+struct InProgressLinkState {
+    // All modules loaded in by this link operation, in the order they were loaded in.
+    new_modules: Vec<InProgressModuleLoad>,
+
+    // Modules that are currently being loaded in from the FS due to needed sections.
+    pending_module_paths: Vec<PathBuf>,
+
+    // Collection of intermediate symbol resolution results. This includes functions
+    // that have been found but not appended to the function tables yet, as well as
+    // unresolved globals.
+    symbols: HashMap<NeededSymbolResolutionKey, InProgressSymbolResolution>,
+
+    unresolved_globals: Vec<UnresolvedGlobal>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum SymbolResolutionKey {
+    Needed(NeededSymbolResolutionKey),
+    Requested {
+        // Note: since we don't support module unloading, resolving the same symbol
+        // from *every* module will find the same symbol every time, so we can cache
+        // the None case as well.
+        // TODO: once we implement RTLD_NEXT, that flag should also be taken into
+        // account here.
+        resolve_from: Option<ModuleHandle>,
+        name: String,
+    },
+}
+
+#[derive(Debug)]
+pub enum SymbolResolutionResult {
+    // The symbol was resolved to a global address. We don't resolve again because
+    // the value of globals and the memory_base for each module and all of its instances
+    // is fixed.
+    // The case of unresolved globals is not mentioned in this enum, since it can't exist
+    // once a link operation is finalized.
+    Memory(u64),
+    // The symbol was resolved to a global address, but the global is a TLS variable.
+    // Each instance of each module has a different TLS area, and TLS symbols must be
+    // resolved again every time.
+    Tls {
+        resolved_from: ModuleHandle,
+        offset: u64,
+    },
+    // The symbol was resolved to a function export with the same name from this module.
+    // it is expected that the symbol resolves to an export of the correct type.
+    Function {
+        ty: FunctionType,
+        resolved_from: ModuleHandle,
+    },
+    // Same deal as above, but a pointer was generated and placed in the function table.
+    FunctionPointer {
+        resolved_from: ModuleHandle,
+        function_table_index: u32,
+    },
+    // The symbol failed to resolve, but it's a function so we can create a stub. The
+    // first call to any stub associated with this symbol must update the resolution
+    // record to point to the module the function was resolved from.
+    StubFunction(FunctionType),
+}
+
+// Used to communicate the result of an operation that happened in one
+// instance group to all others
+#[derive(Debug, Clone)]
+enum DlOperation {
+    LoadModules(Vec<ModuleHandle>),
+    ResolveFunction {
+        name: String,
+        resolved_from: ModuleHandle,
+        // This should match the current length of each instance group's function table
+        // minus one. Otherwise, we're out of sync and an error has been encountered.
+        function_table_index: u32,
+    },
+    // Allocates slots in the function table
+    AllocateFunctionTable {
+        index: u32,
+        size: u32,
+    },
+}
+
+struct DlModule {
+    module: Module,
+    dylink_info: DylinkInfo,
+    memory_base: u64,
+    table_base: u64,
+}
+
+struct DlInstance {
+    instance: Instance,
+    #[allow(dead_code)]
+    instance_handles: WasiModuleInstanceHandles,
+    tls_base: Option<u64>,
+}
+
+struct InstanceGroupState {
+    main_instance: Option<Instance>,
+    main_instance_tls_base: u64,
+
+    side_instances: HashMap<ModuleHandle, DlInstance>,
+
+    stack_pointer: Global,
+    memory: Memory,
+    indirect_function_table: Table,
+    c_longjmp: Tag,
+    cpp_exception: Tag,
+
+    // Once the dl_operation_pending flag is set, a barrier is created and broadcast
+    // by the instigating group, which others must use to rendezvous with it.
+    recv_pending_operation_barrier: bus::BusReader<Arc<Barrier>>,
+    // The corresponding sender is stored in the shared linker state, and is used
+    // by the instigating instance group  to broadcast the results.
+    recv_pending_operation: bus::BusReader<DlOperation>,
+}
+
+// There is only one LinkerState for all instance groups
+struct LinkerState {
+    engine: Engine,
+
+    main_module: Module,
+    main_module_dylink_info: DylinkInfo,
+
+    // We used to have an issue where spawning instances out-of-order in new threads
+    // would break globals. That has since been fixed. However, spawning in the same
+    // order helps with diagnosing potential linker issues, so we're keeping the
+    // hack from back then.
+    // To ensure the same order, we use a BTreeMap here, which means when we
+    // iterate over it, we'll get the modules from lowest handle to highest, and
+    // order is preserved.
+    side_modules: BTreeMap<ModuleHandle, DlModule>,
+    side_modules_by_name: HashMap<PathBuf, ModuleHandle>,
+    next_module_handle: u32,
+
+    memory_allocator: MemoryAllocator,
+    heap_base: u64,
+
+    /// Tracks which slots in the function table are currently used for closures
+    ///
+    /// True if the closure is currently in use, false otherwise.
+    allocated_closure_functions: BTreeMap<u32, bool>,
+    /// Slots in the indirect function table that were allocated for closures but are currently not in use.
+    /// These can be given out without needing to lock all threads.
+    available_closure_functions: Vec<u32>,
+
+    symbol_resolution_records: HashMap<SymbolResolutionKey, SymbolResolutionResult>,
+
+    send_pending_operation_barrier: bus::Bus<Arc<Barrier>>,
+    send_pending_operation: bus::Bus<DlOperation>,
+}
+
+/// The linker is responsible for loading and linking dynamic modules at runtime,
+/// and managing the shared memory and indirect function table.
+/// Each linker instance represents a specific instance group. Cloning a linker
+/// instance does *not* create a new instance group though; the clone will refer
+/// to the same group as the original.
+#[derive(Clone)]
+pub struct Linker {
+    linker_state: Arc<RwLock<LinkerState>>,
+    instance_group_state: Arc<Mutex<Option<InstanceGroupState>>>,
+
+    // Is a DL operation pending? This is the cheapest way I know of to let each
+    // instance group check if an operation is *not* pending, which is the case
+    // 99.99% of the time. Uses Relaxed ordering all the time, since we don't
+    // even particularly care about a missed read of this value. A later call can
+    // always pick the flag up and start waiting for the DL operation to complete.
+    // This should only be written after the linker state has been exclusively
+    // locked for writing.
+    dl_operation_pending: Arc<AtomicBool>,
+}
+
+// This macro exists to ensure we don't get into a deadlock with another pending
+// DL operation. The linker state must be locked for write *ONLY THROUGH THIS
+// MACRO*. Bad things happen otherwise.
+// We also need a lock on the specific group's state here, because if there is a
+// pending DL operation we need to apply, that'll require mutable access to the
+// group's state. Rather than just lock it within the macro and cause a potential
+// deadlock, the macro requires to lock be acquired beforehand and passed in.
+macro_rules! write_linker_state {
+    ($guard:ident, $linker:expr, $group_state:ident, $ctx:ident) => {
+        #[allow(unused_mut)]
+        let mut $guard = loop {
+            match $linker.linker_state.try_write() {
+                Ok(guard) => break guard,
+                Err(TryLockError::WouldBlock) => {
+                    // The group that holds the lock is most likely waiting for an op
+                    // to finish, so we should help it with that...
+                    let env = $ctx.as_ref();
+                    let mut store = $ctx.as_store_mut();
+                    $linker.do_pending_link_operations_internal($group_state, &mut store, &env)?;
+                    // ... and sleep for a while before attempting the lock again, so
+                    // everything has time to settle. We don't care too much about the
+                    // performance of the actual DL ops, since those will be few and
+                    // far in between (hopefully!).
+                    std::thread::sleep(std::time::Duration::from_millis(10));
+                }
+                Err(TryLockError::Poisoned(_)) => panic!("The linker state's lock is poisoned"),
+            }
+        };
+    };
+}
+
+macro_rules! lock_instance_group_state {
+    ($guard:ident, $state:ident, $linker:expr, $err:expr) => {
+        let mut $guard = $linker.instance_group_state.lock().unwrap();
+        if $guard.is_none() {
+            return Err($err);
+        }
+        let $state = $guard.deref_mut().as_mut().unwrap();
+    };
+}
+
+impl std::fmt::Debug for Linker {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Linker").finish()
+    }
+}
+
+pub enum DlModuleSpec<'a> {
+    FileSystem {
+        module_spec: &'a Path,
+        ld_library_path: &'a [&'a Path],
+    },
+    Memory {
+        module_name: &'a str,
+        bytes: &'a [u8],
+    },
+}
+
+impl std::fmt::Debug for DlModuleSpec<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::FileSystem { module_spec, .. } => f
+                .debug_struct("FileSystem")
+                .field("module_spec", module_spec)
+                .finish(),
+            Self::Memory { module_name, .. } => f
+                .debug_struct("Memory")
+                .field("module_name", module_name)
+                .finish(),
+        }
+    }
+}
+
+impl Linker {
+    /// Creates a new linker for the given main module. The module is expected to be a
+    /// PIE executable. Imports for the module will be fulfilled, so that it can start
+    /// running, and a Linker instance is returned which can then be used for the
+    /// loading/linking of further side modules.
+    pub fn new(
+        engine: Engine,
+        main_module: &Module,
+        store: &mut StoreMut<'_>,
+        memory: Option<Memory>,
+        func_env: &mut WasiFunctionEnv,
+        stack_size: u64,
+        ld_library_path: &[&Path],
+    ) -> Result<(Self, LinkedMainModule), LinkError> {
+        let dylink_section = parse_dylink0_section(main_module)?;
+
+        trace!(?dylink_section, "Loading main module");
+
+        let mut imports = import_object_for_all_wasi_versions(main_module, store, &func_env.env);
+
+        let function_table_type = main_module
+            .imports()
+            .tables()
+            .filter_map(|t| {
+                if t.ty().ty == Type::FuncRef
+                    && t.name() == "__indirect_function_table"
+                    && t.module() == "env"
+                {
+                    Some(*t.ty())
+                } else {
+                    None
+                }
+            })
+            .next()
+            .ok_or(LinkError::MissingMainModuleImport(
+                "env.__indirect_function_table".to_string(),
+            ))?;
+
+        trace!(
+            minimum_size = ?function_table_type.minimum,
+            "Creating indirect function table"
+        );
+        let indirect_function_table = Table::new(store, function_table_type, Value::FuncRef(None))
+            .map_err(LinkError::TableAllocationError)?;
+
+        // TODO: do we need to add one to the table length requested by the module? I _think_
+        // clang takes the null funcref at index zero into account in the table size, so we
+        // _may_ not need this. Need to experiment and figure this out.
+        let expected_table_length =
+            dylink_section.mem_info.table_size + MAIN_MODULE_TABLE_BASE as u32;
+        // Make sure the function table is as big as the dylink.0 section expects it to be
+        if indirect_function_table.size(store) < expected_table_length {
+            let current_size = indirect_function_table.size(store);
+            let delta = expected_table_length - current_size;
+            trace!(?current_size, ?delta, "Growing indirect function table");
+            indirect_function_table
+                .grow(store, delta, Value::FuncRef(None))
+                .map_err(LinkError::TableAllocationError)?;
+        }
+
+        trace!(
+            size = indirect_function_table.size(store),
+            "Indirect function table initial size"
+        );
+
+        let memory_type = main_module
+            .imports()
+            .memories()
+            .filter_map(|t| {
+                if t.name() == "memory" && t.module() == "env" {
+                    Some(*t.ty())
+                } else {
+                    None
+                }
+            })
+            .next()
+            .ok_or(LinkError::MissingMainModuleImport("env.memory".to_string()))?;
+
+        let memory = match memory {
+            Some(m) => m,
+            None => Memory::new(store, memory_type)?,
+        };
+
+        let stack_low = {
+            let data_end = dylink_section.mem_info.memory_size as u64;
+            if data_end % 1024 != 0 {
+                data_end + 1024 - (data_end % 1024)
+            } else {
+                data_end
+            }
+        };
+
+        if stack_size % 1024 != 0 {
+            panic!("Stack size must be 1024-bit aligned");
+        }
+
+        let stack_high = stack_low + stack_size;
+
+        // Allocate memory for the stack. This does not need to go through the memory allocator
+        // because it's always placed directly after the main module's data
+        memory.grow_at_least(store, stack_high)?;
+
+        trace!(
+            memory_pages = ?memory.grow(store, 0).unwrap(),
+            stack_low,
+            stack_high,
+            "Memory layout"
+        );
+
+        let stack_pointer_import = main_module
+            .imports()
+            .find(|i| i.module() == "env" && i.name() == "__stack_pointer")
+            .ok_or(LinkError::MissingMainModuleImport(
+                "__stack_pointer".to_string(),
+            ))?;
+
+        let stack_pointer = define_integer_global_import(store, &stack_pointer_import, stack_high)?;
+
+        let c_longjmp = Tag::new(store, vec![Type::I32]);
+        let cpp_exception = Tag::new(store, vec![Type::I32]);
+
+        let mut barrier_tx = Bus::new(1);
+        let barrier_rx = barrier_tx.add_rx();
+        let mut operation_tx = Bus::new(1);
+        let operation_rx = operation_tx.add_rx();
+
+        let mut instance_group = InstanceGroupState {
+            main_instance: None,
+            // Every main instance's TLS area is at the start of its memory,
+            // which is 0 for the main module's main instance
+            main_instance_tls_base: MAIN_MODULE_MEMORY_BASE,
+            side_instances: HashMap::new(),
+            stack_pointer,
+            memory: memory.clone(),
+            indirect_function_table: indirect_function_table.clone(),
+            c_longjmp,
+            cpp_exception,
+            recv_pending_operation_barrier: barrier_rx,
+            recv_pending_operation: operation_rx,
+        };
+
+        let mut linker_state = LinkerState {
+            engine,
+            main_module: main_module.clone(),
+            main_module_dylink_info: dylink_section,
+            side_modules: BTreeMap::new(),
+            side_modules_by_name: HashMap::new(),
+            next_module_handle: MAIN_MODULE_HANDLE.0 + 1,
+            memory_allocator: MemoryAllocator::new(),
+            allocated_closure_functions: BTreeMap::new(),
+            available_closure_functions: Vec::new(),
+            heap_base: stack_high,
+            symbol_resolution_records: HashMap::new(),
+            send_pending_operation_barrier: barrier_tx,
+            send_pending_operation: operation_tx,
+        };
+
+        let mut link_state = InProgressLinkState::default();
+
+        let well_known_imports = [
+            ("env", "__memory_base", MAIN_MODULE_MEMORY_BASE),
+            ("env", "__table_base", MAIN_MODULE_TABLE_BASE),
+            ("GOT.mem", "__stack_high", stack_high),
+            ("GOT.mem", "__stack_low", stack_low),
+            ("GOT.mem", "__heap_base", stack_high),
+        ];
+
+        trace!("Resolving main module's symbols");
+        linker_state.resolve_symbols(
+            &instance_group,
+            store,
+            main_module,
+            MAIN_MODULE_HANDLE,
+            &mut link_state,
+            &well_known_imports,
+        )?;
+
+        trace!("Populating main module's imports object");
+        instance_group.populate_imports_from_link_state(
+            MAIN_MODULE_HANDLE,
+            &mut linker_state,
+            &mut link_state,
+            store,
+            main_module,
+            &mut imports,
+            &func_env.env,
+            &well_known_imports,
+        )?;
+
+        // TODO: figure out which way is faster (stubs in main or stubs in sides),
+        // use that ordering. My *guess* is that, since main exports all the libc
+        // functions and those are called frequently by basically any code, then giving
+        // stubs to main will be faster, but we need numbers before we decide this.
+        let main_instance = Instance::new(store, main_module, &imports)?;
+        instance_group.main_instance = Some(main_instance.clone());
+
+        let runtime_path = linker_state.main_module_dylink_info.runtime_path.clone();
+        for needed in linker_state.main_module_dylink_info.needed.clone() {
+            // A successful load_module will add the module to the side_modules list,
+            // from which symbols can be resolved in the following call to
+            // guard.resolve_imports.
+            trace!(name = needed, "Loading module needed by main");
+            let wasi_env = func_env.data(store);
+            linker_state.load_module_tree(
+                DlModuleSpec::FileSystem {
+                    module_spec: Path::new(needed.as_str()),
+                    ld_library_path,
+                },
+                &mut link_state,
+                &wasi_env.runtime,
+                &wasi_env.state,
+                runtime_path.as_ref(),
+                // HACK: The main module doesn't have to exist in the virtual FS at all; e.g.
+                // if one runs `wasmer ../module.wasm --dir .`, we won't have access to the
+                // main module's folder within the virtual FS. This is why we're picking PWD
+                // as the $ORIGIN of the main module, which should at least be slightly
+                // sensible. The `main.wasm` file name will be stripped and only the `./`
+                // will be taken into account by `locate_module`.
+                Some(Path::new("./main.wasm")),
+            )?;
+        }
+
+        for module_handle in link_state
+            .new_modules
+            .iter()
+            .map(|m| m.handle)
+            .collect::<Vec<_>>()
+        {
+            trace!(?module_handle, "Instantiating module");
+            instance_group.instantiate_side_module_from_link_state(
+                &mut linker_state,
+                store,
+                &func_env.env,
+                &mut link_state,
+                module_handle,
+            )?;
+        }
+
+        let linker = Self {
+            linker_state: Arc::new(RwLock::new(linker_state)),
+            instance_group_state: Arc::new(Mutex::new(Some(instance_group))),
+            dl_operation_pending: Arc::new(AtomicBool::new(false)),
+        };
+
+        let stack_layout = WasiMemoryLayout {
+            stack_lower: stack_low,
+            stack_upper: stack_high,
+            stack_size: stack_high - stack_low,
+            guard_size: 0,
+            tls_base: Some(MAIN_MODULE_MEMORY_BASE),
+        };
+        let module_handles = WasiModuleTreeHandles::Dynamic {
+            linker: linker.clone(),
+            main_module_instance_handles: WasiModuleInstanceHandles::new(
+                memory.clone(),
+                store,
+                main_instance.clone(),
+                Some(indirect_function_table.clone()),
+            ),
+        };
+
+        func_env
+            .initialize_handles_and_layout(
+                store,
+                main_instance.clone(),
+                module_handles,
+                Some(stack_layout),
+                true,
+            )
+            .map_err(LinkError::MainModuleHandleInitFailed)?;
+
+        // The main module isn't added to the link state's list of new modules, so we need to
+        // call its initialization functions separately
+        trace!("Calling data relocator function for main module");
+        call_initialization_function::<()>(&main_instance, store, "__wasm_apply_data_relocs")?;
+        call_initialization_function::<()>(&main_instance, store, "__wasm_apply_tls_relocs")?;
+
+        {
+            let group_guard = linker.instance_group_state.lock().unwrap();
+            let mut linker_state = linker.linker_state.write().unwrap();
+            trace!("Finalizing linking of main module");
+            linker.finalize_link_operation(group_guard, &mut linker_state, store, link_state)?;
+        }
+
+        trace!("Calling main module's _initialize function");
+        call_initialization_function::<()>(&main_instance, store, "_initialize")?;
+
+        trace!("Link complete");
+
+        Ok((
+            linker,
+            LinkedMainModule {
+                instance: main_instance,
+                memory,
+                indirect_function_table,
+                stack_low,
+                stack_high,
+            },
+        ))
+    }
+
+    pub fn create_instance_group(
+        &self,
+        parent_ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        store: &mut StoreMut<'_>,
+        func_env: &mut WasiFunctionEnv,
+    ) -> Result<(Self, LinkedMainModule), LinkError> {
+        trace!("Spawning new instance group");
+
+        lock_instance_group_state!(
+            parent_group_state_guard,
+            parent_group_state,
+            self,
+            LinkError::InstanceGroupIsDead
+        );
+
+        // Can't have other groups do operations that don't get replicated to
+        // the new group, so lock the linker state while we work.
+        write_linker_state!(linker_state, self, parent_group_state, parent_ctx);
+
+        let parent_store = parent_ctx.as_store_mut();
+
+        let main_module = linker_state.main_module.clone();
+        let memory = parent_group_state
+            .memory
+            .share_in_store(&parent_store, store)?;
+
+        let mut imports = import_object_for_all_wasi_versions(&main_module, store, &func_env.env);
+
+        let indirect_function_table_type =
+            parent_group_state.indirect_function_table.ty(&parent_store);
+        trace!(
+            minimum_size = ?indirect_function_table_type.minimum,
+            "Creating indirect function table"
+        );
+
+        let indirect_function_table =
+            Table::new(store, indirect_function_table_type, Value::FuncRef(None))
+                .map_err(LinkError::TableAllocationError)?;
+
+        let expected_table_length = parent_group_state
+            .indirect_function_table
+            .size(&parent_store);
+        // Grow the table to be as big as the parent's
+        if indirect_function_table.size(store) < expected_table_length {
+            let current_size = indirect_function_table.size(store);
+            let delta = expected_table_length - current_size;
+            trace!(?current_size, ?delta, "Growing indirect function table");
+            indirect_function_table
+                .grow(store, delta, Value::FuncRef(None))
+                .map_err(LinkError::TableAllocationError)?;
+        }
+
+        trace!(
+            size = indirect_function_table.size(store),
+            "Indirect function table initial size"
+        );
+
+        // Since threads initialize their own stack space, we can only rely on the layout being
+        // initialized beforehand, which is the case with the thread_spawn syscall.
+        // FIXME: this needs to become a parameter if we ever decouple the linker from WASIX
+        let (stack_low, stack_high, tls_base) = {
+            let layout = &func_env.env.as_ref(store).layout;
+            (
+                layout.stack_lower,
+                layout.stack_upper,
+                layout.tls_base.expect(
+                    "tls_base must be set in memory layout of new instance group's main instance",
+                ),
+            )
+        };
+
+        trace!(stack_low, stack_high, "Memory layout");
+
+        let stack_pointer_import = main_module
+            .imports()
+            .find(|i| i.module() == "env" && i.name() == "__stack_pointer")
+            .ok_or(LinkError::MissingMainModuleImport(
+                "__stack_pointer".to_string(),
+            ))?;
+
+        // WASIX threads initialize their own stack pointer global in wasi_thread_start,
+        // so no need to initialize it to a value here.
+        let stack_pointer = define_integer_global_import(store, &stack_pointer_import, 0)?;
+
+        let c_longjmp = Tag::new(store, vec![Type::I32]);
+        let cpp_exception = Tag::new(store, vec![Type::I32]);
+
+        let barrier_rx = linker_state.send_pending_operation_barrier.add_rx();
+        let operation_rx = linker_state.send_pending_operation.add_rx();
+
+        let mut instance_group = InstanceGroupState {
+            main_instance: None,
+            main_instance_tls_base: tls_base,
+            side_instances: HashMap::new(),
+            stack_pointer,
+            memory: memory.clone(),
+            indirect_function_table: indirect_function_table.clone(),
+            c_longjmp,
+            cpp_exception,
+            recv_pending_operation_barrier: barrier_rx,
+            recv_pending_operation: operation_rx,
+        };
+
+        let mut pending_resolutions = PendingResolutionsFromLinker::default();
+
+        let well_known_imports = [
+            ("env", "__memory_base", MAIN_MODULE_MEMORY_BASE),
+            ("env", "__table_base", MAIN_MODULE_TABLE_BASE),
+            ("GOT.mem", "__stack_high", stack_high),
+            ("GOT.mem", "__stack_low", stack_low),
+            ("GOT.mem", "__heap_base", linker_state.heap_base),
+        ];
+
+        trace!("Populating imports object for new instance group's main instance");
+        instance_group.populate_imports_from_linker(
+            MAIN_MODULE_HANDLE,
+            &linker_state,
+            store,
+            &main_module,
+            &mut imports,
+            &func_env.env,
+            &well_known_imports,
+            &mut pending_resolutions,
+        )?;
+
+        let main_instance = Instance::new(store, &main_module, &imports)?;
+
+        instance_group.main_instance = Some(main_instance.clone());
+
+        for side in &linker_state.side_modules {
+            trace!(module_handle = ?side.0, "Instantiating existing side module");
+            instance_group.instantiate_side_module_from_linker(
+                &linker_state,
+                store,
+                &func_env.env,
+                *side.0,
+                &mut pending_resolutions,
+            )?;
+        }
+
+        trace!("Finalizing pending functions");
+        instance_group.finalize_pending_resolutions_from_linker(&pending_resolutions, store)?;
+
+        trace!("Applying externally-requested function table entries");
+        instance_group.apply_requested_symbols_from_linker(store, &linker_state)?;
+
+        let linker = Self {
+            linker_state: self.linker_state.clone(),
+            instance_group_state: Arc::new(Mutex::new(Some(instance_group))),
+            dl_operation_pending: self.dl_operation_pending.clone(),
+        };
+
+        let module_handles = WasiModuleTreeHandles::Dynamic {
+            linker: linker.clone(),
+            main_module_instance_handles: WasiModuleInstanceHandles::new(
+                memory.clone(),
+                store,
+                main_instance.clone(),
+                Some(indirect_function_table.clone()),
+            ),
+        };
+
+        func_env
+            .initialize_handles_and_layout(
+                store,
+                main_instance.clone(),
+                module_handles,
+                None,
+                false,
+            )
+            .map_err(LinkError::MainModuleHandleInitFailed)?;
+
+        trace!("Instance group spawned successfully");
+
+        Ok((
+            linker,
+            LinkedMainModule {
+                instance: main_instance,
+                memory,
+                indirect_function_table,
+                stack_low,
+                stack_high,
+            },
+        ))
+    }
+
+    pub fn shutdown_instance_group(
+        &self,
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    ) -> Result<(), LinkError> {
+        trace!("Shutting instance group down");
+
+        let mut guard = self.instance_group_state.lock().unwrap();
+        match guard.as_mut() {
+            None => Ok(()),
+            Some(group_state) => {
+                // We need to do this even if the results of an incoming dl op will be thrown away;
+                // this is because the instigating group will have counted us and we need to hit the
+                // barrier twice to unblock everybody else.
+                write_linker_state!(linker_state, self, group_state, ctx);
+                guard.take();
+                drop(linker_state);
+
+                trace!("Instance group shut down");
+
+                Ok(())
+            }
+        }
+    }
+
+    /// Allocate a index for a closure in the indirect function table
+    pub fn allocate_closure_index(
+        &self,
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    ) -> Result<u32, LinkError> {
+        lock_instance_group_state!(
+            group_state_guard,
+            group_state,
+            self,
+            LinkError::InstanceGroupIsDead
+        );
+        write_linker_state!(linker_state, self, group_state, ctx);
+
+        let mut store = ctx.as_store_mut();
+
+        // Use a previously allocated slot if possible
+        if let Some(function_index) = linker_state.available_closure_functions.pop() {
+            linker_state
+                .allocated_closure_functions
+                .insert(function_index, true);
+            return Ok(function_index);
+        }
+
+        // Allocate more closures than we need to reduce the number of sync operations
+        const CLOSURE_ALLOCATION_SIZE: u32 = 100;
+
+        let function_index = group_state
+            .allocate_function_table(&mut store, CLOSURE_ALLOCATION_SIZE, 0)
+            .map_err(LinkError::TableAllocationError)? as u32;
+
+        linker_state
+            .available_closure_functions
+            .reserve(CLOSURE_ALLOCATION_SIZE as usize - 1);
+        for i in 1..CLOSURE_ALLOCATION_SIZE {
+            linker_state
+                .available_closure_functions
+                .push(function_index + i);
+            linker_state
+                .allocated_closure_functions
+                .insert(function_index + i, false);
+        }
+        linker_state
+            .allocated_closure_functions
+            .insert(function_index, true);
+
+        self.synchronize_link_operation(
+            DlOperation::AllocateFunctionTable {
+                index: function_index,
+                size: CLOSURE_ALLOCATION_SIZE,
+            },
+            linker_state,
+            group_state,
+            &ctx.data().process,
+            ctx.data().tid(),
+        );
+
+        Ok(function_index)
+    }
+
+    /// Remove a previously allocated slot for a closure in the indirect function table
+    ///
+    /// After calling this it is undefined behavior to call the function at the given index.
+    pub fn free_closure_index(
+        &self,
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        function_id: u32,
+    ) -> Result<(), LinkError> {
+        lock_instance_group_state!(
+            group_state_guard,
+            group_state,
+            self,
+            LinkError::InstanceGroupIsDead
+        );
+        write_linker_state!(linker_state, self, group_state, ctx);
+
+        let Some(entry) = linker_state
+            .allocated_closure_functions
+            .get_mut(&function_id)
+        else {
+            // Not allocated
+            return Ok(());
+        };
+        if !*entry {
+            // Not used
+            return Ok(());
+        }
+
+        *entry = false;
+        linker_state.available_closure_functions.push(function_id);
+        Ok(())
+    }
+
+    /// Check if an indirect_function_table entry is reserved for closures.
+    ///
+    /// Returns false if the entry is not reserved for closures.
+    pub fn is_closure(&self, function_id: u32) -> bool {
+        // TODO: Check if this can result in a deadlock
+        let linker = self.linker_state.read().unwrap();
+        linker
+            .allocated_closure_functions
+            .contains_key(&function_id)
+    }
+
+    /// Loads a side module from the given path, linking it against the existing module tree
+    /// and instantiating it. Symbols from the module can then be retrieved by calling
+    /// [`Linker::resolve_export`].
+    pub fn load_module(
+        &self,
+        module_spec: DlModuleSpec,
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    ) -> Result<ModuleHandle, LinkError> {
+        trace!(?module_spec, "Loading module");
+
+        lock_instance_group_state!(
+            group_state_guard,
+            group_state,
+            self,
+            LinkError::InstanceGroupIsDead
+        );
+
+        // TODO: differentiate between an actual link error and an error that occurs as the
+        // result of a pending operation that needs to be applied first. Currently, errors
+        // from pending ops are treated as link errors and just reported to guest code rather
+        // than terminating the process.
+        write_linker_state!(linker_state, self, group_state, ctx);
+
+        let mut link_state = InProgressLinkState::default();
+        let env = ctx.as_ref();
+        let mut store = ctx.as_store_mut();
+
+        trace!("Loading module tree for requested module");
+        let wasi_env = env.as_ref(&store);
+        let runtime_path: &[String] = &[];
+        let module_handle = linker_state.load_module_tree(
+            module_spec,
+            &mut link_state,
+            &wasi_env.runtime,
+            &wasi_env.state,
+            runtime_path,          // No runtime path when loading a module via dlopen
+            Option::<&Path>::None, // Empty runtime path means we don't need the module's path either
+        )?;
+
+        let new_modules = link_state
+            .new_modules
+            .iter()
+            .map(|m| m.handle)
+            .collect::<Vec<_>>();
+
+        for handle in &new_modules {
+            trace!(?module_handle, "Instantiating module");
+            group_state.instantiate_side_module_from_link_state(
+                &mut linker_state,
+                &mut store,
+                &env,
+                &mut link_state,
+                *handle,
+            )?;
+        }
+
+        trace!("Finalizing link");
+        self.finalize_link_operation(group_state_guard, &mut linker_state, &mut store, link_state)?;
+
+        if !new_modules.is_empty() {
+            // The group state is unlocked for stub functions, now lock it again
+            lock_instance_group_state!(
+                group_state_guard,
+                group_state,
+                self,
+                LinkError::InstanceGroupIsDead
+            );
+
+            self.synchronize_link_operation(
+                DlOperation::LoadModules(new_modules),
+                linker_state,
+                group_state,
+                &ctx.data().process,
+                ctx.data().tid(),
+            );
+        }
+
+        // FIXME: If we fail at an intermediate step, we should reset the linker's state, a la:
+        // if result.is_err() {
+        //     let mut guard = self.state.lock().unwrap();
+        //     let memory = guard.memory.clone();
+
+        //     for module_handle in link_state.module_handles.iter().cloned() {
+        //         let module = guard.side_modules.remove(&module_handle).unwrap();
+        //         guard
+        //             .side_module_names
+        //             .retain(|_, handle| *handle != module_handle);
+        //         // We already have an error we need to report, so ignore memory deallocation errors
+        //         _ = guard
+        //             .memory_allocator
+        //             .deallocate(&memory, store, module.memory_base);
+        //     }
+        // }
+
+        trace!("Module load complete");
+
+        Ok(module_handle)
+    }
+
+    fn finalize_link_operation(
+        &self,
+        // Take ownership of the guard and drop it ourselves to ensure no deadlock can happen
+        mut group_state_guard: MutexGuard<'_, Option<InstanceGroupState>>,
+        linker_state: &mut LinkerState,
+        store: &mut impl AsStoreMut,
+        link_state: InProgressLinkState,
+    ) -> Result<(), LinkError> {
+        let group_state = group_state_guard.as_mut().unwrap();
+
+        trace!(?link_state, "Finalizing link operation");
+
+        group_state.finalize_pending_globals(
+            linker_state,
+            store,
+            &link_state.unresolved_globals,
+        )?;
+
+        let new_instances = link_state
+            .new_modules
+            .iter()
+            .map(|m| group_state.side_instances[&m.handle].instance.clone())
+            .collect::<Vec<_>>();
+
+        // The instance group must be unlocked for the next step, since modules may need to resolve
+        // stub functions and that requires a lock on the instance group's state
+        drop(group_state_guard);
+
+        // These functions are exported from PIE executables, and need to be run before calling
+        // _initialize or _start. More info:
+        // https://github.com/WebAssembly/tool-conventions/blob/main/DynamicLinking.md
+        trace!("Calling data relocation functions");
+        for instance in &new_instances {
+            call_initialization_function::<()>(instance, store, "__wasm_apply_data_relocs")?;
+            call_initialization_function::<()>(instance, store, "__wasm_apply_tls_relocs")?;
+        }
+
+        trace!("Calling ctor functions");
+        for instance in &new_instances {
+            call_initialization_function::<()>(instance, store, "__wasm_call_ctors")?;
+        }
+
+        Ok(())
+    }
+
+    // TODO: Support RTLD_NEXT
+    /// Resolves an export from the module corresponding to the given module handle.
+    /// Only functions and globals can be resolved.
+    ///
+    /// If the symbol is a global, the returned value will be the absolute address of
+    /// the data corresponding to that global within the shared linear memory.
+    ///
+    /// If it's a function, it'll be placed into the indirect function table,
+    /// which creates a "function pointer" that can be used from WASM code.
+    pub fn resolve_export(
+        &self,
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        module_handle: Option<ModuleHandle>,
+        symbol: &str,
+    ) -> Result<ResolvedExport, ResolveError> {
+        trace!(?module_handle, symbol, "Resolving symbol");
+
+        let resolution_key = SymbolResolutionKey::Requested {
+            resolve_from: module_handle,
+            name: symbol.to_string(),
+        };
+
+        lock_instance_group_state!(guard, group_state, self, ResolveError::InstanceGroupIsDead);
+
+        if let Ok(linker_state) = self.linker_state.try_read() {
+            if let Some(resolution) = linker_state.symbol_resolution_records.get(&resolution_key) {
+                trace!(?resolution, "Already have a resolution for this symbol");
+                match resolution {
+                    SymbolResolutionResult::FunctionPointer {
+                        function_table_index: addr,
+                        ..
+                    } => {
+                        return Ok(ResolvedExport::Function {
+                            func_ptr: *addr as u64,
+                        })
+                    }
+                    SymbolResolutionResult::Memory(addr) => {
+                        return Ok(ResolvedExport::Global { data_ptr: *addr })
+                    }
+                    SymbolResolutionResult::Tls {
+                        resolved_from,
+                        offset,
+                    } => {
+                        let Some(tls_base) = group_state.tls_base(*resolved_from) else {
+                            return Err(ResolveError::TlsSymbolWithoutTls);
+                        };
+                        return Ok(ResolvedExport::Global {
+                            data_ptr: tls_base + offset,
+                        });
+                    }
+                    r => panic!(
+                        "Internal error: unexpected symbol resolution \
+                        {r:?} for requested symbol {symbol}"
+                    ),
+                }
+            }
+        }
+
+        write_linker_state!(linker_state, self, group_state, ctx);
+
+        let mut store = ctx.as_store_mut();
+
+        trace!("Resolving export");
+        let (export, resolved_from) =
+            group_state.resolve_export(&linker_state, &mut store, module_handle, symbol, false)?;
+
+        trace!(?export, ?resolved_from, "Resolved export");
+
+        match export {
+            PartiallyResolvedExport::Global(addr) => {
+                linker_state
+                    .symbol_resolution_records
+                    .insert(resolution_key, SymbolResolutionResult::Memory(addr));
+
+                Ok(ResolvedExport::Global { data_ptr: addr })
+            }
+            PartiallyResolvedExport::Tls { offset, final_addr } => {
+                linker_state.symbol_resolution_records.insert(
+                    resolution_key,
+                    SymbolResolutionResult::Tls {
+                        resolved_from,
+                        offset,
+                    },
+                );
+
+                Ok(ResolvedExport::Global {
+                    data_ptr: final_addr,
+                })
+            }
+            PartiallyResolvedExport::Function(func) => {
+                let func_ptr = group_state
+                    .append_to_function_table(&mut store, func.clone())
+                    .map_err(ResolveError::TableAllocationError)?;
+                trace!(
+                    ?func_ptr,
+                    table_size = group_state.indirect_function_table.size(&store),
+                    "Placed resolved function into table"
+                );
+                linker_state.symbol_resolution_records.insert(
+                    resolution_key,
+                    SymbolResolutionResult::FunctionPointer {
+                        resolved_from,
+                        function_table_index: func_ptr,
+                    },
+                );
+
+                self.synchronize_link_operation(
+                    DlOperation::ResolveFunction {
+                        name: symbol.to_string(),
+                        resolved_from,
+                        function_table_index: func_ptr,
+                    },
+                    linker_state,
+                    group_state,
+                    &ctx.data().process,
+                    ctx.data().tid(),
+                );
+
+                Ok(ResolvedExport::Function {
+                    func_ptr: func_ptr as u64,
+                })
+            }
+        }
+    }
+
+    pub fn is_handle_valid(
+        &self,
+        handle: ModuleHandle,
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    ) -> Result<bool, LinkError> {
+        // Remember, trying to get a read lock here can deadlock if a dl op is pending
+        lock_instance_group_state!(guard, group_state, self, LinkError::InstanceGroupIsDead);
+        write_linker_state!(linker_state, self, group_state, ctx);
+        Ok(linker_state.side_modules.contains_key(&handle))
+    }
+
+    // Note: the caller needs to have applied the link operation beforehand to ensure
+    // there are no (recoverable) errors. This function can only have unrecoverable
+    // errors (i.e. panics).
+    fn synchronize_link_operation(
+        &self,
+        op: DlOperation,
+        mut linker_state_write_lock: RwLockWriteGuard<LinkerState>,
+        group_state: &mut InstanceGroupState,
+        wasi_process: &WasiProcess,
+        self_thread_id: WasiThreadId,
+    ) {
+        trace!(?op, "Synchronizing link operation");
+
+        let num_groups = linker_state_write_lock.send_pending_operation.rx_count();
+
+        if num_groups <= 1 {
+            trace!("No other living instance groups, nothing to do");
+            return;
+        }
+
+        // Create and broadcast the barrier, so we have a rendezvous point
+        let barrier = Arc::new(Barrier::new(num_groups));
+        if linker_state_write_lock
+            .send_pending_operation_barrier
+            .try_broadcast(barrier.clone())
+            .is_err()
+        {
+            // The bus is given a capacity of one to ensure we can't ever get here
+            // more than once concurrently.
+            panic!("Internal error: more than one synchronized link operation active")
+        }
+
+        // Set the flag, so others know they should stop now
+        self.dl_operation_pending.store(true, Ordering::SeqCst);
+
+        trace!("Signalling wasix threads to wake up");
+        for thread in wasi_process
+            .all_threads()
+            .into_iter()
+            .filter(|tid| *tid != self_thread_id)
+        {
+            // Signal all threads to wake them up if they're sleeping or idle
+            wasi_process.signal_thread(&thread, wasmer_wasix_types::wasi::Signal::Sigwakeup);
+        }
+
+        trace!("Waiting at barrier");
+        // Wait for all other threads to hit the barrier
+        barrier.wait();
+
+        trace!("All threads now processing dl op");
+
+        // Reset the flag once everybody's seen it
+        self.dl_operation_pending.store(false, Ordering::SeqCst);
+
+        // Now we broadcast the actual operation. This has to happen before
+        // we release the write lock, since exclusive access to the bus is
+        // required.
+        if linker_state_write_lock
+            .send_pending_operation
+            .try_broadcast(op.clone())
+            .is_err()
+        {
+            // Same deal with the bus capacity
+            panic!("Internal error: more than one synchronized link operation active")
+        }
+
+        // Now that everyone's at a safe point, we can unlock the shared state
+        // and take another read lock. This is safe because everybody else will
+        // also be taking only a read lock between the two barrier waits, and
+        // no write locks can happen.
+        trace!("Unlocking linker state");
+        drop(linker_state_write_lock);
+        let linker_state_read_lock = self.linker_state.read().unwrap();
+
+        // Read and drop the barrier and operation from our own receivers, so
+        // the bus is freed up
+        _ = group_state.recv_pending_operation_barrier.recv().unwrap();
+        _ = group_state.recv_pending_operation.recv().unwrap();
+
+        // Second barrier, to make sure everyone applied the change. Necessary
+        // because another thread may exit do_pending_link_operations and acquire
+        // a write lock before anybody else has had the chance to get a read lock
+        // without this wait in place.
+        trace!("Waiting for other threads to finish processing the dl op");
+        barrier.wait();
+
+        // Drop the read lock after everyone is done.
+        drop(linker_state_read_lock);
+
+        trace!("Synchronization complete");
+    }
+
+    pub(crate) fn do_pending_link_operations(
+        &self,
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fast: bool,
+    ) -> Result<(), LinkError> {
+        // If no operation is pending, we can return immediately. This is the
+        // hot path. If we happen to miss an operation that we would have
+        // caught, no big deal; this will be called again later. However,
+        // in the case where we raise a signal and it's caught by another thread,
+        // we can't have this read go missing, otherwise the other thread will
+        // sleep again and miss the notification. Hence the option to pick fast or
+        // slow.
+        if !self.dl_operation_pending.load(if fast {
+            Ordering::Relaxed
+        } else {
+            Ordering::SeqCst
+        }) {
+            return Ok(());
+        }
+
+        lock_instance_group_state!(guard, group_state, self, LinkError::InstanceGroupIsDead);
+
+        let env = ctx.as_ref();
+        let mut store = ctx.as_store_mut();
+        self.do_pending_link_operations_internal(group_state, &mut store, &env)
+    }
+
+    fn do_pending_link_operations_internal(
+        &self,
+        group_state: &mut InstanceGroupState,
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<WasiEnv>,
+    ) -> Result<(), LinkError> {
+        if !self.dl_operation_pending.load(Ordering::SeqCst) {
+            return Ok(());
+        }
+
+        trace!("Pending link operation discovered, will process");
+
+        // Receive and wait for the barrier.
+        let barrier = group_state.recv_pending_operation_barrier.recv().expect(
+            "Failed to receive barrier while a DL operation was \
+            in progress; this condition can't be recovered from",
+        );
+        barrier.wait();
+
+        trace!("Past the barrier, now processing operation");
+
+        // After everyone, including the instigating group has rendezvoused at
+        // the first barrier, the operation should have been broadcast.
+        let op = group_state.recv_pending_operation.recv().unwrap();
+        // Once past the barrier, the instigating group will downgrade its
+        // lock to a read lock, so we can also get a read lock here.
+        let linker_state = self.linker_state.read().unwrap();
+
+        let result = group_state.apply_dl_operation(linker_state.deref(), op, store, env);
+
+        trace!("Operation applied, now waiting at second barrier");
+
+        // Rendezvous one more time to make sure everybody's done, and nobody's
+        // going to start another DL operation before that happens.
+        barrier.wait();
+        // Drop the read lock after the
+        drop(linker_state);
+
+        trace!("Pending link operation applied successfully");
+
+        result
+    }
+}
+
+impl LinkerState {
+    fn allocate_memory(
+        &mut self,
+        store: &mut impl AsStoreMut,
+        memory: &Memory,
+        mem_info: &wasmparser::MemInfo,
+    ) -> Result<u64, MemoryError> {
+        trace!(?mem_info, "Allocating memory");
+
+        let new_size = if mem_info.memory_size == 0 {
+            0
+        } else {
+            self.memory_allocator.allocate(
+                memory,
+                store,
+                mem_info.memory_size,
+                2_u32.pow(mem_info.memory_alignment),
+            )? as u64
+        };
+
+        trace!(new_size, "Final size");
+
+        Ok(new_size)
+    }
+
+    fn memory_base(&self, module_handle: ModuleHandle) -> u64 {
+        if module_handle == MAIN_MODULE_HANDLE {
+            MAIN_MODULE_MEMORY_BASE
+        } else {
+            self.side_modules
+                .get(&module_handle)
+                .expect("Internal error: bad module handle")
+                .memory_base
+        }
+    }
+
+    fn dylink_info(&self, module_handle: ModuleHandle) -> &DylinkInfo {
+        if module_handle == MAIN_MODULE_HANDLE {
+            &self.main_module_dylink_info
+        } else {
+            &self
+                .side_modules
+                .get(&module_handle)
+                .expect("Internal error: bad module handle")
+                .dylink_info
+        }
+    }
+
+    // Resolves all imports for the given module, and places the results into
+    // the in progress link state's symbol collection.
+    // A follow-up call to [`InstanceGroupState::populate_imports_from_link_state`]
+    // is needed to create a usable imports object, which needs to happen once per
+    // instance group.
+    // Each instance group has a different store, so the group ID corresponding
+    // to the given store must be provided to resolve globals from the correct
+    // instances.
+    fn resolve_symbols(
+        &self,
+        group: &InstanceGroupState,
+        store: &mut impl AsStoreMut,
+        module: &Module,
+        module_handle: ModuleHandle,
+        link_state: &mut InProgressLinkState,
+        // Used only to "skip over" well known imports, so we don't actually need the
+        // u64 values. However, we use the same type as populate_imports to let calling
+        // code construct the data only once.
+        well_known_imports: &[(&str, &str, u64)],
+    ) -> Result<(), LinkError> {
+        trace!(?module_handle, "Resolving symbols");
+        for import in module.imports() {
+            // Skip over well known imports, since they'll be provided externally
+            if well_known_imports
+                .iter()
+                .any(|i| i.0 == import.module() && i.1 == import.name())
+            {
+                trace!(?import, "Skipping resolution of well-known symbol");
+                continue;
+            }
+
+            // Skip over the memory, function table and stack pointer imports as well
+            match import.name() {
+                "memory"
+                | "__indirect_function_table"
+                | "__stack_pointer"
+                | "__c_longjmp"
+                | "__cpp_exception" => {
+                    trace!(?import, "Skipping resolution of special symbol");
+                    continue;
+                }
+                _ => (),
+            }
+
+            match import.module() {
+                "env" => {
+                    let resolution = self.resolve_env_symbol(group, &import, store)?;
+                    trace!(?import, ?resolution, "Symbol resolved");
+                    link_state.symbols.insert(
+                        NeededSymbolResolutionKey {
+                            module_handle,
+                            import_module: "env".to_owned(),
+                            import_name: import.name().to_string(),
+                        },
+                        resolution,
+                    );
+                }
+                "GOT.mem" => {
+                    let resolution = self.resolve_got_mem_symbol(group, &import, store)?;
+                    trace!(?import, ?resolution, "Symbol resolved");
+                    link_state.symbols.insert(
+                        NeededSymbolResolutionKey {
+                            module_handle,
+                            import_module: "GOT.mem".to_owned(),
+                            import_name: import.name().to_string(),
+                        },
+                        resolution,
+                    );
+                }
+                "GOT.func" => {
+                    let resolution = self.resolve_got_func_symbol(group, &import, store)?;
+                    trace!(?import, ?resolution, "Symbol resolved");
+                    link_state.symbols.insert(
+                        NeededSymbolResolutionKey {
+                            module_handle,
+                            import_module: "GOT.func".to_owned(),
+                            import_name: import.name().to_string(),
+                        },
+                        resolution,
+                    );
+                }
+                _ => (),
+            }
+        }
+
+        trace!(?module_handle, "All symbols resolved");
+
+        Ok(())
+    }
+
+    // Imports from the env module are:
+    //   * the memory and indirect function table
+    //   * well-known addresses, such as __stack_pointer and __memory_base
+    //   * functions that are imported directly
+    // resolve_env_symbol only handles the imported functions.
+    fn resolve_env_symbol(
+        &self,
+        group: &InstanceGroupState,
+        import: &ImportType,
+        store: &impl AsStoreRef,
+    ) -> Result<InProgressSymbolResolution, LinkError> {
+        let ExternType::Function(import_func_ty) = import.ty() else {
+            return Err(LinkError::ImportMustBeFunction(
+                "env",
+                import.name().to_string(),
+            ));
+        };
+
+        let export = group.resolve_exported_symbol(import.name());
+
+        match export {
+            Some((module_handle, export)) => {
+                let Extern::Function(export_func) = export else {
+                    return Err(LinkError::ImportTypeMismatch(
+                        "env".to_string(),
+                        import.name().to_string(),
+                        ExternType::Function(import_func_ty.clone()),
+                        export.ty(store).clone(),
+                    ));
+                };
+
+                if export_func.ty(store) != *import_func_ty {
+                    return Err(LinkError::ImportTypeMismatch(
+                        "env".to_string(),
+                        import.name().to_string(),
+                        ExternType::Function(import_func_ty.clone()),
+                        export.ty(store).clone(),
+                    ));
+                }
+
+                Ok(InProgressSymbolResolution::Function(module_handle))
+            }
+            None => {
+                // The function may be exported from a module we have yet to link in,
+                // or otherwise not be used by the module at all. We provide a stub that,
+                // when called, will try to resolve the symbol and call it. This lets
+                // us resolve circular dependencies, as well as letting modules that don't
+                // actually use their imports run successfully.
+                Ok(InProgressSymbolResolution::StubFunction(
+                    import_func_ty.clone(),
+                ))
+            }
+        }
+    }
+
+    // "Global" imports (i.e. imports from GOT.mem and GOT.func) are integer globals.
+    // GOT.mem imports should point to the address of another module's data.
+    fn resolve_got_mem_symbol(
+        &self,
+        group: &InstanceGroupState,
+        import: &ImportType,
+        store: &impl AsStoreRef,
+    ) -> Result<InProgressSymbolResolution, LinkError> {
+        let global_type = get_integer_global_type_from_import(import)?;
+
+        match group.resolve_exported_symbol(import.name()) {
+            Some((module_handle, export)) => {
+                let ExternType::Global(global_type) = export.ty(store) else {
+                    return Err(LinkError::ImportTypeMismatch(
+                        "GOT.mem".to_string(),
+                        import.name().to_string(),
+                        ExternType::Global(global_type),
+                        export.ty(store).clone(),
+                    ));
+                };
+
+                if !matches!(global_type.ty, Type::I32 | Type::I64) {
+                    return Err(LinkError::ImportTypeMismatch(
+                        "GOT.mem".to_string(),
+                        import.name().to_string(),
+                        ExternType::Global(global_type),
+                        export.ty(store).clone(),
+                    ));
+                }
+
+                Ok(InProgressSymbolResolution::MemGlobal(module_handle))
+            }
+            None => Ok(InProgressSymbolResolution::UnresolvedMemGlobal),
+        }
+    }
+
+    // "Global" imports (i.e. imports from GOT.mem and GOT.func) are integer globals.
+    // GOT.func imports are function pointers (i.e. indices into the indirect function
+    // table).
+    fn resolve_got_func_symbol(
+        &self,
+        group: &InstanceGroupState,
+        import: &ImportType,
+        store: &impl AsStoreRef,
+    ) -> Result<InProgressSymbolResolution, LinkError> {
+        // Ensure the global is the correct type (i32 or i64)
+        let _ = get_integer_global_type_from_import(import)?;
+
+        match group.resolve_exported_symbol(import.name()) {
+            Some((module_handle, export)) => {
+                let ExternType::Function(_) = export.ty(store) else {
+                    return Err(LinkError::ExportMustBeFunction(
+                        import.name().to_string(),
+                        export.ty(store).clone(),
+                    ));
+                };
+
+                Ok(InProgressSymbolResolution::FuncGlobal(module_handle))
+            }
+            None => Ok(InProgressSymbolResolution::UnresolvedFuncGlobal),
+        }
+    }
+
+    // TODO: give loaded library a different wasi env that specifies its module handle
+    // This function loads the module (and its needed modules) and puts the resulting `Module`s
+    // in the linker state, while assigning handles and putting the handles in the in-progress
+    // link state. The modules must then get their symbols resolved and be instantiated in the
+    // order in which their handles exist in the link state.
+    // Returns the handle of the originally requested module. This will be the last entry in
+    // the link state's list of module handles, but only if the module was actually loaded; if
+    // it was already loaded, the existing handle is returned.
+    fn load_module_tree(
+        &mut self,
+        module_spec: DlModuleSpec,
+        link_state: &mut InProgressLinkState,
+        runtime: &Arc<dyn Runtime + Send + Sync + 'static>,
+        wasi_state: &WasiState,
+        runtime_path: &[impl AsRef<str>],
+        calling_module_path: Option<impl AsRef<Path>>,
+    ) -> Result<ModuleHandle, LinkError> {
+        let module_name = match module_spec {
+            DlModuleSpec::FileSystem { module_spec, .. } => Cow::Borrowed(module_spec),
+            DlModuleSpec::Memory { module_name, .. } => {
+                Cow::Owned(PathBuf::from(format!("::in-memory::{module_name}")))
+            }
+        };
+        trace!(?module_name, "Locating and loading module");
+
+        if let Some(handle) = self.side_modules_by_name.get(module_name.as_ref()) {
+            let handle = *handle;
+
+            trace!(?module_name, ?handle, "Module was already loaded");
+
+            return Ok(handle);
+        }
+
+        // Locate and load the module bytes
+        let (module_data, paths) = match module_spec {
+            DlModuleSpec::FileSystem {
+                module_spec,
+                ld_library_path,
+            } => {
+                let (full_path, bytes) = InlineWaker::block_on(locate_module(
+                    module_spec,
+                    ld_library_path,
+                    runtime_path,
+                    calling_module_path,
+                    &wasi_state.fs,
+                ))?;
+                // TODO: this can be optimized by detecting early if the module is already
+                // pending without loading its bytes
+                if link_state.pending_module_paths.contains(&full_path) {
+                    trace!("Module is already pending, won't load again");
+                    // This is fine, since a non-empty pending_modules list means we are
+                    // recursively resolving needed modules. We don't use the handle
+                    // returned from this function for anything when running recursively
+                    // (see self.load_module call below).
+                    return Ok(INVALID_MODULE_HANDLE);
+                }
+
+                (
+                    HashedModuleData::new(bytes),
+                    Some((full_path, ld_library_path)),
+                )
+            }
+            DlModuleSpec::Memory { bytes, .. } => (HashedModuleData::new(bytes), None),
+        };
+
+        let module = runtime.load_hashed_module_sync(module_data, Some(&self.engine))?;
+
+        let dylink_info = parse_dylink0_section(&module)?;
+
+        trace!(?dylink_info, "Loading side module");
+
+        if let Some((full_path, ld_library_path)) = paths {
+            link_state.pending_module_paths.push(full_path.clone());
+            let num_pending_modules = link_state.pending_module_paths.len();
+            let pop_pending_module = |link_state: &mut InProgressLinkState| {
+                assert_eq!(
+                    num_pending_modules,
+                    link_state.pending_module_paths.len(),
+                    "Internal error: pending modules not maintained correctly"
+                );
+                link_state.pending_module_paths.pop().unwrap();
+            };
+
+            for needed in &dylink_info.needed {
+                trace!(needed, "Loading needed side module");
+                match self.load_module_tree(
+                    DlModuleSpec::FileSystem {
+                        module_spec: Path::new(needed.as_str()),
+                        ld_library_path,
+                    },
+                    link_state,
+                    runtime,
+                    wasi_state,
+                    // RUNPATH, on which WASM_DYLINK_RUNTIME_PATH is based, is *not* applied
+                    // recursively, so we discard the runtime_path parameter and
+                    // only take the one from the module's dylink.0 section
+                    dylink_info.runtime_path.as_ref(),
+                    Some(&full_path),
+                ) {
+                    Ok(_) => (),
+                    Err(e) => {
+                        pop_pending_module(link_state);
+                        return Err(e);
+                    }
+                }
+            }
+
+            pop_pending_module(link_state);
+        } else if !dylink_info.needed.is_empty() {
+            unreachable!(
+                "Internal error: in-memory modules with further needed modules not \
+                    supported and no code paths can create such a module"
+            );
+        }
+
+        let handle = ModuleHandle(self.next_module_handle);
+        self.next_module_handle += 1;
+
+        trace!(?module_name, ?handle, "Assigned handle to module");
+
+        link_state.new_modules.push(InProgressModuleLoad {
+            handle,
+            dylink_info,
+            module,
+        });
+        // Put the name in the linker state - the actual DlModule must be
+        // constructed later by the instance group once table addresses are
+        // allocated for the module.
+        // TODO: allocate table here (at least logically)?
+        self.side_modules_by_name
+            .insert(module_name.into_owned(), handle);
+
+        Ok(handle)
+    }
+}
+
+impl InstanceGroupState {
+    fn main_instance(&self) -> Option<&Instance> {
+        self.main_instance.as_ref()
+    }
+
+    fn tls_base(&self, module_handle: ModuleHandle) -> Option<u64> {
+        if module_handle == MAIN_MODULE_HANDLE {
+            // Main's TLS area is at the beginning of its memory
+            Some(self.main_instance_tls_base)
+        } else {
+            self.side_instances
+                .get(&module_handle)
+                .expect("Internal error: bad module handle")
+                .tls_base
+        }
+    }
+
+    fn try_instance(&self, handle: ModuleHandle) -> Option<&Instance> {
+        if handle == MAIN_MODULE_HANDLE {
+            self.main_instance.as_ref()
+        } else {
+            self.side_instances.get(&handle).map(|i| &i.instance)
+        }
+    }
+
+    fn instance(&self, handle: ModuleHandle) -> &Instance {
+        self.try_instance(handle)
+            .expect("Internal error: bad module handle or not instantiated in this group")
+    }
+
+    /// Allocate space on the indirect function table for the given number of functions
+    ///
+    /// table_alignment is the alignment of the table as a power of two.
+    fn allocate_function_table(
+        &mut self,
+        store: &mut impl AsStoreMut,
+        table_size: u32,
+        table_alignment: u32,
+    ) -> Result<u64, RuntimeError> {
+        trace!(table_size, "Allocating table indices");
+
+        let base_index = if table_size == 0 {
+            0
+        } else {
+            let current_size = self.indirect_function_table.size(store);
+            let alignment = 2_u32.pow(table_alignment);
+
+            let offset = if current_size % alignment != 0 {
+                alignment - (current_size % alignment)
+            } else {
+                0
+            };
+
+            let delta = table_size + offset;
+            trace!(?current_size, ?delta, "Growing indirect function table");
+            let start = self
+                .indirect_function_table
+                .grow(store, delta, Value::FuncRef(None))?;
+
+            (start + offset) as u64
+        };
+
+        trace!(
+            base_index,
+            new_table_size = ?self.indirect_function_table.size(store),
+            "Allocated table indices"
+        );
+
+        Ok(base_index)
+    }
+
+    fn append_to_function_table(
+        &self,
+        store: &mut impl AsStoreMut,
+        func: Function,
+    ) -> Result<u32, RuntimeError> {
+        let table = &self.indirect_function_table;
+
+        let ty = func.ty(store).to_string();
+        let index: u32 = table.size(store);
+        trace!(?index, ?ty, "Appending function in table");
+
+        table.grow(store, 1, func.into())
+    }
+
+    fn place_in_function_table_at(
+        &self,
+        store: &mut impl AsStoreMut,
+        func: Function,
+        index: u32,
+    ) -> Result<(), RuntimeError> {
+        trace!(
+            ?index,
+            ?func,
+            "Placing function in table at pre-defined index"
+        );
+
+        let table = &self.indirect_function_table;
+        let size = table.size(store);
+
+        if size <= index {
+            let delta = index - size + 1;
+            trace!(
+                current_size = ?size,
+                ?delta,
+                "Growing indirect function table"
+            );
+            table.grow(store, delta, Value::FuncRef(None))?;
+        } else {
+            let existing = table.get(store, index).unwrap();
+            if let Value::FuncRef(Some(_)) = existing {
+                panic!("Internal error: function table index {index} already occupied");
+            }
+        }
+
+        let ty = func.ty(store).to_string();
+        trace!(?index, ?ty, "Placing function in table at index");
+        table.set(store, index, Value::FuncRef(Some(func)))
+    }
+
+    fn instantiate_side_module_from_link_state(
+        &mut self,
+        linker_state: &mut LinkerState,
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<WasiEnv>,
+        link_state: &mut InProgressLinkState,
+        module_handle: ModuleHandle,
+    ) -> Result<(), LinkError> {
+        let Some(pending_module) = link_state
+            .new_modules
+            .iter()
+            .find(|m| m.handle == module_handle)
+        else {
+            panic!(
+                "Only recently-loaded modules in the link state can be instantiated \
+                by instantiate_side_module_from_link_state"
+            )
+        };
+
+        trace!(
+            ?module_handle,
+            ?link_state,
+            "Instantiating module from link state"
+        );
+
+        let memory_base = linker_state.allocate_memory(
+            store,
+            &self.memory,
+            &pending_module.dylink_info.mem_info,
+        )?;
+        let table_base = self
+            .allocate_function_table(
+                store,
+                pending_module.dylink_info.mem_info.table_size,
+                pending_module.dylink_info.mem_info.table_alignment,
+            )
+            .map_err(LinkError::TableAllocationError)?;
+
+        trace!(
+            memory_base,
+            table_base,
+            "Allocated memory and table for module"
+        );
+
+        let mut imports = import_object_for_all_wasi_versions(&pending_module.module, store, env);
+
+        let well_known_imports = [
+            ("env", "__memory_base", memory_base),
+            ("env", "__table_base", table_base),
+        ];
+
+        let module = pending_module.module.clone();
+        let dylink_info = pending_module.dylink_info.clone();
+
+        trace!(?module_handle, "Resolving symbols");
+        linker_state.resolve_symbols(
+            self,
+            store,
+            &module,
+            module_handle,
+            link_state,
+            &well_known_imports,
+        )?;
+
+        trace!(?module_handle, "Populating imports object");
+        self.populate_imports_from_link_state(
+            module_handle,
+            linker_state,
+            link_state,
+            store,
+            &module,
+            &mut imports,
+            env,
+            &well_known_imports,
+        )?;
+
+        let instance = Instance::new(store, &module, &imports)?;
+
+        let instance_handles = WasiModuleInstanceHandles::new(
+            self.memory.clone(),
+            store,
+            instance.clone(),
+            Some(self.indirect_function_table.clone()),
+        );
+
+        let dl_module = DlModule {
+            module,
+            dylink_info,
+            memory_base,
+            table_base,
+        };
+
+        let dl_instance = DlInstance {
+            instance: instance.clone(),
+            instance_handles,
+            // The TLS area of a side module's main instance is at the beginning
+            // of its memory
+            tls_base: Some(memory_base),
+        };
+
+        linker_state.side_modules.insert(module_handle, dl_module);
+        self.side_instances.insert(module_handle, dl_instance);
+
+        trace!(?module_handle, "Module instantiated");
+
+        Ok(())
+    }
+
+    // For when we receive a module loaded DL operation
+    fn allocate_function_table_for_existing_module(
+        &mut self,
+        linker_state: &LinkerState,
+        store: &mut impl AsStoreMut,
+        module_handle: ModuleHandle,
+    ) -> Result<(), LinkError> {
+        if self.side_instances.contains_key(&module_handle) {
+            panic!(
+                "Internal error: Module with handle {module_handle:?} \
+                was already instantiated in this group"
+            )
+        };
+
+        let dl_module = linker_state
+            .side_modules
+            .get(&module_handle)
+            .expect("Internal error: module not loaded into linker");
+
+        let table_base = self
+            .allocate_function_table(
+                store,
+                dl_module.dylink_info.mem_info.table_size,
+                dl_module.dylink_info.mem_info.table_alignment,
+            )
+            .map_err(LinkError::TableAllocationError)?;
+
+        if table_base != dl_module.table_base {
+            panic!("Internal error: table base out of sync with linker state");
+        }
+
+        trace!(table_base, "Allocated table indices for existing module");
+
+        Ok(())
+    }
+
+    // For when we receive a module loaded DL operation
+    fn instantiate_side_module_from_linker(
+        &mut self,
+        linker_state: &LinkerState,
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<WasiEnv>,
+        module_handle: ModuleHandle,
+        pending_resolutions: &mut PendingResolutionsFromLinker,
+    ) -> Result<(), LinkError> {
+        if self.side_instances.contains_key(&module_handle) {
+            panic!(
+                "Internal error: Module with handle {module_handle:?} \
+                was already instantiated in this group"
+            )
+        };
+
+        trace!(?module_handle, "Instantiating existing module from linker");
+
+        let dl_module = linker_state
+            .side_modules
+            .get(&module_handle)
+            .expect("Internal error: module not loaded into linker");
+
+        let mut imports = import_object_for_all_wasi_versions(&dl_module.module, store, env);
+
+        let well_known_imports = [
+            ("env", "__memory_base", dl_module.memory_base),
+            ("env", "__table_base", dl_module.table_base),
+        ];
+
+        trace!(?module_handle, "Populating imports object");
+        self.populate_imports_from_linker(
+            module_handle,
+            linker_state,
+            store,
+            &dl_module.module,
+            &mut imports,
+            env,
+            &well_known_imports,
+            pending_resolutions,
+        )?;
+
+        let instance = Instance::new(store, &dl_module.module, &imports)?;
+
+        // This is a non-main instance of a side module, so it needs a new TLS area
+        let tls_base = call_initialization_function::<i32>(&instance, store, "__wasix_init_tls")?
+            .map(|v| v as u64);
+
+        let instance_handles = WasiModuleInstanceHandles::new(
+            self.memory.clone(),
+            store,
+            instance.clone(),
+            Some(self.indirect_function_table.clone()),
+        );
+
+        let dl_instance = DlInstance {
+            instance: instance.clone(),
+            instance_handles,
+            tls_base,
+        };
+
+        self.side_instances.insert(module_handle, dl_instance);
+
+        // Initialization logic must only be run once, so no init calls here; it is
+        // assumed that the module was instantiated and its init callbacks were called
+        // by whichever thread first called instantiate_side_module_from_link_state.
+
+        trace!(?module_handle, "Existing module instantiated successfully");
+
+        Ok(())
+    }
+
+    fn finalize_pending_resolutions_from_linker(
+        &self,
+        pending_resolutions: &PendingResolutionsFromLinker,
+        store: &mut impl AsStoreMut,
+    ) -> Result<(), LinkError> {
+        trace!("Finalizing pending functions");
+
+        for pending in &pending_resolutions.functions {
+            let func = self
+                .instance(pending.resolved_from)
+                .exports
+                .get_function(&pending.name)
+                .unwrap_or_else(|e| {
+                    panic!(
+                        "Internal error: failed to resolve exported function {}: {e:?}",
+                        pending.name
+                    )
+                });
+
+            self.place_in_function_table_at(store, func.clone(), pending.function_table_index)
+                .map_err(LinkError::TableAllocationError)?;
+
+            trace!(?pending, "Placed pending function in table");
+        }
+
+        for tls in &pending_resolutions.tls {
+            let Some(tls_base) = self.tls_base(tls.resolved_from) else {
+                // This is a panic since this error should have been caught when the symbol
+                // was originally resolved by the instigating instance group. We're just replaying
+                // the changes.
+                panic!(
+                    "Internal error: Tried to import TLS symbol from module {} that \
+                    has no TLS base",
+                    tls.resolved_from.0
+                );
+            };
+
+            let final_addr = tls_base + tls.offset;
+            set_integer_global(store, "<pending TLS global>", &tls.global, final_addr)?;
+            trace!(?tls, tls_base, final_addr, "Setting pending TLS global");
+        }
+
+        Ok(())
+    }
+
+    fn apply_resolved_function(
+        &self,
+        store: &mut impl AsStoreMut,
+        name: &str,
+        resolved_from: ModuleHandle,
+        function_table_index: u32,
+    ) -> Result<(), LinkError> {
+        trace!(
+            ?name,
+            ?resolved_from,
+            function_table_index,
+            "Applying resolved function"
+        );
+
+        let instance = &self.try_instance(resolved_from).unwrap_or_else(|| {
+            panic!("Internal error: module {resolved_from:?} not loaded by this group")
+        });
+
+        let func = instance.exports.get_function(name).unwrap_or_else(|e| {
+            panic!("Internal error: failed to resolve exported function {name}: {e:?}")
+        });
+
+        self.place_in_function_table_at(store, func.clone(), function_table_index)
+            .map_err(LinkError::TableAllocationError)?;
+
+        Ok(())
+    }
+
+    pub fn apply_function_table_allocation(
+        &mut self,
+        store: &mut impl AsStoreMut,
+        index: u32,
+        size: u32,
+    ) -> Result<(), LinkError> {
+        trace!(index, "Applying function table allocation");
+        let allocated_index = self
+            .allocate_function_table(store, size, 0)
+            .map_err(LinkError::TableAllocationError)? as u32;
+        if allocated_index != index {
+            panic!("Internal error: allocated index {allocated_index} does not match expected index {index}");
+        }
+        Ok(())
+    }
+
+    fn apply_dl_operation(
+        &mut self,
+        linker_state: &LinkerState,
+        operation: DlOperation,
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<WasiEnv>,
+    ) -> Result<(), LinkError> {
+        trace!(?operation, "Applying operation");
+        match operation {
+            DlOperation::LoadModules(module_handles) => {
+                let mut pending_functions = PendingResolutionsFromLinker::default();
+                for handle in module_handles {
+                    // We need to do table allocation in exactly the same order as the instigating
+                    // group, which is:
+                    //   * Allocate module's own table space
+                    //   * Fill GOT.func entries (through instantiating the module)
+                    //   * Then repeat for the next module.
+                    self.allocate_function_table_for_existing_module(linker_state, store, handle)?;
+                    self.instantiate_side_module_from_linker(
+                        linker_state,
+                        store,
+                        env,
+                        handle,
+                        &mut pending_functions,
+                    )?;
+                }
+                self.finalize_pending_resolutions_from_linker(&pending_functions, store)?;
+            }
+            DlOperation::ResolveFunction {
+                name,
+                resolved_from,
+                function_table_index,
+            } => self.apply_resolved_function(store, &name, resolved_from, function_table_index)?,
+            DlOperation::AllocateFunctionTable { index, size } => {
+                self.apply_function_table_allocation(store, index, size)?
+            }
+        };
+        trace!("Operation applied successfully");
+        Ok(())
+    }
+
+    fn apply_requested_symbols_from_linker(
+        &self,
+        store: &mut impl AsStoreMut,
+        linker_state: &LinkerState,
+    ) -> Result<(), LinkError> {
+        for (key, val) in &linker_state.symbol_resolution_records {
+            if let SymbolResolutionKey::Requested { name, .. } = key {
+                if let SymbolResolutionResult::FunctionPointer {
+                    resolved_from,
+                    function_table_index,
+                } = val
+                {
+                    self.apply_resolved_function(
+                        store,
+                        name,
+                        *resolved_from,
+                        *function_table_index,
+                    )?;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    // TODO: take expected type into account in case multiple modules export the same name,
+    // but with different types
+    fn resolve_exported_symbol(&self, symbol: &str) -> Option<(ModuleHandle, &Extern)> {
+        if let Some(export) = self
+            .main_instance()
+            .and_then(|instance| instance.exports.get_extern(symbol))
+        {
+            trace!(symbol, from = ?MAIN_MODULE_HANDLE, ?export, "Resolved exported symbol");
+            Some((MAIN_MODULE_HANDLE, export))
+        } else {
+            for (handle, dl_instance) in &self.side_instances {
+                if let Some(export) = dl_instance.instance.exports.get_extern(symbol) {
+                    trace!(symbol, from = ?handle, ?export, "Resolved exported symbol");
+                    return Some((*handle, export));
+                }
+            }
+
+            trace!(symbol, "Failed to resolve exported symbol");
+            None
+        }
+    }
+
+    // This function populates the imports object for a single module from the given
+    // in-progress link state.
+    fn populate_imports_from_link_state(
+        &self,
+        module_handle: ModuleHandle,
+        linker_state: &mut LinkerState,
+        link_state: &mut InProgressLinkState,
+        store: &mut impl AsStoreMut,
+        module: &Module,
+        imports: &mut Imports,
+        env: &FunctionEnv<WasiEnv>,
+        well_known_imports: &[(&str, &str, u64)],
+    ) -> Result<(), LinkError> {
+        trace!(?module_handle, "Populating imports object from link state");
+
+        for import in module.imports() {
+            // Skip non-DL-related import modules
+            if !matches!(import.module(), "env" | "GOT.mem" | "GOT.func") {
+                continue;
+            }
+
+            // Important env imports first!
+            if import.module() == "env" {
+                match import.name() {
+                    "memory" => {
+                        let ExternType::Memory(memory_ty) = import.ty() else {
+                            return Err(LinkError::BadImport(
+                                import.module().to_string(),
+                                import.name().to_string(),
+                                import.ty().clone(),
+                            ));
+                        };
+                        trace!(?module_handle, ?import, "Main memory");
+
+                        // Make sure the memory is big enough for the module being instantiated
+                        let current_size = self.memory.grow(store, 0)?;
+                        if current_size < memory_ty.minimum {
+                            self.memory.grow(store, memory_ty.minimum - current_size)?;
+                        }
+
+                        imports.define(
+                            import.module(),
+                            import.name(),
+                            Extern::Memory(self.memory.clone()),
+                        );
+                        continue;
+                    }
+                    "__indirect_function_table" => {
+                        if !matches!(import.ty(), ExternType::Table(ty) if ty.ty == Type::FuncRef) {
+                            return Err(LinkError::BadImport(
+                                import.module().to_string(),
+                                import.name().to_string(),
+                                import.ty().clone(),
+                            ));
+                        }
+                        trace!(?module_handle, ?import, "Function table");
+                        imports.define(
+                            import.module(),
+                            import.name(),
+                            Extern::Table(self.indirect_function_table.clone()),
+                        );
+                        continue;
+                    }
+                    "__stack_pointer" => {
+                        if !matches!(import.ty(), ExternType::Global(ty) if *ty == self.stack_pointer.ty(store))
+                        {
+                            return Err(LinkError::BadImport(
+                                import.module().to_string(),
+                                import.name().to_string(),
+                                import.ty().clone(),
+                            ));
+                        }
+                        trace!(?module_handle, ?import, "Stack pointer");
+                        imports.define(
+                            import.module(),
+                            import.name(),
+                            Extern::Global(self.stack_pointer.clone()),
+                        );
+                        continue;
+                    }
+                    // Clang generates this symbol when building modules that use EH-based sjlj.
+                    "__c_longjmp" => {
+                        if !matches!(import.ty(), ExternType::Tag(ty) if *ty.params == [Type::I32])
+                        {
+                            return Err(LinkError::BadImport(
+                                import.module().to_string(),
+                                import.name().to_string(),
+                                import.ty().clone(),
+                            ));
+                        }
+                        trace!(?module_handle, ?import, "setjmp/longjmp exception tag");
+                        imports.define(import.module(), import.name(), self.c_longjmp.clone());
+                        continue;
+                    }
+                    // Clang generates this symbol when building C++ code that uses exception handling.
+                    "__cpp_exception" => {
+                        if !matches!(import.ty(), ExternType::Tag(ty) if *ty.params == [Type::I32])
+                        {
+                            return Err(LinkError::BadImport(
+                                import.module().to_string(),
+                                import.name().to_string(),
+                                import.ty().clone(),
+                            ));
+                        }
+                        trace!(?module_handle, ?import, "C++ exception tag");
+                        imports.define(import.module(), import.name(), self.cpp_exception.clone());
+                        continue;
+                    }
+                    _ => (),
+                }
+            }
+
+            // Next, go over the well-known imports
+            if let Some(well_known_value) = well_known_imports.iter().find_map(|i| {
+                if i.0 == import.module() && i.1 == import.name() {
+                    Some(i.2)
+                } else {
+                    None
+                }
+            }) {
+                trace!(
+                    ?module_handle,
+                    ?import,
+                    well_known_value,
+                    "Well-known value"
+                );
+                imports.define(
+                    import.module(),
+                    import.name(),
+                    define_integer_global_import(store, &import, well_known_value)?,
+                );
+                continue;
+            }
+
+            let key = NeededSymbolResolutionKey {
+                module_handle,
+                import_module: import.module().to_owned(),
+                import_name: import.name().to_owned(),
+            };
+
+            // Finally, go through the resolution results
+            let resolution = link_state.symbols.get(&key).unwrap_or_else(|| {
+                panic!(
+                    "Internal error: missing import resolution '{0}'.{1}",
+                    key.import_module, key.import_name
+                )
+            });
+
+            trace!(?module_handle, ?import, ?resolution, "Resolution");
+
+            match resolution {
+                InProgressSymbolResolution::Function(module_handle) => {
+                    let func = self
+                        .instance(*module_handle)
+                        .exports
+                        .get_function(import.name())
+                        .expect("Internal error: bad in-progress symbol resolution");
+                    imports.define(import.module(), import.name(), func.clone());
+                    linker_state.symbol_resolution_records.insert(
+                        SymbolResolutionKey::Needed(key.clone()),
+                        SymbolResolutionResult::Function {
+                            ty: func.ty(store),
+                            resolved_from: *module_handle,
+                        },
+                    );
+                }
+
+                InProgressSymbolResolution::StubFunction(func_ty) => {
+                    let func = self.generate_stub_function(
+                        store,
+                        func_ty,
+                        env,
+                        module_handle,
+                        import.name().to_string(),
+                    );
+                    imports.define(import.module(), import.name(), func);
+                    linker_state.symbol_resolution_records.insert(
+                        SymbolResolutionKey::Needed(key.clone()),
+                        SymbolResolutionResult::StubFunction(func_ty.clone()),
+                    );
+                }
+
+                InProgressSymbolResolution::MemGlobal(module_handle) => {
+                    let export = self
+                        .resolve_export_from(
+                            store,
+                            *module_handle,
+                            import.name(),
+                            self.instance(*module_handle),
+                            linker_state.dylink_info(*module_handle),
+                            linker_state.memory_base(*module_handle),
+                            self.tls_base(*module_handle),
+                            true,
+                        )
+                        .expect("Internal error: bad in-progress symbol resolution");
+
+                    match export {
+                        PartiallyResolvedExport::Global(addr) => {
+                            trace!(?module_handle, ?import, addr, "Memory address");
+
+                            let global =
+                                define_integer_global_import(store, &import, addr).unwrap();
+
+                            imports.define(import.module(), import.name(), global);
+                            linker_state.symbol_resolution_records.insert(
+                                SymbolResolutionKey::Needed(key.clone()),
+                                SymbolResolutionResult::Memory(addr),
+                            );
+                        }
+
+                        PartiallyResolvedExport::Tls { offset, final_addr } => {
+                            trace!(?module_handle, ?import, offset, final_addr, "TLS address");
+
+                            let global =
+                                define_integer_global_import(store, &import, final_addr).unwrap();
+
+                            imports.define(import.module(), import.name(), global);
+                            linker_state.symbol_resolution_records.insert(
+                                SymbolResolutionKey::Needed(key.clone()),
+                                SymbolResolutionResult::Tls {
+                                    resolved_from: *module_handle,
+                                    offset,
+                                },
+                            );
+                        }
+
+                        PartiallyResolvedExport::Function(_) => {
+                            panic!("Internal error: bad in-progress symbol resolution")
+                        }
+                    }
+                }
+
+                InProgressSymbolResolution::UnresolvedMemGlobal => {
+                    let global = define_integer_global_import(store, &import, 0).unwrap();
+                    imports.define(import.module(), import.name(), global.clone());
+
+                    link_state
+                        .unresolved_globals
+                        .push(UnresolvedGlobal::Mem(key, global));
+                }
+
+                InProgressSymbolResolution::FuncGlobal(module_handle) => {
+                    let func = self
+                        .instance(*module_handle)
+                        .exports
+                        .get_function(import.name())
+                        .expect("Internal error: bad in-progress symbol resolution");
+
+                    let func_handle = self
+                        .append_to_function_table(store, func.clone())
+                        .map_err(LinkError::TableAllocationError)?;
+                    trace!(
+                        ?module_handle,
+                        ?import,
+                        index = func_handle,
+                        "Allocated function table index"
+                    );
+                    let global =
+                        define_integer_global_import(store, &import, func_handle as u64).unwrap();
+
+                    imports.define(import.module(), import.name(), global);
+                    linker_state.symbol_resolution_records.insert(
+                        SymbolResolutionKey::Needed(key.clone()),
+                        SymbolResolutionResult::FunctionPointer {
+                            resolved_from: *module_handle,
+                            function_table_index: func_handle,
+                        },
+                    );
+                }
+
+                InProgressSymbolResolution::UnresolvedFuncGlobal => {
+                    let global = define_integer_global_import(store, &import, 0).unwrap();
+                    imports.define(import.module(), import.name(), global.clone());
+
+                    link_state
+                        .unresolved_globals
+                        .push(UnresolvedGlobal::Func(key, global));
+                }
+            }
+        }
+
+        trace!(?module_handle, "Imports object populated successfully");
+
+        Ok(())
+    }
+
+    // For when we receive a module loaded DL operation
+    fn populate_imports_from_linker(
+        &self,
+        module_handle: ModuleHandle,
+        linker_state: &LinkerState,
+        store: &mut impl AsStoreMut,
+        module: &Module,
+        imports: &mut Imports,
+        env: &FunctionEnv<WasiEnv>,
+        well_known_imports: &[(&str, &str, u64)],
+        pending_resolutions: &mut PendingResolutionsFromLinker,
+    ) -> Result<(), LinkError> {
+        trace!(
+            ?module_handle,
+            "Populating imports object for existing module from linker state"
+        );
+
+        for import in module.imports() {
+            // Skip non-DL-related import modules
+            if !matches!(import.module(), "env" | "GOT.mem" | "GOT.func") {
+                continue;
+            }
+
+            // Important env imports first!
+            if import.module() == "env" {
+                match import.name() {
+                    "memory" => {
+                        if !matches!(import.ty(), ExternType::Memory(_)) {
+                            return Err(LinkError::BadImport(
+                                import.module().to_string(),
+                                import.name().to_string(),
+                                import.ty().clone(),
+                            ));
+                        }
+                        trace!(?module_handle, ?import, "Main memory");
+                        imports.define(
+                            import.module(),
+                            import.name(),
+                            Extern::Memory(self.memory.clone()),
+                        );
+                        continue;
+                    }
+                    "__indirect_function_table" => {
+                        if !matches!(import.ty(), ExternType::Table(ty) if ty.ty == Type::FuncRef) {
+                            return Err(LinkError::BadImport(
+                                import.module().to_string(),
+                                import.name().to_string(),
+                                import.ty().clone(),
+                            ));
+                        }
+                        trace!(?module_handle, ?import, "Function table");
+                        imports.define(
+                            import.module(),
+                            import.name(),
+                            Extern::Table(self.indirect_function_table.clone()),
+                        );
+                        continue;
+                    }
+                    "__stack_pointer" => {
+                        if !matches!(import.ty(), ExternType::Global(ty) if *ty == self.stack_pointer.ty(store))
+                        {
+                            return Err(LinkError::BadImport(
+                                import.module().to_string(),
+                                import.name().to_string(),
+                                import.ty().clone(),
+                            ));
+                        }
+                        trace!(?module_handle, ?import, "Stack pointer");
+                        imports.define(
+                            import.module(),
+                            import.name(),
+                            Extern::Global(self.stack_pointer.clone()),
+                        );
+                        continue;
+                    }
+                    "__c_longjmp" => {
+                        if !matches!(import.ty(), ExternType::Tag(ty) if *ty.params == [Type::I32])
+                        {
+                            return Err(LinkError::BadImport(
+                                import.module().to_string(),
+                                import.name().to_string(),
+                                import.ty().clone(),
+                            ));
+                        }
+                        trace!(?module_handle, ?import, "setjmp/longjmp exception tag");
+                        imports.define(import.module(), import.name(), self.c_longjmp.clone());
+                        continue;
+                    }
+                    "__cpp_exception" => {
+                        if !matches!(import.ty(), ExternType::Tag(ty) if *ty.params == [Type::I32])
+                        {
+                            return Err(LinkError::BadImport(
+                                import.module().to_string(),
+                                import.name().to_string(),
+                                import.ty().clone(),
+                            ));
+                        }
+                        trace!(?module_handle, ?import, "C++ exception tag");
+                        imports.define(import.module(), import.name(), self.cpp_exception.clone());
+                        continue;
+                    }
+                    _ => (),
+                }
+            }
+
+            // Next, go over the well-known imports
+            if let Some(well_known_value) = well_known_imports.iter().find_map(|i| {
+                if i.0 == import.module() && i.1 == import.name() {
+                    Some(i.2)
+                } else {
+                    None
+                }
+            }) {
+                trace!(
+                    ?module_handle,
+                    ?import,
+                    well_known_value,
+                    "Well-known value"
+                );
+                imports.define(
+                    import.module(),
+                    import.name(),
+                    define_integer_global_import(store, &import, well_known_value)?,
+                );
+                continue;
+            }
+
+            let key = SymbolResolutionKey::Needed(NeededSymbolResolutionKey {
+                module_handle,
+                import_module: import.module().to_owned(),
+                import_name: import.name().to_owned(),
+            });
+
+            // Finally, go through the resolution results
+            let resolution = linker_state
+                .symbol_resolution_records
+                .get(&key)
+                .unwrap_or_else(|| {
+                    panic!(
+                        "Internal error: missing symbol resolution record for '{0}'.{1}",
+                        import.module(),
+                        import.name()
+                    )
+                });
+
+            trace!(?module_handle, ?import, ?resolution, "Resolution");
+
+            match resolution {
+                SymbolResolutionResult::Function { ty, resolved_from } => {
+                    let func = match self.try_instance(*resolved_from) {
+                        Some(instance) => {
+                            trace!(
+                                ?module_handle,
+                                ?import,
+                                ?resolved_from,
+                                "Already have instance to resolve from"
+                            );
+                            instance
+                                .exports
+                                .get_function(import.name())
+                                .expect("Internal error: failed to get exported function")
+                                .clone()
+                        }
+                        // We may be loading a module tree, and the instance from which
+                        // we're supposed to import the function may not exist yet, so
+                        // we add in a stub, which will later use the resolution records
+                        // to locate the function.
+                        None => {
+                            trace!(
+                                ?module_handle,
+                                ?import,
+                                ?resolved_from,
+                                "Don't have instance yet"
+                            );
+
+                            self.generate_stub_function(
+                                store,
+                                ty,
+                                env,
+                                module_handle,
+                                import.name().to_owned(),
+                            )
+                        }
+                    };
+                    imports.define(import.module(), import.name(), func);
+                }
+                SymbolResolutionResult::StubFunction(ty) => {
+                    let func = self.generate_stub_function(
+                        store,
+                        ty,
+                        env,
+                        module_handle,
+                        import.name().to_owned(),
+                    );
+                    imports.define(import.module(), import.name(), func.clone());
+                }
+                SymbolResolutionResult::FunctionPointer {
+                    resolved_from,
+                    function_table_index,
+                } => {
+                    let func = self.try_instance(*resolved_from).map(|instance| {
+                        instance
+                            .exports
+                            .get_function(import.name())
+                            .unwrap_or_else(|e| {
+                                panic!(
+                                    "Internal error: failed to resolve function {}: {e:?}",
+                                    import.name()
+                                )
+                            })
+                    });
+                    match func {
+                        Some(func) => {
+                            trace!(
+                                ?module_handle,
+                                ?import,
+                                function_table_index,
+                                "Placing function pointer into table"
+                            );
+                            self.place_in_function_table_at(
+                                store,
+                                func.clone(),
+                                *function_table_index,
+                            )
+                            .map_err(LinkError::TableAllocationError)?;
+                        }
+                        None => {
+                            trace!(
+                                ?module_handle,
+                                ?import,
+                                function_table_index,
+                                "Don't have instance yet, creating a pending function"
+                            );
+                            // Since we know the final value of the global, we can create it
+                            // and just fill the function table in later
+                            pending_resolutions.functions.push(
+                                PendingFunctionResolutionFromLinkerState {
+                                    resolved_from: *resolved_from,
+                                    name: import.name().to_string(),
+                                    function_table_index: *function_table_index,
+                                },
+                            );
+                        }
+                    };
+                    let global =
+                        define_integer_global_import(store, &import, *function_table_index as u64)?;
+                    imports.define(import.module(), import.name(), global);
+                }
+                SymbolResolutionResult::Memory(addr) => {
+                    let global = define_integer_global_import(store, &import, *addr)?;
+                    imports.define(import.module(), import.name(), global);
+                }
+                SymbolResolutionResult::Tls {
+                    resolved_from,
+                    offset,
+                } => {
+                    let global = define_integer_global_import(store, &import, 0)?;
+                    pending_resolutions.tls.push(PendingTlsPointer {
+                        global: global.clone(),
+                        resolved_from: *resolved_from,
+                        offset: *offset,
+                    });
+                    imports.define(import.module(), import.name(), global);
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    // Resolve an export down to the "memory address" of the symbol. This is different from
+    // `resolve_symbol`, which resolves a WASM export but does not care about its type and
+    // does no further processing on the export itself.
+    fn resolve_export(
+        &self,
+        linker_state: &LinkerState,
+        store: &mut impl AsStoreMut,
+        module_handle: Option<ModuleHandle>,
+        symbol: &str,
+        allow_hidden: bool,
+    ) -> Result<(PartiallyResolvedExport, ModuleHandle), ResolveError> {
+        trace!(?module_handle, ?symbol, "Resolving export");
+        match module_handle {
+            Some(module_handle) => {
+                let instance = self
+                    .try_instance(module_handle)
+                    .ok_or(ResolveError::InvalidModuleHandle)?;
+                let tls_base = self.tls_base(module_handle);
+                let memory_base = linker_state.memory_base(module_handle);
+                let dylink_info = linker_state.dylink_info(module_handle);
+                Ok((
+                    self.resolve_export_from(
+                        store,
+                        module_handle,
+                        symbol,
+                        instance,
+                        dylink_info,
+                        memory_base,
+                        tls_base,
+                        allow_hidden,
+                    )?,
+                    module_handle,
+                ))
+            }
+
+            None => {
+                // TODO: this would be the place to support RTLD_NEXT
+                if let Some(instance) = self.main_instance() {
+                    match self.resolve_export_from(
+                        store,
+                        MAIN_MODULE_HANDLE,
+                        symbol,
+                        instance,
+                        &linker_state.main_module_dylink_info,
+                        linker_state.memory_base(MAIN_MODULE_HANDLE),
+                        Some(self.main_instance_tls_base),
+                        allow_hidden,
+                    ) {
+                        Ok(export) => return Ok((export, MAIN_MODULE_HANDLE)),
+                        Err(ResolveError::MissingExport) => (),
+                        Err(e) => return Err(e),
+                    }
+                }
+
+                // Iterate over linker.side_modules to ensure we're going over the
+                // modules in increasing order of module_handle, A.K.A. the order
+                // in which modules were loaded. linker.side_modules is a BTreeMap
+                // whereas self.side_instances is a HashMap with undetermined
+                // iteration order.
+                for (handle, module) in &linker_state.side_modules {
+                    let instance = &self.side_instances[handle];
+                    match self.resolve_export_from(
+                        store,
+                        *handle,
+                        symbol,
+                        &instance.instance,
+                        &module.dylink_info,
+                        linker_state.memory_base(*handle),
+                        instance.tls_base,
+                        allow_hidden,
+                    ) {
+                        Ok(export) => return Ok((export, *handle)),
+                        Err(ResolveError::MissingExport) => (),
+                        Err(e) => return Err(e),
+                    }
+                }
+
+                trace!(
+                    ?module_handle,
+                    ?symbol,
+                    "Failed to locate symbol after searching all instances"
+                );
+                Err(ResolveError::MissingExport)
+            }
+        }
+    }
+
+    fn resolve_export_from(
+        &self,
+        store: &mut impl AsStoreMut,
+        module_handle: ModuleHandle,
+        symbol: &str,
+        instance: &Instance,
+        dylink_info: &DylinkInfo,
+        memory_base: u64,
+        tls_base: Option<u64>,
+        allow_hidden: bool,
+    ) -> Result<PartiallyResolvedExport, ResolveError> {
+        trace!(from = ?module_handle, symbol, "Resolving export from instance");
+        let export = instance.exports.get_extern(symbol).ok_or_else(|| {
+            trace!(from = ?module_handle, symbol, "Not found");
+            ResolveError::MissingExport
+        })?;
+
+        if !allow_hidden
+            && dylink_info
+                .export_metadata
+                .get(symbol)
+                .map(|flags| flags.contains(wasmparser::SymbolFlags::VISIBILITY_HIDDEN))
+                .unwrap_or(false)
+        {
+            return Err(ResolveError::MissingExport);
+        }
+
+        match export.ty(store) {
+            ExternType::Function(_) => {
+                trace!(from = ?module_handle, symbol, "Found function");
+                Ok(PartiallyResolvedExport::Function(
+                    Function::get_self_from_extern(export).unwrap().clone(),
+                ))
+            }
+            ty @ ExternType::Global(_) => {
+                let global = Global::get_self_from_extern(export).unwrap();
+                let value = match global.get(store) {
+                    Value::I32(value) => value as u64,
+                    Value::I64(value) => value as u64,
+                    _ => return Err(ResolveError::InvalidExportType(ty.clone())),
+                };
+
+                let is_tls = dylink_info
+                    .export_metadata
+                    .get(symbol)
+                    .map(|flags| flags.contains(wasmparser::SymbolFlags::TLS))
+                    .unwrap_or(false);
+
+                if is_tls {
+                    let Some(tls_base) = tls_base else {
+                        return Err(ResolveError::TlsSymbolWithoutTls);
+                    };
+                    let final_value = value + tls_base;
+                    trace!(
+                        from = ?module_handle,
+                        symbol,
+                        value,
+                        offset = value,
+                        final_value,
+                        "Found TLS global"
+                    );
+                    Ok(PartiallyResolvedExport::Tls {
+                        offset: value,
+                        final_addr: final_value,
+                    })
+                } else {
+                    let final_value = value + memory_base;
+                    trace!(from = ?module_handle, symbol, value, final_value, "Found global");
+                    Ok(PartiallyResolvedExport::Global(final_value))
+                }
+            }
+            ty => Err(ResolveError::InvalidExportType(ty.clone())),
+        }
+    }
+
+    fn generate_stub_function(
+        &self,
+        store: &mut impl AsStoreMut,
+        ty: &FunctionType,
+        env: &FunctionEnv<WasiEnv>,
+        requesting_module: ModuleHandle,
+        name: String,
+    ) -> Function {
+        // TODO: only search through needed modules for the symbol. This requires the implementation
+        // of needing/needed relationships between modules.
+        trace!(?requesting_module, name, "Generating stub function");
+
+        let ty = ty.clone();
+        let resolved: Mutex<Option<Option<Function>>> = Mutex::new(None);
+        Function::new_with_env(
+            store,
+            env,
+            ty.clone(),
+            move |mut env: FunctionEnvMut<'_, WasiEnv>, params: &[Value]| {
+                let mk_error = || {
+                    RuntimeError::user(Box::new(WasiError::DlSymbolResolutionFailed(name.clone())))
+                };
+
+                let mut resolved_guard = resolved.lock().unwrap();
+                let func = match *resolved_guard {
+                    None => {
+                        trace!(?requesting_module, name, "Resolving stub function");
+
+                        let (data, store) = env.data_and_store_mut();
+                        let env_inner = data.inner();
+                        // Safe to unwrap since we already know we're doing DL
+                        let linker = env_inner.linker().unwrap();
+
+                        // Try to lock the linker state. This *can* fail if a stub
+                        // is called as part of the init logic for a module. If we
+                        // can't lock the linker state, we just resolve the symbol
+                        // but don't store the resolved function anywhere; a later
+                        // call to the stub function can then resolve again. Since
+                        // this module and the one that has the symbol have to be
+                        // part of the same module tree, it's super-duper-unlikely
+                        // that a second resolution of the symbol would return a
+                        // different result and would indicate a problem with the
+                        // implementation of the linker.
+                        let linker_state = match linker.linker_state.try_write() {
+                            Ok(guard) => {
+                                trace!(
+                                    ?requesting_module,
+                                    name,
+                                    "Locked linker state successfully"
+                                );
+                                Some(guard)
+                            }
+                            Err(TryLockError::WouldBlock) => {
+                                trace!(?requesting_module, name, "Failed to lock linker state");
+                                None
+                            }
+                            Err(TryLockError::Poisoned(_)) => {
+                                *resolved_guard = Some(None);
+                                return Err(mk_error());
+                            }
+                        };
+
+                        let group_guard = linker.instance_group_state.lock().unwrap();
+                        let Some(group_state) = group_guard.as_ref() else {
+                            trace!(?requesting_module, name, "Instance group is already dead");
+                            *resolved_guard = Some(None);
+                            return Err(mk_error());
+                        };
+
+                        let resolution_key =
+                            SymbolResolutionKey::Needed(NeededSymbolResolutionKey {
+                                module_handle: requesting_module,
+                                import_module: "env".to_owned(),
+                                import_name: name.clone(),
+                            });
+
+                        match linker_state
+                            .as_ref()
+                            .and_then(|l| l.symbol_resolution_records.get(&resolution_key))
+                        {
+                            Some(SymbolResolutionResult::Function {
+                                resolved_from,
+                                ty: resolved_ty,
+                            }) => {
+                                trace!(
+                                    ?requesting_module,
+                                    name,
+                                    "Function was already resolved in the linker"
+                                );
+
+                                if ty != *resolved_ty {
+                                    *resolved_guard = Some(None);
+                                    return Err(mk_error());
+                                }
+
+                                let func = group_state
+                                    .instance(*resolved_from)
+                                    .exports
+                                    .get_function(&name)
+                                    .unwrap()
+                                    .clone();
+                                *resolved_guard = Some(Some(func.clone()));
+                                func
+                            }
+                            Some(SymbolResolutionResult::StubFunction(_)) | None => {
+                                trace!(?requesting_module, name, "Resolving function");
+
+                                let Some((resolved_from, export)) =
+                                    group_state.resolve_exported_symbol(name.as_str())
+                                else {
+                                    trace!(?requesting_module, name, "Failed to resolve symbol");
+                                    *resolved_guard = Some(None);
+                                    return Err(mk_error());
+                                };
+                                let Extern::Function(func) = export else {
+                                    trace!(
+                                        ?requesting_module,
+                                        name,
+                                        ?resolved_from,
+                                        "Resolved symbol is not a function"
+                                    );
+                                    *resolved_guard = Some(None);
+                                    return Err(mk_error());
+                                };
+                                if func.ty(&store) != ty {
+                                    trace!(
+                                        ?requesting_module,
+                                        name,
+                                        ?resolved_from,
+                                        "Resolved function has bad type"
+                                    );
+                                    *resolved_guard = Some(None);
+                                    return Err(mk_error());
+                                }
+
+                                trace!(
+                                    ?requesting_module,
+                                    name,
+                                    ?resolved_from,
+                                    "Function resolved successfully"
+                                );
+
+                                // Only store the result if we can also put it in the linker's
+                                // resolution records for other groups to find.
+                                if let Some(mut linker_state) = linker_state {
+                                    trace!(
+                                        ?requesting_module,
+                                        name,
+                                        ?resolved_from,
+                                        "Updating linker state with this resolution"
+                                    );
+
+                                    *resolved_guard = Some(Some(func.clone()));
+                                    linker_state.symbol_resolution_records.insert(
+                                        resolution_key,
+                                        SymbolResolutionResult::Function {
+                                            ty: func.ty(&store),
+                                            resolved_from,
+                                        },
+                                    );
+                                }
+
+                                func.clone()
+                            }
+                            Some(resolution) => panic!(
+                                "Internal error: resolution record for symbol \
+                                {name} indicates non-function resolution {resolution:?}"
+                            ),
+                        }
+                    }
+                    Some(None) => return Err(mk_error()),
+                    Some(Some(ref func)) => func.clone(),
+                };
+                drop(resolved_guard);
+
+                let mut store = env.as_store_mut();
+                func.call(&mut store, params).map(|ret| ret.into())
+            },
+        )
+    }
+
+    fn finalize_pending_globals(
+        &self,
+        linker_state: &mut LinkerState,
+        store: &mut impl AsStoreMut,
+        unresolved_globals: &Vec<UnresolvedGlobal>,
+    ) -> Result<(), LinkError> {
+        trace!("Finalizing pending globals");
+
+        for unresolved in unresolved_globals {
+            let key = unresolved.key();
+            let import_metadata = &linker_state.dylink_info(key.module_handle).import_metadata;
+            let is_weak = import_metadata
+                .get(&(key.import_module.to_owned(), key.import_name.to_owned()))
+                // clang seems to like putting the import-info in the "env" module
+                // sometimes, so try that as well
+                .or_else(|| import_metadata.get(&("env".to_owned(), key.import_name.to_owned())))
+                .map(|flags| flags.contains(wasmparser::SymbolFlags::BINDING_WEAK))
+                .unwrap_or(false);
+            trace!(?unresolved, is_weak, "Resolving pending global");
+
+            match (
+                unresolved,
+                self.resolve_export(linker_state, store, None, &key.import_name, true),
+            ) {
+                (
+                    UnresolvedGlobal::Mem(key, global),
+                    Ok((PartiallyResolvedExport::Global(addr), resolved_from)),
+                ) => {
+                    trace!(
+                        ?unresolved,
+                        ?resolved_from,
+                        addr,
+                        "Resolved to memory address"
+                    );
+                    set_integer_global(store, &key.import_name, global, addr)?;
+                    linker_state.symbol_resolution_records.insert(
+                        SymbolResolutionKey::Needed(key.clone()),
+                        SymbolResolutionResult::Memory(addr),
+                    );
+                }
+
+                (
+                    UnresolvedGlobal::Mem(key, global),
+                    Ok((PartiallyResolvedExport::Tls { offset, final_addr }, resolved_from)),
+                ) => {
+                    trace!(
+                        ?unresolved,
+                        ?resolved_from,
+                        offset,
+                        final_addr,
+                        "Resolved to TLS address"
+                    );
+                    set_integer_global(store, &key.import_name, global, final_addr)?;
+                    linker_state.symbol_resolution_records.insert(
+                        SymbolResolutionKey::Needed(key.clone()),
+                        SymbolResolutionResult::Tls {
+                            resolved_from,
+                            offset,
+                        },
+                    );
+                }
+
+                (
+                    UnresolvedGlobal::Func(key, global),
+                    Ok((PartiallyResolvedExport::Function(func), resolved_from)),
+                ) => {
+                    let func_handle = self
+                        .append_to_function_table(store, func)
+                        .map_err(LinkError::TableAllocationError)?;
+                    trace!(
+                        ?unresolved,
+                        ?resolved_from,
+                        function_table_index = ?func_handle,
+                        "Resolved to function pointer"
+                    );
+                    set_integer_global(store, &key.import_name, global, func_handle as u64)?;
+                    linker_state.symbol_resolution_records.insert(
+                        SymbolResolutionKey::Needed(key.clone()),
+                        SymbolResolutionResult::FunctionPointer {
+                            resolved_from,
+                            function_table_index: func_handle,
+                        },
+                    );
+                }
+
+                // Expected memory address, resolved function or vice-versa
+                (_, Ok(_)) => {
+                    return Err(LinkError::UnresolvedGlobal(
+                        unresolved.import_module().to_string(),
+                        key.import_name.clone(),
+                        Box::new(ResolveError::MissingExport),
+                    ))
+                }
+
+                // Missing weak symbols get resolved to a null address
+                (_, Err(ResolveError::MissingExport)) if is_weak => {
+                    trace!(?unresolved, "Weak global not found");
+                    set_integer_global(store, &key.import_name, unresolved.global(), 0)?;
+                    linker_state.symbol_resolution_records.insert(
+                        SymbolResolutionKey::Needed(key.clone()),
+                        SymbolResolutionResult::Memory(0),
+                    );
+                }
+
+                (_, Err(e)) => {
+                    return Err(LinkError::UnresolvedGlobal(
+                        "GOT.mem".to_string(),
+                        key.import_name.clone(),
+                        Box::new(e),
+                    ))
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+
+async fn locate_module(
+    module_path: &Path,
+    library_path: &[impl AsRef<Path>],
+    runtime_path: &[impl AsRef<str>],
+    calling_module_path: Option<impl AsRef<Path>>,
+    fs: &WasiFs,
+) -> Result<(PathBuf, OwnedBuffer), LinkError> {
+    async fn try_load(
+        fs: &WasiFsRoot,
+        path: impl AsRef<Path>,
+    ) -> Result<(PathBuf, OwnedBuffer), FsError> {
+        let mut file = match fs.new_open_options().read(true).open(path.as_ref()) {
+            Ok(f) => f,
+            // Fallback for cases where the module thinks it's running on unix,
+            // but the compiled side module is a .wasm file
+            Err(_) if path.as_ref().extension() == Some(OsStr::new("so")) => fs
+                .new_open_options()
+                .read(true)
+                .open(path.as_ref().with_extension("wasm"))?,
+            Err(e) => return Err(e),
+        };
+
+        let buf = if let Some(buf) = file.as_owned_buffer() {
+            buf
+        } else {
+            let mut buf = Vec::new();
+            file.read_to_end(&mut buf).await?;
+            OwnedBuffer::from(buf)
+        };
+
+        Ok((path.as_ref().to_owned(), buf))
+    }
+
+    if module_path.is_absolute() {
+        trace!(?module_path, "Locating module with absolute path");
+        try_load(&fs.root_fs, module_path).await.map_err(|e| {
+            LinkError::SharedLibraryMissing(
+                module_path.to_string_lossy().into_owned(),
+                LocateModuleError::Single(e),
+            )
+        })
+    } else if module_path.components().count() > 1 {
+        trace!(?module_path, "Locating module with relative path");
+        try_load(
+            &fs.root_fs,
+            fs.relative_path_to_absolute(module_path.to_string_lossy().into_owned()),
+        )
+        .await
+        .map_err(|e| {
+            LinkError::SharedLibraryMissing(
+                module_path.to_string_lossy().into_owned(),
+                LocateModuleError::Single(e),
+            )
+        })
+    } else {
+        // Go through all dynamic library lookup paths
+        // Note: a path without a slash does *not* look at the current directory. This is by design.
+
+        // TODO: implement RUNPATH once it's supported by clang and wasmparser
+        // TODO: support $ORIGIN and ${ORIGIN} in RUNPATH
+
+        trace!(
+            ?module_path,
+            "Locating module by name in default runtime path"
+        );
+
+        let calling_module_dir = calling_module_path
+            .as_ref()
+            .map(|p| p.as_ref().parent().unwrap_or_else(|| p.as_ref()));
+
+        let runtime_path = runtime_path.iter().map(|path| {
+            let path = path.as_ref();
+
+            let relative = path
+                .strip_prefix("$ORIGIN")
+                .or_else(|| path.strip_prefix("${ORIGIN}"));
+
+            match relative {
+                Some(relative) => {
+                    let Some(calling_module_dir) = calling_module_dir else {
+                        // This is an internal error because the only time calling_module_path
+                        // should be empty is when loading a module through dlopen, and a
+                        // dlopen'ed module isn't being required by another module so we don't
+                        // have a RUNPATH to consider at all. See the invocation of
+                        // `load_module_tree` in `load_module`.
+                        panic!(
+                            "Internal error: $ORIGIN or ${{ORIGIN}} in RUNPATH, but \
+                            no calling module path provided"
+                        );
+                    };
+                    Cow::Owned(PathBuf::from(
+                        fs.relative_path_to_absolute(
+                            calling_module_dir
+                                .join(relative)
+                                .to_string_lossy()
+                                .into_owned(),
+                        ),
+                    ))
+                }
+                None => Cow::Borrowed(Path::new(path)),
+            }
+        });
+
+        // Search order is: LD_LIBRARY_PATH -> RUNPATH -> system default folders
+        let search_paths = library_path
+            .iter()
+            .map(|path| Cow::Borrowed(path.as_ref()))
+            .chain(runtime_path)
+            .chain(
+                DEFAULT_RUNTIME_PATH
+                    .iter()
+                    .map(|path| Cow::Borrowed(Path::new(path))),
+            );
+
+        let mut errors: Vec<(PathBuf, FsError)> = Vec::new();
+        for path in search_paths {
+            let full_path = path.join(module_path);
+            trace!(search_path = ?path, full_path = ?full_path, "Searching module");
+            match try_load(&fs.root_fs, &full_path).await {
+                Ok(ret) => {
+                    trace!(?module_path, full_path = ?ret.0, "Located module");
+                    return Ok(ret);
+                }
+                Err(e) => errors.push((full_path, e)),
+            };
+        }
+
+        trace!(?module_path, "Failed to locate module");
+        Err(LinkError::SharedLibraryMissing(
+            module_path.to_string_lossy().into_owned(),
+            LocateModuleError::Multiple(errors),
+        ))
+    }
+}
+
+pub fn is_dynamically_linked(module: &Module) -> bool {
+    module.custom_sections("dylink.0").next().is_some()
+}
+
+// Need to parse the RUNPATH subsection manually until wasmparser adds support
+const WASM_DYLINK_RUNTIME_PATH: u8 = 5;
+
+pub fn parse_dylink0_section(module: &Module) -> Result<DylinkInfo, LinkError> {
+    let mut sections = module.custom_sections("dylink.0");
+
+    let Some(section) = sections.next() else {
+        return Err(LinkError::NotDynamicLibrary);
+    };
+
+    // Verify the module contains exactly one dylink.0 section
+    let None = sections.next() else {
+        return Err(LinkError::NotDynamicLibrary);
+    };
+
+    let reader = wasmparser::Dylink0SectionReader::new(wasmparser::BinaryReader::new(&section, 0));
+
+    let mut mem_info = None;
+    let mut needed = None;
+    let mut import_metadata = HashMap::new();
+    let mut export_metadata = HashMap::new();
+    let mut runtime_path = Vec::new();
+
+    for subsection in reader {
+        let subsection = subsection?;
+        match subsection {
+            wasmparser::Dylink0Subsection::MemInfo(m) => {
+                mem_info = Some(m);
+            }
+
+            wasmparser::Dylink0Subsection::Needed(n) => {
+                needed = Some(n.iter().map(|s| s.to_string()).collect::<Vec<_>>());
+            }
+
+            wasmparser::Dylink0Subsection::ImportInfo(i) => {
+                for i in i {
+                    import_metadata.insert((i.module.to_owned(), i.field.to_owned()), i.flags);
+                }
+            }
+
+            wasmparser::Dylink0Subsection::ExportInfo(e) => {
+                for e in e {
+                    export_metadata.insert(e.name.to_owned(), e.flags);
+                }
+            }
+
+            wasmparser::Dylink0Subsection::Unknown {
+                ty: WASM_DYLINK_RUNTIME_PATH,
+                data,
+                range,
+            } => {
+                let mut reader = wasmparser::BinaryReader::new(data, range.start);
+                runtime_path.extend(
+                    (0..reader.read_var_u32()?)
+                        .map(|_| reader.read_string().map(ToOwned::to_owned))
+                        .collect::<Result<Vec<_>, _>>()?
+                        .into_iter(),
+                )
+            }
+
+            wasmparser::Dylink0Subsection::Unknown { ty, .. } => {
+                tracing::warn!("Skipping unknown dylink.0 subsection {ty}");
+            }
+        }
+    }
+
+    Ok(DylinkInfo {
+        mem_info: mem_info.unwrap_or(wasmparser::MemInfo {
+            memory_size: 0,
+            memory_alignment: 0,
+            table_size: 0,
+            table_alignment: 0,
+        }),
+        needed: needed.unwrap_or_default(),
+        import_metadata,
+        export_metadata,
+        runtime_path,
+    })
+}
+
+fn get_integer_global_type_from_import(import: &ImportType) -> Result<GlobalType, LinkError> {
+    let import_type = import.ty();
+    let ExternType::Global(ty) = import_type else {
+        return Err(LinkError::BadImport(
+            import.module().to_owned(),
+            import.name().to_owned(),
+            import_type.clone(),
+        ));
+    };
+
+    if !matches!(ty.ty, Type::I32 | Type::I64) {
+        return Err(LinkError::NonIntegerGlobal(
+            import.module().to_owned(),
+            import.name().to_owned(),
+        ));
+    }
+
+    Ok(*ty)
+}
+
+fn define_integer_global_import(
+    store: &mut impl AsStoreMut,
+    import: &ImportType,
+    value: u64,
+) -> Result<Global, LinkError> {
+    let ExternType::Global(GlobalType { ty, mutability }) = import.ty() else {
+        return Err(LinkError::BadImport(
+            import.module().to_string(),
+            import.name().to_string(),
+            import.ty().clone(),
+        ));
+    };
+
+    let new_global = if mutability.is_mutable() {
+        Global::new_mut
+    } else {
+        Global::new
+    };
+
+    let global = match ty {
+        Type::I32 => new_global(store, wasmer::Value::I32(value as i32)),
+        Type::I64 => new_global(store, wasmer::Value::I64(value as i64)),
+        _ => {
+            return Err(LinkError::BadImport(
+                import.module().to_string(),
+                import.name().to_string(),
+                import.ty().clone(),
+            ));
+        }
+    };
+
+    Ok(global)
+}
+
+fn set_integer_global(
+    store: &mut impl AsStoreMut,
+    name: &str,
+    global: &Global,
+    value: u64,
+) -> Result<(), LinkError> {
+    match global.ty(store).ty {
+        Type::I32 => global
+            .set(store, Value::I32(value as i32))
+            .map_err(|e| LinkError::GlobalUpdateFailed(name.to_owned(), e))?,
+        Type::I64 => global
+            .set(store, Value::I64(value as i64))
+            .map_err(|e| LinkError::GlobalUpdateFailed(name.to_owned(), e))?,
+        _ => {
+            // This should be caught by resolve_global_import, so just panic here
+            unreachable!("Internal error: expected global of type I32 or I64");
+        }
+    }
+
+    Ok(())
+}
+
+fn call_initialization_function<Ret: WasmTypeList>(
+    instance: &Instance,
+    store: &mut impl AsStoreMut,
+    name: &str,
+) -> Result<Option<Ret>, LinkError> {
+    match instance.exports.get_typed_function::<(), Ret>(store, name) {
+        Ok(f) => {
+            let ret = f
+                .call(store)
+                .map_err(|e| LinkError::InitFunctionFailed(name.to_string(), e))?;
+            Ok(Some(ret))
+        }
+        Err(ExportError::Missing(_)) => Ok(None),
+        Err(ExportError::IncompatibleType) => {
+            Err(LinkError::InitFuncWithInvalidSignature(name.to_string()))
+        }
+    }
+}
+
+#[cfg(test)]
+mod memory_allocator_tests {
+    use wasmer::{Engine, Memory, Store};
+
+    use super::MemoryAllocator;
+
+    const WASM_PAGE_SIZE: u32 = wasmer::WASM_PAGE_SIZE as u32;
+
+    #[test]
+    fn test_memory_allocator() {
+        let engine = Engine::default();
+        let mut store = Store::new(engine);
+        let memory = Memory::new(
+            &mut store,
+            wasmer::MemoryType {
+                minimum: wasmer::Pages(2),
+                maximum: None,
+                shared: true,
+            },
+        )
+        .unwrap();
+        let mut allocator = MemoryAllocator::new();
+
+        // Small allocation in new page
+        let addr = allocator.allocate(&memory, &mut store, 24, 4).unwrap();
+        assert_eq!(addr, 2 * WASM_PAGE_SIZE);
+        assert_eq!(memory.grow(&mut store, 0).unwrap().0, 3);
+
+        // Small allocation in existing page
+        let addr = allocator.allocate(&memory, &mut store, 16, 4).unwrap();
+        assert_eq!(addr, 2 * WASM_PAGE_SIZE + 24);
+
+        // Small allocation in existing page, with bigger alignment
+        let addr = allocator.allocate(&memory, &mut store, 64, 32).unwrap();
+        assert_eq!(addr, 2 * WASM_PAGE_SIZE + 64);
+        // Should still have 3 pages
+        assert_eq!(memory.grow(&mut store, 0).unwrap().0, 3);
+
+        // Big allocation in new pages
+        let addr = allocator
+            .allocate(&memory, &mut store, 2 * WASM_PAGE_SIZE + 256, 1024)
+            .unwrap();
+        assert_eq!(addr, WASM_PAGE_SIZE * 3);
+        assert_eq!(memory.grow(&mut store, 0).unwrap().0, 6);
+
+        // Small allocation with multiple empty pages
+        // page 2 has 128 bytes allocated, page 5 has 256, allocation should go
+        // to page 5 (we should allocate from the page with the least free space)
+        let addr = allocator
+            .allocate(&memory, &mut store, 1024 * 63, 64)
+            .unwrap();
+        assert_eq!(addr, 5 * WASM_PAGE_SIZE + 256);
+
+        // Another small allocation, but this time it won't fit on page 5
+        let addr = allocator.allocate(&memory, &mut store, 4096, 512).unwrap();
+        assert_eq!(addr, 2 * WASM_PAGE_SIZE + 512);
+    }
+}
diff --git a/lib/wasix/src/state/mod.rs b/lib/wasix/src/state/mod.rs
index 6d1dce4706..f3eca94bad 100644
--- a/lib/wasix/src/state/mod.rs
+++ b/lib/wasix/src/state/mod.rs
@@ -19,7 +19,7 @@ mod builder;
 mod env;
 mod func_env;
 mod handles;
-mod run;
+mod linker;
 mod types;
 
 use std::{
@@ -30,15 +30,16 @@ use std::{
     time::Duration,
 };
 
-use run::*;
 #[cfg(feature = "enable-serde")]
 use serde::{Deserialize, Serialize};
 use virtual_fs::{FileOpener, FileSystem, FsError, OpenOptions, VirtualFile};
-use wasmer_wasix_types::wasi::{Errno, Fd as WasiFd, Rights, Snapshot0Clockid};
+use wasmer_wasix_types::wasi::{
+    Disposition, Errno, Fd as WasiFd, Rights, Signal, Snapshot0Clockid,
+};
 
 pub use self::{
     builder::*,
-    env::{WasiEnv, WasiEnvInit, WasiInstanceHandles},
+    env::{WasiEnv, WasiEnvInit, WasiModuleInstanceHandles, WasiModuleTreeHandles},
     func_env::WasiFunctionEnv,
     types::*,
 };
@@ -49,6 +50,7 @@ use crate::{
     utils::WasiParkingLot,
 };
 pub(crate) use handles::*;
+pub(crate) use linker::*;
 
 /// all the rights enabled
 pub const ALL_RIGHTS: Rights = Rights::all();
@@ -122,8 +124,8 @@ pub(crate) struct WasiFutexState {
 /// interact.
 ///
 /// * The contents of files are not stored and may be modified by
-/// other, concurrently running programs.  Data such as the contents
-/// of directories are lazily loaded.
+///   other, concurrently running programs.  Data such as the contents
+///   of directories are lazily loaded.
 #[derive(Debug)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub(crate) struct WasiState {
@@ -133,8 +135,9 @@ pub(crate) struct WasiState {
     pub inodes: WasiInodes,
     pub futexs: Mutex<WasiFutexState>,
     pub clock_offset: Mutex<HashMap<Snapshot0Clockid, i64>>,
-    pub args: Vec<String>,
+    pub args: Mutex<Vec<String>>,
     pub envs: Mutex<Vec<Vec<u8>>>,
+    pub signals: Mutex<HashMap<Signal, Disposition>>,
 
     // TODO: should not be here, since this requires active work to resolve.
     // State should only hold active runtime state that can be reproducibly re-created.
@@ -255,8 +258,9 @@ impl WasiState {
             inodes: self.inodes.clone(),
             futexs: Default::default(),
             clock_offset: Mutex::new(self.clock_offset.lock().unwrap().clone()),
-            args: self.args.clone(),
+            args: Mutex::new(self.args.lock().unwrap().clone()),
             envs: Mutex::new(self.envs.lock().unwrap().clone()),
+            signals: Mutex::new(self.signals.lock().unwrap().clone()),
             preopen: self.preopen.clone(),
         }
     }
diff --git a/lib/wasix/src/state/run.rs b/lib/wasix/src/state/run.rs
deleted file mode 100644
index 265b473313..0000000000
--- a/lib/wasix/src/state/run.rs
+++ /dev/null
@@ -1,212 +0,0 @@
-use virtual_mio::InlineWaker;
-use wasmer::{RuntimeError, Store};
-use wasmer_wasix_types::wasi::ExitCode;
-
-use crate::{os::task::thread::RewindResultType, RewindStateOption, WasiError, WasiRuntimeError};
-
-use super::*;
-
-impl WasiFunctionEnv {
-    #[allow(clippy::result_large_err)]
-    pub fn run_async(self, mut store: Store) -> Result<(Self, Store), WasiRuntimeError> {
-        // If no handle or runtime exists then create one
-        #[cfg(feature = "sys-thread")]
-        let _guard = if tokio::runtime::Handle::try_current().is_err() {
-            let runtime = tokio::runtime::Builder::new_multi_thread()
-                .enable_all()
-                .build()
-                .unwrap();
-            Some(runtime)
-        } else {
-            None
-        };
-        #[cfg(feature = "sys-thread")]
-        let _guard = _guard.as_ref().map(|r| r.enter());
-
-        self.data(&store).thread.set_status_running();
-
-        let tasks = self.data(&store).tasks().clone();
-        let pid = self.data(&store).pid();
-        let tid = self.data(&store).tid();
-
-        // The return value is passed synchronously and will block until the result
-        // is returned this is because the main thread can go into a deep sleep and
-        // exit the dedicated thread
-        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
-
-        let this = self.clone();
-        tasks.task_dedicated(Box::new(move || {
-            // Unsafe: The bootstrap must be executed in the same thread that runs the
-            //         actual WASM code
-            let rewind_state = unsafe {
-                match this.bootstrap(&mut store) {
-                    Ok(a) => a,
-                    Err(err) => {
-                        tracing::warn!("failed to bootstrap - {}", err);
-                        this.on_exit(&mut store, None);
-                        tx.send(Err(err)).ok();
-                        return;
-                    }
-                }
-            };
-
-            run_with_deep_sleep(store, rewind_state, this, tx);
-        }))?;
-
-        let result = InlineWaker::block_on(rx.recv());
-        let store = match result {
-            Some(result) => {
-                tracing::trace!(
-                    %pid,
-                    %tid,
-                    error=result.as_ref().err().map(|e| e as &dyn std::error::Error),
-                    "main exit",
-                );
-                result?
-            }
-            None => {
-                tracing::trace!(
-                    %pid,
-                    %tid,
-                    "main premature termination",
-                );
-                return Err(WasiRuntimeError::Runtime(RuntimeError::new(
-                    "main thread terminated without a result, this normally means a panic occurred",
-                )));
-            }
-        };
-        Ok((self, store))
-    }
-}
-
-fn run_with_deep_sleep(
-    mut store: Store,
-    rewind_state: RewindStateOption,
-    env: WasiFunctionEnv,
-    sender: tokio::sync::mpsc::UnboundedSender<Result<Store, WasiRuntimeError>>,
-) {
-    if let Some((rewind_state, rewind_result)) = rewind_state {
-        tracing::trace!("Rewinding");
-        let mut ctx = env.env.clone().into_mut(&mut store);
-        let errno = if rewind_state.is_64bit {
-            crate::rewind_ext::<wasmer_types::Memory64>(
-                &mut ctx,
-                Some(rewind_state.memory_stack),
-                rewind_state.rewind_stack,
-                rewind_state.store_data,
-                rewind_result,
-            )
-        } else {
-            crate::rewind_ext::<wasmer_types::Memory32>(
-                &mut ctx,
-                Some(rewind_state.memory_stack),
-                rewind_state.rewind_stack,
-                rewind_state.store_data,
-                rewind_result,
-            )
-        };
-
-        if errno != Errno::Success {
-            let exit_code = ExitCode::from(errno);
-            env.on_exit(&mut store, Some(exit_code));
-            if exit_code.is_success() {
-                let _ = sender.send(Ok(store));
-            } else {
-                let _ = sender.send(Err(WasiRuntimeError::Wasi(WasiError::Exit(exit_code))));
-            }
-            return;
-        }
-    }
-
-    let instance = match env.data(&store).try_clone_instance() {
-        Some(instance) => instance,
-        None => {
-            tracing::debug!("Unable to clone the instance");
-            env.on_exit(&mut store, None);
-            let _ = sender.send(Err(WasiRuntimeError::Wasi(WasiError::Exit(
-                Errno::Noexec.into(),
-            ))));
-            return;
-        }
-    };
-
-    let start = match instance.exports.get_function("_start") {
-        Ok(start) => start,
-        Err(e) => {
-            tracing::debug!("Unable to get the _start function");
-            env.on_exit(&mut store, None);
-            let _ = sender.send(Err(e.into()));
-            return;
-        }
-    };
-
-    let result = start.call(&mut store, &[]);
-    handle_result(store, env, result, sender);
-}
-
-fn handle_result(
-    mut store: Store,
-    env: WasiFunctionEnv,
-    result: Result<Box<[wasmer::Value]>, RuntimeError>,
-    sender: tokio::sync::mpsc::UnboundedSender<Result<Store, WasiRuntimeError>>,
-) {
-    let result: Result<_, WasiRuntimeError> = match result.map_err(|e| e.downcast::<WasiError>()) {
-        Err(Ok(WasiError::DeepSleep(work))) => {
-            let pid = env.data(&store).pid();
-            let tid = env.data(&store).tid();
-            tracing::trace!(%pid, %tid, "entered a deep sleep");
-
-            let tasks = env.data(&store).tasks().clone();
-            let rewind = work.rewind;
-            let respawn = move |ctx, store, res| {
-                run_with_deep_sleep(
-                    store,
-                    Some((rewind, RewindResultType::RewindWithResult(res))),
-                    ctx,
-                    sender,
-                )
-            };
-
-            // Spawns the WASM process after a trigger
-            unsafe {
-                tasks
-                    .resume_wasm_after_poller(Box::new(respawn), env, store, work.trigger)
-                    .unwrap();
-            }
-
-            return;
-        }
-        Ok(_) => Ok(()),
-        Err(Ok(other)) => Err(other.into()),
-        Err(Err(e)) => Err(e.into()),
-    };
-
-    let (result, exit_code) = wasi_exit_code(result);
-    env.on_exit(&mut store, Some(exit_code));
-    sender.send(result.map(|_| store)).ok();
-}
-
-/// Extract the exit code from a `Result<(), WasiRuntimeError>`.
-///
-/// We need this because calling `exit(0)` inside a WASI program technically
-/// triggers [`WasiError`] with an exit code of `0`, but the end user won't want
-/// that treated as an error.
-pub(super) fn wasi_exit_code(
-    mut result: Result<(), WasiRuntimeError>,
-) -> (Result<(), WasiRuntimeError>, ExitCode) {
-    let exit_code = match &result {
-        Ok(_) => Errno::Success.into(),
-        Err(err) => match err.as_exit_code() {
-            Some(code) if code.is_success() => {
-                // This is actually not an error, so we need to fix up the
-                // result
-                result = Ok(());
-                Errno::Success.into()
-            }
-            Some(other) => other,
-            None => Errno::Noexec.into(),
-        },
-    };
-
-    (result, exit_code)
-}
diff --git a/lib/wasix/src/syscalls/journal/actions/close_thread.rs b/lib/wasix/src/syscalls/journal/actions/close_thread.rs
index 159cafb02b..8f41267132 100644
--- a/lib/wasix/src/syscalls/journal/actions/close_thread.rs
+++ b/lib/wasix/src/syscalls/journal/actions/close_thread.rs
@@ -1,6 +1,6 @@
 use super::*;
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl<'a> JournalSyscallPlayer<'a, '_> {
     #[allow(clippy::result_large_err)]
     pub(crate) unsafe fn action_close_thread(
         &mut self,
diff --git a/lib/wasix/src/syscalls/journal/actions/fd_advise.rs b/lib/wasix/src/syscalls/journal/actions/fd_advise.rs
index 2e094bc9e7..354f587134 100644
--- a/lib/wasix/src/syscalls/journal/actions/fd_advise.rs
+++ b/lib/wasix/src/syscalls/journal/actions/fd_advise.rs
@@ -1,6 +1,6 @@
 use super::*;
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl JournalSyscallPlayer<'_, '_> {
     #[allow(clippy::result_large_err)]
     pub(crate) unsafe fn action_fd_advise(
         &mut self,
diff --git a/lib/wasix/src/syscalls/journal/actions/fd_allocate.rs b/lib/wasix/src/syscalls/journal/actions/fd_allocate.rs
index dbf1896003..6733012fbc 100644
--- a/lib/wasix/src/syscalls/journal/actions/fd_allocate.rs
+++ b/lib/wasix/src/syscalls/journal/actions/fd_allocate.rs
@@ -1,6 +1,6 @@
 use super::*;
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl JournalSyscallPlayer<'_, '_> {
     #[allow(clippy::result_large_err)]
     pub(crate) unsafe fn action_fd_allocate(
         &mut self,
diff --git a/lib/wasix/src/syscalls/journal/actions/fd_close.rs b/lib/wasix/src/syscalls/journal/actions/fd_close.rs
index 26b308c5aa..0f8cd36aa6 100644
--- a/lib/wasix/src/syscalls/journal/actions/fd_close.rs
+++ b/lib/wasix/src/syscalls/journal/actions/fd_close.rs
@@ -1,6 +1,6 @@
 use super::*;
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl JournalSyscallPlayer<'_, '_> {
     #[allow(clippy::result_large_err)]
     pub(crate) unsafe fn action_fd_close(&mut self, fd: u32) -> Result<(), WasiRuntimeError> {
         tracing::trace!(%fd, "Replay journal - FdClose");
diff --git a/lib/wasix/src/syscalls/journal/actions/fd_dup.rs b/lib/wasix/src/syscalls/journal/actions/fd_dup.rs
index dd4bd8d3ba..f3db8f21af 100644
--- a/lib/wasix/src/syscalls/journal/actions/fd_dup.rs
+++ b/lib/wasix/src/syscalls/journal/actions/fd_dup.rs
@@ -1,11 +1,12 @@
 use super::*;
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl JournalSyscallPlayer<'_, '_> {
     #[allow(clippy::result_large_err)]
     pub(crate) unsafe fn action_fd_dup(
         &mut self,
         original_fd: u32,
         copied_fd: u32,
+        cloexec: bool,
     ) -> Result<(), WasiRuntimeError> {
         tracing::trace!(%original_fd, %copied_fd, "Replay journal - FdDuplicate");
         self.real_fd.insert(copied_fd);
@@ -19,7 +20,7 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
         if self.stderr_fds.contains(&original_fd) {
             self.stderr_fds.insert(copied_fd);
         }
-        JournalEffector::apply_fd_duplicate(&mut self.ctx, original_fd, copied_fd)
+        JournalEffector::apply_fd_duplicate(&mut self.ctx, original_fd, copied_fd, cloexec)
             .map_err(anyhow_err_to_runtime_err)?;
         Ok(())
     }
diff --git a/lib/wasix/src/syscalls/journal/actions/fd_open.rs b/lib/wasix/src/syscalls/journal/actions/fd_open.rs
index 2393bac14a..70fe165fc0 100644
--- a/lib/wasix/src/syscalls/journal/actions/fd_open.rs
+++ b/lib/wasix/src/syscalls/journal/actions/fd_open.rs
@@ -1,6 +1,6 @@
 use super::*;
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl<'a> JournalSyscallPlayer<'a, '_> {
     #[allow(clippy::result_large_err)]
     pub(crate) unsafe fn action_fd_open(
         &mut self,
@@ -12,6 +12,7 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
         fs_rights_base: Rights,
         fs_rights_inheriting: Rights,
         fs_flags: Fdflags,
+        fd_flags: Fdflagsext,
     ) -> Result<(), WasiRuntimeError> {
         tracing::trace!(%fd, %dirfd, %dirflags,  "Replay journal - FdOpen {}", path);
         JournalEffector::apply_path_open(
@@ -24,6 +25,7 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
             fs_rights_base,
             fs_rights_inheriting,
             fs_flags,
+            fd_flags,
         )
         .map_err(anyhow_err_to_runtime_err)?;
         Ok(())
diff --git a/lib/wasix/src/syscalls/journal/actions/fd_renumber.rs b/lib/wasix/src/syscalls/journal/actions/fd_renumber.rs
index b2b485f075..b80a1075f1 100644
--- a/lib/wasix/src/syscalls/journal/actions/fd_renumber.rs
+++ b/lib/wasix/src/syscalls/journal/actions/fd_renumber.rs
@@ -1,6 +1,6 @@
 use super::*;
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl JournalSyscallPlayer<'_, '_> {
     #[allow(clippy::result_large_err)]
     pub(crate) unsafe fn action_fd_renumber(
         &mut self,
diff --git a/lib/wasix/src/syscalls/journal/actions/fd_seek.rs b/lib/wasix/src/syscalls/journal/actions/fd_seek.rs
index c57b10dd3e..d7d670fe3a 100644
--- a/lib/wasix/src/syscalls/journal/actions/fd_seek.rs
+++ b/lib/wasix/src/syscalls/journal/actions/fd_seek.rs
@@ -1,6 +1,6 @@
 use super::*;
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl JournalSyscallPlayer<'_, '_> {
     #[allow(clippy::result_large_err)]
     pub(crate) unsafe fn action_fd_seek(
         &mut self,
diff --git a/lib/wasix/src/syscalls/journal/actions/fd_set_fdflags.rs b/lib/wasix/src/syscalls/journal/actions/fd_set_fdflags.rs
new file mode 100644
index 0000000000..f4a6c7fe1c
--- /dev/null
+++ b/lib/wasix/src/syscalls/journal/actions/fd_set_fdflags.rs
@@ -0,0 +1,15 @@
+use super::*;
+
+impl JournalSyscallPlayer<'_, '_> {
+    #[allow(clippy::result_large_err)]
+    pub(crate) unsafe fn action_fd_set_fdflags(
+        &mut self,
+        fd: Fd,
+        flags: Fdflagsext,
+    ) -> Result<(), WasiRuntimeError> {
+        tracing::trace!(%fd, ?flags, "Replay journal - FdSetFlags");
+        JournalEffector::apply_fd_set_fdflags(&mut self.ctx, fd, flags)
+            .map_err(anyhow_err_to_runtime_err)?;
+        Ok(())
+    }
+}
diff --git a/lib/wasix/src/syscalls/journal/actions/fd_set_flags.rs b/lib/wasix/src/syscalls/journal/actions/fd_set_flags.rs
index db2511cf9b..149db3be03 100644
--- a/lib/wasix/src/syscalls/journal/actions/fd_set_flags.rs
+++ b/lib/wasix/src/syscalls/journal/actions/fd_set_flags.rs
@@ -1,6 +1,6 @@
 use super::*;
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl JournalSyscallPlayer<'_, '_> {
     #[allow(clippy::result_large_err)]
     pub(crate) unsafe fn action_fd_set_flags(
         &mut self,
diff --git a/lib/wasix/src/syscalls/journal/actions/fd_set_rights.rs b/lib/wasix/src/syscalls/journal/actions/fd_set_rights.rs
index 479fe23524..8cbf7aeed8 100644
--- a/lib/wasix/src/syscalls/journal/actions/fd_set_rights.rs
+++ b/lib/wasix/src/syscalls/journal/actions/fd_set_rights.rs
@@ -1,6 +1,6 @@
 use super::*;
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl JournalSyscallPlayer<'_, '_> {
     #[allow(clippy::result_large_err)]
     pub(crate) unsafe fn action_fd_set_rights(
         &mut self,
diff --git a/lib/wasix/src/syscalls/journal/actions/fd_set_size.rs b/lib/wasix/src/syscalls/journal/actions/fd_set_size.rs
index 12084fc969..13be5aefcd 100644
--- a/lib/wasix/src/syscalls/journal/actions/fd_set_size.rs
+++ b/lib/wasix/src/syscalls/journal/actions/fd_set_size.rs
@@ -1,6 +1,6 @@
 use super::*;
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl JournalSyscallPlayer<'_, '_> {
     #[allow(clippy::result_large_err)]
     pub(crate) unsafe fn action_fd_set_size(
         &mut self,
diff --git a/lib/wasix/src/syscalls/journal/actions/fd_set_times.rs b/lib/wasix/src/syscalls/journal/actions/fd_set_times.rs
index 7c615e9e23..4e730dc1fa 100644
--- a/lib/wasix/src/syscalls/journal/actions/fd_set_times.rs
+++ b/lib/wasix/src/syscalls/journal/actions/fd_set_times.rs
@@ -1,6 +1,6 @@
 use super::*;
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl JournalSyscallPlayer<'_, '_> {
     #[allow(clippy::result_large_err)]
     pub(crate) unsafe fn action_fd_set_times(
         &mut self,
diff --git a/lib/wasix/src/syscalls/journal/actions/fd_write.rs b/lib/wasix/src/syscalls/journal/actions/fd_write.rs
index 06e7249d85..9a1dda06cb 100644
--- a/lib/wasix/src/syscalls/journal/actions/fd_write.rs
+++ b/lib/wasix/src/syscalls/journal/actions/fd_write.rs
@@ -1,6 +1,6 @@
 use super::*;
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl<'a> JournalSyscallPlayer<'a, '_> {
     #[allow(clippy::result_large_err)]
     pub(crate) unsafe fn action_fd_write(
         &mut self,
@@ -11,18 +11,30 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
     ) -> Result<(), WasiRuntimeError> {
         tracing::trace!(%fd, %offset, "Replay journal - FdWrite");
         if self.stdout_fds.contains(&fd) {
-            self.stdout.push((offset, data, is_64bit));
+            if let Some(x) = self.stdout.as_mut() {
+                x.push(JournalStdIoWrite {
+                    offset,
+                    data,
+                    is_64bit,
+                });
+            }
             return Ok(());
         }
         if self.stderr_fds.contains(&fd) {
-            self.stderr.push((offset, data, is_64bit));
+            if let Some(x) = self.stdout.as_mut() {
+                x.push(JournalStdIoWrite {
+                    offset,
+                    data,
+                    is_64bit,
+                });
+            }
             return Ok(());
         }
 
         if is_64bit {
-            JournalEffector::apply_fd_write::<Memory64>(&self.ctx, fd, offset, data)
+            JournalEffector::apply_fd_write::<Memory64>(&mut self.ctx, fd, offset, data)
         } else {
-            JournalEffector::apply_fd_write::<Memory32>(&self.ctx, fd, offset, data)
+            JournalEffector::apply_fd_write::<Memory32>(&mut self.ctx, fd, offset, data)
         }
         .map_err(anyhow_err_to_runtime_err)?;
         Ok(())
diff --git a/lib/wasix/src/syscalls/journal/actions/init_module.rs b/lib/wasix/src/syscalls/journal/actions/init_module.rs
index a8a5b15329..a1c8c97f44 100644
--- a/lib/wasix/src/syscalls/journal/actions/init_module.rs
+++ b/lib/wasix/src/syscalls/journal/actions/init_module.rs
@@ -1,6 +1,6 @@
 use super::*;
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl<'a> JournalSyscallPlayer<'a, '_> {
     #[allow(clippy::result_large_err)]
     pub(crate) unsafe fn action_init_module(
         &mut self,
diff --git a/lib/wasix/src/syscalls/journal/actions/mod.rs b/lib/wasix/src/syscalls/journal/actions/mod.rs
index 49a5d1d6a4..90ca821535 100644
--- a/lib/wasix/src/syscalls/journal/actions/mod.rs
+++ b/lib/wasix/src/syscalls/journal/actions/mod.rs
@@ -6,6 +6,7 @@ mod fd_dup;
 mod fd_open;
 mod fd_renumber;
 mod fd_seek;
+mod fd_set_fdflags;
 mod fd_set_flags;
 mod fd_set_rights;
 mod fd_set_size;
@@ -21,7 +22,7 @@ mod update_memory;
 
 use crate::journal::JournalEffector;
 use crate::syscalls::anyhow_err_to_runtime_err;
-use crate::syscalls::JournalSyscallPlayer;
+use crate::syscalls::{JournalStdIoWrite, JournalSyscallPlayer};
 use crate::RewindState;
 use crate::WasiRuntimeError;
 use crate::WasiThreadId;
@@ -36,10 +37,10 @@ use wasmer_types::Memory64;
 use wasmer_wasix_types::wasi::Advice;
 use wasmer_wasix_types::wasi::ExitCode;
 use wasmer_wasix_types::wasi::Fd;
-use wasmer_wasix_types::wasi::Fdflags;
 use wasmer_wasix_types::wasi::Filesize;
 use wasmer_wasix_types::wasi::Tty;
 use wasmer_wasix_types::wasi::Whence;
+use wasmer_wasix_types::wasi::{Fdflags, Fdflagsext};
 use wasmer_wasix_types::wasi::{Fstflags, LookupFlags, Timestamp};
 use wasmer_wasix_types::wasi::{Oflags, Rights};
 use wasmer_wasix_types::wasix::ThreadStartType;
diff --git a/lib/wasix/src/syscalls/journal/actions/path_set_times.rs b/lib/wasix/src/syscalls/journal/actions/path_set_times.rs
index c91fe3c21e..7a6d41f425 100644
--- a/lib/wasix/src/syscalls/journal/actions/path_set_times.rs
+++ b/lib/wasix/src/syscalls/journal/actions/path_set_times.rs
@@ -1,12 +1,12 @@
 use super::*;
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl<'a> JournalSyscallPlayer<'a, '_> {
     #[allow(clippy::result_large_err)]
     pub(crate) unsafe fn action_path_set_times(
         &mut self,
         fd: Fd,
         flags: LookupFlags,
-        path: Cow<'_, str>,
+        path: Cow<'a, str>,
         st_atim: Timestamp,
         st_mtim: Timestamp,
         fst_flags: Fstflags,
diff --git a/lib/wasix/src/syscalls/journal/actions/process_exit.rs b/lib/wasix/src/syscalls/journal/actions/process_exit.rs
index 6228c88658..0740442063 100644
--- a/lib/wasix/src/syscalls/journal/actions/process_exit.rs
+++ b/lib/wasix/src/syscalls/journal/actions/process_exit.rs
@@ -1,6 +1,6 @@
 use super::*;
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl<'a> JournalSyscallPlayer<'a, '_> {
     #[allow(clippy::result_large_err)]
     pub(crate) unsafe fn action_process_exit(
         &mut self,
diff --git a/lib/wasix/src/syscalls/journal/actions/set_thread.rs b/lib/wasix/src/syscalls/journal/actions/set_thread.rs
index d97e7d041a..150347a19f 100644
--- a/lib/wasix/src/syscalls/journal/actions/set_thread.rs
+++ b/lib/wasix/src/syscalls/journal/actions/set_thread.rs
@@ -1,6 +1,6 @@
 use super::*;
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl<'a> JournalSyscallPlayer<'a, '_> {
     #[allow(clippy::result_large_err)]
     pub(crate) unsafe fn action_set_thread(
         &mut self,
diff --git a/lib/wasix/src/syscalls/journal/actions/snapshot.rs b/lib/wasix/src/syscalls/journal/actions/snapshot.rs
index add81d0e87..b62720a580 100644
--- a/lib/wasix/src/syscalls/journal/actions/snapshot.rs
+++ b/lib/wasix/src/syscalls/journal/actions/snapshot.rs
@@ -1,6 +1,6 @@
 use super::*;
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl<'a> JournalSyscallPlayer<'a, '_> {
     #[allow(clippy::result_large_err)]
     pub(crate) unsafe fn action_snapshot(
         &mut self,
diff --git a/lib/wasix/src/syscalls/journal/actions/tty_set.rs b/lib/wasix/src/syscalls/journal/actions/tty_set.rs
index 2d0206e394..c277f1fb54 100644
--- a/lib/wasix/src/syscalls/journal/actions/tty_set.rs
+++ b/lib/wasix/src/syscalls/journal/actions/tty_set.rs
@@ -1,6 +1,6 @@
 use super::*;
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl JournalSyscallPlayer<'_, '_> {
     #[allow(clippy::result_large_err)]
     pub(crate) unsafe fn action_tty_set(
         &mut self,
diff --git a/lib/wasix/src/syscalls/journal/actions/update_memory.rs b/lib/wasix/src/syscalls/journal/actions/update_memory.rs
index e12d9da7ec..60edbacb3b 100644
--- a/lib/wasix/src/syscalls/journal/actions/update_memory.rs
+++ b/lib/wasix/src/syscalls/journal/actions/update_memory.rs
@@ -1,6 +1,6 @@
 use super::*;
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl<'a> JournalSyscallPlayer<'a, '_> {
     #[allow(clippy::result_large_err)]
     pub(crate) unsafe fn action_update_compressed_memory(
         &mut self,
diff --git a/lib/wasix/src/syscalls/journal/clear_ethereal.rs b/lib/wasix/src/syscalls/journal/clear_ethereal.rs
index 2ce4fc9b76..94c1f0b0b4 100644
--- a/lib/wasix/src/syscalls/journal/clear_ethereal.rs
+++ b/lib/wasix/src/syscalls/journal/clear_ethereal.rs
@@ -1,18 +1,25 @@
 use super::*;
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl<'a> JournalSyscallPlayer<'a, '_> {
     pub(super) fn clear_ethereal(
         &mut self,
         mut differ_ethereal: Option<&mut Vec<JournalEntry<'a>>>,
     ) {
         tracing::trace!("Replay journal - ClearEthereal");
         self.spawn_threads.clear();
-        self.stdout.clear();
-        self.stderr.clear();
+
+        if let Some(x) = self.stdout.as_mut() {
+            x.clear();
+        }
         self.stdout_fds.clear();
-        self.stderr_fds.clear();
         self.stdout_fds.insert(1 as WasiFd);
+
+        if let Some(x) = self.stderr.as_mut() {
+            x.clear();
+        }
+        self.stderr_fds.clear();
         self.stderr_fds.insert(2 as WasiFd);
+
         differ_ethereal.iter_mut().for_each(|e| e.clear());
         self.staged_differ_memory.clear();
     }
diff --git a/lib/wasix/src/syscalls/journal/mod.rs b/lib/wasix/src/syscalls/journal/mod.rs
index 5d9ffde14f..1b8923ed86 100644
--- a/lib/wasix/src/syscalls/journal/mod.rs
+++ b/lib/wasix/src/syscalls/journal/mod.rs
@@ -27,6 +27,12 @@ use std::{collections::BTreeMap, ops::Range};
 
 use super::*;
 
+pub struct JournalStdIoWrite<'a> {
+    pub offset: u64,
+    pub data: Cow<'a, [u8]>,
+    pub is_64bit: bool,
+}
+
 pub struct JournalSyscallPlayer<'a, 'c> {
     pub ctx: FunctionEnvMut<'c, WasiEnv>,
     pub bootstrapping: bool,
@@ -45,16 +51,18 @@ pub struct JournalSyscallPlayer<'a, 'c> {
     pub differ_memory: Vec<(Range<u64>, Cow<'a, [u8]>)>,
 
     // We capture the stdout and stderr while we replay
-    pub stdout: Vec<(u64, Cow<'a, [u8]>, bool)>,
-    pub stderr: Vec<(u64, Cow<'a, [u8]>, bool)>,
+    pub stdout: Option<Vec<JournalStdIoWrite<'a>>>,
+    pub stderr: Option<Vec<JournalStdIoWrite<'a>>>,
     pub stdout_fds: HashSet<u32>,
     pub stderr_fds: HashSet<u32>,
 }
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl<'c> JournalSyscallPlayer<'_, 'c> {
     pub fn new(mut ctx: FunctionEnvMut<'c, WasiEnv>, bootstrapping: bool) -> Self {
-        let cur_module_hash: Box<[u8]> = Box::from(ctx.data().process.module_hash.as_bytes());
-        let mut ret = JournalSyscallPlayer {
+        let env = ctx.data();
+        let keep_stdio = !env.skip_stdio_during_bootstrap;
+        let cur_module_hash: Box<[u8]> = Box::from(env.process.module_hash.as_bytes());
+        JournalSyscallPlayer {
             ctx,
             bootstrapping,
             cur_module_hash,
@@ -64,17 +72,12 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
             spawn_threads: Default::default(),
             staged_differ_memory: Default::default(),
             differ_memory: Default::default(),
-            stdout: Default::default(),
-            stderr: Default::default(),
-            stdout_fds: Default::default(),
-            stderr_fds: Default::default(),
+            // We capture stdout and stderr while we replay
+            stdout_fds: [1 as WasiFd].into(),
+            stderr_fds: [2 as WasiFd].into(),
+            stdout: keep_stdio.then(Default::default),
+            stderr: keep_stdio.then(Default::default),
             real_fd: Default::default(),
-        };
-
-        // We capture the stdout and stderr while we replay
-        ret.stdout_fds.insert(1 as WasiFd);
-        ret.stderr_fds.insert(2 as WasiFd);
-
-        ret
+        }
     }
 }
diff --git a/lib/wasix/src/syscalls/journal/play_event.rs b/lib/wasix/src/syscalls/journal/play_event.rs
index 96368dc08e..c6fd33d78d 100644
--- a/lib/wasix/src/syscalls/journal/play_event.rs
+++ b/lib/wasix/src/syscalls/journal/play_event.rs
@@ -2,7 +2,7 @@ use std::ops::Range;
 
 use super::*;
 
-impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+impl<'a> JournalSyscallPlayer<'a, '_> {
     #[allow(clippy::result_large_err)]
     pub(super) unsafe fn play_event(
         &mut self,
@@ -108,6 +108,31 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                     fs_rights_base,
                     fs_rights_inheriting,
                     fs_flags,
+                    Fdflagsext::empty(),
+                )?;
+            }
+            JournalEntry::OpenFileDescriptorV2 {
+                fd,
+                dirfd,
+                dirflags,
+                path,
+                o_flags,
+                fs_rights_base,
+                fs_rights_inheriting,
+                fs_flags,
+                fd_flags,
+            } => {
+                self.real_fd.insert(fd);
+                self.action_fd_open(
+                    fd,
+                    dirfd,
+                    dirflags,
+                    path,
+                    o_flags,
+                    fs_rights_base,
+                    fs_rights_inheriting,
+                    fs_flags,
+                    fd_flags,
                 )?;
             }
             JournalEntry::RemoveDirectoryV1 { fd, path } => {
@@ -159,7 +184,7 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                 copied_fd,
             } => {
                 if self.real_fd.contains(&original_fd) {
-                    self.action_fd_dup(original_fd, copied_fd)?;
+                    self.action_fd_dup(original_fd, copied_fd, false)?;
                 } else if let Some(differ_ethereal) = differ_ethereal {
                     tracing::trace!(%original_fd, %copied_fd, "Differ(ether) journal - FdDuplicate");
                     differ_ethereal.push(JournalEntry::DuplicateFileDescriptorV1 {
@@ -167,7 +192,25 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                         copied_fd,
                     });
                 } else {
-                    self.action_fd_dup(original_fd, copied_fd)?;
+                    self.action_fd_dup(original_fd, copied_fd, false)?;
+                }
+            }
+            JournalEntry::DuplicateFileDescriptorV2 {
+                original_fd,
+                copied_fd,
+                cloexec,
+            } => {
+                if self.real_fd.contains(&original_fd) {
+                    self.action_fd_dup(original_fd, copied_fd, cloexec)?;
+                } else if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%original_fd, %copied_fd, %cloexec, "Differ(ether) journal - FdDuplicate");
+                    differ_ethereal.push(JournalEntry::DuplicateFileDescriptorV2 {
+                        original_fd,
+                        copied_fd,
+                        cloexec,
+                    });
+                } else {
+                    self.action_fd_dup(original_fd, copied_fd, cloexec)?;
                 }
             }
             JournalEntry::CreateDirectoryV1 { fd, path } => {
@@ -229,6 +272,16 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                     self.action_fd_set_size(fd, st_size)?;
                 }
             }
+            JournalEntry::FileDescriptorSetFdFlagsV1 { fd, flags } => {
+                if self.real_fd.contains(&fd) {
+                    self.action_fd_set_fdflags(fd, flags)?;
+                } else if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, ?flags, "Differ(ether) journal - FdSetFdFlags");
+                    differ_ethereal.push(JournalEntry::FileDescriptorSetFdFlagsV1 { fd, flags });
+                } else {
+                    self.action_fd_set_fdflags(fd, flags)?;
+                }
+            }
             JournalEntry::FileDescriptorSetFlagsV1 { fd, flags } => {
                 if self.real_fd.contains(&fd) {
                     self.action_fd_set_flags(fd, flags)?;
@@ -323,13 +376,13 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                 JournalEffector::apply_chdir(&mut self.ctx, &path)
                     .map_err(anyhow_err_to_runtime_err)?;
             }
-            JournalEntry::CreatePipeV1 { fd1, fd2 } => {
+            JournalEntry::CreatePipeV1 { read_fd, write_fd } => {
                 if let Some(differ_ethereal) = differ_ethereal {
-                    tracing::trace!(%fd1, %fd2,  "Differ(ether) journal - CreatePipe");
-                    differ_ethereal.push(JournalEntry::CreatePipeV1 { fd1, fd2 });
+                    tracing::trace!(%read_fd, %write_fd,  "Differ(ether) journal - CreatePipe");
+                    differ_ethereal.push(JournalEntry::CreatePipeV1 { read_fd, write_fd });
                 } else {
-                    tracing::trace!(%fd1, %fd2,  "Replay journal - CreatePipe");
-                    JournalEffector::apply_fd_pipe(&mut self.ctx, fd1, fd2)
+                    tracing::trace!(%read_fd, %write_fd,  "Replay journal - CreatePipe");
+                    JournalEffector::apply_fd_pipe(&mut self.ctx, read_fd, write_fd)
                         .map_err(anyhow_err_to_runtime_err)?;
                 }
             }
@@ -446,6 +499,16 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                         .map_err(anyhow_err_to_runtime_err)?
                 }
             }
+            JournalEntry::SocketPairV1 { fd1, fd2 } => {
+                if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd1, %fd2, "Differ(ether) journal - SocketPair");
+                    differ_ethereal.push(JournalEntry::SocketPairV1 { fd1, fd2 });
+                } else {
+                    tracing::trace!(%fd1, %fd2, "Replay journal - SocketOpen");
+                    JournalEffector::apply_sock_pair(&mut self.ctx, fd1, fd2)
+                        .map_err(anyhow_err_to_runtime_err)?
+                }
+            }
             JournalEntry::SocketListenV1 { fd, backlog } => {
                 if let Some(differ_ethereal) = differ_ethereal {
                     tracing::trace!(%fd, "Differ(ether) journal - SocketListen");
@@ -667,11 +730,19 @@ impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
                     tracing::trace!(%fd, "Replay journal - SocketSendTo data={} bytes", data.len());
                     if is_64bit {
                         JournalEffector::apply_sock_send_to::<Memory64>(
-                            &self.ctx, fd, data, flags, addr,
+                            &mut self.ctx,
+                            fd,
+                            data,
+                            flags,
+                            addr,
                         )
                     } else {
                         JournalEffector::apply_sock_send_to::<Memory32>(
-                            &self.ctx, fd, data, flags, addr,
+                            &mut self.ctx,
+                            fd,
+                            data,
+                            flags,
+                            addr,
                         )
                     }
                     .map_err(anyhow_err_to_runtime_err)?
diff --git a/lib/wasix/src/syscalls/journal/restore_snapshot.rs b/lib/wasix/src/syscalls/journal/restore_snapshot.rs
index 2f2699194b..70ba4672b0 100644
--- a/lib/wasix/src/syscalls/journal/restore_snapshot.rs
+++ b/lib/wasix/src/syscalls/journal/restore_snapshot.rs
@@ -8,7 +8,7 @@ use super::*;
 #[tracing::instrument(skip_all)]
 pub unsafe fn restore_snapshot(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
-    journal: Arc<DynJournal>,
+    journal: &DynReadableJournal,
     bootstrapping: bool,
 ) -> Result<Option<RewindState>, WasiRuntimeError> {
     use std::{collections::BTreeMap, ops::Range};
@@ -22,7 +22,7 @@ pub unsafe fn restore_snapshot(
     let mut ethereal_events = Vec::new();
     while let Some(next) = journal.read().map_err(anyhow_err_to_runtime_err)? {
         tracing::trace!(event=?next, "restoring event");
-        runner.play_event(next.into_inner(), Some(&mut ethereal_events));
+        runner.play_event(next.into_inner(), Some(&mut ethereal_events))?;
     }
 
     // Check for events that are orphaned
@@ -30,25 +30,42 @@ pub unsafe fn restore_snapshot(
         tracing::trace!("Orphaned ethereal events - {:?}", evt);
     }
 
+    // FIXME: if the stdout/stderr FDs were closed as a result of replaying the journal,
+    // this breaks. A potential fix would be to only close those two FDs afterwards; so
+    // a `JournalSyscallPlayer::should_close_stdout: bool` or similar.
     // Now output the stdout and stderr
-    tracing::trace!("replaying stdout");
-    for (offset, data, is_64bit) in runner.stdout {
-        if is_64bit {
-            JournalEffector::apply_fd_write::<Memory64>(&runner.ctx, 1, offset, data)
-        } else {
-            JournalEffector::apply_fd_write::<Memory32>(&runner.ctx, 1, offset, data)
+    if let Some(stdout) = runner.stdout {
+        tracing::trace!("replaying stdout");
+        for JournalStdIoWrite {
+            offset,
+            data,
+            is_64bit,
+        } in stdout
+        {
+            if is_64bit {
+                JournalEffector::apply_fd_write::<Memory64>(&mut runner.ctx, 1, offset, data)
+            } else {
+                JournalEffector::apply_fd_write::<Memory32>(&mut runner.ctx, 1, offset, data)
+            }
+            .map_err(anyhow_err_to_runtime_err)?;
         }
-        .map_err(anyhow_err_to_runtime_err)?;
     }
 
-    tracing::trace!("replaying stdout");
-    for (offset, data, is_64bit) in runner.stderr {
-        if is_64bit {
-            JournalEffector::apply_fd_write::<Memory64>(&runner.ctx, 2, offset, data)
-        } else {
-            JournalEffector::apply_fd_write::<Memory32>(&runner.ctx, 2, offset, data)
+    if let Some(stderr) = runner.stderr {
+        tracing::trace!("replaying stderr");
+        for JournalStdIoWrite {
+            offset,
+            data,
+            is_64bit,
+        } in stderr
+        {
+            if is_64bit {
+                JournalEffector::apply_fd_write::<Memory64>(&mut runner.ctx, 2, offset, data)
+            } else {
+                JournalEffector::apply_fd_write::<Memory32>(&mut runner.ctx, 2, offset, data)
+            }
+            .map_err(anyhow_err_to_runtime_err)?;
         }
-        .map_err(anyhow_err_to_runtime_err)?;
     }
 
     // Apply the memory changes (if this is in bootstrapping mode we differed them)
@@ -62,10 +79,6 @@ pub unsafe fn restore_snapshot(
             .map_err(anyhow_err_to_runtime_err)?;
     }
 
-    // Reset the freed FD's so that none of them will be reused after
-    // the journal resumes
-    runner.ctx.data().state().fs.clear_freed_fd_list();
-
     // Once we get to this point we are no longer replaying the journal
     // and need to clear this flag, the reason is that restoring the
     // background threads may immediately process requests while this
diff --git a/lib/wasix/src/syscalls/legacy/snapshot0.rs b/lib/wasix/src/syscalls/legacy/snapshot0.rs
index 215c99602f..30a9384da4 100644
--- a/lib/wasix/src/syscalls/legacy/snapshot0.rs
+++ b/lib/wasix/src/syscalls/legacy/snapshot0.rs
@@ -16,7 +16,7 @@ use crate::{
 };
 
 /// Wrapper around `syscalls::fd_filestat_get` for old Snapshot0
-#[instrument(level = "debug", skip_all, ret)]
+#[instrument(level = "trace", skip_all, ret)]
 pub fn fd_filestat_get(
     mut ctx: FunctionEnvMut<WasiEnv>,
     fd: Fd,
@@ -30,7 +30,7 @@ pub fn fd_filestat_get(
 }
 
 /// Wrapper around `syscalls::path_filestat_get` for old Snapshot0
-#[instrument(level = "debug", skip_all, ret)]
+#[instrument(level = "trace", skip_all, ret)]
 pub fn path_filestat_get(
     mut ctx: FunctionEnvMut<WasiEnv>,
     fd: Fd,
@@ -50,7 +50,7 @@ pub fn path_filestat_get(
 
 /// Wrapper around `syscalls::fd_seek` with extra logic to remap the values
 /// of `Whence`
-#[instrument(level = "debug", skip_all, ret)]
+#[instrument(level = "trace", skip_all, ret)]
 pub fn fd_seek(
     ctx: FunctionEnvMut<WasiEnv>,
     fd: Fd,
@@ -77,7 +77,7 @@ pub fn poll_oneoff<M: MemorySize>(
     nsubscriptions: u32,
     nevents: WasmPtr<u32, Memory32>,
 ) -> Result<Errno, WasiError> {
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+    WasiEnv::do_pending_operations(&mut ctx)?;
 
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
diff --git a/lib/wasix/src/syscalls/mod.rs b/lib/wasix/src/syscalls/mod.rs
index 26e1e81d9f..03e09d75c0 100644
--- a/lib/wasix/src/syscalls/mod.rs
+++ b/lib/wasix/src/syscalls/mod.rs
@@ -85,12 +85,12 @@ pub use windows::*;
 
 pub(crate) use self::types::{
     wasi::{
-        Addressfamily, Advice, Clockid, Dircookie, Dirent, Errno, Event, EventFdReadwrite,
-        Eventrwflags, Eventtype, ExitCode, Fd as WasiFd, Fdflags, Fdstat, Filesize, Filestat,
-        Filetype, Fstflags, Linkcount, Longsize, OptionFd, Pid, Prestat, Rights, Snapshot0Clockid,
-        Sockoption, Sockstatus, Socktype, StackSnapshot, StdioMode as WasiStdioMode,
-        Streamsecurity, Subscription, SubscriptionFsReadwrite, Tid, Timestamp, TlKey, TlUser,
-        TlVal, Tty, Whence,
+        Addressfamily, Advice, Clockid, Dircookie, Dirent, DlFlags, DlHandle, Errno, Event,
+        EventFdReadwrite, Eventrwflags, Eventtype, ExitCode, Fd as WasiFd, Fdflags, Fdflagsext,
+        Fdstat, Filesize, Filestat, Filetype, Fstflags, Linkcount, Longsize, OptionFd, Pid,
+        Prestat, ProcSpawnFdOp, Rights, SignalDisposition, Snapshot0Clockid, Sockoption,
+        Sockstatus, Socktype, StackSnapshot, StdioMode as WasiStdioMode, Streamsecurity,
+        Subscription, SubscriptionFsReadwrite, Tid, Timestamp, TlKey, TlUser, TlVal, Tty, Whence,
     },
     *,
 };
@@ -110,21 +110,21 @@ pub(crate) use crate::{
         socket::{InodeHttpSocketType, InodeSocket, InodeSocketKind},
         write_ip_port,
     },
-    runtime::SpawnMemoryType,
+    runtime::SpawnType,
     state::{
         self, iterate_poll_events, InodeGuard, InodeWeakGuard, PollEvent, PollEventBuilder,
         WasiFutex, WasiState,
     },
     utils::{self, map_io_err},
-    Runtime, VirtualTaskManager, WasiEnv, WasiError, WasiFunctionEnv, WasiInstanceHandles,
+    Runtime, VirtualTaskManager, WasiEnv, WasiError, WasiFunctionEnv, WasiModuleTreeHandles,
     WasiVFork,
 };
 use crate::{
     fs::{
-        fs_error_into_wasi_err, virtual_file_type_to_wasi_file_type, Fd, InodeVal, Kind,
+        fs_error_into_wasi_err, virtual_file_type_to_wasi_file_type, Fd, FdInner, InodeVal, Kind,
         MAX_SYMLINKS,
     },
-    journal::{DynJournal, JournalEffector},
+    journal::{DynJournal, DynReadableJournal, DynWritableJournal, JournalEffector},
     os::task::{
         process::{MaybeCheckpointResult, WasiProcessCheckpoint},
         thread::{RewindResult, RewindResultType},
@@ -233,9 +233,8 @@ pub(crate) fn read_bytes<T: Read, M: MemorySize>(
     Ok(bytes_read)
 }
 
-/// Writes data to the stderr
-
 // TODO: remove allow once inodes are refactored (see comments on [`WasiState`])
+/// Writes data to the stderr
 #[allow(clippy::await_holding_lock)]
 pub unsafe fn stderr_write<'a>(
     ctx: &FunctionEnvMut<'_, WasiEnv>,
@@ -245,11 +244,8 @@ pub unsafe fn stderr_write<'a>(
     let (memory, state, inodes) = env.get_memory_and_wasi_state_and_inodes(ctx, 0);
 
     let buf = buf.to_vec();
-    let fd_map = state.fs.fd_map.clone();
-    Box::pin(async move {
-        let mut stderr = WasiInodes::stderr_mut(&fd_map).map_err(fs_error_into_wasi_err)?;
-        stderr.write_all(&buf).await.map_err(map_io_err)
-    })
+    let mut stderr = WasiInodes::stderr_mut(&state.fs.fd_map).map_err(fs_error_into_wasi_err);
+    Box::pin(async move { stderr?.write_all(&buf).await.map_err(map_io_err) })
 }
 
 fn block_on_with_timeout<T, Fut>(
@@ -328,7 +324,7 @@ where
         ctx: &'a mut FunctionEnvMut<'b, WasiEnv>,
         pinned_work: Pin<Box<Fut>>,
     }
-    impl<'a, 'b, Fut, T> Future for SignalPoller<'a, 'b, Fut, T>
+    impl<Fut, T> Future for SignalPoller<'_, '_, Fut, T>
     where
         Fut: Future<Output = Result<T, Errno>>,
     {
@@ -367,7 +363,7 @@ where
     ctx: &'b mut FunctionEnvMut<'c, WasiEnv>,
     work: &'a mut Pin<Box<Fut>>,
 }
-impl<'a, 'b, 'c, T, Fut> Future for AsyncifyPoller<'a, 'b, 'c, T, Fut>
+impl<T, Fut> Future for AsyncifyPoller<'_, '_, '_, T, Fut>
 where
     Fut: Future<Output = T> + Send + Sync + 'static,
 {
@@ -378,6 +374,8 @@ where
             return Poll::Ready(Ok(res));
         }
 
+        WasiEnv::do_pending_link_operations(self.ctx, false);
+
         let env = self.ctx.data();
         if let Some(forced_exit) = env.thread.try_join() {
             return Poll::Ready(Err(WasiError::Exit(forced_exit.unwrap_or_else(|err| {
@@ -410,10 +408,12 @@ where
                     if let Some(exit_code) = has_exit {
                         Poll::Ready(Err(WasiError::Exit(exit_code)))
                     } else {
+                        // Re-subscribe so we get woken up for further signals as well
+                        self.ctx.data().thread.signals_subscribe(cx.waker());
                         Poll::Pending
                     }
                 }
-                Ok(Err(err)) => Poll::Ready(Err(WasiError::Exit(ExitCode::Errno(err)))),
+                Ok(Err(err)) => Poll::Ready(Err(WasiError::Exit(ExitCode::from(err)))),
                 Err(err) => Poll::Ready(Err(err)),
             };
         }
@@ -498,7 +498,9 @@ where
         let env = ctx.data();
 
         // Create the deep sleeper
-        let tasks_for_deep_sleep = if env.enable_deep_sleep {
+        // Deep sleep breaks the linker completely, as it expects other modules to catch the
+        // signal for DL ops
+        let tasks_for_deep_sleep = if env.enable_deep_sleep && env.inner().linker().is_none() {
             Some(env.tasks().clone())
         } else {
             None
@@ -557,7 +559,7 @@ where
 /// synchronous IO engine
 pub(crate) fn __asyncify_light<T, Fut>(
     env: &WasiEnv,
-    timeout: Option<Duration>,
+    _timeout: Option<Duration>,
     work: Fut,
 ) -> WasiResult<T>
 where
@@ -566,37 +568,6 @@ where
 {
     let snapshot_wait = wait_for_snapshot(env);
 
-    // This poller will process any signals when the main working function is idle
-    struct Poller<'a, Fut, T>
-    where
-        Fut: Future<Output = Result<T, Errno>>,
-    {
-        env: &'a WasiEnv,
-        pinned_work: Pin<Box<Fut>>,
-        pinned_snapshot: Pin<Box<dyn Future<Output = ()>>>,
-    }
-    impl<'a, Fut, T> Future for Poller<'a, Fut, T>
-    where
-        Fut: Future<Output = Result<T, Errno>>,
-    {
-        type Output = Result<Fut::Output, WasiError>;
-        fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-            if let Poll::Ready(res) = Pin::new(&mut self.pinned_work).poll(cx) {
-                return Poll::Ready(Ok(res));
-            }
-            if let Poll::Ready(()) = Pin::new(&mut self.pinned_snapshot).poll(cx) {
-                return Poll::Ready(Ok(Err(Errno::Intr)));
-            }
-            if let Some(exit_code) = self.env.should_exit() {
-                return Poll::Ready(Err(WasiError::Exit(exit_code)));
-            }
-            if self.env.thread.has_signals_or_subscribe(cx.waker()) {
-                return Poll::Ready(Ok(Err(Errno::Intr)));
-            }
-            Poll::Pending
-        }
-    }
-
     // Block until the work is finished or until we
     // unload the thread using asyncify
     Ok(InlineWaker::block_on(work))
@@ -627,7 +598,7 @@ where
     Fut: std::future::Future<Output = Result<T, Errno>>,
 {
     let fd_entry = env.state.fs.get_fd(sock)?;
-    if !rights.is_empty() && !fd_entry.rights.contains(rights) {
+    if !rights.is_empty() && !fd_entry.inner.rights.contains(rights) {
         return Err(Errno::Access);
     }
 
@@ -671,7 +642,7 @@ where
     let tasks = env.tasks().clone();
 
     let fd_entry = env.state.fs.get_fd(sock)?;
-    if !rights.is_empty() && !fd_entry.rights.contains(rights) {
+    if !rights.is_empty() && !fd_entry.inner.rights.contains(rights) {
         return Err(Errno::Access);
     }
 
@@ -710,7 +681,7 @@ where
     let tasks = env.tasks().clone();
 
     let fd_entry = env.state.fs.get_fd(sock)?;
-    if !rights.is_empty() && !fd_entry.rights.contains(rights) {
+    if !rights.is_empty() && !fd_entry.inner.rights.contains(rights) {
         return Err(Errno::Access);
     }
 
@@ -747,7 +718,7 @@ where
     let tasks = env.tasks().clone();
 
     let fd_entry = env.state.fs.get_fd(sock)?;
-    if !rights.is_empty() && !fd_entry.rights.contains(rights) {
+    if !rights.is_empty() && !fd_entry.inner.rights.contains(rights) {
         return Err(Errno::Access);
     }
 
@@ -781,7 +752,7 @@ where
 {
     let env = ctx.data();
     let fd_entry = env.state.fs.get_fd(sock)?;
-    if !rights.is_empty() && !fd_entry.rights.contains(rights) {
+    if !rights.is_empty() && !fd_entry.inner.rights.contains(rights) {
         tracing::warn!(
             "wasi[{}:{}]::sock_upgrade(fd={}, rights={:?}) - failed - no access rights to upgrade",
             ctx.data().pid(),
@@ -802,7 +773,7 @@ where
                 drop(guard);
 
                 // Start the work using the socket
-                let work = actor(socket, fd_entry.flags);
+                let work = actor(socket, fd_entry.inner.flags);
 
                 // Block on the work and process it
                 let res = InlineWaker::block_on(work);
@@ -892,14 +863,20 @@ pub(crate) unsafe fn get_memory_stack_pointer(
     // Get the current value of the stack pointer (which we will use
     // to save all of the stack)
     let stack_upper = get_stack_upper(ctx.data());
-    let stack_pointer = if let Some(stack_pointer) = ctx.data().inner().stack_pointer.clone() {
+    let stack_pointer = if let Some(stack_pointer) = ctx
+        .data()
+        .inner()
+        .main_module_instance_handles()
+        .stack_pointer
+        .clone()
+    {
         match stack_pointer.get(ctx) {
             Value::I32(a) => a as u64,
             Value::I64(a) => a as u64,
             _ => stack_upper,
         }
     } else {
-        return Err("failed to save stack: not exported __stack_pointer global".to_string());
+        return Err("failed to save stack: no __stack_pointer global".to_string());
     };
     Ok(stack_pointer)
 }
@@ -921,8 +898,8 @@ pub(crate) fn set_memory_stack_offset(
     let stack_upper = get_stack_upper(env);
     let stack_pointer = stack_upper - offset;
     if let Some(stack_pointer_ptr) = env
-        .try_inner()
-        .ok_or_else(|| "unable to access the stack pointer of the instance".to_string())?
+        .inner()
+        .main_module_instance_handles()
         .stack_pointer
         .clone()
     {
@@ -941,7 +918,7 @@ pub(crate) fn set_memory_stack_offset(
             }
         }
     } else {
-        return Err("failed to save stack: not exported __stack_pointer global".to_string());
+        return Err("failed to save stack: no __stack_pointer global".to_string());
     }
     Ok(())
 }
@@ -955,8 +932,8 @@ pub(crate) fn get_memory_stack<M: MemorySize>(
     // to save all of the stack)
     let stack_base = get_stack_upper(env);
     let stack_pointer = if let Some(stack_pointer) = env
-        .try_inner()
-        .ok_or_else(|| "unable to access the stack pointer of the instance".to_string())?
+        .inner()
+        .main_module_instance_handles()
         .stack_pointer
         .clone()
     {
@@ -966,7 +943,7 @@ pub(crate) fn get_memory_stack<M: MemorySize>(
             _ => stack_base,
         }
     } else {
-        return Err("failed to save stack: not exported __stack_pointer global".to_string());
+        return Err("failed to save stack: no __stack_pointer global".to_string());
     };
     let memory = env
         .try_memory_view(store)
@@ -988,7 +965,7 @@ pub(crate) fn get_memory_stack<M: MemorySize>(
                 .map_err(|err| format!("failed to save stack: stack pointer overflow (stack_pointer={}, stack_lower={}, stack_upper={})", stack_offset, env.layout.stack_lower, env.layout.stack_upper))?,
         )
         .and_then(|memory_stack| memory_stack.read_to_bytes())
-        .map_err(|err| format!("failed to read stack: {}", err))
+        .map_err(|err| format!("failed to read stack: {err}"))
 }
 
 #[allow(dead_code)]
@@ -1018,7 +995,7 @@ pub(crate) fn set_memory_stack<M: MemorySize>(
                 .map_err(|_| "failed to restore stack: stack pointer overflow".to_string())?,
         )
         .and_then(|memory_stack| memory_stack.write_slice(&stack[..]))
-        .map_err(|err| format!("failed to write stack: {}", err))?;
+        .map_err(|err| format!("failed to write stack: {err}"))?;
 
     // Set the stack pointer itself and return
     set_memory_stack_offset(env, store, stack_offset)?;
@@ -1054,7 +1031,7 @@ pub(crate) fn deep_sleep<M: MemorySize>(
                 .unwrap();
             let store_data = Bytes::from(store_data);
 
-            tracing::debug!(
+            tracing::trace!(
                 "stack snapshot unwind (memory_stack={}, rewind_stack={}, store_data={})",
                 memory_stack.len(),
                 rewind_stack.len(),
@@ -1122,7 +1099,7 @@ pub(crate) fn deep_sleep<M: MemorySize>(
     // If there is an error then exit the process, otherwise we are done
     match res {
         Errno::Success => Ok(()),
-        err => Err(WasiError::Exit(ExitCode::Errno(err))),
+        err => Err(WasiError::Exit(ExitCode::from(err))),
     }
 }
 
@@ -1171,9 +1148,10 @@ where
     // Invoke the callback that will prepare to unwind
     // We need to start unwinding the stack
     let asyncify_data = wasi_try_ok!(unwind_pointer.try_into().map_err(|_| Errno::Overflow));
-    if let Some(asyncify_start_unwind) = wasi_try_ok!(env.try_inner().ok_or(Errno::Fault))
-        .asyncify_start_unwind
-        .clone()
+    if let Some(asyncify_start_unwind) = env
+        .inner()
+        .static_module_instance_handles()
+        .and_then(|handles| handles.asyncify_start_unwind.clone())
     {
         asyncify_start_unwind.call(&mut ctx, asyncify_data);
     } else {
@@ -1233,14 +1211,13 @@ where
                     .map_err(|_| "failed to save stack: stack pointer overflow".to_string())?,
             )
             .and_then(|memory_stack| memory_stack.read_to_bytes())
-            .map_err(|err| format!("failed to read stack: {}", err))?;
+            .map_err(|err| format!("failed to read stack: {err}"))?;
 
         // Notify asyncify that we are no longer unwinding
         if let Some(asyncify_stop_unwind) = env
-            .try_inner()
-            .into_iter()
-            .filter_map(|i| i.asyncify_stop_unwind.clone())
-            .next()
+            .inner()
+            .static_module_instance_handles()
+            .and_then(|i| i.asyncify_stop_unwind.clone())
         {
             asyncify_stop_unwind.call(&mut ctx);
         } else {
@@ -1255,11 +1232,11 @@ where
     Ok(Errno::Success)
 }
 
-#[instrument(level = "debug", skip_all, fields(memory_stack_len = memory_stack.len(), rewind_stack_len = rewind_stack.len(), store_data_len = store_data.len()))]
+// NOTE: not tracing-instrumented because [`rewind_ext`] already is.
 #[must_use = "the action must be passed to the call loop"]
 pub fn rewind<M: MemorySize, T>(
     mut ctx: FunctionEnvMut<WasiEnv>,
-    memory_stack: Bytes,
+    memory_stack: Option<Bytes>,
     rewind_stack: Bytes,
     store_data: Bytes,
     result: T,
@@ -1270,14 +1247,14 @@ where
     let rewind_result = bincode::serialize(&result).unwrap().into();
     rewind_ext::<M>(
         &mut ctx,
-        Some(memory_stack),
+        memory_stack,
         rewind_stack,
         store_data,
         RewindResultType::RewindWithResult(rewind_result),
     )
 }
 
-#[instrument(level = "debug", skip_all, fields(rewind_stack_len = rewind_stack.len(), store_data_len = store_data.len()))]
+#[instrument(level = "trace", skip_all, fields(rewind_stack_len = rewind_stack.len(), store_data_len = store_data.len()))]
 #[must_use = "the action must be passed to the call loop"]
 pub fn rewind_ext<M: MemorySize>(
     ctx: &mut FunctionEnvMut<WasiEnv>,
@@ -1350,10 +1327,9 @@ pub fn rewind_ext<M: MemorySize>(
     // Invoke the callback that will prepare to rewind
     let asyncify_data = wasi_try!(rewind_pointer.try_into().map_err(|_| Errno::Overflow));
     if let Some(asyncify_start_rewind) = env
-        .try_inner()
-        .into_iter()
-        .filter_map(|a| a.asyncify_start_rewind.clone())
-        .next()
+        .inner()
+        .static_module_instance_handles()
+        .and_then(|a| a.asyncify_start_rewind.clone())
     {
         asyncify_start_rewind.call(ctx, asyncify_data);
     } else {
@@ -1451,7 +1427,11 @@ where
 
         // Notify asyncify that we are no longer rewinding
         let env = ctx.data();
-        if let Some(asyncify_stop_rewind) = env.inner().asyncify_stop_unwind.clone() {
+        if let Some(asyncify_stop_rewind) = env
+            .inner()
+            .static_module_instance_handles()
+            .and_then(|handles| handles.asyncify_stop_unwind.clone())
+        {
             asyncify_stop_rewind.call(ctx);
         } else {
             warn!("failed to handle rewind because the asyncify_start_rewind export is missing or inaccessible");
@@ -1466,22 +1446,22 @@ where
 
         match result.rewind_result {
             RewindResultType::RewindRestart => {
-                debug!(%pid, %tid, "rewind for syscall restart");
+                tracing::trace!(%pid, %tid, "rewind for syscall restart");
                 None
             }
             RewindResultType::RewindWithoutResult => {
-                debug!(%pid, %tid, "rewind with no result");
+                tracing::trace!(%pid, %tid, "rewind with no result");
                 Some(None)
             }
             RewindResultType::RewindWithResult(rewind_result) => {
-                debug!(%pid, %tid, "rewind with result (data={})", rewind_result.len());
+                tracing::trace!(%pid, %tid, "rewind with result (data={})", rewind_result.len());
                 let ret = bincode::deserialize(&rewind_result)
                     .expect("failed to deserialize the rewind result");
                 Some(Some(ret))
             }
         }
     } else {
-        debug!(%pid, %tid, "rewind miss");
+        tracing::trace!(%pid, %tid, "rewind miss");
         Some(None)
     }
 }
@@ -1491,12 +1471,11 @@ pub(crate) fn _prepare_wasi(
     wasi_env: &mut WasiEnv,
     args: Option<Vec<String>>,
     envs: Option<Vec<(String, String)>>,
+    signals: Option<Vec<SignalDisposition>>,
 ) {
     // Swap out the arguments with the new ones
     if let Some(args) = args {
-        let mut wasi_state = wasi_env.state.fork();
-        wasi_state.args = args;
-        wasi_env.state = Arc::new(wasi_state);
+        *wasi_env.state.args.lock().unwrap() = args;
     }
 
     // Update the env vars
@@ -1531,26 +1510,12 @@ pub(crate) fn _prepare_wasi(
         drop(guard)
     }
 
-    // Close any files after the STDERR that are not preopened
-    let close_fds = {
-        let preopen_fds = {
-            let preopen_fds = wasi_env.state.fs.preopen_fds.read().unwrap();
-            preopen_fds.iter().copied().collect::<HashSet<_>>()
-        };
-        let mut fd_map = wasi_env.state.fs.fd_map.read().unwrap();
-        fd_map
-            .keys()
-            .filter_map(|a| match *a {
-                a if a <= __WASI_STDERR_FILENO => None,
-                a if preopen_fds.contains(&a) => None,
-                a => Some(a),
-            })
-            .collect::<Vec<_>>()
-    };
-
-    // Now close all these files
-    for fd in close_fds {
-        let _ = wasi_env.state.fs.close_fd(fd);
+    if let Some(signals) = signals {
+        let mut guard = wasi_env.state.signals.lock().unwrap();
+        for signal in signals {
+            guard.insert(signal.sig, signal.disp);
+        }
+        drop(guard);
     }
 }
 
diff --git a/lib/wasix/src/syscalls/wasi/args_get.rs b/lib/wasix/src/syscalls/wasi/args_get.rs
index 8a316d92bb..7db6118ba2 100644
--- a/lib/wasix/src/syscalls/wasi/args_get.rs
+++ b/lib/wasix/src/syscalls/wasi/args_get.rs
@@ -10,7 +10,7 @@ use crate::syscalls::*;
 /// - `char *argv_buf`
 ///     A pointer to a buffer to write the argument string data.
 ///
-#[instrument(level = "debug", skip_all, ret)]
+#[instrument(level = "trace", skip_all, ret)]
 pub fn args_get<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     argv: WasmPtr<WasmPtr<u8, M>, M>,
@@ -21,6 +21,8 @@ pub fn args_get<M: MemorySize>(
 
     let args = state
         .args
+        .lock()
+        .unwrap()
         .iter()
         .map(|a| a.as_bytes().to_vec())
         .collect::<Vec<_>>();
@@ -30,9 +32,11 @@ pub fn args_get<M: MemorySize>(
         "args:\n{}",
         state
             .args
+            .lock()
+            .unwrap()
             .iter()
             .enumerate()
-            .map(|(i, v)| format!("{:>20}: {}", i, v))
+            .map(|(i, v)| format!("{i:>20}: {v}"))
             .collect::<Vec<String>>()
             .join("\n")
     );
diff --git a/lib/wasix/src/syscalls/wasi/args_sizes_get.rs b/lib/wasix/src/syscalls/wasi/args_sizes_get.rs
index 08ec71c167..28fef44a7a 100644
--- a/lib/wasix/src/syscalls/wasi/args_sizes_get.rs
+++ b/lib/wasix/src/syscalls/wasi/args_sizes_get.rs
@@ -8,7 +8,7 @@ use crate::syscalls::*;
 ///     The number of arguments.
 /// - `size_t *argv_buf_size`
 ///     The size of the argument string data.
-#[instrument(level = "debug", skip_all, ret)]
+#[instrument(level = "trace", skip_all, ret)]
 pub fn args_sizes_get<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     argc: WasmPtr<M::Offset, M>,
@@ -20,8 +20,14 @@ pub fn args_sizes_get<M: MemorySize>(
     let argc = argc.deref(&memory);
     let argv_buf_size = argv_buf_size.deref(&memory);
 
-    let argc_val: M::Offset = wasi_try!(state.args.len().try_into().map_err(|_| Errno::Overflow));
-    let argv_buf_size_val: usize = state.args.iter().map(|v| v.len() + 1).sum();
+    let argc_val: M::Offset = wasi_try!(state
+        .args
+        .lock()
+        .unwrap()
+        .len()
+        .try_into()
+        .map_err(|_| Errno::Overflow));
+    let argv_buf_size_val: usize = state.args.lock().unwrap().iter().map(|v| v.len() + 1).sum();
     let argv_buf_size_val: M::Offset =
         wasi_try!(argv_buf_size_val.try_into().map_err(|_| Errno::Overflow));
     wasi_try_mem!(argc.write(argc_val));
diff --git a/lib/wasix/src/syscalls/wasi/clock_time_get.rs b/lib/wasix/src/syscalls/wasi/clock_time_get.rs
index f1caab9635..434bd95f26 100644
--- a/lib/wasix/src/syscalls/wasi/clock_time_get.rs
+++ b/lib/wasix/src/syscalls/wasi/clock_time_get.rs
@@ -6,12 +6,16 @@ use crate::syscalls::*;
 
 /// ### `clock_time_get()`
 /// Get the time of the specified clock
+///
 /// Inputs:
+///
 /// - `Clockid clock_id`
 ///     The ID of the clock to query
 /// - `Timestamp precision`
 ///     The maximum amount of error the reading may have
+///
 /// Output:
+///
 /// - `Timestamp *time`
 ///     The value of the clock in nanoseconds
 #[cfg_attr(
@@ -24,6 +28,8 @@ pub fn clock_time_get<M: MemorySize>(
     precision: Timestamp,
     time: WasmPtr<Timestamp, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     ctx = wasi_try_ok!(maybe_backoff::<M>(ctx)?);
 
     let env = ctx.data();
diff --git a/lib/wasix/src/syscalls/wasi/clock_time_set.rs b/lib/wasix/src/syscalls/wasi/clock_time_set.rs
index 27a618aae5..2c1354ee6a 100644
--- a/lib/wasix/src/syscalls/wasi/clock_time_set.rs
+++ b/lib/wasix/src/syscalls/wasi/clock_time_set.rs
@@ -9,11 +9,13 @@ use crate::syscalls::*;
 /// - `Timestamp *time`
 ///     The value of the clock in nanoseconds
 #[instrument(level = "trace", skip_all, fields(?clock_id, %time), ret)]
-pub fn clock_time_set<M: MemorySize>(
+pub fn clock_time_set(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     clock_id: Snapshot0Clockid,
     time: Timestamp,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let ret = clock_time_set_internal(&mut ctx, clock_id, time);
     let env = ctx.data();
 
@@ -22,7 +24,7 @@ pub fn clock_time_set<M: MemorySize>(
         if env.enable_journal {
             JournalEffector::save_clock_time_set(&mut ctx, clock_id, time).map_err(|err| {
                 tracing::error!("failed to save clock time set event - {}", err);
-                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+                WasiError::Exit(ExitCode::from(Errno::Fault))
             })?;
         }
     }
diff --git a/lib/wasix/src/syscalls/wasi/environ_get.rs b/lib/wasix/src/syscalls/wasi/environ_get.rs
index 0c3b0c6073..042f0ffe53 100644
--- a/lib/wasix/src/syscalls/wasi/environ_get.rs
+++ b/lib/wasix/src/syscalls/wasi/environ_get.rs
@@ -9,7 +9,7 @@ use crate::{journal::SnapshotTrigger, syscalls::*};
 ///     A pointer to a buffer to write the environment variable pointers.
 /// - `char *environ_buf`
 ///     A pointer to a buffer to write the environment variable string data.
-#[instrument(level = "debug", skip_all, ret)]
+#[instrument(level = "trace", skip_all, ret)]
 pub fn environ_get<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     environ: WasmPtr<WasmPtr<u8, M>, M>,
diff --git a/lib/wasix/src/syscalls/wasi/fd_advise.rs b/lib/wasix/src/syscalls/wasi/fd_advise.rs
index bafb7841c4..288a84a845 100644
--- a/lib/wasix/src/syscalls/wasi/fd_advise.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_advise.rs
@@ -12,7 +12,7 @@ use crate::syscalls::*;
 ///     The length from the offset to which the advice applies
 /// - `__wasi_advice_t advice`
 ///     The advice to give
-#[instrument(level = "debug", skip_all, fields(%fd, %offset, %len, ?advice), ret)]
+#[instrument(level = "trace", skip_all, fields(%fd, %offset, %len, ?advice), ret)]
 pub fn fd_advise(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     fd: WasiFd,
@@ -20,6 +20,8 @@ pub fn fd_advise(
     len: Filesize,
     advice: Advice,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     wasi_try_ok!(fd_advise_internal(&mut ctx, fd, offset, len, advice));
     let env = ctx.data();
 
@@ -27,7 +29,7 @@ pub fn fd_advise(
     if env.enable_journal {
         JournalEffector::save_fd_advise(&mut ctx, fd, offset, len, advice).map_err(|err| {
             tracing::error!("failed to save file descriptor advise event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
@@ -49,7 +51,7 @@ pub(crate) fn fd_advise_internal(
     let fd_entry = state.fs.get_fd(fd)?;
     let inode = fd_entry.inode;
 
-    if !fd_entry.rights.contains(Rights::FD_ADVISE) {
+    if !fd_entry.inner.rights.contains(Rights::FD_ADVISE) {
         return Err(Errno::Access);
     }
 
diff --git a/lib/wasix/src/syscalls/wasi/fd_allocate.rs b/lib/wasix/src/syscalls/wasi/fd_allocate.rs
index 23462cbe48..5af1c98d21 100644
--- a/lib/wasix/src/syscalls/wasi/fd_allocate.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_allocate.rs
@@ -10,13 +10,15 @@ use crate::syscalls::*;
 ///     The offset from the start marking the beginning of the allocation
 /// - `Filesize len`
 ///     The length from the offset marking the end of the allocation
-#[instrument(level = "debug", skip_all, fields(%fd, %offset, %len), ret)]
+#[instrument(level = "trace", skip_all, fields(%fd, %offset, %len), ret)]
 pub fn fd_allocate(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     fd: WasiFd,
     offset: Filesize,
     len: Filesize,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     wasi_try_ok!(fd_allocate_internal(&mut ctx, fd, offset, len));
     let env = ctx.data();
 
@@ -24,7 +26,7 @@ pub fn fd_allocate(
     if env.enable_journal {
         JournalEffector::save_fd_allocate(&mut ctx, fd, offset, len).map_err(|err| {
             tracing::error!("failed to save file descriptor allocate event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
@@ -42,7 +44,7 @@ pub(crate) fn fd_allocate_internal(
     let fd_entry = state.fs.get_fd(fd)?;
     let inode = fd_entry.inode;
 
-    if !fd_entry.rights.contains(Rights::FD_ALLOCATE) {
+    if !fd_entry.inner.rights.contains(Rights::FD_ALLOCATE) {
         return Err(Errno::Access);
     }
     let new_size = offset.checked_add(len).ok_or(Errno::Inval)?;
@@ -57,13 +59,16 @@ pub(crate) fn fd_allocate_internal(
                     return Err(Errno::Badf);
                 }
             }
-            Kind::Socket { .. } => return Err(Errno::Badf),
-            Kind::Pipe { .. } => return Err(Errno::Badf),
             Kind::Buffer { buffer } => {
                 buffer.resize(new_size as usize, 0);
             }
-            Kind::Symlink { .. } => return Err(Errno::Badf),
-            Kind::EventNotifications { .. } | Kind::Epoll { .. } => return Err(Errno::Badf),
+            Kind::Socket { .. }
+            | Kind::PipeRx { .. }
+            | Kind::PipeTx { .. }
+            | Kind::DuplexPipe { .. }
+            | Kind::Symlink { .. }
+            | Kind::EventNotifications { .. }
+            | Kind::Epoll { .. } => return Err(Errno::Badf),
             Kind::Dir { .. } | Kind::Root { .. } => return Err(Errno::Isdir),
         }
     }
diff --git a/lib/wasix/src/syscalls/wasi/fd_close.rs b/lib/wasix/src/syscalls/wasi/fd_close.rs
index 9196d2ade3..41d2711939 100644
--- a/lib/wasix/src/syscalls/wasi/fd_close.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_close.rs
@@ -12,31 +12,38 @@ use crate::syscalls::*;
 ///     If `fd` is a directory
 /// - `Errno::Badf`
 ///     If `fd` is invalid or not open
-#[instrument(level = "debug", skip_all, fields(pid = ctx.data().process.pid().raw(), %fd), ret)]
+#[instrument(level = "trace", skip_all, fields(pid = ctx.data().process.pid().raw(), %fd), ret)]
 pub fn fd_close(mut ctx: FunctionEnvMut<'_, WasiEnv>, fd: WasiFd) -> Result<Errno, WasiError> {
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
-
-    // HACK: As a special case, we don't want to close fd 3 because it can break
-    // some programs...
-    // - On Wasix, we have some default fd, 0:stdin, 1:stdout, 2:stderr, 3:root
-    // - On Posix, we have some default fd: 0:stdin, 1:stdout, 2:stderr
-    // - A POSIX program might want to closed all open fd (e.g. when Python
-    //   spawns subprocesses), so it blindly does fd_close() for fd=3..255
-    // - Wasix doesn't work well when 3:root is closed, because it's the root
-    if fd == 3 {
-        tracing::debug!("Skipping fd_close(3)");
-        return Ok(Errno::Success);
-    }
+    WasiEnv::do_pending_operations(&mut ctx)?;
 
     let env = ctx.data();
     let (_, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+
+    // We don't want to allow programs that blindly close all FDs in a loop
+    // to be able to close pre-opens, as that breaks wasix-libc in rather
+    // spectacular fashion.
+    if let Ok(pfd) = state.fs.get_fd(fd) {
+        if !pfd.is_stdio && pfd.inode.is_preopened {
+            trace!("Skipping fd_close for pre-opened FD ({})", fd);
+            return Ok(Errno::Success);
+        }
+    }
+    // HACK: we use tokio files to back WASI file handles. Since tokio
+    // does writes in the background, it may miss writes if the file is
+    // closed without flushing first. Hence, we flush once here.
+    match __asyncify_light(env, None, state.fs.flush(fd))? {
+        Ok(_) | Err(Errno::Isdir) | Err(Errno::Io) | Err(Errno::Access) => {}
+        Err(e) => {
+            return Ok(e);
+        }
+    }
     wasi_try_ok!(state.fs.close_fd(fd));
 
     #[cfg(feature = "journal")]
     if env.enable_journal {
         JournalEffector::save_fd_close(&mut ctx, fd).map_err(|err| {
             tracing::error!("failed to save close descriptor event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
diff --git a/lib/wasix/src/syscalls/wasi/fd_datasync.rs b/lib/wasix/src/syscalls/wasi/fd_datasync.rs
index 75523059cd..f799d90eda 100644
--- a/lib/wasix/src/syscalls/wasi/fd_datasync.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_datasync.rs
@@ -6,14 +6,14 @@ use crate::syscalls::*;
 /// Inputs:
 /// - `Fd fd`
 ///     The file descriptor to sync
-#[instrument(level = "debug", skip_all, fields(%fd), ret)]
+#[instrument(level = "trace", skip_all, fields(%fd), ret)]
 pub fn fd_datasync(mut ctx: FunctionEnvMut<'_, WasiEnv>, fd: WasiFd) -> Result<Errno, WasiError> {
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+    WasiEnv::do_pending_operations(&mut ctx)?;
 
     let env = ctx.data();
     let state = env.state.clone();
     let fd_entry = wasi_try_ok!(state.fs.get_fd(fd));
-    if !fd_entry.rights.contains(Rights::FD_DATASYNC) {
+    if !fd_entry.inner.rights.contains(Rights::FD_DATASYNC) {
         return Ok(Errno::Access);
     }
 
diff --git a/lib/wasix/src/syscalls/wasi/fd_dup.rs b/lib/wasix/src/syscalls/wasi/fd_dup.rs
index 3dfe826b89..87a7fc3ab5 100644
--- a/lib/wasix/src/syscalls/wasi/fd_dup.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_dup.rs
@@ -9,20 +9,22 @@ use crate::syscalls::*;
 /// Outputs:
 /// - `Fd fd`
 ///   The new file handle that is a duplicate of the original
-#[instrument(level = "debug", skip_all, fields(%fd, ret_fd = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(%fd, ret_fd = field::Empty), ret)]
 pub fn fd_dup<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     fd: WasiFd,
     ret_fd: WasmPtr<WasiFd, M>,
 ) -> Result<Errno, WasiError> {
-    let copied_fd = wasi_try_ok!(fd_dup_internal(&mut ctx, fd));
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    let copied_fd = wasi_try_ok!(fd_dup_internal(&mut ctx, fd, 0, false));
     let env = ctx.data();
 
     #[cfg(feature = "journal")]
     if env.enable_journal {
-        JournalEffector::save_fd_duplicate(&mut ctx, fd, copied_fd).map_err(|err| {
+        JournalEffector::save_fd_duplicate(&mut ctx, fd, copied_fd, false).map_err(|err| {
             tracing::error!("failed to save file descriptor duplicate event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
@@ -33,13 +35,3 @@ pub fn fd_dup<M: MemorySize>(
 
     Ok(Errno::Success)
 }
-
-pub(crate) fn fd_dup_internal(
-    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
-    fd: WasiFd,
-) -> Result<WasiFd, Errno> {
-    let env = ctx.data();
-    let (memory, state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
-    let fd = state.fs.clone_fd(fd)?;
-    Ok(fd)
-}
diff --git a/lib/wasix/src/syscalls/wasi/fd_event.rs b/lib/wasix/src/syscalls/wasi/fd_event.rs
index 4c67857f5f..a9eca4ba8d 100644
--- a/lib/wasix/src/syscalls/wasi/fd_event.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_event.rs
@@ -3,13 +3,15 @@ use crate::{fs::NotificationInner, syscalls::*};
 
 /// ### `fd_event()`
 /// Creates a file handle for event notifications
-#[instrument(level = "debug", skip_all, fields(%initial_val, ret_fd = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(%initial_val, ret_fd = field::Empty), ret)]
 pub fn fd_event<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     initial_val: u64,
     flags: EventFdFlags,
     ret_fd: WasmPtr<WasiFd, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let fd = wasi_try_ok!(fd_event_internal(&mut ctx, initial_val, flags, None)?);
 
     let env = ctx.data();
@@ -21,7 +23,7 @@ pub fn fd_event<M: MemorySize>(
     if env.enable_journal {
         JournalEffector::save_fd_event(&mut ctx, initial_val, flags, fd).map_err(|err| {
             tracing::error!("failed to save fd_event event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
@@ -53,12 +55,25 @@ pub fn fd_event_internal(
     let fd = wasi_try_ok_ok!(if let Some(fd) = with_fd {
         state
             .fs
-            .with_fd(rights, rights, Fdflags::empty(), 0, inode, fd)
+            .with_fd(
+                rights,
+                rights,
+                Fdflags::empty(),
+                Fdflagsext::empty(),
+                0,
+                inode,
+                fd,
+            )
             .map(|_| fd)
     } else {
-        state
-            .fs
-            .create_fd(rights, rights, Fdflags::empty(), 0, inode)
+        state.fs.create_fd(
+            rights,
+            rights,
+            Fdflags::empty(),
+            Fdflagsext::empty(),
+            0,
+            inode,
+        )
     });
 
     Ok(Ok(fd))
diff --git a/lib/wasix/src/syscalls/wasi/fd_fdstat_get.rs b/lib/wasix/src/syscalls/wasi/fd_fdstat_get.rs
index 4f0ced4a3b..d58599d1c5 100644
--- a/lib/wasix/src/syscalls/wasi/fd_fdstat_get.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_fdstat_get.rs
@@ -11,17 +11,19 @@ use crate::syscalls::*;
 ///     The location where the metadata will be written
 #[instrument(level = "trace", skip_all, fields(%fd), ret)]
 pub fn fd_fdstat_get<M: MemorySize>(
-    ctx: FunctionEnvMut<'_, WasiEnv>,
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
     fd: WasiFd,
     buf_ptr: WasmPtr<Fdstat, M>,
-) -> Errno {
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
-    let stat = wasi_try!(state.fs.fdstat(fd));
+    let stat = wasi_try_ok!(state.fs.fdstat(fd));
 
     let buf = buf_ptr.deref(&memory);
 
-    wasi_try_mem!(buf.write(stat));
+    wasi_try_mem_ok!(buf.write(stat));
 
-    Errno::Success
+    Ok(Errno::Success)
 }
diff --git a/lib/wasix/src/syscalls/wasi/fd_fdstat_set_flags.rs b/lib/wasix/src/syscalls/wasi/fd_fdstat_set_flags.rs
index cedd78fecc..d1e38f2a2c 100644
--- a/lib/wasix/src/syscalls/wasi/fd_fdstat_set_flags.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_fdstat_set_flags.rs
@@ -8,12 +8,14 @@ use crate::syscalls::*;
 ///     The file descriptor to apply the new flags to
 /// - `Fdflags flags`
 ///     The flags to apply to `fd`
-#[instrument(level = "debug", skip_all, fields(%fd), ret)]
+#[instrument(level = "trace", skip_all, fields(%fd), ret)]
 pub fn fd_fdstat_set_flags(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     fd: WasiFd,
     flags: Fdflags,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let ret = fd_fdstat_set_flags_internal(&mut ctx, fd, flags)?;
     let env = ctx.data();
 
@@ -22,7 +24,7 @@ pub fn fd_fdstat_set_flags(
         if env.enable_journal {
             JournalEffector::save_fd_set_flags(&mut ctx, fd, flags).map_err(|err| {
                 tracing::error!("failed to save file set flags event - {}", err);
-                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+                WasiError::Exit(ExitCode::from(Errno::Fault))
             })?;
         }
     }
@@ -38,11 +40,10 @@ pub(crate) fn fd_fdstat_set_flags_internal(
     {
         let env = ctx.data();
         let (_, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
-        let mut fd_map = state.fs.fd_map.write().unwrap();
-        let fd_entry = wasi_try_ok!(fd_map.get_mut(&fd).ok_or(Errno::Badf));
-        let inode = fd_entry.inode.clone();
+        let fd_map = state.fs.fd_map.read().unwrap();
+        let fd_entry = wasi_try_ok!(fd_map.get(fd).ok_or(Errno::Badf));
 
-        if !fd_entry.rights.contains(Rights::FD_FDSTAT_SET_FLAGS) {
+        if !fd_entry.inner.rights.contains(Rights::FD_FDSTAT_SET_FLAGS) {
             return Ok(Errno::Access);
         }
     }
@@ -50,7 +51,7 @@ pub(crate) fn fd_fdstat_set_flags_internal(
     let env = ctx.data();
     let (_, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
     let mut fd_map = state.fs.fd_map.write().unwrap();
-    let fd_entry = wasi_try_ok!(fd_map.get_mut(&fd).ok_or(Errno::Badf));
+    let mut fd_entry = wasi_try_ok!(fd_map.get_mut(fd).ok_or(Errno::Badf));
     fd_entry.flags = flags;
     Ok(Errno::Success)
 }
diff --git a/lib/wasix/src/syscalls/wasi/fd_fdstat_set_rights.rs b/lib/wasix/src/syscalls/wasi/fd_fdstat_set_rights.rs
index ce9aa91d2d..060cd55ff2 100644
--- a/lib/wasix/src/syscalls/wasi/fd_fdstat_set_rights.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_fdstat_set_rights.rs
@@ -10,13 +10,15 @@ use crate::syscalls::*;
 ///     The rights to apply to `fd`
 /// - `Rights fs_rights_inheriting`
 ///     The inheriting rights to apply to `fd`
-#[instrument(level = "debug", skip_all, fields(%fd), ret)]
+#[instrument(level = "trace", skip_all, fields(%fd), ret)]
 pub fn fd_fdstat_set_rights(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     fd: WasiFd,
     fs_rights_base: Rights,
     fs_rights_inheriting: Rights,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     wasi_try_ok!(fd_fdstat_set_rights_internal(
         &mut ctx,
         fd,
@@ -30,7 +32,7 @@ pub fn fd_fdstat_set_rights(
         JournalEffector::save_fd_set_rights(&mut ctx, fd, fs_rights_base, fs_rights_inheriting)
             .map_err(|err| {
                 tracing::error!("failed to save file set rights event - {}", err);
-                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+                WasiError::Exit(ExitCode::from(Errno::Fault))
             })?;
     }
 
@@ -46,7 +48,7 @@ pub(crate) fn fd_fdstat_set_rights_internal(
     let env = ctx.data();
     let (_, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
     let mut fd_map = state.fs.fd_map.write().unwrap();
-    let fd_entry = fd_map.get_mut(&fd).ok_or(Errno::Badf)?;
+    let mut fd_entry = unsafe { fd_map.get_mut(fd) }.ok_or(Errno::Badf)?;
 
     // ensure new rights are a subset of current rights
     if fd_entry.rights | fs_rights_base != fd_entry.rights
diff --git a/lib/wasix/src/syscalls/wasi/fd_filestat_get.rs b/lib/wasix/src/syscalls/wasi/fd_filestat_get.rs
index e893a35185..328c29fb45 100644
--- a/lib/wasix/src/syscalls/wasi/fd_filestat_get.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_filestat_get.rs
@@ -4,33 +4,43 @@ use crate::types::wasi::Snapshot0Filestat;
 
 /// ### `fd_filestat_get()`
 /// Get the metadata of an open file
+///
 /// Input:
 /// - `Fd fd`
 ///     The open file descriptor whose metadata will be read
+///
 /// Output:
 /// - `Filestat *buf`
 ///     Where the metadata from `fd` will be written
-#[instrument(level = "debug", skip_all, fields(%fd), ret)]
+#[instrument(level = "trace", skip_all, fields(%fd, size = field::Empty, mtime = field::Empty), ret)]
 pub fn fd_filestat_get<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     fd: WasiFd,
     buf: WasmPtr<Filestat, M>,
-) -> Errno {
-    let stat = wasi_try!(fd_filestat_get_internal(&mut ctx, fd));
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    let stat = wasi_try_ok!(fd_filestat_get_internal(&mut ctx, fd));
+
+    // These two values have proved to be helpful in multiple investigations
+    Span::current().record("size", stat.st_size);
+    Span::current().record("mtime", stat.st_mtim);
 
     let env = ctx.data();
     let (memory, _) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
     let buf = buf.deref(&memory);
-    wasi_try_mem!(buf.write(stat));
+    wasi_try_mem_ok!(buf.write(stat));
 
-    Errno::Success
+    Ok(Errno::Success)
 }
 
 /// ### `fd_filestat_get()`
 /// Get the metadata of an open file
+///
 /// Input:
 /// - `__wasi_fd_t fd`
 ///     The open file descriptor whose metadata will be read
+///
 /// Output:
 /// - `__wasi_filestat_t *buf`
 ///     Where the metadata from `fd` will be written
@@ -41,7 +51,7 @@ pub(crate) fn fd_filestat_get_internal(
     let env = ctx.data();
     let (_, state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
     let fd_entry = state.fs.get_fd(fd)?;
-    if !fd_entry.rights.contains(Rights::FD_FILESTAT_GET) {
+    if !fd_entry.inner.rights.contains(Rights::FD_FILESTAT_GET) {
         return Err(Errno::Access);
     }
 
@@ -50,13 +60,15 @@ pub(crate) fn fd_filestat_get_internal(
 
 /// ### `fd_filestat_get_old()`
 /// Get the metadata of an open file
+///
 /// Input:
 /// - `Fd fd`
 ///     The open file descriptor whose metadata will be read
+///
 /// Output:
 /// - `Snapshot0Filestat *buf`
 ///     Where the metadata from `fd` will be written
-#[instrument(level = "debug", skip_all, fields(%fd), ret)]
+#[instrument(level = "trace", skip_all, fields(%fd), ret)]
 pub fn fd_filestat_get_old<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     fd: WasiFd,
diff --git a/lib/wasix/src/syscalls/wasi/fd_filestat_set_size.rs b/lib/wasix/src/syscalls/wasi/fd_filestat_set_size.rs
index ddb361744b..e2728e28bc 100644
--- a/lib/wasix/src/syscalls/wasi/fd_filestat_set_size.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_filestat_set_size.rs
@@ -8,12 +8,14 @@ use crate::syscalls::*;
 ///     File descriptor to adjust
 /// - `Filesize st_size`
 ///     New size that `fd` will be set to
-#[instrument(level = "debug", skip_all, fields(%fd, %st_size), ret)]
+#[instrument(level = "trace", skip_all, fields(%fd, %st_size), ret)]
 pub fn fd_filestat_set_size(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     fd: WasiFd,
     st_size: Filesize,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     wasi_try_ok!(fd_filestat_set_size_internal(&mut ctx, fd, st_size));
     let env = ctx.data();
 
@@ -21,7 +23,7 @@ pub fn fd_filestat_set_size(
     if env.enable_journal {
         JournalEffector::save_fd_set_size(&mut ctx, fd, st_size).map_err(|err| {
             tracing::error!("failed to save file set size event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
@@ -38,7 +40,7 @@ pub(crate) fn fd_filestat_set_size_internal(
     let fd_entry = state.fs.get_fd(fd)?;
     let inode = fd_entry.inode;
 
-    if !fd_entry.rights.contains(Rights::FD_FILESTAT_SET_SIZE) {
+    if !fd_entry.inner.rights.contains(Rights::FD_FILESTAT_SET_SIZE) {
         return Err(Errno::Access);
     }
 
@@ -56,10 +58,13 @@ pub(crate) fn fd_filestat_set_size_internal(
             Kind::Buffer { buffer } => {
                 buffer.resize(st_size as usize, 0);
             }
-            Kind::Socket { .. } => return Err(Errno::Badf),
-            Kind::Pipe { .. } => return Err(Errno::Badf),
-            Kind::Symlink { .. } => return Err(Errno::Badf),
-            Kind::EventNotifications { .. } | Kind::Epoll { .. } => return Err(Errno::Badf),
+            Kind::Socket { .. }
+            | Kind::PipeRx { .. }
+            | Kind::PipeTx { .. }
+            | Kind::DuplexPipe { .. }
+            | Kind::Symlink { .. }
+            | Kind::EventNotifications { .. }
+            | Kind::Epoll { .. } => return Err(Errno::Badf),
             Kind::Dir { .. } | Kind::Root { .. } => return Err(Errno::Isdir),
         }
     }
diff --git a/lib/wasix/src/syscalls/wasi/fd_filestat_set_times.rs b/lib/wasix/src/syscalls/wasi/fd_filestat_set_times.rs
index 9add80b56d..9810eb43c3 100644
--- a/lib/wasix/src/syscalls/wasi/fd_filestat_set_times.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_filestat_set_times.rs
@@ -12,7 +12,7 @@ use crate::syscalls::*;
 ///     Last modified time
 /// - `Fstflags fst_flags`
 ///     Bit-vector for controlling which times get set
-#[instrument(level = "debug", skip_all, fields(%fd, %st_atim, %st_mtim), ret)]
+#[instrument(level = "trace", skip_all, fields(%fd, %st_atim, %st_mtim), ret)]
 pub fn fd_filestat_set_times(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     fd: WasiFd,
@@ -20,6 +20,8 @@ pub fn fd_filestat_set_times(
     st_mtim: Timestamp,
     fst_flags: Fstflags,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     wasi_try_ok!(fd_filestat_set_times_internal(
         &mut ctx, fd, st_atim, st_mtim, fst_flags
     ));
@@ -30,7 +32,7 @@ pub fn fd_filestat_set_times(
         JournalEffector::save_fd_set_times(&mut ctx, fd, st_atim, st_mtim, fst_flags).map_err(
             |err| {
                 tracing::error!("failed to save file set times event - {}", err);
-                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+                WasiError::Exit(ExitCode::from(Errno::Fault))
             },
         )?;
     }
@@ -49,7 +51,11 @@ pub(crate) fn fd_filestat_set_times_internal(
     let (_, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
     let fd_entry = state.fs.get_fd(fd)?;
 
-    if !fd_entry.rights.contains(Rights::FD_FILESTAT_SET_TIMES) {
+    if !fd_entry
+        .inner
+        .rights
+        .contains(Rights::FD_FILESTAT_SET_TIMES)
+    {
         return Err(Errno::Access);
     }
 
diff --git a/lib/wasix/src/syscalls/wasi/fd_prestat_dir_name.rs b/lib/wasix/src/syscalls/wasi/fd_prestat_dir_name.rs
index 9cdf72532e..98b21872b6 100644
--- a/lib/wasix/src/syscalls/wasi/fd_prestat_dir_name.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_prestat_dir_name.rs
@@ -13,7 +13,8 @@ pub fn fd_prestat_dir_name<M: MemorySize>(
     let path_chars = wasi_try_mem!(path.slice(&memory, path_len));
 
     let inode = wasi_try!(state.fs.get_fd_inode(fd));
-    Span::current().record("path", inode.name.as_ref());
+    let name = inode.name.read().unwrap();
+    Span::current().record("path", name.as_ref());
 
     // check inode-val.is_preopened?
 
@@ -22,11 +23,11 @@ pub fn fd_prestat_dir_name<M: MemorySize>(
         Kind::Dir { .. } | Kind::Root { .. } => {
             // TODO: verify this: null termination, etc
             let path_len: u64 = path_len.into();
-            if (inode.name.len() as u64) < path_len {
+            if (name.len() as u64) < path_len {
                 wasi_try_mem!(path_chars
-                    .subslice(0..inode.name.len() as u64)
-                    .write_slice(inode.name.as_bytes()));
-                wasi_try_mem!(path_chars.index(inode.name.len() as u64).write(0));
+                    .subslice(0..name.len() as u64)
+                    .write_slice(name.as_bytes()));
+                wasi_try_mem!(path_chars.index(name.len() as u64).write(0));
 
                 //trace!("=> result: \"{}\"", inode_val.name);
 
@@ -39,7 +40,9 @@ pub fn fd_prestat_dir_name<M: MemorySize>(
         | Kind::Buffer { .. }
         | Kind::File { .. }
         | Kind::Socket { .. }
-        | Kind::Pipe { .. }
+        | Kind::PipeRx { .. }
+        | Kind::PipeTx { .. }
+        | Kind::DuplexPipe { .. }
         | Kind::EventNotifications { .. }
         | Kind::Epoll { .. } => Errno::Notdir,
     }
diff --git a/lib/wasix/src/syscalls/wasi/fd_read.rs b/lib/wasix/src/syscalls/wasi/fd_read.rs
index 5558a29e52..1aabf5e9bc 100644
--- a/lib/wasix/src/syscalls/wasi/fd_read.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_read.rs
@@ -32,6 +32,8 @@ pub fn fd_read<M: MemorySize>(
     iovs_len: M::Offset,
     nread: WasmPtr<M::Offset, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let pid = ctx.data().pid();
     let tid = ctx.data().tid();
 
@@ -41,7 +43,7 @@ pub fn fd_read<M: MemorySize>(
         let inodes = state.inodes.clone();
 
         let fd_entry = wasi_try_ok!(state.fs.get_fd(fd));
-        fd_entry.offset.load(Ordering::Acquire) as usize
+        fd_entry.inner.offset.load(Ordering::Acquire) as usize
     };
 
     ctx = wasi_try_ok!(maybe_backoff::<M>(ctx)?);
@@ -127,8 +129,6 @@ pub(crate) fn fd_read_internal<M: MemorySize>(
     nread: WasmPtr<M::Offset, M>,
     should_update_cursor: bool,
 ) -> WasiResult<usize> {
-    wasi_try_ok_ok!(WasiEnv::process_signals_and_exit(ctx)?);
-
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
     let state = env.state();
@@ -137,13 +137,13 @@ pub(crate) fn fd_read_internal<M: MemorySize>(
     let is_stdio = fd_entry.is_stdio;
 
     let bytes_read = {
-        if !is_stdio && !fd_entry.rights.contains(Rights::FD_READ) {
+        if !is_stdio && !fd_entry.inner.rights.contains(Rights::FD_READ) {
             // TODO: figure out the error to return when lacking rights
             return Ok(Err(Errno::Access));
         }
 
         let inode = fd_entry.inode;
-        let fd_flags = fd_entry.flags;
+        let fd_flags = fd_entry.inner.flags;
 
         let (bytes_read, can_update_cursor) = {
             let mut guard = inode.write();
@@ -184,24 +184,24 @@ pub(crate) fn fd_read_internal<M: MemorySize>(
                                         .map_err(mem_error_to_wasi)?
                                         .access()
                                         .map_err(mem_error_to_wasi)?;
-                                    let local_read =
-                                        match handle.read(buf.as_mut()).await.map_err(|err| {
-                                            let err = From::<std::io::Error>::from(err);
-                                            match err {
-                                                Errno::Again => {
-                                                    if is_stdio {
-                                                        Errno::Badf
-                                                    } else {
-                                                        Errno::Again
-                                                    }
+                                    let r = handle.read(buf.as_mut()).await.map_err(|err| {
+                                        let err = From::<std::io::Error>::from(err);
+                                        match err {
+                                            Errno::Again => {
+                                                if is_stdio {
+                                                    Errno::Badf
+                                                } else {
+                                                    Errno::Again
                                                 }
-                                                a => a,
                                             }
-                                        }) {
-                                            Ok(s) => s,
-                                            Err(_) if total_read > 0 => break,
-                                            Err(err) => return Err(err),
-                                        };
+                                            a => a,
+                                        }
+                                    });
+                                    let local_read = match r {
+                                        Ok(s) => s,
+                                        Err(_) if total_read > 0 => break,
+                                        Err(err) => return Err(err),
+                                    };
                                     total_read += local_read;
                                     if local_read != buf.len() {
                                         break;
@@ -258,6 +258,7 @@ pub(crate) fn fd_read_internal<M: MemorySize>(
                                         buf.as_mut_uninit(),
                                         Some(timeout),
                                         nonblocking,
+                                        false,
                                     )
                                     .await?;
                                 total_read += local_read;
@@ -280,9 +281,63 @@ pub(crate) fn fd_read_internal<M: MemorySize>(
                         }
                     }
                 }
-                Kind::Pipe { pipe } => {
-                    let mut pipe = pipe.clone();
+                Kind::PipeTx { .. } => return Ok(Err(Errno::Badf)),
+                Kind::PipeRx { rx } => {
+                    let mut rx = rx.clone();
+                    drop(guard);
+
+                    let nonblocking = fd_flags.contains(Fdflags::NONBLOCK);
+
+                    let res = __asyncify_light(
+                        env,
+                        if fd_flags.contains(Fdflags::NONBLOCK) {
+                            Some(Duration::ZERO)
+                        } else {
+                            None
+                        },
+                        async move {
+                            let mut total_read = 0usize;
+
+                            let iovs_arr =
+                                iovs.slice(&memory, iovs_len).map_err(mem_error_to_wasi)?;
+                            let iovs_arr = iovs_arr.access().map_err(mem_error_to_wasi)?;
+                            for iovs in iovs_arr.iter() {
+                                let mut buf = WasmPtr::<u8, M>::new(iovs.buf)
+                                    .slice(&memory, iovs.buf_len)
+                                    .map_err(mem_error_to_wasi)?
+                                    .access()
+                                    .map_err(mem_error_to_wasi)?;
 
+                                let local_read = match nonblocking {
+                                    true => match rx.try_read(buf.as_mut()) {
+                                        Some(amt) => amt,
+                                        None => {
+                                            return Err(Errno::Again);
+                                        }
+                                    },
+                                    false => {
+                                        virtual_fs::AsyncReadExt::read(&mut rx, buf.as_mut())
+                                            .await?
+                                    }
+                                };
+                                total_read += local_read;
+                                if local_read != buf.len() {
+                                    break;
+                                }
+                            }
+                            Ok(total_read)
+                        },
+                    );
+
+                    let bytes_read = wasi_try_ok_ok!(res?.map_err(|err| match err {
+                        Errno::Timedout => Errno::Again,
+                        a => a,
+                    }));
+
+                    (bytes_read, false)
+                }
+                Kind::DuplexPipe { pipe } => {
+                    let mut pipe = pipe.clone();
                     drop(guard);
 
                     let nonblocking = fd_flags.contains(Fdflags::NONBLOCK);
@@ -395,7 +450,7 @@ pub(crate) fn fd_read_internal<M: MemorySize>(
         if !is_stdio && should_update_cursor && can_update_cursor {
             // reborrow
             let mut fd_map = state.fs.fd_map.write().unwrap();
-            let fd_entry = wasi_try_ok_ok!(fd_map.get_mut(&fd).ok_or(Errno::Badf));
+            let fd_entry = wasi_try_ok_ok!(fd_map.get_mut(fd).ok_or(Errno::Badf));
             let old = fd_entry
                 .offset
                 .fetch_add(bytes_read as u64, Ordering::AcqRel);
diff --git a/lib/wasix/src/syscalls/wasi/fd_readdir.rs b/lib/wasix/src/syscalls/wasi/fd_readdir.rs
index 2595b1e689..6039c659d7 100644
--- a/lib/wasix/src/syscalls/wasi/fd_readdir.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_readdir.rs
@@ -18,21 +18,23 @@ use crate::syscalls::*;
 ///     directory has been read
 #[instrument(level = "trace", skip_all, fields(%fd), ret)]
 pub fn fd_readdir<M: MemorySize>(
-    ctx: FunctionEnvMut<'_, WasiEnv>,
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
     fd: WasiFd,
     buf: WasmPtr<u8, M>,
     buf_len: M::Offset,
     cookie: Dircookie,
     bufused: WasmPtr<M::Offset, M>,
-) -> Errno {
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let (memory, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
     // TODO: figure out how this is supposed to work;
     // is it supposed to pack the buffer full every time until it can't? or do one at a time?
 
-    let buf_arr = wasi_try_mem!(buf.slice(&memory, buf_len));
+    let buf_arr = wasi_try_mem_ok!(buf.slice(&memory, buf_len));
     let bufused_ref = bufused.deref(&memory);
-    let working_dir = wasi_try!(state.fs.get_fd(fd));
+    let working_dir = wasi_try_ok!(state.fs.get_fd(fd));
     let mut cur_cookie = cookie;
     let mut buf_idx = 0usize;
 
@@ -45,10 +47,10 @@ pub fn fd_readdir<M: MemorySize>(
                 // we need to support multiple calls,
                 // simple and obviously correct implementation for now:
                 // maintain consistent order via lexacographic sorting
-                let fs_info = wasi_try!(wasi_try!(state.fs_read_dir(path))
+                let fs_info = wasi_try_ok!(wasi_try_ok!(state.fs_read_dir(path))
                     .collect::<Result<Vec<_>, _>>()
                     .map_err(fs_error_into_wasi_err));
-                let mut entry_vec = wasi_try!(fs_info
+                let mut entry_vec = wasi_try_ok!(fs_info
                     .into_iter()
                     .map(|entry| {
                         let filename = entry.file_name().to_string_lossy().to_string();
@@ -64,7 +66,11 @@ pub fn fd_readdir<M: MemorySize>(
                 entry_vec.extend(entries.iter().filter(|(_, inode)| inode.is_preopened).map(
                     |(name, inode)| {
                         let stat = inode.stat.read().unwrap();
-                        (inode.name.to_string(), stat.st_filetype, stat.st_ino)
+                        (
+                            inode.name.read().unwrap().to_string(),
+                            stat.st_filetype,
+                            stat.st_ino,
+                        )
                     },
                 ));
                 // adding . and .. special folders
@@ -88,7 +94,11 @@ pub fn fd_readdir<M: MemorySize>(
                     .into_iter()
                     .map(|(name, inode)| {
                         let stat = inode.stat.read().unwrap();
-                        (format!("/{}", inode.name), stat.st_filetype, stat.st_ino)
+                        (
+                            format!("/{}", inode.name.read().unwrap().as_ref()),
+                            stat.st_filetype,
+                            stat.st_ino,
+                        )
                     })
                     .collect()
             }
@@ -96,9 +106,11 @@ pub fn fd_readdir<M: MemorySize>(
             | Kind::Symlink { .. }
             | Kind::Buffer { .. }
             | Kind::Socket { .. }
-            | Kind::Pipe { .. }
+            | Kind::PipeRx { .. }
+            | Kind::PipeTx { .. }
+            | Kind::DuplexPipe { .. }
             | Kind::EventNotifications { .. }
-            | Kind::Epoll { .. } => return Errno::Notdir,
+            | Kind::Epoll { .. } => return Ok(Errno::Notdir),
         }
     };
 
@@ -119,7 +131,7 @@ pub fn fd_readdir<M: MemorySize>(
             std::mem::size_of::<Dirent>(),
         );
         for (i, b) in dirent_bytes.iter().enumerate().take(upper_limit) {
-            wasi_try_mem!(buf_arr.index((i + buf_idx) as u64).write(*b));
+            wasi_try_mem_ok!(buf_arr.index((i + buf_idx) as u64).write(*b));
         }
         buf_idx += upper_limit;
         if upper_limit != std::mem::size_of::<Dirent>() {
@@ -127,7 +139,7 @@ pub fn fd_readdir<M: MemorySize>(
         }
         let upper_limit = std::cmp::min((buf_len - buf_idx as u64) as usize, namlen);
         for (i, b) in entry_path_str.bytes().take(upper_limit).enumerate() {
-            wasi_try_mem!(buf_arr.index((i + buf_idx) as u64).write(b));
+            wasi_try_mem_ok!(buf_arr.index((i + buf_idx) as u64).write(b));
         }
         buf_idx += upper_limit;
         if upper_limit != namlen {
@@ -135,7 +147,7 @@ pub fn fd_readdir<M: MemorySize>(
         }
     }
 
-    let buf_idx: M::Offset = wasi_try!(buf_idx.try_into().map_err(|_| Errno::Overflow));
-    wasi_try_mem!(bufused_ref.write(buf_idx));
-    Errno::Success
+    let buf_idx: M::Offset = wasi_try_ok!(buf_idx.try_into().map_err(|_| Errno::Overflow));
+    wasi_try_mem_ok!(bufused_ref.write(buf_idx));
+    Ok(Errno::Success)
 }
diff --git a/lib/wasix/src/syscalls/wasi/fd_renumber.rs b/lib/wasix/src/syscalls/wasi/fd_renumber.rs
index 55add2ebea..ffaffe9fa1 100644
--- a/lib/wasix/src/syscalls/wasi/fd_renumber.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_renumber.rs
@@ -8,13 +8,15 @@ use crate::syscalls::*;
 ///     File descriptor to copy
 /// - `Fd to`
 ///     Location to copy file descriptor to
-#[instrument(level = "debug", skip_all, fields(%from, %to), ret)]
+#[instrument(level = "trace", skip_all, fields(%from, %to), ret)]
 pub fn fd_renumber(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     from: WasiFd,
     to: WasiFd,
 ) -> Result<Errno, WasiError> {
-    let ret = fd_renumber_internal(&mut ctx, from, to);
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    let ret = fd_renumber_internal(&mut ctx, from, to)?;
     let env = ctx.data();
 
     if ret == Errno::Success {
@@ -22,10 +24,11 @@ pub fn fd_renumber(
         if env.enable_journal {
             JournalEffector::save_fd_renumber(&mut ctx, from, to).map_err(|err| {
                 tracing::error!("failed to save file descriptor renumber event - {}", err);
-                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+                WasiError::Exit(ExitCode::from(Errno::Fault))
             })?;
         }
     }
+
     Ok(ret)
 }
 
@@ -33,25 +36,57 @@ pub(crate) fn fd_renumber_internal(
     ctx: &mut FunctionEnvMut<'_, WasiEnv>,
     from: WasiFd,
     to: WasiFd,
-) -> Errno {
+) -> Result<Errno, WasiError> {
     if from == to {
-        return Errno::Success;
+        return Ok(Errno::Success);
     }
     let env = ctx.data();
     let (_, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
 
+    if let Ok(fd) = state.fs.get_fd(to) {
+        if !fd.is_stdio && fd.inode.is_preopened {
+            // There isn't a good hack we can do here; the code that made this call
+            // expects its new FD to be the number it asked for. This will, however,
+            // break wasix-libc when it attempts to use the FD to make any fs-related
+            // syscalls. The best we can do is warn people so they can change the code.
+            warn!(
+                "FD ({to}) is a pre-open and should not be closed, \
+                but will be closed in response to an fd_renumber operation. \
+                This will likely break stuff."
+            );
+        }
+        match __asyncify_light(env, None, state.fs.flush(to))? {
+            Ok(_) | Err(Errno::Isdir) | Err(Errno::Io) | Err(Errno::Access) => {}
+            Err(e) => {
+                return Ok(e);
+            }
+        }
+        wasi_try_ok!(state.fs.close_fd(to));
+    }
+
     let mut fd_map = state.fs.fd_map.write().unwrap();
-    let fd_entry = wasi_try!(fd_map.get_mut(&from).ok_or(Errno::Badf));
+    let fd_entry = wasi_try_ok!(fd_map.get(from).ok_or(Errno::Badf));
 
     let new_fd_entry = Fd {
         // TODO: verify this is correct
-        offset: fd_entry.offset.clone(),
-        rights: fd_entry.rights_inheriting,
+        inner: FdInner {
+            offset: fd_entry.inner.offset.clone(),
+            rights: fd_entry.inner.rights_inheriting,
+            fd_flags: {
+                let mut f = fd_entry.inner.fd_flags;
+                f.set(Fdflagsext::CLOEXEC, false);
+                f
+            },
+            ..fd_entry.inner
+        },
         inode: fd_entry.inode.clone(),
         ..*fd_entry
     };
-    fd_map.insert(to, new_fd_entry);
-    state.fs.make_max_fd(to + 1);
 
-    Errno::Success
+    // Exclusive insert because we expect `to` to be empty after closing it above
+    if !fd_map.insert(true, to, new_fd_entry) {
+        panic!("Internal error: expected FD {to} to be free after closing in fd_renumber");
+    }
+
+    Ok(Errno::Success)
 }
diff --git a/lib/wasix/src/syscalls/wasi/fd_seek.rs b/lib/wasix/src/syscalls/wasi/fd_seek.rs
index 527ed185dc..31cfe43eee 100644
--- a/lib/wasix/src/syscalls/wasi/fd_seek.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_seek.rs
@@ -21,7 +21,7 @@ pub fn fd_seek<M: MemorySize>(
     whence: Whence,
     newoffset: WasmPtr<Filesize, M>,
 ) -> Result<Errno, WasiError> {
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+    WasiEnv::do_pending_operations(&mut ctx)?;
 
     let new_offset = wasi_try_ok!(fd_seek_internal(&mut ctx, fd, offset, whence)?);
     let env = ctx.data();
@@ -30,7 +30,7 @@ pub fn fd_seek<M: MemorySize>(
     if env.enable_journal {
         JournalEffector::save_fd_seek(&mut ctx, fd, offset, whence).map_err(|err| {
             tracing::error!("failed to save file descriptor seek event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
@@ -59,18 +59,15 @@ pub(crate) fn fd_seek_internal(
     let (memory, _) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
     let fd_entry = wasi_try_ok_ok!(state.fs.get_fd(fd));
 
-    if !fd_entry.rights.contains(Rights::FD_SEEK) {
+    if !fd_entry.inner.rights.contains(Rights::FD_SEEK) {
         return Ok(Err(Errno::Access));
     }
-    if fd_entry.flags.contains(Fdflags::APPEND) {
-        return Ok(Ok(fd_entry.offset.load(Ordering::Acquire)));
-    }
 
     // TODO: handle case if fd is a dir?
     let new_offset = match whence {
         Whence::Cur => {
             let mut fd_map = state.fs.fd_map.write().unwrap();
-            let fd_entry = wasi_try_ok_ok!(fd_map.get_mut(&fd).ok_or(Errno::Badf));
+            let fd_entry = wasi_try_ok_ok!(fd_map.get_mut(fd).ok_or(Errno::Badf));
 
             #[allow(clippy::comparison_chain)]
             if offset > 0 {
@@ -110,7 +107,7 @@ pub(crate) fn fd_seek_internal(
                             // TODO: handle case if fd_entry.offset uses 64 bits of a u64
                             drop(handle);
                             let mut fd_map = state.fs.fd_map.write().unwrap();
-                            let fd_entry = fd_map.get_mut(&fd).ok_or(Errno::Badf)?;
+                            let fd_entry = fd_map.get_mut(fd).ok_or(Errno::Badf)?;
                             fd_entry.offset.store(end, Ordering::Release);
                             Ok(())
                         })?);
@@ -124,7 +121,9 @@ pub(crate) fn fd_seek_internal(
                 Kind::Dir { .. }
                 | Kind::Root { .. }
                 | Kind::Socket { .. }
-                | Kind::Pipe { .. }
+                | Kind::PipeRx { .. }
+                | Kind::PipeTx { .. }
+                | Kind::DuplexPipe { .. }
                 | Kind::EventNotifications { .. }
                 | Kind::Epoll { .. } => {
                     // TODO: check this
@@ -136,11 +135,11 @@ pub(crate) fn fd_seek_internal(
                     return Ok(Err(Errno::Inval));
                 }
             }
-            fd_entry.offset.load(Ordering::Acquire)
+            fd_entry.inner.offset.load(Ordering::Acquire)
         }
         Whence::Set => {
             let mut fd_map = state.fs.fd_map.write().unwrap();
-            let fd_entry = wasi_try_ok_ok!(fd_map.get_mut(&fd).ok_or(Errno::Badf));
+            let fd_entry = wasi_try_ok_ok!(fd_map.get_mut(fd).ok_or(Errno::Badf));
             let offset: u64 = wasi_try_ok_ok!(u64::try_from(offset).map_err(|_| Errno::Inval));
 
             fd_entry.offset.store(offset, Ordering::Release);
diff --git a/lib/wasix/src/syscalls/wasi/fd_sync.rs b/lib/wasix/src/syscalls/wasi/fd_sync.rs
index d0600bbdca..bf2df6c1f1 100644
--- a/lib/wasix/src/syscalls/wasi/fd_sync.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_sync.rs
@@ -10,14 +10,14 @@ use crate::syscalls::*;
 /// TODO: figure out which errors this should return
 /// - `Errno::Perm`
 /// - `Errno::Notcapable`
-#[instrument(level = "debug", skip_all, fields(%fd), ret)]
+#[instrument(level = "trace", skip_all, fields(%fd), ret)]
 pub fn fd_sync(mut ctx: FunctionEnvMut<'_, WasiEnv>, fd: WasiFd) -> Result<Errno, WasiError> {
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+    WasiEnv::do_pending_operations(&mut ctx)?;
 
     let env = ctx.data();
     let (_, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
     let fd_entry = wasi_try_ok!(state.fs.get_fd(fd));
-    if !fd_entry.rights.contains(Rights::FD_SYNC) {
+    if !fd_entry.inner.rights.contains(Rights::FD_SYNC) {
         return Ok(Errno::Access);
     }
     let inode = fd_entry.inode;
@@ -63,7 +63,9 @@ pub fn fd_sync(mut ctx: FunctionEnvMut<'_, WasiEnv>, fd: WasiFd) -> Result<Errno
             Kind::Buffer { .. }
             | Kind::Symlink { .. }
             | Kind::Socket { .. }
-            | Kind::Pipe { .. }
+            | Kind::PipeTx { .. }
+            | Kind::PipeRx { .. }
+            | Kind::DuplexPipe { .. }
             | Kind::EventNotifications { .. }
             | Kind::Epoll { .. } => return Ok(Errno::Inval),
         }
diff --git a/lib/wasix/src/syscalls/wasi/fd_tell.rs b/lib/wasix/src/syscalls/wasi/fd_tell.rs
index 7f01c7bd6b..ce6f3e3ba8 100644
--- a/lib/wasix/src/syscalls/wasi/fd_tell.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_tell.rs
@@ -9,25 +9,27 @@ use crate::syscalls::*;
 /// Output:
 /// - `Filesize *offset`
 ///     The offset of `fd` relative to the start of the file
-#[instrument(level = "debug", skip_all, fields(%fd, offset = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(%fd, offset = field::Empty), ret)]
 pub fn fd_tell<M: MemorySize>(
-    ctx: FunctionEnvMut<'_, WasiEnv>,
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
     fd: WasiFd,
     offset: WasmPtr<Filesize, M>,
-) -> Errno {
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let (memory, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
     let offset_ref = offset.deref(&memory);
 
-    let fd_entry = wasi_try!(state.fs.get_fd(fd));
+    let fd_entry = wasi_try_ok!(state.fs.get_fd(fd));
 
-    if !fd_entry.rights.contains(Rights::FD_TELL) {
-        return Errno::Access;
+    if !fd_entry.inner.rights.contains(Rights::FD_TELL) {
+        return Ok(Errno::Access);
     }
 
-    let offset = fd_entry.offset.load(Ordering::Acquire);
+    let offset = fd_entry.inner.offset.load(Ordering::Acquire);
     Span::current().record("offset", offset);
-    wasi_try_mem!(offset_ref.write(offset));
+    wasi_try_mem_ok!(offset_ref.write(offset));
 
-    Errno::Success
+    Ok(Errno::Success)
 }
diff --git a/lib/wasix/src/syscalls/wasi/fd_write.rs b/lib/wasix/src/syscalls/wasi/fd_write.rs
index b5f0d648a8..b5bb1f3f47 100644
--- a/lib/wasix/src/syscalls/wasi/fd_write.rs
+++ b/lib/wasix/src/syscalls/wasi/fd_write.rs
@@ -30,24 +30,25 @@ pub fn fd_write<M: MemorySize>(
     iovs_len: M::Offset,
     nwritten: WasmPtr<M::Offset, M>,
 ) -> Result<Errno, WasiError> {
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+    WasiEnv::do_pending_operations(&mut ctx)?;
 
     let env = ctx.data();
+    let enable_journal = env.enable_journal;
     let offset = {
         let state = env.state.clone();
         let inodes = state.inodes.clone();
 
         let fd_entry = wasi_try_ok!(state.fs.get_fd(fd));
-        fd_entry.offset.load(Ordering::Acquire) as usize
+        fd_entry.inner.offset.load(Ordering::Acquire) as usize
     };
 
     let bytes_written = wasi_try_ok!(fd_write_internal::<M>(
-        &ctx,
+        &mut ctx,
         fd,
         FdWriteSource::Iovs { iovs, iovs_len },
         offset as u64,
         true,
-        env.enable_journal,
+        enable_journal,
     )?);
 
     Span::current().record("nwritten", bytes_written);
@@ -85,12 +86,12 @@ pub fn fd_pwrite<M: MemorySize>(
     offset: Filesize,
     nwritten: WasmPtr<M::Offset, M>,
 ) -> Result<Errno, WasiError> {
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+    WasiEnv::do_pending_operations(&mut ctx)?;
 
     let enable_snapshot_capture = ctx.data().enable_journal;
 
     let bytes_written = wasi_try_ok!(fd_write_internal::<M>(
-        &ctx,
+        &mut ctx,
         fd,
         FdWriteSource::Iovs { iovs, iovs_len },
         offset,
@@ -120,13 +121,14 @@ pub(crate) enum FdWriteSource<'a, M: MemorySize> {
 
 #[allow(clippy::await_holding_lock)]
 pub(crate) fn fd_write_internal<M: MemorySize>(
-    ctx: &FunctionEnvMut<'_, WasiEnv>,
+    mut ctx: &mut FunctionEnvMut<'_, WasiEnv>,
     fd: WasiFd,
     data: FdWriteSource<'_, M>,
     offset: u64,
     should_update_cursor: bool,
     should_snapshot: bool,
 ) -> Result<Result<usize, Errno>, WasiError> {
+    let mut offset = offset;
     let mut env = ctx.data();
     let state = env.state.clone();
 
@@ -134,11 +136,11 @@ pub(crate) fn fd_write_internal<M: MemorySize>(
     let is_stdio = fd_entry.is_stdio;
 
     let bytes_written = {
-        if !is_stdio && !fd_entry.rights.contains(Rights::FD_WRITE) {
+        if !is_stdio && !fd_entry.inner.rights.contains(Rights::FD_WRITE) {
             return Ok(Err(Errno::Access));
         }
 
-        let fd_flags = fd_entry.flags;
+        let fd_flags = fd_entry.inner.flags;
         let mut memory = unsafe { env.memory_view(&ctx) };
 
         let (bytes_written, is_file, can_snapshot) = {
@@ -152,7 +154,7 @@ pub(crate) fn fd_write_internal<M: MemorySize>(
 
                         let res = __asyncify_light(
                             env,
-                            if fd_entry.flags.contains(Fdflags::NONBLOCK) {
+                            if fd_entry.inner.flags.contains(Fdflags::NONBLOCK) {
                                 Some(Duration::ZERO)
                             } else {
                                 None
@@ -160,6 +162,12 @@ pub(crate) fn fd_write_internal<M: MemorySize>(
                             async {
                                 let mut handle = handle.write().unwrap();
                                 if !is_stdio {
+                                    if fd_entry.inner.flags.contains(Fdflags::APPEND) {
+                                        // `fdflags::append` means we need to seek to the end before writing.
+                                        offset = fd_entry.inode.stat.read().unwrap().st_size;
+                                        fd_entry.inner.offset.store(offset, Ordering::Release);
+                                    }
+
                                     handle
                                         .seek(std::io::SeekFrom::Start(offset))
                                         .await
@@ -267,11 +275,15 @@ pub(crate) fn fd_write_internal<M: MemorySize>(
                     let written = wasi_try_ok_ok!(res?);
                     (written, false, false)
                 }
-                Kind::Pipe { pipe } => {
+                Kind::PipeRx { .. } => {
+                    return Ok(Err(Errno::Badf));
+                }
+                Kind::PipeTx { tx } => {
                     let mut written = 0usize;
 
                     match &data {
                         FdWriteSource::Iovs { iovs, iovs_len } => {
+                            let mut raise_sigpipe = false;
                             let iovs_arr = wasi_try_ok_ok!(iovs
                                 .slice(&memory, *iovs_len)
                                 .map_err(mem_error_to_wasi));
@@ -282,20 +294,98 @@ pub(crate) fn fd_write_internal<M: MemorySize>(
                                     .slice(&memory, iovs.buf_len)
                                     .map_err(mem_error_to_wasi));
                                 let buf = wasi_try_ok_ok!(buf.access().map_err(mem_error_to_wasi));
-                                let local_written =
-                                    wasi_try_ok_ok!(std::io::Write::write(pipe, buf.as_ref())
-                                        .map_err(map_io_err));
+                                let write_result = std::io::Write::write(tx, buf.as_ref());
+                                let local_written = match write_result {
+                                    Ok(w) => w,
+                                    Err(e) if e.kind() == std::io::ErrorKind::BrokenPipe => {
+                                        // Need to do this to avoid double borrow on ctx with iovs_arr
+                                        raise_sigpipe = true;
+                                        break;
+                                    }
+                                    Err(e) => return Ok(Err(map_io_err(e))),
+                                };
 
                                 written += local_written;
                                 if local_written != buf.len() {
                                     break;
                                 }
                             }
+
+                            drop(iovs_arr);
+
+                            if raise_sigpipe {
+                                env.process.signal_process(Signal::Sigpipe);
+                                wasi_try_ok_ok!(WasiEnv::process_signals_and_exit(ctx)?);
+                                return Ok(Err(Errno::Pipe));
+                            }
                         }
                         FdWriteSource::Buffer(data) => {
-                            wasi_try_ok_ok!(
-                                std::io::Write::write_all(pipe, data).map_err(map_io_err)
-                            );
+                            match std::io::Write::write_all(tx, data) {
+                                Ok(()) => (),
+                                Err(e) if e.kind() == std::io::ErrorKind::BrokenPipe => {
+                                    env.process.signal_process(Signal::Sigpipe);
+                                    wasi_try_ok_ok!(WasiEnv::process_signals_and_exit(ctx)?);
+                                    return Ok(Err(Errno::Pipe));
+                                }
+                                Err(e) => return Ok(Err(map_io_err(e))),
+                            };
+                            written += data.len();
+                        }
+                    }
+
+                    (written, false, true)
+                }
+                Kind::DuplexPipe { pipe } => {
+                    let mut written = 0usize;
+
+                    match &data {
+                        FdWriteSource::Iovs { iovs, iovs_len } => {
+                            let mut raise_sigpipe = false;
+                            let iovs_arr = wasi_try_ok_ok!(iovs
+                                .slice(&memory, *iovs_len)
+                                .map_err(mem_error_to_wasi));
+                            let iovs_arr =
+                                wasi_try_ok_ok!(iovs_arr.access().map_err(mem_error_to_wasi));
+                            for iovs in iovs_arr.iter() {
+                                let buf = wasi_try_ok_ok!(WasmPtr::<u8, M>::new(iovs.buf)
+                                    .slice(&memory, iovs.buf_len)
+                                    .map_err(mem_error_to_wasi));
+                                let buf = wasi_try_ok_ok!(buf.access().map_err(mem_error_to_wasi));
+                                let write_result = std::io::Write::write(pipe, buf.as_ref());
+                                let local_written = match write_result {
+                                    Ok(w) => w,
+                                    Err(e) if e.kind() == std::io::ErrorKind::BrokenPipe => {
+                                        // Need to do this to avoid double borrow on ctx with iovs_arr
+                                        raise_sigpipe = true;
+                                        break;
+                                    }
+                                    Err(e) => return Ok(Err(map_io_err(e))),
+                                };
+
+                                written += local_written;
+                                if local_written != buf.len() {
+                                    break;
+                                }
+                            }
+
+                            drop(iovs_arr);
+
+                            if raise_sigpipe {
+                                env.process.signal_process(Signal::Sigpipe);
+                                wasi_try_ok_ok!(WasiEnv::process_signals_and_exit(ctx)?);
+                                return Ok(Err(Errno::Pipe));
+                            }
+                        }
+                        FdWriteSource::Buffer(data) => {
+                            match std::io::Write::write_all(pipe, data) {
+                                Ok(()) => (),
+                                Err(e) if e.kind() == std::io::ErrorKind::BrokenPipe => {
+                                    env.process.signal_process(Signal::Sigpipe);
+                                    wasi_try_ok_ok!(WasiEnv::process_signals_and_exit(ctx)?);
+                                    return Ok(Err(Errno::Pipe));
+                                }
+                                Err(e) => return Ok(Err(map_io_err(e))),
+                            };
                             written += data.len();
                         }
                     }
@@ -404,7 +494,7 @@ pub(crate) fn fd_write_internal<M: MemorySize>(
                 JournalEffector::save_fd_write(ctx, fd, offset, bytes_written, iovs, iovs_len)
                     .map_err(|err| {
                         tracing::error!("failed to save terminal data - {}", err);
-                        WasiError::Exit(ExitCode::Errno(Errno::Fault))
+                        WasiError::Exit(ExitCode::from(Errno::Fault))
                     })?;
             }
         }
@@ -417,14 +507,14 @@ pub(crate) fn fd_write_internal<M: MemorySize>(
             let curr_offset = if is_file && should_update_cursor {
                 let bytes_written = bytes_written as u64;
                 let mut fd_map = state.fs.fd_map.write().unwrap();
-                let fd_entry = wasi_try_ok_ok!(fd_map.get_mut(&fd).ok_or(Errno::Badf));
+                let fd_entry = wasi_try_ok_ok!(fd_map.get_mut(fd).ok_or(Errno::Badf));
                 fd_entry
                     .offset
                     .fetch_add(bytes_written, Ordering::AcqRel)
                     // fetch_add returns the previous value, we have to add bytes_written again here
                     + bytes_written
             } else {
-                fd_entry.offset.load(Ordering::Acquire)
+                fd_entry.inner.offset.load(Ordering::Acquire)
             };
 
             // we set the size but we don't return any errors if it fails as
diff --git a/lib/wasix/src/syscalls/wasi/path_create_directory.rs b/lib/wasix/src/syscalls/wasi/path_create_directory.rs
index 99944f7992..025427c47f 100644
--- a/lib/wasix/src/syscalls/wasi/path_create_directory.rs
+++ b/lib/wasix/src/syscalls/wasi/path_create_directory.rs
@@ -1,4 +1,7 @@
-use std::{path::PathBuf, str::FromStr};
+use std::{
+    path::{Component, PathBuf},
+    str::FromStr,
+};
 
 use super::*;
 use crate::syscalls::*;
@@ -23,20 +26,14 @@ pub fn path_create_directory<M: MemorySize>(
     path: WasmPtr<u8, M>,
     path_len: M::Offset,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let (memory, state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
 
     let mut path_string = unsafe { get_input_str_ok!(&memory, path, path_len) };
     Span::current().record("path", path_string.as_str());
 
-    // Convert relative paths into absolute paths
-    if path_string.starts_with("./") {
-        path_string = ctx.data().state.fs.relative_path_to_absolute(path_string);
-        trace!(
-            %path_string
-        );
-    }
-
     wasi_try_ok!(path_create_directory_internal(&mut ctx, fd, &path_string));
     let env = ctx.data();
 
@@ -44,7 +41,7 @@ pub fn path_create_directory<M: MemorySize>(
     if env.enable_journal {
         JournalEffector::save_path_create_directory(&mut ctx, fd, path_string).map_err(|err| {
             tracing::error!("failed to save create directory event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
@@ -60,115 +57,84 @@ pub(crate) fn path_create_directory_internal(
     let (memory, state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
     let working_dir = state.fs.get_fd(fd)?;
 
-    if !working_dir.rights.contains(Rights::PATH_CREATE_DIRECTORY) {
+    if !working_dir
+        .inner
+        .rights
+        .contains(Rights::PATH_CREATE_DIRECTORY)
+    {
         trace!("working directory (fd={fd}) has no rights to create a directory");
         return Err(Errno::Access);
     }
 
-    let path = std::path::PathBuf::from(path);
-    let path_vec = path
-        .components()
-        .map(|comp| {
-            comp.as_os_str()
-                .to_str()
-                .map(|inner_str| inner_str.to_string())
-                .ok_or(Errno::Inval)
-        })
-        .collect::<Result<Vec<String>, Errno>>()?;
-    if path_vec.is_empty() {
-        trace!("path vector is inva;id (its empty)");
-        return Err(Errno::Inval);
-    }
+    let (parent_inode, dir_name) =
+        state
+            .fs
+            .get_parent_inode_at_path(inodes, fd, Path::new(path), true)?;
 
-    let mut cur_dir_inode = working_dir.inode;
-    let mut created_directory = false;
-    for comp in &path_vec {
-        let processing_cur_dir_inode = cur_dir_inode.clone();
-        let mut guard = processing_cur_dir_inode.write();
-        match guard.deref_mut() {
-            Kind::Dir {
-                ref mut entries,
-                path,
-                parent,
-            } => {
-                match comp.borrow() {
-                    ".." => {
-                        if let Some(p) = parent.upgrade() {
-                            cur_dir_inode = p;
-                            continue;
-                        }
-                    }
-                    "." => continue,
-                    _ => (),
-                }
-                if let Some(child) = entries.get(comp) {
-                    cur_dir_inode = child.clone();
-                } else {
-                    let mut adjusted_path = path.clone();
-                    drop(guard);
-
-                    // TODO: double check this doesn't risk breaking the sandbox
-                    adjusted_path.push(comp);
-                    if let Ok(adjusted_path_stat) = path_filestat_get_internal(
-                        &memory,
-                        state,
-                        inodes,
-                        fd,
-                        0,
-                        &adjusted_path.to_string_lossy(),
-                    ) {
-                        if adjusted_path_stat.st_filetype != Filetype::Directory {
-                            trace!("path is not a directory");
-                            return Err(Errno::Notdir);
-                        }
-                    } else {
-                        created_directory = true;
-                        state.fs_create_dir(&adjusted_path)?;
-                    }
-                    let kind = Kind::Dir {
-                        parent: cur_dir_inode.downgrade(),
-                        path: adjusted_path,
-                        entries: Default::default(),
-                    };
-                    let new_inode = state
-                        .fs
-                        .create_inode(inodes, kind, false, comp.to_string())?;
-
-                    // reborrow to insert
-                    {
-                        let mut guard = cur_dir_inode.write();
-                        if let Kind::Dir {
-                            ref mut entries, ..
-                        } = guard.deref_mut()
-                        {
-                            entries.insert(comp.to_string(), new_inode.clone());
-                        }
-                    }
-                    cur_dir_inode = new_inode;
-                }
+    let mut guard = parent_inode.write();
+    match guard.deref_mut() {
+        Kind::Dir {
+            ref entries,
+            ref path,
+            ..
+        } => {
+            if let Some(child) = entries.get(&dir_name) {
+                return Err(Errno::Exist);
             }
-            Kind::Root { entries } => {
-                match comp.borrow() {
-                    "." | ".." => continue,
-                    _ => (),
-                }
-                if let Some(child) = entries.get(comp) {
-                    cur_dir_inode = child.clone();
-                } else {
-                    trace!("the root node can no create a directory");
-                    return Err(Errno::Access);
-                }
+
+            let mut new_dir_path = path.clone();
+            new_dir_path.push(&dir_name);
+
+            drop(guard);
+
+            // TODO: This condition should already have been checked by the entries.get check
+            // above, but it was in the code before my refactor and I'm keeping it just in case.
+            if path_filestat_get_internal(
+                &memory,
+                state,
+                inodes,
+                fd,
+                0,
+                &new_dir_path.to_string_lossy(),
+            )
+            .is_ok()
+            {
+                return Err(Errno::Exist);
             }
-            _ => {
-                trace!("path is not a directory");
-                return Err(Errno::Notdir);
+
+            state.fs_create_dir(&new_dir_path)?;
+
+            let kind = Kind::Dir {
+                parent: parent_inode.downgrade(),
+                path: new_dir_path,
+                entries: Default::default(),
+            };
+            let new_inode = state
+                .fs
+                .create_inode(inodes, kind, false, dir_name.clone())?;
+
+            // reborrow to insert
+            {
+                let mut guard = parent_inode.write();
+                let Kind::Dir {
+                    ref mut entries, ..
+                } = guard.deref_mut()
+                else {
+                    unreachable!();
+                };
+
+                entries.insert(dir_name, new_inode.clone());
             }
         }
+        Kind::Root { .. } => {
+            trace!("the root node can only contain pre-opened directories");
+            return Err(Errno::Access);
+        }
+        _ => {
+            trace!("path is not a directory");
+            return Err(Errno::Notdir);
+        }
     }
 
-    if created_directory {
-        Ok(())
-    } else {
-        Err(Errno::Exist)
-    }
+    Ok(())
 }
diff --git a/lib/wasix/src/syscalls/wasi/path_filestat_get.rs b/lib/wasix/src/syscalls/wasi/path_filestat_get.rs
index 293b9c86f9..e68ee70441 100644
--- a/lib/wasix/src/syscalls/wasi/path_filestat_get.rs
+++ b/lib/wasix/src/syscalls/wasi/path_filestat_get.rs
@@ -31,9 +31,16 @@ pub fn path_filestat_get<M: MemorySize>(
     let mut path_string = unsafe { get_input_str!(&memory, path, path_len) };
 
     // Convert relative paths into absolute paths
-    if path_string.starts_with("./") {
-        path_string = ctx.data().state.fs.relative_path_to_absolute(path_string);
-    }
+    // let path_str = if path_string == "." {
+    //     &"/"
+    // } else if path_string.starts_with("./") {
+    //     &path_string[1..]
+    // } else {
+    //     &path_string
+    // };
+    // if path_string.starts_with("./") || path_string == "." {
+    //     path_string = ctx.data().state.fs.relative_path_to_absolute(path_string);
+    // }
     tracing::trace!(path = path_string.as_str());
 
     let stat = wasi_try!(path_filestat_get_internal(
@@ -62,7 +69,7 @@ pub(crate) fn path_filestat_get_internal(
 ) -> Result<Filestat, Errno> {
     let root_dir = state.fs.get_fd(fd)?;
 
-    if !root_dir.rights.contains(Rights::PATH_FILESTAT_GET) {
+    if !root_dir.inner.rights.contains(Rights::PATH_FILESTAT_GET) {
         return Err(Errno::Access);
     }
     let file_inode = state.fs.get_inode_at_path(
@@ -109,13 +116,8 @@ pub fn path_filestat_get_old<M: MemorySize>(
     let env = ctx.data();
     let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
 
-    let mut path_string = unsafe { get_input_str!(&memory, path, path_len) };
-
-    // Convert relative paths into absolute paths
-    if path_string.starts_with("./") {
-        path_string = ctx.data().state.fs.relative_path_to_absolute(path_string);
-    }
-    tracing::trace!(path = path_string.as_str());
+    let path_string = unsafe { get_input_str!(&memory, path, path_len) };
+    Span::current().record("path", path_string.as_str());
 
     let stat = wasi_try!(path_filestat_get_internal(
         &memory,
diff --git a/lib/wasix/src/syscalls/wasi/path_filestat_set_times.rs b/lib/wasix/src/syscalls/wasi/path_filestat_set_times.rs
index c471374e20..e2e35eb5bd 100644
--- a/lib/wasix/src/syscalls/wasi/path_filestat_set_times.rs
+++ b/lib/wasix/src/syscalls/wasi/path_filestat_set_times.rs
@@ -18,7 +18,7 @@ use crate::syscalls::*;
 ///     The timestamp that the last modified time attribute is set to
 /// - `Fstflags fst_flags`
 ///     A bitmask controlling which attributes are set
-#[instrument(level = "debug", skip_all, fields(%fd, path = field::Empty, %st_atim, %st_mtim), ret)]
+#[instrument(level = "trace", skip_all, fields(%fd, path = field::Empty, %st_atim, %st_mtim), ret)]
 pub fn path_filestat_set_times<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     fd: WasiFd,
@@ -29,20 +29,14 @@ pub fn path_filestat_set_times<M: MemorySize>(
     st_mtim: Timestamp,
     fst_flags: Fstflags,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
 
-    let mut path_string = unsafe { get_input_str_ok!(&memory, path, path_len) };
+    let path_string = unsafe { get_input_str_ok!(&memory, path, path_len) };
     Span::current().record("path", path_string.as_str());
 
-    // Convert relative paths into absolute paths
-    if path_string.starts_with("./") {
-        path_string = ctx.data().state.fs.relative_path_to_absolute(path_string);
-        trace!(
-            %path_string
-        );
-    }
-
     wasi_try_ok!(path_filestat_set_times_internal(
         &mut ctx,
         fd,
@@ -67,7 +61,7 @@ pub fn path_filestat_set_times<M: MemorySize>(
         )
         .map_err(|err| {
             tracing::error!("failed to save file set times event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
@@ -87,7 +81,11 @@ pub(crate) fn path_filestat_set_times_internal(
     let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
     let fd_entry = state.fs.get_fd(fd)?;
     let fd_inode = fd_entry.inode;
-    if !fd_entry.rights.contains(Rights::PATH_FILESTAT_SET_TIMES) {
+    if !fd_entry
+        .inner
+        .rights
+        .contains(Rights::PATH_FILESTAT_SET_TIMES)
+    {
         return Err(Errno::Access);
     }
     if (fst_flags.contains(Fstflags::SET_ATIM) && fst_flags.contains(Fstflags::SET_ATIM_NOW))
diff --git a/lib/wasix/src/syscalls/wasi/path_link.rs b/lib/wasix/src/syscalls/wasi/path_link.rs
index 9b0388d6cd..265b4729e0 100644
--- a/lib/wasix/src/syscalls/wasi/path_link.rs
+++ b/lib/wasix/src/syscalls/wasi/path_link.rs
@@ -18,7 +18,7 @@ use crate::syscalls::*;
 ///     String containing the new file path
 /// - `u32 old_path_len`
 ///     Length of the `new_path` string
-#[instrument(level = "debug", skip_all, fields(%old_fd, %new_fd, old_path = field::Empty, new_path = field::Empty, follow_symlinks = false), ret)]
+#[instrument(level = "trace", skip_all, fields(%old_fd, %new_fd, old_path = field::Empty, new_path = field::Empty, follow_symlinks = false), ret)]
 pub fn path_link<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     old_fd: WasiFd,
@@ -29,6 +29,8 @@ pub fn path_link<M: MemorySize>(
     new_path: WasmPtr<u8, M>,
     new_path_len: M::Offset,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     if old_flags & __WASI_LOOKUP_SYMLINK_FOLLOW != 0 {
         Span::current().record("follow_symlinks", true);
     }
@@ -61,7 +63,7 @@ pub fn path_link<M: MemorySize>(
         )
         .map_err(|err| {
             tracing::error!("failed to save path hard link event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
@@ -81,37 +83,28 @@ pub(crate) fn path_link_internal(
     let source_fd = state.fs.get_fd(old_fd)?;
     let target_fd = state.fs.get_fd(new_fd)?;
 
-    if !source_fd.rights.contains(Rights::PATH_LINK_SOURCE)
-        || !target_fd.rights.contains(Rights::PATH_LINK_TARGET)
+    if !source_fd.inner.rights.contains(Rights::PATH_LINK_SOURCE)
+        || !target_fd.inner.rights.contains(Rights::PATH_LINK_TARGET)
     {
         return Err(Errno::Access);
     }
 
-    // Convert relative paths into absolute paths
-    let old_path_str = ctx
-        .data()
-        .state
-        .fs
-        .relative_path_to_absolute(old_path.to_string());
-    let new_path_str = ctx
-        .data()
-        .state
-        .fs
-        .relative_path_to_absolute(new_path.to_string());
+    Span::current().record("old_path", old_path);
+    Span::current().record("new_path", new_path);
 
     let source_inode = state.fs.get_inode_at_path(
         inodes,
         old_fd,
-        &old_path_str,
+        old_path,
         old_flags & __WASI_LOOKUP_SYMLINK_FOLLOW != 0,
     )?;
-    let target_path_arg = std::path::PathBuf::from(&new_path_str);
+    let target_path_arg = std::path::PathBuf::from(new_path);
     let (target_parent_inode, new_entry_name) =
         state
             .fs
             .get_parent_inode_at_path(inodes, new_fd, &target_path_arg, false)?;
 
-    if source_inode.stat.write().unwrap().st_nlink == Linkcount::max_value() {
+    if source_inode.stat.write().unwrap().st_nlink == Linkcount::MAX {
         return Err(Errno::Mlink);
     }
     {
@@ -128,7 +121,9 @@ pub(crate) fn path_link_internal(
             | Kind::Symlink { .. }
             | Kind::Buffer { .. }
             | Kind::Socket { .. }
-            | Kind::Pipe { .. }
+            | Kind::PipeTx { .. }
+            | Kind::PipeRx { .. }
+            | Kind::DuplexPipe { .. }
             | Kind::EventNotifications { .. }
             | Kind::Epoll { .. } => return Err(Errno::Notdir),
         }
diff --git a/lib/wasix/src/syscalls/wasi/path_open.rs b/lib/wasix/src/syscalls/wasi/path_open.rs
index 5f8033cb63..d2ca1b6c19 100644
--- a/lib/wasix/src/syscalls/wasi/path_open.rs
+++ b/lib/wasix/src/syscalls/wasi/path_open.rs
@@ -25,7 +25,7 @@ use crate::syscalls::*;
 ///     The new file descriptor
 /// Possible Errors:
 /// - `Errno::Access`, `Errno::Badf`, `Errno::Fault`, `Errno::Fbig?`, `Errno::Inval`, `Errno::Io`, `Errno::Loop`, `Errno::Mfile`, `Errno::Nametoolong?`, `Errno::Nfile`, `Errno::Noent`, `Errno::Notdir`, `Errno::Rofs`, and `Errno::Notcapable`
-#[instrument(level = "debug", skip_all, fields(%dirfd, path = field::Empty, follow_symlinks = field::Empty, ret_fd = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(%dirfd, path = field::Empty, follow_symlinks = field::Empty, ret_fd = field::Empty), ret)]
 pub fn path_open<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     dirfd: WasiFd,
@@ -38,6 +38,8 @@ pub fn path_open<M: MemorySize>(
     fs_flags: Fdflags,
     fd: WasmPtr<WasiFd, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     if dirflags & __WASI_LOOKUP_SYMLINK_FOLLOW != 0 {
         Span::current().record("follow_symlinks", true);
     }
@@ -60,19 +62,11 @@ pub fn path_open<M: MemorySize>(
     // - __WASI_O_EXCL (fail if file exists)
     // - __WASI_O_TRUNC (truncate size to 0)
 
-    let mut path_string = unsafe { get_input_str_ok!(&memory, path, path_len) };
+    let path_string = unsafe { get_input_str_ok!(&memory, path, path_len) };
     Span::current().record("path", path_string.as_str());
 
-    // Convert relative paths into absolute paths
-    if path_string.starts_with("./") {
-        path_string = ctx.data().state.fs.relative_path_to_absolute(path_string);
-        trace!(
-            %path_string
-        );
-    }
-
     let out_fd = wasi_try_ok!(path_open_internal(
-        &mut ctx,
+        ctx.data(),
         dirfd,
         dirflags,
         &path_string,
@@ -80,6 +74,7 @@ pub fn path_open<M: MemorySize>(
         fs_rights_base,
         fs_rights_inheriting,
         fs_flags,
+        Fdflagsext::empty(),
         None,
     )?);
     let env = ctx.data();
@@ -96,10 +91,11 @@ pub fn path_open<M: MemorySize>(
             fs_rights_base,
             fs_rights_inheriting,
             fs_flags,
+            Fdflagsext::empty(),
         )
         .map_err(|err| {
             tracing::error!("failed to save unlink event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
@@ -114,316 +110,3 @@ pub fn path_open<M: MemorySize>(
 
     Ok(Errno::Success)
 }
-
-pub(crate) fn path_open_internal(
-    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
-    dirfd: WasiFd,
-    dirflags: LookupFlags,
-    path: &str,
-    o_flags: Oflags,
-    fs_rights_base: Rights,
-    fs_rights_inheriting: Rights,
-    fs_flags: Fdflags,
-    with_fd: Option<WasiFd>,
-) -> Result<Result<WasiFd, Errno>, WasiError> {
-    let env = ctx.data();
-    let (memory, mut state, mut inodes) =
-        unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
-
-    let path_arg = std::path::PathBuf::from(&path);
-    let maybe_inode = state.fs.get_inode_at_path(
-        inodes,
-        dirfd,
-        path,
-        dirflags & __WASI_LOOKUP_SYMLINK_FOLLOW != 0,
-    );
-
-    let working_dir = wasi_try_ok_ok!(state.fs.get_fd(dirfd));
-    let working_dir_rights_inheriting = working_dir.rights_inheriting;
-
-    // ASSUMPTION: open rights apply recursively
-    if !working_dir.rights.contains(Rights::PATH_OPEN) {
-        return Ok(Err(Errno::Access));
-    }
-
-    let mut open_flags = 0;
-    // TODO: traverse rights of dirs properly
-    // COMMENTED OUT: WASI isn't giving appropriate rights here when opening
-    //              TODO: look into this; file a bug report if this is a bug
-    //
-    // Maximum rights: should be the working dir rights
-    // Minimum rights: whatever rights are provided
-    let adjusted_rights = /*fs_rights_base &*/ working_dir_rights_inheriting;
-    let mut open_options = state.fs_new_open_options();
-
-    let target_rights = match maybe_inode {
-        Ok(_) => {
-            let write_permission = adjusted_rights.contains(Rights::FD_WRITE);
-
-            // append, truncate, and create all require the permission to write
-            let (append_permission, truncate_permission, create_permission) = if write_permission {
-                (
-                    fs_flags.contains(Fdflags::APPEND),
-                    o_flags.contains(Oflags::TRUNC),
-                    o_flags.contains(Oflags::CREATE),
-                )
-            } else {
-                (false, false, false)
-            };
-
-            virtual_fs::OpenOptionsConfig {
-                read: fs_rights_base.contains(Rights::FD_READ),
-                write: write_permission,
-                create_new: create_permission && o_flags.contains(Oflags::EXCL),
-                create: create_permission,
-                append: append_permission,
-                truncate: truncate_permission,
-            }
-        }
-        Err(_) => virtual_fs::OpenOptionsConfig {
-            append: fs_flags.contains(Fdflags::APPEND),
-            write: fs_rights_base.contains(Rights::FD_WRITE),
-            read: fs_rights_base.contains(Rights::FD_READ),
-            create_new: o_flags.contains(Oflags::CREATE) && o_flags.contains(Oflags::EXCL),
-            create: o_flags.contains(Oflags::CREATE),
-            truncate: o_flags.contains(Oflags::TRUNC),
-        },
-    };
-
-    let parent_rights = virtual_fs::OpenOptionsConfig {
-        read: working_dir.rights.contains(Rights::FD_READ),
-        write: working_dir.rights.contains(Rights::FD_WRITE),
-        // The parent is a directory, which is why these options
-        // aren't inherited from the parent (append / truncate doesn't work on directories)
-        create_new: true,
-        create: true,
-        append: true,
-        truncate: true,
-    };
-
-    let minimum_rights = target_rights.minimum_rights(&parent_rights);
-
-    open_options.options(minimum_rights.clone());
-
-    let orig_path = path;
-
-    let inode = if let Ok(inode) = maybe_inode {
-        // Happy path, we found the file we're trying to open
-        let processing_inode = inode.clone();
-        let mut guard = processing_inode.write();
-
-        let deref_mut = guard.deref_mut();
-
-        if o_flags.contains(Oflags::EXCL) && o_flags.contains(Oflags::CREATE) {
-            return Ok(Err(Errno::Exist));
-        }
-
-        match deref_mut {
-            Kind::File {
-                ref mut handle,
-                path,
-                fd,
-                ..
-            } => {
-                if let Some(special_fd) = fd {
-                    // short circuit if we're dealing with a special file
-                    assert!(handle.is_some());
-                    return Ok(Ok(*special_fd));
-                }
-                if o_flags.contains(Oflags::DIRECTORY) || orig_path.ends_with('/') {
-                    return Ok(Err(Errno::Notdir));
-                }
-
-                let open_options = open_options
-                    .write(minimum_rights.write)
-                    .create(minimum_rights.create)
-                    .append(minimum_rights.append)
-                    .truncate(minimum_rights.truncate);
-
-                if minimum_rights.read {
-                    open_flags |= Fd::READ;
-                }
-                if minimum_rights.write {
-                    open_flags |= Fd::WRITE;
-                }
-                if minimum_rights.create {
-                    open_flags |= Fd::CREATE;
-                }
-                if minimum_rights.truncate {
-                    open_flags |= Fd::TRUNCATE;
-                }
-                *handle = Some(Arc::new(std::sync::RwLock::new(wasi_try_ok_ok!(
-                    open_options.open(&path).map_err(fs_error_into_wasi_err)
-                ))));
-
-                if let Some(handle) = handle {
-                    let handle = handle.read().unwrap();
-                    if let Some(fd) = handle.get_special_fd() {
-                        // We clone the file descriptor so that when its closed
-                        // nothing bad happens
-                        let dup_fd = wasi_try_ok_ok!(state.fs.clone_fd(fd));
-                        trace!(
-                            %dup_fd
-                        );
-
-                        // some special files will return a constant FD rather than
-                        // actually open the file (/dev/stdin, /dev/stdout, /dev/stderr)
-                        return Ok(Ok(dup_fd));
-                    }
-                }
-            }
-            Kind::Buffer { .. } => unimplemented!("wasi::path_open for Buffer type files"),
-            Kind::Root { .. } => {
-                if !o_flags.contains(Oflags::DIRECTORY) {
-                    return Ok(Err(Errno::Notcapable));
-                }
-            }
-            Kind::Dir { .. } => {
-                if fs_rights_base.contains(Rights::FD_WRITE) {
-                    return Ok(Err(Errno::Isdir));
-                }
-            }
-            Kind::Socket { .. }
-            | Kind::Pipe { .. }
-            | Kind::EventNotifications { .. }
-            | Kind::Epoll { .. } => {}
-            Kind::Symlink {
-                base_po_dir,
-                path_to_symlink,
-                relative_path,
-            } => {
-                // I think this should return an error (because symlinks should be resolved away by the path traversal)
-                // TODO: investigate this
-                unimplemented!("SYMLINKS IN PATH_OPEN");
-            }
-        }
-        inode
-    } else {
-        // less-happy path, we have to try to create the file
-        if o_flags.contains(Oflags::CREATE) {
-            if o_flags.contains(Oflags::DIRECTORY) {
-                return Ok(Err(Errno::Notdir));
-            }
-
-            // Trailing slash matters. But the underlying opener normalizes it away later.
-            if path.ends_with('/') {
-                return Ok(Err(Errno::Isdir));
-            }
-
-            // strip end file name
-
-            let (parent_inode, new_entity_name) =
-                wasi_try_ok_ok!(state.fs.get_parent_inode_at_path(
-                    inodes,
-                    dirfd,
-                    &path_arg,
-                    dirflags & __WASI_LOOKUP_SYMLINK_FOLLOW != 0
-                ));
-            let new_file_host_path = {
-                let guard = parent_inode.read();
-                match guard.deref() {
-                    Kind::Dir { path, .. } => {
-                        let mut new_path = path.clone();
-                        new_path.push(&new_entity_name);
-                        new_path
-                    }
-                    Kind::Root { .. } => {
-                        let mut new_path = std::path::PathBuf::new();
-                        new_path.push(&new_entity_name);
-                        new_path
-                    }
-                    _ => return Ok(Err(Errno::Inval)),
-                }
-            };
-            // once we got the data we need from the parent, we lookup the host file
-            // todo: extra check that opening with write access is okay
-            let handle = {
-                // We set create_new because the path already didn't resolve to an existing file,
-                // so it must be created.
-                let open_options = open_options
-                    .read(minimum_rights.read)
-                    .append(minimum_rights.append)
-                    .write(minimum_rights.write)
-                    .create_new(true);
-
-                if minimum_rights.read {
-                    open_flags |= Fd::READ;
-                }
-                if minimum_rights.write {
-                    open_flags |= Fd::WRITE;
-                }
-                if minimum_rights.create_new {
-                    open_flags |= Fd::CREATE;
-                }
-                if minimum_rights.truncate {
-                    open_flags |= Fd::TRUNCATE;
-                }
-
-                match open_options.open(&new_file_host_path) {
-                    Ok(handle) => Some(handle),
-                    Err(err) => {
-                        // Even though the file does not exist, it still failed to create with
-                        // `AlreadyExists` error.  This can happen if the path resolves to a
-                        // symlink that points outside the FS sandbox.
-                        if err == FsError::AlreadyExists {
-                            return Ok(Err(Errno::Perm));
-                        }
-
-                        return Ok(Err(fs_error_into_wasi_err(err)));
-                    }
-                }
-            };
-
-            let new_inode = {
-                let kind = Kind::File {
-                    handle: handle.map(|a| Arc::new(std::sync::RwLock::new(a))),
-                    path: new_file_host_path,
-                    fd: None,
-                };
-                wasi_try_ok_ok!(state
-                    .fs
-                    .create_inode(inodes, kind, false, new_entity_name.clone()))
-            };
-
-            {
-                let mut guard = parent_inode.write();
-                if let Kind::Dir {
-                    ref mut entries, ..
-                } = guard.deref_mut()
-                {
-                    entries.insert(new_entity_name, new_inode.clone());
-                }
-            }
-
-            new_inode
-        } else {
-            return Ok(Err(maybe_inode.unwrap_err()));
-        }
-    };
-
-    // TODO: check and reduce these
-    // TODO: ensure a mutable fd to root can never be opened
-    let out_fd = wasi_try_ok_ok!(if let Some(fd) = with_fd {
-        state
-            .fs
-            .with_fd(
-                adjusted_rights,
-                fs_rights_inheriting,
-                fs_flags,
-                open_flags,
-                inode,
-                fd,
-            )
-            .map(|_| fd)
-    } else {
-        state.fs.create_fd(
-            adjusted_rights,
-            fs_rights_inheriting,
-            fs_flags,
-            open_flags,
-            inode,
-        )
-    });
-
-    Ok(Ok(out_fd))
-}
diff --git a/lib/wasix/src/syscalls/wasi/path_readlink.rs b/lib/wasix/src/syscalls/wasi/path_readlink.rs
index e83589008f..3c20be26bd 100644
--- a/lib/wasix/src/syscalls/wasi/path_readlink.rs
+++ b/lib/wasix/src/syscalls/wasi/path_readlink.rs
@@ -17,35 +17,29 @@ use crate::syscalls::*;
 ///     Pointer to characters containing the path that the symlink points to
 /// - `u32 buf_used`
 ///     The number of bytes written to `buf`
-#[instrument(level = "debug", skip_all, fields(%dir_fd, path = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(%dir_fd, path = field::Empty), ret)]
 pub fn path_readlink<M: MemorySize>(
-    ctx: FunctionEnvMut<'_, WasiEnv>,
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
     dir_fd: WasiFd,
     path: WasmPtr<u8, M>,
     path_len: M::Offset,
     buf: WasmPtr<u8, M>,
     buf_len: M::Offset,
     buf_used: WasmPtr<M::Offset, M>,
-) -> Errno {
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
 
-    let base_dir = wasi_try!(state.fs.get_fd(dir_fd));
-    if !base_dir.rights.contains(Rights::PATH_READLINK) {
-        return Errno::Access;
+    let base_dir = wasi_try_ok!(state.fs.get_fd(dir_fd));
+    if !base_dir.inner.rights.contains(Rights::PATH_READLINK) {
+        return Ok(Errno::Access);
     }
-    let mut path_str = unsafe { get_input_str!(&memory, path, path_len) };
+    let mut path_str = unsafe { get_input_str_ok!(&memory, path, path_len) };
     Span::current().record("path", path_str.as_str());
 
-    // Convert relative paths into absolute paths
-    if path_str.starts_with("./") {
-        path_str = ctx.data().state.fs.relative_path_to_absolute(path_str);
-        trace!(
-            %path_str
-        );
-    }
-
-    let inode = wasi_try!(state.fs.get_inode_at_path(inodes, dir_fd, &path_str, false));
+    let inode = wasi_try_ok!(state.fs.get_inode_at_path(inodes, dir_fd, &path_str, false));
 
     {
         let guard = inode.read();
@@ -54,21 +48,22 @@ pub fn path_readlink<M: MemorySize>(
             let buf_len: u64 = buf_len.into();
             let bytes = rel_path_str.bytes();
             if bytes.len() as u64 >= buf_len {
-                return Errno::Overflow;
+                return Ok(Errno::Overflow);
             }
             let bytes: Vec<_> = bytes.collect();
 
-            let out = wasi_try_mem!(buf.slice(&memory, wasi_try!(to_offset::<M>(bytes.len()))));
-            wasi_try_mem!(out.write_slice(&bytes));
+            let out =
+                wasi_try_mem_ok!(buf.slice(&memory, wasi_try_ok!(to_offset::<M>(bytes.len()))));
+            wasi_try_mem_ok!(out.write_slice(&bytes));
             // should we null terminate this?
 
             let bytes_len: M::Offset =
-                wasi_try!(bytes.len().try_into().map_err(|_| Errno::Overflow));
-            wasi_try_mem!(buf_used.deref(&memory).write(bytes_len));
+                wasi_try_ok!(bytes.len().try_into().map_err(|_| Errno::Overflow));
+            wasi_try_mem_ok!(buf_used.deref(&memory).write(bytes_len));
         } else {
-            return Errno::Inval;
+            return Ok(Errno::Inval);
         }
     }
 
-    Errno::Success
+    Ok(Errno::Success)
 }
diff --git a/lib/wasix/src/syscalls/wasi/path_remove_directory.rs b/lib/wasix/src/syscalls/wasi/path_remove_directory.rs
index 2fc0fe2fec..4419bb0a83 100644
--- a/lib/wasix/src/syscalls/wasi/path_remove_directory.rs
+++ b/lib/wasix/src/syscalls/wasi/path_remove_directory.rs
@@ -1,36 +1,32 @@
+use std::fs;
+
 use super::*;
 use crate::syscalls::*;
 
 /// Returns Errno::Notemtpy if directory is not empty
-#[instrument(level = "debug", skip_all, fields(%fd, path = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(%fd, path = field::Empty), ret)]
 pub fn path_remove_directory<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     fd: WasiFd,
     path: WasmPtr<u8, M>,
     path_len: M::Offset,
-) -> Errno {
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     // TODO check if fd is a dir, ensure it's within sandbox, etc.
     let env = ctx.data();
     let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
 
-    let base_dir = wasi_try!(state.fs.get_fd(fd));
-    let mut path_str = unsafe { get_input_str!(&memory, path, path_len) };
+    let base_dir = wasi_try_ok!(state.fs.get_fd(fd));
+    let path_str = unsafe { get_input_str_ok!(&memory, path, path_len) };
     Span::current().record("path", path_str.as_str());
 
-    // Convert relative paths into absolute paths
-    if path_str.starts_with("./") {
-        path_str = ctx.data().state.fs.relative_path_to_absolute(path_str);
-        trace!(
-            %path_str
-        );
-    }
-
-    wasi_try!(path_remove_directory_internal(&mut ctx, fd, &path_str));
+    wasi_try_ok!(path_remove_directory_internal(&mut ctx, fd, &path_str));
     let env = ctx.data();
 
     #[cfg(feature = "journal")]
     if env.enable_journal {
-        wasi_try!(
+        wasi_try_ok!(
             JournalEffector::save_path_remove_directory(&mut ctx, fd, path_str).map_err(|err| {
                 tracing::error!("failed to save remove directory event - {}", err);
                 Errno::Fault
@@ -38,7 +34,7 @@ pub fn path_remove_directory<M: MemorySize>(
         )
     }
 
-    Errno::Success
+    Ok(Errno::Success)
 }
 
 pub(crate) fn path_remove_directory_internal(
@@ -50,123 +46,54 @@ pub(crate) fn path_remove_directory_internal(
     let (memory, state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
     let working_dir = state.fs.get_fd(fd)?;
 
-    let path = std::path::PathBuf::from(path);
-    let path_vec = path
-        .components()
-        .map(|comp| {
-            comp.as_os_str()
-                .to_str()
-                .map(|inner_str| inner_str.to_string())
-                .ok_or(Errno::Inval)
-        })
-        .collect::<Result<Vec<String>, Errno>>()?;
-    if path_vec.is_empty() {
-        trace!("path vector is invalid (its empty)");
-        return Err(Errno::Inval);
-    }
-
-    let (child, parent) = path_vec.split_last().unwrap();
-
-    // if path only contains one component (the root), operation is not permitted
-    if child.is_empty() {
-        return Err(Errno::Access);
-    }
-
-    let mut cur_dir_inode = working_dir.inode;
-    for comp in path_vec.iter() {
-        let processing_cur_dir_inode = cur_dir_inode.clone();
-        let mut guard = processing_cur_dir_inode.write();
-        match guard.deref_mut() {
-            Kind::Dir {
-                ref mut entries,
-                path,
-                parent,
-            } => {
-                match comp.borrow() {
-                    ".." => {
-                        if let Some(p) = parent.upgrade() {
-                            cur_dir_inode = p;
-                            continue;
-                        }
-                    }
-                    "." => continue,
-                    _ => (),
+    let (parent_inode, dir_name) =
+        state
+            .fs
+            .get_parent_inode_at_path(inodes, fd, Path::new(path), true)?;
+
+    let mut guard = parent_inode.write();
+    match guard.deref_mut() {
+        Kind::Dir {
+            entries: ref mut parent_entries,
+            ..
+        } => {
+            let Some(child_inode) = parent_entries.get(&dir_name) else {
+                return Err(Errno::Noent);
+            };
+
+            {
+                let Kind::Dir {
+                    entries: ref child_entries,
+                    path: ref child_path,
+                    ..
+                } = *child_inode.read()
+                else {
+                    return Err(Errno::Notdir);
+                };
+
+                if !child_entries.is_empty() {
+                    return Err(Errno::Notempty);
                 }
-                if let Some(child) = entries.get(comp) {
-                    cur_dir_inode = child.clone();
-                } else {
-                    let parent_path = path.clone();
-                    let mut adjusted_path = path.clone();
-                    drop(guard);
-
-                    // TODO: double check this doesn't risk breaking the sandbox
-                    adjusted_path.push(comp);
-                    if let Ok(adjusted_path_stat) = path_filestat_get_internal(
-                        &memory,
-                        state,
-                        inodes,
-                        fd,
-                        0,
-                        &adjusted_path.to_string_lossy(),
-                    ) {
-                        if adjusted_path_stat.st_filetype != Filetype::Directory {
-                            trace!("path is not a directory");
-                            return Err(Errno::Notdir);
-                        }
-                    } else {
-                        return Err(Errno::Noent);
-                    }
-                    let kind = Kind::Dir {
-                        parent: cur_dir_inode.downgrade(),
-                        path: adjusted_path,
-                        entries: Default::default(),
-                    };
-                    let new_inode = state
-                        .fs
-                        .create_inode(inodes, kind, false, comp.to_string())?;
 
-                    // reborrow to insert
-                    {
-                        let mut guard = cur_dir_inode.write();
-                        if let Kind::Dir {
-                            ref mut entries, ..
-                        } = guard.deref_mut()
-                        {
-                            entries.insert(comp.to_string(), new_inode.clone());
-                        }
-                    }
-                    cur_dir_inode = new_inode;
+                if let Err(e) = state.fs_remove_dir(child_path) {
+                    tracing::warn!(path = ?child_path, error = ?e, "failed to remove directory");
+                    return Err(e);
                 }
             }
-            Kind::Root { .. } => {
-                trace!("the root node can no create a directory");
-                return Err(Errno::Access);
-            }
-            _ => {
-                trace!("path is not a directory");
-                return Err(Errno::Notdir);
-            }
-        }
-    }
-
-    if let Kind::Dir {
-        parent,
-        path: child_path,
-        entries,
-    } = cur_dir_inode.write().deref_mut()
-    {
-        let parent = parent.upgrade().ok_or(Errno::Noent)?;
 
-        if let Kind::Dir { entries, .. } = parent.write().deref_mut() {
-            let child_inode = entries.remove(child).ok_or(Errno::Noent)?;
+            parent_entries.remove(&dir_name).expect(
+                "Entry should exist since we checked before and have an exclusive write lock",
+            );
 
-            if let Err(e) = state.fs_remove_dir(&child_path) {
-                tracing::warn!(path = ?child_path, error = ?e, "failed to remove directory");
-            }
+            Ok(())
+        }
+        Kind::Root { .. } => {
+            trace!("directories directly in the root node can not be removed");
+            Err(Errno::Access)
+        }
+        _ => {
+            trace!("path is not a directory");
+            Err(Errno::Notdir)
         }
-
-        drop(parent)
     }
-
-    Ok(())
 }
diff --git a/lib/wasix/src/syscalls/wasi/path_rename.rs b/lib/wasix/src/syscalls/wasi/path_rename.rs
index 147c8f209a..bd880afb2e 100644
--- a/lib/wasix/src/syscalls/wasi/path_rename.rs
+++ b/lib/wasix/src/syscalls/wasi/path_rename.rs
@@ -1,3 +1,7 @@
+use std::path::PathBuf;
+
+use anyhow::Context;
+
 use super::*;
 use crate::syscalls::*;
 
@@ -16,7 +20,7 @@ use crate::syscalls::*;
 ///     Pointer to UTF8 bytes, the new file name
 /// - `u32 new_path_len`
 ///     The number of bytes to read from `new_path`
-#[instrument(level = "debug", skip_all, fields(%old_fd, %new_fd, old_path = field::Empty, new_path = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(%old_fd, %new_fd, old_path = field::Empty, new_path = field::Empty), ret)]
 pub fn path_rename<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     old_fd: WasiFd,
@@ -26,14 +30,14 @@ pub fn path_rename<M: MemorySize>(
     new_path: WasmPtr<u8, M>,
     new_path_len: M::Offset,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
-    let mut source_str = unsafe { get_input_str_ok!(&memory, old_path, old_path_len) };
+    let source_str = unsafe { get_input_str_ok!(&memory, old_path, old_path_len) };
     Span::current().record("old_path", source_str.as_str());
-    source_str = ctx.data().state.fs.relative_path_to_absolute(source_str);
-    let mut target_str = unsafe { get_input_str_ok!(&memory, new_path, new_path_len) };
+    let target_str = unsafe { get_input_str_ok!(&memory, new_path, new_path_len) };
     Span::current().record("new_path", target_str.as_str());
-    target_str = ctx.data().state.fs.relative_path_to_absolute(target_str);
 
     let ret = path_rename_internal(&mut ctx, old_fd, &source_str, new_fd, &target_str)?;
     let env = ctx.data();
@@ -44,7 +48,7 @@ pub fn path_rename<M: MemorySize>(
             JournalEffector::save_path_rename(&mut ctx, old_fd, source_str, new_fd, target_str)
                 .map_err(|err| {
                     tracing::error!("failed to save path rename event - {}", err);
-                    WasiError::Exit(ExitCode::Errno(Errno::Fault))
+                    WasiError::Exit(ExitCode::from(Errno::Fault))
                 })?;
         }
     }
@@ -63,16 +67,16 @@ pub fn path_rename_internal(
 
     {
         let source_fd = wasi_try_ok!(state.fs.get_fd(source_fd));
-        if !source_fd.rights.contains(Rights::PATH_RENAME_SOURCE) {
+        if !source_fd.inner.rights.contains(Rights::PATH_RENAME_SOURCE) {
             return Ok(Errno::Access);
         }
         let target_fd = wasi_try_ok!(state.fs.get_fd(target_fd));
-        if !target_fd.rights.contains(Rights::PATH_RENAME_TARGET) {
+        if !target_fd.inner.rights.contains(Rights::PATH_RENAME_TARGET) {
             return Ok(Errno::Access);
         }
     }
 
-    // this is to be sure the source file is fetch from filesystem if needed
+    // this is to be sure the source file is fetched from the filesystem if needed
     wasi_try_ok!(state
         .fs
         .get_inode_at_path(inodes, source_fd, source_path, true));
@@ -100,13 +104,13 @@ pub fn path_rename_internal(
                 if entries.contains_key(&target_entry_name) {
                     need_create = false;
                 }
-                let mut out_path = path.clone();
-                out_path.push(std::path::Path::new(&target_entry_name));
-                out_path
+                path.join(&target_entry_name)
             }
             Kind::Root { .. } => return Ok(Errno::Notcapable),
             Kind::Socket { .. }
-            | Kind::Pipe { .. }
+            | Kind::PipeTx { .. }
+            | Kind::PipeRx { .. }
+            | Kind::DuplexPipe { .. }
             | Kind::EventNotifications { .. }
             | Kind::Epoll { .. } => return Ok(Errno::Inval),
             Kind::Symlink { .. } | Kind::File { .. } | Kind::Buffer { .. } => {
@@ -124,7 +128,9 @@ pub fn path_rename_internal(
             }
             Kind::Root { .. } => return Ok(Errno::Notcapable),
             Kind::Socket { .. }
-            | Kind::Pipe { .. }
+            | Kind::PipeRx { .. }
+            | Kind::PipeTx { .. }
+            | Kind::DuplexPipe { .. }
             | Kind::EventNotifications { .. }
             | Kind::Epoll { .. } => {
                 return Ok(Errno::Inval);
@@ -159,13 +165,11 @@ pub fn path_rename_internal(
                         return Ok(e);
                     }
                 } else {
-                    {
-                        let mut guard = source_entry.write();
-                        if let Kind::File { ref mut path, .. } = guard.deref_mut() {
-                            *path = host_adjusted_target_path;
-                        } else {
-                            unreachable!()
-                        }
+                    let mut guard = source_entry.write();
+                    if let Kind::File { ref mut path, .. } = guard.deref_mut() {
+                        *path = host_adjusted_target_path;
+                    } else {
+                        unreachable!()
                     }
                 }
             }
@@ -184,27 +188,29 @@ pub fn path_rename_internal(
                     return Ok(e);
                 }
                 {
+                    let source_dir_path = path.clone();
                     drop(guard);
-                    let mut guard = source_entry.write();
-                    if let Kind::Dir { path, .. } = guard.deref_mut() {
-                        *path = host_adjusted_target_path;
-                    }
+                    rename_inode_tree(&source_entry, &source_dir_path, &host_adjusted_target_path);
                 }
             }
-            Kind::Buffer { .. } => {}
-            Kind::Symlink { .. } => {}
-            Kind::Socket { .. } => {}
-            Kind::Pipe { .. } => {}
-            Kind::Epoll { .. } => {}
-            Kind::EventNotifications { .. } => {}
+            Kind::Buffer { .. }
+            | Kind::Symlink { .. }
+            | Kind::Socket { .. }
+            | Kind::PipeTx { .. }
+            | Kind::PipeRx { .. }
+            | Kind::DuplexPipe { .. }
+            | Kind::Epoll { .. }
+            | Kind::EventNotifications { .. } => {}
             Kind::Root { .. } => unreachable!("The root can not be moved"),
         }
     }
 
+    let source_size = source_entry.stat.read().unwrap().st_size;
+
     if need_create {
         let mut guard = target_parent_inode.write();
         if let Kind::Dir { entries, .. } = guard.deref_mut() {
-            let result = entries.insert(target_entry_name, source_entry);
+            let result = entries.insert(target_entry_name.clone(), source_entry);
             assert!(
                 result.is_none(),
                 "fatal error: race condition on filesystem detected or internal logic error"
@@ -212,5 +218,47 @@ pub fn path_rename_internal(
         }
     }
 
+    // The target entry is created, one way or the other
+    let target_inode = state
+        .fs
+        .get_inode_at_path(inodes, target_fd, target_path, true)
+        .expect("Expected target inode to exist, and it's too late to safely fail");
+    *target_inode.name.write().unwrap() = target_entry_name.into();
+    target_inode.stat.write().unwrap().st_size = source_size;
+
     Ok(Errno::Success)
 }
+
+fn rename_inode_tree(inode: &InodeGuard, source_dir_path: &Path, target_dir_path: &Path) {
+    let children;
+
+    let mut guard = inode.write();
+    match guard.deref_mut() {
+        Kind::File { ref mut path, .. } => {
+            *path = adjust_path(path, source_dir_path, target_dir_path);
+            return;
+        }
+        Kind::Dir {
+            ref mut path,
+            entries,
+            ..
+        } => {
+            *path = adjust_path(path, source_dir_path, target_dir_path);
+            children = entries.values().cloned().collect::<Vec<_>>();
+        }
+        _ => return,
+    }
+    drop(guard);
+
+    for child in children {
+        rename_inode_tree(&child, source_dir_path, target_dir_path);
+    }
+}
+
+fn adjust_path(path: &Path, source_dir_path: &Path, target_dir_path: &Path) -> PathBuf {
+    let relative_path = path
+        .strip_prefix(source_dir_path)
+        .with_context(|| format!("Expected path {path:?} to be a subpath of {source_dir_path:?}"))
+        .expect("Fatal filesystem error");
+    target_dir_path.join(relative_path)
+}
diff --git a/lib/wasix/src/syscalls/wasi/path_symlink.rs b/lib/wasix/src/syscalls/wasi/path_symlink.rs
index 66a4598877..4fa7e3b9f4 100644
--- a/lib/wasix/src/syscalls/wasi/path_symlink.rs
+++ b/lib/wasix/src/syscalls/wasi/path_symlink.rs
@@ -14,7 +14,7 @@ use crate::syscalls::*;
 ///     Array of UTF-8 bytes representing the target path
 /// - `u32 new_path_len`
 ///     The number of bytes to read from `new_path`
-#[instrument(level = "debug", skip_all, fields(%fd, old_path = field::Empty, new_path = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(%fd, old_path = field::Empty, new_path = field::Empty), ret)]
 pub fn path_symlink<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     old_path: WasmPtr<u8, M>,
@@ -23,14 +23,14 @@ pub fn path_symlink<M: MemorySize>(
     new_path: WasmPtr<u8, M>,
     new_path_len: M::Offset,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
-    let mut old_path_str = unsafe { get_input_str_ok!(&memory, old_path, old_path_len) };
+    let old_path_str = unsafe { get_input_str_ok!(&memory, old_path, old_path_len) };
     Span::current().record("old_path", old_path_str.as_str());
-    let mut new_path_str = unsafe { get_input_str_ok!(&memory, new_path, new_path_len) };
+    let new_path_str = unsafe { get_input_str_ok!(&memory, new_path, new_path_len) };
     Span::current().record("new_path", new_path_str.as_str());
-    old_path_str = ctx.data().state.fs.relative_path_to_absolute(old_path_str);
-    new_path_str = ctx.data().state.fs.relative_path_to_absolute(new_path_str);
 
     wasi_try_ok!(path_symlink_internal(
         &mut ctx,
@@ -45,7 +45,7 @@ pub fn path_symlink<M: MemorySize>(
         JournalEffector::save_path_symlink(&mut ctx, old_path_str, fd, new_path_str).map_err(
             |err| {
                 tracing::error!("failed to save path symbolic link event - {}", err);
-                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+                WasiError::Exit(ExitCode::from(Errno::Fault))
             },
         )?;
     }
@@ -63,7 +63,7 @@ pub fn path_symlink_internal(
     let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
 
     let base_fd = state.fs.get_fd(fd)?;
-    if !base_fd.rights.contains(Rights::PATH_SYMLINK) {
+    if !base_fd.inner.rights.contains(Rights::PATH_SYMLINK) {
         return Err(Errno::Access);
     }
 
@@ -97,7 +97,9 @@ pub fn path_symlink_internal(
             }
             Kind::Root { .. } => return Err(Errno::Notcapable),
             Kind::Socket { .. }
-            | Kind::Pipe { .. }
+            | Kind::PipeRx { .. }
+            | Kind::PipeTx { .. }
+            | Kind::DuplexPipe { .. }
             | Kind::EventNotifications { .. }
             | Kind::Epoll { .. } => return Err(Errno::Inval),
             Kind::File { .. } | Kind::Symlink { .. } | Kind::Buffer { .. } => {
diff --git a/lib/wasix/src/syscalls/wasi/path_unlink_file.rs b/lib/wasix/src/syscalls/wasi/path_unlink_file.rs
index c79a5812c3..12d0fb2db7 100644
--- a/lib/wasix/src/syscalls/wasi/path_unlink_file.rs
+++ b/lib/wasix/src/syscalls/wasi/path_unlink_file.rs
@@ -10,28 +10,25 @@ use crate::syscalls::*;
 ///     Array of UTF-8 bytes representing the path
 /// - `u32 path_len`
 ///     The number of bytes in the `path` array
-#[instrument(level = "debug", skip_all, fields(%fd, path = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(%fd, path = field::Empty), ret)]
 pub fn path_unlink_file<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     fd: WasiFd,
     path: WasmPtr<u8, M>,
     path_len: M::Offset,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
 
     let base_dir = wasi_try_ok!(state.fs.get_fd(fd));
-    if !base_dir.rights.contains(Rights::PATH_UNLINK_FILE) {
+    if !base_dir.inner.rights.contains(Rights::PATH_UNLINK_FILE) {
         return Ok(Errno::Access);
     }
-    let mut path_str = unsafe { get_input_str_ok!(&memory, path, path_len) };
+    let path_str = unsafe { get_input_str_ok!(&memory, path, path_len) };
     Span::current().record("path", path_str.as_str());
 
-    // Convert relative paths into absolute paths
-    if path_str.starts_with("./") {
-        path_str = ctx.data().state.fs.relative_path_to_absolute(path_str);
-    }
-
     let ret = path_unlink_file_internal(&mut ctx, fd, &path_str)?;
     let env = ctx.data();
 
diff --git a/lib/wasix/src/syscalls/wasi/poll_oneoff.rs b/lib/wasix/src/syscalls/wasi/poll_oneoff.rs
index dddf274c0a..5466fc419a 100644
--- a/lib/wasix/src/syscalls/wasi/poll_oneoff.rs
+++ b/lib/wasix/src/syscalls/wasi/poll_oneoff.rs
@@ -44,6 +44,7 @@ impl EventResult {
 
 /// ### `poll_oneoff()`
 /// Concurrently poll for a set of events
+///
 /// Inputs:
 /// - `const __wasi_subscription_t *in`
 ///     The events to subscribe to
@@ -51,10 +52,11 @@ impl EventResult {
 ///     The events that have occured
 /// - `u32 nsubscriptions`
 ///     The number of subscriptions and the number of events
+///
 /// Output:
 /// - `u32 nevents`
 ///     The number of events seen
-//#[instrument(level = "trace", skip_all, fields(timeout_ms = field::Empty, fd_guards = field::Empty, seen = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(timeout_ms = field::Empty, fd_guards = field::Empty, seen = field::Empty), ret)]
 pub fn poll_oneoff<M: MemorySize + 'static>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     in_: WasmPtr<Subscription, M>,
@@ -62,7 +64,7 @@ pub fn poll_oneoff<M: MemorySize + 'static>(
     nsubscriptions: M::Offset,
     nevents: WasmPtr<M::Offset, M>,
 ) -> Result<Errno, WasiError> {
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+    WasiEnv::do_pending_operations(&mut ctx)?;
 
     ctx = wasi_try_ok!(maybe_backoff::<M>(ctx)?);
     ctx = wasi_try_ok!(maybe_snapshot::<M>(ctx)?);
@@ -95,7 +97,7 @@ pub fn poll_oneoff<M: MemorySize + 'static>(
             wasi_try_mem!(event_array.index(events_seen as u64).write(event));
             events_seen += 1;
         }
-        let events_seen: M::Offset = wasi_try!(events_seen.try_into().map_err(|_| Errno::Overflow));
+        let events_seen: M::Offset = events_seen.into();
         let out_ptr = nevents.deref(&memory);
         wasi_try_mem!(out_ptr.write(events_seen));
         Errno::Success
@@ -177,7 +179,7 @@ pub(crate) fn poll_fd_guard(
             .map_err(fs_error_into_wasi_err)?,
         _ => {
             let fd_entry = state.fs.get_fd(fd)?;
-            if !fd_entry.rights.contains(Rights::POLL_FD_READWRITE) {
+            if !fd_entry.inner.rights.contains(Rights::POLL_FD_READWRITE) {
                 return Err(Errno::Access);
             }
             let inode = fd_entry.inode;
@@ -198,6 +200,7 @@ pub(crate) fn poll_fd_guard(
 
 /// ### `poll_oneoff()`
 /// Concurrently poll for a set of events
+///
 /// Inputs:
 /// - `const __wasi_subscription_t *in`
 ///     The events to subscribe to
@@ -205,6 +208,7 @@ pub(crate) fn poll_fd_guard(
 ///     The events that have occured
 /// - `u32 nsubscriptions`
 ///     The number of subscriptions and the number of events
+///
 /// Output:
 /// - `u32 nevents`
 ///     The number of events seen
@@ -216,8 +220,6 @@ pub(crate) fn poll_oneoff_internal<'a, M: MemorySize, After>(
 where
     After: FnOnce(&FunctionEnvMut<'a, WasiEnv>, Vec<Event>) -> Errno,
 {
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
-
     let pid = ctx.data().pid();
     let tid = ctx.data().tid();
     let subs_len = subs.len();
@@ -252,7 +254,9 @@ where
                             Ok(a) => a,
                             Err(err) => return Ok(err),
                         };
-                        if !fd_entry.rights.contains(Rights::POLL_FD_READWRITE) {
+                        if !(fd_entry.inner.rights.contains(Rights::POLL_FD_READWRITE)
+                            && fd_entry.inner.rights.contains(Rights::FD_READ))
+                        {
                             return Ok(Errno::Access);
                         }
                     }
@@ -270,7 +274,9 @@ where
                             Ok(a) => a,
                             Err(err) => return Ok(err),
                         };
-                        if !fd_entry.rights.contains(Rights::POLL_FD_READWRITE) {
+                        if !(fd_entry.inner.rights.contains(Rights::POLL_FD_READWRITE)
+                            && fd_entry.inner.rights.contains(Rights::FD_WRITE))
+                        {
                             return Ok(Errno::Access);
                         }
                     }
@@ -353,9 +359,9 @@ where
 
             if fd_guards.len() > 10 {
                 let small_list: Vec<_> = fd_guards.iter().take(10).collect();
-                tracing::Span::current().record("fd_guards", format!("{:?}...", small_list));
+                tracing::Span::current().record("fd_guards", format!("{small_list:?}..."));
             } else {
-                tracing::Span::current().record("fd_guards", format!("{:?}", fd_guards));
+                tracing::Span::current().record("fd_guards", format!("{fd_guards:?}"));
             }
 
             fd_guards
@@ -387,7 +393,7 @@ where
         |ctx: &FunctionEnvMut<'a, WasiEnv>| {
             // The timeout has triggered so lets add that event
             if clock_subs.is_empty() {
-                tracing::warn!("triggered_timeout (without any clock subscriptions)",);
+                tracing::warn!("triggered_timeout (without any clock subscriptions)");
             }
             let mut evts = Vec::new();
             for (clock_info, userdata) in clock_subs {
@@ -399,7 +405,7 @@ where
                 };
                 Span::current().record(
                     "seen",
-                    &format!(
+                    format!(
                         "clock(id={},userdata={})",
                         clock_info.clock_id as u32, evt.userdata
                     ),
@@ -451,9 +457,9 @@ where
                 Ok(evts) => {
                     // If its a timeout then return an event for it
                     if evts.len() == 1 {
-                        Span::current().record("seen", &format!("{:?}", evts.first().unwrap()));
+                        Span::current().record("seen", format!("{:?}", evts.first().unwrap()));
                     } else {
-                        Span::current().record("seen", &format!("trigger_cnt=({})", evts.len()));
+                        Span::current().record("seen", format!("trigger_cnt=({})", evts.len()));
                     }
 
                     // Process the events
diff --git a/lib/wasix/src/syscalls/wasi/proc_exit.rs b/lib/wasix/src/syscalls/wasi/proc_exit.rs
index 58b83d54b4..fadb46b0d2 100644
--- a/lib/wasix/src/syscalls/wasi/proc_exit.rs
+++ b/lib/wasix/src/syscalls/wasi/proc_exit.rs
@@ -8,15 +8,31 @@ use crate::syscalls::*;
 /// Inputs:
 /// - `ExitCode`
 ///   Exit code to return to the operating system
-#[instrument(level = "debug", skip_all)]
+#[instrument(level = "trace", skip_all)]
 pub fn proc_exit<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     code: ExitCode,
 ) -> Result<(), WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     debug!(%code);
 
     // If we are in a vfork we need to return to the point we left off
     if let Some(mut vfork) = ctx.data_mut().vfork.take() {
+        tracing::debug!(
+            parent_pid = %vfork.env.process.pid(),
+            child_pid = %ctx.data().process.pid(),
+            "proc_exit from vfork, returning control to parent process"
+        );
+
+        // Prepare the child env for teardown by closing its FDs
+        InlineWaker::block_on(
+            unsafe { ctx.data().get_memory_and_wasi_state(&ctx, 0) }
+                .1
+                .fs
+                .close_all(),
+        );
+
         // Restore the WasiEnv to the point when we vforked
         vfork.env.swap_inner(ctx.data_mut());
         std::mem::swap(vfork.env.as_mut(), ctx.data_mut());
@@ -28,14 +44,13 @@ pub fn proc_exit<M: MemorySize>(
 
         // Jump back to the vfork point and current on execution
         let child_pid = child_env.process.pid();
-        let memory_stack = vfork.memory_stack.freeze();
         let rewind_stack = vfork.rewind_stack.freeze();
         let store_data = vfork.store_data;
         unwind::<M, _>(ctx, move |mut ctx, _, _| {
             // Now rewind the previous stack and carry on from where we did the vfork
             match rewind::<M, _>(
                 ctx,
-                memory_stack,
+                None,
                 rewind_stack,
                 store_data,
                 ForkResult {
diff --git a/lib/wasix/src/syscalls/wasi/proc_raise.rs b/lib/wasix/src/syscalls/wasi/proc_raise.rs
index 6cd8cdf9f0..fec04deee2 100644
--- a/lib/wasix/src/syscalls/wasi/proc_raise.rs
+++ b/lib/wasix/src/syscalls/wasi/proc_raise.rs
@@ -7,12 +7,12 @@ use crate::syscalls::*;
 /// Inputs:
 /// - `Signal`
 ///   Signal to be raised for this process
-#[instrument(level = "debug", skip_all, fields(sig), ret)]
+#[instrument(level = "trace", skip_all, fields(sig), ret)]
 pub fn proc_raise(mut ctx: FunctionEnvMut<'_, WasiEnv>, sig: Signal) -> Result<Errno, WasiError> {
     let env = ctx.data();
     env.process.signal_process(sig);
 
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+    WasiEnv::do_pending_operations(&mut ctx)?;
 
     Ok(Errno::Success)
 }
@@ -37,7 +37,7 @@ pub fn proc_raise_interval(
     let repeat = matches!(repeat, Bool::True);
     env.process.signal_interval(sig, interval, repeat);
 
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+    WasiEnv::do_pending_operations(&mut ctx)?;
 
     Ok(Errno::Success)
 }
diff --git a/lib/wasix/src/syscalls/wasi/thread_spawn.rs b/lib/wasix/src/syscalls/wasi/thread_spawn.rs
index be8e9de02a..36b81e3a29 100644
--- a/lib/wasix/src/syscalls/wasi/thread_spawn.rs
+++ b/lib/wasix/src/syscalls/wasi/thread_spawn.rs
@@ -16,7 +16,7 @@ use wasmer_wasix_types::wasi::ThreadStart;
 ///
 /// Returns the thread index of the newly created thread
 /// (indices always start from the same value as `pid` and increments in steps)
-#[instrument(level = "debug", skip_all, ret)]
+#[instrument(level = "trace", skip_all, ret)]
 pub fn thread_spawn<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     start_ptr: WasmPtr<ThreadStart<M>, M>,
diff --git a/lib/wasix/src/syscalls/wasix/call_dynamic.rs b/lib/wasix/src/syscalls/wasix/call_dynamic.rs
new file mode 100644
index 0000000000..b31387c069
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/call_dynamic.rs
@@ -0,0 +1,191 @@
+use super::*;
+use crate::syscalls::*;
+use wasmer::Type;
+use wasmer::ValueType;
+
+macro_rules! write_value {
+    ($memory:expr, $offset:expr, $max:expr, $strict:expr, $value:expr) => {{
+        let bytes = $value.to_le_bytes();
+        if $offset + bytes.len() as u64 <= $max {
+            $memory.write($offset, &bytes)?;
+            $offset += bytes.len() as u64;
+            Ok(true)
+        } else {
+            Ok(!$strict)
+        }
+    }};
+}
+
+fn write_value(
+    memory: &MemoryView,
+    offset: &mut u64,
+    max: u64,
+    strict: bool,
+    value: &Value,
+) -> Result<bool, MemoryAccessError> {
+    match value {
+        Value::I32(value) => write_value!(memory, *offset, max, strict, value),
+        Value::I64(value) => write_value!(memory, *offset, max, strict, value),
+        Value::F32(value) => write_value!(memory, *offset, max, strict, value),
+        Value::F64(value) => write_value!(memory, *offset, max, strict, value),
+        Value::V128(value) => write_value!(memory, *offset, max, strict, value),
+        // ExternRef, FuncRef, and ExceptionRef cannot be represented as byte slices
+        _ => panic!("Cannot write non-scalar value as bytes"),
+    }
+}
+
+macro_rules! read_value {
+    ($memory:expr, $offset:expr, $max:expr, $strict:expr, $ty:ident, $val:ident, $len:expr) => {{
+        if $offset + $len > $max {
+            Ok(if $strict {
+                None
+            } else {
+                Some(Value::$val($ty::default()))
+            })
+        } else {
+            let mut buffer = [0u8; $len];
+            $memory.read($offset, &mut buffer)?;
+            $offset += $len;
+            Ok(Some(Value::$val($ty::from_le_bytes(buffer))))
+        }
+    }};
+}
+
+fn read_value(
+    memory: &MemoryView,
+    offset: &mut u64,
+    max: u64,
+    strict: bool,
+    ty: &Type,
+) -> Result<Option<Value>, MemoryAccessError> {
+    match ty {
+        Type::I32 => read_value!(memory, *offset, max, strict, i32, I32, 4),
+        Type::I64 => read_value!(memory, *offset, max, strict, i64, I64, 8),
+        Type::F32 => read_value!(memory, *offset, max, strict, f32, F32, 4),
+        Type::F64 => read_value!(memory, *offset, max, strict, f64, F64, 8),
+        Type::V128 => read_value!(memory, *offset, max, strict, u128, V128, 16),
+        // ExternRef, FuncRef, and ExceptionRef cannot be represented as byte slices
+        _ => panic!("Cannot read non-scalar value from memory"),
+    }
+}
+
+fn flatten_runtime_error(err: RuntimeError) -> RuntimeError {
+    let e_ref = err.downcast_ref::<WasiRuntimeError>();
+    match e_ref {
+        Some(WasiRuntimeError::Wasi(_)) => {
+            let Ok(WasiRuntimeError::Wasi(err)) = err.downcast::<WasiRuntimeError>() else {
+                unreachable!()
+            };
+            RuntimeError::user(Box::new(err))
+        }
+        Some(WasiRuntimeError::Runtime(_)) => {
+            let Ok(WasiRuntimeError::Runtime(err)) = err.downcast::<WasiRuntimeError>() else {
+                unreachable!()
+            };
+            flatten_runtime_error(err)
+        }
+        _ => err,
+    }
+}
+
+/// Call a function from the `__indirect_function_table` with parameters and results from memory.
+///
+/// This function can be used to call functions whose types are not known at
+/// compile time of the caller. It is the callers responsibility to ensure
+/// that the passed parameters and results match the signature of the function
+/// beeing called.
+///
+/// ### Format of the values and results buffer
+///
+/// The buffers contain all values sequentially. i32, and f32 are 4 bytes,
+/// i64 and f64 are 8 bytes, v128 is 16 bytes.
+///     
+/// For example if the function takes an i32 and an i64, the values buffer will
+/// be 12 bytes long, with the first 4 bytes being the i32 and the next 8
+/// bytes being the i64.
+///
+/// ### Parameters
+///
+/// * function_id: The indirect function table index of the function to call
+///
+/// * values: Pointer to a sequence of values that will be passed to the function.
+///   The buffer will be interpreted as described above.
+///   If the function does not have any parameters, this can be a nullptr (0).
+///
+/// * results: Pointer to a sequence of values.
+///   If the function does not return a value, this can be a nullptr (0).
+///   The buffer needs to be large enough to hold all return values.
+///
+#[instrument(
+    level = "trace",
+    skip_all,
+    fields(%function_id, values_ptr = values.offset().into(), results_ptr = results.offset().into()),
+    ret
+)]
+#[allow(clippy::result_large_err)]
+pub fn call_dynamic<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    function_id: u32,
+    values: WasmPtr<u8, M>,
+    values_len: M::Offset,
+    results: WasmPtr<u8, M>,
+    results_len: M::Offset,
+    strict: Bool,
+) -> Result<Errno, RuntimeError> {
+    let (env, mut store) = ctx.data_and_store_mut();
+
+    let strict = matches!(strict, Bool::True);
+
+    let function = wasi_try_ok!(env
+        .inner()
+        .indirect_function_table_lookup(&mut store, function_id)
+        .map_err(Errno::from));
+
+    let function_type = function.ty(&store);
+
+    let memory = unsafe { env.memory_view(&store) };
+    let mut current_values_offset: u64 = values.offset().into();
+    let max_values_offset = current_values_offset + values_len.into();
+    let mut values_buffer = vec![];
+    for ty in function_type.params() {
+        let Some(value) = wasi_try_mem_ok!(read_value(
+            &memory,
+            &mut current_values_offset,
+            max_values_offset,
+            strict,
+            ty
+        )) else {
+            return Ok(Errno::Inval);
+        };
+        values_buffer.push(value);
+    }
+
+    if strict && current_values_offset != max_values_offset {
+        // If strict is true, we expect to have read all values
+        return Ok(Errno::Inval);
+    }
+
+    let result_values = function
+        .call(&mut store, values_buffer.as_slice())
+        .map_err(flatten_runtime_error)?;
+
+    let memory = unsafe { env.memory_view(&store) };
+    let mut current_results_offset: u64 = results.offset().into();
+    let max_results_offset = current_results_offset + results_len.into();
+    for result_value in result_values {
+        wasi_try_mem_ok!(write_value(
+            &memory,
+            &mut current_results_offset,
+            max_results_offset,
+            strict,
+            &result_value
+        ));
+    }
+
+    if strict && current_results_offset != max_results_offset {
+        // If strict is true, we expect to have written all results
+        return Ok(Errno::Inval);
+    }
+
+    Ok(Errno::Success)
+}
diff --git a/lib/wasix/src/syscalls/wasix/callback_signal.rs b/lib/wasix/src/syscalls/wasix/callback_signal.rs
index e5dcb80203..940b34d26d 100644
--- a/lib/wasix/src/syscalls/wasix/callback_signal.rs
+++ b/lib/wasix/src/syscalls/wasix/callback_signal.rs
@@ -27,7 +27,9 @@ pub fn callback_signal<M: MemorySize>(
     };
     Span::current().record("name", name.as_str());
 
-    let funct = unsafe { env.inner() }
+    let funct = env
+        .inner()
+        .main_module_instance_handles()
         .instance
         .exports
         .get_typed_function(&ctx, &name)
@@ -35,12 +37,13 @@ pub fn callback_signal<M: MemorySize>(
     Span::current().record("funct_is_some", funct.is_some());
 
     {
-        let mut inner = ctx.data_mut().try_inner_mut().unwrap();
+        let mut env_inner = ctx.data_mut().inner_mut();
+        let inner = env_inner.main_module_instance_handles_mut();
         inner.signal = funct;
         inner.signal_set = true;
     }
 
-    let _ = unsafe { WasiEnv::process_signals_and_exit(&mut ctx)? };
+    WasiEnv::do_pending_operations(&mut ctx)?;
 
     Ok(())
 }
diff --git a/lib/wasix/src/syscalls/wasix/chdir.rs b/lib/wasix/src/syscalls/wasix/chdir.rs
index beb4b93a75..e7e5018d4d 100644
--- a/lib/wasix/src/syscalls/wasix/chdir.rs
+++ b/lib/wasix/src/syscalls/wasix/chdir.rs
@@ -3,34 +3,35 @@ use crate::syscalls::*;
 
 /// ### `chdir()`
 /// Sets the current working directory
-#[instrument(level = "debug", skip_all, fields(name = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(name = field::Empty), ret)]
 pub fn chdir<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     path: WasmPtr<u8, M>,
     path_len: M::Offset,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let (memory, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
     let path = unsafe { get_input_str_ok!(&memory, path, path_len) };
     Span::current().record("path", path.as_str());
 
-    wasi_try_ok!(chdir_internal(&mut ctx, &path,));
+    wasi_try_ok!(chdir_internal(ctx.data(), &path));
     let env = ctx.data();
 
     #[cfg(feature = "journal")]
     if env.enable_journal {
         JournalEffector::save_chdir(&mut ctx, path).map_err(|err| {
             tracing::error!("failed to chdir event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
     Ok(Errno::Success)
 }
 
-pub fn chdir_internal(ctx: &mut FunctionEnvMut<'_, WasiEnv>, path: &str) -> Result<(), Errno> {
-    let env = ctx.data();
-    let (memory, mut state) = unsafe { env.get_memory_and_wasi_state(ctx, 0) };
+pub fn chdir_internal(env: &WasiEnv, path: &str) -> Result<(), Errno> {
+    let state = &env.state;
 
     // Check if the directory exists
     if state.fs.root_fs.read_dir(Path::new(path)).is_err() {
diff --git a/lib/wasix/src/syscalls/wasix/closure_allocate.rs b/lib/wasix/src/syscalls/wasix/closure_allocate.rs
new file mode 100644
index 0000000000..9c1f1b2673
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/closure_allocate.rs
@@ -0,0 +1,34 @@
+use crate::syscalls::*;
+
+/// Allocate a new slot in the __indirect_function_table for a closure
+///
+/// Until the slot is prepared with [`closure_prepare`], it is undefined behavior to call the function at the given index.
+///
+/// The slot should be freed with [`closure_free`] when it is no longer needed.
+#[instrument(level = "trace", skip_all, ret)]
+pub fn closure_allocate<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    closure: WasmPtr<u32, M>,
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    let (env, mut store) = ctx.data_and_store_mut();
+    let Some(linker) = env.inner().linker().cloned() else {
+        error!("Closures only work for dynamic modules.");
+        return Ok(Errno::Notsup);
+    };
+
+    let function_id = match linker.allocate_closure_index(&mut ctx) {
+        Ok(f) => f,
+        Err(e) => {
+            // Should never happen
+            error!("Failed to allocate closure index: {e}");
+            return Ok(Errno::Fault);
+        }
+    };
+
+    let (env, mut store) = ctx.data_and_store_mut();
+    let memory = unsafe { env.memory_view(&store) };
+    closure.write(&memory, function_id);
+    return Ok(Errno::Success);
+}
diff --git a/lib/wasix/src/syscalls/wasix/closure_free.rs b/lib/wasix/src/syscalls/wasix/closure_free.rs
new file mode 100644
index 0000000000..ce54eb0fce
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/closure_free.rs
@@ -0,0 +1,27 @@
+use crate::syscalls::*;
+
+/// Free a previously allocated slot for a closure in the `__indirect_function_table`
+///
+/// After calling this it is undefined behavior to call the function at the given index.
+#[instrument(level = "trace", fields(%closure), ret)]
+pub fn closure_free(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    closure: u32,
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    let (env, mut store) = ctx.data_and_store_mut();
+
+    let Some(linker) = env.inner().linker().cloned() else {
+        error!("Closures only work for dynamic modules.");
+        return Ok(Errno::Notsup);
+    };
+
+    let free_result = linker.free_closure_index(&mut ctx, closure);
+    if let Err(e) = free_result {
+        // Should never happen
+        panic!("Failed to free closure index: {e}");
+    }
+
+    return Ok(Errno::Success);
+}
diff --git a/lib/wasix/src/syscalls/wasix/closure_prepare.rs b/lib/wasix/src/syscalls/wasix/closure_prepare.rs
new file mode 100644
index 0000000000..8e81d50ec1
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/closure_prepare.rs
@@ -0,0 +1,389 @@
+//! Closures provide a way to generate a WASM function that wraps a generic function and an environment.
+//!
+//! A typical usage of this API is as follows:
+//!
+//! 1. Allocate a function pointer for your closure with [`closure_allocate`]
+//! 2. Prepare the closure with [`closure_prepare`]
+//! 3. Call function pointer
+//! 4. Call [`closure_prepare`] again to redefine the function pointer
+//! 5. Notify wasmer that the closure is no longer needed with [`closure_free`]
+
+use crate::{state::DlModuleSpec, syscalls::*};
+use std::{path::PathBuf, sync::atomic::AtomicUsize};
+use wasm_encoder::{
+    CodeSection, CustomSection, ExportKind, ExportSection, FunctionSection, GlobalType,
+    ImportSection, InstructionSink, MemArg, MemoryType, RefType, TableType, TypeSection, ValType,
+};
+use wasmer::{imports, FunctionType, Table, Type};
+
+use wasmer_wasix_types::wasi::WasmValueType;
+
+// Implement helper functions for wasm_encoder::ValType
+trait ValTypeOps
+where
+    Self: Sized,
+{
+    fn from_u8(value: u8) -> Result<Self, Errno>;
+    fn size(&self) -> u64;
+    fn store(&self, sink: &mut InstructionSink<'_>, offset: u64, memory_index: u32);
+    fn load(&self, sink: &mut InstructionSink<'_>, offset: u64, memory_index: u32);
+}
+impl ValTypeOps for ValType {
+    fn from_u8(value: u8) -> Result<Self, Errno> {
+        let wasix_type = WasmValueType::try_from(value).map_err(|_| Errno::Inval)?;
+        match wasix_type {
+            WasmValueType::I32 => Ok(Self::I32),
+            WasmValueType::I64 => Ok(Self::I64),
+            WasmValueType::F32 => Ok(Self::F32),
+            WasmValueType::F64 => Ok(Self::F64),
+            WasmValueType::V128 => Ok(Self::V128),
+        }
+    }
+    fn size(&self) -> u64 {
+        match self {
+            Self::I32 => 4,
+            Self::I64 => 8,
+            Self::F32 => 4,
+            Self::F64 => 8,
+            Self::V128 => 16,
+            // Not supported in closures.
+            Self::Ref(_) => panic!("Cannot get size of reference type"),
+        }
+    }
+    fn store(&self, sink: &mut InstructionSink<'_>, offset: u64, memory_index: u32) {
+        match self {
+            Self::I32 => sink.i32_store(MemArg {
+                offset,
+                align: 0,
+                memory_index,
+            }),
+            Self::I64 => sink.i64_store(MemArg {
+                offset,
+                align: 0,
+                memory_index,
+            }),
+            Self::F32 => sink.f32_store(MemArg {
+                offset,
+                align: 0,
+                memory_index,
+            }),
+            Self::F64 => sink.f64_store(MemArg {
+                offset,
+                align: 0,
+                memory_index,
+            }),
+            Self::V128 => sink.v128_store(MemArg {
+                offset,
+                align: 0,
+                memory_index,
+            }),
+            // Not supported in closures
+            Self::Ref(_) => panic!("Cannot store reference type"),
+        };
+    }
+    fn load(&self, sink: &mut InstructionSink<'_>, offset: u64, memory_index: u32) {
+        match self {
+            Self::I32 => sink.i32_load(MemArg {
+                offset,
+                align: 0,
+                memory_index,
+            }),
+            Self::I64 => sink.i64_load(MemArg {
+                offset,
+                align: 0,
+                memory_index,
+            }),
+            Self::F32 => sink.f32_load(MemArg {
+                offset,
+                align: 0,
+                memory_index,
+            }),
+            Self::F64 => sink.f64_load(MemArg {
+                offset,
+                align: 0,
+                memory_index,
+            }),
+            Self::V128 => sink.v128_load(MemArg {
+                offset,
+                align: 0,
+                memory_index,
+            }),
+            // Not supported in closures
+            Self::Ref(_) => panic!("Cannot load reference type"),
+        };
+    }
+}
+
+/// Build a dynamically linkable WASM module for the given closure.
+fn build_closure_wasm_bytes(
+    module_name: &str,
+    closure: u32,
+    backing_function: u32,
+    environment_offset: u64,
+    argument_types: &[ValType],
+    result_types: &[ValType],
+) -> Vec<u8> {
+    let mut wasm_module = wasm_encoder::Module::new();
+
+    // Add dylink section
+    let dylink = CustomSection {
+        name: Cow::Borrowed("dylink.0"),
+        data: Cow::Borrowed(&[]),
+    };
+    wasm_module.section(&dylink);
+
+    // Add types section
+    let mut types = TypeSection::new();
+    types.ty().function(vec![], vec![]);
+    let on_load_function_type_index = 0;
+    let mut trampoline_function_params = argument_types.to_vec();
+    let mut trampoline_function_results = result_types.to_vec();
+    types
+        .ty()
+        .function(trampoline_function_params, trampoline_function_results);
+    let trampoline_function_type_index = 1;
+    types
+        .ty()
+        .function(vec![ValType::I32, ValType::I32, ValType::I32], vec![]);
+    let backing_function_type_index = 2;
+    wasm_module.section(&types);
+
+    // Add a imports section
+    let mut imports = ImportSection::new();
+    imports.import(
+        "env",
+        "memory",
+        MemoryType {
+            minimum: 1,
+            maximum: Some(65536),
+            shared: true,
+            memory64: false,
+            page_size_log2: None,
+        },
+    );
+    let main_memory_index = 0;
+    imports.import(
+        "env",
+        "__indirect_function_table",
+        TableType {
+            element_type: RefType::FUNCREF,
+            minimum: 1,
+            maximum: None,
+            shared: false,
+            table64: false,
+        },
+    );
+    let indirect_function_table_index = 0;
+    imports.import(
+        "env",
+        "__stack_pointer",
+        GlobalType {
+            val_type: ValType::I32,
+            mutable: true,
+            shared: false,
+        },
+    );
+    let stack_pointer_index = 0;
+    imports.import(
+        "GOT.func",
+        module_name,
+        GlobalType {
+            val_type: ValType::I32,
+            mutable: true,
+            shared: false,
+        },
+    );
+    let trampoline_function_pointer_index = 1;
+    wasm_module.section(&imports);
+
+    let mut functions = FunctionSection::new();
+    functions.function(on_load_function_type_index);
+    let on_load_function_index = 0;
+    functions.function(trampoline_function_type_index);
+    let trampoline_function_index = 1;
+    wasm_module.section(&functions);
+
+    // Add an export section
+    // FIXME: Look into replacing this with the wasm start function
+    let mut exports = ExportSection::new();
+    exports.export(
+        "__wasm_call_ctors",
+        ExportKind::Func,
+        on_load_function_index,
+    );
+    exports.export(module_name, ExportKind::Func, trampoline_function_index);
+    wasm_module.section(&exports);
+
+    let mut code = CodeSection::new();
+    let mut on_load_function = wasm_encoder::Function::new(vec![]);
+    on_load_function
+        .instructions()
+        .i32_const(closure as i32)
+        .global_get(trampoline_function_pointer_index)
+        .table_get(indirect_function_table_index)
+        .table_set(indirect_function_table_index)
+        .end();
+    code.function(&on_load_function);
+
+    let mut trampoline_function = wasm_encoder::Function::new(vec![(3, ValType::I32)]);
+    let original_stackpointer_local: u32 = argument_types.len() as u32;
+    let arguments_base_local: u32 = argument_types.len() as u32 + 1;
+    let results_base_local: u32 = argument_types.len() as u32 + 2;
+    let mut trampoline_function_instructions = trampoline_function.instructions();
+    let values_size = argument_types
+        .iter()
+        .map(ValType::size)
+        .sum::<u64>()
+        .next_multiple_of(16);
+    let results_size = result_types
+        .iter()
+        .map(ValType::size)
+        .sum::<u64>()
+        .next_multiple_of(16);
+    trampoline_function_instructions
+        .global_get(stack_pointer_index)
+        .local_tee(original_stackpointer_local)
+        .i32_const(results_size as i32)
+        .i32_sub()
+        .local_tee(results_base_local)
+        .i32_const(values_size as i32)
+        .i32_sub()
+        .local_tee(arguments_base_local)
+        .global_set(stack_pointer_index);
+    argument_types.iter().enumerate().fold(
+        (0, &mut trampoline_function_instructions),
+        |mut acc, (index, ty)| {
+            let size = ty.size();
+            acc.1
+                .local_get(arguments_base_local)
+                .local_get(index as u32);
+            ty.store(acc.1, acc.0, main_memory_index);
+            acc.0 += size;
+            acc
+        },
+    );
+    trampoline_function_instructions
+        .local_get(arguments_base_local)
+        .local_get(results_base_local)
+        .i32_const(environment_offset as i32)
+        .i32_const(backing_function as i32)
+        .call_indirect(indirect_function_table_index, backing_function_type_index);
+    result_types.iter().enumerate().fold(
+        (0, &mut trampoline_function_instructions),
+        |mut acc, (index, ty)| {
+            let size = ty.size();
+            acc.1.local_get(results_base_local);
+            ty.load(acc.1, acc.0, main_memory_index);
+            acc.0 += size;
+            acc
+        },
+    );
+    trampoline_function_instructions
+        .local_get(original_stackpointer_local)
+        .global_set(stack_pointer_index)
+        .end();
+    code.function(&trampoline_function);
+    wasm_module.section(&code);
+
+    wasm_module.finish()
+}
+
+// Monotonically incrementing id for closures
+static CLOSURE_ID: AtomicUsize = AtomicUsize::new(0);
+
+/// Prepare a closure so that it can be called with a given signature.
+///
+/// When the closure is called after [`closure_prepare`], the arguments will be decoded and passed to the backing function together with a pointer to the environment.
+///
+/// The backing function needs to conform to the following signature:
+///   uint8_t* values - a pointer to a buffer containing the arguments.
+///   uint8_t* results - a pointer to a buffer where the results will be written.
+///   void* environment - the environment that was passed to closure_prepare
+///
+/// `backing_function` is a pointer (index into `__indirect_function_table`) to the backing function
+///
+/// `closure` is a pointer (index into `__indirect_function_table`) to the closure that was obtained via [`closure_allocate`].
+///
+/// `argument_types_ptr` is a pointer to the argument types as a list of [`WasmValueType`]s
+/// `argument_types_length` is the number of arguments
+///
+/// `result_types_ptr` is a pointer to the result types as a list of [`WasmValueType`]s
+/// `result_types_length` is the number of results
+///
+/// `environment` is the closure environment that will be passed to the backing function alongside the decoded arguments and results
+#[instrument(level = "trace", fields(%backing_function, %closure), ret)]
+pub fn closure_prepare<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    backing_function: u32,
+    closure: u32,
+    argument_types_ptr: WasmPtr<u8, M>,
+    argument_types_length: u32,
+    result_types_ptr: WasmPtr<u8, M>,
+    result_types_length: u32,
+    environment: WasmPtr<u8, M>,
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    let (env, mut store) = ctx.data_and_store_mut();
+    let memory = unsafe { env.memory_view(&store) };
+
+    let Some(linker) = env.inner().linker().cloned() else {
+        error!("Closures only work for dynamic modules.");
+        return Ok(Errno::Notsup);
+    };
+
+    let argument_types = {
+        let arg_offset = argument_types_ptr.offset().into();
+        let arguments_slice =
+            wasi_try_mem_ok!(
+                WasmSlice::new(&memory, arg_offset, argument_types_length as u64)
+                    .and_then(WasmSlice::access)
+            );
+        wasi_try_ok!(arguments_slice
+            .iter()
+            .map(|t: &u8| ValType::from_u8(*t))
+            .collect::<Result<Vec<_>, Errno>>())
+    };
+
+    let result_types = {
+        let res_offset = result_types_ptr.offset().into();
+        let result_slice =
+            wasi_try_mem_ok!(
+                WasmSlice::new(&memory, res_offset, result_types_length as u64)
+                    .and_then(WasmSlice::access)
+            );
+        wasi_try_ok!(result_slice
+            .iter()
+            .map(|t: &u8| ValType::from_u8(*t))
+            .collect::<Result<Vec<_>, Errno>>())
+    };
+
+    let module_name = format!(
+        "__wasix_closure_{}",
+        CLOSURE_ID.fetch_add(1, Ordering::SeqCst),
+    );
+
+    let wasm_bytes = build_closure_wasm_bytes(
+        &module_name,
+        closure,
+        backing_function,
+        environment.offset().into(),
+        &argument_types,
+        &result_types,
+    );
+
+    let ld_library_path: [&Path; 0] = [];
+    let wasm_loader = DlModuleSpec::Memory {
+        module_name: &module_name,
+        bytes: &wasm_bytes,
+    };
+    let module_handle = match linker.load_module(wasm_loader, &mut ctx) {
+        Ok(m) => m,
+        Err(e) => {
+            // Should never happen
+            panic!("Failed to load newly built in-memory module: {e}");
+        }
+    };
+
+    return Ok(Errno::Success);
+}
diff --git a/lib/wasix/src/syscalls/wasix/dl_invalid_handle.rs b/lib/wasix/src/syscalls/wasix/dl_invalid_handle.rs
new file mode 100644
index 0000000000..e9defe71d9
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/dl_invalid_handle.rs
@@ -0,0 +1,39 @@
+use state::ModuleHandle;
+
+use super::*;
+use crate::syscalls::*;
+
+#[instrument(level = "trace", skip_all, fields(path = field::Empty), ret)]
+pub fn dl_invalid_handle(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    handle: DlHandle,
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    let (env, mut store) = ctx.data_and_store_mut();
+    let memory = unsafe { env.memory_view(&store) };
+
+    let handle = if handle == 0 {
+        // Handle zero is the main module, and never a valid side module handle
+        return Ok(Errno::Noexec);
+    } else {
+        ModuleHandle::from(handle)
+    };
+
+    let env_inner = unsafe { env.inner() };
+    let Some(linker) = env_inner.linker() else {
+        // No linker means no handles
+        return Ok(Errno::Noexec);
+    };
+
+    let is_valid = linker
+        .clone()
+        .is_handle_valid(handle, &mut ctx)
+        .unwrap_or(false);
+
+    Ok(if is_valid {
+        Errno::Success
+    } else {
+        Errno::Noexec
+    })
+}
diff --git a/lib/wasix/src/syscalls/wasix/dlopen.rs b/lib/wasix/src/syscalls/wasix/dlopen.rs
new file mode 100644
index 0000000000..01063772bc
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/dlopen.rs
@@ -0,0 +1,97 @@
+use super::*;
+use crate::{state::DlModuleSpec, syscalls::*};
+
+// TODO: add journal events for dl-related syscalls
+#[instrument(level = "trace", skip_all, fields(path = field::Empty, ld_library_path = field::Empty, flags), ret)]
+pub fn dlopen<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    path: WasmPtr<u8, M>,
+    path_len: M::Offset,
+    flags: DlFlags,
+    err_buf: WasmPtr<u8, M>,
+    err_buf_len: M::Offset,
+    ld_library_path: WasmPtr<u8, M>,
+    ld_library_path_len: M::Offset,
+    out_handle: WasmPtr<DlHandle, M>,
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    let (env, mut store) = ctx.data_and_store_mut();
+    let memory = unsafe { env.memory_view(&store) };
+
+    let env_inner = unsafe { env.inner() };
+    let Some(linker) = env_inner.linker() else {
+        wasi_dl_err!(
+            "The current instance is not a dynamically-linked instance",
+            memory,
+            err_buf,
+            err_buf_len
+        );
+    };
+
+    if path.is_null() {
+        // A null file name symbolizes the main module, which has a static handle
+        wasi_try_mem_ok!(out_handle.write(&memory, crate::state::MAIN_MODULE_HANDLE.into()));
+        return Ok(Errno::Success);
+    }
+
+    let path = unsafe { get_input_str_ok!(&memory, path, path_len) };
+    Span::current().record("path", path.as_str());
+
+    let ld_library_path =
+        unsafe { get_input_str_ok!(&memory, ld_library_path, ld_library_path_len) };
+    Span::current().record("ld_library_path", ld_library_path.as_str());
+    let ld_library_path = ld_library_path
+        .split(':')
+        .map(Path::new)
+        .collect::<Vec<_>>();
+
+    let linker = linker.clone();
+
+    let location = DlModuleSpec::FileSystem {
+        module_spec: Path::new(&path),
+        ld_library_path: ld_library_path.as_slice(),
+    };
+    let module_handle = linker.load_module(location, &mut ctx);
+
+    // Reborrow to keep rust happy
+    let (env, mut store) = ctx.data_and_store_mut();
+    let memory = unsafe { env.memory_view(&store) };
+
+    let module_handle = wasi_try_dl!(
+        module_handle,
+        "failed to load module: {}",
+        memory,
+        err_buf,
+        err_buf_len
+    );
+
+    wasi_try_mem_ok!(out_handle.write(&memory, module_handle.into()));
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn write_dl_error<M: MemorySize>(
+    mut err: &str,
+    memory: &MemoryView,
+    err_buf: WasmPtr<u8, M>,
+    err_buf_len: u64,
+) -> Result<(), MemoryAccessError> {
+    let mut err_len = err.len();
+
+    if err_len > err_buf_len as usize {
+        err_len = err_buf_len as usize - 1;
+        err = &err[..err_len];
+    }
+
+    let mut buf = vec![0; err_len + 1];
+    buf[0..err_len].copy_from_slice(err.as_bytes());
+
+    let Ok(err_len_offset) = M::Offset::try_from(err_len + 1) else {
+        panic!("Failed to convert size to offset")
+    };
+    let mut err_buf = err_buf.slice(memory, err_len_offset)?.access()?;
+    err_buf.copy_from_slice(&buf[..]);
+
+    Ok(())
+}
diff --git a/lib/wasix/src/syscalls/wasix/dlsym.rs b/lib/wasix/src/syscalls/wasix/dlsym.rs
new file mode 100644
index 0000000000..eb1f5e3417
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/dlsym.rs
@@ -0,0 +1,66 @@
+use state::MAIN_MODULE_HANDLE;
+
+use super::*;
+use crate::{
+    state::{ModuleHandle, ResolvedExport},
+    syscalls::*,
+};
+
+#[instrument(level = "trace", skip_all, fields(symbol = field::Empty), ret)]
+pub fn dlsym<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    handle: DlHandle,
+    symbol: WasmPtr<u8, M>,
+    symbol_len: M::Offset,
+    err_buf: WasmPtr<u8, M>,
+    err_buf_len: M::Offset,
+    out_symbol: WasmPtr<M::Offset, M>,
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    let (env, mut store) = ctx.data_and_store_mut();
+    let memory = unsafe { env.memory_view(&store) };
+    let symbol = unsafe { get_input_str_ok!(&memory, symbol, symbol_len) };
+    Span::current().record("symbol", symbol.as_str());
+
+    let env_inner = unsafe { env.inner() };
+    let Some(linker) = env_inner.linker() else {
+        wasi_dl_err!(
+            "The current instance is not a dynamically-linked instance",
+            memory,
+            err_buf,
+            err_buf_len
+        );
+    };
+    let linker = linker.clone();
+
+    // handle = 0 is RTLD_DEFAULT, so search everywhere
+    let handle = if handle == 0 {
+        None
+    } else {
+        Some(ModuleHandle::from(handle))
+    };
+    let symbol = linker.resolve_export(&mut ctx, handle, &symbol);
+
+    let (env, mut store) = ctx.data_and_store_mut();
+    let memory = unsafe { env.memory_view(&store) };
+
+    let symbol = wasi_try_dl!(
+        symbol,
+        "failed to resolve symbol: {}",
+        memory,
+        err_buf,
+        err_buf_len
+    );
+
+    match symbol {
+        ResolvedExport::Function { func_ptr: addr } | ResolvedExport::Global { data_ptr: addr } => {
+            let Ok(addr) = addr.try_into() else {
+                panic!("Failed to convert u64 address to M::Offset");
+            };
+            wasi_try_mem_ok!(out_symbol.write(&memory, addr));
+        }
+    }
+
+    Ok(Errno::Success)
+}
diff --git a/lib/wasix/src/syscalls/wasix/epoll_create.rs b/lib/wasix/src/syscalls/wasix/epoll_create.rs
index 91e63ea978..4c9a43345d 100644
--- a/lib/wasix/src/syscalls/wasix/epoll_create.rs
+++ b/lib/wasix/src/syscalls/wasix/epoll_create.rs
@@ -18,6 +18,8 @@ pub fn epoll_create<M: MemorySize + 'static>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     ret_fd: WasmPtr<WasiFd, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let fd = wasi_try_ok!(epoll_create_internal(&mut ctx, None)?);
     let env = ctx.data();
 
@@ -25,7 +27,7 @@ pub fn epoll_create<M: MemorySize + 'static>(
     if env.enable_journal {
         JournalEffector::save_epoll_create(&mut ctx, fd).map_err(|err| {
             tracing::error!("failed to save epoll_create event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
@@ -42,8 +44,6 @@ pub fn epoll_create_internal(
     ctx: &mut FunctionEnvMut<'_, WasiEnv>,
     with_fd: Option<WasiFd>,
 ) -> Result<Result<WasiFd, Errno>, WasiError> {
-    wasi_try_ok_ok!(WasiEnv::process_signals_and_exit(ctx)?);
-
     let env = ctx.data();
     let (memory, state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
 
@@ -64,12 +64,25 @@ pub fn epoll_create_internal(
     let fd = wasi_try_ok_ok!(if let Some(fd) = with_fd {
         state
             .fs
-            .with_fd(rights, rights, Fdflags::empty(), 0, inode, fd)
+            .with_fd(
+                rights,
+                rights,
+                Fdflags::empty(),
+                Fdflagsext::empty(),
+                0,
+                inode,
+                fd,
+            )
             .map(|_| fd)
     } else {
-        state
-            .fs
-            .create_fd(rights, rights, Fdflags::empty(), 0, inode)
+        state.fs.create_fd(
+            rights,
+            rights,
+            Fdflags::empty(),
+            Fdflagsext::empty(),
+            0,
+            inode,
+        )
     });
 
     Ok(Ok(fd))
diff --git a/lib/wasix/src/syscalls/wasix/epoll_ctl.rs b/lib/wasix/src/syscalls/wasix/epoll_ctl.rs
index 06ff54159a..f53914040f 100644
--- a/lib/wasix/src/syscalls/wasix/epoll_ctl.rs
+++ b/lib/wasix/src/syscalls/wasix/epoll_ctl.rs
@@ -34,6 +34,8 @@ pub fn epoll_ctl<M: MemorySize + 'static>(
     fd: WasiFd,
     event_ref: WasmPtr<EpollEvent<M>, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
 
     let memory = unsafe { env.memory_view(&ctx) };
@@ -64,7 +66,7 @@ pub fn epoll_ctl<M: MemorySize + 'static>(
     if env.enable_journal {
         JournalEffector::save_epoll_ctl(&mut ctx, epfd, op, fd, event_ctl).map_err(|err| {
             tracing::error!("failed to save epoll_create event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
@@ -122,13 +124,15 @@ pub(crate) fn epoll_ctl_internal(
 
                     // Now we register the epoll waker
                     let tx = tx.clone();
-                    let mut fd_guards =
-                        wasi_try_ok_ok!(register_epoll_waker(&env.state, &epoll_fd, tx));
+                    let mut fd_guard =
+                        wasi_try_ok_ok!(register_epoll_handler(&env.state, &epoll_fd, tx));
 
                     // After the guards are created we need to attach them to the subscription
                     let mut guard = subscriptions.lock().unwrap();
                     if let Some(subs) = guard.get_mut(&event.fd) {
-                        subs.1.append(&mut fd_guards);
+                        if let Some(fd_guard) = fd_guard {
+                            subs.1.push(fd_guard);
+                        }
                     }
                 }
             }
@@ -139,31 +143,6 @@ pub(crate) fn epoll_ctl_internal(
 }
 
 #[derive(Debug)]
-pub struct EpollJoinWaker {
-    fd: WasiFd,
-    readiness: EpollType,
-    tx: Arc<watch::Sender<EpollInterest>>,
-}
-impl EpollJoinWaker {
-    pub fn new(
-        fd: WasiFd,
-        readiness: EpollType,
-        tx: Arc<watch::Sender<EpollInterest>>,
-    ) -> Arc<Self> {
-        Arc::new(Self { fd, readiness, tx })
-    }
-
-    fn wake_now(&self) {
-        self.tx.send_modify(|i| {
-            i.interest.insert((self.fd, self.readiness));
-        });
-    }
-    pub fn as_waker(self: &Arc<Self>) -> Waker {
-        let s: *const Self = Arc::into_raw(Arc::clone(self));
-        let raw_waker = RawWaker::new(s as *const (), &VTABLE);
-        unsafe { Waker::from_raw(raw_waker) }
-    }
-}
 pub struct EpollHandler {
     fd: WasiFd,
     tx: Arc<watch::Sender<EpollInterest>>,
@@ -216,31 +195,11 @@ impl InterestHandler for EpollHandler {
     }
 }
 
-fn inline_waker_wake(s: &EpollJoinWaker) {
-    let waker_arc = unsafe { Arc::from_raw(s) };
-    waker_arc.wake_now();
-}
-
-fn inline_waker_clone(s: &EpollJoinWaker) -> RawWaker {
-    let arc = unsafe { Arc::from_raw(s) };
-    std::mem::forget(arc.clone());
-    RawWaker::new(Arc::into_raw(arc) as *const (), &VTABLE)
-}
-
-const VTABLE: RawWakerVTable = unsafe {
-    RawWakerVTable::new(
-        |s| inline_waker_clone(&*(s as *const EpollJoinWaker)), // clone
-        |s| inline_waker_wake(&*(s as *const EpollJoinWaker)),  // wake
-        |s| (*(s as *const EpollJoinWaker)).wake_now(), // wake by ref (don't decrease refcount)
-        |s| drop(Arc::from_raw(s as *const EpollJoinWaker)), // decrease refcount
-    )
-};
-
-pub(super) fn register_epoll_waker(
+pub(super) fn register_epoll_handler(
     state: &Arc<WasiState>,
     event: &EpollFd,
     tx: Arc<watch::Sender<EpollInterest>>,
-) -> Result<Vec<EpollJoinGuard>, Errno> {
+) -> Result<Option<EpollJoinGuard>, Errno> {
     let mut type_ = Eventtype::FdRead;
     let mut peb = PollEventBuilder::new();
     if event.events.contains(EpollType::EPOLLOUT) {
@@ -270,37 +229,35 @@ pub(super) fn register_epoll_waker(
     };
 
     // Get guard object which we will register the waker against
-    let mut ret = Vec::new();
     let fd_guard = poll_fd_guard(state, peb.build(), event.fd, s)?;
+    let handler = EpollHandler::new(event.fd, tx);
+
     match &fd_guard.mode {
-        // Sockets now use epoll
+        InodeValFilePollGuardMode::File(_) => {
+            // Intentionally ignored, epoll doesn't work with files
+            return Ok(None);
+        }
         InodeValFilePollGuardMode::Socket { inner, .. } => {
-            let handler = EpollHandler::new(event.fd, tx);
-
             let mut inner = inner.protected.write().unwrap();
             inner.set_handler(handler).map_err(net_error_into_io_err)?;
             drop(inner);
-
-            ret.push(EpollJoinGuard::Handler { fd_guard })
         }
-        _ => {
-            // Otherwise we fall back on the regular polling guard
-
-            // First we create the waker
-            let epoll_waker = EpollJoinWaker::new(event.fd, event.events, tx);
-            let waker = epoll_waker.as_waker();
-            let mut cx = Context::from_waker(&waker);
-
-            // Now we use the waker to trigger events
-            let mut join_guard = InodeValFilePollGuardJoin::new(fd_guard);
-            if Pin::new(&mut join_guard).poll(&mut cx).is_ready() {
-                waker.wake();
-            }
-            ret.push(EpollJoinGuard::Join {
-                join_guard,
-                epoll_waker,
-            });
+        InodeValFilePollGuardMode::EventNotifications(inner) => inner.set_interest_handler(handler),
+        InodeValFilePollGuardMode::DuplexPipe { pipe } => {
+            let mut inner = pipe.write().unwrap();
+            inner.set_interest_handler(handler);
+        }
+        InodeValFilePollGuardMode::PipeRx { rx } => {
+            let mut inner = rx.write().unwrap();
+            inner.set_interest_handler(handler);
+        }
+        InodeValFilePollGuardMode::PipeTx { tx } => {
+            // The sending end of a pipe can't have an interest handler, since we
+            // only support "readable" interest on pipes; they're considered to
+            // always be writable.
+            return Ok(None);
         }
     }
-    Ok(ret)
+
+    Ok(Some(EpollJoinGuard { fd_guard }))
 }
diff --git a/lib/wasix/src/syscalls/wasix/epoll_wait.rs b/lib/wasix/src/syscalls/wasix/epoll_wait.rs
index e67675f0be..812ca4f8e4 100644
--- a/lib/wasix/src/syscalls/wasix/epoll_wait.rs
+++ b/lib/wasix/src/syscalls/wasix/epoll_wait.rs
@@ -16,15 +16,15 @@ const TIMEOUT_FOREVER: u64 = u64::MAX;
 /// ### `epoll_wait()`
 /// Wait for an I/O event on an epoll file descriptor
 #[instrument(level = "trace", skip_all, fields(timeout_ms = field::Empty, fd_guards = field::Empty, seen = field::Empty), ret)]
-pub fn epoll_wait<'a, M: MemorySize + 'static>(
-    mut ctx: FunctionEnvMut<'a, WasiEnv>,
+pub fn epoll_wait<M: MemorySize + 'static>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
     epfd: WasiFd,
     events: WasmPtr<EpollEvent<M>, M>,
     maxevents: i32,
     timeout: Timestamp,
     ret_nevents: WasmPtr<M::Offset, M>,
 ) -> Result<Errno, WasiError> {
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+    WasiEnv::do_pending_operations(&mut ctx)?;
 
     ctx = wasi_try_ok!(maybe_backoff::<M>(ctx)?);
     ctx = wasi_try_ok!(maybe_snapshot::<M>(ctx)?);
@@ -85,13 +85,6 @@ pub fn epoll_wait<'a, M: MemorySize + 'static>(
                             }
                         };
 
-                        // We have to renew any joins that have now been spent
-                        for join in joins {
-                            if join.is_spent() {
-                                join.renew();
-                            }
-                        }
-
                         // Record the event
                         ret.push((fd.clone(), readiness));
                         if ret.len() + POLL_GUARD_MAX_RET >= (maxevents as usize) {
@@ -144,7 +137,7 @@ pub fn epoll_wait<'a, M: MemorySize + 'static>(
     // which will interpret the error codes
     let process_events = {
         let events_out = events;
-        move |ctx: &FunctionEnvMut<'a, WasiEnv>,
+        move |ctx: &FunctionEnvMut<'_, WasiEnv>,
               events: Result<Vec<(EpollFd, EpollType)>, Errno>| {
             let env = ctx.data();
             let memory = unsafe { env.memory_view(ctx) };
diff --git a/lib/wasix/src/syscalls/wasix/fd_dup2.rs b/lib/wasix/src/syscalls/wasix/fd_dup2.rs
new file mode 100644
index 0000000000..c95415e25d
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/fd_dup2.rs
@@ -0,0 +1,57 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `fd_dup()`
+/// Duplicates the file handle
+/// Inputs:
+/// - `Fd fd`
+///   File handle to be cloned
+/// Outputs:
+/// - `Fd fd`
+///   The new file handle that is a duplicate of the original
+#[instrument(level = "trace", skip_all, fields(%fd, ret_fd = field::Empty), ret)]
+pub fn fd_dup2<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    min_result_fd: WasiFd,
+    cloexec: Bool,
+    ret_fd: WasmPtr<WasiFd, M>,
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    let copied_fd = wasi_try_ok!(fd_dup_internal(
+        &mut ctx,
+        fd,
+        min_result_fd,
+        cloexec == Bool::True
+    ));
+    let env = ctx.data();
+
+    #[cfg(feature = "journal")]
+    if env.enable_journal {
+        JournalEffector::save_fd_duplicate(&mut ctx, fd, copied_fd, cloexec == Bool::True)
+            .map_err(|err| {
+                tracing::error!("failed to save file descriptor duplicate event - {}", err);
+                WasiError::Exit(ExitCode::from(Errno::Fault))
+            })?;
+    }
+
+    Span::current().record("ret_fd", copied_fd);
+    let env = ctx.data();
+    let (memory, state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+    wasi_try_mem_ok!(ret_fd.write(&memory, copied_fd));
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn fd_dup_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    min_result_fd: WasiFd,
+    cloexec: bool,
+) -> Result<WasiFd, Errno> {
+    let env = ctx.data();
+    let (memory, state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+    let fd = state.fs.clone_fd_ext(fd, min_result_fd, Some(cloexec))?;
+    Ok(fd)
+}
diff --git a/lib/wasix/src/syscalls/wasix/fd_fdflags_get.rs b/lib/wasix/src/syscalls/wasix/fd_fdflags_get.rs
new file mode 100644
index 0000000000..14d2380514
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/fd_fdflags_get.rs
@@ -0,0 +1,27 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `fd_fdstat_get()`
+/// Get metadata of a file descriptor
+/// Input:
+/// - `Fd fd`
+///     The file descriptor whose metadata will be accessed
+/// Output:
+/// - `Fdstat *buf`
+///     The location where the metadata will be written
+#[instrument(level = "trace", skip_all, fields(%wasi_fd), ret)]
+pub fn fd_fdflags_get<M: MemorySize>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    wasi_fd: WasiFd,
+    buf_ptr: WasmPtr<Fdflagsext, M>,
+) -> Errno {
+    let env = ctx.data();
+    let (memory, state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+    let fd = wasi_try!(state.fs.get_fd(wasi_fd));
+
+    let buf = buf_ptr.deref(&memory);
+
+    wasi_try_mem!(buf.write(fd.inner.fd_flags));
+
+    Errno::Success
+}
diff --git a/lib/wasix/src/syscalls/wasix/fd_fdflags_set.rs b/lib/wasix/src/syscalls/wasix/fd_fdflags_set.rs
new file mode 100644
index 0000000000..1041b80ff8
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/fd_fdflags_set.rs
@@ -0,0 +1,51 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `fd_fdstat_set_flags()`
+/// Set file descriptor flags for a file descriptor
+/// Inputs:
+/// - `Fd fd`
+///     The file descriptor to apply the new flags to
+/// - `Fdflags flags`
+///     The flags to apply to `fd`
+#[instrument(level = "trace", skip_all, fields(%fd), ret)]
+pub fn fd_fdflags_set(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    flags: Fdflagsext,
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    let ret = fd_fdflags_set_internal(&mut ctx, fd, flags)?;
+
+    if ret == Errno::Success {
+        #[cfg(feature = "journal")]
+        {
+            let env = ctx.data();
+            if env.enable_journal {
+                JournalEffector::save_fd_set_fdflags(&mut ctx, fd, flags).map_err(|err| {
+                    tracing::error!("failed to save file set fd flags event - {}", err);
+                    WasiError::Exit(ExitCode::from(Errno::Fault))
+                })?;
+            }
+        }
+    }
+
+    Ok(ret)
+}
+
+pub(crate) fn fd_fdflags_set_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    flags: Fdflagsext,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let (_, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+    let mut fd_map = state.fs.fd_map.write().unwrap();
+    let mut fd_entry = wasi_try_ok!(fd_map.get_mut(fd).ok_or(Errno::Badf));
+    if !fd_entry.rights.contains(Rights::FD_FDSTAT_SET_FLAGS) {
+        return Ok(Errno::Access);
+    }
+    fd_entry.fd_flags = flags;
+    Ok(Errno::Success)
+}
diff --git a/lib/wasix/src/syscalls/wasix/fd_pipe.rs b/lib/wasix/src/syscalls/wasix/fd_pipe.rs
index 7faf451870..6456aba453 100644
--- a/lib/wasix/src/syscalls/wasix/fd_pipe.rs
+++ b/lib/wasix/src/syscalls/wasix/fd_pipe.rs
@@ -1,94 +1,137 @@
+use std::sync::atomic::AtomicUsize;
+
 use virtual_fs::Pipe;
 
 use super::*;
 use crate::syscalls::*;
 
+// Used to make pipe end names unique. This is necessary since we use
+// a hash of the name to calculate inode numbers. The actual number
+// has no other meaning.
+static PIPE_NUMBER: AtomicUsize = AtomicUsize::new(0);
+
 /// ### `fd_pipe()`
 /// Creates ta pipe that feeds data between two file handles
 /// Output:
 /// - `Fd`
-///     First file handle that represents one end of the pipe
+///     First file handle that represents the read end of the pipe
 /// - `Fd`
-///     Second file handle that represents the other end of the pipe
-#[instrument(level = "trace", skip_all, fields(fd1 = field::Empty, fd2 = field::Empty), ret)]
+///     Second file handle that represents the write end of the pipe
+#[instrument(level = "trace", skip_all, fields(read_fd = field::Empty, write_fd = field::Empty), ret)]
 pub fn fd_pipe<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
-    ro_fd1: WasmPtr<WasiFd, M>,
-    ro_fd2: WasmPtr<WasiFd, M>,
+    ro_read_fd: WasmPtr<WasiFd, M>,
+    ro_write_fd: WasmPtr<WasiFd, M>,
 ) -> Result<Errno, WasiError> {
-    let (fd1, fd2) = wasi_try_ok!(fd_pipe_internal(&mut ctx, None, None));
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    let (read_fd, write_fd) = wasi_try_ok!(fd_pipe_internal(&mut ctx, None, None));
     let env = ctx.data();
 
     #[cfg(feature = "journal")]
     if env.enable_journal {
-        JournalEffector::save_fd_pipe(&mut ctx, fd1, fd2).map_err(|err| {
+        JournalEffector::save_fd_pipe(&mut ctx, read_fd, write_fd).map_err(|err| {
             tracing::error!("failed to save create pipe event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
     let env = ctx.data();
     let (memory, state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
 
-    Span::current().record("fd1", fd1).record("fd2", fd2);
+    Span::current()
+        .record("read_fd", read_fd)
+        .record("write_fd", write_fd);
 
-    wasi_try_mem_ok!(ro_fd1.write(&memory, fd1));
-    wasi_try_mem_ok!(ro_fd2.write(&memory, fd2));
+    wasi_try_mem_ok!(ro_read_fd.write(&memory, read_fd));
+    wasi_try_mem_ok!(ro_write_fd.write(&memory, write_fd));
 
     Ok(Errno::Success)
 }
 
 pub fn fd_pipe_internal(
     ctx: &mut FunctionEnvMut<'_, WasiEnv>,
-    with_fd1: Option<WasiFd>,
-    with_fd2: Option<WasiFd>,
+    with_read_fd: Option<WasiFd>,
+    with_write_fd: Option<WasiFd>,
 ) -> Result<(WasiFd, WasiFd), Errno> {
     let env = ctx.data();
     let (memory, state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
-    let (pipe1, pipe2) = Pipe::channel();
+    let (tx, rx) = Pipe::new().split();
 
-    let inode1 = state.fs.create_inode_with_default_stat(
+    // FIXME: since a hash of the inode name is used to calculate the inode number, this may
+    // or may not break journals that include pipes and are compacted.
+    let pipe_no = PIPE_NUMBER.fetch_add(1, Ordering::SeqCst);
+
+    let rx_inode = state.fs.create_inode_with_default_stat(
         inodes,
-        Kind::Pipe { pipe: pipe1 },
+        Kind::PipeRx { rx },
         false,
-        "pipe".to_string().into(),
+        format!("pipe{pipe_no}-rx").into(),
     );
-    let inode2 = state.fs.create_inode_with_default_stat(
+    let tx_inode = state.fs.create_inode_with_default_stat(
         inodes,
-        Kind::Pipe { pipe: pipe2 },
+        Kind::PipeTx { tx },
         false,
-        "pipe".to_string().into(),
+        format!("pipe{pipe_no}-tx").into(),
     );
 
-    let rights = Rights::FD_READ
-        | Rights::FD_WRITE
-        | Rights::FD_SYNC
+    let rights = Rights::FD_SYNC
         | Rights::FD_DATASYNC
         | Rights::POLL_FD_READWRITE
         | Rights::SOCK_SEND
-        | Rights::FD_FDSTAT_SET_FLAGS;
+        | Rights::FD_FDSTAT_SET_FLAGS
+        | Rights::FD_FILESTAT_GET;
+
+    let read_rights = rights | Rights::FD_READ;
+    let write_rights = rights | Rights::FD_WRITE;
 
-    let fd1 = if let Some(fd) = with_fd1 {
+    let read_fd = if let Some(fd) = with_read_fd {
         state
             .fs
-            .with_fd(rights, rights, Fdflags::empty(), 0, inode1, fd)
-            .map(|_| fd)?
+            .with_fd(
+                read_rights,
+                read_rights,
+                Fdflags::empty(),
+                Fdflagsext::empty(),
+                0,
+                rx_inode,
+                fd,
+            )
+            .map(|()| fd)?
     } else {
-        state
-            .fs
-            .create_fd(rights, rights, Fdflags::empty(), 0, inode1)?
+        state.fs.create_fd(
+            read_rights,
+            read_rights,
+            Fdflags::empty(),
+            Fdflagsext::empty(),
+            0,
+            rx_inode,
+        )?
     };
 
-    let fd2 = if let Some(fd) = with_fd2 {
+    let write_fd = if let Some(fd) = with_write_fd {
         state
             .fs
-            .with_fd(rights, rights, Fdflags::empty(), 0, inode2, fd)
-            .map(|_| fd)?
+            .with_fd(
+                write_rights,
+                write_rights,
+                Fdflags::empty(),
+                Fdflagsext::empty(),
+                0,
+                tx_inode,
+                fd,
+            )
+            .map(|()| fd)?
     } else {
-        state
-            .fs
-            .create_fd(rights, rights, Fdflags::empty(), 0, inode2)?
+        state.fs.create_fd(
+            write_rights,
+            write_rights,
+            Fdflags::empty(),
+            Fdflagsext::empty(),
+            0,
+            tx_inode,
+        )?
     };
 
-    Ok((fd1, fd2))
+    Ok((read_fd, write_fd))
 }
diff --git a/lib/wasix/src/syscalls/wasix/futex_wait.rs b/lib/wasix/src/syscalls/wasix/futex_wait.rs
index 69b46f43b2..c9e78a9f7e 100644
--- a/lib/wasix/src/syscalls/wasix/futex_wait.rs
+++ b/lib/wasix/src/syscalls/wasix/futex_wait.rs
@@ -72,12 +72,14 @@ impl Drop for FutexPoller {
 /// * `timeout` - Timeout should the futex not be triggered in the allocated time
 #[instrument(level = "trace", skip_all, fields(futex_idx = field::Empty, poller_idx = field::Empty, %expected, timeout = field::Empty, woken = field::Empty))]
 pub fn futex_wait<M: MemorySize + 'static>(
-    ctx: FunctionEnvMut<'_, WasiEnv>,
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
     futex_ptr: WasmPtr<u32, M>,
     expected: u32,
     timeout: WasmPtr<OptionTimestamp, M>,
     ret_woken: WasmPtr<Bool, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     futex_wait_internal(ctx, futex_ptr, expected, timeout, ret_woken)
 }
 
@@ -88,8 +90,6 @@ pub(super) fn futex_wait_internal<M: MemorySize + 'static>(
     timeout: WasmPtr<OptionTimestamp, M>,
     ret_woken: WasmPtr<Bool, M>,
 ) -> Result<Errno, WasiError> {
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
-
     ctx = wasi_try_ok!(maybe_backoff::<M>(ctx)?);
     ctx = wasi_try_ok!(maybe_snapshot::<M>(ctx)?);
 
@@ -113,10 +113,10 @@ pub(super) fn futex_wait_internal<M: MemorySize + 'static>(
         OptionTag::Some => Some(Duration::from_nanos(timeout.u)),
         _ => None,
     };
-    Span::current().record("timeout", &format!("{:?}", timeout));
+    Span::current().record("timeout", format!("{timeout:?}"));
 
     let state = env.state.clone();
-    let futex_idx: u64 = wasi_try_ok!(futex_ptr.offset().try_into().map_err(|_| Errno::Overflow));
+    let futex_idx: u64 = futex_ptr.offset().into();
     Span::current().record("futex_idx", futex_idx);
 
     // We generate a new poller which also registers in the
diff --git a/lib/wasix/src/syscalls/wasix/futex_wake.rs b/lib/wasix/src/syscalls/wasix/futex_wake.rs
index 88e5a7d669..6160f872cd 100644
--- a/lib/wasix/src/syscalls/wasix/futex_wake.rs
+++ b/lib/wasix/src/syscalls/wasix/futex_wake.rs
@@ -10,15 +10,17 @@ use crate::syscalls::*;
 /// * `futex` - Memory location that holds a futex that others may be waiting on
 #[instrument(level = "trace", skip_all, fields(futex_idx = field::Empty, woken = field::Empty), ret)]
 pub fn futex_wake<M: MemorySize>(
-    ctx: FunctionEnvMut<'_, WasiEnv>,
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
     futex_ptr: WasmPtr<u32, M>,
     ret_woken: WasmPtr<Bool, M>,
-) -> Errno {
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
     let state = env.state.deref();
 
-    let pointer: u64 = wasi_try!(futex_ptr.offset().try_into().map_err(|_| Errno::Overflow));
+    let pointer: u64 = futex_ptr.offset().into();
     Span::current().record("futex_idx", pointer);
 
     let mut woken = false;
@@ -47,7 +49,7 @@ pub fn futex_wake<M: MemorySize>(
         false => Bool::False,
         true => Bool::True,
     };
-    wasi_try_mem!(ret_woken.write(&memory, woken));
+    wasi_try_mem_ok!(ret_woken.write(&memory, woken));
 
-    Errno::Success
+    Ok(Errno::Success)
 }
diff --git a/lib/wasix/src/syscalls/wasix/futex_wake_all.rs b/lib/wasix/src/syscalls/wasix/futex_wake_all.rs
index 432a4aebeb..8a74714d04 100644
--- a/lib/wasix/src/syscalls/wasix/futex_wake_all.rs
+++ b/lib/wasix/src/syscalls/wasix/futex_wake_all.rs
@@ -8,15 +8,17 @@ use crate::syscalls::*;
 /// * `futex` - Memory location that holds a futex that others may be waiting on
 #[instrument(level = "trace", skip_all, fields(futex_idx = field::Empty, woken = field::Empty), ret)]
 pub fn futex_wake_all<M: MemorySize>(
-    ctx: FunctionEnvMut<'_, WasiEnv>,
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
     futex_ptr: WasmPtr<u32, M>,
     ret_woken: WasmPtr<Bool, M>,
-) -> Errno {
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
     let state = env.state.deref();
 
-    let pointer: u64 = wasi_try!(futex_ptr.offset().try_into().map_err(|_| Errno::Overflow));
+    let pointer: u64 = futex_ptr.offset().into();
     //Span::current().record("futex_idx", pointer);
 
     let mut woken = false;
@@ -41,6 +43,6 @@ pub fn futex_wake_all<M: MemorySize>(
         false => Bool::False,
         true => Bool::True,
     };
-    wasi_try_mem!(ret_woken.write(&memory, woken));
-    Errno::Success
+    wasi_try_mem_ok!(ret_woken.write(&memory, woken));
+    Ok(Errno::Success)
 }
diff --git a/lib/wasix/src/syscalls/wasix/getcwd.rs b/lib/wasix/src/syscalls/wasix/getcwd.rs
index 27250221a8..31758ca65f 100644
--- a/lib/wasix/src/syscalls/wasix/getcwd.rs
+++ b/lib/wasix/src/syscalls/wasix/getcwd.rs
@@ -5,7 +5,7 @@ use crate::syscalls::*;
 /// Returns the current working directory
 /// If the path exceeds the size of the buffer then this function
 /// will return ERANGE
-#[instrument(level = "debug", skip_all, fields(path = field::Empty, max_path_len = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(path = field::Empty, max_path_len = field::Empty), ret)]
 pub fn getcwd<M: MemorySize>(
     ctx: FunctionEnvMut<'_, WasiEnv>,
     path: WasmPtr<u8, M>,
@@ -14,7 +14,7 @@ pub fn getcwd<M: MemorySize>(
     let env = ctx.data();
     let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
 
-    let (_, cur_dir) = wasi_try!(state.fs.get_current_dir(inodes, crate::VIRTUAL_ROOT_FD,));
+    let (_, cur_dir) = wasi_try!(state.fs.get_current_dir(inodes, crate::VIRTUAL_ROOT_FD));
     Span::current().record("path", cur_dir.as_str());
 
     let max_path_len = wasi_try_mem!(path_len.read(&memory));
diff --git a/lib/wasix/src/syscalls/wasix/mod.rs b/lib/wasix/src/syscalls/wasix/mod.rs
index 520e024bee..0ec461deab 100644
--- a/lib/wasix/src/syscalls/wasix/mod.rs
+++ b/lib/wasix/src/syscalls/wasix/mod.rs
@@ -1,13 +1,24 @@
+mod call_dynamic;
 mod callback_signal;
 mod chdir;
+mod closure_allocate;
+mod closure_free;
+mod closure_prepare;
+mod dl_invalid_handle;
+mod dlopen;
+mod dlsym;
 mod epoll_create;
 mod epoll_ctl;
 mod epoll_wait;
+mod fd_dup2;
+mod fd_fdflags_get;
+mod fd_fdflags_set;
 mod fd_pipe;
 mod futex_wait;
 mod futex_wake;
 mod futex_wake_all;
 mod getcwd;
+mod path_open2;
 mod port_addr_add;
 mod port_addr_clear;
 mod port_addr_list;
@@ -23,12 +34,18 @@ mod port_route_remove;
 mod port_unbridge;
 mod proc_exec;
 mod proc_exec2;
+mod proc_exec3;
 mod proc_fork;
 mod proc_id;
 mod proc_join;
 mod proc_parent;
 mod proc_signal;
+mod proc_signals_get;
+mod proc_signals_sizes_get;
+mod proc_snapshot;
 mod proc_spawn;
+mod proc_spawn2;
+mod reflect_signature;
 mod resolve;
 mod sched_yield;
 mod sock_accept;
@@ -45,6 +62,7 @@ mod sock_leave_multicast_v4;
 mod sock_leave_multicast_v6;
 mod sock_listen;
 mod sock_open;
+mod sock_pair;
 mod sock_recv;
 mod sock_recv_from;
 mod sock_send;
@@ -67,16 +85,27 @@ mod thread_spawn;
 mod tty_get;
 mod tty_set;
 
+pub use call_dynamic::*;
 pub use callback_signal::*;
 pub use chdir::*;
+pub use closure_allocate::*;
+pub use closure_free::*;
+pub use closure_prepare::*;
+pub use dl_invalid_handle::*;
+pub use dlopen::*;
+pub use dlsym::*;
 pub use epoll_create::*;
 pub use epoll_ctl::*;
 pub use epoll_wait::*;
+pub use fd_dup2::*;
+pub use fd_fdflags_get::*;
+pub use fd_fdflags_set::*;
 pub use fd_pipe::*;
 pub use futex_wait::*;
 pub use futex_wake::*;
 pub use futex_wake_all::*;
 pub use getcwd::*;
+pub use path_open2::*;
 pub use port_addr_add::*;
 pub use port_addr_clear::*;
 pub use port_addr_list::*;
@@ -92,12 +121,18 @@ pub use port_route_remove::*;
 pub use port_unbridge::*;
 pub use proc_exec::*;
 pub use proc_exec2::*;
+pub use proc_exec3::*;
 pub use proc_fork::*;
 pub use proc_id::*;
 pub use proc_join::*;
 pub use proc_parent::*;
 pub use proc_signal::*;
+pub use proc_signals_get::*;
+pub use proc_signals_sizes_get::*;
+pub use proc_snapshot::*;
 pub use proc_spawn::*;
+pub use proc_spawn2::*;
+pub use reflect_signature::*;
 pub use resolve::*;
 pub use sched_yield::*;
 pub use sock_accept::*;
@@ -114,6 +149,7 @@ pub use sock_leave_multicast_v4::*;
 pub use sock_leave_multicast_v6::*;
 pub use sock_listen::*;
 pub use sock_open::*;
+pub use sock_pair::*;
 pub use sock_recv::*;
 pub use sock_recv_from::*;
 pub use sock_send::*;
diff --git a/lib/wasix/src/syscalls/wasix/path_open2.rs b/lib/wasix/src/syscalls/wasix/path_open2.rs
new file mode 100644
index 0000000000..1a797664fa
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/path_open2.rs
@@ -0,0 +1,432 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `path_open()`
+/// Open file located at the given path
+/// Inputs:
+/// - `Fd dirfd`
+///     The fd corresponding to the directory that the file is in
+/// - `LookupFlags dirflags`
+///     Flags specifying how the path will be resolved
+/// - `char *path`
+///     The path of the file or directory to open
+/// - `u32 path_len`
+///     The length of the `path` string
+/// - `Oflags o_flags`
+///     How the file will be opened
+/// - `Rights fs_rights_base`
+///     The rights of the created file descriptor
+/// - `Rights fs_rightsinheriting`
+///     The rights of file descriptors derived from the created file descriptor
+/// - `Fdflags fs_flags`
+///     The flags of the file descriptor
+/// Output:
+/// - `Fd* fd`
+///     The new file descriptor
+/// Possible Errors:
+/// - `Errno::Access`, `Errno::Badf`, `Errno::Fault`, `Errno::Fbig?`, `Errno::Inval`, `Errno::Io`, `Errno::Loop`, `Errno::Mfile`, `Errno::Nametoolong?`, `Errno::Nfile`, `Errno::Noent`, `Errno::Notdir`, `Errno::Rofs`, and `Errno::Notcapable`
+#[instrument(level = "trace", skip_all, fields(%dirfd, path = field::Empty, follow_symlinks = field::Empty, ret_fd = field::Empty), ret)]
+pub fn path_open2<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    dirfd: WasiFd,
+    dirflags: LookupFlags,
+    path: WasmPtr<u8, M>,
+    path_len: M::Offset,
+    o_flags: Oflags,
+    fs_rights_base: Rights,
+    fs_rights_inheriting: Rights,
+    fs_flags: Fdflags,
+    fd_flags: Fdflagsext,
+    fd: WasmPtr<WasiFd, M>,
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    if dirflags & __WASI_LOOKUP_SYMLINK_FOLLOW != 0 {
+        Span::current().record("follow_symlinks", true);
+    }
+    let env = ctx.data();
+    let (memory, mut state, mut inodes) =
+        unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+    /* TODO: find actual upper bound on name size (also this is a path, not a name :think-fish:) */
+    let path_len64: u64 = path_len.into();
+    if path_len64 > 1024u64 * 1024u64 {
+        return Ok(Errno::Nametoolong);
+    }
+
+    if path_len64 == 0 {
+        return Ok(Errno::Noent);
+    }
+
+    // o_flags:
+    // - __WASI_O_CREAT (create if it does not exist)
+    // - __WASI_O_DIRECTORY (fail if not dir)
+    // - __WASI_O_EXCL (fail if file exists)
+    // - __WASI_O_TRUNC (truncate size to 0)
+
+    let path_string = unsafe { get_input_str_ok!(&memory, path, path_len) };
+    Span::current().record("path", path_string.as_str());
+
+    let out_fd = wasi_try_ok!(path_open_internal(
+        ctx.data(),
+        dirfd,
+        dirflags,
+        &path_string,
+        o_flags,
+        fs_rights_base,
+        fs_rights_inheriting,
+        fs_flags,
+        fd_flags,
+        None,
+    )?);
+    let env = ctx.data();
+
+    #[cfg(feature = "journal")]
+    if env.enable_journal {
+        JournalEffector::save_path_open(
+            &mut ctx,
+            out_fd,
+            dirfd,
+            dirflags,
+            path_string,
+            o_flags,
+            fs_rights_base,
+            fs_rights_inheriting,
+            fs_flags,
+            fd_flags,
+        )
+        .map_err(|err| {
+            tracing::error!("failed to save unlink event - {}", err);
+            WasiError::Exit(ExitCode::from(Errno::Fault))
+        })?;
+    }
+
+    let env = ctx.data();
+    let (memory, mut state, mut inodes) =
+        unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+
+    Span::current().record("ret_fd", out_fd);
+
+    let fd_ref = fd.deref(&memory);
+    wasi_try_mem_ok!(fd_ref.write(out_fd));
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn path_open_internal(
+    env: &WasiEnv,
+    dirfd: WasiFd,
+    dirflags: LookupFlags,
+    path: &str,
+    o_flags: Oflags,
+    fs_rights_base: Rights,
+    fs_rights_inheriting: Rights,
+    fs_flags: Fdflags,
+    fd_flags: Fdflagsext,
+    with_fd: Option<WasiFd>,
+) -> Result<Result<WasiFd, Errno>, WasiError> {
+    let state = env.state.deref();
+    let inodes = &state.inodes;
+
+    let path_arg = std::path::PathBuf::from(&path);
+    let maybe_inode = state.fs.get_inode_at_path(
+        inodes,
+        dirfd,
+        path,
+        dirflags & __WASI_LOOKUP_SYMLINK_FOLLOW != 0,
+    );
+
+    let working_dir = wasi_try_ok_ok!(state.fs.get_fd(dirfd));
+    let working_dir_rights_inheriting = working_dir.inner.rights_inheriting;
+
+    // ASSUMPTION: open rights apply recursively
+    if !working_dir.inner.rights.contains(Rights::PATH_OPEN) {
+        return Ok(Err(Errno::Access));
+    }
+
+    let mut open_flags = 0;
+    // TODO: traverse rights of dirs properly
+    // COMMENTED OUT: WASI isn't giving appropriate rights here when opening
+    //              TODO: look into this; file a bug report if this is a bug
+    //
+    // Maximum rights: should be the working dir rights
+    // Minimum rights: whatever rights are provided
+    let adjusted_rights = /*fs_rights_base &*/ working_dir_rights_inheriting;
+    let mut open_options = state.fs_new_open_options();
+
+    let target_rights = match maybe_inode {
+        Ok(_) => {
+            let write_permission = adjusted_rights.contains(Rights::FD_WRITE);
+
+            // append, truncate, and create all require the permission to write
+            let (append_permission, truncate_permission, create_permission) = if write_permission {
+                (
+                    fs_flags.contains(Fdflags::APPEND),
+                    o_flags.contains(Oflags::TRUNC),
+                    o_flags.contains(Oflags::CREATE),
+                )
+            } else {
+                (false, false, false)
+            };
+
+            virtual_fs::OpenOptionsConfig {
+                read: fs_rights_base.contains(Rights::FD_READ),
+                write: write_permission,
+                create_new: create_permission && o_flags.contains(Oflags::EXCL),
+                create: create_permission,
+                append: append_permission,
+                truncate: truncate_permission,
+            }
+        }
+        Err(_) => virtual_fs::OpenOptionsConfig {
+            append: fs_flags.contains(Fdflags::APPEND),
+            write: fs_rights_base.contains(Rights::FD_WRITE),
+            read: fs_rights_base.contains(Rights::FD_READ),
+            create_new: o_flags.contains(Oflags::CREATE) && o_flags.contains(Oflags::EXCL),
+            create: o_flags.contains(Oflags::CREATE),
+            truncate: o_flags.contains(Oflags::TRUNC),
+        },
+    };
+
+    let parent_rights = virtual_fs::OpenOptionsConfig {
+        read: working_dir.inner.rights.contains(Rights::FD_READ),
+        write: working_dir.inner.rights.contains(Rights::FD_WRITE),
+        // The parent is a directory, which is why these options
+        // aren't inherited from the parent (append / truncate doesn't work on directories)
+        create_new: true,
+        create: true,
+        append: true,
+        truncate: true,
+    };
+
+    let minimum_rights = target_rights.minimum_rights(&parent_rights);
+
+    open_options.options(minimum_rights.clone());
+
+    let orig_path = path;
+
+    let inode = if let Ok(inode) = maybe_inode {
+        // Happy path, we found the file we're trying to open
+        let processing_inode = inode.clone();
+        let mut guard = processing_inode.write();
+
+        let deref_mut = guard.deref_mut();
+
+        if o_flags.contains(Oflags::EXCL) && o_flags.contains(Oflags::CREATE) {
+            return Ok(Err(Errno::Exist));
+        }
+
+        match deref_mut {
+            Kind::File {
+                ref mut handle,
+                path,
+                fd,
+                ..
+            } => {
+                if let Some(special_fd) = fd {
+                    // short circuit if we're dealing with a special file
+                    assert!(handle.is_some());
+                    return Ok(Ok(*special_fd));
+                }
+                if o_flags.contains(Oflags::DIRECTORY) || orig_path.ends_with('/') {
+                    return Ok(Err(Errno::Notdir));
+                }
+
+                let open_options = open_options
+                    .write(minimum_rights.write)
+                    .create(minimum_rights.create)
+                    .append(false)
+                    .truncate(minimum_rights.truncate);
+
+                if minimum_rights.read {
+                    open_flags |= Fd::READ;
+                }
+                if minimum_rights.write {
+                    open_flags |= Fd::WRITE;
+                }
+                if minimum_rights.create {
+                    open_flags |= Fd::CREATE;
+                }
+                if minimum_rights.truncate {
+                    open_flags |= Fd::TRUNCATE;
+                }
+                // TODO: I strongly suspect that assigning the handle unconditionally
+                // breaks opening the same file multiple times.
+                *handle = Some(Arc::new(std::sync::RwLock::new(wasi_try_ok_ok!(
+                    open_options.open(&path).map_err(fs_error_into_wasi_err)
+                ))));
+
+                if let Some(handle) = handle {
+                    let handle = handle.read().unwrap();
+                    if let Some(fd) = handle.get_special_fd() {
+                        // We clone the file descriptor so that when its closed
+                        // nothing bad happens
+                        let dup_fd = wasi_try_ok_ok!(state.fs.clone_fd(fd));
+                        trace!(
+                            %dup_fd
+                        );
+
+                        // some special files will return a constant FD rather than
+                        // actually open the file (/dev/stdin, /dev/stdout, /dev/stderr)
+                        return Ok(Ok(dup_fd));
+                    }
+                }
+            }
+            Kind::Buffer { .. } => unimplemented!("wasi::path_open for Buffer type files"),
+            Kind::Root { .. } => {
+                if !o_flags.contains(Oflags::DIRECTORY) {
+                    return Ok(Err(Errno::Notcapable));
+                }
+            }
+            Kind::Dir { .. } => {
+                if fs_rights_base.contains(Rights::FD_WRITE) {
+                    return Ok(Err(Errno::Isdir));
+                }
+            }
+            Kind::Socket { .. }
+            | Kind::PipeTx { .. }
+            | Kind::PipeRx { .. }
+            | Kind::DuplexPipe { .. }
+            | Kind::EventNotifications { .. }
+            | Kind::Epoll { .. } => {}
+            Kind::Symlink {
+                base_po_dir,
+                path_to_symlink,
+                relative_path,
+            } => {
+                // I think this should return an error (because symlinks should be resolved away by the path traversal)
+                // TODO: investigate this
+                unimplemented!("SYMLINKS IN PATH_OPEN");
+            }
+        }
+        inode
+    } else {
+        // less-happy path, we have to try to create the file
+        if o_flags.contains(Oflags::CREATE) {
+            if o_flags.contains(Oflags::DIRECTORY) {
+                return Ok(Err(Errno::Notdir));
+            }
+
+            // Trailing slash matters. But the underlying opener normalizes it away later.
+            if path.ends_with('/') {
+                return Ok(Err(Errno::Isdir));
+            }
+
+            // strip end file name
+
+            let (parent_inode, new_entity_name) =
+                wasi_try_ok_ok!(state.fs.get_parent_inode_at_path(
+                    inodes,
+                    dirfd,
+                    &path_arg,
+                    dirflags & __WASI_LOOKUP_SYMLINK_FOLLOW != 0
+                ));
+            let new_file_host_path = {
+                let guard = parent_inode.read();
+                match guard.deref() {
+                    Kind::Dir { path, .. } => {
+                        let mut new_path = path.clone();
+                        new_path.push(&new_entity_name);
+                        new_path
+                    }
+                    Kind::Root { .. } => {
+                        let mut new_path = std::path::PathBuf::new();
+                        new_path.push(&new_entity_name);
+                        new_path
+                    }
+                    _ => return Ok(Err(Errno::Inval)),
+                }
+            };
+            // once we got the data we need from the parent, we lookup the host file
+            // todo: extra check that opening with write access is okay
+            let handle = {
+                // We set create_new because the path already didn't resolve to an existing file,
+                // so it must be created.
+                let open_options = open_options
+                    .read(minimum_rights.read)
+                    .append(minimum_rights.append)
+                    .write(minimum_rights.write)
+                    .create_new(true);
+
+                if minimum_rights.read {
+                    open_flags |= Fd::READ;
+                }
+                if minimum_rights.write {
+                    open_flags |= Fd::WRITE;
+                }
+                if minimum_rights.create_new {
+                    open_flags |= Fd::CREATE;
+                }
+                if minimum_rights.truncate {
+                    open_flags |= Fd::TRUNCATE;
+                }
+
+                match open_options.open(&new_file_host_path) {
+                    Ok(handle) => Some(handle),
+                    Err(err) => {
+                        // Even though the file does not exist, it still failed to create with
+                        // `AlreadyExists` error.  This can happen if the path resolves to a
+                        // symlink that points outside the FS sandbox.
+                        if err == FsError::AlreadyExists {
+                            return Ok(Err(Errno::Perm));
+                        }
+
+                        return Ok(Err(fs_error_into_wasi_err(err)));
+                    }
+                }
+            };
+
+            let new_inode = {
+                let kind = Kind::File {
+                    handle: handle.map(|a| Arc::new(std::sync::RwLock::new(a))),
+                    path: new_file_host_path,
+                    fd: None,
+                };
+                wasi_try_ok_ok!(state
+                    .fs
+                    .create_inode(inodes, kind, false, new_entity_name.clone()))
+            };
+
+            {
+                let mut guard = parent_inode.write();
+                if let Kind::Dir {
+                    ref mut entries, ..
+                } = guard.deref_mut()
+                {
+                    entries.insert(new_entity_name, new_inode.clone());
+                }
+            }
+
+            new_inode
+        } else {
+            return Ok(Err(maybe_inode.unwrap_err()));
+        }
+    };
+
+    // TODO: check and reduce these
+    // TODO: ensure a mutable fd to root can never be opened
+    let out_fd = wasi_try_ok_ok!(if let Some(fd) = with_fd {
+        state
+            .fs
+            .with_fd(
+                adjusted_rights,
+                fs_rights_inheriting,
+                fs_flags,
+                fd_flags,
+                open_flags,
+                inode,
+                fd,
+            )
+            .map(|_| fd)
+    } else {
+        state.fs.create_fd(
+            adjusted_rights,
+            fs_rights_inheriting,
+            fs_flags,
+            fd_flags,
+            open_flags,
+            inode,
+        )
+    });
+
+    Ok(Ok(out_fd))
+}
diff --git a/lib/wasix/src/syscalls/wasix/port_addr_add.rs b/lib/wasix/src/syscalls/wasix/port_addr_add.rs
index 5a9d5909a6..f63063d432 100644
--- a/lib/wasix/src/syscalls/wasix/port_addr_add.rs
+++ b/lib/wasix/src/syscalls/wasix/port_addr_add.rs
@@ -9,16 +9,18 @@ use crate::syscalls::*;
 /// ## Parameters
 ///
 /// * `addr` - Address to be added
-#[instrument(level = "debug", skip_all, fields(ip = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(ip = field::Empty), ret)]
 pub fn port_addr_add<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     ip: WasmPtr<__wasi_cidr_t, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
 
     let cidr = wasi_try_ok!(crate::net::read_cidr(&memory, ip));
-    Span::current().record("ip", &format!("{:?}", cidr));
+    Span::current().record("ip", format!("{cidr:?}"));
 
     wasi_try_ok!(port_addr_add_internal(&mut ctx, cidr)?);
 
@@ -26,7 +28,7 @@ pub fn port_addr_add<M: MemorySize>(
     if ctx.data().enable_journal {
         JournalEffector::save_port_addr_add(&mut ctx, cidr).map_err(|err| {
             tracing::error!("failed to save port_addr_add event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
diff --git a/lib/wasix/src/syscalls/wasix/port_addr_clear.rs b/lib/wasix/src/syscalls/wasix/port_addr_clear.rs
index 9ceb6c45c6..a78003b558 100644
--- a/lib/wasix/src/syscalls/wasix/port_addr_clear.rs
+++ b/lib/wasix/src/syscalls/wasix/port_addr_clear.rs
@@ -3,15 +3,17 @@ use crate::syscalls::*;
 
 /// ### `port_addr_clear()`
 /// Clears all the addresses on the local port
-#[instrument(level = "debug", skip_all, ret)]
+#[instrument(level = "trace", skip_all, ret)]
 pub fn port_addr_clear(mut ctx: FunctionEnvMut<'_, WasiEnv>) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     wasi_try_ok!(port_addr_clear_internal(&mut ctx)?);
 
     #[cfg(feature = "journal")]
     if ctx.data().enable_journal {
         JournalEffector::save_port_addr_clear(&mut ctx).map_err(|err| {
             tracing::error!("failed to save port_addr_clear event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
diff --git a/lib/wasix/src/syscalls/wasix/port_addr_list.rs b/lib/wasix/src/syscalls/wasix/port_addr_list.rs
index 5439085541..fd51d41b94 100644
--- a/lib/wasix/src/syscalls/wasix/port_addr_list.rs
+++ b/lib/wasix/src/syscalls/wasix/port_addr_list.rs
@@ -14,16 +14,18 @@ use crate::syscalls::*;
 /// ## Return
 ///
 /// The number of addresses returned.
-#[instrument(level = "debug", skip_all, fields(naddrs = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(naddrs = field::Empty), ret)]
 pub fn port_addr_list<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     addrs_ptr: WasmPtr<__wasi_cidr_t, M>,
     naddrs_ptr: WasmPtr<M::Offset, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let mut env = ctx.data();
     let mut memory = unsafe { env.memory_view(&ctx) };
     let max_addrs = wasi_try_mem_ok!(naddrs_ptr.read(&memory));
-    let max_addrs: u64 = wasi_try_ok!(max_addrs.try_into().map_err(|_| Errno::Overflow));
+    let max_addrs: u64 = max_addrs.into();
 
     let net = env.net().clone();
     let addrs = wasi_try_ok!(__asyncify(&mut ctx, None, async {
diff --git a/lib/wasix/src/syscalls/wasix/port_addr_remove.rs b/lib/wasix/src/syscalls/wasix/port_addr_remove.rs
index eb68924357..ed586a74a7 100644
--- a/lib/wasix/src/syscalls/wasix/port_addr_remove.rs
+++ b/lib/wasix/src/syscalls/wasix/port_addr_remove.rs
@@ -7,16 +7,18 @@ use crate::syscalls::*;
 /// ## Parameters
 ///
 /// * `addr` - Address to be removed
-#[instrument(level = "debug", skip_all, fields(ip = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(ip = field::Empty), ret)]
 pub fn port_addr_remove<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     ip: WasmPtr<__wasi_addr_t, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
 
     let ip = wasi_try_ok!(crate::net::read_ip(&memory, ip));
-    Span::current().record("ip", &format!("{:?}", ip));
+    Span::current().record("ip", format!("{ip:?}"));
 
     wasi_try_ok!(port_addr_remove_internal(&mut ctx, ip)?);
 
@@ -24,7 +26,7 @@ pub fn port_addr_remove<M: MemorySize>(
     if ctx.data().enable_journal {
         JournalEffector::save_port_addr_remove(&mut ctx, ip).map_err(|err| {
             tracing::error!("failed to save port_addr_remove event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
diff --git a/lib/wasix/src/syscalls/wasix/port_bridge.rs b/lib/wasix/src/syscalls/wasix/port_bridge.rs
index e686ec5d07..d5fea56a3c 100644
--- a/lib/wasix/src/syscalls/wasix/port_bridge.rs
+++ b/lib/wasix/src/syscalls/wasix/port_bridge.rs
@@ -9,7 +9,7 @@ use crate::syscalls::*;
 /// * `network` - Fully qualified identifier for the network
 /// * `token` - Access token used to authenticate with the network
 /// * `security` - Level of encryption to encapsulate the network connection with
-#[instrument(level = "debug", skip_all, fields(network = field::Empty, ?security), ret)]
+#[instrument(level = "trace", skip_all, fields(network = field::Empty, ?security), ret)]
 pub fn port_bridge<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     network: WasmPtr<u8, M>,
@@ -18,6 +18,8 @@ pub fn port_bridge<M: MemorySize>(
     token_len: M::Offset,
     security: Streamsecurity,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
 
@@ -44,7 +46,7 @@ pub fn port_bridge<M: MemorySize>(
     if ctx.data().enable_journal {
         JournalEffector::save_port_bridge(&mut ctx, network, token, security).map_err(|err| {
             tracing::error!("failed to save port_bridge event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
diff --git a/lib/wasix/src/syscalls/wasix/port_dhcp_acquire.rs b/lib/wasix/src/syscalls/wasix/port_dhcp_acquire.rs
index 1415f76c60..f8d3e9cfd2 100644
--- a/lib/wasix/src/syscalls/wasix/port_dhcp_acquire.rs
+++ b/lib/wasix/src/syscalls/wasix/port_dhcp_acquire.rs
@@ -3,15 +3,17 @@ use crate::syscalls::*;
 
 /// ### `port_dhcp_acquire()`
 /// Acquires a set of IP addresses using DHCP
-#[instrument(level = "debug", skip_all, ret)]
+#[instrument(level = "trace", skip_all, ret)]
 pub fn port_dhcp_acquire(mut ctx: FunctionEnvMut<'_, WasiEnv>) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     wasi_try_ok!(port_dhcp_acquire_internal(&mut ctx)?);
 
     #[cfg(feature = "journal")]
     if ctx.data().enable_journal {
         JournalEffector::save_port_dhcp_acquire(&mut ctx).map_err(|err| {
             tracing::error!("failed to save port_dhcp_acquire event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
diff --git a/lib/wasix/src/syscalls/wasix/port_gateway_set.rs b/lib/wasix/src/syscalls/wasix/port_gateway_set.rs
index fc0549ea2c..c7985774dc 100644
--- a/lib/wasix/src/syscalls/wasix/port_gateway_set.rs
+++ b/lib/wasix/src/syscalls/wasix/port_gateway_set.rs
@@ -7,16 +7,18 @@ use crate::syscalls::*;
 /// ## Parameters
 ///
 /// * `addr` - Address of the default gateway
-#[instrument(level = "debug", skip_all, fields(ip = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(ip = field::Empty), ret)]
 pub fn port_gateway_set<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     ip: WasmPtr<__wasi_addr_t, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
 
     let ip = wasi_try_ok!(crate::net::read_ip(&memory, ip));
-    Span::current().record("ip", &format!("{:?}", ip));
+    Span::current().record("ip", format!("{ip:?}"));
 
     wasi_try_ok!(port_gateway_set_internal(&mut ctx, ip)?);
 
@@ -24,7 +26,7 @@ pub fn port_gateway_set<M: MemorySize>(
     if ctx.data().enable_journal {
         JournalEffector::save_port_gateway_set(&mut ctx, ip).map_err(|err| {
             tracing::error!("failed to save port_gateway_set event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
diff --git a/lib/wasix/src/syscalls/wasix/port_mac.rs b/lib/wasix/src/syscalls/wasix/port_mac.rs
index 93b13c544c..10f7a00275 100644
--- a/lib/wasix/src/syscalls/wasix/port_mac.rs
+++ b/lib/wasix/src/syscalls/wasix/port_mac.rs
@@ -3,11 +3,13 @@ use crate::syscalls::*;
 
 /// ### `port_mac()`
 /// Returns the MAC address of the local port
-#[instrument(level = "debug", skip_all, fields(max = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(max = field::Empty), ret)]
 pub fn port_mac<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     ret_mac: WasmPtr<__wasi_hardwareaddress_t, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let mut env = ctx.data();
     let mut memory = unsafe { env.memory_view(&ctx) };
 
diff --git a/lib/wasix/src/syscalls/wasix/port_route_add.rs b/lib/wasix/src/syscalls/wasix/port_route_add.rs
index 00e9f781c3..54d948dc43 100644
--- a/lib/wasix/src/syscalls/wasix/port_route_add.rs
+++ b/lib/wasix/src/syscalls/wasix/port_route_add.rs
@@ -5,7 +5,7 @@ use crate::syscalls::*;
 
 /// ### `port_route_add()`
 /// Adds a new route to the local port
-#[instrument(level = "debug", skip_all, fields(cidr = field::Empty, via_router = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(cidr = field::Empty, via_router = field::Empty), ret)]
 pub fn port_route_add<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     cidr: WasmPtr<__wasi_cidr_t, M>,
@@ -13,14 +13,16 @@ pub fn port_route_add<M: MemorySize>(
     preferred_until: WasmPtr<OptionTimestamp, M>,
     expires_at: WasmPtr<OptionTimestamp, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
 
     let cidr = wasi_try_ok!(crate::net::read_cidr(&memory, cidr));
-    Span::current().record("cidr", &format!("{:?}", cidr));
+    Span::current().record("cidr", format!("{cidr:?}"));
 
     let via_router = wasi_try_ok!(crate::net::read_ip(&memory, via_router));
-    Span::current().record("via_router", &format!("{:?}", via_router));
+    Span::current().record("via_router", format!("{via_router:?}"));
 
     let preferred_until = wasi_try_mem_ok!(preferred_until.read(&memory));
     let preferred_until = match preferred_until.tag {
@@ -54,7 +56,7 @@ pub fn port_route_add<M: MemorySize>(
         )
         .map_err(|err| {
             tracing::error!("failed to save port_route_add event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
diff --git a/lib/wasix/src/syscalls/wasix/port_route_clear.rs b/lib/wasix/src/syscalls/wasix/port_route_clear.rs
index 3eca5de420..5d28e05e43 100644
--- a/lib/wasix/src/syscalls/wasix/port_route_clear.rs
+++ b/lib/wasix/src/syscalls/wasix/port_route_clear.rs
@@ -3,15 +3,17 @@ use crate::syscalls::*;
 
 /// ### `port_route_clear()`
 /// Clears all the routes in the local port
-#[instrument(level = "debug", skip_all, ret)]
+#[instrument(level = "trace", skip_all, ret)]
 pub fn port_route_clear(mut ctx: FunctionEnvMut<'_, WasiEnv>) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     wasi_try_ok!(port_route_clear_internal(&mut ctx)?);
 
     #[cfg(feature = "journal")]
     if ctx.data().enable_journal {
         JournalEffector::save_port_route_clear(&mut ctx).map_err(|err| {
             tracing::error!("failed to save port_route_clear event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
diff --git a/lib/wasix/src/syscalls/wasix/port_route_list.rs b/lib/wasix/src/syscalls/wasix/port_route_list.rs
index 31b0ee397d..628cd5204c 100644
--- a/lib/wasix/src/syscalls/wasix/port_route_list.rs
+++ b/lib/wasix/src/syscalls/wasix/port_route_list.rs
@@ -10,12 +10,14 @@ use crate::syscalls::*;
 /// ## Parameters
 ///
 /// * `routes` - The buffer where routes will be stored
-#[instrument(level = "debug", skip_all, fields(nroutes = field::Empty, max_routes = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(nroutes = field::Empty, max_routes = field::Empty), ret)]
 pub fn port_route_list<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     routes_ptr: WasmPtr<Route, M>,
     nroutes_ptr: WasmPtr<M::Offset, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let mut env = ctx.data();
     let mut memory = unsafe { env.memory_view(&ctx) };
     let ref_nroutes = nroutes_ptr.deref(&memory);
diff --git a/lib/wasix/src/syscalls/wasix/port_route_remove.rs b/lib/wasix/src/syscalls/wasix/port_route_remove.rs
index 0b1b5da292..f02b303728 100644
--- a/lib/wasix/src/syscalls/wasix/port_route_remove.rs
+++ b/lib/wasix/src/syscalls/wasix/port_route_remove.rs
@@ -3,16 +3,18 @@ use crate::syscalls::*;
 
 /// ### `port_route_remove()`
 /// Removes an existing route from the local port
-#[instrument(level = "debug", skip_all, fields(ip = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(ip = field::Empty), ret)]
 pub fn port_route_remove<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     ip: WasmPtr<__wasi_addr_t, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
 
     let ip = wasi_try_ok!(crate::net::read_ip(&memory, ip));
-    Span::current().record("ip", &format!("{:?}", ip));
+    Span::current().record("ip", format!("{ip:?}"));
 
     wasi_try_ok!(port_route_remove_internal(&mut ctx, ip)?);
 
@@ -20,7 +22,7 @@ pub fn port_route_remove<M: MemorySize>(
     if ctx.data().enable_journal {
         JournalEffector::save_port_route_remove(&mut ctx, ip).map_err(|err| {
             tracing::error!("failed to save port_route_remove event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
diff --git a/lib/wasix/src/syscalls/wasix/port_unbridge.rs b/lib/wasix/src/syscalls/wasix/port_unbridge.rs
index 4495cd0486..23c8b6e045 100644
--- a/lib/wasix/src/syscalls/wasix/port_unbridge.rs
+++ b/lib/wasix/src/syscalls/wasix/port_unbridge.rs
@@ -3,15 +3,17 @@ use crate::syscalls::*;
 
 /// ### `port_unbridge()`
 /// Disconnects from a remote network
-#[instrument(level = "debug", skip_all, ret)]
+#[instrument(level = "trace", skip_all, ret)]
 pub fn port_unbridge(mut ctx: FunctionEnvMut<'_, WasiEnv>) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     wasi_try_ok!(port_unbridge_internal(&mut ctx)?);
 
     #[cfg(feature = "journal")]
     if ctx.data().enable_journal {
         JournalEffector::save_port_unbridge(&mut ctx).map_err(|err| {
             tracing::error!("failed to save port_unbridge event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
diff --git a/lib/wasix/src/syscalls/wasix/proc_exec.rs b/lib/wasix/src/syscalls/wasix/proc_exec.rs
index d5c433298e..fbf9fc66bf 100644
--- a/lib/wasix/src/syscalls/wasix/proc_exec.rs
+++ b/lib/wasix/src/syscalls/wasix/proc_exec.rs
@@ -17,7 +17,7 @@ use crate::{
 /// ## Return
 ///
 /// Returns a bus process id that can be used to invoke calls
-#[instrument(level = "debug", skip_all, fields(name = field::Empty, %args_len), ret)]
+#[instrument(level = "trace", skip_all, fields(name = field::Empty, %args_len), ret)]
 pub fn proc_exec<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     name: WasmPtr<u8, M>,
diff --git a/lib/wasix/src/syscalls/wasix/proc_exec2.rs b/lib/wasix/src/syscalls/wasix/proc_exec2.rs
index 3d909b466b..c44ef1aac7 100644
--- a/lib/wasix/src/syscalls/wasix/proc_exec2.rs
+++ b/lib/wasix/src/syscalls/wasix/proc_exec2.rs
@@ -18,7 +18,7 @@ use crate::{
 /// ## Return
 ///
 /// Returns a bus process id that can be used to invoke calls
-#[instrument(level = "debug", skip_all, fields(name = field::Empty, %args_len), ret)]
+#[instrument(level = "trace", skip_all, fields(name = field::Empty, %args_len), ret)]
 pub fn proc_exec2<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     name: WasmPtr<u8, M>,
@@ -28,253 +28,19 @@ pub fn proc_exec2<M: MemorySize>(
     envs: WasmPtr<u8, M>,
     envs_len: M::Offset,
 ) -> Result<(), WasiError> {
-    WasiEnv::process_signals_and_exit(&mut ctx)?;
-
-    // If we were just restored the stack then we were woken after a deep sleep
-    if let Some(exit_code) = unsafe { handle_rewind::<M, i32>(&mut ctx) } {
-        // We should never get here as the process will be termined
-        // in the `WasiEnv::process_signals_and_exit()` call
-        let exit_code = ExitCode::from_native(exit_code);
-        ctx.data().process.terminate(exit_code);
-        return Err(WasiError::Exit(exit_code));
-    }
-
-    let memory = unsafe { ctx.data().memory_view(&ctx) };
-    let mut name = name.read_utf8_string(&memory, name_len).map_err(|err| {
-        warn!("failed to execve as the name could not be read - {}", err);
-        WasiError::Exit(Errno::Inval.into())
-    })?;
-    Span::current().record("name", name.as_str());
-    let args = args.read_utf8_string(&memory, args_len).map_err(|err| {
-        warn!("failed to execve as the args could not be read - {}", err);
-        WasiError::Exit(Errno::Inval.into())
-    })?;
-    let args: Vec<_> = args
-        .split(&['\n', '\r'])
-        .map(|a| a.to_string())
-        .filter(|a| !a.is_empty())
-        .collect();
-
-    let envs = if !envs.is_null() {
-        let envs = envs.read_utf8_string(&memory, envs_len).map_err(|err| {
-            warn!("failed to execve as the envs could not be read - {}", err);
-            WasiError::Exit(Errno::Inval.into())
-        })?;
-
-        let envs = envs
-            .split(&['\n', '\r'])
-            .map(|a| a.to_string())
-            .filter(|a| !a.is_empty());
-
-        let mut vec = vec![];
-        for env in envs {
-            let (key, value) = env.split_once('=').unwrap();
-
-            vec.push((key.to_string(), value.to_string()));
-        }
-
-        Some(vec)
-    } else {
-        None
-    };
-
-    // Convert relative paths into absolute paths
-    if name.starts_with("./") {
-        name = ctx.data().state.fs.relative_path_to_absolute(name);
-    }
-    trace!(name);
-
-    // Convert the preopen directories
-    let preopen = ctx.data().state.preopen.clone();
-
-    // Get the current working directory
-    let (_, cur_dir) = {
-        let (memory, state, inodes) =
-            unsafe { ctx.data().get_memory_and_wasi_state_and_inodes(&ctx, 0) };
-        match state.fs.get_current_dir(inodes, crate::VIRTUAL_ROOT_FD) {
-            Ok(a) => a,
-            Err(err) => {
-                warn!("failed to create subprocess for fork - {}", err);
-                return Err(WasiError::Exit(err.into()));
-            }
-        }
-    };
-
-    let new_store = ctx.data().runtime.new_store();
-
-    // If we are in a vfork we need to first spawn a subprocess of this type
-    // with the forked WasiEnv, then do a longjmp back to the vfork point.
-    if let Some(mut vfork) = ctx.data_mut().vfork.take() {
-        // We will need the child pid later
-        let child_process = ctx.data().process.clone();
-        let child_pid = child_process.pid();
-        let child_finished = child_process.finished;
-
-        // Restore the WasiEnv to the point when we vforked
-        vfork.env.swap_inner(ctx.data_mut());
-        std::mem::swap(vfork.env.as_mut(), ctx.data_mut());
-        let mut wasi_env = *vfork.env;
-        wasi_env.owned_handles.push(vfork.handle);
-        _prepare_wasi(&mut wasi_env, Some(args), envs);
-
-        // Recrod the stack offsets before we give up ownership of the wasi_env
-        let stack_lower = wasi_env.layout.stack_lower;
-        let stack_upper = wasi_env.layout.stack_upper;
-
-        // Spawn a new process with this current execution environment
-        let mut err_exit_code: ExitCode = Errno::Success.into();
-
-        {
-            let bin_factory = Box::new(ctx.data().bin_factory.clone());
-            let tasks = wasi_env.tasks().clone();
-
-            let mut new_store = Some(new_store);
-            let mut config = Some(wasi_env);
-
-            match bin_factory.try_built_in(name.clone(), Some(&ctx), &mut new_store, &mut config) {
-                Ok(a) => {}
-                Err(err) => {
-                    if !err.is_not_found() {
-                        error!("builtin failed - {}", err);
-                    }
-
-                    let new_store = new_store.take().unwrap();
-                    let env = config.take().unwrap();
-
-                    let name_inner = name.clone();
-                    __asyncify_light(ctx.data(), None, async {
-                        let ret = bin_factory.spawn(name_inner, new_store, env).await;
-                        match ret {
-                            Ok(ret) => {
-                                trace!(%child_pid, "spawned sub-process");
-                            }
-                            Err(err) => {
-                                err_exit_code = conv_spawn_err_to_exit_code(&err);
-
-                                debug!(%child_pid, "process failed with (err={})", err_exit_code);
-                                child_finished.set_finished(Ok(err_exit_code));
-
-                                warn!(
-                                    "failed to execve as the process could not be spawned (vfork) - {}",
-                                    err
-                                );
-                                let _ = unsafe {
-                                    stderr_write(
-                                        &ctx,
-                                        format!(
-                                            "wasm execute failed [{}] - {}\n",
-                                            name.as_str(),
-                                            err
-                                        )
-                                        .as_bytes(),
-                                    )
-                                }
-                                .await;
-                            }
-                        }
-
-                        Ok(())
-                    });
-                }
-            }
-        };
-
-        // Jump back to the vfork point and current on execution
-        // note: fork does not return any values hence passing `()`
-        let memory_stack = vfork.memory_stack.freeze();
-        let rewind_stack = vfork.rewind_stack.freeze();
-        let store_data = vfork.store_data;
-        unwind::<M, _>(ctx, move |mut ctx, _, _| {
-            // Rewind the stack
-            match rewind::<M, _>(
-                ctx,
-                memory_stack,
-                rewind_stack,
-                store_data,
-                ForkResult {
-                    pid: child_pid.raw() as Pid,
-                    ret: Errno::Success,
-                },
-            ) {
-                Errno::Success => OnCalledAction::InvokeAgain,
-                err => {
-                    warn!("fork failed - could not rewind the stack - errno={}", err);
-                    OnCalledAction::Trap(Box::new(WasiError::Exit(err.into())))
-                }
-            }
-        })?;
-        Ok(())
-    }
-    // Otherwise we need to unwind the stack to get out of the current executing
-    // callstack, steal the memory/WasiEnv and switch it over to a new thread
-    // on the new module
-    else {
-        // Prepare the environment
-        let mut wasi_env = ctx.data().clone();
-        _prepare_wasi(&mut wasi_env, Some(args), envs);
-
-        // Get a reference to the runtime
-        let bin_factory = ctx.data().bin_factory.clone();
-        let tasks = wasi_env.tasks().clone();
-
-        // Create the process and drop the context
-        let bin_factory = Box::new(ctx.data().bin_factory.clone());
-
-        let mut new_store = Some(new_store);
-        let mut builder = Some(wasi_env);
-
-        let process = match bin_factory.try_built_in(
-            name.clone(),
-            Some(&ctx),
-            &mut new_store,
-            &mut builder,
-        ) {
-            Ok(a) => Ok(a),
-            Err(err) => {
-                if !err.is_not_found() {
-                    error!("builtin failed - {}", err);
-                }
-
-                let new_store = new_store.take().unwrap();
-                let env = builder.take().unwrap();
-
-                // Spawn a new process with this current execution environment
-                InlineWaker::block_on(bin_factory.spawn(name, new_store, env))
-            }
-        };
-
-        match process {
-            Ok(mut process) => {
-                // If we support deep sleeping then we switch to deep sleep mode
-                let env = ctx.data();
-                let thread = env.thread.clone();
-
-                // The poller will wait for the process to actually finish
-                let res = __asyncify_with_deep_sleep::<M, _, _>(ctx, async move {
-                    process
-                        .wait_finished()
-                        .await
-                        .unwrap_or_else(|_| Errno::Child.into())
-                        .to_native()
-                })?;
-                match res {
-                    AsyncifyAction::Finish(mut ctx, result) => {
-                        // When we arrive here the process should already be terminated
-                        let exit_code = ExitCode::from_native(result);
-                        ctx.data().process.terminate(exit_code);
-                        WasiEnv::process_signals_and_exit(&mut ctx)?;
-                        Err(WasiError::Exit(Errno::Unknown.into()))
-                    }
-                    AsyncifyAction::Unwind => Ok(()),
-                }
-            }
-            Err(err) => {
-                warn!(
-                    "failed to execve as the process could not be spawned (fork)[0] - {}",
-                    err
-                );
-                Err(WasiError::Exit(Errno::Noexec.into()))
-            }
-        }
+    match proc_exec3(
+        ctx,
+        name,
+        name_len,
+        args,
+        args_len,
+        envs,
+        envs_len,
+        Bool::False,
+        WasmPtr::null(),
+        0u32.into(),
+    ) {
+        Ok(e) => Err(WasiError::Exit(e.into())),
+        Err(e) => Err(e),
     }
 }
diff --git a/lib/wasix/src/syscalls/wasix/proc_exec3.rs b/lib/wasix/src/syscalls/wasix/proc_exec3.rs
new file mode 100644
index 0000000000..e72cdd7c7f
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/proc_exec3.rs
@@ -0,0 +1,328 @@
+use wasmer::FromToNativeWasmType;
+
+use super::*;
+use crate::{
+    os::task::{OwnedTaskStatus, TaskStatus},
+    syscalls::*,
+    WasiFs, VIRTUAL_ROOT_FD,
+};
+
+/// Replaces the current process with a new process
+///
+/// ## Parameters
+///
+/// * `name` - Name of the process to be spawned
+/// * `args` - List of the arguments to pass the process
+///   (entries are separated by line feeds)
+/// * `envs` - List of the environment variables to pass process
+///
+/// ## Return
+///
+/// If the execution fails, returns an error code. Does not return otherwise.
+#[instrument(level = "trace", skip_all, fields(name = field::Empty, %args_len), ret)]
+pub fn proc_exec3<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    name: WasmPtr<u8, M>,
+    name_len: M::Offset,
+    args: WasmPtr<u8, M>,
+    args_len: M::Offset,
+    envs: WasmPtr<u8, M>,
+    envs_len: M::Offset,
+    search_path: Bool,
+    path: WasmPtr<u8, M>,
+    path_len: M::Offset,
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    // If we were just restored the stack then we were woken after a deep sleep
+    if let Some(exit_code) = unsafe { handle_rewind::<M, i32>(&mut ctx) } {
+        // We should never get here as the process will be termined
+        // in the `WasiEnv::do_pending_operations()` call
+        let exit_code = ExitCode::from_native(exit_code);
+        ctx.data().process.terminate(exit_code);
+        return Err(WasiError::Exit(exit_code));
+    }
+
+    let memory = unsafe { ctx.data().memory_view(&ctx) };
+    let mut name = name.read_utf8_string(&memory, name_len).map_err(|err| {
+        warn!("failed to execve as the name could not be read - {}", err);
+        WasiError::Exit(Errno::Inval.into())
+    })?;
+    Span::current().record("name", name.as_str());
+    let args = args.read_utf8_string(&memory, args_len).map_err(|err| {
+        warn!("failed to execve as the args could not be read - {}", err);
+        WasiError::Exit(Errno::Inval.into())
+    })?;
+    let args: Vec<_> = args
+        .split(&['\n', '\r'])
+        .map(|a| a.to_string())
+        .filter(|a| !a.is_empty())
+        .collect();
+
+    let envs = if !envs.is_null() {
+        let envs = envs.read_utf8_string(&memory, envs_len).map_err(|err| {
+            warn!("failed to execve as the envs could not be read - {}", err);
+            WasiError::Exit(Errno::Inval.into())
+        })?;
+
+        let envs = envs
+            .split(&['\n', '\r'])
+            .map(|a| a.to_string())
+            .filter(|a| !a.is_empty());
+
+        let mut vec = vec![];
+        for env in envs {
+            let (key, value) = wasi_try_ok!(env.split_once('=').ok_or(Errno::Inval));
+
+            vec.push((key.to_string(), value.to_string()));
+        }
+
+        Some(vec)
+    } else {
+        None
+    };
+
+    // Convert relative paths into absolute paths
+    if search_path == Bool::True && !name.contains('/') {
+        let path_str;
+
+        let path = if path.is_null() {
+            vec!["/usr/local/bin", "/bin", "/usr/bin"]
+        } else {
+            path_str = path.read_utf8_string(&memory, path_len).map_err(|err| {
+                warn!("failed to execve as the path could not be read - {}", err);
+                WasiError::Exit(Errno::Inval.into())
+            })?;
+            path_str.split(':').collect()
+        };
+        let (_, state, inodes) =
+            unsafe { ctx.data().get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+        match find_executable_in_path(&state.fs, inodes, path.iter().map(AsRef::as_ref), &name) {
+            FindExecutableResult::Found(p) => name = p,
+            FindExecutableResult::AccessError => return Ok(Errno::Access),
+            FindExecutableResult::NotFound => return Ok(Errno::Noexec),
+        }
+    } else if name.starts_with("./") {
+        name = ctx.data().state.fs.relative_path_to_absolute(name);
+    }
+
+    trace!(name);
+
+    // Convert the preopen directories
+    let preopen = ctx.data().state.preopen.clone();
+
+    // Get the current working directory
+    let (_, cur_dir) = {
+        let (memory, state, inodes) =
+            unsafe { ctx.data().get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+        match state.fs.get_current_dir(inodes, crate::VIRTUAL_ROOT_FD) {
+            Ok(a) => a,
+            Err(err) => {
+                warn!("failed to create subprocess for fork - {}", err);
+                return Err(WasiError::Exit(err.into()));
+            }
+        }
+    };
+
+    let new_store = ctx.data().runtime.new_store();
+
+    // If we are in a vfork we need to first spawn a subprocess of this type
+    // with the forked WasiEnv, then do a longjmp back to the vfork point.
+    if let Some(mut vfork) = ctx.data_mut().vfork.take() {
+        // Needed in case an error happens and we need to get back into the child process
+        let mut child_env = Box::new(ctx.data().clone());
+
+        // We will need the child pid later
+        let child_pid = ctx.data().process.pid();
+
+        tracing::debug!(
+            %child_pid,
+            vfork_pid = %vfork.env.process.pid(),
+            "proc_exec in presence of vfork"
+        );
+
+        // Restore the WasiEnv to the point when we vforked
+        let mut vfork_env = vfork.env.clone();
+        vfork_env.swap_inner(ctx.data_mut());
+        std::mem::swap(vfork_env.as_mut(), ctx.data_mut());
+        let mut wasi_env = *vfork_env;
+        wasi_env.owned_handles.push(vfork.handle.clone());
+        _prepare_wasi(&mut wasi_env, Some(args), envs, None);
+
+        // Recrod the stack offsets before we give up ownership of the wasi_env
+        let stack_lower = wasi_env.layout.stack_lower;
+        let stack_upper = wasi_env.layout.stack_upper;
+
+        // Spawn a new process with this current execution environment
+        let mut err_exit_code: ExitCode = Errno::Success.into();
+
+        let spawn_result = {
+            let bin_factory = Box::new(ctx.data().bin_factory.clone());
+            let tasks = wasi_env.tasks().clone();
+
+            let mut config = Some(wasi_env);
+
+            match bin_factory.try_built_in(name.clone(), Some(&ctx), &mut config) {
+                Ok(a) => Ok(()),
+                Err(err) => {
+                    if !err.is_not_found() {
+                        error!("builtin failed - {}", err);
+                    }
+
+                    let env = config.take().unwrap();
+
+                    let name_inner = name.clone();
+                    __asyncify_light(ctx.data(), None, async {
+                        let ret = bin_factory.spawn(name_inner, env).await;
+                        match ret {
+                            Ok(ret) => {
+                                trace!(%child_pid, "spawned sub-process");
+                                Ok(())
+                            }
+                            Err(err) => {
+                                err_exit_code = conv_spawn_err_to_exit_code(&err);
+
+                                debug!(%child_pid, "process failed with (err={})", err_exit_code);
+
+                                Err(Errno::Noexec)
+                            }
+                        }
+                    })
+                    .unwrap()
+                }
+            }
+        };
+
+        match spawn_result {
+            Err(e) => {
+                // We failed to spawn a new process - put the vfork back
+                child_env.swap_inner(ctx.data_mut());
+                std::mem::swap(child_env.as_mut(), ctx.data_mut());
+
+                ctx.data_mut().vfork = Some(vfork);
+                return Ok(e);
+            }
+            Ok(()) => {
+                // Jump back to the vfork point and current on execution
+                // note: fork does not return any values hence passing `()`
+                let rewind_stack = vfork.rewind_stack.freeze();
+                let store_data = vfork.store_data;
+                unwind::<M, _>(ctx, move |mut ctx, _, _| {
+                    // Rewind the stack
+                    match rewind::<M, _>(
+                        ctx,
+                        None,
+                        rewind_stack,
+                        store_data,
+                        ForkResult {
+                            pid: child_pid.raw() as Pid,
+                            ret: Errno::Success,
+                        },
+                    ) {
+                        Errno::Success => OnCalledAction::InvokeAgain,
+                        err => {
+                            warn!("fork failed - could not rewind the stack - errno={}", err);
+                            OnCalledAction::Trap(Box::new(WasiError::Exit(err.into())))
+                        }
+                    }
+                })?;
+                Ok(Errno::Success)
+            }
+        }
+    }
+    // Otherwise we need to unwind the stack to get out of the current executing
+    // callstack, steal the memory/WasiEnv and switch it over to a new thread
+    // on the new module
+    else {
+        // Prepare the environment
+        let mut wasi_env = ctx.data().clone();
+        _prepare_wasi(&mut wasi_env, Some(args), envs, None);
+
+        // Get a reference to the runtime
+        let bin_factory = ctx.data().bin_factory.clone();
+        let tasks = wasi_env.tasks().clone();
+
+        // Create the process and drop the context
+        let bin_factory = Box::new(ctx.data().bin_factory.clone());
+
+        let mut builder = Some(wasi_env);
+
+        let process = match bin_factory.try_built_in(name.clone(), Some(&ctx), &mut builder) {
+            Ok(a) => Ok(a),
+            Err(err) => {
+                if !err.is_not_found() {
+                    error!("builtin failed - {}", err);
+                }
+
+                let env = builder.take().unwrap();
+
+                // Spawn a new process with this current execution environment
+                InlineWaker::block_on(bin_factory.spawn(name, env))
+            }
+        };
+
+        match process {
+            Ok(mut process) => {
+                // If we support deep sleeping then we switch to deep sleep mode
+                let env = ctx.data();
+
+                let thread = env.thread.clone();
+
+                // The poller will wait for the process to actually finish
+                let res = __asyncify_with_deep_sleep::<M, _, _>(ctx, async move {
+                    process
+                        .wait_finished()
+                        .await
+                        .unwrap_or_else(|_| Errno::Child.into())
+                        .to_native()
+                })?;
+                match res {
+                    AsyncifyAction::Finish(mut ctx, result) => {
+                        // When we arrive here the process should already be terminated
+                        let exit_code = ExitCode::from_native(result);
+                        ctx.data().process.terminate(exit_code);
+                        WasiEnv::process_signals_and_exit(&mut ctx)?;
+                        Err(WasiError::Exit(Errno::Unknown.into()))
+                    }
+                    AsyncifyAction::Unwind => Ok(Errno::Success),
+                }
+            }
+            Err(err) => {
+                warn!(
+                    "failed to execve as the process could not be spawned (fork)[0] - {}",
+                    err
+                );
+                Ok(Errno::Noexec)
+            }
+        }
+    }
+}
+
+pub(crate) enum FindExecutableResult {
+    Found(String),
+    AccessError,
+    NotFound,
+}
+
+pub(crate) fn find_executable_in_path<'a>(
+    fs: &WasiFs,
+    inodes: &WasiInodes,
+    path: impl IntoIterator<Item = &'a str>,
+    file_name: &str,
+) -> FindExecutableResult {
+    let mut encountered_eaccess = false;
+    for p in path {
+        let full_path = format!("{}/{}", p.trim_end_matches('/'), file_name);
+        match fs.get_inode_at_path(inodes, VIRTUAL_ROOT_FD, &full_path, true) {
+            Ok(_) => return FindExecutableResult::Found(full_path),
+            Err(Errno::Access) => encountered_eaccess = true,
+            Err(_) => (),
+        }
+    }
+
+    if encountered_eaccess {
+        FindExecutableResult::AccessError
+    } else {
+        FindExecutableResult::NotFound
+    }
+}
diff --git a/lib/wasix/src/syscalls/wasix/proc_fork.rs b/lib/wasix/src/syscalls/wasix/proc_fork.rs
index 31092c86e5..f2b17e5197 100644
--- a/lib/wasix/src/syscalls/wasix/proc_fork.rs
+++ b/lib/wasix/src/syscalls/wasix/proc_fork.rs
@@ -19,13 +19,18 @@ pub(crate) struct ForkResult {
 /// Forks the current process into a new subprocess. If the function
 /// returns a zero then its the new subprocess. If it returns a positive
 /// number then its the current process and the $pid represents the child.
-#[instrument(level = "debug", skip_all, fields(pid = ctx.data().process.pid().raw()), ret)]
+#[instrument(level = "trace", skip_all, fields(pid = ctx.data().process.pid().raw()), ret)]
 pub fn proc_fork<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     mut copy_memory: Bool,
     pid_ptr: WasmPtr<Pid, M>,
 ) -> Result<Errno, WasiError> {
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    wasi_try_ok!(ctx.data().ensure_static_module().map_err(|_| {
+        warn!("process forking not supported for dynamically linked modules");
+        Errno::Notsup
+    }));
 
     // If we were just restored then we need to return the value instead
     if let Some(result) = unsafe { handle_rewind::<M, ForkResult>(&mut ctx) } {
@@ -96,10 +101,10 @@ pub fn proc_fork<M: MemorySize>(
             std::mem::swap(ctx.data_mut(), &mut child_env);
             ctx.data_mut().vfork.replace(WasiVFork {
                 rewind_stack: rewind_stack.clone(),
-                memory_stack: memory_stack.clone(),
                 store_data: store_data.clone(),
                 env: Box::new(child_env),
                 handle: child_handle,
+                is_64bit: M::is_64bit(),
             });
 
             // Carry on as if the fork had taken place (which basically means
@@ -107,7 +112,7 @@ pub fn proc_fork<M: MemorySize>(
             // Rewind the stack and carry on
             match rewind::<M, _>(
                 ctx,
-                memory_stack.freeze(),
+                Some(memory_stack.freeze()),
                 rewind_stack.freeze(),
                 store_data,
                 ForkResult {
@@ -151,9 +156,11 @@ pub fn proc_fork<M: MemorySize>(
         let child_memory_stack = memory_stack.clone();
         let child_rewind_stack = rewind_stack.clone();
 
-        let module = unsafe { ctx.data().inner() }.module_clone();
-        let memory = unsafe { ctx.data().inner() }.memory_clone();
-        let spawn_type = SpawnMemoryType::CopyMemory(memory, ctx.as_store_ref());
+        let env_inner = ctx.data().inner();
+        let instance_handles = env_inner.static_module_instance_handles().unwrap();
+        let module = instance_handles.module_clone();
+        let memory = instance_handles.memory_clone();
+        let spawn_type = SpawnType::CopyMemory(memory, ctx.as_store_ref());
 
         // Spawn a new process with this current execution environment
         let signaler = Box::new(child_env.process.clone());
@@ -174,7 +181,7 @@ pub fn proc_fork<M: MemorySize>(
                     let (data, mut store) = ctx.data_and_store_mut();
                     match rewind::<M, _>(
                         ctx,
-                        child_memory_stack,
+                        Some(child_memory_stack),
                         child_rewind_stack,
                         store_data.clone(),
                         ForkResult {
@@ -199,8 +206,8 @@ pub fn proc_fork<M: MemorySize>(
 
             tasks_outer
                 .task_wasm(
-                    TaskWasm::new(Box::new(run), child_env, module, false)
-                        .with_globals(&snapshot)
+                    TaskWasm::new(Box::new(run), child_env, module, false, false)
+                        .with_globals(snapshot)
                         .with_memory(spawn_type),
                 )
                 .map_err(|err| {
@@ -216,7 +223,7 @@ pub fn proc_fork<M: MemorySize>(
         // Rewind the stack and carry on
         match rewind::<M, _>(
             ctx,
-            memory_stack,
+            Some(memory_stack),
             rewind_stack,
             store_data,
             ForkResult {
@@ -262,11 +269,22 @@ fn run<M: MemorySize>(
     let mut ret: ExitCode = Errno::Success.into();
     let err = if ctx.data(&store).thread.is_main() {
         trace!(%pid, %tid, "re-invoking main");
-        let start = unsafe { ctx.data(&store).inner() }.start.clone().unwrap();
+        let start = ctx
+            .data(&store)
+            .inner()
+            .static_module_instance_handles()
+            .unwrap()
+            .start
+            .clone()
+            .unwrap();
         start.call(&mut store)
     } else {
         trace!(%pid, %tid, "re-invoking thread_spawn");
-        let start = unsafe { ctx.data(&store).inner() }
+        let start = ctx
+            .data(&store)
+            .inner()
+            .static_module_instance_handles()
+            .unwrap()
             .thread_spawn
             .clone()
             .unwrap();
diff --git a/lib/wasix/src/syscalls/wasix/proc_id.rs b/lib/wasix/src/syscalls/wasix/proc_id.rs
index bbbc25fb0c..3c32c91759 100644
--- a/lib/wasix/src/syscalls/wasix/proc_id.rs
+++ b/lib/wasix/src/syscalls/wasix/proc_id.rs
@@ -3,7 +3,7 @@ use crate::syscalls::*;
 
 /// ### `proc_id()`
 /// Returns the handle of the current process
-#[instrument(level = "debug", skip_all, fields(pid = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(pid = field::Empty), ret)]
 pub fn proc_id<M: MemorySize>(ctx: FunctionEnvMut<'_, WasiEnv>, ret_pid: WasmPtr<Pid, M>) -> Errno {
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
diff --git a/lib/wasix/src/syscalls/wasix/proc_join.rs b/lib/wasix/src/syscalls/wasix/proc_join.rs
index 3bc85e2cce..2ec6fd9ced 100644
--- a/lib/wasix/src/syscalls/wasix/proc_join.rs
+++ b/lib/wasix/src/syscalls/wasix/proc_join.rs
@@ -22,11 +22,13 @@ enum JoinStatusResult {
 /// * `pid` - Handle of the child process to wait on
 //#[instrument(level = "trace", skip_all, fields(pid = ctx.data().process.pid().raw()), ret)]
 pub fn proc_join<M: MemorySize + 'static>(
-    ctx: FunctionEnvMut<'_, WasiEnv>,
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
     pid_ptr: WasmPtr<OptionPid, M>,
     flags: JoinFlags,
     status_ptr: WasmPtr<JoinStatus, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     proc_join_internal(ctx, pid_ptr, flags, status_ptr)
 }
 
@@ -36,8 +38,6 @@ pub(super) fn proc_join_internal<M: MemorySize + 'static>(
     flags: JoinFlags,
     status_ptr: WasmPtr<JoinStatus, M>,
 ) -> Result<Errno, WasiError> {
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
-
     ctx = wasi_try_ok!(maybe_snapshot::<M>(ctx)?);
 
     // This lambda will look at what we wrote in the status variable
diff --git a/lib/wasix/src/syscalls/wasix/proc_parent.rs b/lib/wasix/src/syscalls/wasix/proc_parent.rs
index f1efee7273..fe652b9daf 100644
--- a/lib/wasix/src/syscalls/wasix/proc_parent.rs
+++ b/lib/wasix/src/syscalls/wasix/proc_parent.rs
@@ -3,7 +3,7 @@ use crate::syscalls::*;
 
 /// ### `proc_parent()`
 /// Returns the parent handle of the supplied process
-#[instrument(level = "debug", skip_all, fields(%pid, parent = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(%pid, parent = field::Empty), ret)]
 pub fn proc_parent<M: MemorySize>(
     ctx: FunctionEnvMut<'_, WasiEnv>,
     pid: Pid,
diff --git a/lib/wasix/src/syscalls/wasix/proc_signal.rs b/lib/wasix/src/syscalls/wasix/proc_signal.rs
index 5cb8bf8cb5..9c806405d4 100644
--- a/lib/wasix/src/syscalls/wasix/proc_signal.rs
+++ b/lib/wasix/src/syscalls/wasix/proc_signal.rs
@@ -9,7 +9,7 @@ use crate::syscalls::*;
 /// * `pid` - Handle of the child process to wait on
 /// * `sig` - Signal to send the child process
 #[instrument(level = "trace", skip_all, fields(%pid, ?sig), ret)]
-pub fn proc_signal<M: MemorySize>(
+pub fn proc_signal(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     pid: Pid,
     sig: Signal,
@@ -22,7 +22,7 @@ pub fn proc_signal<M: MemorySize>(
         process.signal_process(sig);
     }
 
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+    WasiEnv::do_pending_operations(&mut ctx)?;
 
     Ok(Errno::Success)
 }
diff --git a/lib/wasix/src/syscalls/wasix/proc_signals_get.rs b/lib/wasix/src/syscalls/wasix/proc_signals_get.rs
new file mode 100644
index 0000000000..de691ca065
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/proc_signals_get.rs
@@ -0,0 +1,30 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `proc_signals_get()`
+/// Gets signals with overridden handlers.
+///
+/// Inputs:
+/// - `__wasi_signal_and_action_t *buf`
+///     A pointer to a buffer to write the signal data.
+#[instrument(level = "trace", skip_all, ret)]
+pub fn proc_signals_get<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    buf: WasmPtr<SignalDisposition, M>,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let (memory, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+
+    let signals = state.signals.lock().unwrap();
+
+    let buf = wasi_try_mem_ok!(buf.slice(&memory, wasi_try_ok!(to_offset::<M>(signals.len()))));
+
+    for (idx, (sig, act)) in signals.iter().enumerate() {
+        wasi_try_mem_ok!(buf.index(idx as u64).write(SignalDisposition {
+            sig: *sig,
+            disp: *act
+        }));
+    }
+
+    Ok(Errno::Success)
+}
diff --git a/lib/wasix/src/syscalls/wasix/proc_signals_sizes_get.rs b/lib/wasix/src/syscalls/wasix/proc_signals_sizes_get.rs
new file mode 100644
index 0000000000..8412abaf88
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/proc_signals_sizes_get.rs
@@ -0,0 +1,32 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `proc_signals_count_get()`
+/// Gets the number of signals with overridden handlers.
+///
+/// Outputs:
+/// - `size_t *signal_count`
+///     The number of signals.
+#[instrument(level = "trace", skip_all, fields(signal_count = field::Empty), ret)]
+pub fn proc_signals_sizes_get<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    signal_count: WasmPtr<M::Offset, M>,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let (memory, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+
+    let signal_count = signal_count.deref(&memory);
+
+    let count_val: M::Offset = wasi_try_ok!(state
+        .signals
+        .lock()
+        .unwrap()
+        .len()
+        .try_into()
+        .map_err(|_| Errno::Overflow));
+    wasi_try_mem_ok!(signal_count.write(count_val));
+
+    Span::current().record("signal_count", u64::try_from(count_val).unwrap());
+
+    Ok(Errno::Success)
+}
diff --git a/lib/wasix/src/syscalls/wasix/proc_snapshot.rs b/lib/wasix/src/syscalls/wasix/proc_snapshot.rs
new file mode 100644
index 0000000000..ec0a1c3faa
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/proc_snapshot.rs
@@ -0,0 +1,16 @@
+use super::*;
+use crate::syscalls::*;
+
+/// Explicitly snapshots the process state.
+#[instrument(level = "trace", skip_all, ret)]
+pub fn proc_snapshot<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    // If we have an Explicit trigger, process that...
+    ctx = wasi_try_ok!(maybe_snapshot_once::<M>(ctx, SnapshotTrigger::Explicit)?);
+    // ... if not, we may still have an external request for a snapshot, so do that as well
+    ctx = wasi_try_ok!(maybe_snapshot::<M>(ctx)?);
+    Ok(Errno::Success)
+}
diff --git a/lib/wasix/src/syscalls/wasix/proc_spawn.rs b/lib/wasix/src/syscalls/wasix/proc_spawn.rs
index 10158c742a..958b9b03f5 100644
--- a/lib/wasix/src/syscalls/wasix/proc_spawn.rs
+++ b/lib/wasix/src/syscalls/wasix/proc_spawn.rs
@@ -23,7 +23,7 @@ use crate::syscalls::*;
 /// ## Return
 ///
 /// Returns a bus process id that can be used to invoke calls
-#[instrument(level = "debug", skip_all, fields(name = field::Empty, working_dir = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(name = field::Empty, working_dir = field::Empty), ret)]
 pub fn proc_spawn<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     name: WasmPtr<u8, M>,
@@ -40,6 +40,8 @@ pub fn proc_spawn<M: MemorySize>(
     working_dir_len: M::Offset,
     ret_handles: WasmPtr<ProcessHandles, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let control_plane = &env.control_plane;
     let memory = unsafe { env.memory_view(&ctx) };
@@ -53,7 +55,7 @@ pub fn proc_spawn<M: MemorySize>(
         .record("working_dir", working_dir.as_str());
 
     if chroot == Bool::True {
-        warn!("chroot is not currently supported",);
+        warn!("chroot is not currently supported");
         return Ok(Errno::Notsup);
     }
 
@@ -103,9 +105,6 @@ pub fn proc_spawn_internal(
 ) -> WasiResult<(ProcessHandles, FunctionEnvMut<'_, WasiEnv>)> {
     let env = ctx.data();
 
-    // Build a new store that will be passed to the thread
-    let new_store = ctx.data().runtime.new_store();
-
     // Fork the current environment and set the new arguments
     let (mut child_env, handle) = match ctx.data().fork() {
         Ok(x) => x,
@@ -117,7 +116,7 @@ pub fn proc_spawn_internal(
     let child_process = child_env.process.clone();
     if let Some(args) = args {
         let mut child_state = env.state.fork();
-        child_state.args = args;
+        child_state.args = std::sync::Mutex::new(args);
         child_env.state = Arc::new(child_state);
     }
 
@@ -146,38 +145,49 @@ pub fn proc_spawn_internal(
     // Replace the STDIO
     let (stdin, stdout, stderr) = {
         let (child_state, child_inodes) = child_env.get_wasi_state_and_inodes();
-        let mut conv_stdio_mode = |mode: WasiStdioMode, fd: WasiFd| -> Result<OptionFd, Errno> {
+        let mut conv_stdio_mode = |mode: WasiStdioMode,
+                                   fd: WasiFd,
+                                   pipe_towards_child: bool|
+         -> Result<OptionFd, Errno> {
             match mode {
                 WasiStdioMode::Piped => {
-                    let (pipe1, pipe2) = Pipe::channel();
-                    let inode1 = child_state.fs.create_inode_with_default_stat(
+                    let (tx, rx) = Pipe::new().split();
+                    let read_inode = child_state.fs.create_inode_with_default_stat(
                         child_inodes,
-                        Kind::Pipe { pipe: pipe1 },
+                        Kind::PipeRx { rx },
                         false,
                         "pipe".into(),
                     );
-                    let inode2 = child_state.fs.create_inode_with_default_stat(
+                    let write_inode = child_state.fs.create_inode_with_default_stat(
                         child_inodes,
-                        Kind::Pipe { pipe: pipe2 },
+                        Kind::PipeTx { tx },
                         false,
                         "pipe".into(),
                     );
 
+                    let (parent_end, child_end) = if pipe_towards_child {
+                        (write_inode, read_inode)
+                    } else {
+                        (read_inode, write_inode)
+                    };
+
                     let rights = crate::net::socket::all_socket_rights();
                     let pipe = ctx.data().state.fs.create_fd(
                         rights,
                         rights,
                         Fdflags::empty(),
+                        Fdflagsext::empty(),
                         0,
-                        inode1,
+                        parent_end,
                     )?;
                     child_state.fs.create_fd_ext(
                         rights,
                         rights,
                         Fdflags::empty(),
+                        Fdflagsext::empty(),
                         0,
-                        inode2,
-                        fd,
+                        child_end,
+                        Some(fd),
                         false,
                     )?;
 
@@ -200,15 +210,17 @@ pub fn proc_spawn_internal(
                 }
             }
         };
-        let stdin = match conv_stdio_mode(stdin, 0) {
+        // TODO: proc_spawn isn't used in WASIX at the time of writing
+        // this code, so the implementation isn't tested at all
+        let stdin = match conv_stdio_mode(stdin, 0, true) {
             Ok(a) => a,
             Err(err) => return Ok(Err(err)),
         };
-        let stdout = match conv_stdio_mode(stdout, 1) {
+        let stdout = match conv_stdio_mode(stdout, 1, false) {
             Ok(a) => a,
             Err(err) => return Ok(Err(err)),
         };
-        let stderr = match conv_stdio_mode(stderr, 2) {
+        let stderr = match conv_stdio_mode(stderr, 2, false) {
             Ok(a) => a,
             Err(err) => return Ok(Err(err)),
         };
@@ -219,30 +231,27 @@ pub fn proc_spawn_internal(
     let bin_factory = Box::new(ctx.data().bin_factory.clone());
     let child_pid = child_env.pid();
 
-    let mut new_store = Some(new_store);
     let mut builder = Some(child_env);
 
     // First we try the built in commands
-    let mut process =
-        match bin_factory.try_built_in(name.clone(), Some(&ctx), &mut new_store, &mut builder) {
-            Ok(a) => a,
-            Err(err) => {
-                if !err.is_not_found() {
-                    error!("builtin failed - {}", err);
-                }
-                // Now we actually spawn the process
-                let child_work =
-                    bin_factory.spawn(name, new_store.take().unwrap(), builder.take().unwrap());
+    let mut process = match bin_factory.try_built_in(name.clone(), Some(&ctx), &mut builder) {
+        Ok(a) => a,
+        Err(err) => {
+            if !err.is_not_found() {
+                error!("builtin failed - {}", err);
+            }
+            // Now we actually spawn the process
+            let child_work = bin_factory.spawn(name, builder.take().unwrap());
 
-                match __asyncify(&mut ctx, None, async move { Ok(child_work.await) })?
-                    .map_err(|err| Errno::Unknown)
-                {
-                    Ok(Ok(a)) => a,
-                    Ok(Err(err)) => return Ok(Err(conv_spawn_err_to_errno(&err))),
-                    Err(err) => return Ok(Err(err)),
-                }
+            match __asyncify(&mut ctx, None, async move { Ok(child_work.await) })?
+                .map_err(|err| Errno::Unknown)
+            {
+                Ok(Ok(a)) => a,
+                Ok(Err(err)) => return Ok(Err(conv_spawn_err_to_errno(&err))),
+                Err(err) => return Ok(Err(err)),
             }
-        };
+        }
+    };
 
     // Add the process to the environment state
     {
diff --git a/lib/wasix/src/syscalls/wasix/proc_spawn2.rs b/lib/wasix/src/syscalls/wasix/proc_spawn2.rs
new file mode 100644
index 0000000000..b907118494
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/proc_spawn2.rs
@@ -0,0 +1,291 @@
+use wasmer::FromToNativeWasmType;
+use wasmer_wasix_types::wasi::ProcSpawnFdOpName;
+
+use super::*;
+use crate::{
+    os::task::{OwnedTaskStatus, TaskStatus},
+    syscalls::*,
+    WasiFs, VIRTUAL_ROOT_FD,
+};
+
+/// Replaces the current process with a new process
+///
+/// ## Parameters
+///
+/// * `name` - Name of the process to be spawned
+/// * `args` - List of the arguments to pass the process
+///   (entries are separated by line feeds)
+/// * `envs` - List of the environment variables to pass process
+///
+/// ## Return
+///
+/// If the execution fails, returns an error code. Does not return otherwise.
+#[instrument(
+    level = "trace",
+    skip_all,
+    fields(name = field::Empty, full_path = field::Empty, pid = field::Empty, tid = field::Empty, %args_len),
+    ret)]
+pub fn proc_spawn2<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    name: WasmPtr<u8, M>,
+    name_len: M::Offset,
+    args: WasmPtr<u8, M>,
+    args_len: M::Offset,
+    envs: WasmPtr<u8, M>,
+    envs_len: M::Offset,
+    fd_ops: WasmPtr<ProcSpawnFdOp<M>, M>,
+    fd_ops_len: M::Offset,
+    signal_actions: WasmPtr<SignalDisposition, M>,
+    signal_actions_len: M::Offset,
+    search_path: Bool,
+    path: WasmPtr<u8, M>,
+    path_len: M::Offset,
+    ret: WasmPtr<Pid, M>,
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    let env = ctx.data();
+    let memory = unsafe { ctx.data().memory_view(&ctx) };
+    let mut name = unsafe { get_input_str_ok!(&memory, name, name_len) };
+    Span::current().record("name", name.as_str());
+    let args = unsafe { get_input_str_ok!(&memory, args, args_len) };
+    let args: Vec<_> = args
+        .split(&['\n', '\r'])
+        .map(|a| a.to_string())
+        .filter(|a| !a.is_empty())
+        .collect();
+
+    let envs = if !envs.is_null() {
+        let envs = unsafe { get_input_str_ok!(&memory, envs, envs_len) };
+
+        let envs = envs
+            .split(&['\n', '\r'])
+            .map(|a| a.to_string())
+            .filter(|a| !a.is_empty());
+
+        let mut vec = vec![];
+        for env in envs {
+            let (key, value) = wasi_try_ok!(env.split_once('=').ok_or(Errno::Inval));
+            vec.push((key.to_string(), value.to_string()));
+        }
+
+        Some(vec)
+    } else {
+        None
+    };
+
+    let signals = if !signal_actions.is_null() {
+        let signal_actions = wasi_try_mem_ok!(signal_actions.slice(&memory, signal_actions_len));
+        let mut vec = Vec::with_capacity(signal_actions.len() as usize);
+        for s in wasi_try_mem_ok!(signal_actions.access()).iter() {
+            vec.push(*s);
+        }
+        Some(vec)
+    } else {
+        None
+    };
+
+    let fd_ops = if !fd_ops.is_null() {
+        let fd_ops = wasi_try_mem_ok!(fd_ops.slice(&memory, fd_ops_len));
+        let mut vec = Vec::with_capacity(fd_ops.len() as usize);
+        for s in wasi_try_mem_ok!(fd_ops.access()).iter() {
+            vec.push(*s);
+        }
+        vec
+    } else {
+        vec![]
+    };
+
+    // Convert relative paths into absolute paths
+    if search_path == Bool::True && !name.contains('/') {
+        let path_str;
+
+        let path = if path.is_null() {
+            vec!["/usr/local/bin", "/bin", "/usr/bin"]
+        } else {
+            path_str = unsafe { get_input_str_ok!(&memory, path, path_len) };
+            path_str.split(':').collect()
+        };
+        let (_, state, inodes) =
+            unsafe { ctx.data().get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+        match find_executable_in_path(&state.fs, inodes, path.iter().map(AsRef::as_ref), &name) {
+            FindExecutableResult::Found(p) => name = p,
+            FindExecutableResult::AccessError => return Ok(Errno::Access),
+            FindExecutableResult::NotFound => return Ok(Errno::Noexec),
+        }
+    } else if name.starts_with("./") {
+        name = ctx.data().state.fs.relative_path_to_absolute(name);
+    }
+
+    Span::current().record("full_path", &name);
+
+    // Fork the environment which will copy all the open file handlers
+    // and associate a new context but otherwise shares things like the
+    // file system interface. The handle to the forked process is stored
+    // in the parent process context
+    let (mut child_env, mut child_handle) = match ctx.data().fork() {
+        Ok(p) => p,
+        Err(err) => {
+            debug!("could not fork process: {err}");
+            // TODO: evaluate the appropriate error code, document it in the spec.
+            return Ok(Errno::Perm);
+        }
+    };
+
+    {
+        let mut inner = ctx.data().process.lock();
+        inner.children.push(child_env.process.clone());
+    }
+
+    // Setup some properties in the child environment
+    let pid = child_env.pid();
+    let tid = child_env.tid();
+    wasi_try_mem_ok!(ret.write(&memory, pid.raw()));
+    Span::current()
+        .record("pid", pid.raw())
+        .record("tid", tid.raw());
+
+    _prepare_wasi(&mut child_env, Some(args), envs, signals);
+
+    for fd_op in fd_ops {
+        wasi_try_ok!(apply_fd_op(&mut child_env, &memory, &fd_op));
+    }
+
+    // Create the process and drop the context
+    let bin_factory = Box::new(child_env.bin_factory.clone());
+
+    let mut builder = Some(child_env);
+
+    let process = match bin_factory.try_built_in(name.clone(), Some(&ctx), &mut builder) {
+        Ok(a) => Ok(a),
+        Err(err) => {
+            if !err.is_not_found() {
+                error!("builtin failed - {}", err);
+            }
+
+            let env = builder.take().unwrap();
+
+            // Spawn a new process with this current execution environment
+            InlineWaker::block_on(bin_factory.spawn(name, env))
+        }
+    };
+
+    match process {
+        Ok(_) => {
+            ctx.data_mut().owned_handles.push(child_handle);
+            trace!(child_pid = %pid, "spawned sub-process");
+            Ok(Errno::Success)
+        }
+        Err(err) => {
+            let err_exit_code = conv_spawn_err_to_exit_code(&err);
+
+            debug!(child_pid = %pid, "process failed with (err={})", err_exit_code);
+
+            Ok(Errno::Noexec)
+        }
+    }
+}
+
+fn apply_fd_op<M: MemorySize>(
+    env: &mut WasiEnv,
+    memory: &MemoryView,
+    op: &ProcSpawnFdOp<M>,
+) -> Result<(), Errno> {
+    match op.cmd {
+        ProcSpawnFdOpName::Close => {
+            if let Ok(fd) = env.state.fs.get_fd(op.fd) {
+                if !fd.is_stdio && fd.inode.is_preopened {
+                    trace!("Skipping close FD action for pre-opened FD ({})", op.fd);
+                    return Ok(());
+                }
+            }
+            env.state.fs.close_fd(op.fd)
+        }
+        ProcSpawnFdOpName::Dup2 => {
+            if let Ok(fd) = env.state.fs.get_fd(op.fd) {
+                if !fd.is_stdio && fd.inode.is_preopened {
+                    warn!(
+                        "FD {} is a pre-open and should not be closed, \
+                        but will be closed in response to a dup2 FD action. \
+                        This will likely break stuff.",
+                        op.fd
+                    );
+                }
+            }
+            if env.state.fs.get_fd(op.fd).is_ok() {
+                env.state.fs.close_fd(op.fd)?;
+            }
+
+            let mut fd_map = env.state.fs.fd_map.write().unwrap();
+            let fd_entry = fd_map.get(op.src_fd).ok_or(Errno::Badf)?;
+
+            let new_fd_entry = Fd {
+                // TODO: verify this is correct
+                inner: FdInner {
+                    offset: fd_entry.inner.offset.clone(),
+                    rights: fd_entry.inner.rights_inheriting,
+                    fd_flags: {
+                        let mut f = fd_entry.inner.fd_flags;
+                        f.set(Fdflagsext::CLOEXEC, false);
+                        f
+                    },
+                    ..fd_entry.inner
+                },
+                inode: fd_entry.inode.clone(),
+                ..*fd_entry
+            };
+
+            // Exclusive insert because we expect `to` to be empty after closing it above
+            fd_map.insert(true, op.fd, new_fd_entry);
+            Ok(())
+        }
+        ProcSpawnFdOpName::Open => {
+            let mut name = unsafe {
+                WasmPtr::<u8, M>::new(op.name)
+                    .read_utf8_string(memory, op.name_len)
+                    .map_err(mem_error_to_wasi)?
+            };
+            name = env.state.fs.relative_path_to_absolute(name.to_owned());
+            match path_open_internal(
+                env,
+                VIRTUAL_ROOT_FD,
+                op.dirflags,
+                &name,
+                op.oflags,
+                op.fs_rights_base,
+                op.fs_rights_inheriting,
+                op.fdflags,
+                op.fdflagsext,
+                Some(op.fd),
+            ) {
+                Err(e) => {
+                    tracing::warn!("Failed to open file for posix_spawn: {:?}", e);
+                    Err(Errno::Io)
+                }
+                Ok(Err(e)) => Err(e),
+                Ok(Ok(_)) => Ok(()),
+            }
+        }
+        ProcSpawnFdOpName::Chdir => {
+            let mut path = unsafe {
+                WasmPtr::<u8, M>::new(op.name)
+                    .read_utf8_string(memory, op.name_len)
+                    .map_err(mem_error_to_wasi)?
+            };
+            path = env.state.fs.relative_path_to_absolute(path.to_owned());
+            chdir_internal(env, &path)
+        }
+        ProcSpawnFdOpName::Fchdir => {
+            let fd = env.state.fs.get_fd(op.fd)?;
+            let inode_kind = fd.inode.read();
+            match inode_kind.deref() {
+                Kind::Dir { path, .. } => {
+                    let path = path.to_str().ok_or(Errno::Notsup)?;
+                    env.state.fs.set_current_dir(path);
+                    Ok(())
+                }
+                _ => Err(Errno::Notdir),
+            }
+        }
+    }
+}
diff --git a/lib/wasix/src/syscalls/wasix/reflect_signature.rs b/lib/wasix/src/syscalls/wasix/reflect_signature.rs
new file mode 100644
index 0000000000..15b03a744e
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/reflect_signature.rs
@@ -0,0 +1,137 @@
+use crate::{state::FunctionLookupError, WasiEnv, WasiError};
+use tracing::{instrument, trace};
+use wasmer::{FunctionEnvMut, MemorySize, Type, WasmPtr, WasmSlice};
+use wasmer_wasix_types::wasi::{Bool, Errno, ReflectionResult, WasmValueType};
+
+fn serialize_types(types: &[Type]) -> Result<Vec<WasmValueType>, Errno> {
+    types
+        .iter()
+        .map(|t| {
+            WasmValueType::try_from(*t).map_err(|_| {
+                trace!("Cannot convert type {} to WasmValueType", t);
+                Errno::Inval
+            })
+        })
+        .collect::<Result<Vec<_>, _>>()
+}
+
+/// Provides information about a function's signature.
+///
+/// ### Errors
+///
+/// Besides the standard error codes, `reflect_signature` may set `errno` to the
+/// following values:
+///
+/// - `Errno::Inval`: The function pointer is not valid, i.e. it does not point to a
+/// function in the indirect function table or the function has a unsupported
+/// signature. The sizes in the result are undefined in this case.
+/// - `Errno::Overflow`: The argument_types and result_types buffers were not big enough
+/// to hold the signature. They will be left unchanged. The reflection result
+/// will be valid.
+#[instrument(
+    level = "trace",
+    skip_all,
+    fields(
+        %function_id,
+        argument_types_ptr = argument_types.offset().into(),
+        argument_types_len,
+        result_types_ptr = result_types.offset().into(),
+        result_types_len,
+        result = result.offset().into()),
+    ret
+)]
+pub fn reflect_signature<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    function_id: u32,
+    argument_types: WasmPtr<WasmValueType, M>,
+    argument_types_len: u16,
+    result_types: WasmPtr<WasmValueType, M>,
+    result_types_len: u16,
+    result: WasmPtr<ReflectionResult, M>,
+) -> Result<Errno, WasiError> {
+    let (env, mut store) = ctx.data_and_store_mut();
+
+    let function_lookup_result = env
+        .inner()
+        .indirect_function_table_lookup(&mut store, function_id);
+
+    let memory = unsafe { env.memory_view(&store) };
+    let signature_info = result.deref(&memory);
+
+    // Look up the function in the indirect function table
+    let function = match function_lookup_result {
+        Ok(f) => f,
+        Err(e) => {
+            let cacheable = match e {
+                FunctionLookupError::Empty(_) => {
+                    if env.inner().is_closure(function_id) {
+                        Bool::False
+                    } else {
+                        Bool::True
+                    }
+                }
+                FunctionLookupError::OutOfBounds(_) => Bool::False,
+                _ => Bool::True,
+            };
+            trace!(
+                "Failed to look up function in indirect function table: {}",
+                e
+            );
+            wasi_try_mem_ok!(signature_info.write(ReflectionResult {
+                cacheable,
+                arguments: 0,
+                results: 0,
+            }));
+            return Ok(e.into());
+        }
+    };
+
+    let is_closure = env.inner().is_closure(function_id);
+    let cacheable = if is_closure { Bool::False } else { Bool::True };
+
+    let function_type = function.ty(&store);
+    let arguments = function_type.params();
+    let results = function_type.results();
+
+    wasi_try_mem_ok!(signature_info.write(ReflectionResult {
+        cacheable,
+        arguments: arguments.len() as u16,
+        results: results.len() as u16,
+    }));
+
+    if (arguments.len() as u16 > argument_types_len) {
+        trace!(
+            "Provided arguments buffer is too small {}/{}",
+            argument_types_len,
+            arguments.len()
+        );
+        return Ok(Errno::Overflow);
+    }
+    if (results.len() as u16 > result_types_len) {
+        trace!(
+            "Provided results buffer is too small {}/{}",
+            result_types_len,
+            results.len()
+        );
+        return Ok(Errno::Overflow);
+    }
+
+    let serialized_argument_types = wasi_try_ok!(serialize_types(function_type.params()));
+    let serialized_result_types = wasi_try_ok!(serialize_types(function_type.results()));
+
+    let mut argument_types_slice = wasi_try_mem_ok!(WasmSlice::<WasmValueType>::new(
+        &memory,
+        argument_types.offset().into(),
+        arguments.len() as u64
+    ));
+    let mut result_types_slice = wasi_try_mem_ok!(WasmSlice::<WasmValueType>::new(
+        &memory,
+        result_types.offset().into(),
+        results.len() as u64
+    ));
+
+    wasi_try_mem_ok!(argument_types_slice.write_slice(&serialized_argument_types));
+    wasi_try_mem_ok!(result_types_slice.write_slice(&serialized_result_types));
+
+    Ok(Errno::Success)
+}
diff --git a/lib/wasix/src/syscalls/wasix/resolve.rs b/lib/wasix/src/syscalls/wasix/resolve.rs
index 2e40e6e682..a7579d381a 100644
--- a/lib/wasix/src/syscalls/wasix/resolve.rs
+++ b/lib/wasix/src/syscalls/wasix/resolve.rs
@@ -19,7 +19,7 @@ use crate::syscalls::*;
 /// ## Return
 ///
 /// The number of IP addresses returned during the DNS resolution.
-#[instrument(level = "debug", skip_all, fields(host = field::Empty, %port), ret)]
+#[instrument(level = "trace", skip_all, fields(host = field::Empty, %port), ret)]
 pub fn resolve<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     host: WasmPtr<u8, M>,
@@ -29,6 +29,8 @@ pub fn resolve<M: MemorySize>(
     naddrs: M::Offset,
     ret_naddrs: WasmPtr<M::Offset, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let naddrs: usize = wasi_try_ok!(naddrs.try_into().map_err(|_| Errno::Inval));
     let mut env = ctx.data();
     let host_str = {
diff --git a/lib/wasix/src/syscalls/wasix/sched_yield.rs b/lib/wasix/src/syscalls/wasix/sched_yield.rs
index aef27d4ef2..e0699d5d18 100644
--- a/lib/wasix/src/syscalls/wasix/sched_yield.rs
+++ b/lib/wasix/src/syscalls/wasix/sched_yield.rs
@@ -7,6 +7,8 @@ use crate::syscalls::*;
 pub fn sched_yield<M: MemorySize + 'static>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     ctx = wasi_try_ok!(maybe_backoff::<M>(ctx)?);
 
     //trace!("wasi[{}:{}]::sched_yield", ctx.data().pid(), ctx.data().tid());
diff --git a/lib/wasix/src/syscalls/wasix/sock_accept.rs b/lib/wasix/src/syscalls/wasix/sock_accept.rs
index 0c317aec8d..b8516660e6 100644
--- a/lib/wasix/src/syscalls/wasix/sock_accept.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_accept.rs
@@ -15,14 +15,14 @@ use crate::{net::socket::TimeType, syscalls::*};
 /// ## Return
 ///
 /// New socket connection
-#[instrument(level = "debug", skip_all, fields(%sock, fd = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(%sock, fd = field::Empty), ret)]
 pub fn sock_accept<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     sock: WasiFd,
     fd_flags: Fdflags,
     ro_fd: WasmPtr<WasiFd, M>,
 ) -> Result<Errno, WasiError> {
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+    WasiEnv::do_pending_operations(&mut ctx)?;
 
     ctx = wasi_try_ok!(maybe_snapshot::<M>(ctx)?);
 
@@ -57,7 +57,7 @@ pub fn sock_accept<M: MemorySize>(
 /// ## Return
 ///
 /// New socket connection
-#[instrument(level = "debug", skip_all, fields(%sock, fd = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(%sock, fd = field::Empty), ret)]
 pub fn sock_accept_v2<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     sock: WasiFd,
@@ -65,7 +65,7 @@ pub fn sock_accept_v2<M: MemorySize>(
     ro_fd: WasmPtr<WasiFd, M>,
     ro_addr: WasmPtr<__wasi_addr_port_t, M>,
 ) -> Result<Errno, WasiError> {
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+    WasiEnv::do_pending_operations(&mut ctx)?;
 
     let env = ctx.data();
     let (memory, state, _) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
@@ -93,7 +93,7 @@ pub fn sock_accept_v2<M: MemorySize>(
         )
         .map_err(|err| {
             tracing::error!("failed to save sock_accepted event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
@@ -126,7 +126,7 @@ pub(crate) fn sock_accept_internal(
         sock,
         Rights::SOCK_ACCEPT,
         move |socket, fd| async move {
-            if fd.flags.contains(Fdflags::NONBLOCK) {
+            if fd.inner.flags.contains(Fdflags::NONBLOCK) {
                 fd_flags.set(Fdflags::NONBLOCK, true);
                 nonblocking = true;
             }
@@ -168,10 +168,12 @@ pub(crate) fn sock_accept_internal(
     let fd = wasi_try_ok_ok!(if let Some(fd) = with_fd {
         state
             .fs
-            .with_fd(rights, rights, new_flags, 0, inode, fd)
+            .with_fd(rights, rights, new_flags, Fdflagsext::empty(), 0, inode, fd)
             .map(|_| fd)
     } else {
-        state.fs.create_fd(rights, rights, new_flags, 0, inode)
+        state
+            .fs
+            .create_fd(rights, rights, new_flags, Fdflagsext::empty(), 0, inode)
     });
     Span::current().record("fd", fd);
 
diff --git a/lib/wasix/src/syscalls/wasix/sock_addr_local.rs b/lib/wasix/src/syscalls/wasix/sock_addr_local.rs
index ac329bfd50..447aa6782e 100644
--- a/lib/wasix/src/syscalls/wasix/sock_addr_local.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_addr_local.rs
@@ -12,7 +12,7 @@ use crate::syscalls::*;
 /// ## Parameters
 ///
 /// * `fd` - Socket that the address is bound to
-#[instrument(level = "debug", skip_all, fields(%sock, addr = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(%sock, addr = field::Empty), ret)]
 pub fn sock_addr_local<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     sock: WasiFd,
@@ -25,7 +25,7 @@ pub fn sock_addr_local<M: MemorySize>(
         |socket, _| socket.addr_local()
     ));
 
-    Span::current().record("addr", &format!("{:?}", addr));
+    Span::current().record("addr", format!("{addr:?}"));
 
     let memory = unsafe { ctx.data().memory_view(&ctx) };
     wasi_try!(crate::net::write_ip_port(
diff --git a/lib/wasix/src/syscalls/wasix/sock_addr_peer.rs b/lib/wasix/src/syscalls/wasix/sock_addr_peer.rs
index c49aea0d07..05ba4a2dbe 100644
--- a/lib/wasix/src/syscalls/wasix/sock_addr_peer.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_addr_peer.rs
@@ -12,7 +12,7 @@ use crate::syscalls::*;
 /// ## Parameters
 ///
 /// * `fd` - Socket that the address is bound to
-#[instrument(level = "debug", skip_all, fields(%sock, addr = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(%sock, addr = field::Empty), ret)]
 pub fn sock_addr_peer<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     sock: WasiFd,
@@ -24,7 +24,7 @@ pub fn sock_addr_peer<M: MemorySize>(
         Rights::empty(),
         |socket, _| socket.addr_peer()
     ));
-    Span::current().record("addr", &format!("{:?}", addr));
+    Span::current().record("addr", format!("{addr:?}"));
 
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
diff --git a/lib/wasix/src/syscalls/wasix/sock_bind.rs b/lib/wasix/src/syscalls/wasix/sock_bind.rs
index bdea8822e3..37bec2ac69 100644
--- a/lib/wasix/src/syscalls/wasix/sock_bind.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_bind.rs
@@ -9,18 +9,20 @@ use crate::syscalls::*;
 ///
 /// * `fd` - File descriptor of the socket to be bind
 /// * `addr` - Address to bind the socket to
-#[instrument(level = "debug", skip_all, fields(%sock, addr = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(%sock, addr = field::Empty), ret)]
 pub fn sock_bind<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     sock: WasiFd,
     addr: WasmPtr<__wasi_addr_port_t, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
 
     let addr = wasi_try_ok!(crate::net::read_ip_port(&memory, addr));
     let addr = SocketAddr::new(addr.0, addr.1);
-    Span::current().record("addr", &format!("{:?}", addr));
+    Span::current().record("addr", format!("{addr:?}"));
 
     wasi_try_ok!(sock_bind_internal(&mut ctx, sock, addr)?);
 
@@ -28,7 +30,7 @@ pub fn sock_bind<M: MemorySize>(
     if ctx.data().enable_journal {
         JournalEffector::save_sock_bind(&mut ctx, sock, addr).map_err(|err| {
             tracing::error!("failed to save sock_bind event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
diff --git a/lib/wasix/src/syscalls/wasix/sock_connect.rs b/lib/wasix/src/syscalls/wasix/sock_connect.rs
index 3942d3dbcb..af9c1450d3 100644
--- a/lib/wasix/src/syscalls/wasix/sock_connect.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_connect.rs
@@ -13,17 +13,19 @@ use crate::syscalls::*;
 ///
 /// * `fd` - Socket descriptor
 /// * `addr` - Address of the socket to connect to
-#[instrument(level = "debug", skip_all, fields(%sock, addr = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(%sock, addr = field::Empty), ret)]
 pub fn sock_connect<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     sock: WasiFd,
     addr: WasmPtr<__wasi_addr_port_t, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
     let addr = wasi_try_ok!(crate::net::read_ip_port(&memory, addr));
     let peer_addr = SocketAddr::new(addr.0, addr.1);
-    Span::current().record("addr", &format!("{:?}", peer_addr));
+    Span::current().record("addr", format!("{peer_addr:?}"));
 
     wasi_try_ok!(sock_connect_internal(&mut ctx, sock, peer_addr)?);
 
@@ -38,7 +40,7 @@ pub fn sock_connect<M: MemorySize>(
         JournalEffector::save_sock_connect(&mut ctx, sock, local_addr, peer_addr).map_err(
             |err| {
                 tracing::error!("failed to save sock_connected event - {}", err);
-                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+                WasiError::Exit(ExitCode::from(Errno::Fault))
             },
         )?;
     }
@@ -59,6 +61,11 @@ pub(crate) fn sock_connect_internal(
         sock,
         Rights::SOCK_CONNECT,
         move |mut socket, flags| async move {
+            // Auto-bind UDP
+            socket = socket
+                .auto_bind_udp(tasks.deref(), net.deref())
+                .await?
+                .unwrap_or(socket);
             socket
                 .connect(
                     tasks.deref(),
diff --git a/lib/wasix/src/syscalls/wasix/sock_get_opt_flag.rs b/lib/wasix/src/syscalls/wasix/sock_get_opt_flag.rs
index 54083606e3..83f1f4d5e4 100644
--- a/lib/wasix/src/syscalls/wasix/sock_get_opt_flag.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_get_opt_flag.rs
@@ -9,7 +9,7 @@ use crate::syscalls::*;
 ///
 /// * `fd` - Socket descriptor
 /// * `sockopt` - Socket option to be retrieved
-#[instrument(level = "debug", skip_all, fields(%sock, %opt), ret)]
+#[instrument(level = "trace", skip_all, fields(%sock, %opt), ret)]
 pub fn sock_get_opt_flag<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     sock: WasiFd,
diff --git a/lib/wasix/src/syscalls/wasix/sock_get_opt_size.rs b/lib/wasix/src/syscalls/wasix/sock_get_opt_size.rs
index cedb2cdf56..dd741284fe 100644
--- a/lib/wasix/src/syscalls/wasix/sock_get_opt_size.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_get_opt_size.rs
@@ -9,7 +9,7 @@ use crate::syscalls::*;
 ///
 /// * `fd` - Socket descriptor
 /// * `sockopt` - Socket option to be retrieved
-#[instrument(level = "debug", skip_all, fields(%sock, %opt), ret)]
+#[instrument(level = "trace", skip_all, fields(%sock, %opt), ret)]
 pub fn sock_get_opt_size<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     sock: WasiFd,
diff --git a/lib/wasix/src/syscalls/wasix/sock_get_opt_time.rs b/lib/wasix/src/syscalls/wasix/sock_get_opt_time.rs
index 02e8386ad0..eaced230fb 100644
--- a/lib/wasix/src/syscalls/wasix/sock_get_opt_time.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_get_opt_time.rs
@@ -8,7 +8,7 @@ use crate::{net::socket::TimeType, syscalls::*};
 ///
 /// * `fd` - Socket descriptor
 /// * `sockopt` - Socket option to be retrieved
-#[instrument(level = "debug", skip_all, fields(%sock, %opt), ret)]
+#[instrument(level = "trace", skip_all, fields(%sock, %opt), ret)]
 pub fn sock_get_opt_time<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     sock: WasiFd,
diff --git a/lib/wasix/src/syscalls/wasix/sock_join_multicast_v4.rs b/lib/wasix/src/syscalls/wasix/sock_join_multicast_v4.rs
index 56ef67e929..909009fa61 100644
--- a/lib/wasix/src/syscalls/wasix/sock_join_multicast_v4.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_join_multicast_v4.rs
@@ -9,13 +9,15 @@ use crate::syscalls::*;
 /// * `fd` - Socket descriptor
 /// * `multiaddr` - Multicast group to joined
 /// * `interface` - Interface that will join
-#[instrument(level = "debug", skip_all, fields(%sock), ret)]
+#[instrument(level = "trace", skip_all, fields(%sock), ret)]
 pub fn sock_join_multicast_v4<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     sock: WasiFd,
     multiaddr: WasmPtr<__wasi_addr_ip4_t, M>,
     iface: WasmPtr<__wasi_addr_ip4_t, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
     let multiaddr = wasi_try_ok!(crate::net::read_ip_v4(&memory, multiaddr));
@@ -30,7 +32,7 @@ pub fn sock_join_multicast_v4<M: MemorySize>(
         JournalEffector::save_sock_join_ipv4_multicast(&mut ctx, sock, multiaddr, iface).map_err(
             |err| {
                 tracing::error!("failed to save sock_join_ipv4_multicast event - {}", err);
-                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+                WasiError::Exit(ExitCode::from(Errno::Fault))
             },
         )?;
     }
diff --git a/lib/wasix/src/syscalls/wasix/sock_join_multicast_v6.rs b/lib/wasix/src/syscalls/wasix/sock_join_multicast_v6.rs
index 420ddfbbd2..3a7fb15e30 100644
--- a/lib/wasix/src/syscalls/wasix/sock_join_multicast_v6.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_join_multicast_v6.rs
@@ -9,13 +9,15 @@ use crate::syscalls::*;
 /// * `fd` - Socket descriptor
 /// * `multiaddr` - Multicast group to joined
 /// * `interface` - Interface that will join
-#[instrument(level = "debug", skip_all, fields(%sock, %iface), ret)]
+#[instrument(level = "trace", skip_all, fields(%sock, %iface), ret)]
 pub fn sock_join_multicast_v6<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     sock: WasiFd,
     multiaddr: WasmPtr<__wasi_addr_ip6_t, M>,
     iface: u32,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
     let multiaddr = wasi_try_ok!(crate::net::read_ip_v6(&memory, multiaddr));
@@ -29,7 +31,7 @@ pub fn sock_join_multicast_v6<M: MemorySize>(
         JournalEffector::save_sock_join_ipv6_multicast(&mut ctx, sock, multiaddr, iface).map_err(
             |err| {
                 tracing::error!("failed to save sock_join_ipv6_multicast event - {}", err);
-                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+                WasiError::Exit(ExitCode::from(Errno::Fault))
             },
         )?;
     }
diff --git a/lib/wasix/src/syscalls/wasix/sock_leave_multicast_v4.rs b/lib/wasix/src/syscalls/wasix/sock_leave_multicast_v4.rs
index b668c628aa..9ca3cf4fbd 100644
--- a/lib/wasix/src/syscalls/wasix/sock_leave_multicast_v4.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_leave_multicast_v4.rs
@@ -9,13 +9,15 @@ use crate::syscalls::*;
 /// * `fd` - Socket descriptor
 /// * `multiaddr` - Multicast group to leave
 /// * `interface` - Interface that will left
-#[instrument(level = "debug", skip_all, fields(%sock), ret)]
+#[instrument(level = "trace", skip_all, fields(%sock), ret)]
 pub fn sock_leave_multicast_v4<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     sock: WasiFd,
     multiaddr: WasmPtr<__wasi_addr_ip4_t, M>,
     iface: WasmPtr<__wasi_addr_ip4_t, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
     let multiaddr = wasi_try_ok!(crate::net::read_ip_v4(&memory, multiaddr));
@@ -30,7 +32,7 @@ pub fn sock_leave_multicast_v4<M: MemorySize>(
         JournalEffector::save_sock_leave_ipv4_multicast(&mut ctx, sock, multiaddr, iface).map_err(
             |err| {
                 tracing::error!("failed to save sock_leave_ipv4_multicast event - {}", err);
-                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+                WasiError::Exit(ExitCode::from(Errno::Fault))
             },
         )?;
     }
diff --git a/lib/wasix/src/syscalls/wasix/sock_leave_multicast_v6.rs b/lib/wasix/src/syscalls/wasix/sock_leave_multicast_v6.rs
index 886bfd563e..2255bda5e6 100644
--- a/lib/wasix/src/syscalls/wasix/sock_leave_multicast_v6.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_leave_multicast_v6.rs
@@ -9,13 +9,15 @@ use crate::syscalls::*;
 /// * `fd` - Socket descriptor
 /// * `multiaddr` - Multicast group to leave
 /// * `interface` - Interface that will left
-#[instrument(level = "debug", skip_all, fields(%sock, %iface), ret)]
+#[instrument(level = "trace", skip_all, fields(%sock, %iface), ret)]
 pub fn sock_leave_multicast_v6<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     sock: WasiFd,
     multiaddr: WasmPtr<__wasi_addr_ip6_t, M>,
     iface: u32,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
     let multiaddr = wasi_try_ok!(crate::net::read_ip_v6(&memory, multiaddr));
@@ -29,7 +31,7 @@ pub fn sock_leave_multicast_v6<M: MemorySize>(
         JournalEffector::save_sock_leave_ipv6_multicast(&mut ctx, sock, multiaddr, iface).map_err(
             |err| {
                 tracing::error!("failed to save sock_leave_ipv6_multicast event - {}", err);
-                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+                WasiError::Exit(ExitCode::from(Errno::Fault))
             },
         )?;
     }
diff --git a/lib/wasix/src/syscalls/wasix/sock_listen.rs b/lib/wasix/src/syscalls/wasix/sock_listen.rs
index c706bd8e2d..708374d7cf 100644
--- a/lib/wasix/src/syscalls/wasix/sock_listen.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_listen.rs
@@ -13,12 +13,14 @@ use crate::{journal::SnapshotTrigger, syscalls::*};
 ///
 /// * `fd` - File descriptor of the socket to be bind
 /// * `backlog` - Maximum size of the queue for pending connections
-#[instrument(level = "debug", skip_all, fields(%sock, %backlog), ret)]
+#[instrument(level = "trace", skip_all, fields(%sock, %backlog), ret)]
 pub fn sock_listen<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     sock: WasiFd,
     backlog: M::Offset,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     ctx = wasi_try_ok!(maybe_snapshot_once::<M>(ctx, SnapshotTrigger::FirstListen)?);
 
     let env = ctx.data();
@@ -30,7 +32,7 @@ pub fn sock_listen<M: MemorySize>(
     if ctx.data().enable_journal {
         JournalEffector::save_sock_listen(&mut ctx, sock, backlog).map_err(|err| {
             tracing::error!("failed to save sock_listen event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
diff --git a/lib/wasix/src/syscalls/wasix/sock_open.rs b/lib/wasix/src/syscalls/wasix/sock_open.rs
index da6de57778..ba68585cb6 100644
--- a/lib/wasix/src/syscalls/wasix/sock_open.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_open.rs
@@ -20,7 +20,7 @@ use crate::{net::socket::SocketProperties, syscalls::*};
 /// ## Return
 ///
 /// The file descriptor of the socket that has been opened.
-#[instrument(level = "debug", skip_all, fields(?af, ?ty, ?pt, sock = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(?af, ?ty, ?pt, sock = field::Empty), ret)]
 pub fn sock_open<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     af: Addressfamily,
@@ -28,6 +28,8 @@ pub fn sock_open<M: MemorySize>(
     pt: SockProto,
     ro_sock: WasmPtr<WasiFd, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     // only certain combinations are supported
     match pt {
         SockProto::Tcp => {
@@ -49,7 +51,7 @@ pub fn sock_open<M: MemorySize>(
     if ctx.data().enable_journal {
         JournalEffector::save_sock_open(&mut ctx, af, ty, pt, fd).map_err(|err| {
             tracing::error!("failed to save sock_open event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
@@ -105,12 +107,25 @@ pub(crate) fn sock_open_internal(
     let fd = wasi_try_ok_ok!(if let Some(fd) = with_fd {
         state
             .fs
-            .with_fd(rights, rights, Fdflags::empty(), 0, inode, fd)
+            .with_fd(
+                rights,
+                rights,
+                Fdflags::empty(),
+                Fdflagsext::empty(),
+                0,
+                inode,
+                fd,
+            )
             .map(|_| fd)
     } else {
-        state
-            .fs
-            .create_fd(rights, rights, Fdflags::empty(), 0, inode)
+        state.fs.create_fd(
+            rights,
+            rights,
+            Fdflags::empty(),
+            Fdflagsext::empty(),
+            0,
+            inode,
+        )
     });
     Span::current().record("sock", fd);
 
diff --git a/lib/wasix/src/syscalls/wasix/sock_pair.rs b/lib/wasix/src/syscalls/wasix/sock_pair.rs
new file mode 100644
index 0000000000..9548c0d017
--- /dev/null
+++ b/lib/wasix/src/syscalls/wasix/sock_pair.rs
@@ -0,0 +1,154 @@
+use virtual_fs::Pipe;
+
+use super::*;
+use crate::{
+    net::socket::{self, SocketProperties},
+    syscalls::*,
+};
+
+// FIXME
+/// ### `sock_pair()`
+/// Create an interconnected socket pair; or at least it's supposed to.
+///
+/// Currently, this creates a pipe rather than a pair of sockets. Before this
+/// syscall was added, wasix-libc would just do pipe2 in its socketpair
+/// implementation. Since we fixed pipe2 to return a simplex pipe, that was no
+/// longer an option; hence this syscall was added, but the implementation
+/// still uses a pipe as the underlying communication mechanism. This is not
+/// the correct implementation and needs to be fixed. We hope that the pipe
+/// is sufficient for anything that doesn't do socket-specific stuff, such
+/// as sending out-of-band packets.
+///
+/// Note: This is (supposed to be) similar to `socketpair` in POSIX using PF_INET
+///
+/// Note 2: This requires hacks in `sock_send` and `sock_recv` as well.
+///
+/// ## Parameters
+///
+/// * `af` - Address family
+/// * `socktype` - Socket type, either datagram or stream
+/// * `sock_proto` - Socket protocol
+///
+/// ## Return
+///
+/// The file descriptor of the socket that has been opened.
+#[instrument(level = "trace", skip_all, fields(?af, ?ty, ?pt, sock1 = field::Empty, sock2 = field::Empty), ret)]
+pub fn sock_pair<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    af: Addressfamily,
+    ty: Socktype,
+    pt: SockProto,
+    ro_sock1: WasmPtr<WasiFd, M>,
+    ro_sock2: WasmPtr<WasiFd, M>,
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
+    // only certain combinations are supported
+    match pt {
+        SockProto::Tcp => {
+            if ty != Socktype::Stream {
+                return Ok(Errno::Notsup);
+            }
+        }
+        SockProto::Udp => {
+            if ty != Socktype::Dgram {
+                return Ok(Errno::Notsup);
+            }
+        }
+        _ => {}
+    }
+
+    // FIXME: currently, socket properties are ignored outright, since they
+    // make no sense for the underlying pipe
+    let (fd1, fd2) = wasi_try_ok!(sock_pair_internal(&mut ctx, None, None));
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_sock_pair(&mut ctx, fd1, fd2).map_err(|err| {
+            tracing::error!("failed to save sock_pair event - {}", err);
+            WasiError::Exit(ExitCode::from(Errno::Fault))
+        })?;
+    }
+
+    let env = ctx.data();
+    let (memory, state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+    wasi_try_mem_ok!(ro_sock1.write(&memory, fd1));
+    wasi_try_mem_ok!(ro_sock2.write(&memory, fd2));
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn sock_pair_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    with_fd1: Option<WasiFd>,
+    with_fd2: Option<WasiFd>,
+) -> Result<(WasiFd, WasiFd), Errno> {
+    let env = ctx.data();
+    let (memory, state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+    let (end1, end2) = Pipe::channel();
+
+    let inode1 = state.fs.create_inode_with_default_stat(
+        inodes,
+        Kind::DuplexPipe { pipe: end1 },
+        false,
+        "socketpair".into(),
+    );
+    let inode2 = state.fs.create_inode_with_default_stat(
+        inodes,
+        Kind::DuplexPipe { pipe: end2 },
+        false,
+        "socketpair".into(),
+    );
+
+    let rights = Rights::all_socket();
+    let fd1 = if let Some(fd) = with_fd1 {
+        state
+            .fs
+            .with_fd(
+                rights,
+                rights,
+                Fdflags::empty(),
+                Fdflagsext::empty(),
+                0,
+                inode1,
+                fd,
+            )
+            .map(|_| fd)?
+    } else {
+        state.fs.create_fd(
+            rights,
+            rights,
+            Fdflags::empty(),
+            Fdflagsext::empty(),
+            0,
+            inode1,
+        )?
+    };
+    let fd2 = if let Some(fd) = with_fd2 {
+        state
+            .fs
+            .with_fd(
+                rights,
+                rights,
+                Fdflags::empty(),
+                Fdflagsext::empty(),
+                0,
+                inode2,
+                fd,
+            )
+            .map(|_| fd)?
+    } else {
+        state.fs.create_fd(
+            rights,
+            rights,
+            Fdflags::empty(),
+            Fdflagsext::empty(),
+            0,
+            inode2,
+        )?
+    };
+    Span::current().record("end1", fd1);
+    Span::current().record("end2", fd2);
+
+    Ok((fd1, fd2))
+}
diff --git a/lib/wasix/src/syscalls/wasix/sock_recv.rs b/lib/wasix/src/syscalls/wasix/sock_recv.rs
index 565a80e3f0..68899d6af1 100644
--- a/lib/wasix/src/syscalls/wasix/sock_recv.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_recv.rs
@@ -26,10 +26,13 @@ pub fn sock_recv<M: MemorySize>(
     ro_data_len: WasmPtr<M::Offset, M>,
     ro_flags: WasmPtr<RoFlags, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let fd_entry = wasi_try_ok!(env.state.fs.get_fd(sock));
     let guard = fd_entry.inode.read();
-    let use_read = matches!(guard.deref(), Kind::Pipe { .. });
+    // We need this hack because we use a pipe to back socket pairs
+    let use_read = matches!(guard.deref(), Kind::DuplexPipe { .. });
     drop(guard);
     if use_read {
         fd_read(ctx, sock, ri_data, ri_data_len, ro_data_len)
@@ -108,12 +111,11 @@ pub(super) fn sock_recv_internal<M: MemorySize>(
     ro_data_len: WasmPtr<M::Offset, M>,
     ro_flags: WasmPtr<RoFlags, M>,
 ) -> WasiResult<usize> {
-    wasi_try_ok_ok!(WasiEnv::process_signals_and_exit(ctx)?);
-
     let mut env = ctx.data();
     let memory = unsafe { env.memory_view(ctx) };
 
     let peek = (ri_flags & __WASI_SOCK_RECV_INPUT_PEEK) != 0;
+    let nonblocking_flag = (ri_flags & __WASI_SOCK_RECV_INPUT_DONT_WAIT) != 0;
     let data = wasi_try_ok_ok!(__sock_asyncify(
         env,
         sock,
@@ -132,7 +134,7 @@ pub(super) fn sock_recv_internal<M: MemorySize>(
                     .access()
                     .map_err(mem_error_to_wasi)?;
 
-                let nonblocking = fd.flags.contains(Fdflags::NONBLOCK);
+                let nonblocking = nonblocking_flag || fd.inner.flags.contains(Fdflags::NONBLOCK);
                 let timeout = socket
                     .opt_time(TimeType::ReadTimeout)
                     .ok()
@@ -145,6 +147,7 @@ pub(super) fn sock_recv_internal<M: MemorySize>(
                         buf.as_mut_uninit(),
                         Some(timeout),
                         nonblocking,
+                        peek,
                     )
                     .await
                 {
diff --git a/lib/wasix/src/syscalls/wasix/sock_recv_from.rs b/lib/wasix/src/syscalls/wasix/sock_recv_from.rs
index 17df5bab3c..7ace6a56d2 100644
--- a/lib/wasix/src/syscalls/wasix/sock_recv_from.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_recv_from.rs
@@ -18,7 +18,7 @@ use crate::{net::socket::TimeType, syscalls::*};
 /// Number of bytes stored in ri_data and message flags.
 #[instrument(level = "trace", skip_all, fields(%sock, nread = field::Empty, peer = field::Empty), ret)]
 pub fn sock_recv_from<M: MemorySize>(
-    ctx: FunctionEnvMut<'_, WasiEnv>,
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
     sock: WasiFd,
     ri_data: WasmPtr<__wasi_iovec_t<M>, M>,
     ri_data_len: M::Offset,
@@ -27,6 +27,8 @@ pub fn sock_recv_from<M: MemorySize>(
     ro_flags: WasmPtr<RoFlags, M>,
     ro_addr: WasmPtr<__wasi_addr_port_t, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     sock_recv_from_internal(
         ctx,
         sock,
@@ -44,17 +46,18 @@ pub(super) fn sock_recv_from_internal<M: MemorySize>(
     sock: WasiFd,
     ri_data: WasmPtr<__wasi_iovec_t<M>, M>,
     ri_data_len: M::Offset,
-    _ri_flags: RiFlags,
+    ri_flags: RiFlags,
     ro_data_len: WasmPtr<M::Offset, M>,
     ro_flags: WasmPtr<RoFlags, M>,
     ro_addr: WasmPtr<__wasi_addr_port_t, M>,
 ) -> Result<Errno, WasiError> {
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
-
     let mut env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
     let iovs_arr = wasi_try_mem_ok!(ri_data.slice(&memory, ri_data_len));
 
+    let peek = (ri_flags & __WASI_SOCK_RECV_INPUT_PEEK) != 0;
+    let nonblocking_flag = (ri_flags & __WASI_SOCK_RECV_INPUT_DONT_WAIT) != 0;
+
     let max_size = {
         let mut max_size = 0usize;
         for iovs in iovs_arr.iter() {
@@ -74,14 +77,21 @@ pub(super) fn sock_recv_from_internal<M: MemorySize>(
                 sock,
                 Rights::SOCK_RECV,
                 |socket, fd| async move {
-                    let nonblocking = fd.flags.contains(Fdflags::NONBLOCK);
+                    let nonblocking =
+                        nonblocking_flag || fd.inner.flags.contains(Fdflags::NONBLOCK);
                     let timeout = socket
                         .opt_time(TimeType::ReadTimeout)
                         .ok()
                         .flatten()
                         .unwrap_or(Duration::from_secs(30));
                     socket
-                        .recv_from(env.tasks().deref(), writer, Some(timeout), nonblocking)
+                        .recv_from(
+                            env.tasks().deref(),
+                            writer,
+                            Some(timeout),
+                            nonblocking,
+                            peek,
+                        )
                         .await
                 },
             ));
@@ -99,7 +109,7 @@ pub(super) fn sock_recv_from_internal<M: MemorySize>(
                 sock,
                 Rights::SOCK_RECV_FROM,
                 |socket, fd| async move {
-                    let nonblocking = fd.flags.contains(Fdflags::NONBLOCK);
+                    let nonblocking = fd.inner.flags.contains(Fdflags::NONBLOCK);
                     let timeout = socket
                         .opt_time(TimeType::ReadTimeout)
                         .ok()
@@ -111,7 +121,13 @@ pub(super) fn sock_recv_from_internal<M: MemorySize>(
                         buf.set_len(max_size);
                     }
                     socket
-                        .recv_from(env.tasks().deref(), &mut buf, Some(timeout), nonblocking)
+                        .recv_from(
+                            env.tasks().deref(),
+                            &mut buf,
+                            Some(timeout),
+                            nonblocking,
+                            peek,
+                        )
                         .await
                         .map(|(amt, addr)| {
                             unsafe {
@@ -134,7 +150,7 @@ pub(super) fn sock_recv_from_internal<M: MemorySize>(
     };
     Span::current()
         .record("nread", bytes_read)
-        .record("peer", &format!("{:?}", peer));
+        .record("peer", format!("{peer:?}"));
 
     wasi_try_ok!(write_ip_port(&memory, ro_addr, peer.ip(), peer.port()));
 
diff --git a/lib/wasix/src/syscalls/wasix/sock_send.rs b/lib/wasix/src/syscalls/wasix/sock_send.rs
index 00b543c50f..f8de621f62 100644
--- a/lib/wasix/src/syscalls/wasix/sock_send.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_send.rs
@@ -25,12 +25,14 @@ pub fn sock_send<M: MemorySize>(
     si_flags: SiFlags,
     ret_data_len: WasmPtr<M::Offset, M>,
 ) -> Result<Errno, WasiError> {
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+    WasiEnv::do_pending_operations(&mut ctx)?;
 
     let env = ctx.data();
     let fd_entry = wasi_try_ok!(env.state.fs.get_fd(fd));
+    let enable_journal = env.enable_journal;
     let guard = fd_entry.inode.read();
-    let use_write = matches!(guard.deref(), Kind::Pipe { .. });
+    // We need this hack because we use a pipe to back socket pairs
+    let use_write = matches!(guard.deref(), Kind::DuplexPipe { .. });
     drop(guard);
 
     let bytes_written = if use_write {
@@ -39,11 +41,11 @@ pub fn sock_send<M: MemorySize>(
             let inodes = state.inodes.clone();
 
             let fd_entry = wasi_try_ok!(state.fs.get_fd(fd));
-            fd_entry.offset.load(Ordering::Acquire) as usize
+            fd_entry.inner.offset.load(Ordering::Acquire) as usize
         };
 
         wasi_try_ok!(fd_write_internal::<M>(
-            &ctx,
+            &mut ctx,
             fd,
             FdWriteSource::Iovs {
                 iovs: si_data,
@@ -51,7 +53,7 @@ pub fn sock_send<M: MemorySize>(
             },
             offset as u64,
             true,
-            env.enable_journal,
+            enable_journal
         )?)
     } else {
         wasi_try_ok!(sock_send_internal::<M>(
@@ -70,7 +72,7 @@ pub fn sock_send<M: MemorySize>(
         JournalEffector::save_sock_send(&ctx, fd, bytes_written, si_data, si_data_len, si_flags)
             .map_err(|err| {
                 tracing::error!("failed to save sock_send event - {}", err);
-                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+                WasiError::Exit(ExitCode::from(Errno::Fault))
             })?;
     }
 
@@ -95,12 +97,14 @@ pub(crate) fn sock_send_internal<M: MemorySize>(
     let memory = unsafe { env.memory_view(&ctx) };
     let runtime = env.runtime.clone();
 
+    let nonblocking_flag = (si_flags & __WASI_SOCK_SEND_INPUT_DONT_WAIT) != 0;
+
     let bytes_written = wasi_try_ok_ok!(__sock_asyncify(
         env,
         sock,
         Rights::SOCK_SEND,
         |socket, fd| async move {
-            let nonblocking = fd.flags.contains(Fdflags::NONBLOCK);
+            let nonblocking = nonblocking_flag || fd.inner.flags.contains(Fdflags::NONBLOCK);
             let timeout = socket
                 .opt_time(TimeType::WriteTimeout)
                 .ok()
diff --git a/lib/wasix/src/syscalls/wasix/sock_send_file.rs b/lib/wasix/src/syscalls/wasix/sock_send_file.rs
index 75500152e6..6df8121ecd 100644
--- a/lib/wasix/src/syscalls/wasix/sock_send_file.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_send_file.rs
@@ -15,7 +15,7 @@ use crate::{net::socket::TimeType, syscalls::*, WasiInodes};
 /// ## Return
 ///
 /// Number of bytes transmitted.
-#[instrument(level = "debug", skip_all, fields(%sock, %in_fd, %offset, %count, nsent = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(%sock, %in_fd, %offset, %count, nsent = field::Empty), ret)]
 pub fn sock_send_file<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     sock: WasiFd,
@@ -24,7 +24,7 @@ pub fn sock_send_file<M: MemorySize>(
     count: Filesize,
     ret_sent: WasmPtr<Filesize, M>,
 ) -> Result<Errno, WasiError> {
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+    WasiEnv::do_pending_operations(&mut ctx)?;
 
     let total_written = wasi_try_ok!(sock_send_file_internal(
         &mut ctx, sock, in_fd, offset, count
@@ -35,7 +35,7 @@ pub fn sock_send_file<M: MemorySize>(
         JournalEffector::save_sock_send_file::<M>(&mut ctx, sock, in_fd, offset, total_written)
             .map_err(|err| {
                 tracing::error!("failed to save sock_send_file event - {}", err);
-                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+                WasiError::Exit(ExitCode::from(Errno::Fault))
             })?;
     }
 
@@ -64,7 +64,7 @@ pub(crate) fn sock_send_file_internal(
     // Set the offset of the file
     {
         let mut fd_map = state.fs.fd_map.write().unwrap();
-        let fd_entry = wasi_try_ok_ok!(fd_map.get_mut(&in_fd).ok_or(Errno::Badf));
+        let fd_entry = wasi_try_ok_ok!(fd_map.get_mut(in_fd).ok_or(Errno::Badf));
         fd_entry.offset.store(offset, Ordering::Release);
     }
 
@@ -75,7 +75,7 @@ pub(crate) fn sock_send_file_internal(
         count -= sub_count;
 
         let fd_entry = wasi_try_ok_ok!(state.fs.get_fd(in_fd));
-        let fd_flags = fd_entry.flags;
+        let fd_flags = fd_entry.inner.flags;
 
         let data = {
             match in_fd {
@@ -95,12 +95,12 @@ pub(crate) fn sock_send_file_internal(
                 }
                 __WASI_STDOUT_FILENO | __WASI_STDERR_FILENO => return Ok(Err(Errno::Inval)),
                 _ => {
-                    if !fd_entry.rights.contains(Rights::FD_READ) {
+                    if !fd_entry.inner.rights.contains(Rights::FD_READ) {
                         // TODO: figure out the error to return when lacking rights
                         return Ok(Err(Errno::Access));
                     }
 
-                    let offset = fd_entry.offset.load(Ordering::Acquire) as usize;
+                    let offset = fd_entry.inner.offset.load(Ordering::Acquire) as usize;
                     let inode = fd_entry.inode;
                     let data = {
                         let mut guard = inode.write();
@@ -146,7 +146,13 @@ pub(crate) fn sock_send_file_internal(
                                         buf.set_len(sub_count as usize);
                                     }
                                     socket
-                                        .recv(tasks.deref(), &mut buf, Some(read_timeout), false)
+                                        .recv(
+                                            tasks.deref(),
+                                            &mut buf,
+                                            Some(read_timeout),
+                                            false,
+                                            false,
+                                        )
                                         .await
                                         .map(|amt| {
                                             unsafe {
@@ -159,7 +165,20 @@ pub(crate) fn sock_send_file_internal(
                                 env = ctx.data();
                                 data
                             }
-                            Kind::Pipe { ref mut pipe, .. } => {
+                            Kind::PipeRx { ref mut rx } => {
+                                let data = wasi_try_ok_ok!(__asyncify(ctx, None, async move {
+                                    // TODO: optimize with MaybeUninit
+                                    let mut buf = vec![0u8; sub_count as usize];
+                                    let amt = virtual_fs::AsyncReadExt::read(rx, &mut buf[..])
+                                        .await
+                                        .map_err(map_io_err)?;
+                                    buf.truncate(amt);
+                                    Ok(buf)
+                                })?);
+                                env = ctx.data();
+                                data
+                            }
+                            Kind::DuplexPipe { ref mut pipe } => {
                                 let data = wasi_try_ok_ok!(__asyncify(ctx, None, async move {
                                     // TODO: optimize with MaybeUninit
                                     let mut buf = vec![0u8; sub_count as usize];
@@ -172,15 +191,14 @@ pub(crate) fn sock_send_file_internal(
                                 env = ctx.data();
                                 data
                             }
-                            Kind::Epoll { .. } => {
+                            Kind::PipeTx { .. }
+                            | Kind::Epoll { .. }
+                            | Kind::EventNotifications { .. } => {
                                 return Ok(Err(Errno::Inval));
                             }
                             Kind::Dir { .. } | Kind::Root { .. } => {
                                 return Ok(Err(Errno::Isdir));
                             }
-                            Kind::EventNotifications { .. } => {
-                                return Ok(Err(Errno::Inval));
-                            }
                             Kind::Symlink { .. } => unimplemented!("Symlinks in wasi::fd_read"),
                             Kind::Buffer { buffer } => {
                                 // TODO: optimize with MaybeUninit
@@ -200,7 +218,7 @@ pub(crate) fn sock_send_file_internal(
 
                     // reborrow
                     let mut fd_map = state.fs.fd_map.write().unwrap();
-                    let fd_entry = wasi_try_ok_ok!(fd_map.get_mut(&in_fd).ok_or(Errno::Badf));
+                    let fd_entry = wasi_try_ok_ok!(fd_map.get_mut(in_fd).ok_or(Errno::Badf));
                     fd_entry
                         .offset
                         .fetch_add(data.len() as u64, Ordering::AcqRel);
diff --git a/lib/wasix/src/syscalls/wasix/sock_send_to.rs b/lib/wasix/src/syscalls/wasix/sock_send_to.rs
index 48ec74675c..d86fad670a 100644
--- a/lib/wasix/src/syscalls/wasix/sock_send_to.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_send_to.rs
@@ -27,6 +27,8 @@ pub fn sock_send_to<M: MemorySize>(
     addr: WasmPtr<__wasi_addr_port_t, M>,
     ret_data_len: WasmPtr<M::Offset, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
     let iovs_arr = wasi_try_mem_ok!(si_data.slice(&memory, si_data_len));
@@ -36,10 +38,10 @@ pub fn sock_send_to<M: MemorySize>(
         wasi_try_ok!(read_ip_port(&memory, addr))
     };
     let addr = SocketAddr::new(addr_ip, addr_port);
-    Span::current().record("addr", &format!("{:?}", addr));
+    Span::current().record("addr", format!("{addr:?}"));
 
     let bytes_written = wasi_try_ok!(sock_send_to_internal(
-        &ctx,
+        &mut ctx,
         sock,
         FdWriteSource::Iovs {
             iovs: si_data,
@@ -62,7 +64,7 @@ pub fn sock_send_to<M: MemorySize>(
         )
         .map_err(|err| {
             tracing::error!("failed to save sock_send_to event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
@@ -78,22 +80,36 @@ pub fn sock_send_to<M: MemorySize>(
 }
 
 pub(crate) fn sock_send_to_internal<M: MemorySize>(
-    ctx: &FunctionEnvMut<'_, WasiEnv>,
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
     sock: WasiFd,
     si_data: FdWriteSource<'_, M>,
-    _si_flags: SiFlags,
+    si_flags: SiFlags,
     addr: SocketAddr,
 ) -> Result<Result<usize, Errno>, WasiError> {
+    let env = ctx.data();
+    let net = env.net().clone();
+    let tasks = ctx.data().tasks().clone();
+
+    // Auto-bind UDP
+    wasi_try_ok_ok!(__sock_upgrade(
+        ctx,
+        sock,
+        Rights::SOCK_SEND_TO,
+        move |mut socket, flags| async move { socket.auto_bind_udp(tasks.deref(), net.deref()).await }
+    ));
+
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
 
+    let nonblocking_flag = (si_flags & __WASI_SOCK_SEND_INPUT_DONT_WAIT) != 0;
+
     let bytes_written = {
         wasi_try_ok_ok!(__sock_asyncify(
             env,
             sock,
             Rights::SOCK_SEND_TO,
             |socket, fd| async move {
-                let nonblocking = fd.flags.contains(Fdflags::NONBLOCK);
+                let nonblocking = nonblocking_flag || fd.inner.flags.contains(Fdflags::NONBLOCK);
                 let timeout = socket
                     .opt_time(TimeType::WriteTimeout)
                     .ok()
diff --git a/lib/wasix/src/syscalls/wasix/sock_set_opt_flag.rs b/lib/wasix/src/syscalls/wasix/sock_set_opt_flag.rs
index 993779520a..c83d93d3e3 100644
--- a/lib/wasix/src/syscalls/wasix/sock_set_opt_flag.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_set_opt_flag.rs
@@ -10,13 +10,15 @@ use crate::syscalls::*;
 /// * `fd` - Socket descriptor
 /// * `sockopt` - Socket option to be set
 /// * `flag` - Value to set the option to
-#[instrument(level = "debug", skip_all, fields(%sock, %opt, %flag), ret)]
+#[instrument(level = "trace", skip_all, fields(%sock, %opt, %flag), ret)]
 pub fn sock_set_opt_flag(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     sock: WasiFd,
     opt: Sockoption,
     flag: Bool,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let flag = match flag {
         Bool::False => false,
         Bool::True => true,
@@ -29,7 +31,7 @@ pub fn sock_set_opt_flag(
     if ctx.data().enable_journal {
         JournalEffector::save_sock_set_opt_flag(&mut ctx, sock, opt, flag).map_err(|err| {
             tracing::error!("failed to save sock_set_opt_flag event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
diff --git a/lib/wasix/src/syscalls/wasix/sock_set_opt_size.rs b/lib/wasix/src/syscalls/wasix/sock_set_opt_size.rs
index a9bdb842b4..3552842dbe 100644
--- a/lib/wasix/src/syscalls/wasix/sock_set_opt_size.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_set_opt_size.rs
@@ -10,20 +10,22 @@ use crate::{net::socket::TimeType, syscalls::*};
 /// * `fd` - Socket descriptor
 /// * `opt` - Socket option to be set
 /// * `size` - Buffer size
-#[instrument(level = "debug", skip_all, fields(%sock, %opt, %size), ret)]
+#[instrument(level = "trace", skip_all, fields(%sock, %opt, %size), ret)]
 pub fn sock_set_opt_size(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     sock: WasiFd,
     opt: Sockoption,
     size: Filesize,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     wasi_try_ok!(sock_set_opt_size_internal(&mut ctx, sock, opt, size)?);
 
     #[cfg(feature = "journal")]
     if ctx.data().enable_journal {
         JournalEffector::save_sock_set_opt_size(&mut ctx, sock, opt, size).map_err(|err| {
             tracing::error!("failed to save sock_set_opt_size event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
diff --git a/lib/wasix/src/syscalls/wasix/sock_set_opt_time.rs b/lib/wasix/src/syscalls/wasix/sock_set_opt_time.rs
index 6196cc5e4a..718fe97bbb 100644
--- a/lib/wasix/src/syscalls/wasix/sock_set_opt_time.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_set_opt_time.rs
@@ -9,13 +9,15 @@ use crate::{net::socket::TimeType, syscalls::*};
 /// * `fd` - Socket descriptor
 /// * `sockopt` - Socket option to be set
 /// * `time` - Value to set the time to
-#[instrument(level = "debug", skip_all, fields(%sock, %opt, time = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(%sock, %opt, time = field::Empty), ret)]
 pub fn sock_set_opt_time<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     sock: WasiFd,
     opt: Sockoption,
     time: WasmPtr<OptionTimestamp, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
     let time = wasi_try_mem_ok!(time.read(&memory));
@@ -24,7 +26,7 @@ pub fn sock_set_opt_time<M: MemorySize>(
         OptionTag::Some => Some(Duration::from_nanos(time.u)),
         _ => return Ok(Errno::Inval),
     };
-    Span::current().record("time", &format!("{:?}", time));
+    Span::current().record("time", format!("{time:?}"));
 
     let ty = match opt {
         Sockoption::RecvTimeout => TimeType::ReadTimeout,
@@ -41,7 +43,7 @@ pub fn sock_set_opt_time<M: MemorySize>(
     if ctx.data().enable_journal {
         JournalEffector::save_sock_set_opt_time(&mut ctx, sock, ty, time).map_err(|err| {
             tracing::error!("failed to save sock_set_opt_time event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
diff --git a/lib/wasix/src/syscalls/wasix/sock_shutdown.rs b/lib/wasix/src/syscalls/wasix/sock_shutdown.rs
index 8ef89634e2..50caf59cb1 100644
--- a/lib/wasix/src/syscalls/wasix/sock_shutdown.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_shutdown.rs
@@ -10,12 +10,14 @@ use crate::syscalls::*;
 /// ## Parameters
 ///
 /// * `how` - Which channels on the socket to shut down.
-#[instrument(level = "debug", skip_all, fields(%sock), ret)]
+#[instrument(level = "trace", skip_all, fields(%sock), ret)]
 pub fn sock_shutdown(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     sock: WasiFd,
     how: SdFlags,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let both = __WASI_SHUT_RD | __WASI_SHUT_WR;
     let shutdown = match how {
         __WASI_SHUT_RD => std::net::Shutdown::Read,
@@ -30,7 +32,7 @@ pub fn sock_shutdown(
     if ctx.data().enable_journal {
         JournalEffector::save_sock_shutdown(&mut ctx, sock, shutdown).map_err(|err| {
             tracing::error!("failed to save sock_shutdown event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
diff --git a/lib/wasix/src/syscalls/wasix/sock_status.rs b/lib/wasix/src/syscalls/wasix/sock_status.rs
index 81a7b96092..e26d0e5153 100644
--- a/lib/wasix/src/syscalls/wasix/sock_status.rs
+++ b/lib/wasix/src/syscalls/wasix/sock_status.rs
@@ -3,7 +3,7 @@ use crate::syscalls::*;
 
 /// ### `sock_status()`
 /// Returns the current status of a socket
-#[instrument(level = "debug", skip_all, fields(%sock, status = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(%sock, status = field::Empty), ret)]
 pub fn sock_status<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     sock: WasiFd,
@@ -23,7 +23,7 @@ pub fn sock_status<M: MemorySize>(
         WasiSocketStatus::Closed => Sockstatus::Closed,
         WasiSocketStatus::Failed => Sockstatus::Failed,
     };
-    Span::current().record("status", &format!("{:?}", status));
+    Span::current().record("status", format!("{status:?}"));
 
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
diff --git a/lib/wasix/src/syscalls/wasix/stack_checkpoint.rs b/lib/wasix/src/syscalls/wasix/stack_checkpoint.rs
index 7100ce79c1..db97b4281c 100644
--- a/lib/wasix/src/syscalls/wasix/stack_checkpoint.rs
+++ b/lib/wasix/src/syscalls/wasix/stack_checkpoint.rs
@@ -18,9 +18,9 @@ pub fn stack_checkpoint<M: MemorySize>(
         trace!("restored - (ret={})", val);
         return Ok(Errno::Success);
     }
-    trace!("capturing",);
+    trace!("capturing");
 
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+    WasiEnv::do_pending_operations(&mut ctx)?;
 
     // Set the return value that we will give back to
     // indicate we are a normal function call that has not yet
@@ -36,7 +36,7 @@ pub fn stack_checkpoint<M: MemorySize>(
 
     // We clear the target memory location before we grab the stack so that
     // it correctly hashes
-    if let Err(err) = snapshot_ptr.write(&memory, StackSnapshot { hash: 0, user: 0 }) {
+    if let Err(err) = snapshot_ptr.write(&memory, StackSnapshot::new(0, 0)) {
         warn!(
             %err
         );
@@ -67,10 +67,7 @@ pub fn stack_checkpoint<M: MemorySize>(
         };
 
         // Build a stack snapshot
-        let snapshot = StackSnapshot {
-            hash,
-            user: ret_offset.into(),
-        };
+        let snapshot = StackSnapshot::new(ret_offset.into(), hash);
 
         // Get a reference directly to the bytes of snapshot
         let val_bytes = unsafe {
@@ -115,7 +112,7 @@ pub fn stack_checkpoint<M: MemorySize>(
             &rewind_stack[..],
             &store_data[..],
         );
-        trace!(hash = snapshot.hash, user = snapshot.user);
+        trace!(hash = snapshot.hash(), user = snapshot.user);
 
         // Save the stack snapshot
         let env = ctx.data();
@@ -131,7 +128,7 @@ pub fn stack_checkpoint<M: MemorySize>(
         let tid = ctx.data().tid();
         match rewind::<M, _>(
             ctx,
-            memory_stack_corrected.freeze(),
+            Some(memory_stack_corrected.freeze()),
             rewind_stack.freeze(),
             store_data,
             0 as Longsize,
diff --git a/lib/wasix/src/syscalls/wasix/stack_restore.rs b/lib/wasix/src/syscalls/wasix/stack_restore.rs
index b601d58f22..112ecf7877 100644
--- a/lib/wasix/src/syscalls/wasix/stack_restore.rs
+++ b/lib/wasix/src/syscalls/wasix/stack_restore.rs
@@ -14,12 +14,14 @@ pub fn stack_restore<M: MemorySize>(
     snapshot_ptr: WasmPtr<StackSnapshot, M>,
     mut val: Longsize,
 ) -> Result<(), WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     // Read the snapshot from the stack
     let env = ctx.data();
     let memory = unsafe { env.memory_view(&ctx) };
     let snapshot = match snapshot_ptr.read(&memory) {
         Ok(a) => {
-            trace!("with_ret={}, hash={}, user={}", val, a.hash, a.user);
+            trace!("with_ret={}, hash={}, user={}", val, a.hash(), a.user);
             a
         }
         Err(err) => {
@@ -33,7 +35,7 @@ pub fn stack_restore<M: MemorySize>(
         // Let the stack (or fail trying!)
         let env = ctx.data();
         if let Some((mut memory_stack, rewind_stack, store_data)) =
-            env.thread.get_snapshot(snapshot.hash)
+            env.thread.get_snapshot(snapshot.hash())
         {
             let env = ctx.data();
             let memory = unsafe { env.memory_view(&ctx) };
@@ -61,7 +63,7 @@ pub fn stack_restore<M: MemorySize>(
         } else {
             warn!(
                 "snapshot stack restore failed - the snapshot can not be found and hence restored (hash={})",
-                snapshot.hash
+                snapshot.hash()
             );
             OnCalledAction::Trap(Box::new(WasiError::Exit(Errno::Unknown.into())))
         }
diff --git a/lib/wasix/src/syscalls/wasix/thread_exit.rs b/lib/wasix/src/syscalls/wasix/thread_exit.rs
index 9282f440a2..d8736c65f5 100644
--- a/lib/wasix/src/syscalls/wasix/thread_exit.rs
+++ b/lib/wasix/src/syscalls/wasix/thread_exit.rs
@@ -3,15 +3,14 @@ use crate::syscalls::*;
 
 /// ### `thread_exit()`
 /// Terminates the current running thread, if this is the last thread then
-/// the process will also exit with the specified exit code. An exit code
-/// of 0 indicates successful termination of the thread. The meanings of
-/// other values is dependent on the environment.
+/// the process will also exit with code 0.
+/// The exit code parameter is a left over from a previous version of this
+/// syscall, maintained here to keep the syscall backwards-compatible, but
+/// is otherwise unused.
 ///
-/// ## Parameters
-///
-/// * `rval` - The exit code returned by the process.
-#[instrument(level = "debug", skip_all, fields(%exitcode), ret)]
-pub fn thread_exit(ctx: FunctionEnvMut<'_, WasiEnv>, exitcode: ExitCode) -> Result<(), WasiError> {
-    tracing::debug!(tid=%ctx.data().thread.id(), %exitcode);
-    Err(WasiError::Exit(exitcode))
+/// This syscall does not return.
+#[instrument(level = "trace", skip_all, fields(%_exitcode), ret)]
+pub fn thread_exit(ctx: FunctionEnvMut<'_, WasiEnv>, _exitcode: u32) -> Result<(), WasiError> {
+    tracing::debug!(tid=%ctx.data().thread.id(), "thread exit");
+    Err(WasiError::ThreadExit)
 }
diff --git a/lib/wasix/src/syscalls/wasix/thread_join.rs b/lib/wasix/src/syscalls/wasix/thread_join.rs
index 9b9c87816b..49c3fb9d63 100644
--- a/lib/wasix/src/syscalls/wasix/thread_join.rs
+++ b/lib/wasix/src/syscalls/wasix/thread_join.rs
@@ -10,11 +10,13 @@ use crate::syscalls::*;
 /// ## Parameters
 ///
 /// * `tid` - Handle of the thread to wait on
-//#[instrument(level = "debug", skip_all, fields(%join_tid), ret)]
+//#[instrument(level = "trace", skip_all, fields(%join_tid), ret)]
 pub fn thread_join<M: MemorySize + 'static>(
-    ctx: FunctionEnvMut<'_, WasiEnv>,
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
     join_tid: Tid,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     thread_join_internal::<M>(ctx, join_tid)
 }
 
@@ -22,7 +24,6 @@ pub(super) fn thread_join_internal<M: MemorySize + 'static>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     join_tid: Tid,
 ) -> Result<Errno, WasiError> {
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
     if let Some(_child_exit_code) = unsafe { handle_rewind::<M, i32>(&mut ctx) } {
         return Ok(Errno::Success);
     }
@@ -37,10 +38,7 @@ pub(super) fn thread_join_internal<M: MemorySize + 'static>(
             other_thread
                 .join()
                 .await
-                .map_err(|err| {
-                    err.as_exit_code()
-                        .unwrap_or(ExitCode::Errno(Errno::Unknown))
-                })
+                .map_err(|err| err.as_exit_code().unwrap_or(ExitCode::from(Errno::Unknown)))
                 .unwrap_or_else(|a| a)
                 .raw()
         })?;
diff --git a/lib/wasix/src/syscalls/wasix/thread_parallelism.rs b/lib/wasix/src/syscalls/wasix/thread_parallelism.rs
index c8c97587e4..51c5770756 100644
--- a/lib/wasix/src/syscalls/wasix/thread_parallelism.rs
+++ b/lib/wasix/src/syscalls/wasix/thread_parallelism.rs
@@ -4,7 +4,7 @@ use crate::syscalls::*;
 /// ### `thread_parallelism()`
 /// Returns the available parallelism which is normally the
 /// number of available cores that can run concurrently
-#[instrument(level = "debug", skip_all, fields(parallelism = field::Empty), ret)]
+#[instrument(level = "trace", skip_all, fields(parallelism = field::Empty), ret)]
 pub fn thread_parallelism<M: MemorySize>(
     ctx: FunctionEnvMut<'_, WasiEnv>,
     ret_parallelism: WasmPtr<M::Offset, M>,
diff --git a/lib/wasix/src/syscalls/wasix/thread_signal.rs b/lib/wasix/src/syscalls/wasix/thread_signal.rs
index 87000502c1..96c9c55765 100644
--- a/lib/wasix/src/syscalls/wasix/thread_signal.rs
+++ b/lib/wasix/src/syscalls/wasix/thread_signal.rs
@@ -7,7 +7,7 @@ use crate::syscalls::*;
 /// Inputs:
 /// - `Signal`
 ///   Signal to be raised for this process
-#[instrument(level = "debug", skip_all, fields(%tid, ?sig), ret)]
+#[instrument(level = "trace", skip_all, fields(%tid, ?sig), ret)]
 pub fn thread_signal(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     tid: Tid,
@@ -20,7 +20,7 @@ pub fn thread_signal(
 
     let env = ctx.data();
 
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+    WasiEnv::do_pending_operations(&mut ctx)?;
 
     Ok(Errno::Success)
 }
diff --git a/lib/wasix/src/syscalls/wasix/thread_sleep.rs b/lib/wasix/src/syscalls/wasix/thread_sleep.rs
index 4925d4d0c7..175f0791fa 100644
--- a/lib/wasix/src/syscalls/wasix/thread_sleep.rs
+++ b/lib/wasix/src/syscalls/wasix/thread_sleep.rs
@@ -9,11 +9,13 @@ use crate::syscalls::*;
 /// ## Parameters
 ///
 /// * `duration` - Amount of time that the thread should sleep
-#[instrument(level = "debug", skip_all, fields(%duration), ret)]
+#[instrument(level = "trace", skip_all, fields(%duration), ret)]
 pub fn thread_sleep<M: MemorySize + 'static>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     duration: Timestamp,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     thread_sleep_internal::<M>(ctx, duration)
 }
 
@@ -21,8 +23,6 @@ pub(crate) fn thread_sleep_internal<M: MemorySize + 'static>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     duration: Timestamp,
 ) -> Result<Errno, WasiError> {
-    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
-
     if let Some(()) = unsafe { handle_rewind::<M, _>(&mut ctx) } {
         return Ok(Errno::Success);
     }
diff --git a/lib/wasix/src/syscalls/wasix/thread_spawn.rs b/lib/wasix/src/syscalls/wasix/thread_spawn.rs
index d40b11afbc..87c4dfd589 100644
--- a/lib/wasix/src/syscalls/wasix/thread_spawn.rs
+++ b/lib/wasix/src/syscalls/wasix/thread_spawn.rs
@@ -4,7 +4,6 @@ use super::*;
 #[cfg(feature = "journal")]
 use crate::journal::JournalEffector;
 use crate::{
-    capture_store_snapshot,
     os::task::thread::WasiMemoryLayout,
     runtime::{
         task_manager::{TaskWasm, TaskWasmRunProperties},
@@ -30,18 +29,20 @@ use wasmer_wasix_types::wasi::ThreadStart;
 ///
 /// Returns the thread index of the newly created thread
 /// (indices always start from the same value as `pid` and increments in steps)
-#[instrument(level = "debug", skip_all, ret)]
+#[instrument(level = "trace", skip_all, ret)]
 pub fn thread_spawn_v2<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     start_ptr: WasmPtr<ThreadStart<M>, M>,
     ret_tid: WasmPtr<Tid, M>,
-) -> Errno {
+) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     // Create the thread
-    let tid = wasi_try!(thread_spawn_internal_from_wasi(&mut ctx, start_ptr));
+    let tid = wasi_try_ok!(thread_spawn_internal_from_wasi(&mut ctx, start_ptr));
 
     // Success
     let memory = unsafe { ctx.data().memory_view(&ctx) };
-    wasi_try_mem!(ret_tid.write(&memory, tid));
+    wasi_try_mem_ok!(ret_tid.write(&memory, tid));
 
     tracing::debug!(
         tid,
@@ -49,7 +50,7 @@ pub fn thread_spawn_v2<M: MemorySize>(
         "spawned new thread"
     );
 
-    Errno::Success
+    Ok(Errno::Success)
 }
 
 pub fn thread_spawn_internal_from_wasi<M: MemorySize>(
@@ -66,10 +67,10 @@ pub fn thread_spawn_internal_from_wasi<M: MemorySize>(
     // Read the properties about the stack which we will use for asyncify
     let layout = {
         let start: ThreadStart<M> = start_ptr.read(&memory).map_err(mem_error_to_wasi)?;
-        let stack_upper: u64 = start.stack_upper.try_into().map_err(|_| Errno::Overflow)?;
-        let stack_size: u64 = start.stack_size.try_into().map_err(|_| Errno::Overflow)?;
-        let guard_size: u64 = start.guard_size.try_into().map_err(|_| Errno::Overflow)?;
-        let tls_base: u64 = start.tls_base.try_into().map_err(|_| Errno::Overflow)?;
+        let stack_upper: u64 = start.stack_upper.into();
+        let stack_size: u64 = start.stack_size.into();
+        let guard_size: u64 = start.guard_size.into();
+        let tls_base: u64 = start.tls_base.into();
         let stack_lower = stack_upper - stack_size;
 
         WasiMemoryLayout {
@@ -77,6 +78,7 @@ pub fn thread_spawn_internal_from_wasi<M: MemorySize>(
             stack_lower,
             guard_size,
             stack_size,
+            tls_base: Some(tls_base),
         }
     };
     tracing::trace!(
@@ -118,9 +120,16 @@ pub fn thread_spawn_internal_using_layout<M: MemorySize>(
     rewind_state: Option<(RewindState, RewindResultType)>,
 ) -> Result<(), Errno> {
     // We extract the memory which will be passed to the thread
-    let env = ctx.data();
+    let func_env = ctx.as_ref();
+    let mut store = ctx.as_store_mut();
+    let env = func_env.as_ref(&store);
     let tasks = env.tasks().clone();
-    let thread_memory = unsafe { env.inner() }.memory_clone();
+
+    let env_inner = env.inner();
+    let module_handles = env_inner.main_module_instance_handles();
+
+    let thread_memory = module_handles.memory_clone();
+    let linker = env_inner.linker().cloned();
 
     // We capture some local variables
     let state = env.state.clone();
@@ -149,32 +158,122 @@ pub fn thread_spawn_internal_using_layout<M: MemorySize>(
 
     // If the process does not export a thread spawn function then obviously
     // we can't spawn a background thread
-    if unsafe { env.inner() }.thread_spawn.is_none() {
+    if module_handles.thread_spawn.is_none() {
         warn!("thread failed - the program does not export a `wasi_thread_start` function");
         return Err(Errno::Notcapable);
     }
-    let thread_module = unsafe { env.inner() }.module_clone();
-    let globals = capture_store_snapshot(&mut ctx.as_store_mut());
-    let spawn_type =
-        crate::runtime::SpawnMemoryType::ShareMemory(thread_memory, ctx.as_store_ref());
+    let thread_module = module_handles.module_clone();
+    let spawn_type = match linker {
+        Some(linker) => crate::runtime::SpawnType::NewLinkerInstanceGroup(linker, func_env, store),
+        None => crate::runtime::SpawnType::ShareMemory(thread_memory, store.as_store_ref()),
+    };
 
     // Now spawn a thread
     trace!("threading: spawning background thread");
     let run = move |props: TaskWasmRunProperties| {
         execute_module(props.ctx, props.store);
     };
-    tasks
-        .task_wasm(
-            TaskWasm::new(Box::new(run), thread_env, thread_module, false)
-                .with_globals(&globals)
-                .with_memory(spawn_type),
-        )
-        .map_err(Into::<Errno>::into)?;
+
+    let mut task_wasm = TaskWasm::new(Box::new(run), thread_env, thread_module, false, false)
+        .with_memory(spawn_type);
+
+    tasks.task_wasm(task_wasm).map_err(Into::<Errno>::into)?;
 
     // Success
     Ok(())
 }
 
+// This function calls into the module
+fn call_module_internal<M: MemorySize>(
+    env: &WasiFunctionEnv,
+    store: &mut Store,
+    start_ptr_offset: M::Offset,
+) -> Result<(), DeepSleepWork> {
+    // We either call the reactor callback or the thread spawn callback
+    //trace!("threading: invoking thread callback (reactor={})", reactor);
+
+    // Note: we ensure both unwraps can happen before getting to this point
+    let spawn = env
+        .data(&store)
+        .inner()
+        .main_module_instance_handles()
+        .thread_spawn
+        .clone()
+        .unwrap();
+    let tid = env.data(&store).tid();
+    let thread_result = spawn.call(
+        store,
+        tid.raw().try_into().map_err(|_| Errno::Overflow).unwrap(),
+        start_ptr_offset
+            .try_into()
+            .map_err(|_| Errno::Overflow)
+            .unwrap(),
+    );
+    trace!("callback finished (ret={:?})", thread_result);
+
+    let exit_code = handle_thread_result(env, store, thread_result)?;
+
+    // Clean up the environment on exit
+    env.on_exit(store, exit_code);
+    Ok(())
+}
+
+fn handle_thread_result(
+    env: &WasiFunctionEnv,
+    store: &mut Store,
+    err: Result<(), RuntimeError>,
+) -> Result<Option<ExitCode>, DeepSleepWork> {
+    let tid = env.data(&store).tid();
+    let pid = env.data(&store).pid();
+    let Err(err) = err else {
+        trace!("thread exited cleanly without calling thread_exit");
+        return Ok(None);
+    };
+    match err.downcast::<WasiError>() {
+        Ok(WasiError::ThreadExit) => {
+            trace!("thread exited cleanly");
+            Ok(None)
+        }
+        Ok(WasiError::Exit(code)) => {
+            trace!(exit_code = ?code, "thread requested exit");
+            if !code.is_success() {
+                // TODO: Why do we need to taint the runtime on a non-zero exit code? Why not also for zero?
+                env.data(&store)
+                    .runtime
+                    .on_taint(TaintReason::NonZeroExitCode(code));
+            };
+            Ok(Some(code))
+        }
+        Ok(WasiError::DeepSleep(deep)) => {
+            trace!("entered a deep sleep");
+            Err(deep)
+        }
+        Ok(WasiError::UnknownWasiVersion) => {
+            eprintln!(
+                "Thread {tid} of process {pid} failed because it has an unknown wasix version"
+            );
+            env.data(&store)
+                .runtime
+                .on_taint(TaintReason::UnknownWasiVersion);
+            Ok(Some(ExitCode::from(129)))
+        }
+        Ok(WasiError::DlSymbolResolutionFailed(symbol)) => {
+            eprintln!("Thread {tid} of process {pid} failed to find required symbol: {symbol}");
+            env.data(&store)
+                .runtime
+                .on_taint(TaintReason::DlSymbolResolutionFailed(symbol.clone()));
+            Ok(Some(ExitCode::from(129)))
+        }
+        Err(err) => {
+            eprintln!("Thread {tid} of process {pid} failed with runtime error: {err}");
+            env.data(&store)
+                .runtime
+                .on_taint(TaintReason::RuntimeError(err));
+            Ok(Some(ExitCode::from(129)))
+        }
+    }
+}
+
 /// Calls the module
 fn call_module<M: MemorySize>(
     mut ctx: WasiFunctionEnv,
@@ -182,69 +281,10 @@ fn call_module<M: MemorySize>(
     start_ptr_offset: M::Offset,
     thread_handle: Arc<WasiThreadHandle>,
     rewind_state: Option<(RewindState, RewindResultType)>,
-) -> Result<Tid, Errno> {
+) {
     let env = ctx.data(&store);
     let tasks = env.tasks().clone();
 
-    // This function calls into the module
-    let call_module_internal = move |env: &WasiFunctionEnv, store: &mut Store| {
-        // We either call the reactor callback or the thread spawn callback
-        //trace!("threading: invoking thread callback (reactor={})", reactor);
-        let spawn = unsafe { env.data(&store).inner() }
-            .thread_spawn
-            .clone()
-            .unwrap();
-        let tid = env.data(&store).tid();
-        let call_ret = spawn.call(
-            store,
-            tid.raw().try_into().map_err(|_| Errno::Overflow).unwrap(),
-            start_ptr_offset
-                .try_into()
-                .map_err(|_| Errno::Overflow)
-                .unwrap(),
-        );
-        let mut ret = Errno::Success;
-        if let Err(err) = call_ret {
-            match err.downcast::<WasiError>() {
-                Ok(WasiError::Exit(code)) => {
-                    ret = if code.is_success() {
-                        Errno::Success
-                    } else {
-                        env.data(&store)
-                            .runtime
-                            .on_taint(TaintReason::NonZeroExitCode(code));
-                        Errno::Noexec
-                    };
-                }
-                Ok(WasiError::DeepSleep(deep)) => {
-                    trace!("entered a deep sleep");
-                    return Err(deep);
-                }
-                Ok(WasiError::UnknownWasiVersion) => {
-                    debug!("failed as wasi version is unknown",);
-                    env.data(&store)
-                        .runtime
-                        .on_taint(TaintReason::UnknownWasiVersion);
-                    ret = Errno::Noexec;
-                }
-                Err(err) => {
-                    debug!("failed with runtime error: {}", err);
-                    env.data(&store)
-                        .runtime
-                        .on_taint(TaintReason::RuntimeError(err));
-                    ret = Errno::Noexec;
-                }
-            }
-        }
-        trace!("callback finished (ret={})", ret);
-
-        // Clean up the environment
-        env.on_exit(store, Some(ret.into()));
-
-        // Return the result
-        Ok(ret as u32)
-    };
-
     // If we need to rewind then do so
     if let Some((rewind_state, rewind_result)) = rewind_state {
         let mut ctx = ctx.env.clone().into_mut(&mut store);
@@ -256,42 +296,37 @@ fn call_module<M: MemorySize>(
             rewind_result,
         );
         if res != Errno::Success {
-            return Err(res);
+            return;
         }
     }
 
     // Now invoke the module
-    let ret = call_module_internal(&ctx, &mut store);
+    let ret = call_module_internal::<M>(&ctx, &mut store, start_ptr_offset);
 
     // If it went to deep sleep then we need to handle that
-    match ret {
-        Ok(ret) => {
-            // Frees the handle so that it closes
-            drop(thread_handle);
-            Ok(ret as Pid)
-        }
-        Err(deep) => {
-            // Create the callback that will be invoked when the thread respawns after a deep sleep
-            let rewind = deep.rewind;
-            let respawn = {
-                let tasks = tasks.clone();
-                move |ctx, store, trigger_res| {
-                    // Call the thread
-                    call_module::<M>(
-                        ctx,
-                        store,
-                        start_ptr_offset,
-                        thread_handle,
-                        Some((rewind, RewindResultType::RewindWithResult(trigger_res))),
-                    );
-                }
-            };
+    if let Err(deep) = ret {
+        // Create the callback that will be invoked when the thread respawns after a deep sleep
+        let rewind = deep.rewind;
+        let respawn = {
+            let tasks = tasks.clone();
+            move |ctx, store, trigger_res| {
+                // Call the thread
+                call_module::<M>(
+                    ctx,
+                    store,
+                    start_ptr_offset,
+                    thread_handle,
+                    Some((rewind, RewindResultType::RewindWithResult(trigger_res))),
+                );
+            }
+        };
 
-            /// Spawns the WASM process after a trigger
-            unsafe {
-                tasks.resume_wasm_after_poller(Box::new(respawn), ctx, store, deep.trigger)
-            };
-            Err(Errno::Unknown)
-        }
-    }
+        /// Spawns the WASM process after a trigger
+        unsafe {
+            tasks.resume_wasm_after_poller(Box::new(respawn), ctx, store, deep.trigger)
+        };
+        return;
+    };
+    // I don't think we need to do this explicitly, but it was done before refactoring so we keep it for now.
+    drop(thread_handle);
 }
diff --git a/lib/wasix/src/syscalls/wasix/tty_get.rs b/lib/wasix/src/syscalls/wasix/tty_get.rs
index 937917a5af..93d28dd740 100644
--- a/lib/wasix/src/syscalls/wasix/tty_get.rs
+++ b/lib/wasix/src/syscalls/wasix/tty_get.rs
@@ -3,7 +3,7 @@ use crate::syscalls::*;
 
 /// ### `tty_get()`
 /// Retrieves the current state of the TTY
-#[instrument(level = "debug", skip_all, ret)]
+#[instrument(level = "trace", skip_all, ret)]
 pub fn tty_get<M: MemorySize>(
     ctx: FunctionEnvMut<'_, WasiEnv>,
     tty_state: WasmPtr<Tty, M>,
diff --git a/lib/wasix/src/syscalls/wasix/tty_set.rs b/lib/wasix/src/syscalls/wasix/tty_set.rs
index 24866d9f5b..7252223663 100644
--- a/lib/wasix/src/syscalls/wasix/tty_set.rs
+++ b/lib/wasix/src/syscalls/wasix/tty_set.rs
@@ -3,11 +3,13 @@ use crate::{syscalls::*, WasiTtyState};
 
 /// ### `tty_set()`
 /// Updates the properties of the rect
-#[instrument(level = "debug", skip_all, ret)]
+#[instrument(level = "trace", skip_all, ret)]
 pub fn tty_set<M: MemorySize>(
     mut ctx: FunctionEnvMut<'_, WasiEnv>,
     tty_state: WasmPtr<Tty, M>,
 ) -> Result<Errno, WasiError> {
+    WasiEnv::do_pending_operations(&mut ctx)?;
+
     let env = ctx.data();
 
     let memory = unsafe { env.memory_view(&ctx) };
@@ -44,7 +46,7 @@ pub fn tty_set<M: MemorySize>(
     if env.enable_journal {
         JournalEffector::save_tty_set(&mut ctx, state).map_err(|err| {
             tracing::error!("failed to save path symbolic link event - {}", err);
-            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            WasiError::Exit(ExitCode::from(Errno::Fault))
         })?;
     }
 
diff --git a/lib/wasix/src/utils/mod.rs b/lib/wasix/src/utils/mod.rs
index 798c9482d3..cd93005286 100644
--- a/lib/wasix/src/utils/mod.rs
+++ b/lib/wasix/src/utils/mod.rs
@@ -11,22 +11,12 @@ pub use self::{dummy_waker::WasiDummyWaker, thread_parker::WasiParkingLot};
 pub(crate) use owned_mutex_guard::{
     read_owned, write_owned, OwnedRwLockReadGuard, OwnedRwLockWriteGuard,
 };
-use rand::RngCore;
-use wasmer_types::ModuleHash;
 
 use std::collections::BTreeSet;
 
 use wasmer::Module;
 use wasmer_wasix_types::wasi::Errno;
 
-/// Creates a random xxhash for the module
-pub fn xxhash_random() -> ModuleHash {
-    let mut rand = rand::thread_rng();
-    let mut key = [0u8; 8];
-    rand.fill_bytes(&mut key);
-    ModuleHash::xxhash_from_bytes(key)
-}
-
 /// Check if a provided module is compiled for some version of WASI.
 /// Use [`get_wasi_version`] to find out which version of WASI the module is.
 pub fn is_wasi_module(module: &Module) -> bool {
diff --git a/lib/wasix/src/utils/owned_mutex_guard.rs b/lib/wasix/src/utils/owned_mutex_guard.rs
index 4edc7103d1..f2ab5812e9 100644
--- a/lib/wasix/src/utils/owned_mutex_guard.rs
+++ b/lib/wasix/src/utils/owned_mutex_guard.rs
@@ -115,7 +115,7 @@ where
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(guard) = self.guard.as_ref() {
-            write!(f, "{:?}", guard)
+            write!(f, "{guard:?}")
         } else {
             write!(f, "none")
         }
@@ -128,7 +128,7 @@ where
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(guard) = self.guard.as_ref() {
-            write!(f, "{}", guard)
+            write!(f, "{guard}")
         } else {
             write!(f, "none")
         }
@@ -193,7 +193,7 @@ where
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(guard) = self.guard.as_ref() {
-            write!(f, "{:?}", guard)
+            write!(f, "{guard:?}")
         } else {
             write!(f, "none")
         }
@@ -206,7 +206,7 @@ where
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(guard) = self.guard.as_ref() {
-            write!(f, "{}", guard)
+            write!(f, "{guard}")
         } else {
             write!(f, "none")
         }
diff --git a/lib/wasix/tests/envvar.rs b/lib/wasix/tests/envvar.rs
index a76f23115b..2c82c81287 100644
--- a/lib/wasix/tests/envvar.rs
+++ b/lib/wasix/tests/envvar.rs
@@ -10,14 +10,14 @@ fn get_env_var(var_name: &str) -> Result<String, env::VarError> {
 
 fn main() {
     let mut env_vars = env::vars()
-        .map(|(key, value)| format!("{}={}", key, value))
+        .map(|(key, value)| format!("{key}={value}"))
         .collect::<Vec<String>>();
 
     env_vars.sort();
 
     println!("Env vars:");
     for e in env_vars {
-        println!("{}", e);
+        println!("{e}");
     }
 
     env::set_var("WASI_ENVVAR_TEST", "HELLO");
diff --git a/lib/wasix/tests/runners.rs b/lib/wasix/tests/runners.rs
index b58c41e599..3d67e9a8c9 100644
--- a/lib/wasix/tests/runners.rs
+++ b/lib/wasix/tests/runners.rs
@@ -2,17 +2,19 @@
 // there.
 #![cfg(not(target_family = "wasm"))]
 
+use std::sync::Once;
 use std::{
     path::{Path, PathBuf},
     sync::Arc,
     time::Duration,
 };
 
+static INIT: Once = Once::new();
+
 use reqwest::Client;
 use tokio::runtime::Handle;
-use wasmer::Engine;
 use wasmer_wasix::{
-    http::{reqwest::get_proxy, HttpClient},
+    http::HttpClient,
     runners::Runner,
     runtime::{
         module_cache::{FileSystemCache, ModuleCache, SharedCache},
@@ -21,18 +23,29 @@ use wasmer_wasix::{
     },
     PluggableRuntime, Runtime,
 };
-use webc::Container;
 
 mod wasi {
     use virtual_fs::{AsyncReadExt, AsyncSeekExt};
-    use wasmer_wasix::{bin_factory::BinaryPackage, runners::wasi::WasiRunner, WasiError};
+    use wasmer_package::utils::from_bytes;
+    use wasmer_wasix::{
+        bin_factory::BinaryPackage,
+        runners::wasi::{RuntimeOrEngine, WasiRunner},
+        WasiError,
+    };
 
     use super::*;
 
+    fn setup() {
+        INIT.call_once(|| {
+            env_logger::builder()
+                .filter_level(log::LevelFilter::Debug)
+                .init();
+        });
+    }
     #[tokio::test]
     async fn can_run_wat2wasm() {
         let webc = download_cached("https://wasmer.io/wasmer/wabt@1.0.37").await;
-        let container = Container::from_bytes(webc).unwrap();
+        let container = from_bytes(webc).unwrap();
         let command = &container.manifest().commands["wat2wasm"];
 
         assert!(WasiRunner::can_run_command(command).unwrap());
@@ -40,21 +53,24 @@ mod wasi {
 
     #[tokio::test(flavor = "multi_thread")]
     async fn wat2wasm() {
+        setup();
         let webc = download_cached("https://wasmer.io/wasmer/wabt@1.0.37").await;
-        let container = Container::from_bytes(webc).unwrap();
+        let container = from_bytes(webc).unwrap();
         let (rt, tasks) = runtime();
         let pkg = BinaryPackage::from_webc(&container, &rt).await.unwrap();
         let mut stdout = virtual_fs::ArcFile::new(Box::<virtual_fs::BufferFile>::default());
+        let mut stderr = virtual_fs::ArcFile::new(Box::<virtual_fs::BufferFile>::default());
 
         let stdout_2 = stdout.clone();
+        let stderr_2 = stderr.clone();
         let handle = std::thread::spawn(move || {
             let _guard = tasks.runtime_handle().enter();
             WasiRunner::new()
                 .with_args(["--version"])
                 .with_stdin(Box::<virtual_fs::NullFile>::default())
                 .with_stdout(Box::new(stdout_2) as Box<_>)
-                .with_stderr(Box::<virtual_fs::NullFile>::default())
-                .run_command("wat2wasm", &pkg, Arc::new(rt))
+                .with_stderr(Box::new(stderr_2) as Box<_>)
+                .run_command("wat2wasm", &pkg, RuntimeOrEngine::Runtime(Arc::new(rt)))
         });
 
         handle
@@ -63,34 +79,62 @@ mod wasi {
             .expect("The runner encountered an error");
 
         stdout.rewind().await.unwrap();
-        let mut output = Vec::new();
-        stdout.read_to_end(&mut output).await.unwrap();
-        assert_eq!(String::from_utf8(output).unwrap(), "1.0.37 (git~v1.0.37)\n");
+        stderr.rewind().await.unwrap();
+        let mut stdout_buf = Vec::new();
+        let mut stderr_buf = Vec::new();
+        stdout.read_to_end(&mut stdout_buf).await.unwrap();
+        stderr.read_to_end(&mut stderr_buf).await.unwrap();
+        let stdout = String::from_utf8(stdout_buf).unwrap();
+        let stderr = String::from_utf8(stderr_buf).unwrap();
+
+        eprintln!("{stdout}");
+        eprintln!("{stderr}");
+
+        assert_eq!(stdout, "1.0.37 (git~v1.0.37)\n");
     }
 
     #[tokio::test(flavor = "multi_thread")]
     async fn python() {
+        setup();
+
         let webc = download_cached("https://wasmer.io/python/python@0.1.0").await;
         let (rt, tasks) = runtime();
-        let container = Container::from_bytes(webc).unwrap();
+        let container = from_bytes(webc).unwrap();
         let pkg = BinaryPackage::from_webc(&container, &rt).await.unwrap();
+        let mut stdout = virtual_fs::ArcFile::new(Box::<virtual_fs::BufferFile>::default());
+        let mut stderr = virtual_fs::ArcFile::new(Box::<virtual_fs::BufferFile>::default());
+
+        let stdout_2 = stdout.clone();
+        let stderr_2 = stderr.clone();
 
         let handle = std::thread::spawn(move || {
             let _guard = tasks.runtime_handle().enter();
             WasiRunner::new()
                 .with_args(["-c", "import sys; sys.exit(42)"])
                 .with_stdin(Box::<virtual_fs::NullFile>::default())
-                .with_stdout(Box::<virtual_fs::NullFile>::default())
-                .with_stderr(Box::<virtual_fs::NullFile>::default())
-                .run_command("python", &pkg, Arc::new(rt))
+                .with_stdout(Box::new(stdout_2) as Box<_>)
+                .with_stderr(Box::new(stderr_2) as Box<_>)
+                .run_command("python", &pkg, RuntimeOrEngine::Runtime(Arc::new(rt)))
         });
 
+        stdout.rewind().await.unwrap();
+        stderr.rewind().await.unwrap();
+        let mut stdout_buf = Vec::new();
+        let mut stderr_buf = Vec::new();
+        stdout.read_to_end(&mut stdout_buf).await.unwrap();
+        stderr.read_to_end(&mut stderr_buf).await.unwrap();
+        let stdout = String::from_utf8(stdout_buf).unwrap();
+        let stderr = String::from_utf8(stderr_buf).unwrap();
+
+        eprintln!("{stdout}");
+        eprintln!("{stderr}");
+
         let err = handle.join().unwrap().unwrap_err();
         let runtime_error = err.chain().find_map(|e| e.downcast_ref::<WasiError>());
         let exit_code = match runtime_error {
             Some(WasiError::Exit(code)) => *code,
-            Some(other) => panic!("Something else went wrong: {:?}", other),
-            None => panic!("Not a WasiError: {:?}", err),
+            Some(other) => panic!("Something else went wrong: {other:?}"),
+            None => panic!("Not a WasiError: {err:?}"),
         };
         assert_eq!(exit_code.raw(), 42);
     }
@@ -103,6 +147,7 @@ mod wcgi {
     use futures::{channel::mpsc::Sender, future::AbortHandle, SinkExt, StreamExt};
     use rand::Rng;
     use tokio::runtime::Handle;
+    use wasmer_package::utils::from_bytes;
     use wasmer_wasix::{
         bin_factory::BinaryPackage,
         runners::wcgi::{NoOpWcgiCallbacks, WcgiRunner},
@@ -113,7 +158,7 @@ mod wcgi {
     #[tokio::test]
     async fn can_run_staticserver() {
         let webc = download_cached("https://wasmer.io/Michael-F-Bryan/staticserver@1.0.3").await;
-        let container = Container::from_bytes(webc).unwrap();
+        let container = from_bytes(webc).unwrap();
 
         let entrypoint = container.manifest().entrypoint.as_ref().unwrap();
         assert!(WcgiRunner::can_run_command(&container.manifest().commands[entrypoint]).unwrap());
@@ -123,7 +168,7 @@ mod wcgi {
     async fn staticserver() {
         let webc = download_cached("https://wasmer.io/Michael-F-Bryan/staticserver@1.0.3").await;
         let (rt, tasks) = runtime();
-        let container = Container::from_bytes(webc).unwrap();
+        let container = from_bytes(webc).unwrap();
         let mut runner = WcgiRunner::new(NoOpWcgiCallbacks);
         let port = rand::thread_rng().gen_range(10000_u16..65535_u16);
         let (cb, started) = callbacks(Handle::current());
@@ -173,6 +218,7 @@ mod wcgi {
         (cb, fut)
     }
 
+    #[derive(Debug)]
     struct Callbacks {
         sender: Sender<AbortHandle>,
         handle: Handle,
@@ -202,9 +248,9 @@ async fn download_cached(url: &str) -> bytes::Bytes {
     let cache_dir = tmp_dir().join("downloads");
     let cached_path = cache_dir.join(file_name);
 
-    if cached_path.exists() {
-        return std::fs::read(&cached_path).unwrap().into();
-    }
+    //if cached_path.exists() {
+    //    return std::fs::read(&cached_path).unwrap().into();
+    //}
 
     let response = client()
         .get(url)
@@ -228,6 +274,15 @@ async fn download_cached(url: &str) -> bytes::Bytes {
     body
 }
 
+pub fn get_proxy() -> Result<Option<reqwest::Proxy>, anyhow::Error> {
+    if let Ok(scheme) = std::env::var("http_proxy").or_else(|_| std::env::var("HTTP_PROXY")) {
+        let proxy = reqwest::Proxy::all(scheme)?;
+        Ok(Some(proxy))
+    } else {
+        Ok(None)
+    }
+}
+
 fn client() -> Client {
     let builder = {
         let mut builder = reqwest::ClientBuilder::new().connect_timeout(Duration::from_secs(30));
@@ -236,9 +291,8 @@ fn client() -> Client {
         }
         builder
     };
-    let client = builder.build().unwrap();
 
-    client
+    builder.build().unwrap()
 }
 
 #[cfg(not(target_os = "windows"))]
@@ -271,8 +325,7 @@ fn runtime() -> (impl Runtime + Send + Sync, Arc<TokioTaskManager>) {
     let http_client: Arc<dyn HttpClient + Send + Sync> =
         Arc::new(wasmer_wasix::http::default_http_client().unwrap());
 
-    rt.set_engine(Some(Engine::default()))
-        .set_module_cache(cache)
+    rt.set_module_cache(cache)
         .set_package_loader(
             BuiltinPackageLoader::new()
                 .with_cache_dir(cache_dir)
diff --git a/lib/wasix/tests/stdio.rs b/lib/wasix/tests/stdio.rs
index 9875aae75b..6e49ba9e46 100644
--- a/lib/wasix/tests/stdio.rs
+++ b/lib/wasix/tests/stdio.rs
@@ -1,21 +1,26 @@
 use virtual_fs::{AsyncReadExt, AsyncWriteExt};
-use wasmer::{Module, Store};
-use wasmer_wasix::{Pipe, WasiEnv};
+use virtual_mio::InlineWaker;
+use wasmer::Module;
+use wasmer_types::ModuleHash;
+use wasmer_wasix::{
+    runners::wasi::{RuntimeOrEngine, WasiRunner},
+    Pipe,
+};
 
 mod sys {
-    #[tokio::test]
-    async fn test_stdout() {
-        super::test_stdout().await;
+    #[test]
+    fn test_stdout() {
+        super::test_stdout();
     }
 
-    #[tokio::test]
-    async fn test_stdin() {
-        super::test_stdin().await;
+    #[test]
+    fn test_stdin() {
+        super::test_stdin();
     }
 
-    #[tokio::test]
-    async fn test_env() {
-        super::test_env().await;
+    #[test]
+    fn test_env() {
+        super::test_env();
     }
 }
 
@@ -39,9 +44,19 @@ mod sys {
 //     }
 // }
 
-async fn test_stdout() {
-    let mut store = Store::default();
-    let module = Module::new(&store, br#"
+fn test_stdout() {
+    #[cfg(not(target_arch = "wasm32"))]
+    let runtime = tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .build()
+        .unwrap();
+    #[cfg(not(target_arch = "wasm32"))]
+    let handle = runtime.handle().clone();
+    #[cfg(not(target_arch = "wasm32"))]
+    let _guard = handle.enter();
+
+    let engine = wasmer::Engine::default();
+    let module = Module::new(&engine, br#"
     (module
         ;; Import the required fd_write WASI function which will write the given io vectors to stdout
         ;; The function signature for fd_write is:
@@ -74,31 +89,41 @@ async fn test_stdout() {
     // Create the `WasiEnv`.
     let (stdout_tx, mut stdout_rx) = Pipe::channel();
 
-    let builder = WasiEnv::builder("command-name")
-        .args(["Gordon"])
-        .stdout(Box::new(stdout_tx));
-
-    #[cfg(feature = "js")]
     {
-        builder.run_with_store(module, &mut store).unwrap();
-    }
-    #[cfg(not(feature = "js"))]
-    {
-        std::thread::spawn(move || builder.run_with_store(module, &mut store))
-            .join()
-            .unwrap()
+        let mut runner = WasiRunner::new();
+        runner
+            .with_stdout(Box::new(stdout_tx))
+            .with_args(["Gordon"]);
+
+        runner
+            .run_wasm(
+                RuntimeOrEngine::Engine(engine),
+                "command-name",
+                module,
+                ModuleHash::random(),
+            )
             .unwrap();
     }
 
     let mut stdout_str = String::new();
-    stdout_rx.read_to_string(&mut stdout_str).await.unwrap();
+    InlineWaker::block_on(stdout_rx.read_to_string(&mut stdout_str)).unwrap();
     let stdout_as_str = stdout_str.as_str();
     assert_eq!(stdout_as_str, "hello world");
 }
 
-async fn test_env() {
-    let mut store = Store::default();
-    let module = Module::new(&store, include_bytes!("envvar.wasm")).unwrap();
+fn test_env() {
+    #[cfg(not(target_arch = "wasm32"))]
+    let runtime = tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .build()
+        .unwrap();
+    #[cfg(not(target_arch = "wasm32"))]
+    let handle = runtime.handle().clone();
+    #[cfg(not(target_arch = "wasm32"))]
+    let _guard = handle.enter();
+
+    let engine = wasmer::Engine::default();
+    let module = Module::new(&engine, include_bytes!("envvar.wasm")).unwrap();
 
     #[cfg(feature = "js")]
     tracing_wasm::set_as_global_default_with_config({
@@ -110,57 +135,61 @@ async fn test_env() {
     // Create the `WasiEnv`.
     let (pipe_tx, mut pipe_rx) = Pipe::channel();
 
-    let builder = WasiEnv::builder("command-name")
-        .args(["Gordon"])
-        .env("DOG", "X")
-        .env("TEST", "VALUE")
-        .env("TEST2", "VALUE2")
-        .stdout(Box::new(pipe_tx));
-
-    #[cfg(feature = "js")]
     {
-        builder.run_with_store(module, &mut store).unwrap();
-    }
-
-    #[cfg(not(feature = "js"))]
-    {
-        std::thread::spawn(move || builder.run_with_store(module, &mut store))
-            .join()
-            .unwrap()
+        let mut runner = WasiRunner::new();
+        runner
+            .with_stdout(Box::new(pipe_tx))
+            .with_args(["Gordon"])
+            .with_envs([("DOG", "X"), ("TEST", "VALUE"), ("TEST2", "VALUE2")]);
+
+        runner
+            .run_wasm(
+                RuntimeOrEngine::Engine(engine),
+                "command-name",
+                module,
+                ModuleHash::random(),
+            )
             .unwrap();
     }
 
     let mut stdout_str = String::new();
-    pipe_rx.read_to_string(&mut stdout_str).await.unwrap();
+    InlineWaker::block_on(pipe_rx.read_to_string(&mut stdout_str)).unwrap();
     let stdout_as_str = stdout_str.as_str();
     assert_eq!(stdout_as_str, "Env vars:\nDOG=X\nTEST2=VALUE2\nTEST=VALUE\nDOG Ok(\"X\")\nDOG_TYPE Err(NotPresent)\nSET VAR Ok(\"HELLO\")\n");
 }
 
-async fn test_stdin() {
-    let mut store = Store::default();
-    let module = Module::new(&store, include_bytes!("stdin-hello.wasm")).unwrap();
+fn test_stdin() {
+    #[cfg(not(target_arch = "wasm32"))]
+    let runtime = tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .build()
+        .unwrap();
+    #[cfg(not(target_arch = "wasm32"))]
+    let handle = runtime.handle().clone();
+    #[cfg(not(target_arch = "wasm32"))]
+    let _guard = handle.enter();
+
+    let engine = wasmer::Engine::default();
+    let module = Module::new(&engine, include_bytes!("stdin-hello.wasm")).unwrap();
 
     // Create the `WasiEnv`.
     let (mut pipe_tx, pipe_rx) = Pipe::channel();
-    // FIXME: needed? (method not available)
-    // .with_blocking(false);
 
     // Write to STDIN
     let buf = "Hello, stdin!\n".as_bytes().to_owned();
-    pipe_tx.write_all(&buf[..]).await.unwrap();
+    InlineWaker::block_on(pipe_tx.write_all(&buf[..])).unwrap();
 
-    let builder = WasiEnv::builder("command-name").stdin(Box::new(pipe_rx));
-
-    #[cfg(feature = "js")]
     {
-        builder.run_with_store(module, &mut store).unwrap();
-    }
-
-    #[cfg(not(feature = "js"))]
-    {
-        std::thread::spawn(move || builder.run_with_store(module, &mut store))
-            .join()
-            .unwrap()
+        let mut runner = WasiRunner::new();
+        runner.with_stdin(Box::new(pipe_rx));
+
+        runner
+            .run_wasm(
+                RuntimeOrEngine::Engine(engine),
+                "command-name",
+                module,
+                ModuleHash::random(),
+            )
             .unwrap();
     }
 
diff --git a/lib/wasm-interface/Cargo.toml b/lib/wasm-interface/Cargo.toml
deleted file mode 100644
index c071307414..0000000000
--- a/lib/wasm-interface/Cargo.toml
+++ /dev/null
@@ -1,29 +0,0 @@
-[package]
-name = "wasmer-wasm-interface"
-description = "WASM Interface definition and parser"
-readme = "README.md"
-authors.workspace = true
-edition.workspace = true
-homepage.workspace = true
-license.workspace = true
-repository.workspace = true
-rust-version.workspace = true
-version.workspace = true
-
-[dependencies]
-bincode = { version = "1", optional = true }
-either = "1.5"
-nom = "5"
-serde = { version = "1", features = ["derive"] }
-wasmparser = { workspace = true, optional = true }
-
-[dev-dependencies]
-wat = "1.0"
-
-[features]
-validation = ["wasmparser"]
-binary_encode = ["bincode"]
-default = ["validation"]
-
-[package.metadata.docs.rs]
-rustc-args = ["--cfg", "docsrs"]
diff --git a/lib/wasm-interface/README.md b/lib/wasm-interface/README.md
deleted file mode 100644
index c3526b6431..0000000000
--- a/lib/wasm-interface/README.md
+++ /dev/null
@@ -1,88 +0,0 @@
-# Wasm Interface
-
-This is an experimental crate for validating the imports and exports of a WebAssembly module.
-
-For the time being, Wasm Interface provides:
-
-- a convenient text format for specifying the requirements of Wasm modules
-- a convenient way to compose interfaces safely (it ensures no conflicts (duplicates are allowed but they must agree))
-- validation that the modules meet the requirements
-
-## Syntax example
-
-Here's the interface for the current version of [WASI](https://github.com/WebAssembly/WASI):
-
-```lisp
-(interface "wasi_unstable"
-  ;; Here's a bunch of function imports!
-  (func (import "wasi_unstable" "args_get") (param i32 i32) (result i32))
-  (func (import "wasi_unstable" "args_sizes_get") (param i32 i32) (result i32))
-  (func (import "wasi_unstable" "clock_res_get") (param i32 i32) (result i32))
-  (func (import "wasi_unstable" "clock_time_get") (param i32 i32 i32) (result i32))
-  (func (import "wasi_unstable" "environ_get") (param i32 i32) (result i32))
-  (func (import "wasi_unstable" "environ_sizes_get") (param i32 i32) (result i32))
-  (func (import "wasi_unstable" "fd_advise") (param i32 i64 i64 i32) (result i32))
-  (func (import "wasi_unstable" "fd_allocate") (param i32 i64 i64) (result i32))
-  (func (import "wasi_unstable" "fd_close") (param i32) (result i32))
-  (func (import "wasi_unstable" "fd_datasync") (param i32) (result i32))
-  (func (import "wasi_unstable" "fd_fdstat_get") (param i32 i32) (result i32))
-  (func (import "wasi_unstable" "fd_fdstat_set_flags") (param i32 i32) (result i32))
-  (func (import "wasi_unstable" "fd_fdstat_set_rights") (param i32 i64 i64) (result i32))
-  (func (import "wasi_unstable" "fd_filestat_get") (param i32 i32) (result i32))
-  (func (import "wasi_unstable" "fd_filestat_set_size") (param i32 i64) (result i32))
-  (func (import "wasi_unstable" "fd_filestat_set_times") (param i32 i64 i64 i32) (result i32))
-  (func (import "wasi_unstable" "fd_pread") (param i32 i32 i32 i64 i32) (result i32))
-  (func (import "wasi_unstable" "fd_prestat_get") (param i32 i32) (result i32))
-  (func (import "wasi_unstable" "fd_prestat_dir_name") (param i32 i32 i32) (result i32))
-  (func (import "wasi_unstable" "fd_pwrite") (param i32 i32 i32 i64 i32) (result i32))
-  (func (import "wasi_unstable" "fd_read") (param i32 i32 i32 i32) (result i32))
-  (func (import "wasi_unstable" "fd_readdir") (param i32 i32 i32 i64 i32) (result i32))
-  (func (import "wasi_unstable" "fd_renumber") (param i32 i32) (result i32))
-  (func (import "wasi_unstable" "fd_seek") (param i32 i64 i32 i32) (result i32))
-  (func (import "wasi_unstable" "fd_sync") (param i32) (result i32))
-  (func (import "wasi_unstable" "fd_tell") (param i32 i32) (result i32))
-  (func (import "wasi_unstable" "fd_write") (param i32 i32 i32 i32) (result i32))
-  (func (import "wasi_unstable" "path_create_directory") (param i32 i32 i32) (result i32))
-  (func (import "wasi_unstable" "path_filestat_get") (param i32 i32 i32 i32 i32) (result i32))
-  (func (import "wasi_unstable" "path_filestat_set_times") (param i32 i32 i32 i32 i64 i64 i32) (result i32))
-  (func (import "wasi_unstable" "path_link") (param i32 i32 i32 i32 i32 i32 i32) (result i32))
-  (func (import "wasi_unstable" "path_open") (param i32 i32 i32 i32 i32 i64 i64 i32 i32) (result i32))
-  (func (import "wasi_unstable" "path_readlink") (param i32 i32 i32 i32 i32 i32) (result i32))
-  (func (import "wasi_unstable" "path_remove_directory") (param i32 i32 i32) (result i32))
-  (func (import "wasi_unstable" "path_rename") (param i32 i32 i32 i32 i32 i32) (result i32))
-  (func (import "wasi_unstable" "path_symlink") (param i32 i32 i32 i32 i32) (result i32))
-  (func (import "wasi_unstable" "path_unlink_file") (param i32 i32 i32) (result i32))
-  (func (import "wasi_unstable" "poll_oneoff") (param i32 i32 i32 i32) (result i32))
-  (func (import "wasi_unstable" "proc_exit") (param i32))
-  (func (import "wasi_unstable" "proc_raise") (param i32) (result i32))
-  (func (import "wasi_unstable" "random_get") (param i32 i32) (result i32))
-  (func (import "wasi_unstable" "sched_yield") (result i32))
-  (func (import "wasi_unstable" "sock_recv") (param i32 i32 i32 i32 i32 i32) (result i32))
-  (func (import "wasi_unstable" "sock_send") (param i32 i32 i32 i32 i32) (result i32))
-  (func (import "wasi_unstable" "sock_shutdown") (param i32 i32) (result i32))
-)
-```
-
-
-Notes:
-- multiple `assert-import` and `assert-export` declarations are allowed.
-- comments (starts with `;` and ends with a newline) and whitespace are valid between any tokens
-
-## Semantics
-
-All imports used by the module must be specified in the interface.
-
-All exports in the interface must be exported by the module.
-
-Thus the module may have additional exports than the interface or fewer imports than the interface specifies and be considered valid.
-
-
-## Misc
-
-Wasm Interface serves a slightly different purpose than the proposed WebIDL for Wasm standard, but may be replaced by it in the future if things change.
-
-Due to an issue with nested closures in Rust, `wasm-interface` can't both compile on stable and have good error reporting. This is being fixed and `wasm-interface` will be updated to have better error handling.
-
-See the `parser.rs` file for a comment containing the grammar in a BNF style.
-
-Suggestions, contributions, and thoughts welcome! This is an experiment in the early stages, but we hope to work with the wider community and develop this in cooperation with all interested parties.
diff --git a/lib/wasm-interface/src/interface.rs b/lib/wasm-interface/src/interface.rs
deleted file mode 100644
index 12a4d1f755..0000000000
--- a/lib/wasm-interface/src/interface.rs
+++ /dev/null
@@ -1,205 +0,0 @@
-//! The definition of a WASM interface
-
-use crate::interface_matcher::InterfaceMatcher;
-use serde::{Deserialize, Serialize};
-use std::collections::{hash_map::Entry, HashMap, HashSet};
-
-#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
-pub struct Interface {
-    /// The name the interface gave itself
-    pub name: Option<String>,
-    /// Things that the module can import
-    pub imports: HashMap<(String, String), Import>,
-    /// Things that the module must export
-    pub exports: HashMap<String, Export>,
-}
-
-impl Interface {
-    pub fn merge(&self, other: Interface) -> Result<Interface, String> {
-        let mut base = self.clone();
-
-        for (key, val) in other.imports {
-            match base.imports.entry(key) {
-                Entry::Occupied(e) if *e.get() != val => {
-                    let (namespace, name) = e.key();
-                    let original_value = e.get();
-                    return Err(format!("Conflict detected: the import \"{namespace}\" \"{name}\" was found but the definitions were different: {original_value:?} {val:?}"));
-                }
-                Entry::Occupied(_) => {
-                    // it's okay for the imported items to be the same.
-                }
-                Entry::Vacant(e) => {
-                    e.insert(val);
-                }
-            };
-        }
-
-        for (key, val) in other.exports {
-            match base.exports.entry(key) {
-                Entry::Occupied(e) if *e.get() != val => {
-                    let name = e.key();
-                    let original_value = e.get();
-                    return Err(format!("Conflict detected: the key \"{name}\" was found in exports but the definitions were different: {original_value:?} {val:?}"));
-                }
-                Entry::Occupied(_) => {
-                    // it's okay for the exported items to be the same.
-                }
-                Entry::Vacant(e) => {
-                    e.insert(val);
-                }
-            };
-        }
-
-        Ok(base)
-    }
-
-    pub fn create_interface_matcher(&self) -> InterfaceMatcher {
-        let mut namespaces = HashSet::new();
-        let mut namespace_imports: HashMap<String, HashSet<Import>> =
-            HashMap::with_capacity(self.imports.len());
-        let mut exports = HashSet::with_capacity(self.exports.len());
-
-        for (_, import) in self.imports.iter() {
-            match import {
-                Import::Func { namespace, .. } | Import::Global { namespace, .. } => {
-                    if !namespaces.contains(namespace) {
-                        namespaces.insert(namespace.clone());
-                    }
-                    let ni = namespace_imports.entry(namespace.clone()).or_default();
-                    ni.insert(import.clone());
-                }
-            }
-        }
-        for (_, export) in self.exports.iter() {
-            exports.insert(export.clone());
-        }
-        InterfaceMatcher {
-            namespaces,
-            namespace_imports,
-            exports,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub enum Import {
-    Func {
-        namespace: String,
-        name: String,
-        params: Vec<WasmType>,
-        result: Vec<WasmType>,
-    },
-    Global {
-        namespace: String,
-        name: String,
-        var_type: WasmType,
-    },
-}
-
-impl Import {
-    pub fn format_key(ns: &str, name: &str) -> (String, String) {
-        (ns.to_string(), name.to_string())
-    }
-
-    /// Get the key used to look this import up in the Interface's import hashmap
-    pub fn get_key(&self) -> (String, String) {
-        match self {
-            Import::Func {
-                namespace, name, ..
-            }
-            | Import::Global {
-                namespace, name, ..
-            } => Self::format_key(namespace, name),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub enum Export {
-    Func {
-        name: String,
-        params: Vec<WasmType>,
-        result: Vec<WasmType>,
-    },
-    Global {
-        name: String,
-        var_type: WasmType,
-    },
-}
-
-impl Export {
-    pub fn format_key(name: &str) -> String {
-        name.to_string()
-    }
-
-    /// Get the key used to look this export up in the Interface's export hashmap
-    pub fn get_key(&self) -> String {
-        match self {
-            Export::Func { name, .. } | Export::Global { name, .. } => Self::format_key(name),
-        }
-    }
-}
-
-/// Primitive wasm type
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub enum WasmType {
-    I32,
-    I64,
-    F32,
-    F64,
-}
-
-impl std::fmt::Display for WasmType {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(
-            f,
-            "{}",
-            match self {
-                WasmType::I32 => "i32",
-                WasmType::I64 => "i64",
-                WasmType::F32 => "f32",
-                WasmType::F64 => "f64",
-            }
-        )
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::parser;
-
-    #[test]
-    fn merging_works() {
-        let interface1_src =
-            r#"(interface (func (import "env" "plus_one") (param i32) (result i32)))"#;
-        let interface2_src =
-            r#"(interface (func (import "env" "plus_one") (param i64) (result i64)))"#;
-        let interface3_src =
-            r#"(interface (func (import "env" "times_two") (param i64) (result i64)))"#;
-        let interface4_src =
-            r#"(interface (func (import "env" "times_two") (param i64 i64) (result i64)))"#;
-        let interface5_src = r#"(interface (func (export "empty_bank_account") (param) (result)))"#;
-        let interface6_src =
-            r#"(interface (func (export "empty_bank_account") (param) (result i64)))"#;
-
-        let interface1 = parser::parse_interface(interface1_src).unwrap();
-        let interface2 = parser::parse_interface(interface2_src).unwrap();
-        let interface3 = parser::parse_interface(interface3_src).unwrap();
-        let interface4 = parser::parse_interface(interface4_src).unwrap();
-        let interface5 = parser::parse_interface(interface5_src).unwrap();
-        let interface6 = parser::parse_interface(interface6_src).unwrap();
-
-        assert!(interface1.merge(interface2.clone()).is_err());
-        assert!(interface2.merge(interface1.clone()).is_err());
-        assert!(interface1.merge(interface3.clone()).is_ok());
-        assert!(interface2.merge(interface3.clone()).is_ok());
-        assert!(interface3.merge(interface2).is_ok());
-        assert!(
-            interface1.merge(interface1.clone()).is_ok(),
-            "exact matches are accepted"
-        );
-        assert!(interface3.merge(interface4).is_err());
-        assert!(interface5.merge(interface5.clone()).is_ok());
-        assert!(interface5.merge(interface6).is_err());
-    }
-}
diff --git a/lib/wasm-interface/src/interface_matcher.rs b/lib/wasm-interface/src/interface_matcher.rs
deleted file mode 100644
index c9bf62b06f..0000000000
--- a/lib/wasm-interface/src/interface_matcher.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-use serde::{Deserialize, Serialize};
-use std::collections::{HashMap, HashSet};
-
-use crate::interface::{Export, Import};
-
-/// A struct containing data for more efficient matching.
-///
-/// An ideal use case for this is to parse [`Interface`]s at compile time,
-/// create [`InterfaceMatcher`]s, and store them as bytes so that they
-/// can be efficiently loaded at runtime for matching.
-#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
-pub struct InterfaceMatcher {
-    pub namespaces: HashSet<String>,
-    pub namespace_imports: HashMap<String, HashSet<Import>>,
-    pub exports: HashSet<Export>,
-}
-
-#[cfg(feature = "binary_encode")]
-impl InterfaceMatcher {
-    /// Store the matcher as bytes to avoid reparsing
-    fn into_bytes(&self) -> Vec<u8> {
-        bincode::serialize(self).expect("Could not serialize InterfaceMatcher")
-    }
-
-    /// Load the matcher from bytes to avoid reparsing
-    fn from_bytes(bytes: &[u8]) -> Option<Self> {
-        bincode::deserialize(bytes).ok()
-    }
-}
diff --git a/lib/wasm-interface/src/lib.rs b/lib/wasm-interface/src/lib.rs
deleted file mode 100644
index 9dea4482b3..0000000000
--- a/lib/wasm-interface/src/lib.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-#![type_length_limit = "5795522"]
-//! Definition and parsing of wasm interfaces
-//!
-//! wasm interfaces ensure wasm modules conform to a specific shape
-//! they do this by asserting on the imports and exports of the module.
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
-
-pub mod interface;
-pub mod interface_matcher;
-pub mod parser;
-#[cfg(feature = "validation")]
-pub mod validate;
-
-pub use interface::*;
diff --git a/lib/wasm-interface/src/parser.rs b/lib/wasm-interface/src/parser.rs
deleted file mode 100644
index 03475a9b30..0000000000
--- a/lib/wasm-interface/src/parser.rs
+++ /dev/null
@@ -1,596 +0,0 @@
-//! Parsers to get a wasm interface from text
-//!
-//! The grammar of the text format is:
-//! interface = "(" interface name? interface-entry* ")"
-//! interface-entry = func | global
-//!
-//! func = import-fn | export-fn
-//! global = import-global | export-global
-//!
-//! import-fn = "(" "func" import-id param-list? result-list? ")"
-//! import-global = "(" "global" import-id type-decl ")"
-//! import-id = "(" "import" namespace name ")"
-//!
-//! export-fn = "(" "func" export-id param-list? result-list? ")"
-//! export-global = "(" "global" export-id type-decl ")"
-//! export-id = "(" export name ")"
-//!
-//! param-list = "(" param type* ")"
-//! result-list = "(" result type* ")"
-//! type-decl = "(" "type" type ")"
-//! namespace = "\"" identifier "\""
-//! name = "\"" identifier "\""
-//! identifier = any character that's not a whitespace character or an open or close parenthesis
-//! type = "i32" | "i64" | "f32" | "f64"
-//!
-//! + means 1 or more
-//! * means 0 or more
-//! ? means 0 or 1
-//! | means "or"
-//! "\"" means one `"` character
-//!
-//! comments start with a `;` character and go until a newline `\n` character is reached
-//! comments and whitespace are valid between any tokens
-
-use either::Either;
-use nom::{
-    branch::*,
-    bytes::complete::{escaped, is_not, tag},
-    character::complete::{char, multispace0, multispace1, one_of},
-    combinator::*,
-    error::context,
-    multi::many0,
-    sequence::{delimited, preceded, tuple},
-    IResult,
-};
-
-use crate::interface::*;
-
-/// Some example input:
-/// (interface "example_interface"
-///     (func (import "ns" "name") (param f64 i32) (result f64 i32))
-///     (func (export "name") (param f64 i32) (result f64 i32))
-///     (global (import "ns" "name") (type f64)))
-pub fn parse_interface(mut input: &str) -> Result<Interface, String> {
-    let mut interface = Interface::default();
-    let interface_inner = preceded(
-        tag("interface"),
-        tuple((
-            opt(preceded(space_comments, identifier)),
-            many0(parse_func_or_global),
-        )),
-    );
-    let interface_parser = preceded(space_comments, s_exp(interface_inner));
-
-    if let Result::Ok((inp, (sig_id, out))) = interface_parser(input) {
-        interface.name = sig_id.map(|s_id| s_id.to_string());
-
-        for entry in out.into_iter() {
-            match entry {
-                Either::Left(import) => {
-                    if let Some(dup) = interface.imports.insert(import.get_key(), import) {
-                        return Err(format!("Duplicate import found {:?}", dup));
-                    }
-                }
-                Either::Right(export) => {
-                    if let Some(dup) = interface.exports.insert(export.get_key(), export) {
-                        return Err(format!("Duplicate export found {:?}", dup));
-                    }
-                }
-            }
-        }
-        input = inp;
-    }
-    // catch trailing comments and spaces
-    if let Ok((inp, _)) = space_comments(input) {
-        input = inp;
-    }
-    if !input.is_empty() {
-        Err(format!("Could not parse remaining input: {}", input))
-    } else {
-        Ok(interface)
-    }
-}
-
-fn parse_comment(input: &str) -> IResult<&str, ()> {
-    map(
-        preceded(multispace0, preceded(char(';'), many0(is_not("\n")))),
-        |_| (),
-    )(input)
-}
-
-/// Consumes spaces and comments
-/// comments must terminate with a new line character
-fn space_comments<'a>(mut input: &'a str) -> IResult<&'a str, ()> {
-    let mut space_found = true;
-    let mut comment_found = true;
-    while space_found || comment_found {
-        let space: IResult<&'a str, _> = multispace1(input);
-        space_found = if let Result::Ok((inp, _)) = space {
-            input = inp;
-            true
-        } else {
-            false
-        };
-        comment_found = if let Result::Ok((inp, _)) = parse_comment(input) {
-            input = inp;
-            true
-        } else {
-            false
-        };
-    }
-    Ok((input, ()))
-}
-
-/// A quoted identifier, must be valid UTF8
-fn identifier(input: &str) -> IResult<&str, &str> {
-    let name_inner = escaped(is_not("\"\\"), '\\', one_of("\"n\\"));
-    context("identifier", delimited(char('"'), name_inner, char('"')))(input)
-}
-
-/// Parses a wasm primitive type
-fn wasm_type(input: &str) -> IResult<&str, WasmType> {
-    let i32_tag = map(tag("i32"), |_| WasmType::I32);
-    let i64_tag = map(tag("i64"), |_| WasmType::I64);
-    let f32_tag = map(tag("f32"), |_| WasmType::F32);
-    let f64_tag = map(tag("f64"), |_| WasmType::F64);
-
-    alt((i32_tag, i64_tag, f32_tag, f64_tag))(input)
-}
-
-/// Parses an S-expression
-fn s_exp<'a, O1, F>(inner: F) -> impl Fn(&'a str) -> IResult<&'a str, O1>
-where
-    F: Fn(&'a str) -> IResult<&'a str, O1>,
-{
-    delimited(
-        char('('),
-        preceded(space_comments, inner),
-        preceded(space_comments, char(')')),
-    )
-}
-
-fn parse_func_or_global(input: &str) -> IResult<&str, Either<Import, Export>> {
-    preceded(space_comments, alt((func, global)))(input)
-}
-
-/// (func (import "ns" "name") (param f64 i32) (result f64 i32))
-/// (func (export "name") (param f64 i32) (result f64 i32))
-fn func(input: &str) -> IResult<&str, Either<Import, Export>> {
-    let param_list_inner = preceded(tag("param"), many0(preceded(space_comments, wasm_type)));
-    let param_list = opt(s_exp(param_list_inner));
-    let result_list_inner = preceded(tag("result"), many0(preceded(space_comments, wasm_type)));
-    let result_list = opt(s_exp(result_list_inner));
-    let import_id_inner = preceded(
-        tag("import"),
-        tuple((
-            preceded(space_comments, identifier),
-            preceded(space_comments, identifier),
-        )),
-    );
-    let export_id_inner = preceded(tag("export"), preceded(space_comments, identifier));
-    let func_id_inner = alt((
-        map(import_id_inner, |(ns, name)| {
-            Either::Left((ns.to_string(), name.to_string()))
-        }),
-        map(export_id_inner, |name| Either::Right(name.to_string())),
-    ));
-    let func_id = s_exp(func_id_inner);
-    let func_import_inner = context(
-        "func import inner",
-        preceded(
-            tag("func"),
-            map(
-                tuple((
-                    preceded(space_comments, func_id),
-                    preceded(space_comments, param_list),
-                    preceded(space_comments, result_list),
-                )),
-                |(func_id, pl, rl)| match func_id {
-                    Either::Left((ns, name)) => Either::Left(Import::Func {
-                        namespace: ns,
-                        name,
-                        params: pl.unwrap_or_default(),
-                        result: rl.unwrap_or_default(),
-                    }),
-                    Either::Right(name) => Either::Right(Export::Func {
-                        name,
-                        params: pl.unwrap_or_default(),
-                        result: rl.unwrap_or_default(),
-                    }),
-                },
-            ),
-        ),
-    );
-    s_exp(func_import_inner)(input)
-}
-
-/// (global (import "ns" "name") (type f64))
-/// (global (export "name") (type f64))
-fn global(input: &str) -> IResult<&str, Either<Import, Export>> {
-    let global_type_inner = preceded(tag("type"), preceded(space_comments, wasm_type));
-    let type_s_exp = s_exp(global_type_inner);
-    let export_inner = preceded(tag("export"), preceded(space_comments, identifier));
-    let import_inner = preceded(
-        tag("import"),
-        tuple((
-            preceded(space_comments, identifier),
-            preceded(space_comments, identifier),
-        )),
-    );
-    let global_id_inner = alt((
-        map(import_inner, |(ns, name)| {
-            Either::Left(Import::Global {
-                namespace: ns.to_string(),
-                name: name.to_string(),
-                // placeholder type, overwritten in `global_inner`
-                var_type: WasmType::I32,
-            })
-        }),
-        map(export_inner, |name| {
-            Either::Right(Export::Global {
-                name: name.to_string(),
-                // placeholder type, overwritten in `global_inner`
-                var_type: WasmType::I32,
-            })
-        }),
-    ));
-    let global_id = s_exp(global_id_inner);
-    let global_inner = context(
-        "global inner",
-        preceded(
-            tag("global"),
-            map(
-                tuple((
-                    preceded(space_comments, global_id),
-                    preceded(space_comments, type_s_exp),
-                )),
-                |(import_or_export, var_type)| match import_or_export {
-                    Either::Left(Import::Global {
-                        namespace, name, ..
-                    }) => Either::Left(Import::Global {
-                        namespace,
-                        name,
-                        var_type,
-                    }),
-                    Either::Right(Export::Global { name, .. }) => {
-                        Either::Right(Export::Global { name, var_type })
-                    }
-                    _ => unreachable!("Invalid value interonally in parse global function"),
-                },
-            ),
-        ),
-    );
-    s_exp(global_inner)(input)
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use std::collections::HashMap;
-
-    #[test]
-    fn parse_wasm_type() {
-        let i32_res = wasm_type("i32").unwrap();
-        assert_eq!(i32_res, ("", WasmType::I32));
-        let i64_res = wasm_type("i64").unwrap();
-        assert_eq!(i64_res, ("", WasmType::I64));
-        let f32_res = wasm_type("f32").unwrap();
-        assert_eq!(f32_res, ("", WasmType::F32));
-        let f64_res = wasm_type("f64").unwrap();
-        assert_eq!(f64_res, ("", WasmType::F64));
-
-        assert!(wasm_type("i128").is_err());
-    }
-
-    #[test]
-    fn parse_identifier() {
-        let inner_str = "柴は可愛すぎるだと思います";
-        let input = format!("\"{}\"", &inner_str);
-        let parse_res = identifier(&input).unwrap();
-        assert_eq!(parse_res, ("", inner_str))
-    }
-
-    #[test]
-    fn parse_global_import() {
-        let parse_res = global(r#"(global (import "env" "length") (type i32))"#)
-            .ok()
-            .and_then(|(a, b)| Some((a, b.left()?)))
-            .unwrap();
-        assert_eq!(
-            parse_res,
-            (
-                "",
-                Import::Global {
-                    namespace: "env".to_string(),
-                    name: "length".to_string(),
-                    var_type: WasmType::I32,
-                }
-            )
-        );
-    }
-
-    #[test]
-    fn parse_global_export() {
-        let parse_res = global(r#"(global (export "length") (type i32))"#)
-            .ok()
-            .and_then(|(a, b)| Some((a, b.right()?)))
-            .unwrap();
-        assert_eq!(
-            parse_res,
-            (
-                "",
-                Export::Global {
-                    name: "length".to_string(),
-                    var_type: WasmType::I32,
-                }
-            )
-        );
-    }
-
-    #[test]
-    fn parse_func_import() {
-        let parse_res = func(r#"(func (import "ns" "name") (param f64 i32) (result f64 i32))"#)
-            .ok()
-            .and_then(|(a, b)| Some((a, b.left()?)))
-            .unwrap();
-        assert_eq!(
-            parse_res,
-            (
-                "",
-                Import::Func {
-                    namespace: "ns".to_string(),
-                    name: "name".to_string(),
-                    params: vec![WasmType::F64, WasmType::I32],
-                    result: vec![WasmType::F64, WasmType::I32],
-                }
-            )
-        );
-    }
-
-    #[test]
-    fn parse_func_export() {
-        let parse_res = func(r#"(func (export "name") (param f64 i32) (result f64 i32))"#)
-            .ok()
-            .and_then(|(a, b)| Some((a, b.right()?)))
-            .unwrap();
-        assert_eq!(
-            parse_res,
-            (
-                "",
-                Export::Func {
-                    name: "name".to_string(),
-                    params: vec![WasmType::F64, WasmType::I32],
-                    result: vec![WasmType::F64, WasmType::I32],
-                }
-            )
-        );
-
-        let parse_res = func(r#"(func (export "name"))"#)
-            .ok()
-            .and_then(|(a, b)| Some((a, b.right()?)))
-            .unwrap();
-        assert_eq!(
-            parse_res,
-            (
-                "",
-                Export::Func {
-                    name: "name".to_string(),
-                    params: vec![],
-                    result: vec![],
-                }
-            )
-        )
-    }
-
-    #[test]
-    fn parse_imports_test() {
-        let parse_imports = |in_str| {
-            many0(parse_func_or_global)(in_str)
-                .map(|(a, b)| {
-                    (
-                        a,
-                        b.into_iter().filter_map(|x| x.left()).collect::<Vec<_>>(),
-                    )
-                })
-                .unwrap()
-        };
-        let parse_res =
-            parse_imports(r#"(func (import "ns" "name") (param f64 i32) (result f64 i32))"#);
-        assert_eq!(
-            parse_res,
-            (
-                "",
-                vec![Import::Func {
-                    namespace: "ns".to_string(),
-                    name: "name".to_string(),
-                    params: vec![WasmType::F64, WasmType::I32],
-                    result: vec![WasmType::F64, WasmType::I32],
-                }]
-            )
-        );
-
-        let parse_res = parse_imports(
-            r#"(func (import "ns" "name")
-                                                   (param f64 i32) (result f64 i32))
-        ( global ( import "env" "length" ) ( type
-    ;; i32 is the best type
-    i32 )
-    )
-                                              (func (import "ns" "name2") (param f32
-                                                                          i64)
-                                   ;; The return value comes next
-                                                                    (
-                                                                     result
-                                                                     f64
-                                                                     i32
-                                                                     )
-                                              )"#,
-        );
-        assert_eq!(
-            parse_res,
-            (
-                "",
-                vec![
-                    Import::Func {
-                        namespace: "ns".to_string(),
-                        name: "name".to_string(),
-                        params: vec![WasmType::F64, WasmType::I32],
-                        result: vec![WasmType::F64, WasmType::I32],
-                    },
-                    Import::Global {
-                        namespace: "env".to_string(),
-                        name: "length".to_string(),
-                        var_type: WasmType::I32,
-                    },
-                    Import::Func {
-                        namespace: "ns".to_string(),
-                        name: "name2".to_string(),
-                        params: vec![WasmType::F32, WasmType::I64],
-                        result: vec![WasmType::F64, WasmType::I32],
-                    },
-                ]
-            )
-        );
-    }
-
-    #[test]
-    fn top_level_test() {
-        let parse_res = parse_interface(
-            r#" (interface 
- (func (import "ns" "name") (param f64 i32) (result f64 i32))
- (func (export "name2") (param) (result i32))
- (global (import "env" "length") (type f64)))"#,
-        )
-        .unwrap();
-
-        let imports = vec![
-            Import::Func {
-                namespace: "ns".to_string(),
-                name: "name".to_string(),
-                params: vec![WasmType::F64, WasmType::I32],
-                result: vec![WasmType::F64, WasmType::I32],
-            },
-            Import::Global {
-                namespace: "env".to_string(),
-                name: "length".to_string(),
-                var_type: WasmType::F64,
-            },
-        ];
-        let exports = vec![Export::Func {
-            name: "name2".to_string(),
-            params: vec![],
-            result: vec![WasmType::I32],
-        }];
-        let import_map = imports
-            .into_iter()
-            .map(|entry| (entry.get_key(), entry))
-            .collect::<HashMap<(String, String), Import>>();
-        let export_map = exports
-            .into_iter()
-            .map(|entry| (entry.get_key(), entry))
-            .collect::<HashMap<String, Export>>();
-        assert_eq!(
-            parse_res,
-            Interface {
-                name: None,
-                imports: import_map,
-                exports: export_map,
-            }
-        );
-    }
-
-    #[test]
-    fn duplicates_not_allowed() {
-        let parse_res = parse_interface(
-            r#" (interface "sig_name" (func (import "ns" "name") (param f64 i32) (result f64 i32))
-; test comment
-  ;; hello
- (func (import "ns" "name") (param) (result i32))
- (global (export "length") (type f64)))
-
-"#,
-        );
-
-        assert!(parse_res.is_err());
-    }
-
-    #[test]
-    fn test_comment_space_parsing() {
-        let parse_res = space_comments(" ").unwrap();
-        assert_eq!(parse_res, ("", ()));
-        let parse_res = space_comments("").unwrap();
-        assert_eq!(parse_res, ("", ()));
-        let parse_res = space_comments("; hello\n").unwrap();
-        assert_eq!(parse_res, ("", ()));
-        let parse_res = space_comments("abc").unwrap();
-        assert_eq!(parse_res, ("abc", ()));
-        let parse_res = space_comments("\n ; hello\n ").unwrap();
-        assert_eq!(parse_res, ("", ()));
-        let parse_res = space_comments("\n ; hello\n ; abc\n\n ; hello\n").unwrap();
-        assert_eq!(parse_res, ("", ()));
-    }
-
-    #[test]
-    fn test_param_elision() {
-        let parse_res = parse_interface(
-            r#" (interface "interface_name" (func (import "ns" "name") (result f64 i32))
-(func (export "name")))
-"#,
-        )
-        .unwrap();
-
-        let imports = vec![Import::Func {
-            namespace: "ns".to_string(),
-            name: "name".to_string(),
-            params: vec![],
-            result: vec![WasmType::F64, WasmType::I32],
-        }];
-        let exports = vec![Export::Func {
-            name: "name".to_string(),
-            params: vec![],
-            result: vec![],
-        }];
-        let import_map = imports
-            .into_iter()
-            .map(|entry| (entry.get_key(), entry))
-            .collect::<HashMap<(String, String), Import>>();
-        let export_map = exports
-            .into_iter()
-            .map(|entry| (entry.get_key(), entry))
-            .collect::<HashMap<String, Export>>();
-        assert_eq!(
-            parse_res,
-            Interface {
-                name: Some("interface_name".to_string()),
-                imports: import_map,
-                exports: export_map,
-            }
-        );
-    }
-
-    #[test]
-    fn typo_gets_caught() {
-        let interface_src = r#"
-(interface "interface_id"
-(func (import "env" "do_panic") (params i32 i64))
-(global (import "length") (type i32)))"#;
-        let result = parse_interface(interface_src);
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn parse_trailing_spaces_on_interface() {
-        let parse_res = parse_interface(
-            r#" (interface "really_good_interface" (func (import "ns" "name") (param f64 i32) (result f64 i32))
-; test comment
-  ;; hello
- (global (import "ns" "length") (type f64))
-)
-
-"#,
-        );
-
-        assert!(parse_res.is_ok());
-    }
-}
diff --git a/lib/wasm-interface/src/validate.rs b/lib/wasm-interface/src/validate.rs
deleted file mode 100644
index 7901eeb302..0000000000
--- a/lib/wasm-interface/src/validate.rs
+++ /dev/null
@@ -1,504 +0,0 @@
-//! Validate a wasm module given a interface.
-//!
-//! This checks that all imports are specified in the interface and that their types
-//! are correct, as well as that all exports that the interface expects are exported
-//! by the module and that their types are correct.
-
-use crate::{Export, Import, Interface, WasmType};
-use std::collections::HashMap;
-use wasmparser::{CompositeType, ExternalKind, FuncType, GlobalType, Payload, TypeRef};
-
-pub fn validate_wasm_and_report_errors(
-    wasm: &[u8],
-    interface: &Interface,
-) -> Result<(), WasmValidationError> {
-    let mut errors: Vec<String> = vec![];
-    let mut import_fns: HashMap<(String, String), u32> = HashMap::new();
-    let mut export_fns: HashMap<String, u32> = HashMap::new();
-    let mut export_globals: HashMap<String, u32> = HashMap::new();
-    let mut type_defs: Vec<FuncType> = vec![];
-    let mut global_types: Vec<GlobalType> = vec![];
-    let mut fn_sigs: Vec<u32> = vec![];
-
-    let mut val = wasmparser::Validator::new_with_features(wasmparser::WasmFeatures {
-        threads: true,
-        reference_types: true,
-        simd: true,
-        bulk_memory: true,
-        multi_value: true,
-        ..Default::default()
-    });
-
-    val.validate_all(wasm)
-        .map_err(|e| WasmValidationError::InvalidWasm {
-            error: format!("{}", e),
-        })?;
-
-    let parser = wasmparser::Parser::new(0).parse_all(wasm);
-
-    for res in parser {
-        let payload = res.map_err(|e| WasmValidationError::InvalidWasm {
-            error: format!("{}", e),
-        })?;
-        match payload {
-            Payload::End(_) => break,
-            Payload::ImportSection(reader) => {
-                for item in reader.into_iter_with_offsets() {
-                    let (_offset, import) = item.map_err(|e| WasmValidationError::InvalidWasm {
-                        error: format!("{}", e),
-                    })?;
-
-                    match import.ty {
-                        TypeRef::Func(idx) => {
-                            import_fns.insert(Import::format_key(import.module, import.name), idx);
-                            fn_sigs.push(idx);
-                        }
-                        TypeRef::Global(GlobalType { content_type, .. }) => {
-                            let global_type = wasmparser_type_into_wasm_type(content_type)
-                                .map_err(|err| WasmValidationError::UnsupportedType {
-                                    error: format!(
-                                        "Invalid type found in import \"{}\" \"{}\": {}",
-                                        import.module, import.name, err
-                                    ),
-                                })?;
-                            if let Some(val) = interface
-                                .imports
-                                .get(&Import::format_key(import.module, import.name))
-                            {
-                                if let Import::Global { var_type, .. } = val {
-                                    if *var_type != global_type {
-                                        errors.push(format!(
-                                            "Invalid type on Global \"{}\". Expected {} found {}",
-                                            import.name, var_type, global_type
-                                        ));
-                                    }
-                                } else {
-                                    errors.push(format!(
-                                        "Invalid import type. Expected Global, found {:?}",
-                                        val
-                                    ));
-                                }
-                            } else {
-                                errors.push(format!(
-                                    "Global import \"{}\" not found in the specified interface",
-                                    import.name
-                                ));
-                            }
-                        }
-                        _ => (),
-                    }
-                }
-            }
-            Payload::ExportSection(reader) => {
-                for res in reader.into_iter() {
-                    let export = res.map_err(|e| WasmValidationError::InvalidWasm {
-                        error: format!("{}", e),
-                    })?;
-
-                    match export.kind {
-                        ExternalKind::Func => {
-                            export_fns.insert(Export::format_key(export.name), export.index);
-                        }
-                        ExternalKind::Global => {
-                            export_globals.insert(Export::format_key(export.name), export.index);
-                        }
-                        _ => (),
-                    }
-                }
-            }
-            Payload::GlobalSection(reader) => {
-                for res in reader.into_iter() {
-                    let global = res.map_err(|e| WasmValidationError::InvalidWasm {
-                        error: format!("{}", e),
-                    })?;
-
-                    global_types.push(global.ty);
-                }
-            }
-            Payload::TypeSection(reader) => {
-                for res in reader.into_iter() {
-                    let group = res.map_err(|e| WasmValidationError::InvalidWasm {
-                        error: format!("{}", e),
-                    })?;
-
-                    for ty in group.into_types() {
-                        if let CompositeType::Func(ft) = ty.composite_type {
-                            type_defs.push(ft);
-                        }
-                    }
-                }
-            }
-            Payload::FunctionSection(reader) => {
-                for res in reader.into_iter() {
-                    let func = res.map_err(|e| WasmValidationError::InvalidWasm {
-                        error: format!("{}", e),
-                    })?;
-
-                    fn_sigs.push(func);
-                }
-            }
-            _ => {}
-        }
-    }
-
-    validate_imports(&import_fns, &type_defs, interface, &mut errors);
-    validate_export_fns(&export_fns, &type_defs, &fn_sigs, interface, &mut errors);
-    validate_export_globals(&export_globals, &global_types, interface, &mut errors);
-
-    if errors.is_empty() {
-        Ok(())
-    } else {
-        Err(WasmValidationError::InterfaceViolated { errors })
-    }
-}
-
-/// Validates the import functions, checking the name and type against the given
-/// `Interface`
-fn validate_imports(
-    import_fns: &HashMap<(String, String), u32>,
-    type_defs: &[FuncType],
-    interface: &Interface,
-    errors: &mut Vec<String>,
-) {
-    for (key, val) in import_fns.iter() {
-        if let Some(interface_def) = interface.imports.get(key) {
-            let type_sig = if let Some(v) = type_defs.get(*val as usize) {
-                v
-            } else {
-                errors.push(format!(
-                    "Use of undeclared function reference \"{}\" in import function \"{}\" \"{}\"",
-                    val, key.0, key.1
-                ));
-                continue;
-            };
-            if let Import::Func { params, result, .. } = interface_def {
-                for (i, param) in type_sig
-                    .params()
-                    .iter()
-                    .cloned()
-                    .map(wasmparser_type_into_wasm_type)
-                    .enumerate()
-                {
-                    match param {
-                        Ok(t) => {
-                            if params.get(i).is_none() {
-                                errors.push(format!("Found {} args but the interface only expects {} for imported function \"{}\" \"{}\"", i, params.len(), &key.0, &key.1));
-                                continue;
-                            }
-                            if t != params[i] {
-                                errors.push(format!(
-                                    "Type mismatch in params in imported func \"{}\" \"{}\": argument {}, expected {} found {}",
-                                    &key.0, &key.1, i + 1, params[i], t
-                                ));
-                            }
-                        }
-                        Err(e) => errors.push(format!(
-                            "Invalid type in func \"{}\" \"{}\": {}",
-                            &key.0, &key.1, e
-                        )),
-                    }
-                }
-                for (i, ret) in type_sig
-                    .results()
-                    .iter()
-                    .cloned()
-                    .map(wasmparser_type_into_wasm_type)
-                    .enumerate()
-                {
-                    match ret {
-                        Ok(t) => {
-                            if result.get(i).is_none() {
-                                errors.push(format!("Found {} returns but the interface only expects {} for imported function \"{}\" \"{}\"", i, params.len(), &key.0, &key.1));
-                                continue;
-                            }
-
-                            if t != result[i] {
-                                errors.push(format!(
-                                    "Type mismatch in returns in func \"{}\" \"{}\", return {}, expected {} found {}",
-                                    &key.0, &key.1, i + 1, params[i], t
-                                ));
-                            }
-                        }
-                        Err(e) => errors.push(format!(
-                            "Invalid type in func \"{}\" \"{}\": {}",
-                            &key.0, &key.1, e
-                        )),
-                    }
-                }
-            }
-        } else {
-            // we didn't find the import at all in the interface
-            // TODO: improve error messages by including type information
-            errors.push(format!("Missing import \"{}\" \"{}\"", key.0, key.1));
-        }
-    }
-}
-
-/// Validates the export functions, checking the name and type against the given
-/// `Interface`
-fn validate_export_fns(
-    export_fns: &HashMap<String, u32>,
-    type_defs: &[FuncType],
-    fn_sigs: &Vec<u32>,
-    interface: &Interface,
-    errors: &mut Vec<String>,
-) {
-    'export_loop: for (key, val) in export_fns.iter() {
-        if let Some(interface_def) = interface.exports.get(key) {
-            let type_sig = if let Some(type_idx) = fn_sigs.get(*val as usize) {
-                if let Some(v) = type_defs.get(*type_idx as usize) {
-                    v
-                } else {
-                    errors.push(format!(
-                        "Export \"{}\" refers to type \"{}\" but only {} types were found",
-                        &key,
-                        type_idx,
-                        fn_sigs.len()
-                    ));
-                    continue;
-                }
-            } else {
-                errors.push(format!(
-                    "Use of undeclared function reference \"{}\" in export \"{}\"",
-                    val, &key
-                ));
-                continue;
-            };
-            if let Export::Func { params, result, .. } = interface_def {
-                for (i, param) in type_sig
-                    .params()
-                    .iter()
-                    .cloned()
-                    .map(wasmparser_type_into_wasm_type)
-                    .enumerate()
-                {
-                    match param {
-                        Ok(t) => {
-                            if params.get(i).is_none() {
-                                errors.push(format!("Found {} args but the interface only expects {} for exported function \"{}\"", type_sig.params().len(), params.len(), &key));
-                                continue 'export_loop;
-                            }
-                            if t != params[i] {
-                                errors.push(format!(
-                                    "Type mismatch in params in exported func \"{}\": in argument {}, expected {} found {}",
-                                    &key, i + 1, params[i], t
-                                ));
-                            }
-                        }
-                        Err(e) => errors
-                            .push(format!("Invalid type in exported func \"{}\": {}", &key, e)),
-                    }
-                }
-                for (i, ret) in type_sig
-                    .results()
-                    .iter()
-                    .cloned()
-                    .map(wasmparser_type_into_wasm_type)
-                    .enumerate()
-                {
-                    match ret {
-                        Ok(t) => {
-                            if result.get(i).is_none() {
-                                errors.push(format!("Found {} returns but the interface only expects {} for exported function \"{}\"", i, params.len(), &key));
-                                continue 'export_loop;
-                            }
-
-                            if t != result[i] {
-                                errors.push(format!(
-                                    "Type mismatch in returns in exported func \"{}\": in return {}, expected {} found {}",
-                                    &key, i + 1, result[i], t
-                                ));
-                            }
-                        }
-                        Err(e) => errors
-                            .push(format!("Invalid type in exported func \"{}\": {}", &key, e)),
-                    }
-                }
-            }
-        }
-    }
-}
-
-/// Validates the export globals, checking the name and type against the given
-/// `Interface`
-fn validate_export_globals(
-    export_globals: &HashMap<String, u32>,
-    global_types: &Vec<GlobalType>,
-    interface: &Interface,
-    errors: &mut Vec<String>,
-) {
-    for (key, val) in export_globals.iter() {
-        if let Some(Export::Global { var_type, .. }) = interface.exports.get(key) {
-            if global_types.get(*val as usize).is_none() {
-                errors.push(format!(
-                    "Invalid wasm, expected {} global types, found {}",
-                    val,
-                    global_types.len()
-                ));
-            }
-            match wasmparser_type_into_wasm_type(global_types[*val as usize].content_type) {
-                Ok(t) => {
-                    if *var_type != t {
-                        errors.push(format!(
-                            "Type mismatch in global export {}: expected {} found {}",
-                            &key, var_type, t
-                        ));
-                    }
-                }
-                Err(e) => errors.push(format!("In global export {}: {}", &key, e)),
-            }
-        }
-    }
-}
-
-/// Converts Wasmparser's type enum into wasm-interface's type enum
-/// wasmparser's enum contains things which are invalid in many situations
-///
-/// Additionally wasmerparser containers more advanced types like references that
-/// wasm-interface does not yet support
-fn wasmparser_type_into_wasm_type(ty: wasmparser::ValType) -> Result<WasmType, String> {
-    use wasmparser::ValType;
-    Ok(match ty {
-        ValType::I32 => WasmType::I32,
-        ValType::I64 => WasmType::I64,
-        ValType::F32 => WasmType::F32,
-        ValType::F64 => WasmType::F64,
-        e => {
-            return Err(format!("Invalid type found: {:?}", e));
-        }
-    })
-}
-
-#[cfg(test)]
-mod validation_tests {
-    use super::*;
-    use crate::parser;
-
-    #[test]
-    fn global_imports() {
-        const WAT: &str = r#"(module
-(type $t0 (func (param i32 i64)))
-(global $length (import "env" "length") i32)
-(import "env" "do_panic" (func $do_panic (type $t0)))
-)"#;
-        let wasm = wat::parse_str(WAT).unwrap();
-
-        let interface_src = r#"
-(interface
-(func (import "env" "do_panic") (param i32 i64))
-(global (import "env" "length") (type i32)))"#;
-        let interface = parser::parse_interface(interface_src).unwrap();
-
-        let result = validate_wasm_and_report_errors(&wasm[..], &interface);
-
-        assert!(result.is_ok());
-
-        // Now set the global import type to mismatch the wasm
-        let interface_src = r#"
-(interface
-(func (import "env" "do_panic") (param i32 i64))
-(global (import "env" "length") (type i64)))"#;
-        let interface = parser::parse_interface(interface_src).unwrap();
-
-        let result = validate_wasm_and_report_errors(&wasm[..], &interface);
-
-        assert!(
-            result.is_err(),
-            "global import type mismatch causes an error"
-        );
-
-        // Now set the function import type to mismatch the wasm
-        let interface_src = r#"
-(interface
-(func (import "env" "do_panic") (param i64))
-(global (import "env" "length") (type i32)))"#;
-        let interface = parser::parse_interface(interface_src).unwrap();
-
-        let result = validate_wasm_and_report_errors(&wasm[..], &interface);
-
-        assert!(
-            result.is_err(),
-            "function import type mismatch causes an error"
-        );
-
-        // Now try with a module that has an import that the interface doesn't have
-        let interface_src = r#"
-(interface
-(func (import "env" "do_panic") (param i64))
-(global (import "env" "length_plus_plus") (type i32)))"#;
-        let interface = parser::parse_interface(interface_src).unwrap();
-
-        let result = validate_wasm_and_report_errors(&wasm[..], &interface);
-
-        assert!(
-            result.is_err(),
-            "all imports must be covered by the interface"
-        );
-    }
-
-    #[test]
-    fn global_exports() {
-        const WAT: &str = r#"(module
-(func (export "as-set_local-first") (param i32) (result i32)
-  (nop) (i32.const 2) (set_local 0) (get_local 0))
-(global (export "num_tries") i64 (i64.const 0))
-)"#;
-        let wasm = wat::parse_str(WAT).unwrap();
-
-        let interface_src = r#"
-(interface
-(func (export "as-set_local-first") (param i32) (result i32))
-(global (export "num_tries") (type i64)))"#;
-        let interface = parser::parse_interface(interface_src).unwrap();
-
-        let result = validate_wasm_and_report_errors(&wasm[..], &interface);
-
-        assert!(result.is_ok());
-
-        // Now set the global export type to mismatch the wasm
-        let interface_src = r#"
-(interface
-(func (export "as-set_local-first") (param i32) (result i32))
-(global (export "num_tries") (type f32)))"#;
-        let interface = parser::parse_interface(interface_src).unwrap();
-
-        let result = validate_wasm_and_report_errors(&wasm[..], &interface);
-
-        assert!(
-            result.is_err(),
-            "global export type mismatch causes an error"
-        );
-
-        // Now set the function export type to mismatch the wasm
-        let interface_src = r#"
-(interface
-(func (export "as-set_local-first") (param i64) (result i64))
-(global (export "num_tries") (type i64)))"#;
-        let interface = parser::parse_interface(interface_src).unwrap();
-
-        let result = validate_wasm_and_report_errors(&wasm[..], &interface);
-
-        assert!(
-            result.is_err(),
-            "function export type mismatch causes an error"
-        );
-
-        // Now try a interface that requires an export that the module doesn't have
-        let interface_src = r#"
-(interface
-(func (export "as-set_local-first") (param i64) (result i64))
-(global (export "numb_trees") (type i64)))"#;
-        let interface = parser::parse_interface(interface_src).unwrap();
-
-        let result = validate_wasm_and_report_errors(&wasm[..], &interface);
-
-        assert!(result.is_err(), "missing a required export is an error");
-    }
-}
-
-#[derive(Debug)]
-pub enum WasmValidationError {
-    InvalidWasm { error: String },
-    InterfaceViolated { errors: Vec<String> },
-    UnsupportedType { error: String },
-}
diff --git a/rust-toolchain b/rust-toolchain
index bc8a6589c9..85cfbbbc3f 100644
--- a/rust-toolchain
+++ b/rust-toolchain
@@ -1 +1 @@
-1.74
+1.84
\ No newline at end of file
diff --git a/scripts/alpine-linux-install-deps.sh b/scripts/alpine-linux-install-deps.sh
index baa2d63386..a83820411f 100755
--- a/scripts/alpine-linux-install-deps.sh
+++ b/scripts/alpine-linux-install-deps.sh
@@ -4,4 +4,5 @@
 # This script is used by the CI!
 
 apk update
-apk add build-base bash musl-dev curl tar make libtool libffi-dev gcc automake autoconf git openssl-dev g++ pkgconfig
+apk add bash mold make curl cmake ninja clang18 zstd-static llvm18-dev clang18-static llvm18-static ncurses-static zlib-static
+ln -s /usr/bin/clang-18 /usr/bin/clang
\ No newline at end of file
diff --git a/scripts/nix/pkg.nix b/scripts/nix/pkg.nix
index 6b4dc30b32..24c14c6d96 100644
--- a/scripts/nix/pkg.nix
+++ b/scripts/nix/pkg.nix
@@ -64,7 +64,7 @@ rustPlatform.buildRustPackage rec {
     description = "The Universal WebAssembly Runtime";
     longDescription = ''
       Wasmer is a standalone WebAssembly runtime for running WebAssembly outside
-      of the browser, supporting WASI and Emscripten. Wasmer can be used
+      of the browser, supporting WASI. Wasmer can be used
       standalone (via the CLI) and embedded in different languages, running in
       x86 and ARM devices.
     '';
diff --git a/scripts/publish.py b/scripts/publish.py
index 553eab2fb9..8df7285232 100644
--- a/scripts/publish.py
+++ b/scripts/publish.py
@@ -45,13 +45,13 @@
     # extra features to put when publishing, for example wasmer-cli needs a
     # compiler by default otherwise it won't work standalone
     "publish_features": {
+        "wasmer-compiler": "compiler",
         "wasmer-cli": "default,cranelift",
-        "wasmer-wasix": "sys,wasmer/sys",
-        "wasmer-wasix-types": "wasmer/sys",
-        "wasmer-wast": "wasmer/sys",
+        "wasmer-wasix": "sys,wasmer/sys-default",
+        "wasmer-wasix-types": "wasmer/sys-default",
+        "wasmer-wast": "wasmer/sys-default",
         "wai-bindgen-wasmer": "sys",
-        "wasmer-cache": "wasmer/sys",
-        "wasmer-emscripten": "wasmer/sys"
+        "wasmer-cache": "wasmer/sys-default",
     },
     # workspace members we want to publish but whose path doesn't start by
     # "./lib/"
@@ -126,8 +126,24 @@ def __init__(self, version=None, dry_run=True, verbose=True):
         elif self.verbose and self.dry_run:
             print(f"Publishing version {self.version} dry run!")
 
+        print(data["dependencies"])
+        print("wasmer-package" in data["workspace"]["dependencies"])
+
+        check_local_workspace_dep = lambda t: \
+            (t[0] in data["dependencies"] and \
+             isinstance(data["dependencies"][t[0]], dict) and \
+             "path" in data["dependencies"][t[0]]) or \
+            (t[0] in data["workspace"]["dependencies"] and \
+             isinstance(data["workspace"]["dependencies"][t[0]], dict) and \
+             "path" in data["workspace"]["dependencies"][t[0]])
+
         # define helper function
-        check_local_dep_fn = lambda t: isinstance(t[1], dict) and "path" in t[1]
+        check_local_dep_fn = lambda t: \
+            isinstance(t[1], dict) and \
+            ("path" in t[1] or \
+             "workspace" in t[1] and t[1]["workspace"] is True and \
+             check_local_workspace_dep(t))
+                
         members = set(
             map(
                 lambda p: p + "/Cargo.toml",
@@ -286,15 +302,6 @@ def publish(self):
                 print(f"`{crate_name}` was already published!")
                 continue
 
-            # sleep for 16 seconds between crates to ensure the crates.io
-            # index has time to update
-            if not self.dry_run:
-                print(
-                    "Sleeping for 16 seconds to allow the `crates.io` index to update..."
-                )
-                time.sleep(16)
-            else:
-                print("In dry-run: not sleeping for crates.io to update.")
         if failures > 0 and self.verbose:
             print(f"encountered {failures} failures.")
             for key, value in status.items():
diff --git a/scripts/update-version.py b/scripts/update-version.py
index 1796a44712..f5705ed79c 100644
--- a/scripts/update-version.py
+++ b/scripts/update-version.py
@@ -1,7 +1,19 @@
 #!/usr/bin/python
 
-PREVIOUS_VERSION='4.3.6'
-NEXT_VERSION='4.3.7'
+PREVIOUS_VERSION='6.1.0-rc.5'
+NEXT_VERSION='6.1.0'
+
+def make_prerelease_version(version: str) -> str:
+    parts = version.split('.', 2)
+    if len(parts) != 3:
+        raise ValueError(f"Invalid version format: {version} - {parts}")
+    major, minor, patch = parts
+    new_minor = str(int(major) * 100 + int(minor))
+    # patch may potentially contain a pre-release identifier, and that's OK
+    return f"0.{new_minor}.{patch}"
+
+PREVIOUS_PRERELEASE_VERSION = make_prerelease_version(PREVIOUS_VERSION)
+NEXT_PRERELEASE_VERSION = make_prerelease_version(NEXT_VERSION)
 
 import os
 import re
@@ -25,18 +37,23 @@ def replace_version(path):
     print(PREVIOUS_VERSION + " -> " + NEXT_VERSION + " (" + path + ")")
     replace(path, "version = \"" + PREVIOUS_VERSION +"\"", "version = \"" + NEXT_VERSION +"\"")
     replace(path, "version = \"=" + PREVIOUS_VERSION +"\"", "version = \"=" + NEXT_VERSION +"\"")
+    replace(path, "version = \"" + PREVIOUS_PRERELEASE_VERSION +"\"", "version = \"" + NEXT_PRERELEASE_VERSION +"\"")
+    replace(path, "version = \"=" + PREVIOUS_PRERELEASE_VERSION +"\"", "version = \"=" + NEXT_PRERELEASE_VERSION +"\"")
     pass
 
 def replace_version_py(path):
     print(PREVIOUS_VERSION + " -> " + NEXT_VERSION + " (" + path + ")")
     replace(path, "target_version = \"" + PREVIOUS_VERSION +"\"", "target_version = \"" + NEXT_VERSION +"\"")
+    replace(path, "target_version = \"" + PREVIOUS_PRERELEASE_VERSION +"\"", "target_version = \"" + NEXT_PRERELEASE_VERSION +"\"")
     pass
 
 def replace_version_iss(path):
     print(PREVIOUS_VERSION + " -> " + NEXT_VERSION + " (" + path + ")")
     replace(path, "AppVersion=" + PREVIOUS_VERSION, "AppVersion=" + NEXT_VERSION)
+    replace(path, "AppVersion=" + PREVIOUS_PRERELEASE_VERSION, "AppVersion=" + NEXT_PRERELEASE_VERSION)
     pass
 
+print ("Updating crate versions from " + PREVIOUS_VERSION + " to " + NEXT_VERSION + " (and prerelease versions from " + PREVIOUS_PRERELEASE_VERSION + " to " + NEXT_PRERELEASE_VERSION + ")")
 for root, dirs, files in os.walk("."):
     path = root.split(os.sep)
     # print((len(path) - 1) * '---', os.path.basename(root))
diff --git a/scripts/windows-installer/wasmer.iss b/scripts/windows-installer/wasmer.iss
index 5f061f9452..78f2827e3c 100644
--- a/scripts/windows-installer/wasmer.iss
+++ b/scripts/windows-installer/wasmer.iss
@@ -1,6 +1,6 @@
 [Setup]
 AppName=Wasmer
-AppVersion=4.3.7
+AppVersion=6.1.0
 DefaultDirName={pf}\Wasmer
 DefaultGroupName=Wasmer
 Compression=lzma2
diff --git a/tests/c-wasi-tests/.gitignore b/tests/c-wasi-tests/.gitignore
new file mode 100644
index 0000000000..1b869ca132
--- /dev/null
+++ b/tests/c-wasi-tests/.gitignore
@@ -0,0 +1,4 @@
+*.wasm
+*.wat
+*.o
+*.so
\ No newline at end of file
diff --git a/tests/c-wasi-tests/Makefile b/tests/c-wasi-tests/Makefile
new file mode 100644
index 0000000000..575ae5a9ac
--- /dev/null
+++ b/tests/c-wasi-tests/Makefile
@@ -0,0 +1,107 @@
+all: install
+
+libside1.so: side1.c libside2.so
+	clang-19 \
+	  --target=wasm32-wasi --sysroot=${WASIX_SYSROOT_PIC} \
+	  -matomics -mbulk-memory -mmutable-globals -pthread \
+	  -mthread-model posix -ftls-model=local-exec \
+      -fno-trapping-math -D_WASI_EMULATED_MMAN -D_WASI_EMULATED_SIGNAL \
+	  -D_WASI_EMULATED_PROCESS_CLOCKS \
+      -g -flto -O0 \
+	  -fPIC -fvisibility=default \
+      -c $< -o $(patsubst %.so, %.o, $@)
+
+	wasm-ld-19 \
+	  -L. -lside2 \
+	  --extra-features=atomics,bulk-memory,mutable-globals \
+	  --export=__wasm_call_ctors --export-if-defined=__wasm_apply_data_relocs \
+	  --experimental-pic --unresolved-symbols=import-dynamic \
+	  -shared --shared-memory \
+	  -o $@ $(patsubst %.so, %.o, $@)
+
+libside2.so: side2.c
+	clang-19 \
+	  --target=wasm32-wasi --sysroot=${WASIX_SYSROOT_PIC} \
+	  -matomics -mbulk-memory -mmutable-globals -pthread \
+	  -mthread-model posix -ftls-model=local-exec \
+      -fno-trapping-math -D_WASI_EMULATED_MMAN -D_WASI_EMULATED_SIGNAL \
+	  -D_WASI_EMULATED_PROCESS_CLOCKS \
+      -g -flto -O0 \
+	  -fPIC -fvisibility=default \
+      -c $< -o $(patsubst %.so, %.o, $@)
+
+	wasm-ld-19 \
+	  --extra-features=atomics,bulk-memory,mutable-globals \
+	  --export=__wasm_call_ctors --export-if-defined=__wasm_apply_data_relocs \
+	  --experimental-pic --unresolved-symbols=import-dynamic \
+	  -shared --shared-memory \
+	  -o $@ $(patsubst %.so, %.o, $@)
+
+dlopen.wasm: dlopen.c
+	clang-19 \
+	  --target=wasm32-wasi --sysroot=${WASIX_SYSROOT_PIC} \
+	  -matomics -mbulk-memory -mmutable-globals -pthread \
+	  -mthread-model posix -ftls-model=local-exec \
+      -fno-trapping-math -D_WASI_EMULATED_MMAN -D_WASI_EMULATED_SIGNAL \
+	  -D_WASI_EMULATED_PROCESS_CLOCKS \
+      -g -flto -O0 \
+	  -fPIC \
+      -c $< -o $(patsubst %.wasm, %.o, $@)
+
+	wasm-ld-19 \
+	  -L${WASIX_SYSROOT_PIC}/lib \
+	  -L${WASIX_SYSROOT_PIC}/lib/wasm32-wasi \
+	  --whole-archive --export-all \
+	  $(patsubst %.wasm, %.o, $@) \
+	  ${WASIX_SYSROOT_PIC}/lib/wasm32-wasi/crt1.o \
+	  -lc -lresolv -lrt -lm -lpthread \
+	  -lwasi-emulated-mman \
+	  --max-memory=4294967296 --import-memory --shared-memory \
+	  --extra-features=atomics,bulk-memory,mutable-globals \
+	  --export=__wasm_signal --export=__tls_size --export=__tls_align \
+	  --export=__tls_base --export=__wasm_call_ctors --export-if-defined=__wasm_apply_data_relocs \
+	  --experimental-pic \
+	  -pie \
+	  --no-export-dynamic \
+	  -o $@
+
+dylink-needed.wasm: dylink-needed.c libside1.so
+	clang-19 \
+	  --target=wasm32-wasi --sysroot=${WASIX_SYSROOT_PIC} \
+	  -matomics -mbulk-memory -mmutable-globals -pthread \
+	  -mthread-model posix -ftls-model=local-exec \
+      -fno-trapping-math -D_WASI_EMULATED_MMAN -D_WASI_EMULATED_SIGNAL \
+	  -D_WASI_EMULATED_PROCESS_CLOCKS \
+      -g -flto -O0 \
+	  -fPIC \
+      -c $< -o $(patsubst %.wasm, %.o, $@)
+
+	wasm-ld-19 \
+	  -L. -lside1 \
+	  -L${WASIX_SYSROOT_PIC}/lib \
+	  -L${WASIX_SYSROOT_PIC}/lib/wasm32-wasi \
+	  --whole-archive --export-all \
+	  $(patsubst %.wasm, %.o, $@) \
+	  ${WASIX_SYSROOT_PIC}/lib/wasm32-wasi/crt1.o \
+	  -lc -lresolv -lrt -lm -lpthread \
+	  -lwasi-emulated-mman \
+	  --max-memory=4294967296 --import-memory --shared-memory \
+	  --extra-features=atomics,bulk-memory,mutable-globals \
+	  --export=__wasm_signal --export=__tls_size --export=__tls_align \
+	  --export=__tls_base --export=__wasm_call_ctors --export-if-defined=__wasm_apply_data_relocs \
+	  --experimental-pic \
+	  -pie \
+	  --no-export-dynamic \
+	  -o $@
+
+%.wat: %.wasm
+	wasm-tools print $< > $@
+
+%.wat: %.so
+	wasm-tools print $< > $@
+
+install: libside1.so libside2.so dlopen.wasm dylink-needed.wasm
+	cp -f $^ ../integration/cli/tests/wasm
+
+clean:
+	rm -f *.wasm *.wat *.o *.so
\ No newline at end of file
diff --git a/tests/c-wasi-tests/dlopen.c b/tests/c-wasi-tests/dlopen.c
new file mode 100644
index 0000000000..40869cdc01
--- /dev/null
+++ b/tests/c-wasi-tests/dlopen.c
@@ -0,0 +1,70 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <dlfcn.h>
+
+void __attribute__((constructor)) main_ctor()
+{
+    printf("Main loaded\n");
+}
+
+void __attribute__((destructor)) main_dtor()
+{
+    printf("Main unloaded\n");
+}
+
+// TODO: the side module should run its destructors when it's unloaded
+// via dlclose, but currently, it does so when the main module exits.
+// This is a known issue with the current linker implementation.
+int main()
+{
+    printf("loading side module...\n");
+    void *handle = dlopen("libside1.so", RTLD_NOW);
+    if (!handle)
+    {
+        fprintf(stderr, "failed to open dl: %s\n", dlerror());
+        return 1;
+    }
+
+    printf("finding data_export...\n");
+    int *data_export = dlsym(handle, "data_export");
+    if (!data_export)
+    {
+        fprintf(stderr, "failed to find data_export symbol: %s\n", dlerror());
+        return 1;
+    }
+    if (*data_export != 42)
+    {
+        fprintf(stderr, "data_export expected to be 42: %d\n", *data_export);
+        return 1;
+    }
+    printf("data_export = %d\n", *data_export);
+
+    printf("finding func_export...\n");
+    int (*func_export)() = dlsym(handle, "func_export");
+    if (!func_export)
+    {
+        fprintf(stderr, "failed to find func_export symbol: %s\n", dlerror());
+        return 1;
+    }
+
+    printf("calling func_export\n");
+    printf("result: %d\n", func_export());
+
+    int (*local_function)(int *) = dlsym(handle, "local_function");
+    if (local_function)
+    {
+        fprintf(stderr, "local_function should not be found since it's private\n");
+        return 1;
+    }
+
+    printf("closing side\n");
+    if (dlclose(handle) != 0)
+    {
+        fprintf(stderr, "failed to unload library: %s\n", dlerror());
+        return 1;
+    }
+
+    printf("done!\n");
+
+    return 0;
+}
diff --git a/tests/c-wasi-tests/dylink-needed.c b/tests/c-wasi-tests/dylink-needed.c
new file mode 100644
index 0000000000..1d0d71c29d
--- /dev/null
+++ b/tests/c-wasi-tests/dylink-needed.c
@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+extern int data_export;
+extern int func_export();
+
+void __attribute__((constructor)) main_ctor()
+{
+    printf("Main loaded\n");
+}
+
+void __attribute__((destructor)) main_dtor()
+{
+    printf("Main unloaded\n");
+}
+
+int main()
+{
+    printf("Main started\n");
+
+    printf("data_export = %d\n", data_export);
+
+    printf("calling func_export directly\n");
+    printf("result: %d\n", func_export());
+
+    printf("calling func_export via pointer\n");
+    int (*func_export_ptr)() = &func_export;
+    (*func_export_ptr)();
+
+    printf("done\n");
+
+    return 0;
+}
\ No newline at end of file
diff --git a/tests/c-wasi-tests/side1.c b/tests/c-wasi-tests/side1.c
new file mode 100644
index 0000000000..b83c215015
--- /dev/null
+++ b/tests/c-wasi-tests/side1.c
@@ -0,0 +1,38 @@
+#include <stdio.h>
+
+int data_export = 42;
+
+extern int data_export2;
+extern int func_export2();
+
+void __attribute__((constructor)) side1_ctor()
+{
+    printf("Side 1 loaded\n");
+}
+
+void __attribute__((destructor)) side1_dtor()
+{
+    printf("Side 1 unloaded\n");
+}
+
+static void local_function(int *i)
+{
+    printf("local_function called with %d\n", *i);
+}
+
+int func_export()
+{
+    printf("func_export started\n");
+    int x = 123;
+    local_function(&x);
+
+    printf("calling func_export2\n");
+    printf("result: %d\n", func_export2());
+
+    printf("calling func_export2 via pointer\n");
+    int (*func_export2_ptr)() = &func_export2;
+    (*func_export2_ptr)();
+
+    printf("data_export2: %d\n", data_export2);
+    return 234;
+}
\ No newline at end of file
diff --git a/tests/c-wasi-tests/side2.c b/tests/c-wasi-tests/side2.c
new file mode 100644
index 0000000000..7106f56f57
--- /dev/null
+++ b/tests/c-wasi-tests/side2.c
@@ -0,0 +1,9 @@
+#include <stdio.h>
+
+int data_export2 = 10101;
+
+int func_export2()
+{
+    printf("starting func_export2\n");
+    return 987;
+}
\ No newline at end of file
diff --git a/tests/compilers/artifact.rs b/tests/compilers/artifact.rs
index 334ec9d2af..3e75630e1c 100644
--- a/tests/compilers/artifact.rs
+++ b/tests/compilers/artifact.rs
@@ -1,7 +1,7 @@
 use std::{fs, path::PathBuf};
 
-use cfg_if::cfg_if;
 use wasmer::{Engine, Module};
+use wasmer_types::Features;
 
 #[test]
 fn artifact_serialization_roundtrip() {
@@ -26,15 +26,20 @@ fn artifact_serialization_roundtrip() {
 #[ignore = "Please enable it when tests fail, so we can generate new versions of the .wasmu files"]
 fn artifact_serialization_build() {
     use std::str::FromStr;
-    use wasmer::sys::{get_default_compiler_config, Features, NativeEngineExt};
-    use wasmer::{CpuFeature, Target, Triple};
+    use wasmer::{
+        sys::{
+            engine::{get_default_compiler_config, NativeEngineExt},
+            CpuFeature, Target, Triple,
+        },
+        Engine, Module,
+    };
 
     let file_names = ["bash.wasm", "cowsay.wasm", "python-3.11.3.wasm"];
     let operating_systems = ["linux", "windows"];
     let chipset = "x86_64";
 
     for os in operating_systems {
-        let triple = Triple::from_str(&format!("{}-{}", chipset, os)).unwrap();
+        let triple = Triple::from_str(&format!("{chipset}-{os}")).unwrap();
         let mut cpu_feature = CpuFeature::set();
         cpu_feature.insert(CpuFeature::from_str("sse2").unwrap());
         let target = Target::new(triple, cpu_feature);
@@ -48,7 +53,7 @@ fn artifact_serialization_build() {
 
             let module = Module::new(&engine, wasm_module).unwrap();
             let serialized_bytes = module.serialize().unwrap();
-            let path = PathBuf::from(&format!("tests/compilers/wasmu/{}/{}u", os, file_name));
+            let path = PathBuf::from(&format!("tests/compilers/wasmu/{os}/{file_name}u"));
             std::fs::write(path, serialized_bytes).unwrap();
         }
     }
@@ -57,6 +62,7 @@ fn artifact_serialization_build() {
 #[test]
 #[cfg(target_arch = "x86_64")]
 fn artifact_deserialization_roundtrip() {
+    use cfg_if::cfg_if;
     // This test is included to make sure we don't break the serialized format
     // by mistake. Otherwise, everything in this test is already tested in
     // `artifact_serialization_roundtrip`.
diff --git a/tests/compilers/config.rs b/tests/compilers/config.rs
index 9673955876..f950ed4348 100644
--- a/tests/compilers/config.rs
+++ b/tests/compilers/config.rs
@@ -1,6 +1,9 @@
 use std::sync::Arc;
 use wasmer::sys::Features;
-use wasmer::{CompilerConfig, ModuleMiddleware, Store};
+use wasmer::{
+    sys::{CompilerConfig, ModuleMiddleware},
+    Store,
+};
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Compiler {
@@ -93,10 +96,7 @@ impl Config {
             }
             #[allow(unreachable_patterns)]
             compiler => {
-                panic!(
-                    "The {:?} Compiler is not enabled. Enable it via the features",
-                    compiler
-                )
+                panic!("The {compiler:?} Compiler is not enabled. Enable it via the features")
             }
         }
     }
diff --git a/tests/compilers/issues.rs b/tests/compilers/issues.rs
index 7eb051776b..5ca9a0b957 100644
--- a/tests/compilers/issues.rs
+++ b/tests/compilers/issues.rs
@@ -324,14 +324,20 @@ fn test_popcnt(mut config: crate::Config) -> Result<()> {
     let mut num = 1;
     for _ in 1..10000 {
         let result = popcnt_i32.call(&mut store, &[Value::I32(num)]).unwrap();
-        assert_eq!(&Value::I32(num.count_ones() as i32), result.get(0).unwrap());
+        assert_eq!(
+            &Value::I32(num.count_ones() as i32),
+            result.first().unwrap()
+        );
         num = get_next_number_i32(num);
     }
 
     let mut num = 1;
     for _ in 1..10000 {
         let result = popcnt_i64.call(&mut store, &[Value::I64(num)]).unwrap();
-        assert_eq!(&Value::I64(num.count_ones() as i64), result.get(0).unwrap());
+        assert_eq!(
+            &Value::I64(num.count_ones() as i64),
+            result.first().unwrap()
+        );
         num = get_next_number_i64(num);
     }
 
@@ -439,7 +445,7 @@ fn large_number_local(mut config: crate::Config) -> Result<()> {
         .get_function("large_local")?
         .call(&mut store, &[])
         .unwrap();
-    assert_eq!(&Value::I64(1_i64), result.get(0).unwrap());
+    assert_eq!(&Value::I64(1_i64), result.first().unwrap());
     Ok(())
 }
 
@@ -463,35 +469,66 @@ fn issue_4519(mut config: crate::Config) -> Result<()> {
 #[cfg(target_arch = "aarch64")]
 #[compiler_test(issues)]
 /// Singlepass panics on aarch64 for long relocations.
-/// This test specifically targets the emission of the sdiv64 binop.
+/// This test specifically targets the emission of sdiv64, srem64, urem64 binops.
 ///
 /// Note: this one is specific to Singlepass, but we want to test in all
 /// available compilers.
 ///
 /// https://github.com/wasmerio/wasmer/issues/4519
-fn issue_4519_sdiv64(mut config: crate::Config) -> Result<()> {
-    const REPEATS_TO_REPRODUCE: usize = 16_000;
-
-    let sdiv64 = r#"
-        i64.const 3155225962131072202
-        i64.const -6717269760755396770
-        i64.div_s
-        drop
-    "#;
+fn issue_4519_sdiv64_srem64_urem64(mut config: crate::Config) -> Result<()> {
+    const REPEATS_TO_REPRODUCE: usize = 30_000;
 
-    let wat = format!(
-        r#"
-      (module
-        (func (;0;)
-            {}
+    let ops = ["i64.div_s", "i64.rem_s", "i64.rem_u"];
+
+    for op in ops {
+        let sdiv64 = format!(
+            r#"
+            i64.const 3155225962131072202
+            i64.const -6717269760755396770
+            {op}
+            drop
+        "#
+        );
+
+        let wat = format!(
+            r#"
+        (module
+            (func (;0;)
+                {}
+            )
         )
+        "#,
+            sdiv64.repeat(REPEATS_TO_REPRODUCE)
+        );
+
+        let mut store = config.store();
+        let module = Module::new(&store, wat)?;
+    }
+
+    Ok(())
+}
+
+#[compiler_test(issues)]
+/// Singlepass panics when encountering ref types.
+///
+/// Note: this one is specific to Singlepass, but we want to test in all
+/// available compilers.
+///
+/// Note: for now, we don't want to implement reference types, we just don't want singlepass to
+/// panic.
+///
+/// https://github.com/wasmerio/wasmer/issues/5309
+fn issue_5309_reftype_panic(mut config: crate::Config) -> Result<()> {
+    let wat = r#"
+      (module
+        (type $x1 (func (param funcref)))
+        (import "env" "abort" (func $f (type $x1)))
       )
-    "#,
-        sdiv64.repeat(REPEATS_TO_REPRODUCE)
-    );
+    "#
+    .to_string();
 
     let mut store = config.store();
-    let module = Module::new(&store, wat)?;
+    let _ = Module::new(&store, wat);
 
     Ok(())
 }
diff --git a/tests/compilers/metering.rs b/tests/compilers/metering.rs
index 8d5855b54f..21676efc61 100644
--- a/tests/compilers/metering.rs
+++ b/tests/compilers/metering.rs
@@ -111,41 +111,41 @@ fn complex_loop(mut config: crate::Config) -> Result<()> {
         (local $l0 i32)
         block $B0
             i32.const 0
-            set_local $l0
+            local.set $l0
             loop $L1
-            get_local $l0
-            get_local $p0
+            local.get $l0
+            local.get $p0
             i32.lt_s
             i32.eqz
             br_if $B0
-            get_local $l0
+            local.get $l0
             i32.const 1
             i32.rem_s
             i32.const 0
             i32.eq
             if $I2
-                get_local $p1
-                get_local $l0
+                local.get $p1
+                local.get $l0
                 i32.add
-                set_local $p1
+                local.set $p1
             else
-                get_local $p1
-                get_local $l0
+                local.get $p1
+                local.get $l0
                 i32.mul
-                set_local $p1
+                local.set $p1
             end
-            get_local $l0
+            local.get $l0
             i32.const 1
             i32.add
-            set_local $l0
+            local.set $l0
             br $L1
             unreachable
             end
             unreachable
         end
-        get_local $p1)
+        local.get $p1)
         (func $f1 (type $t1))
-        (table $table (export "table") 1 anyfunc)
+        (table $table (export "table") 1 funcref)
         (memory $memory (export "memory") 0)
         (global $g0 i32 (i32.const 8))
         (elem (i32.const 0) $f1))
diff --git a/tests/compilers/middlewares.rs b/tests/compilers/middlewares.rs
index 393545098d..df5439961f 100644
--- a/tests/compilers/middlewares.rs
+++ b/tests/compilers/middlewares.rs
@@ -3,7 +3,7 @@ use anyhow::Result;
 use std::sync::Arc;
 use wasmer::wasmparser::Operator;
 use wasmer::FunctionEnv;
-use wasmer::*;
+use wasmer::{sys::*, *};
 
 #[derive(Debug)]
 struct Add2MulGen {
diff --git a/tests/compilers/multi_value_imports.rs b/tests/compilers/multi_value_imports.rs
index 26f291938b..2e26a5dc7a 100644
--- a/tests/compilers/multi_value_imports.rs
+++ b/tests/compilers/multi_value_imports.rs
@@ -16,7 +16,7 @@ macro_rules! mvr_test {
                     &stringify!( $( $result_type ),* ).replace(",", "").replace("(", "").replace(")", "") + &r#")))
   (import "host" "callback_fn" (func $callback_fn (type $type)))
   (func (export "test_call") (type $type)
-    get_local 0
+    local.get 0
     call $callback_fn)
   (func (export "test_call_indirect") (type $type)
     (i32.const 1)
diff --git a/tests/compilers/serialize.rs b/tests/compilers/serialize.rs
index fce0451402..582c1ec8a7 100644
--- a/tests/compilers/serialize.rs
+++ b/tests/compilers/serialize.rs
@@ -1,5 +1,5 @@
 use anyhow::Result;
-use wasmer::*;
+use wasmer::{sys::engine::NativeEngineExt, *};
 
 #[test]
 fn sanity_test_artifact_deserialize() {
@@ -62,7 +62,7 @@ fn test_deserialize(config: crate::Config) -> Result<()> {
     );
     let f0 = Function::new(&mut store, &func_type, |params| {
         let param_0: i64 = params[0].unwrap_i32() as i64;
-        let param_1: i64 = params[1].unwrap_i64() as i64;
+        let param_1: i64 = params[1].unwrap_i64();
         let param_2: i64 = params[2].unwrap_i32() as i64;
         let param_3: i64 = params[3].unwrap_f32() as i64;
         let param_4: i64 = params[4].unwrap_f64() as i64;
diff --git a/tests/compilers/traps.rs b/tests/compilers/traps.rs
index 1f369dd676..e173762867 100644
--- a/tests/compilers/traps.rs
+++ b/tests/compilers/traps.rs
@@ -114,7 +114,7 @@ fn test_trap_trace_cb(config: crate::Config) -> Result<()> {
         .expect_err("error calling function");
 
     let trace = e.trace();
-    println!("Trace {:?}", trace);
+    println!("Trace {trace:?}");
     // TODO: Reenable this (disabled as it was not working with llvm/singlepass)
     // assert_eq!(trace.len(), 2);
     // assert_eq!(trace[0].module_name(), "hello_mod");
@@ -300,7 +300,9 @@ fn rust_panic_import(config: crate::Config) -> Result<()> {
     let module = Module::new(&store, binary)?;
     let sig = FunctionType::new(vec![], vec![]);
     let func = Function::new(&mut store, &sig, |_| panic!("this is a panic"));
-    let f0 = Function::new_typed(&mut store, || panic!("this is another panic"));
+    let f0 = Function::new_typed(&mut store, || {
+        panic!("this is another panic");
+    });
     let instance = Instance::new(
         &mut store,
         &module,
@@ -359,7 +361,9 @@ fn rust_panic_start_function(config: crate::Config) -> Result<()> {
     .unwrap_err();
     assert_eq!(err.downcast_ref::<&'static str>(), Some(&"this is a panic"));
 
-    let func = Function::new_typed(&mut store, || panic!("this is another panic"));
+    let func = Function::new_typed(&mut store, || {
+        panic!("this is another panic");
+    });
     let err = panic::catch_unwind(AssertUnwindSafe(|| {
         drop(Instance::new(
             &mut store,
@@ -422,7 +426,7 @@ fn call_signature_mismatch(config: crate::Config) -> Result<()> {
             (func $bar (param i32))
             (start $foo)
 
-            (table 1 anyfunc)
+            (table 1 funcref)
             (elem (i32.const 0) 1)
         )
     "#;
@@ -430,7 +434,7 @@ fn call_signature_mismatch(config: crate::Config) -> Result<()> {
     let module = Module::new(&store, binary)?;
     let err = Instance::new(&mut store, &module, &imports! {}).expect_err("expected error");
     assert_eq!(
-        format!("{}", err),
+        format!("{err}"),
         "\
 RuntimeError: indirect call type mismatch
     at foo (a[0]:0x30)\
@@ -457,7 +461,7 @@ fn start_trap_pretty(config: crate::Config) -> Result<()> {
     let err = Instance::new(&mut store, &module, &imports! {}).expect_err("expected error");
 
     assert_eq!(
-        format!("{}", err),
+        format!("{err}"),
         "\
 RuntimeError: unreachable
     at die (m[0]:0x1d)
@@ -485,7 +489,7 @@ fn present_after_module_drop(config: crate::Config) -> Result<()> {
     return Ok(());
 
     fn assert_trap(t: RuntimeError) {
-        println!("{}", t);
+        println!("{t}");
         // assert_eq!(t.trace().len(), 1);
         // assert_eq!(t.trace()[0].func_index(), 0);
     }
diff --git a/tests/compilers/typed_functions.rs b/tests/compilers/typed_functions.rs
index f55447a43a..61fe171c7b 100644
--- a/tests/compilers/typed_functions.rs
+++ b/tests/compilers/typed_functions.rs
@@ -86,7 +86,7 @@ fn typed_host_function_closure_panics(config: crate::Config) {
     let mut store = config.store();
     let state = 3;
     Function::new_typed(&mut store, move |_: i32| {
-        println!("{}", state);
+        println!("{state}");
     });
 }
 
@@ -100,7 +100,7 @@ fn typed_with_env_host_function_closure_panics(config: crate::Config) {
         &mut store,
         &env,
         move |_env: FunctionEnvMut<i32>, _: i32| {
-            println!("{}", state);
+            println!("{state}");
         },
     );
 }
diff --git a/tests/compilers/wasi.rs b/tests/compilers/wasi.rs
index ffe37657c3..986052cc31 100644
--- a/tests/compilers/wasi.rs
+++ b/tests/compilers/wasi.rs
@@ -22,7 +22,7 @@ pub fn run_wasi(
     base_dir: &str,
     filesystem_kind: WasiFileSystemKind,
 ) -> anyhow::Result<()> {
-    println!("Running wasi wast `{}`", wast_path);
+    println!("Running wasi wast `{wast_path}`");
     let mut store = config.store();
 
     let source = {
diff --git a/tests/compilers/wasmu/linux/bash.wasmu b/tests/compilers/wasmu/linux/bash.wasmu
index 250829379c..6c36bc62c0 100644
Binary files a/tests/compilers/wasmu/linux/bash.wasmu and b/tests/compilers/wasmu/linux/bash.wasmu differ
diff --git a/tests/compilers/wasmu/linux/cowsay.wasmu b/tests/compilers/wasmu/linux/cowsay.wasmu
index edad4ec602..fc3a3b347b 100644
Binary files a/tests/compilers/wasmu/linux/cowsay.wasmu and b/tests/compilers/wasmu/linux/cowsay.wasmu differ
diff --git a/tests/compilers/wasmu/linux/python-3.11.3.wasmu b/tests/compilers/wasmu/linux/python-3.11.3.wasmu
index 3a00242a73..96a3f7d89f 100644
Binary files a/tests/compilers/wasmu/linux/python-3.11.3.wasmu and b/tests/compilers/wasmu/linux/python-3.11.3.wasmu differ
diff --git a/tests/compilers/wasmu/windows/bash.wasmu b/tests/compilers/wasmu/windows/bash.wasmu
index 129d6fdcda..6ad87ab566 100644
Binary files a/tests/compilers/wasmu/windows/bash.wasmu and b/tests/compilers/wasmu/windows/bash.wasmu differ
diff --git a/tests/compilers/wasmu/windows/cowsay.wasmu b/tests/compilers/wasmu/windows/cowsay.wasmu
index a3b5c42aad..c9036f6c1b 100644
Binary files a/tests/compilers/wasmu/windows/cowsay.wasmu and b/tests/compilers/wasmu/windows/cowsay.wasmu differ
diff --git a/tests/compilers/wasmu/windows/python-3.11.3.wasmu b/tests/compilers/wasmu/windows/python-3.11.3.wasmu
index c48ae7bb06..46c9777144 100644
Binary files a/tests/compilers/wasmu/windows/python-3.11.3.wasmu and b/tests/compilers/wasmu/windows/python-3.11.3.wasmu differ
diff --git a/tests/compilers/wast.rs b/tests/compilers/wast.rs
index f79ceac564..ae9e53b31e 100644
--- a/tests/compilers/wast.rs
+++ b/tests/compilers/wast.rs
@@ -17,12 +17,13 @@ use wasmer_wast::Wast;
 include!(concat!(env!("OUT_DIR"), "/generated_spectests.rs"));
 
 pub fn run_wast(mut config: crate::Config, wast_path: &str) -> anyhow::Result<()> {
-    println!("Running wast `{}`", wast_path);
+    println!("Running wast `{wast_path}`");
     let try_nan_canonicalization = wast_path.contains("nan-canonicalization");
     let mut features = Features::default();
     let is_bulkmemory = wast_path.contains("bulk-memory");
     let is_simd = wast_path.contains("simd");
     let is_threads = wast_path.contains("threads");
+    let is_exception_handling = wast_path.contains("exception-handling");
     if is_bulkmemory {
         features.bulk_memory(true);
     }
@@ -32,6 +33,10 @@ pub fn run_wast(mut config: crate::Config, wast_path: &str) -> anyhow::Result<()
     if is_threads {
         features.threads(true);
     }
+
+    if is_exception_handling {
+        features.exceptions(true);
+    }
     if config.compiler == crate::Compiler::Singlepass {
         features.multi_value(false);
     }
diff --git a/tests/examples/call_indirect.wat b/tests/examples/call_indirect.wat
index 613b5bfb4f..9e93646476 100644
--- a/tests/examples/call_indirect.wat
+++ b/tests/examples/call_indirect.wat
@@ -9,15 +9,15 @@
  (export "main" (func $main))
  (func $dispatch (; 0 ;) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
   (call_indirect (type $multiply_signature)
-   (get_local $1)
-   (get_local $2)
-   (get_local $0)
+   (local.get $1)
+   (local.get $2)
+   (local.get $0)
   )
  )
  (func $multiply (; 1 ;) (type $multiply_signature) (param $0 i32) (param $1 i32) (result i32)
   (i32.mul
-   (get_local $1)
-   (get_local $0)
+   (local.get $1)
+   (local.get $0)
   )
  )
  (func $main (; 2 ;) (result i32)
diff --git a/tests/examples/fib.wat b/tests/examples/fib.wat
index c23fbb66bb..c29b7ed15a 100644
--- a/tests/examples/fib.wat
+++ b/tests/examples/fib.wat
@@ -4,15 +4,15 @@
     )
 
     (func $fib (param $n i32) (result i32)
-        (if (i32.eq (get_local $n) (i32.const 0))
+        (if (i32.eq (local.get $n) (i32.const 0))
             (then (return (i32.const 1)))
         )
-        (if (i32.eq (get_local $n) (i32.const 1))
+        (if (i32.eq (local.get $n) (i32.const 1))
             (then (return (i32.const 1)))
         )
         (i32.add
-            (call $fib (i32.sub (get_local $n) (i32.const 1)))
-            (call $fib (i32.sub (get_local $n) (i32.const 2)))
+            (call $fib (i32.sub (local.get $n) (i32.const 1)))
+            (call $fib (i32.sub (local.get $n) (i32.const 2)))
         )
     )
 
diff --git a/tests/examples/memory.wat b/tests/examples/memory.wat
index 09c3685e22..88523348c1 100755
--- a/tests/examples/memory.wat
+++ b/tests/examples/memory.wat
@@ -3,13 +3,13 @@
     (table 20 anyfunc)
     (elem (i32.const 9) $f)
     (func $f (param i32) (result i32)
-        (get_local 0)
+        (local.get 0)
     )
     (func $main (export "main") (result i32)
         (local i32)
         (set_local 0 (i32.const 100))
-        (i32.store (get_local 0) (i32.const 1602))
-        (i32.load (get_local 0))
+        (i32.store (local.get 0) (i32.const 1602))
+        (i32.load (local.get 0))
 
         (drop)
         (memory.grow (i32.const 0))
diff --git a/tests/examples/test.py b/tests/examples/test.py
index ce47b771f4..f95d0c14f7 100644
--- a/tests/examples/test.py
+++ b/tests/examples/test.py
@@ -1 +1 @@
-print("hello")
\ No newline at end of file
+print("hello\n")
diff --git a/tests/ignores.txt b/tests/ignores.txt
index d32e3e1eb5..d0d6177401 100644
--- a/tests/ignores.txt
+++ b/tests/ignores.txt
@@ -1,5 +1,8 @@
 # Compilers
 singlepass spec::simd # Singlepass doesn't support yet SIMD (no one asked for this feature)
+singlepass spec::exception_handling # Singlepass doesn't support EH yet (no one asked for this feature)
+cranelift spec::exception_handling # Cranelift doesn't support EH yet (no one asked for this feature)
+windows spec::exception_handling # No EH support on Windows yet
 
 # Traps
 ## Traps. Tracing doesn't work properly in Singlepass
@@ -9,6 +12,7 @@ singlepass+aarch64+macos traps::test_trap_trace
 cranelift+aarch64+macos    traps::test_trap_trace
 llvm+aarch64    traps::test_trap_trace
 llvm+riscv64    traps::test_trap_trace
+llvm+loongarch64    traps::test_trap_trace
 singlepass+aarch64+macos traps::test_trap_stack_overflow # Need to investigate
 singlepass+aarch64+macos traps::trap_display_pretty
 llvm       traps::trap_display_pretty
@@ -29,6 +33,7 @@ cranelift+aarch64+macos    traps::start_trap_pretty
 # https://github.com/wasmerio/wasmer/issues/2808
 llvm+aarch64      spec::skip_stack_guard_page
 llvm+riscv64      spec::skip_stack_guard_page
+llvm+loongarch64  spec::skip_stack_guard_page
 
 # riscv support is still early, function call ABI needs some work
 llvm+riscv64      static_function::llvm::universal
@@ -56,6 +61,24 @@ cranelift+riscv64 spec::r#if::cranelift::universal
 # no SIMD on riscv, Cranelift will not handle them
 cranelift+riscv64 spec::simd
 
+# loongarch64 support is still early, function call ABI needs some work
+llvm+loongarch64  static_function::llvm::universal
+llvm+loongarch64  static_function_with_env::llvm::universal
+llvm+loongarch64  static_function_with_results::llvm::universal
+llvm+loongarch64  spec::f32::llvm::universal
+llvm+loongarch64  spec::f64::llvm::universal
+llvm+loongarch64  spec::float_misc::llvm::universal
+llvm+loongarch64  spec::memory_copy::llvm::universal
+llvm+loongarch64  spec::memory_init::llvm::universal
+llvm+loongarch64  spec::memory_trap::llvm::universal
+llvm+loongarch64  spec::multi_value::binary::llvm::universal
+llvm+loongarch64  spec::multi_value::block::llvm::universal
+llvm+loongarch64  spec::simd::simd_align::llvm::universal
+llvm+loongarch64  spec::simd::simd_f32x4_rounding::llvm::universal
+llvm+loongarch64  spec::simd::simd_f64x2_rounding::llvm::universal
+llvm+loongarch64  wasmer::nan_canonicalization::llvm::universal
+llvm+loongarch64  wasmer::stack_overflow_sret::llvm::universal
+
 # Windows doesn't overcommit and fails to allocate 4GB of memory
 windows wasmer::max_size_of_memory
 
diff --git a/tests/integration/cli/Cargo.toml b/tests/integration/cli/Cargo.toml
index a29b9d0a37..662cef0d7d 100644
--- a/tests/integration/cli/Cargo.toml
+++ b/tests/integration/cli/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "wasmer-integration-tests-cli"
-version = "4.3.7"
+version = "6.1.0"
 authors = ["Wasmer Engineering Team <engineering@wasmer.io>"]
 description = "CLI integration tests"
 repository = "https://github.com/wasmerio/wasmer"
@@ -9,33 +9,34 @@ publish = false
 
 [dev-dependencies]
 rand = "0.8.5"
-target-lexicon = "0.12.4"
-serde = { version = "1.0.147", features = ["derive"] }
+target-lexicon.workspace = true
+serde.workspace = true
 insta = { version = "1.21.1", features = ["json"] }
 md5 = "0.7.0"
-hex = "0.4.3"
-pretty_assertions = "1.3.0"
+hex.workspace = true
+pretty_assertions.workspace = true
 object = "0.30.0"
 reqwest = { workspace = true, default-features = false, features = ["json", "blocking", "rustls-tls"] }
-tokio = { version = "1", features = [ "rt", "rt-multi-thread", "macros" ] }
+tokio = { workspace = true, features = [ "rt", "rt-multi-thread", "macros", "process" ] }
 assert_cmd = "2.0.8"
 predicates = "2.1.5"
-once_cell = "1.17.1"
+once_cell.workspace = true
 futures = "0.3.28"
 regex = "1.8.3"
 libc.workspace = true
 
 [dependencies]
-anyhow = "1"
-tempfile = "3.6.0"
-target-lexicon = "0.12.5"
-tar = "0.4.38"
-flate2 = "1.0.24"
+anyhow.workspace = true
+tempfile.workspace = true
+target-lexicon.workspace = true
+tar.workspace = true
+flate2.workspace = true
 dirs = "4.0.0"
-derivative = { version = "^2" }
-wasmer-registry = { path = "../../../lib/registry", default-features = false }
 
 [features]
 default = ["webc_runner"]
 webc_runner = []
+wamr = []
+v8 = []
+wasmi = []
 debug = []
diff --git a/tests/integration/cli/src/assets.rs b/tests/integration/cli/src/assets.rs
index f6692636d8..84e2177940 100644
--- a/tests/integration/cli/src/assets.rs
+++ b/tests/integration/cli/src/assets.rs
@@ -67,7 +67,7 @@ pub fn get_libwasmer_path() -> PathBuf {
         ret = wasmer_target_path_2().join(LIBWASMER_FILENAME);
     }
     if !ret.exists() {
-        panic!("Could not find libwasmer path! {:?}", ret);
+        panic!("Could not find libwasmer path! {ret:?}");
     }
     ret
 }
@@ -93,7 +93,7 @@ pub fn get_wasmer_path() -> PathBuf {
                 }
             }
             None => {
-                panic!("Could not find wasmer executable path! {:?}", ret);
+                panic!("Could not find wasmer executable path! {ret:?}");
             }
         };
     }
@@ -112,7 +112,7 @@ pub fn get_wasmer_path() -> PathBuf {
                     .join(executable)
             }
             None => {
-                panic!("Could not find wasmer executable path! {:?}", ret);
+                panic!("Could not find wasmer executable path! {ret:?}");
             }
         };
     }
diff --git a/tests/integration/cli/tests/config.rs b/tests/integration/cli/tests/config.rs
index 491ae4b258..d4e506b21b 100644
--- a/tests/integration/cli/tests/config.rs
+++ b/tests/integration/cli/tests/config.rs
@@ -1,16 +1,41 @@
-use std::path::Path;
+use std::{fs::OpenOptions, io::Write, path::Path};
 
 use assert_cmd::Command;
 use predicates::str::contains;
 use tempfile::TempDir;
 use wasmer_integration_tests_cli::get_wasmer_path;
-use wasmer_registry::WasmerConfig;
 
 fn setup_wasmer_dir() -> TempDir {
     let temp = TempDir::new().unwrap();
 
-    let config_path = WasmerConfig::get_file_location(temp.path());
-    WasmerConfig::default().save(&config_path).unwrap();
+    // The config path and the config contents themselves are manually crafted so that we don't
+    // depend on the cli crate.
+    //
+    // Eventually, this part of the config shall live on a freestanding crate - perhaps added to
+    // `wasmer-config`.
+    let config_path = temp.path().join("wasmer.toml");
+
+    let contents = r#"
+telemetry_enabled = true
+update_notifications_enabled = true
+
+[registry]
+active_registry = "https://registry.wasmer.io/graphql"
+
+[[registry.tokens]]
+registry = "https://registry.wasmer.io/graphql"
+
+[proxy]
+        "#;
+
+    let mut file = OpenOptions::new()
+        .create(true)
+        .truncate(true)
+        .write(true)
+        .open(&config_path)
+        .unwrap();
+
+    file.write_all(contents.as_bytes()).unwrap();
 
     temp
 }
diff --git a/tests/integration/cli/tests/create.rs b/tests/integration/cli/tests/create.rs
index 9b553c430d..eb85f1109e 100644
--- a/tests/integration/cli/tests/create.rs
+++ b/tests/integration/cli/tests/create.rs
@@ -17,9 +17,9 @@ fn wasmer_create_package() -> anyhow::Result<()> {
         .arg("--quiet")
         .arg(format!("--name={app_name}"))
         .arg(format!("--owner={username}"))
-        .arg(format!("--package=wasmer/hello"))
+        .arg("--package=wasmer/hello")
         .arg(format!("--dir={}", app_dir.display()))
-        .arg(format!("--non-interactive"))
+        .arg("--non-interactive")
         .arg("--registry=https://registry.wasmer.wtf/graphql");
 
     if let Some(token) = wapm_dev_token {
@@ -61,9 +61,9 @@ fn wasmer_create_template() -> anyhow::Result<()> {
         .arg("--quiet")
         .arg(format!("--name={app_name}"))
         .arg(format!("--owner={username}"))
-        .arg(format!("--template=static-website"))
+        .arg("--template=static-website")
         .arg(format!("--dir={}", app_dir.display()))
-        .arg(format!("--non-interactive"))
+        .arg("--non-interactive")
         .arg("--registry=https://registry.wasmer.wtf/graphql");
 
     if let Some(token) = wapm_dev_token {
@@ -86,8 +86,7 @@ owner: {username}
     let got = std::fs::read_to_string(app_dir.join("app.yaml"))?;
     assert_eq!(got, want);
 
-    let want = format!(
-        r#"[dependencies]
+    let want = r#"[dependencies]
 "wasmer/static-web-server" = "^1"
 
 [fs]
@@ -101,8 +100,7 @@ runner = "https://webc.org/runner/wasi"
 
 [command.annotations.wasi]
 main-args = ["-w", "/settings/config.toml"]
-"#
-    );
+"#;
     let got = std::fs::read_to_string(app_dir.join("wasmer.toml"))?;
     assert_eq!(got, want);
 
diff --git a/tests/integration/cli/tests/create_exe.rs b/tests/integration/cli/tests/create_exe.rs
index 4511e343a3..e6cb19f3c3 100644
--- a/tests/integration/cli/tests/create_exe.rs
+++ b/tests/integration/cli/tests/create_exe.rs
@@ -41,7 +41,7 @@ impl Default for WasmerCreateExe {
         Self {
             current_dir: std::env::current_dir().unwrap(),
             wasmer_path: get_wasmer_path(),
-            wasm_path: PathBuf::from(fixtures::qjs()),
+            wasm_path: fixtures::qjs(),
             native_executable_path,
             compiler: Compiler::Cranelift,
             extra_cli_flags: vec![],
@@ -65,7 +65,7 @@ impl WasmerCreateExe {
             output.arg("--tarball");
             output.arg(&tarball_path);
         }
-        let cmd = format!("{:?}", output);
+        let cmd = format!("{output:?}");
 
         println!("(integration-test) running create-exe: {cmd}");
 
@@ -116,7 +116,7 @@ impl Default for WasmerCreateObj {
         Self {
             current_dir: std::env::current_dir().unwrap(),
             wasmer_path: get_wasmer_path(),
-            wasm_path: PathBuf::from(fixtures::qjs()),
+            wasm_path: fixtures::qjs(),
             output_object_path,
             compiler: Compiler::Cranelift,
             extra_cli_flags: vec![],
@@ -135,7 +135,7 @@ impl WasmerCreateObj {
         output.arg("-o");
         output.arg(&self.output_object_path);
 
-        let cmd = format!("{:?}", output);
+        let cmd = format!("{output:?}");
 
         println!("(integration-test) running create-obj: {cmd}");
 
@@ -265,9 +265,11 @@ fn test_create_exe_with_precompiled_works_1() {
 // Ignored because of -lunwind linker issue on Windows
 // see https://github.com/wasmerio/wasmer/issues/3459
 // Also ignored on macOS because it's flaky
-#[cfg_attr(any(target_os = "windows", target_os = "macos"), ignore)]
+#[cfg_attr(
+    any(target_os = "windows", target_os = "macos"),
+    ignore = "See https://github.com/wasmerio/wasmer/issues/4285"
+)]
 #[test]
-#[ignore = "See https://github.com/wasmerio/wasmer/issues/4285"]
 fn create_exe_works() -> anyhow::Result<()> {
     let temp_dir = tempfile::tempdir()?;
     let operating_dir: PathBuf = temp_dir.path().to_owned();
@@ -296,7 +298,7 @@ fn create_exe_works() -> anyhow::Result<()> {
     )
     .context("Failed to run generated executable")?;
     let result_lines = result.lines().collect::<Vec<&str>>();
-    assert_eq!(result_lines, vec!["\"Hello, World\""],);
+    assert_eq!(result_lines, vec!["\"Hello, World\""]);
 
     Ok(())
 }
@@ -396,7 +398,7 @@ fn create_exe_works_underscore_module_name() -> anyhow::Result<()> {
     let mut create_exe_flags = Vec::new();
 
     for a in atoms.iter() {
-        let object_path = operating_dir.as_path().join(&format!("{a}.o"));
+        let object_path = operating_dir.as_path().join(format!("{a}.o"));
         let _output: Vec<u8> = WasmerCreateObj {
             current_dir: operating_dir.clone(),
             wasm_path: wasm_path.clone(),
@@ -544,7 +546,7 @@ fn create_exe_works_with_file() -> anyhow::Result<()> {
     )
     .context("Failed to run generated executable")?;
     let result_lines = result.lines().collect::<Vec<&str>>();
-    assert_eq!(result_lines, vec!["\"Hello, World\""],);
+    assert_eq!(result_lines, vec!["\"Hello, World\""]);
 
     // test with `--mapdir`
     let result = run_code(
@@ -559,7 +561,7 @@ fn create_exe_works_with_file() -> anyhow::Result<()> {
     )
     .context("Failed to run generated executable")?;
     let result_lines = result.lines().collect::<Vec<&str>>();
-    assert_eq!(result_lines, vec!["\"Hello, World\""],);
+    assert_eq!(result_lines, vec!["\"Hello, World\""]);
 
     Ok(())
 }
@@ -673,7 +675,7 @@ fn create_exe_with_object_input(args: Vec<String>) -> anyhow::Result<()> {
     )
     .context("Failed to run generated executable")?;
     let result_lines = result.lines().collect::<Vec<&str>>();
-    assert_eq!(result_lines, vec!["\"Hello, World\""],);
+    assert_eq!(result_lines, vec!["\"Hello, World\""]);
 
     Ok(())
 }
@@ -828,7 +830,7 @@ fn test_cross_compile_python_windows() {
                     .filter_map(|e| Some(e.ok()?.path()))
                     .collect::<Vec<_>>();
                 let output = assert.get_output();
-                panic!("target {t} was not compiled correctly tempdir: {p:#?}, {output:?}",);
+                panic!("target {t} was not compiled correctly tempdir: {p:#?}, {output:?}");
             }
         }
     }
diff --git a/tests/integration/cli/tests/msrv.rs b/tests/integration/cli/tests/msrv.rs
index 8beac17371..bb60f55acf 100644
--- a/tests/integration/cli/tests/msrv.rs
+++ b/tests/integration/cli/tests/msrv.rs
@@ -96,7 +96,7 @@ fn ensure_file_contents(path: impl AsRef<Path>, contents: impl AsRef<str>) {
     if let Some(parent) = path.parent() {
         let _ = std::fs::create_dir_all(parent);
     }
-    std::fs::write(&path, contents).unwrap();
+    std::fs::write(path, contents).unwrap();
     panic!(
         "\"{}\" was not up to date and has been updated. Please commit the changes and re-run the tests.",
         path.strip_prefix(project_root()).unwrap_or(path).display()
diff --git a/tests/integration/cli/tests/packages/axum/Cargo.toml b/tests/integration/cli/tests/packages/axum/Cargo.toml
index ee730b73da..2ca5e91667 100644
--- a/tests/integration/cli/tests/packages/axum/Cargo.toml
+++ b/tests/integration/cli/tests/packages/axum/Cargo.toml
@@ -5,12 +5,12 @@ edition = "2021"
 
 [dependencies]
 axum = { version = "=0.6.9", features = ["tokio", "json"] }
-serde = { version = "1.0.160", features = ["derive"] }
-tracing = "0.1.37"
-tracing-subscriber = { version = "0.3.16", features = ["fmt"] }
+serde.workspace = true
+tracing.workspace = true
+tracing-subscriber = { workspace = true, features = ["fmt"] }
 
 # NOTE: We need to pin and replace some dependencies to achieve wasix compatibility.
-tokio = { version = "=1.24.2", default-features = false, features = ["full"] }
+tokio = { workspace = true, default-features = false, features = ["full"] }
 parking_lot = { version = "=0.12.1", features = ["nightly"] }
 
 [patch.crates-io]
diff --git a/tests/integration/cli/tests/publish.rs b/tests/integration/cli/tests/publish.rs
index c58a224a23..77fc4149ba 100644
--- a/tests/integration/cli/tests/publish.rs
+++ b/tests/integration/cli/tests/publish.rs
@@ -116,7 +116,7 @@ fn wasmer_init_publish() {
         .arg("build")
         .arg("--release")
         .arg("--target")
-        .arg("wasm32-wasi")
+        .arg("wasm32-wasip1")
         .arg("--manifest-path")
         .arg(path.join("randomversion").join("Cargo.toml"))
         .assert()
@@ -133,7 +133,7 @@ fn wasmer_init_publish() {
         .assert()
         .success();
 
-    let s = std::fs::read_to_string(path.join("randomversion").join("wasmer.toml")).unwrap();
+    let _s = std::fs::read_to_string(path.join("randomversion").join("wasmer.toml")).unwrap();
 
     // publish
     let mut cmd = std::process::Command::new(get_wasmer_path());
@@ -180,7 +180,7 @@ fn wasmer_publish_and_run() {
     .unwrap();
 
     let package_name =
-        format!("{username}/largewasmfile@{random_major}.{random_minor}.{random_patch}",);
+        format!("{username}/largewasmfile@{random_major}.{random_minor}.{random_patch}");
 
     let mut cmd = std::process::Command::new(get_wasmer_path());
     cmd.arg("publish")
diff --git a/tests/integration/cli/tests/run.rs b/tests/integration/cli/tests/run.rs
index b43f9d3750..d47dca2975 100644
--- a/tests/integration/cli/tests/run.rs
+++ b/tests/integration/cli/tests/run.rs
@@ -9,7 +9,7 @@ use std::{
 
 use assert_cmd::{assert::Assert, prelude::OutputAssertExt};
 use once_cell::sync::Lazy;
-use predicates::str::contains;
+use predicates::str::{contains, is_match};
 use rand::Rng;
 use reqwest::{blocking::Client, IntoUrl};
 use tempfile::TempDir;
@@ -47,7 +47,51 @@ static CACHE_RUST_LOG: Lazy<String> = Lazy::new(|| {
     .join(",")
 });
 
+#[tokio::test]
+async fn aio_http() {
+    let status = tokio::process::Command::new(get_wasmer_path())
+        .kill_on_drop(true)
+        .arg("package")
+        .arg("download")
+        .arg("wasmer-integration-tests/aio-http-hello-world")
+        .arg("-o")
+        .arg("aio-http-hello-world.webc")
+        .arg("--quiet")
+        .spawn()
+        .unwrap()
+        .wait()
+        .await
+        .unwrap();
+
+    assert!(status.success());
+
+    let mut wasmer = tokio::process::Command::new(get_wasmer_path())
+        .kill_on_drop(true)
+        .arg("run")
+        .arg("aio-http-hello-world.webc")
+        .arg("--net")
+        .stdout(Stdio::null())
+        .spawn()
+        .unwrap();
+
+    tokio::time::sleep(std::time::Duration::from_secs(5)).await;
+
+    let rsp = reqwest::Client::new()
+        .get("http://localhost:34343")
+        .send()
+        .await
+        .unwrap();
+
+    let body = rsp.text().await.unwrap();
+
+    assert_eq!(body, "Hello, World!");
+
+    wasmer.kill().await.unwrap();
+    wasmer.wait().await.unwrap();
+}
+
 #[test]
+#[cfg_attr(feature = "wasmi", ignore = "wasmi currently does not support threads")]
 fn list_cwd() {
     let package = packages().join("list-cwd");
 
@@ -58,6 +102,7 @@ fn list_cwd() {
         .unwrap();
 
     let stdout = output.stdout;
+    eprintln!("{}", String::from_utf8(output.stderr).unwrap());
 
     let expected = ".
 ..
@@ -71,6 +116,7 @@ wasmer.toml
 }
 
 #[test]
+#[cfg_attr(feature = "wasmi", ignore = "wasmi currently does not support threads")]
 fn nested_mounted_paths() {
     let package = packages().join("nested-mounted-paths");
 
@@ -82,6 +128,7 @@ fn nested_mounted_paths() {
         .output()
         .unwrap();
     let host_stdout = host_output.stdout;
+    println!("{}", String::from_utf8(host_output.stderr).unwrap());
 
     let webc_output = Command::new(get_wasmer_path())
         .arg("run")
@@ -89,7 +136,9 @@ fn nested_mounted_paths() {
         .arg(".")
         .output()
         .unwrap();
+
     let webc_stdout = webc_output.stdout;
+    println!("{}", String::from_utf8(webc_output.stderr).unwrap());
 
     let expected = "/:
 .
@@ -139,7 +188,12 @@ fn run_python_create_temp_dir_in_subprocess() {
         .output()
         .unwrap();
 
-    assert_eq!(output.stdout, "0".as_bytes().to_vec());
+    if cfg!(not(feature = "wamr")) {
+        assert_eq!(output.stdout, "0".as_bytes().to_vec());
+    } else {
+        // WAMR can print spurious warnings to stdout when running python, so we can't assert that it's exactly `[48]`.
+        assert!(output.status.success())
+    }
 }
 
 #[test]
@@ -159,7 +213,12 @@ fn run_php_with_sqlite() {
         .output()
         .unwrap();
 
-    assert_eq!(output.stdout, "0".as_bytes().to_vec());
+    if cfg!(not(feature = "wamr")) {
+        assert_eq!(output.stdout, "0".as_bytes().to_vec());
+    } else {
+        // WAMR can print spurious warnings to stdout when running php, so we can't assert that it's exactly `[48]`.
+        assert!(output.status.success())
+    }
 }
 
 /// Ignored on Windows because running vendored packages does not work
@@ -169,7 +228,6 @@ fn run_php_with_sqlite() {
 /// https://github.com/wasmerio/wasmer/issues/3535
 // FIXME: Re-enable. See https://github.com/wasmerio/wasmer/issues/3717
 #[test]
-#[ignore]
 fn test_run_customlambda() {
     let assert = Command::new(get_wasmer_path())
         .arg("config")
@@ -225,29 +283,25 @@ fn run_wasi_works() {
     assert.stdout("27\n");
 }
 
-// FIXME: Re-enable. See https://github.com/wasmerio/wasmer/issues/3717
 #[test]
-#[ignore]
 fn test_wasmer_run_pirita_works() {
     let temp_dir = tempfile::TempDir::new().unwrap();
     let python_wasmer_path = temp_dir.path().join("python.wasmer");
     std::fs::copy(fixtures::python(), &python_wasmer_path).unwrap();
 
-    let assert = Command::new(get_wasmer_path())
+    let output = Command::new(get_wasmer_path())
         .arg("run")
         .arg(python_wasmer_path)
         .arg("--")
         .arg("-c")
         .arg("print(\"hello\")")
-        .assert()
-        .success();
+        .output()
+        .unwrap();
 
-    assert.stdout("hello\n");
+    output.assert().success().stdout("hello\n");
 }
 
-// FIXME: Re-enable. See https://github.com/wasmerio/wasmer/issues/3717
 #[test]
-#[ignore]
 fn test_wasmer_run_pirita_url_works() {
     let assert = Command::new(get_wasmer_path())
         .arg("run")
@@ -296,40 +350,56 @@ fn test_wasmer_run_works_with_dir() {
 }
 
 // FIXME: Re-enable. See https://github.com/wasmerio/wasmer/issues/3717
-#[ignore]
 #[test]
+#[cfg_attr(feature = "wasmi", ignore = "wasmi currently does not support threads")]
 fn test_wasmer_run_works() {
     let assert = Command::new(get_wasmer_path())
-        .arg("https://wasmer.io/python/python@0.1.0")
+        .arg("https://wasmer.io/python/python@0.2.0")
         .arg(format!("--mapdir=.:{}", asset_path().display()))
         .arg("test.py")
         .assert()
         .success();
 
-    assert.stdout("hello\n");
+    if cfg!(not(feature = "wamr")) {
+        assert.stdout("hello\n");
+    } else {
+        // WAMR can print spurious warnings to stdout when running python, so it's better to use
+        // `contains` rather than asserting that stdout *is exactly* that
+        assert.stdout(contains("hello\n"));
+    }
 
     // same test again, but this time with "wasmer run ..."
     let assert = Command::new(get_wasmer_path())
         .arg("run")
-        .arg("https://wasmer.io/python/python@0.1.0")
+        .arg("https://wasmer.io/python/python@0.2.0")
         .arg(format!("--mapdir=.:{}", asset_path().display()))
         .arg("test.py")
         .assert()
         .success();
 
-    assert.stdout("hello\n");
+    if cfg!(not(feature = "wamr")) {
+        assert.stdout("hello\n");
+    } else {
+        // See above
+        assert.stdout(contains("hello\n"));
+    }
 
     // same test again, but this time without specifying the registry in the URL
     let assert = Command::new(get_wasmer_path())
         .arg("run")
-        .arg("python/python@0.1.0")
+        .arg("python/python@0.2.0")
         .arg(format!("--mapdir=.:{}", asset_path().display()))
         .arg("--registry=wasmer.io")
         .arg("test.py")
         .assert()
         .success();
 
-    assert.stdout("hello\n");
+    if cfg!(not(feature = "wamr")) {
+        assert.stdout("hello\n");
+    } else {
+        // See above
+        assert.stdout(contains("hello\n"));
+    }
 
     // same test again, but this time with only the command "python" (should be looked up locally)
     let assert = Command::new(get_wasmer_path())
@@ -341,7 +411,12 @@ fn test_wasmer_run_works() {
         .assert()
         .success();
 
-    assert.stdout("hello\n");
+    if cfg!(not(feature = "wamr")) {
+        assert.stdout("hello\n");
+    } else {
+        // See above
+        assert.stdout(contains("hello\n"));
+    }
 }
 
 #[test]
@@ -476,9 +551,7 @@ fn run_test_caching_works_for_urls() {
         // Got a cache hit downloading the *.webc file's metadata
         .stderr(contains("web_source: Cache hit"))
         // Cache hit downloading the *.webc file
-        .stderr(contains(
-            r#"builtin_loader: Cache hit! pkg.name="python" pkg.version=0.1.0"#,
-        ))
+        .stderr(contains("builtin_loader: Cache hit! pkg=python@0.1.0"))
         // Cache hit compiling the module
         .stderr(contains("module_cache::filesystem: Cache hit!"));
 }
@@ -648,6 +721,7 @@ fn wasi_runner_on_disk_with_mounted_directories_and_webc_volumes() {
     all(target_env = "musl", target_os = "linux"),
     ignore = "wasmer run-unstable segfaults on musl"
 )]
+#[cfg_attr(feature = "wamr", ignore = "wamr does not support multiple memories")]
 fn wasi_runner_on_disk_with_dependencies() {
     let port = random_port();
     let mut cmd = Command::new(get_wasmer_path());
@@ -789,6 +863,7 @@ fn wcgi_runner_on_disk_with_mounted_directories() {
     all(target_env = "musl", target_os = "linux"),
     ignore = "wasmer run-unstable segfaults on musl"
 )]
+#[cfg_attr(feature = "wasmi", ignore = "wasmi currently does not support threads")]
 fn issue_3794_unable_to_mount_relative_paths() {
     let temp = TempDir::new().unwrap();
     std::fs::write(temp.path().join("message.txt"), b"Hello, World!").unwrap();
@@ -815,6 +890,10 @@ fn issue_3794_unable_to_mount_relative_paths() {
     windows,
     ignore = "FIXME(Michael-F-Bryan): Temporarily broken on Windows - https://github.com/wasmerio/wasmer/issues/3929"
 )]
+#[cfg_attr(
+    feature = "wamr",
+    ignore = "FIXME(xdoardo): Bash is currently not working in wamr"
+)]
 fn merged_filesystem_contains_all_files() {
     let assert = Command::new(get_wasmer_path())
         .arg("run")
@@ -883,6 +962,10 @@ fn error_if_no_start_function_found() {
     all(target_env = "musl", target_os = "linux"),
     ignore = "wasmer run-unstable segfaults on musl"
 )]
+#[cfg_attr(
+    any(feature = "wamr", feature = "v8", feature = "wasmi"),
+    ignore = "wasmer using a c_api backend only may not have the 'compile' command"
+)]
 fn run_a_pre_compiled_wasm_file() {
     let temp = TempDir::new().unwrap();
     let dest = temp.path().join("qjs.wasmu");
@@ -980,6 +1063,11 @@ fn run_quickjs_via_url() {
     windows,
     ignore = "TODO(Michael-F-Bryan): Figure out why WasiFs::get_inode_at_path_inner() returns Errno::notcapable on Windows"
 )]
+#[cfg_attr(
+    feature = "wamr",
+    ignore = "FIXME(xdoardo): Bash is currently not working in wamr"
+)]
+#[cfg_attr(feature = "wasmi", ignore = "wasmi currently does not support threads")]
 fn run_bash_using_coreutils() {
     let assert = Command::new(get_wasmer_path())
         .arg("run")
@@ -997,10 +1085,13 @@ fn run_bash_using_coreutils() {
     // well as the commands from all the --use packages
 
     let some_expected_binaries = [
-        "arch", "base32", "base64", "baseenc", "basename", "bash", "cat",
+        "", "arch", "base32", "base64", "baseenc", "basename", "bash", "cat", "",
     ]
-    .join("\n");
-    assert.success().stdout(contains(some_expected_binaries));
+    .join("((?s)(.*))");
+
+    assert
+        .success()
+        .stdout(is_match(some_expected_binaries).unwrap());
 }
 
 #[test]
@@ -1024,6 +1115,7 @@ fn run_a_package_that_uses_an_atom_from_a_dependency() {
 }
 
 #[test]
+#[cfg_attr(feature = "wasmi", ignore = "wasmi currently does not support threads")]
 fn local_package_has_write_access_to_its_volumes() {
     let temp = tempfile::tempdir().unwrap();
 
@@ -1156,7 +1248,7 @@ fn wait_for(text: &str, reader: &mut dyn Read) -> String {
 fn read_line(reader: &mut dyn Read) -> Result<String, std::io::Error> {
     let mut line = Vec::new();
 
-    while !line.ends_with(&[b'\n']) {
+    while !line.ends_with(b"\n") {
         let mut buffer = [0_u8];
         match reader.read_exact(&mut buffer) {
             Ok(_) => {
diff --git a/tests/integration/cli/tests/snapshot.rs b/tests/integration/cli/tests/snapshot.rs
index a75274eddc..a39423978a 100644
--- a/tests/integration/cli/tests/snapshot.rs
+++ b/tests/integration/cli/tests/snapshot.rs
@@ -7,22 +7,25 @@ use std::{
 };
 
 use anyhow::Error;
-use derivative::Derivative;
 use futures::TryFutureExt;
 use insta::assert_json_snapshot;
 
 use tempfile::NamedTempFile;
 use wasmer_integration_tests_cli::get_wasmer_path;
 
-#[derive(Derivative, serde::Serialize, serde::Deserialize, Clone)]
-#[derivative(Debug, PartialEq)]
+#[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
 pub struct TestIncludeWeb {
     pub name: String,
-    #[derivative(Debug = "ignore", PartialEq = "ignore")]
     #[serde(skip, default = "default_include_webc")]
     pub webc: Arc<NamedTempFile>,
 }
 
+impl PartialEq for TestIncludeWeb {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name
+    }
+}
+
 fn default_include_webc() -> Arc<NamedTempFile> {
     Arc::new(NamedTempFile::new().unwrap())
 }
@@ -48,6 +51,9 @@ pub struct TestSpec {
     #[serde(skip_serializing_if = "is_false")]
     #[serde(default)]
     pub enable_async_threads: bool,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    #[serde(default)]
+    pub mounts: Vec<(PathBuf, PathBuf)>,
 }
 
 fn is_false(b: &bool) -> bool {
@@ -137,6 +143,7 @@ impl TestBuilder {
                 enable_threads: true,
                 enable_network: false,
                 enable_async_threads: false,
+                mounts: vec![],
             },
         }
     }
@@ -214,6 +221,14 @@ impl TestBuilder {
         self
     }
 
+    pub fn mount(mut self, host: impl AsRef<Path>, guest: impl AsRef<Path>) -> Self {
+        let guest = guest.as_ref().to_path_buf();
+        let host = host.as_ref().canonicalize().unwrap();
+        assert!(guest.is_absolute());
+        self.spec.mounts.push((guest, host));
+        self
+    }
+
     pub fn run_file(self, path: impl AsRef<Path>) -> TestSnapshot {
         snapshot_file(path.as_ref(), self.spec)
     }
@@ -248,11 +263,8 @@ impl Default for TestBuilder {
 }
 
 pub fn wasm_dir() -> PathBuf {
-    std::env::current_dir()
-        .unwrap()
-        .parent()
-        .unwrap()
-        .join("wasm")
+    let dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
+    Path::new(&dir).join("tests").join("wasm")
 }
 
 fn wasmer_path() -> PathBuf {
@@ -309,6 +321,14 @@ pub fn run_test_with(spec: TestSpec, code: &[u8], with: RunWith) -> TestResult {
         cmd.arg("--include-webc").arg(pkg.webc.path());
     }
 
+    for mount in &spec.mounts {
+        cmd.arg("--mapdir").arg(format!(
+            "{}:{}",
+            mount.0.to_str().unwrap(),
+            mount.1.to_str().unwrap()
+        ));
+    }
+
     cmd.env("RUST_LOG", "off");
 
     cmd.env("RUST_BACKTRACE", "1");
@@ -641,7 +661,7 @@ fn test_run_http_request(
 
     let expected_size = match expected_size {
         None => {
-            let url = format!("http://localhost:{}/{}.size", port, what);
+            let url = format!("http://localhost:{port}/{what}.size");
             let expected_size = String::from_utf8_lossy(http_get(url, 50)?.as_ref())
                 .trim()
                 .parse()?;
@@ -652,9 +672,9 @@ fn test_run_http_request(
         }
         Some(s) => s,
     };
-    println!("expected_size: {}", expected_size);
+    println!("expected_size: {expected_size}");
 
-    let url = format!("http://localhost:{}/{}", port, what);
+    let url = format!("http://localhost:{port}/{what}");
     let reference_data = http_get(url.clone(), 50)?;
     for _ in 0..20 {
         let test_data = http_get(url.clone(), 2)?;
@@ -722,8 +742,7 @@ fn test_snapshot_web_server() {
 cat /public/main.js | wc -c > /public/main.js.size
 rm -r -f /cfg/
 cd /public
-/bin/webserver --log-level warn --root /public --port {}"#,
-        port
+/bin/webserver --log-level warn --root /public --port {port}"#,
     );
     let builder = TestBuilder::new()
         .with_name(name)
@@ -762,7 +781,7 @@ fn test_snapshot_web_server_epoll() {
         .arg("--log-level")
         .arg("warn")
         .arg("--port")
-        .arg(&format!("{}", port));
+        .arg(format!("{port}"));
 
     let snapshot = builder.run_wasm_with(
         include_bytes!("./wasm/web-server-epoll.wasm"),
@@ -795,7 +814,7 @@ fn test_snapshot_web_server_poll() {
         .arg("--log-level")
         .arg("warn")
         .arg("--port")
-        .arg(&format!("{}", port));
+        .arg(format!("{port}"));
 
     let snapshot = builder.run_wasm_with(
         include_bytes!("./wasm/web-server-poll.wasm"),
@@ -1281,3 +1300,112 @@ fn test_snapshot_fs_rename() {
         .run_wasm(include_bytes!("./wasm/fs-rename.wasm"));
     assert_json_snapshot!(snapshot);
 }
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_exit_0_from_main() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .run_wasm(include_bytes!("./wasm/exit-0-from-main.wasm"));
+    assert!(matches!(
+        snapshot.result,
+        TestResult::Success(TestOutput { exit_code: 0, .. })
+    ));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_exit_1_from_main() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .run_wasm(include_bytes!("./wasm/exit-1-from-main.wasm"));
+    assert!(matches!(
+        snapshot.result,
+        TestResult::Success(TestOutput { exit_code: 1, .. })
+    ));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_exit_0_from_worker() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .run_wasm(include_bytes!("./wasm/exit-0-from-worker.wasm"));
+    assert!(matches!(
+        snapshot.result,
+        TestResult::Success(TestOutput { exit_code: 0, .. })
+    ));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_exit_1_from_worker() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .run_wasm(include_bytes!("./wasm/exit-1-from-worker.wasm"));
+    assert!(matches!(
+        snapshot.result,
+        TestResult::Success(TestOutput { exit_code: 1, .. })
+    ));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_worker_terminating_normally() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .run_wasm(include_bytes!("./wasm/worker-terminating-normally.wasm"));
+    assert!(matches!(
+        snapshot.result,
+        TestResult::Success(TestOutput { exit_code: 0, .. })
+    ));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_worker_panicking() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .run_wasm(include_bytes!("./wasm/worker-panicking.wasm"));
+    assert!(matches!(
+        snapshot.result,
+        TestResult::Success(TestOutput { exit_code: 173, .. })
+    ));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_mkdir_rename() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .run_wasm(include_bytes!("./wasm/mkdir-rename.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_dlopen() {
+    // test sources in tests/c-wasi-tests
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .mount(wasm_dir(), "/lib")
+        .run_wasm(include_bytes!("./wasm/dlopen.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_dylink_needed() {
+    // test sources in tests/c-wasi-tests
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .mount(wasm_dir(), "/lib")
+        .run_wasm(include_bytes!("./wasm/dylink-needed.wasm"));
+    assert_json_snapshot!(snapshot);
+}
diff --git a/tests/integration/cli/tests/snapshots/snapshot__snapshot_dlopen.snap b/tests/integration/cli/tests/snapshots/snapshot__snapshot_dlopen.snap
new file mode 100644
index 0000000000..41b312318d
--- /dev/null
+++ b/tests/integration/cli/tests/snapshots/snapshot__snapshot_dlopen.snap
@@ -0,0 +1,28 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+assertion_line: 1399
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_dlopen",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false,
+    "mounts": [
+      [
+        "/lib",
+        "/home/arshia/repos/wasmer/wasmer/tests/integration/cli/tests/wasm"
+      ]
+    ]
+  },
+  "result": {
+    "Success": {
+      "stdout": "Main loaded\nloading side module...\nSide 1 loaded\nfinding data_export...\ndata_export = 42\nfinding func_export...\ncalling func_export\nfunc_export started\nlocal_function called with 123\ncalling func_export2\nstarting func_export2\nresult: 987\ncalling func_export2 via pointer\nstarting func_export2\ndata_export2: 10101\nresult: 234\nclosing side\ndone!\nSide 1 unloaded\nMain unloaded\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/tests/integration/cli/tests/snapshots/snapshot__snapshot_dylink_needed.snap b/tests/integration/cli/tests/snapshots/snapshot__snapshot_dylink_needed.snap
new file mode 100644
index 0000000000..059dc104b2
--- /dev/null
+++ b/tests/integration/cli/tests/snapshots/snapshot__snapshot_dylink_needed.snap
@@ -0,0 +1,28 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+assertion_line: 1409
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_dylink_needed",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false,
+    "mounts": [
+      [
+        "/lib",
+        "/home/arshia/repos/wasmer/wasmer/tests/integration/cli/tests/wasm"
+      ]
+    ]
+  },
+  "result": {
+    "Success": {
+      "stdout": "Side 1 loaded\nMain loaded\nMain started\ndata_export = 42\ncalling func_export directly\nfunc_export started\nlocal_function called with 123\ncalling func_export2\nstarting func_export2\nresult: 987\ncalling func_export2 via pointer\nstarting func_export2\ndata_export2: 10101\nresult: 234\ncalling func_export via pointer\nfunc_export started\nlocal_function called with 123\ncalling func_export2\nstarting func_export2\nresult: 987\ncalling func_export2 via pointer\nstarting func_export2\ndata_export2: 10101\ndone\nMain unloaded\nSide 1 unloaded\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/tests/integration/cli/tests/snapshots/snapshot__snapshot_exit_0_from_main.snap b/tests/integration/cli/tests/snapshots/snapshot__snapshot_exit_0_from_main.snap
new file mode 100644
index 0000000000..ecff3deec8
--- /dev/null
+++ b/tests/integration/cli/tests/snapshots/snapshot__snapshot_exit_0_from_main.snap
@@ -0,0 +1,21 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_exit_0_from_main",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/tests/integration/cli/tests/snapshots/snapshot__snapshot_exit_0_from_worker.snap b/tests/integration/cli/tests/snapshots/snapshot__snapshot_exit_0_from_worker.snap
new file mode 100644
index 0000000000..700990daa1
--- /dev/null
+++ b/tests/integration/cli/tests/snapshots/snapshot__snapshot_exit_0_from_worker.snap
@@ -0,0 +1,22 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+assertion_line: 1309
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_exit_0_from_worker",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/tests/integration/cli/tests/snapshots/snapshot__snapshot_exit_1_from_main.snap b/tests/integration/cli/tests/snapshots/snapshot__snapshot_exit_1_from_main.snap
new file mode 100644
index 0000000000..648532b484
--- /dev/null
+++ b/tests/integration/cli/tests/snapshots/snapshot__snapshot_exit_1_from_main.snap
@@ -0,0 +1,22 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+assertion_line: 1300
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_exit_1_from_main",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "",
+      "stderr": "",
+      "exit_code": 1
+    }
+  }
+}
diff --git a/tests/integration/cli/tests/snapshots/snapshot__snapshot_exit_1_from_worker.snap b/tests/integration/cli/tests/snapshots/snapshot__snapshot_exit_1_from_worker.snap
new file mode 100644
index 0000000000..6057c50b02
--- /dev/null
+++ b/tests/integration/cli/tests/snapshots/snapshot__snapshot_exit_1_from_worker.snap
@@ -0,0 +1,22 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+assertion_line: 1318
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_exit_1_from_worker",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "",
+      "stderr": "",
+      "exit_code": 1
+    }
+  }
+}
diff --git a/tests/integration/cli/tests/snapshots/snapshot__snapshot_mkdir_rename.snap b/tests/integration/cli/tests/snapshots/snapshot__snapshot_mkdir_rename.snap
new file mode 100644
index 0000000000..ec4c07b5e9
--- /dev/null
+++ b/tests/integration/cli/tests/snapshots/snapshot__snapshot_mkdir_rename.snap
@@ -0,0 +1,22 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+assertion_line: 1369
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_mkdir_rename",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/tests/integration/cli/tests/snapshots/snapshot__snapshot_worker_panicking.snap b/tests/integration/cli/tests/snapshots/snapshot__snapshot_worker_panicking.snap
new file mode 100644
index 0000000000..108e464722
--- /dev/null
+++ b/tests/integration/cli/tests/snapshots/snapshot__snapshot_worker_panicking.snap
@@ -0,0 +1,22 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+assertion_line: 1336
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_worker_panicking",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "",
+      "stderr": "thread '<unnamed>' panicked at src/bin/worker-panicking.rs:3:9:\nchild thread panicking\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace\n",
+      "exit_code": 173
+    }
+  }
+}
diff --git a/tests/integration/cli/tests/snapshots/snapshot__snapshot_worker_terminating_normally.snap b/tests/integration/cli/tests/snapshots/snapshot__snapshot_worker_terminating_normally.snap
new file mode 100644
index 0000000000..7bc3af32a3
--- /dev/null
+++ b/tests/integration/cli/tests/snapshots/snapshot__snapshot_worker_terminating_normally.snap
@@ -0,0 +1,22 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+assertion_line: 1327
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_worker_terminating_normally",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "In child thread\nIn main thread\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/tests/integration/cli/tests/wasm/dlopen.wasm b/tests/integration/cli/tests/wasm/dlopen.wasm
new file mode 100755
index 0000000000..33649fdba1
Binary files /dev/null and b/tests/integration/cli/tests/wasm/dlopen.wasm differ
diff --git a/tests/integration/cli/tests/wasm/dylink-needed.wasm b/tests/integration/cli/tests/wasm/dylink-needed.wasm
new file mode 100755
index 0000000000..69cf8e6fc9
Binary files /dev/null and b/tests/integration/cli/tests/wasm/dylink-needed.wasm differ
diff --git a/tests/integration/cli/tests/wasm/exit-0-from-main.wasm b/tests/integration/cli/tests/wasm/exit-0-from-main.wasm
new file mode 100644
index 0000000000..1804962058
Binary files /dev/null and b/tests/integration/cli/tests/wasm/exit-0-from-main.wasm differ
diff --git a/tests/integration/cli/tests/wasm/exit-0-from-worker.wasm b/tests/integration/cli/tests/wasm/exit-0-from-worker.wasm
new file mode 100644
index 0000000000..929389d31a
Binary files /dev/null and b/tests/integration/cli/tests/wasm/exit-0-from-worker.wasm differ
diff --git a/tests/integration/cli/tests/wasm/exit-1-from-main.wasm b/tests/integration/cli/tests/wasm/exit-1-from-main.wasm
new file mode 100644
index 0000000000..43f62bf916
Binary files /dev/null and b/tests/integration/cli/tests/wasm/exit-1-from-main.wasm differ
diff --git a/tests/integration/cli/tests/wasm/exit-1-from-worker.wasm b/tests/integration/cli/tests/wasm/exit-1-from-worker.wasm
new file mode 100644
index 0000000000..855c4ddaf2
Binary files /dev/null and b/tests/integration/cli/tests/wasm/exit-1-from-worker.wasm differ
diff --git a/tests/integration/cli/tests/wasm/libside1.so b/tests/integration/cli/tests/wasm/libside1.so
new file mode 100755
index 0000000000..bb72325046
Binary files /dev/null and b/tests/integration/cli/tests/wasm/libside1.so differ
diff --git a/tests/integration/cli/tests/wasm/libside2.so b/tests/integration/cli/tests/wasm/libside2.so
new file mode 100755
index 0000000000..590b1ea7bb
Binary files /dev/null and b/tests/integration/cli/tests/wasm/libside2.so differ
diff --git a/tests/integration/cli/tests/wasm/mkdir-rename.wasm b/tests/integration/cli/tests/wasm/mkdir-rename.wasm
new file mode 100644
index 0000000000..ad160ef9f9
Binary files /dev/null and b/tests/integration/cli/tests/wasm/mkdir-rename.wasm differ
diff --git a/tests/integration/cli/tests/wasm/worker-panicking.wasm b/tests/integration/cli/tests/wasm/worker-panicking.wasm
new file mode 100644
index 0000000000..8dc9639374
Binary files /dev/null and b/tests/integration/cli/tests/wasm/worker-panicking.wasm differ
diff --git a/tests/integration/cli/tests/wasm/worker-terminating-normally.wasm b/tests/integration/cli/tests/wasm/worker-terminating-normally.wasm
new file mode 100644
index 0000000000..2ccbd04537
Binary files /dev/null and b/tests/integration/cli/tests/wasm/worker-terminating-normally.wasm differ
diff --git a/tests/integration/cli/tests/webc/wasmer-tests--volume-static-webserver@0.1.0.webc b/tests/integration/cli/tests/webc/wasmer-tests--volume-static-webserver@0.1.0.webc
new file mode 100644
index 0000000000..ca28cc71e5
Binary files /dev/null and b/tests/integration/cli/tests/webc/wasmer-tests--volume-static-webserver@0.1.0.webc differ
diff --git a/tests/integration/ios/Cargo.toml b/tests/integration/ios/Cargo.toml
index 073eb73f6c..7a590c78ce 100644
--- a/tests/integration/ios/Cargo.toml
+++ b/tests/integration/ios/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "wasmer-integration-tests-ios"
-version = "4.3.7"
+version = "6.1.0"
 authors = ["Wasmer Engineering Team <engineering@wasmer.io>"]
 description = "iOS integration tests"
 repository = "https://github.com/wasmerio/wasmer"
diff --git a/tests/lib/compiler-test-derive/build.rs b/tests/lib/compiler-test-derive/build.rs
index d65caeba6a..255c164c0a 100644
--- a/tests/lib/compiler-test-derive/build.rs
+++ b/tests/lib/compiler-test-derive/build.rs
@@ -1,12 +1,12 @@
 fn main() {
     println!("cargo:rerun-if-changed=../../ignores.txt");
     if let Ok(os) = std::env::var("CARGO_CFG_TARGET_OS") {
-        println!("cargo:rustc-env=CFG_TARGET_OS={}", os);
+        println!("cargo:rustc-env=CFG_TARGET_OS={os}");
     }
     if let Ok(os) = std::env::var("CARGO_CFG_TARGET_ARCH") {
-        println!("cargo:rustc-env=CFG_TARGET_ARCH={}", os);
+        println!("cargo:rustc-env=CFG_TARGET_ARCH={os}");
     }
     if let Ok(os) = std::env::var("CARGO_CFG_TARGET_ENV") {
-        println!("cargo:rustc-env=CFG_TARGET_ENV={}", os);
+        println!("cargo:rustc-env=CFG_TARGET_ENV={os}");
     }
 }
diff --git a/tests/lib/compiler-test-derive/src/ignores.rs b/tests/lib/compiler-test-derive/src/ignores.rs
index 12364cf219..268f11e4e4 100644
--- a/tests/lib/compiler-test-derive/src/ignores.rs
+++ b/tests/lib/compiler-test-derive/src/ignores.rs
@@ -111,7 +111,7 @@ impl Ignores {
                             target_env = Some(alias.to_string());
                         }
                         // Chipset architectures
-                        "aarch64" | "x86" | "x64" | "riscv64" => {
+                        "aarch64" | "x86" | "x64" | "riscv64" | "loongarch64" => {
                             arch = Some(alias.to_string());
                         }
                         // Engines
diff --git a/tests/lib/compiler-test-derive/src/lib.rs b/tests/lib/compiler-test-derive/src/lib.rs
index 83c95eba0e..2243c98282 100644
--- a/tests/lib/compiler-test-derive/src/lib.rs
+++ b/tests/lib/compiler-test-derive/src/lib.rs
@@ -94,8 +94,12 @@ fn compiler_test_impl(attrs: TokenStream, input: TokenStream) -> TokenStream {
     let construct_compiler_test =
         |func: &::syn::ItemFn, compiler_name: &str| -> ::proc_macro2::TokenStream {
             let mod_name = ::quote::format_ident!("{}", compiler_name.to_lowercase());
-            let universal_engine_test =
-                construct_engine_test(func, compiler_name, "Universal", "universal");
+            let universal_engine_test = construct_engine_test(
+                func,
+                compiler_name,
+                compiler_name,
+                &compiler_name.to_lowercase(),
+            );
             let compiler_name_lowercase = compiler_name.to_lowercase();
 
             quote! {
diff --git a/tests/lib/compiler-test-derive/src/tests.rs b/tests/lib/compiler-test-derive/src/tests.rs
index b25b39988c..378ddf0acf 100644
--- a/tests/lib/compiler-test-derive/src/tests.rs
+++ b/tests/lib/compiler-test-derive/src/tests.rs
@@ -44,7 +44,7 @@ gen_tests! {
     } == stringify! {
         #[cfg(test)]
         mod foo {
-            use super::*;
+            use super:: * ;
 
             #[allow(unused)]
             fn foo(config: crate::Config) {
@@ -53,11 +53,11 @@ gen_tests! {
 
             #[cfg(feature = "singlepass")]
             mod singlepass {
-                use super::*;
+                use super:: * ;
                 #[test_log::test]
                 #[cold]
-                #[cfg(feature = "universal")]
-                fn universal() {
+                #[cfg(feature = "singlepass")]
+                fn singlepass() {
                     foo(crate::Config::new(
                         crate::Compiler::Singlepass
                     ))
@@ -66,11 +66,11 @@ gen_tests! {
 
             #[cfg(feature = "cranelift")]
             mod cranelift {
-                use super::*;
+                use super:: * ;
                 #[test_log::test]
                 #[cold]
-                #[cfg(feature = "universal")]
-                fn universal() {
+                #[cfg(feature = "cranelift")]
+                fn cranelift() {
                     foo(crate::Config::new(
                         crate::Compiler::Cranelift
                     ))
@@ -79,11 +79,11 @@ gen_tests! {
 
             #[cfg(feature = "llvm")]
             mod llvm {
-                use super::*;
+                use super:: * ;
                 #[test_log::test]
                 #[cold]
-                #[cfg(feature = "universal")]
-                fn universal() {
+                #[cfg(feature = "llvm")]
+                fn llvm() {
                     foo(crate::Config::new(
                         crate::Compiler::LLVM
                     ))
diff --git a/tests/lib/test-generator/src/lib.rs b/tests/lib/test-generator/src/lib.rs
index b1e4a16e09..cf5f81ce96 100644
--- a/tests/lib/test-generator/src/lib.rs
+++ b/tests/lib/test-generator/src/lib.rs
@@ -7,7 +7,7 @@
 //! > https://github.com/bytecodealliance/wasmtime/blob/master/build.rs
 mod processors;
 
-pub use crate::processors::{emscripten_processor, wasi_processor, wast_processor};
+pub use crate::processors::{wasi_processor, wast_processor};
 use anyhow::Context;
 use std::fmt::Write;
 use std::path::{Path, PathBuf};
@@ -44,7 +44,7 @@ fn write_test(out: &mut Testsuite, testname: &str, body: &str) -> anyhow::Result
         "fn r#{}(config: crate::Config) -> anyhow::Result<()> {{",
         &testname
     )?;
-    writeln!(out.buffer, "{}", body)?;
+    writeln!(out.buffer, "{body}")?;
     writeln!(out.buffer, "}}")?;
     writeln!(out.buffer)?;
     Ok(())
@@ -58,7 +58,7 @@ pub fn test_directory(
     let path = path.as_ref();
     let mut dir_entries: Vec<_> = path
         .read_dir()
-        .context(format!("failed to read {:?}", path))?
+        .context(format!("failed to read {path:?}"))?
         .map(|r| r.expect("reading testsuite directory entry"))
         .filter_map(|dir_entry| processor(out, dir_entry.path()))
         .collect();
diff --git a/tests/lib/test-generator/src/processors.rs b/tests/lib/test-generator/src/processors.rs
index ce7ca22cc3..7fe35b3ec3 100644
--- a/tests/lib/test-generator/src/processors.rs
+++ b/tests/lib/test-generator/src/processors.rs
@@ -27,40 +27,6 @@ pub fn wast_processor(_out: &mut Testsuite, p: PathBuf) -> Option<Test> {
     })
 }
 
-/// Given a Testsuite and a path, process the path in case is a Emscripten
-/// wasm file.
-pub fn emscripten_processor(_out: &mut Testsuite, p: PathBuf) -> Option<Test> {
-    let ext = p.extension()?;
-    // Only look at wast files.
-    if ext != "wasm" {
-        return None;
-    }
-
-    let outfile = {
-        let mut out_ext = p.clone();
-        out_ext.set_extension("out");
-        if out_ext.exists() {
-            out_ext
-        } else {
-            return None;
-        }
-    };
-
-    let testname = extract_name(&p);
-
-    // The implementation of `run_emscripten` lives in /tests/emtest.rs
-    let body = format!(
-        "crate::emscripten::run_emscripten(config, r#\"{}\"#, r#\"{}\"#)",
-        p.display(),
-        outfile.display()
-    );
-
-    Some(Test {
-        name: testname,
-        body,
-    })
-}
-
 /// Given a Testsuite and a path, process the path in case is a WASI
 /// wasm file.
 pub fn wasi_processor(
diff --git a/tests/lib/wast/Cargo.toml b/tests/lib/wast/Cargo.toml
index fa5c1a4935..ec1998ef8f 100644
--- a/tests/lib/wast/Cargo.toml
+++ b/tests/lib/wast/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "wasmer-wast"
-version = "4.3.7"
+version = "6.1.0"
 authors = ["Wasmer Engineering Team <engineering@wasmer.io>"]
 description = "wast testing support for wasmer"
 license = "MIT OR Apache-2.0 WITH LLVM-exception"
@@ -11,20 +11,20 @@ readme = "README.md"
 edition = "2018"
 
 [dependencies]
-wasmer-types = { path = "../../../lib/types", version="=4.3.7" }
-wasmer-wasix = { path = "../../../lib/wasix", version="=0.27.0" }
-wasmer = { path = "../../../lib/api", version = "=4.3.7", default-features = false }
-virtual-fs = { path = "../../../lib/virtual-fs", version = "0.16.0" }
+wasmer-types = { path = "../../../lib/types", version = "=6.1.0" }
+wasmer-wasix = { path = "../../../lib/wasix", version = "=0.601.0" }
+wasmer = { path = "../../../lib/api", version = "=6.1.0", default-features = false }
+virtual-fs = { path = "../../../lib/virtual-fs", version = "0.601.0" }
 
-anyhow = "1.0"
-wast = "38.0"
+anyhow.workspace = true
+wast = "221.0.2"
 serde = "1"
-tempfile = "3.6.0"
-thiserror = "1.0"
+tempfile.workspace = true
+thiserror.workspace = true
 futures = "0.3"
-tokio = { version = "1", features = [
-    "io-util",
-    "rt",
+tokio = { workspace = true, features = [
+	"io-util",
+	"rt",
 ], default-features = false }
 
 [features]
diff --git a/tests/lib/wast/src/spectest.rs b/tests/lib/wast/src/spectest.rs
index 7eda1b643b..ca5effd6ba 100644
--- a/tests/lib/wast/src/spectest.rs
+++ b/tests/lib/wast/src/spectest.rs
@@ -5,23 +5,23 @@ use wasmer::*;
 #[allow(clippy::print_stdout)]
 pub fn spectest_importobject(store: &mut Store) -> Imports {
     let print = Function::new_typed(store, || {});
-    let print_i32 = Function::new_typed(store, |val: i32| println!("{}: i32", val));
-    let print_i64 = Function::new_typed(store, |val: i64| println!("{}: i64", val));
-    let print_f32 = Function::new_typed(store, |val: f32| println!("{}: f32", val));
-    let print_f64 = Function::new_typed(store, |val: f64| println!("{}: f64", val));
+    let print_i32 = Function::new_typed(store, |val: i32| println!("{val}: i32"));
+    let print_i64 = Function::new_typed(store, |val: i64| println!("{val}: i64"));
+    let print_f32 = Function::new_typed(store, |val: f32| println!("{val}: f32"));
+    let print_f64 = Function::new_typed(store, |val: f64| println!("{val}: f64"));
     let print_i32_f32 = Function::new_typed(store, |i: i32, f: f32| {
-        println!("{}: i32", i);
-        println!("{}: f32", f);
+        println!("{i}: i32");
+        println!("{f}: f32");
     });
     let print_f64_f64 = Function::new_typed(store, |f1: f64, f2: f64| {
-        println!("{}: f64", f1);
-        println!("{}: f64", f2);
+        println!("{f1}: f64");
+        println!("{f2}: f64");
     });
 
     let global_i32 = Global::new(store, Value::I32(666));
     let global_i64 = Global::new(store, Value::I64(666));
-    let global_f32 = Global::new(store, Value::F32(f32::from_bits(0x4426_8000)));
-    let global_f64 = Global::new(store, Value::F64(f64::from_bits(0x4084_d000_0000_0000)));
+    let global_f32 = Global::new(store, Value::F32(666.6));
+    let global_f64 = Global::new(store, Value::F64(666.6));
 
     let ty = TableType::new(Type::FuncRef, 10, Some(20));
     let table = Table::new(store, ty, Value::FuncRef(None)).unwrap();
diff --git a/tests/lib/wast/src/wasi_wast.rs b/tests/lib/wast/src/wasi_wast.rs
index 4491fbc82d..404a54583d 100644
--- a/tests/lib/wast/src/wasi_wast.rs
+++ b/tests/lib/wast/src/wasi_wast.rs
@@ -110,7 +110,7 @@ impl<'a> WasiTest<'a> {
         let mut rt = PluggableRuntime::new(Arc::new(TokioTaskManager::new(runtime)));
         #[cfg(target_arch = "wasm32")]
         let mut rt = PluggableRuntime::new(Arc::new(TokioTaskManager::default()));
-        rt.set_engine(Some(store.engine().clone()));
+        rt.set_engine(store.engine().clone());
 
         let mut pb = PathBuf::from(base_path);
         pb.push(self.wasm_path);
@@ -155,9 +155,7 @@ impl<'a> WasiTest<'a> {
                 let stderr_str = get_stdio_output(&stderr_rx)?;
                 Err(e).with_context(|| {
                     format!(
-                        "failed to run WASI `_start` function: failed with stdout: \"{}\"\nstderr: \"{}\"",
-                        stdout_str,
-                        stderr_str,
+                        "failed to run WASI `_start` function: failed with stdout: \"{stdout_str}\"\nstderr: \"{stderr_str}\"",
                     )
                 })?;
             }
@@ -165,7 +163,7 @@ impl<'a> WasiTest<'a> {
 
         if let Some(expected_stdout) = &self.assert_stdout {
             let stdout_str = get_stdio_output(&stdout_rx)?;
-            dbg!(&expected_stdout, &stdout_str);
+            //dbg!(&expected_stdout, &stdout_str);
             assert_eq!(stdout_str, expected_stdout.expected);
         }
 
@@ -307,7 +305,7 @@ impl<'a> WasiTest<'a> {
 
                 for alias in &self.temp_dirs {
                     let temp_dir_name =
-                        PathBuf::from(format!("/.tmp_wasmer_wast_{}", temp_dir_index));
+                        PathBuf::from(format!("/.tmp_wasmer_wast_{temp_dir_index}"));
                     fs.create_dir(temp_dir_name.as_path())?;
                     builder.add_map_dir(alias, temp_dir_name)?;
                     temp_dir_index += 1;
@@ -378,55 +376,55 @@ impl<'a> Parse<'a> for WasiTest<'a> {
             let wasm_path = parser.parse::<&'a str>()?;
 
             // TODO: allow these to come in any order
-            let envs = if parser.peek2::<wasi_kw::envs>() {
+            let envs = if parser.peek2::<wasi_kw::envs>()? {
                 parser.parens(|p| p.parse::<Envs>())?.envs
             } else {
                 vec![]
             };
 
-            let args = if parser.peek2::<wasi_kw::args>() {
+            let args = if parser.peek2::<wasi_kw::args>()? {
                 parser.parens(|p| p.parse::<Args>())?.args
             } else {
                 vec![]
             };
 
-            let dirs = if parser.peek2::<wasi_kw::preopens>() {
+            let dirs = if parser.peek2::<wasi_kw::preopens>()? {
                 parser.parens(|p| p.parse::<Preopens>())?.preopens
             } else {
                 vec![]
             };
 
-            let mapped_dirs = if parser.peek2::<wasi_kw::map_dirs>() {
+            let mapped_dirs = if parser.peek2::<wasi_kw::map_dirs>()? {
                 parser.parens(|p| p.parse::<MapDirs>())?.map_dirs
             } else {
                 vec![]
             };
 
-            let temp_dirs = if parser.peek2::<wasi_kw::temp_dirs>() {
+            let temp_dirs = if parser.peek2::<wasi_kw::temp_dirs>()? {
                 parser.parens(|p| p.parse::<TempDirs>())?.temp_dirs
             } else {
                 vec![]
             };
 
-            let assert_return = if parser.peek2::<wasi_kw::assert_return>() {
+            let assert_return = if parser.peek2::<wasi_kw::assert_return>()? {
                 Some(parser.parens(|p| p.parse::<AssertReturn>())?)
             } else {
                 None
             };
 
-            let stdin = if parser.peek2::<wasi_kw::stdin>() {
+            let stdin = if parser.peek2::<wasi_kw::stdin>()? {
                 Some(parser.parens(|p| p.parse::<Stdin>())?)
             } else {
                 None
             };
 
-            let assert_stdout = if parser.peek2::<wasi_kw::assert_stdout>() {
+            let assert_stdout = if parser.peek2::<wasi_kw::assert_stdout>()? {
                 Some(parser.parens(|p| p.parse::<AssertStdout>())?)
             } else {
                 None
             };
 
-            let assert_stderr = if parser.peek2::<wasi_kw::assert_stderr>() {
+            let assert_stderr = if parser.peek2::<wasi_kw::assert_stderr>()? {
                 Some(parser.parens(|p| p.parse::<AssertStderr>())?)
             } else {
                 None
@@ -458,7 +456,7 @@ impl<'a> Parse<'a> for Envs<'a> {
         let mut envs = vec![];
         parser.parse::<wasi_kw::envs>()?;
 
-        while parser.peek::<&'a str>() {
+        while parser.peek::<&'a str>()? {
             let res = parser.parse::<&'a str>()?;
             let mut strs = res.split('=');
             let first = strs.next().unwrap();
@@ -480,7 +478,7 @@ impl<'a> Parse<'a> for Args<'a> {
         let mut args = vec![];
         parser.parse::<wasi_kw::args>()?;
 
-        while parser.peek::<&'a str>() {
+        while parser.peek::<&'a str>()? {
             let res = parser.parse::<&'a str>()?;
             args.push(res);
         }
@@ -498,7 +496,7 @@ impl<'a> Parse<'a> for Preopens<'a> {
         let mut preopens = vec![];
         parser.parse::<wasi_kw::preopens>()?;
 
-        while parser.peek::<&'a str>() {
+        while parser.peek::<&'a str>()? {
             let res = parser.parse::<&'a str>()?;
             preopens.push(res);
         }
@@ -516,7 +514,7 @@ impl<'a> Parse<'a> for MapDirs<'a> {
         let mut map_dirs = vec![];
         parser.parse::<wasi_kw::map_dirs>()?;
 
-        while parser.peek::<&'a str>() {
+        while parser.peek::<&'a str>()? {
             let res = parser.parse::<&'a str>()?;
             let mut iter = res.split(':');
             let dir = iter.next().unwrap();
@@ -537,7 +535,7 @@ impl<'a> Parse<'a> for TempDirs<'a> {
         let mut temp_dirs = vec![];
         parser.parse::<wasi_kw::temp_dirs>()?;
 
-        while parser.peek::<&'a str>() {
+        while parser.peek::<&'a str>()? {
             let alias = parser.parse::<&'a str>()?;
             temp_dirs.push(alias);
         }
diff --git a/tests/lib/wast/src/wast.rs b/tests/lib/wast/src/wast.rs
index 80b02adc27..e524132783 100644
--- a/tests/lib/wast/src/wast.rs
+++ b/tests/lib/wast/src/wast.rs
@@ -5,6 +5,10 @@ use std::collections::{HashMap, HashSet};
 use std::path::Path;
 use std::str;
 use wasmer::*;
+use wast::core::{AbstractHeapType, HeapType, WastArgCore, WastRetCore};
+use wast::token::{F32, F64};
+use wast::{lexer::Lexer, parser};
+use wast::{QuoteWat, Wast as WWast, WastArg};
 
 /// The wast test script language allows modules to be defined and actions
 /// to be performed on them.
@@ -31,6 +35,9 @@ pub struct Wast {
     /// A flag indicating that assert_trap and assert_exhaustion should be skipped.
     /// See https://github.com/wasmerio/wasmer/issues/1550 for more info
     disable_assert_trap_exhaustion: bool,
+
+    /// A flag indicating that assert_exception should be skipped.
+    disable_assert_exception: bool,
 }
 
 impl Wast {
@@ -46,6 +53,7 @@ impl Wast {
             instances: HashMap::new(),
             fail_fast: true,
             disable_assert_trap_exhaustion: false,
+            disable_assert_exception: false,
         }
     }
 
@@ -68,6 +76,11 @@ impl Wast {
         self.disable_assert_trap_exhaustion = true;
     }
 
+    /// Do not run any code in assert_exception.
+    pub fn disable_assert_exception(&mut self) {
+        self.disable_assert_exception = true;
+    }
+
     /// Construct a new instance of `Wast` with the spectests imports.
     pub fn new_with_spectest(mut store: Store) -> Self {
         let import_object = spectest_importobject(&mut store);
@@ -92,12 +105,14 @@ impl Wast {
     fn perform_execute(&mut self, exec: wast::WastExecute<'_>) -> Result<Vec<Value>> {
         match exec {
             wast::WastExecute::Invoke(invoke) => self.perform_invoke(invoke),
-            wast::WastExecute::Module(mut module) => {
+            wast::WastExecute::Wat(mut module) => {
                 let binary = module.encode()?;
                 let result = self.instantiate(&binary);
                 result.map(|_| Vec::new())
             }
-            wast::WastExecute::Get { module, global } => self.get(module.map(|s| s.name()), global),
+            wast::WastExecute::Get { module, global, .. } => {
+                self.get(module.map(|s| s.name()), global)
+            }
         }
     }
 
@@ -105,7 +120,11 @@ impl Wast {
         let values = exec
             .args
             .iter()
-            .map(|a| self.runtime_value(a))
+            .map(|v| match v {
+                WastArg::Core(v) => self.runtime_value(v),
+                WastArg::Component(_) => bail!("expected component function, found core"),
+                _ => todo!(),
+            })
             .collect::<Result<Vec<_>>>()?;
         self.invoke(exec.module.map(|i| i.name()), exec.name, &values)
     }
@@ -113,15 +132,22 @@ impl Wast {
     fn assert_return(
         &self,
         result: Result<Vec<Value>>,
-        results: &[wast::AssertExpression],
+        results: &[wast::WastRet<'_>],
     ) -> Result<()> {
         let values = result?;
         for (v, e) in values.iter().zip(results) {
-            if self.val_matches(v, e)? {
-                continue;
+            match e {
+                wast::WastRet::Core(e) => {
+                    if self.val_matches(v, e)? {
+                        continue;
+                    }
+                }
+                wast::WastRet::Component(_) => anyhow::bail!("Components not supported yet!"),
+                _ => todo!(),
             }
+
             if let Value::V128(bits) = v {
-                if let wast::AssertExpression::V128(pattern) = e {
+                if let wast::WastRet::Core(WastRetCore::V128(pattern)) = e {
                     bail!(
                         "expected {:?}, got {:?} (v128 bits: {})",
                         e,
@@ -130,7 +156,41 @@ impl Wast {
                     );
                 }
             }
-            bail!("expected {:?}, got {:?}", e, v)
+            if let Some(f) = v.f64() {
+                if let wast::WastRet::Core(WastRetCore::F64(wast::core::NanPattern::Value(f1))) = e
+                {
+                    let f = f64::from_bits(f1.bits);
+                    bail!("expected {f:?} ({:?}), got {v:?} ({})", e, f.to_bits())
+                } else {
+                    bail!("expected {:?}, got {:?} ({})", e, v, f.to_bits())
+                }
+            } else if let Some(f) = v.f32() {
+                if let wast::WastRet::Core(WastRetCore::F32(wast::core::NanPattern::Value(f1))) = e
+                {
+                    let f = f32::from_bits(f1.bits);
+                    bail!("expected {f:?} ({:?}), got {v:?} ({})", e, f.to_bits())
+                } else {
+                    bail!("expected {:?}, got {:?} ({})", e, v, f.to_bits())
+                }
+            } else {
+                bail!("expected {:?}, got {:?}", e, v)
+            }
+        }
+        Ok(())
+    }
+    /// Define a module and register it.
+    fn wat(&mut self, mut wat: QuoteWat<'_>) -> Result<()> {
+        let (is_module, name) = match &wat {
+            QuoteWat::Wat(wast::Wat::Module(m)) => (true, m.id.map(|v| v.name())),
+            QuoteWat::QuoteModule(..) => (true, None),
+            QuoteWat::Wat(wast::Wat::Component(m)) => (false, m.id.map(|v| v.name())),
+            QuoteWat::QuoteComponent(..) => (false, None),
+        };
+        let bytes = wat.encode()?;
+        if is_module {
+            self.module(name, &bytes)?;
+        } else {
+            bail!("component-model support not enabled");
         }
         Ok(())
     }
@@ -138,7 +198,7 @@ impl Wast {
     fn assert_trap(&self, result: Result<Vec<Value>>, expected: &str) -> Result<()> {
         let actual = match result {
             Ok(values) => bail!("expected trap, got {:?}", values),
-            Err(t) => format!("{}", t),
+            Err(t) => format!("{t}"),
         };
         if self.matches_message_assert_trap(expected, &actual) {
             return Ok(());
@@ -146,14 +206,12 @@ impl Wast {
         bail!("expected '{}', got '{}'", expected, actual)
     }
 
-    fn run_directive(&mut self, test: &Path, directive: wast::WastDirective) -> Result<()> {
+    fn run_directive(&mut self, _test: &Path, directive: wast::WastDirective) -> Result<()> {
         use wast::WastDirective::*;
 
         match directive {
-            Module(mut module) => {
-                let binary = module.encode()?;
-                self.module(module.id.map(|s| s.name()), &binary)?;
-            }
+            ModuleDefinition(module) => self.wat(module)?,
+            Module(module) => self.wat(module)?,
             Register {
                 span: _,
                 name,
@@ -197,15 +255,11 @@ impl Wast {
                 module,
                 message,
             } => {
-                let wasm = match module {
-                    wast::QuoteModule::Module(mut m) => m.encode()?,
-                    wast::QuoteModule::Quote(list) => self.parse_quote_module(test, &list)?,
-                };
-                let err = match self.module(None, &wasm) {
+                let err = match self.wat(module) {
                     Ok(()) => bail!("expected module to fail to build"),
                     Err(e) => e,
                 };
-                let error_message = format!("{:?}", err);
+                let error_message = format!("{err:?}");
                 if !Self::matches_message_assert_invalid(message, &error_message) {
                     bail!(
                         "assert_invalid: expected \"{}\", got \"{}\"",
@@ -214,11 +268,11 @@ impl Wast {
                     )
                 }
             }
-            QuoteModule { .. } => {
-                // Do nothing
-            }
-            AssertException { .. } => {
-                // Do nothing for now
+            AssertException { span: _, exec } => {
+                if !self.disable_assert_exception {
+                    let result = self.perform_execute(exec);
+                    self.assert_exception(result)?;
+                }
             }
             AssertMalformed {
                 module,
@@ -226,10 +280,13 @@ impl Wast {
                 message: _,
             } => {
                 let mut module = match module {
-                    wast::QuoteModule::Module(m) => m,
+                    wast::QuoteWat::Wat(m) => m,
                     // This is a `*.wat` parser test which we're not
                     // interested in.
-                    wast::QuoteModule::Quote(_) => return Ok(()),
+                    wast::QuoteWat::QuoteModule(_, _) => return Ok(()),
+                    wast::QuoteWat::QuoteComponent(_, _) => {
+                        anyhow::bail!("Components not supported!")
+                    }
                 };
                 let bytes = module.encode()?;
                 if self.module(None, &bytes).is_ok() {
@@ -246,7 +303,7 @@ impl Wast {
                     Ok(()) => bail!("expected module to fail to link"),
                     Err(e) => e,
                 };
-                let error_message = format!("{:?}", err);
+                let error_message = format!("{err:?}");
                 if !Self::matches_message_assert_unlinkable(message, &error_message) {
                     bail!(
                         "assert_unlinkable: expected {}, got {}",
@@ -255,6 +312,14 @@ impl Wast {
                     )
                 }
             }
+            Thread(_) => anyhow::bail!("`thread` directives not implemented yet!"),
+            Wait { .. } => anyhow::bail!("`wait` directives not implemented yet!"),
+            ModuleInstance { .. } => {
+                anyhow::bail!("module instance directive not implemented yet!")
+            }
+            AssertSuspension { .. } => {
+                anyhow::bail!("`assert suspension` directive not implemented yet!")
+            }
         }
 
         Ok(())
@@ -270,13 +335,16 @@ impl Wast {
             err
         };
 
-        let buf = wast::parser::ParseBuffer::new(wast).map_err(adjust_wast)?;
-        let ast = wast::parser::parse::<wast::Wast>(&buf).map_err(adjust_wast)?;
+        let mut lexer = Lexer::new(wast);
+        lexer.allow_confusing_unicode(filename.ends_with("names.wast"));
+        let buf = wast::parser::ParseBuffer::new_with_lexer(lexer).map_err(adjust_wast)?;
+        let ast = parser::parse::<WWast>(&buf).map_err(adjust_wast)?;
+
         let mut errors = Vec::with_capacity(ast.directives.len());
         for directive in ast.directives {
             let sp = directive.span();
             if let Err(e) = self.run_directive(test, directive) {
-                let message = format!("{}", e);
+                let message = format!("{e}");
                 // If depends on an instance that doesn't exist
                 if message.contains("no previous instance found") {
                     continue;
@@ -307,28 +375,28 @@ impl Wast {
         Ok(())
     }
 
-    fn parse_quote_module(&self, test: &Path, source: &[&[u8]]) -> Result<Vec<u8>> {
-        let mut ret = String::new();
-        for src in source {
-            match str::from_utf8(src) {
-                Ok(s) => ret.push_str(s),
-                Err(_) => bail!("malformed UTF-8 encoding"),
-            }
-            ret.push(' ');
-        }
-        let buf = wast::parser::ParseBuffer::new(&ret)?;
-        let mut wat = wast::parser::parse::<wast::Wat>(&buf)?;
-
-        // TODO: when memory64 merges into the proper spec then this should be
-        // removed since it will presumably no longer be a text-format error but
-        // rather a validation error. Currently all non-memory64 proposals
-        // assert that this offset is a text-parser error, whereas with memory64
-        // support that error is deferred until later.
-        if ret.contains("offset=4294967296") && !test.iter().any(|t| t == "memory64") {
-            bail!("i32 constant out of bounds");
-        }
-        Ok(wat.module.encode()?)
-    }
+    //fn parse_quote_module(&self, test: &Path, source: &[&[u8]]) -> Result<Vec<u8>> {
+    //    let mut ret = String::new();
+    //    for src in source {
+    //        match str::from_utf8(src) {
+    //            Ok(s) => ret.push_str(s),
+    //            Err(_) => bail!("malformed UTF-8 encoding"),
+    //        }
+    //        ret.push(' ');
+    //    }
+    //    let buf = wast::parser::ParseBuffer::new(&ret)?;
+    //    let mut wat = wast::parser::parse::<wast::Wat>(&buf)?;
+
+    //    // TODO: when memory64 merges into the proper spec then this should be
+    //    // removed since it will presumably no longer be a text-format error but
+    //    // rather a validation error. Currently all non-memory64 proposals
+    //    // assert that this offset is a text-parser error, whereas with memory64
+    //    // support that error is deferred until later.
+    //    if ret.contains("offset=4294967296") && !test.iter().any(|t| t == "memory64") {
+    //        bail!("i32 constant out of bounds");
+    //    }
+    //    Ok(wat.encode()?)
+    //}
 
     /// Run a wast script from a file.
     pub fn run_file(&mut self, path: &Path) -> Result<()> {
@@ -347,7 +415,7 @@ impl Wast {
                 // We set the current to None to allow running other
                 // spectests when `fail_fast` is `false`.
                 self.current = None;
-                let error_message = format!("{}", e);
+                let error_message = format!("{e}");
                 self.current_is_allowed_failure = false;
                 for allowed_failure in self.allowed_instantiation_failures.iter() {
                     if error_message.contains(allowed_failure) {
@@ -416,20 +484,23 @@ impl Wast {
     }
 
     /// Translate from a `script::Value` to a `Value`.
-    fn runtime_value(&mut self, v: &wast::Expression<'_>) -> Result<Value> {
-        use wast::Instruction::*;
-
-        if v.instrs.len() != 1 {
-            bail!("too many instructions in {:?}", v);
-        }
-        Ok(match &v.instrs[0] {
-            I32Const(x) => Value::I32(*x),
-            I64Const(x) => Value::I64(*x),
-            F32Const(x) => Value::F32(f32::from_bits(x.bits)),
-            F64Const(x) => Value::F64(f64::from_bits(x.bits)),
-            V128Const(x) => Value::V128(u128::from_le_bytes(x.to_le_bytes())),
-            RefNull(wast::HeapType::Func) => Value::FuncRef(None),
-            RefNull(wast::HeapType::Extern) => Value::null(),
+    fn runtime_value(&mut self, v: &WastArgCore) -> Result<Value> {
+        use wast::core::WastArgCore::*;
+
+        Ok(match v {
+            I32(x) => Value::I32(*x),
+            I64(x) => Value::I64(*x),
+            F32(x) => Value::F32(f32::from_bits(x.bits)),
+            F64(x) => Value::F64(f64::from_bits(x.bits)),
+            V128(x) => Value::V128(u128::from_le_bytes(x.to_le_bytes())),
+            RefNull(HeapType::Abstract {
+                ty: AbstractHeapType::Func,
+                ..
+            }) => Value::FuncRef(None),
+            RefNull(HeapType::Abstract {
+                ty: AbstractHeapType::Extern,
+                ..
+            }) => Value::null(),
             RefExtern(number) => Value::ExternRef(Some(ExternRef::new(&mut self.store, *number))),
             other => bail!("couldn't convert {:?} to a runtime value", other),
         })
@@ -456,6 +527,17 @@ impl Wast {
             // handle `unknown memory $NUM` error messages that wasmparser doesn't return yet
             || (expected.contains("unknown memory") && actual.contains("unknown memory"))
             || (expected.contains("unknown memory") && actual.contains("Data segment extends past end of the data section"))
+            || (expected.contains("unknown elem segment") && actual.contains("unknown element segment"))
+            // The same test here is asserted to have one error message in
+            // `memory.wast` and a different error message in
+            // `memory64/memory.wast`, so we equate these two error messages to get
+            // the memory64 tests to pass.
+            || (expected.contains("memory size must be at most 65536 pages") && actual.contains("invalid u32 number"))
+            // the spec test suite asserts a different error message than we print
+            // for this scenario
+            || (expected == "unknown global" && actual.contains("global.get of locally defined global"))
+            || (expected == "immutable global" && actual.contains("global is immutable: cannot modify it with `global.set`"))
+            || (expected.contains("type mismatch: instruction requires") && actual.contains("instantiation failed with: Validation error: type mismatch: expected"))
     }
 
     // Checks if the `assert_trap` message matches the expected one
@@ -464,33 +546,48 @@ impl Wast {
             || self
                 .match_trap_messages
                 .get(expected)
-                .map_or(false, |alternative| actual.contains(alternative))
+                .is_some_and(|alternative| actual.contains(alternative))
+    }
+
+    fn assert_exception(&self, result: Result<Vec<Value>>) -> Result<()> {
+        if result.is_ok() {
+            anyhow::bail!("Expected exception to be thrown, returned {result:?} instead");
+        }
+        Ok(())
     }
 
-    fn val_matches(&self, actual: &Value, expected: &wast::AssertExpression) -> Result<bool> {
+    fn val_matches(&self, actual: &Value, expected: &WastRetCore) -> Result<bool> {
         Ok(match (actual, expected) {
-            (Value::I32(a), wast::AssertExpression::I32(b)) => a == b,
-            (Value::I64(a), wast::AssertExpression::I64(b)) => a == b,
+            (Value::I32(a), WastRetCore::I32(b)) => a == b,
+            (Value::I64(a), WastRetCore::I64(b)) => a == b,
             // Note that these float comparisons are comparing bits, not float
             // values, so we're testing for bit-for-bit equivalence
-            (Value::F32(a), wast::AssertExpression::F32(b)) => f32_matches(*a, b),
-            (Value::F64(a), wast::AssertExpression::F64(b)) => f64_matches(*a, b),
-            (Value::V128(a), wast::AssertExpression::V128(b)) => v128_matches(*a, b),
-            (Value::FuncRef(None), wast::AssertExpression::RefNull(Some(wast::HeapType::Func))) => {
-                true
-            }
-            (Value::FuncRef(Some(_)), wast::AssertExpression::RefNull(_)) => false,
-            (Value::FuncRef(None), wast::AssertExpression::RefFunc(None)) => true,
-            (Value::FuncRef(None), wast::AssertExpression::RefFunc(Some(_))) => false,
+            (Value::F32(a), WastRetCore::F32(b)) => f32_matches(*a, b),
+            (Value::F64(a), WastRetCore::F64(b)) => f64_matches(*a, b),
+            (Value::V128(a), WastRetCore::V128(b)) => v128_matches(*a, b),
+            (
+                Value::FuncRef(None),
+                WastRetCore::RefNull(Some(wast::core::HeapType::Abstract {
+                    ty: AbstractHeapType::Func,
+                    ..
+                })),
+            ) => true,
+            (Value::FuncRef(Some(_)), WastRetCore::RefNull(_)) => false,
+            (Value::FuncRef(None), WastRetCore::RefFunc(None)) => true,
+            (Value::FuncRef(None), WastRetCore::RefFunc(Some(_))) => false,
             (
                 Value::ExternRef(None),
-                wast::AssertExpression::RefNull(Some(wast::HeapType::Extern)),
+                WastRetCore::RefNull(Some(wast::core::HeapType::Abstract {
+                    ty: AbstractHeapType::Extern,
+                    ..
+                })),
             ) => true,
-            (Value::ExternRef(None), wast::AssertExpression::RefExtern(_)) => false,
-
-            (Value::ExternRef(Some(_)), wast::AssertExpression::RefNull(_)) => false,
-            (Value::ExternRef(Some(extern_ref)), wast::AssertExpression::RefExtern(num)) => {
-                extern_ref.downcast(&self.store) == Some(num)
+            (Value::ExternRef(None), WastRetCore::RefExtern(_)) => false,
+            (Value::ExceptionRef(None), WastRetCore::RefNull(_)) => true,
+            (Value::ExternRef(Some(_)), WastRetCore::RefNull(_)) => false,
+            (Value::ExternRef(Some(extern_ref)), WastRetCore::RefExtern(num)) => {
+                let x = extern_ref.downcast::<u32>(&self.store).cloned();
+                x == *num
             }
             _ => bail!(
                 "don't know how to compare {:?} and {:?} yet",
@@ -517,54 +614,54 @@ fn extract_lane_as_i64(bytes: u128, lane: usize) -> i64 {
     (bytes >> (lane * 64)) as i64
 }
 
-fn f32_matches(actual: f32, expected: &wast::NanPattern<wast::Float32>) -> bool {
+fn f32_matches(actual: f32, expected: &wast::core::NanPattern<F32>) -> bool {
     match expected {
-        wast::NanPattern::CanonicalNan => actual.is_canonical_nan(),
-        wast::NanPattern::ArithmeticNan => actual.is_arithmetic_nan(),
-        wast::NanPattern::Value(expected_value) => actual.to_bits() == expected_value.bits,
+        wast::core::NanPattern::CanonicalNan => actual.is_canonical_nan(),
+        wast::core::NanPattern::ArithmeticNan => actual.is_arithmetic_nan(),
+        wast::core::NanPattern::Value(expected_value) => actual.to_bits() == expected_value.bits,
     }
 }
 
-fn f64_matches(actual: f64, expected: &wast::NanPattern<wast::Float64>) -> bool {
+fn f64_matches(actual: f64, expected: &wast::core::NanPattern<F64>) -> bool {
     match expected {
-        wast::NanPattern::CanonicalNan => actual.is_canonical_nan(),
-        wast::NanPattern::ArithmeticNan => actual.is_arithmetic_nan(),
-        wast::NanPattern::Value(expected_value) => actual.to_bits() == expected_value.bits,
+        wast::core::NanPattern::CanonicalNan => actual.is_canonical_nan(),
+        wast::core::NanPattern::ArithmeticNan => actual.is_arithmetic_nan(),
+        wast::core::NanPattern::Value(expected_value) => actual.to_bits() == expected_value.bits,
     }
 }
 
-fn v128_matches(actual: u128, expected: &wast::V128Pattern) -> bool {
+fn v128_matches(actual: u128, expected: &wast::core::V128Pattern) -> bool {
     match expected {
-        wast::V128Pattern::I8x16(b) => b
+        wast::core::V128Pattern::I8x16(b) => b
             .iter()
             .enumerate()
             .all(|(i, b)| *b == extract_lane_as_i8(actual, i)),
-        wast::V128Pattern::I16x8(b) => b
+        wast::core::V128Pattern::I16x8(b) => b
             .iter()
             .enumerate()
             .all(|(i, b)| *b == extract_lane_as_i16(actual, i)),
-        wast::V128Pattern::I32x4(b) => b
+        wast::core::V128Pattern::I32x4(b) => b
             .iter()
             .enumerate()
             .all(|(i, b)| *b == extract_lane_as_i32(actual, i)),
-        wast::V128Pattern::I64x2(b) => b
+        wast::core::V128Pattern::I64x2(b) => b
             .iter()
             .enumerate()
             .all(|(i, b)| *b == extract_lane_as_i64(actual, i)),
-        wast::V128Pattern::F32x4(b) => b.iter().enumerate().all(|(i, b)| {
+        wast::core::V128Pattern::F32x4(b) => b.iter().enumerate().all(|(i, b)| {
             let a = extract_lane_as_i32(actual, i) as u32;
             f32_matches(f32::from_bits(a), b)
         }),
-        wast::V128Pattern::F64x2(b) => b.iter().enumerate().all(|(i, b)| {
+        wast::core::V128Pattern::F64x2(b) => b.iter().enumerate().all(|(i, b)| {
             let a = extract_lane_as_i64(actual, i) as u64;
             f64_matches(f64::from_bits(a), b)
         }),
     }
 }
 
-fn v128_format(actual: u128, expected: &wast::V128Pattern) -> wast::V128Pattern {
+fn v128_format(actual: u128, expected: &wast::core::V128Pattern) -> wast::core::V128Pattern {
     match expected {
-        wast::V128Pattern::I8x16(_) => wast::V128Pattern::I8x16([
+        wast::core::V128Pattern::I8x16(_) => wast::core::V128Pattern::I8x16([
             extract_lane_as_i8(actual, 0),
             extract_lane_as_i8(actual, 1),
             extract_lane_as_i8(actual, 2),
@@ -582,7 +679,7 @@ fn v128_format(actual: u128, expected: &wast::V128Pattern) -> wast::V128Pattern
             extract_lane_as_i8(actual, 14),
             extract_lane_as_i8(actual, 15),
         ]),
-        wast::V128Pattern::I16x8(_) => wast::V128Pattern::I16x8([
+        wast::core::V128Pattern::I16x8(_) => wast::core::V128Pattern::I16x8([
             extract_lane_as_i16(actual, 0),
             extract_lane_as_i16(actual, 1),
             extract_lane_as_i16(actual, 2),
@@ -592,35 +689,35 @@ fn v128_format(actual: u128, expected: &wast::V128Pattern) -> wast::V128Pattern
             extract_lane_as_i16(actual, 6),
             extract_lane_as_i16(actual, 7),
         ]),
-        wast::V128Pattern::I32x4(_) => wast::V128Pattern::I32x4([
+        wast::core::V128Pattern::I32x4(_) => wast::core::V128Pattern::I32x4([
             extract_lane_as_i32(actual, 0),
             extract_lane_as_i32(actual, 1),
             extract_lane_as_i32(actual, 2),
             extract_lane_as_i32(actual, 3),
         ]),
-        wast::V128Pattern::I64x2(_) => wast::V128Pattern::I64x2([
+        wast::core::V128Pattern::I64x2(_) => wast::core::V128Pattern::I64x2([
             extract_lane_as_i64(actual, 0),
             extract_lane_as_i64(actual, 1),
         ]),
-        wast::V128Pattern::F32x4(_) => wast::V128Pattern::F32x4([
-            wast::NanPattern::Value(wast::Float32 {
+        wast::core::V128Pattern::F32x4(_) => wast::core::V128Pattern::F32x4([
+            wast::core::NanPattern::Value(F32 {
                 bits: extract_lane_as_i32(actual, 0) as _,
             }),
-            wast::NanPattern::Value(wast::Float32 {
+            wast::core::NanPattern::Value(F32 {
                 bits: extract_lane_as_i32(actual, 1) as _,
             }),
-            wast::NanPattern::Value(wast::Float32 {
+            wast::core::NanPattern::Value(F32 {
                 bits: extract_lane_as_i32(actual, 2) as _,
             }),
-            wast::NanPattern::Value(wast::Float32 {
+            wast::core::NanPattern::Value(F32 {
                 bits: extract_lane_as_i32(actual, 3) as _,
             }),
         ]),
-        wast::V128Pattern::F64x2(_) => wast::V128Pattern::F64x2([
-            wast::NanPattern::Value(wast::Float64 {
+        wast::core::V128Pattern::F64x2(_) => wast::core::V128Pattern::F64x2([
+            wast::core::NanPattern::Value(F64 {
                 bits: extract_lane_as_i64(actual, 0) as _,
             }),
-            wast::NanPattern::Value(wast::Float64 {
+            wast::core::NanPattern::Value(F64 {
                 bits: extract_lane_as_i64(actual, 1) as _,
             }),
         ]),
diff --git a/tests/old-tar-gz/coreutils-1.0.11.tar.gz b/tests/old-tar-gz/coreutils-1.0.11.tar.gz
new file mode 100644
index 0000000000..a30ac16849
Binary files /dev/null and b/tests/old-tar-gz/coreutils-1.0.11.tar.gz differ
diff --git a/tests/old-tar-gz/cowsay-0.3.0.tar.gz b/tests/old-tar-gz/cowsay-0.3.0.tar.gz
new file mode 100644
index 0000000000..13f0f75e96
Binary files /dev/null and b/tests/old-tar-gz/cowsay-0.3.0.tar.gz differ
diff --git a/tests/rust-wasi-tests/src/bin/exit-0-from-main.rs b/tests/rust-wasi-tests/src/bin/exit-0-from-main.rs
new file mode 100644
index 0000000000..44490fa246
--- /dev/null
+++ b/tests/rust-wasi-tests/src/bin/exit-0-from-main.rs
@@ -0,0 +1,3 @@
+fn main() {
+    std::process::exit(0);
+}
diff --git a/tests/rust-wasi-tests/src/bin/exit-0-from-worker.rs b/tests/rust-wasi-tests/src/bin/exit-0-from-worker.rs
new file mode 100644
index 0000000000..fb5d491c2f
--- /dev/null
+++ b/tests/rust-wasi-tests/src/bin/exit-0-from-worker.rs
@@ -0,0 +1,3 @@
+fn main() {
+    std::thread::spawn(|| std::process::exit(0)).join().unwrap();
+}
diff --git a/tests/rust-wasi-tests/src/bin/exit-1-from-main.rs b/tests/rust-wasi-tests/src/bin/exit-1-from-main.rs
new file mode 100644
index 0000000000..081ca869c8
--- /dev/null
+++ b/tests/rust-wasi-tests/src/bin/exit-1-from-main.rs
@@ -0,0 +1,3 @@
+fn main() {
+    std::process::exit(1);
+}
diff --git a/tests/rust-wasi-tests/src/bin/exit-1-from-worker.rs b/tests/rust-wasi-tests/src/bin/exit-1-from-worker.rs
new file mode 100644
index 0000000000..b1cb0e5818
--- /dev/null
+++ b/tests/rust-wasi-tests/src/bin/exit-1-from-worker.rs
@@ -0,0 +1,3 @@
+fn main() {
+    std::thread::spawn(|| std::process::exit(1)).join().unwrap();
+}
diff --git a/tests/rust-wasi-tests/src/bin/mkdir-rename.rs b/tests/rust-wasi-tests/src/bin/mkdir-rename.rs
new file mode 100644
index 0000000000..9a20a4e2f0
--- /dev/null
+++ b/tests/rust-wasi-tests/src/bin/mkdir-rename.rs
@@ -0,0 +1,12 @@
+fn main() {
+    std::fs::create_dir("/a").unwrap();
+    assert!(std::fs::metadata("/a").unwrap().is_dir());
+
+    std::fs::rename("/a", "/b").unwrap();
+    assert!(matches!(std::fs::metadata("/a"), Err(e) if e.kind() == std::io::ErrorKind::NotFound));
+    assert!(std::fs::metadata("/b").unwrap().is_dir());
+
+    std::fs::create_dir("/a").unwrap();
+    assert!(std::fs::metadata("/a").unwrap().is_dir());
+    assert!(std::fs::metadata("/b").unwrap().is_dir());
+}
diff --git a/tests/rust-wasi-tests/src/bin/worker-panicking.rs b/tests/rust-wasi-tests/src/bin/worker-panicking.rs
new file mode 100644
index 0000000000..a3d50ce29a
--- /dev/null
+++ b/tests/rust-wasi-tests/src/bin/worker-panicking.rs
@@ -0,0 +1,11 @@
+fn main() {
+    std::thread::spawn(|| {
+        panic!("child thread panicking");
+    })
+    .join()
+    .unwrap();
+
+    println!("In main thread");
+
+    std::process::exit(0);
+}
diff --git a/tests/rust-wasi-tests/src/bin/worker-terminating-normally.rs b/tests/rust-wasi-tests/src/bin/worker-terminating-normally.rs
new file mode 100644
index 0000000000..d252f7b22d
--- /dev/null
+++ b/tests/rust-wasi-tests/src/bin/worker-terminating-normally.rs
@@ -0,0 +1,11 @@
+fn main() {
+    std::thread::spawn(|| {
+        println!("In child thread");
+    })
+    .join()
+    .unwrap();
+
+    println!("In main thread");
+
+    std::process::exit(0);
+}
diff --git a/tests/wasi-fyi/build.sh b/tests/wasi-fyi/build.sh
index d063bb0761..c677c41400 100755
--- a/tests/wasi-fyi/build.sh
+++ b/tests/wasi-fyi/build.sh
@@ -5,5 +5,5 @@ for input in *.rs; do
   output="$(basename $input .rs).wasm"
 
   echo "Compiling $input"
-  rustc +nightly --target=wasm32-wasi -o "$output" "$input"
+  rustc +nightly --target=wasm32-wasip1 -o "$output" "$input"
 done
diff --git a/tests/wasi-fyi/fd_seek_append.rs b/tests/wasi-fyi/fd_seek_append.rs
new file mode 100644
index 0000000000..d8babd5a5a
--- /dev/null
+++ b/tests/wasi-fyi/fd_seek_append.rs
@@ -0,0 +1,15 @@
+use std::io::{Seek as _, SeekFrom};
+
+fn main() {
+    let offset = 100u64;
+    let mut f = std::fs::OpenOptions::new()
+        .read(true)
+        .write(true)
+        .create(true)
+        .append(true)
+        .open("/fyi/fs_seek_append.dir/file")
+        .unwrap();
+    let new_offset = f.seek(SeekFrom::Start(offset)).unwrap();
+
+    assert_eq!(offset, new_offset);
+}
diff --git a/tests/wasi-fyi/fs_create_dir-non_existent.rs b/tests/wasi-fyi/fs_create_dir-non_existent.rs
new file mode 100644
index 0000000000..278c96909a
--- /dev/null
+++ b/tests/wasi-fyi/fs_create_dir-non_existent.rs
@@ -0,0 +1,5 @@
+use std::fs;
+
+fn main() {
+    assert!(fs::create_dir("/fyi/fs_create_dir-non_existent.dir/not-exist/new-directory").is_err());
+}
diff --git a/tests/wasi-fyi/fs_open_append_offset.rs b/tests/wasi-fyi/fs_open_append_offset.rs
new file mode 100644
index 0000000000..fef83616f5
--- /dev/null
+++ b/tests/wasi-fyi/fs_open_append_offset.rs
@@ -0,0 +1,31 @@
+use std::{
+    fs,
+    io::{Seek, SeekFrom, Write},
+};
+
+fn main() {
+    let file = "fyi/fs_open_append_offset.dir/file";
+    let mut f0 = fs::OpenOptions::new()
+        .create(true)
+        .truncate(true)
+        .write(true)
+        .open(file)
+        .unwrap();
+
+    f0.write_all(b"abc").unwrap();
+    f0.seek(SeekFrom::Start(1)).unwrap();
+
+    assert_eq!(fs::read_to_string(file).unwrap(), "abc");
+
+    // This open with append should not affect the offset of f0.
+    let _f1 = fs::OpenOptions::new()
+        .create(true)
+        .write(true)
+        .append(true)
+        .open(file)
+        .unwrap();
+
+    f0.write_all(b"d").unwrap();
+
+    assert_eq!(fs::read_to_string(file).unwrap(), "adc");
+}
diff --git a/tests/wasi-fyi/fs_seek_append_mode.rs b/tests/wasi-fyi/fs_seek_append_mode.rs
index 7e1d54321f..74bb0698c6 100644
--- a/tests/wasi-fyi/fs_seek_append_mode.rs
+++ b/tests/wasi-fyi/fs_seek_append_mode.rs
@@ -13,8 +13,9 @@ fn main() {
     // file offset must be 1 now
     write!(file, "{}", "a").unwrap();
 
-    // rewind should not work on file in append mode
-    // since the offset must always be at the end of the file
+    // rewind should not work on file in append mode.
+    // It changes the offset, which is immediately set to the end of the file
+    // with a write.
     let _ = file.rewind();
 
     // file offset must be 2 now
diff --git a/tests/wasi-fyi/ported_close_preopen_fd.stdout b/tests/wasi-fyi/ported_close_preopen_fd.stdout
index e6e9b9f673..97a106d510 100644
--- a/tests/wasi-fyi/ported_close_preopen_fd.stdout
+++ b/tests/wasi-fyi/ported_close_preopen_fd.stdout
@@ -1,3 +1,3 @@
 accessing preopen fd was a success
 Closing preopen fd was a success
-accessing closed preopen fd was an EBADF error: true
+accessing closed preopen fd was an EBADF error: false
diff --git a/tests/wasi-fyi/test_fs/fyi/fs_create_dir-non_existent.rs/.ignore b/tests/wasi-fyi/test_fs/fyi/fs_create_dir-non_existent.rs/.ignore
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/wasi-fyi/test_fs/fyi/fs_open_append_offset.dir/.gitignore b/tests/wasi-fyi/test_fs/fyi/fs_open_append_offset.dir/.gitignore
new file mode 100644
index 0000000000..f73f3093ff
--- /dev/null
+++ b/tests/wasi-fyi/test_fs/fyi/fs_open_append_offset.dir/.gitignore
@@ -0,0 +1 @@
+file
diff --git a/tests/wasi-fyi/test_fs/fyi/fs_seek_append.dir/file b/tests/wasi-fyi/test_fs/fyi/fs_seek_append.dir/file
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/wasi-wast/Cargo.toml b/tests/wasi-wast/Cargo.toml
index 9e7c0d20e5..48f8cc95a1 100644
--- a/tests/wasi-wast/Cargo.toml
+++ b/tests/wasi-wast/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "wasi-test-generator"
-version = "4.3.7"
+version = "6.1.0"
 description = "Tests for our WASI implementation"
 license = "MIT"
 authors = ["Wasmer Engineering Team <engineering@wasmer.io>"]
@@ -10,7 +10,7 @@ publish = false
 [dependencies]
 glob = "0.3"
 gumdrop = "0.8"
-tempfile = "3.6.0"
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"
-wast = "24.0"
+tempfile.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+wast = "216.0.0"
diff --git a/tests/wasi-wast/src/set_up_toolchain.rs b/tests/wasi-wast/src/set_up_toolchain.rs
index 4ff4da5deb..59dd833ee1 100644
--- a/tests/wasi-wast/src/set_up_toolchain.rs
+++ b/tests/wasi-wast/src/set_up_toolchain.rs
@@ -4,7 +4,7 @@ use super::wasi_version::*;
 use std::process::Command;
 
 fn install_toolchain(toolchain_name: &str) {
-    println!("Installing rustup toolchain: {}", toolchain_name);
+    println!("Installing rustup toolchain: {toolchain_name}");
     let rustup_out = Command::new("rustup")
         .arg("toolchain")
         .arg("install")
@@ -17,7 +17,7 @@ fn install_toolchain(toolchain_name: &str) {
     let rustup_out = Command::new("rustup")
         .arg("target")
         .arg("add")
-        .arg("wasm32-wasi")
+        .arg("wasm32-wasip1")
         .arg("--toolchain")
         .arg(toolchain_name)
         .output()
diff --git a/tests/wasi-wast/src/util.rs b/tests/wasi-wast/src/util.rs
index 7ce1e1c532..aedb95f746 100644
--- a/tests/wasi-wast/src/util.rs
+++ b/tests/wasi-wast/src/util.rs
@@ -1,6 +1,6 @@
 pub fn print_info_on_error(output: &std::process::Output, context: &str) {
     if !output.status.success() {
-        println!("{}", context);
+        println!("{context}");
         println!(
             "stdout:\n{}",
             std::str::from_utf8(&output.stdout[..]).unwrap()
diff --git a/tests/wasi-wast/src/wasitests.rs b/tests/wasi-wast/src/wasitests.rs
index d01d048c13..c13ed2e1c2 100644
--- a/tests/wasi-wast/src/wasitests.rs
+++ b/tests/wasi-wast/src/wasitests.rs
@@ -79,7 +79,7 @@ fn generate_native_output(
         .unwrap();
 
     if let Some(stdin_str) = &options.stdin {
-        write!(native_command.stdin.as_ref().unwrap(), "{}", stdin_str).unwrap();
+        write!(native_command.stdin.as_ref().unwrap(), "{stdin_str}").unwrap();
     }
 
     let result = native_command
@@ -100,8 +100,8 @@ fn generate_native_output(
     };
     if !result.success() {
         println!("NATIVE PROGRAM FAILED");
-        println!("stdout:\n{}", stdout_str);
-        eprintln!("stderr:\n{}", stderr_str);
+        println!("stdout:\n{stdout_str}");
+        eprintln!("stderr:\n{stderr_str}");
     }
 
     let result = result.code().unwrap() as i64;
@@ -131,7 +131,7 @@ fn compile_wasm_for_version(
         wasm_out_name.set_extension("wasm");
         wasm_out_name
     };
-    println!("Reading contents from file `{}`", file);
+    println!("Reading contents from file `{file}`");
     let file_contents: String = {
         let mut fc = String::new();
         let mut f = fs::OpenOptions::new().read(true).open(file)?;
@@ -139,7 +139,7 @@ fn compile_wasm_for_version(
         fc
     };
 
-    let temp_wasi_rs_file_name = temp_dir.join(format!("wasi_modified_version_{}.rs", rs_mod_name));
+    let temp_wasi_rs_file_name = temp_dir.join(format!("wasi_modified_version_{rs_mod_name}.rs"));
     {
         let mut actual_file = fs::OpenOptions::new()
             .write(true)
@@ -159,13 +159,13 @@ fn compile_wasm_for_version(
 
     command
         .arg(format!("+{}", version.get_compiler_toolchain()))
-        .arg("--target=wasm32-wasi")
+        .arg("--target=wasm32-wasip1")
         .arg("-C")
         .arg("opt-level=z")
         .arg(&temp_wasi_rs_file_name)
         .arg("-o")
         .arg(&wasm_out_name);
-    println!("Command {:?}", command);
+    println!("Command {command:?}");
 
     let wasm_compilation_out = command.output().expect("Failed to compile program to wasm");
     util::print_info_on_error(&wasm_compilation_out, "WASM COMPILATION");
@@ -214,7 +214,7 @@ fn compile(temp_dir: &Path, file: &str, wasi_versions: &[WasiVersion]) {
         .expect("Generate native output");
 
     let test = WasiTest {
-        wasm_prog_name: format!("{}.wasm", rs_mod_name),
+        wasm_prog_name: format!("{rs_mod_name}.wasm"),
         stdout,
         stderr,
         result,
@@ -238,7 +238,7 @@ fn compile(temp_dir: &Path, file: &str, wasi_versions: &[WasiVersion]) {
             println!("Writing test output to {}", wasm_out_name.to_string_lossy());
             fs::write(&wasm_out_name, test_serialized.clone()).unwrap();
 
-            println!("Compiling wasm version {:?}", version);
+            println!("Compiling wasm version {version:?}");
             compile_wasm_for_version(temp_dir, file, &out_dir, &rs_mod_name, version)
                 .unwrap_or_else(|_| panic!("Could not compile Wasm to WASI version {:?}, perhaps you need to install the `{}` rust toolchain", version, version.get_compiler_toolchain()));
         }).for_each(drop); // Do nothing with it, but let the iterator be consumed/iterated.
@@ -261,7 +261,7 @@ pub fn build(wasi_versions: &[WasiVersion], specific_tests: &[&str]) {
                     compile(temp_dir.path(), test, wasi_versions);
                 }
             }
-            Err(e) => println!("{:?}", e),
+            Err(e) => println!("{e:?}"),
         }
     }
     println!("All modules generated.");
@@ -296,20 +296,20 @@ impl WasiTest {
                 .options
                 .env
                 .iter()
-                .map(|(name, value)| format!("\"{}={}\"", name, value))
+                .map(|(name, value)| format!("\"{name}={value}\""))
                 .collect::<Vec<String>>()
                 .join(" ");
-            let _ = write!(out, "\n  (envs {})", envs);
+            let _ = write!(out, "\n  (envs {envs})");
         }
         if !self.options.args.is_empty() {
             let args = self
                 .options
                 .args
                 .iter()
-                .map(|v| format!("\"{}\"", v))
+                .map(|v| format!("\"{v}\""))
                 .collect::<Vec<String>>()
                 .join(" ");
-            let _ = write!(out, "\n  (args {})", args);
+            let _ = write!(out, "\n  (args {args})");
         }
 
         if !self.options.dir.is_empty() {
@@ -317,35 +317,35 @@ impl WasiTest {
                 .options
                 .dir
                 .iter()
-                .map(|v| format!("\"{}\"", v))
+                .map(|v| format!("\"{v}\""))
                 .collect::<Vec<String>>()
                 .join(" ");
-            let _ = write!(out, "\n  (preopens {})", preopens);
+            let _ = write!(out, "\n  (preopens {preopens})");
         }
         if !self.options.mapdir.is_empty() {
             let map_dirs = self
                 .options
                 .mapdir
                 .iter()
-                .map(|(a, b)| format!("\"{}:{}\"", a, b))
+                .map(|(a, b)| format!("\"{a}:{b}\""))
                 .collect::<Vec<String>>()
                 .join(" ");
-            let _ = write!(out, "\n  (map_dirs {})", map_dirs);
+            let _ = write!(out, "\n  (map_dirs {map_dirs})");
         }
         if !self.options.tempdir.is_empty() {
             let temp_dirs = self
                 .options
                 .tempdir
                 .iter()
-                .map(|td| format!("\"{}\"", td))
+                .map(|td| format!("\"{td}\""))
                 .collect::<Vec<String>>()
                 .join(" ");
-            let _ = write!(out, "\n  (temp_dirs {})", temp_dirs);
+            let _ = write!(out, "\n  (temp_dirs {temp_dirs})");
         }
 
         let _ = write!(out, "\n  (assert_return (i64.const {}))", self.result);
         if let Some(stdin) = &self.options.stdin {
-            let _ = write!(out, "\n  (stdin {:?})", stdin);
+            let _ = write!(out, "\n  (stdin {stdin:?})");
         }
 
         if !self.stdout.is_empty() {
@@ -407,14 +407,14 @@ fn extract_args_from_source_file(source_code: &str) -> Option<WasiOptions> {
                         // And then we try splitting by `:` (for compatibility with previous API)
                         args.mapdir.push((alias.to_string(), real_dir.to_string()));
                     } else {
-                        eprintln!("Parse error in mapdir {} not parsed correctly", value);
+                        eprintln!("Parse error in mapdir {value} not parsed correctly");
                     }
                 }
                 "env" => {
                     if let [name, val] = value.split('=').collect::<Vec<&str>>()[..] {
                         args.env.push((name.to_string(), val.to_string()));
                     } else {
-                        eprintln!("Parse error in env {} not parsed correctly", value);
+                        eprintln!("Parse error in env {value} not parsed correctly");
                     }
                 }
                 "dir" => {
@@ -437,7 +437,7 @@ fn extract_args_from_source_file(source_code: &str) -> Option<WasiOptions> {
                     args.stdin = Some(s.to_string());
                 }
                 e => {
-                    eprintln!("WARN: comment arg: `{}` is not supported", e);
+                    eprintln!("WARN: comment arg: `{e}` is not supported");
                 }
             }
         }
diff --git a/tests/wasi-wast/wasi/nightly_2022_10_18/close_preopen_fd.wast b/tests/wasi-wast/wasi/nightly_2022_10_18/close_preopen_fd.wast
index 65dda3b05c..0e52faba57 100644
--- a/tests/wasi-wast/wasi/nightly_2022_10_18/close_preopen_fd.wast
+++ b/tests/wasi-wast/wasi/nightly_2022_10_18/close_preopen_fd.wast
@@ -3,5 +3,5 @@
 (wasi_test "close_preopen_fd.wasm"
   (map_dirs "hamlet:test_fs/hamlet")
   (assert_return (i64.const 0))
-  (assert_stdout "accessing preopen fd was a success\nClosing preopen fd was a success\naccessing closed preopen fd was an EBADF error: true\n")
+  (assert_stdout "accessing preopen fd was a success\nClosing preopen fd was a success\naccessing closed preopen fd was an EBADF error: false\n")
 )
diff --git a/tests/wasi-wast/wasi/snapshot1/close_preopen_fd.wast b/tests/wasi-wast/wasi/snapshot1/close_preopen_fd.wast
index 65dda3b05c..0e52faba57 100644
--- a/tests/wasi-wast/wasi/snapshot1/close_preopen_fd.wast
+++ b/tests/wasi-wast/wasi/snapshot1/close_preopen_fd.wast
@@ -3,5 +3,5 @@
 (wasi_test "close_preopen_fd.wasm"
   (map_dirs "hamlet:test_fs/hamlet")
   (assert_return (i64.const 0))
-  (assert_stdout "accessing preopen fd was a success\nClosing preopen fd was a success\naccessing closed preopen fd was an EBADF error: true\n")
+  (assert_stdout "accessing preopen fd was a success\nClosing preopen fd was a success\naccessing closed preopen fd was an EBADF error: false\n")
 )
diff --git a/tests/wasi-wast/wasi/tests/inode.rs b/tests/wasi-wast/wasi/tests/inode.rs
index 1c2e00ac69..9b01c4fd76 100644
--- a/tests/wasi-wast/wasi/tests/inode.rs
+++ b/tests/wasi-wast/wasi/tests/inode.rs
@@ -7,7 +7,7 @@ use std::io;
 use std::os::wasi::fs::MetadataExt;
 
 // `test_fs` will be implicit.
-// this need experimentat MetadataExt
+// this need experimental MetadataExt
 // this program does nothing in native
 // it only tests things in wasi
 fn main() {
diff --git a/tests/wasi-wast/wasi/tests/path_rename.rs b/tests/wasi-wast/wasi/tests/path_rename.rs
index 87f985fa83..43b1c5fd00 100644
--- a/tests/wasi-wast/wasi/tests/path_rename.rs
+++ b/tests/wasi-wast/wasi/tests/path_rename.rs
@@ -48,7 +48,7 @@ fn run_with_toplevel_dir() {
         return;
     }
 
-    // TODO: add temp directory suport for native execution...
+    // TODO: add temp directory support for native execution...
     // until then, don't actually inspect the directory when running native code.
     #[cfg(target_os = "wasi")]
     for item in fs::read_dir(&base).unwrap() {
@@ -128,7 +128,7 @@ fn run_with_toplevel_dir_overwrite() {
         return;
     }
 
-    // TODO: add temp directory suport for native execution...
+    // TODO: add temp directory support for native execution...
     // until then, don't actually inspect the directory when running native code.
     #[cfg(target_os = "wasi")]
     for item in fs::read_dir(&base).unwrap() {
diff --git a/tests/wasi-wast/wasi/unstable/close_preopen_fd.wast b/tests/wasi-wast/wasi/unstable/close_preopen_fd.wast
index 65dda3b05c..0e52faba57 100644
--- a/tests/wasi-wast/wasi/unstable/close_preopen_fd.wast
+++ b/tests/wasi-wast/wasi/unstable/close_preopen_fd.wast
@@ -3,5 +3,5 @@
 (wasi_test "close_preopen_fd.wasm"
   (map_dirs "hamlet:test_fs/hamlet")
   (assert_return (i64.const 0))
-  (assert_stdout "accessing preopen fd was a success\nClosing preopen fd was a success\naccessing closed preopen fd was an EBADF error: true\n")
+  (assert_stdout "accessing preopen fd was a success\nClosing preopen fd was a success\naccessing closed preopen fd was an EBADF error: false\n")
 )
diff --git a/tests/wasix/.gitignore b/tests/wasix/.gitignore
index 61b5cdac58..6bcd63e700 100644
--- a/tests/wasix/.gitignore
+++ b/tests/wasix/.gitignore
@@ -1,3 +1,4 @@
 output*
 *.webc
-*.wasm
\ No newline at end of file
+*.wasm
+*.so
\ No newline at end of file
diff --git a/tests/wasix/cloexec/main.c b/tests/wasix/cloexec/main.c
new file mode 100644
index 0000000000..cacaa0a358
--- /dev/null
+++ b/tests/wasix/cloexec/main.c
@@ -0,0 +1,196 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/wait.h>
+
+int expect_cloexec_flag(int fd, int expected)
+{
+    int flags = fcntl(fd, F_GETFD);
+    if (flags == -1)
+    {
+        perror("fcntl in expect_cloexec_flag");
+        return -1;
+    }
+
+    if ((flags & FD_CLOEXEC) != expected)
+    {
+        printf("Expected FD_CLOEXEC to be %d, but got %d\n", expected, flags & FD_CLOEXEC);
+        return -1;
+    }
+
+    return 0;
+}
+
+int flag_tests()
+{
+    int fd = open("/bin/file", O_RDONLY | O_CREAT);
+    // WASIX preopens FDs 0 through 5, so fd should be 6
+    if (fd != 6)
+    {
+        perror("open");
+        return -1;
+    }
+
+    int fd2 = fcntl(fd, F_DUPFD, 4);
+    if (fd2 != 7)
+    {
+        perror("fcntl");
+        return -1;
+    }
+
+    int fd3 = fcntl(fd, F_DUPFD_CLOEXEC, 10);
+    if (fd3 != 10)
+    {
+        perror("fctnl 2");
+        return -1;
+    }
+
+    if (expect_cloexec_flag(fd, 0) != 0)
+    {
+        return -1;
+    }
+
+    if (expect_cloexec_flag(fd2, 0) != 0)
+    {
+        return -1;
+    }
+
+    if (expect_cloexec_flag(fd3, FD_CLOEXEC) != 0)
+    {
+        return -1;
+    }
+
+    if (fcntl(fd, F_SETFD, FD_CLOEXEC) != 0)
+    {
+        perror("fcntl 3");
+        return -1;
+    }
+
+    if (expect_cloexec_flag(fd, FD_CLOEXEC) != 0)
+    {
+        return -1;
+    }
+
+    int fd4 = open("/bin/file2", O_RDONLY | O_CREAT | O_CLOEXEC);
+    if (expect_cloexec_flag(fd4, FD_CLOEXEC) != 0)
+    {
+        return -1;
+    }
+
+    return 0;
+}
+
+int exec_tests()
+{
+    int fd = open("/bin/file", O_RDONLY | O_CREAT | O_CLOEXEC);
+    if (fd != 6)
+    {
+        perror("open");
+        return -1;
+    }
+
+    int fd2 = fcntl(fd, F_DUPFD, 0);
+    if (fd2 != 7)
+    {
+        perror("fcntl");
+        return -1;
+    }
+
+    int pid = fork();
+
+    if (pid == -1)
+    {
+        perror("fork");
+        return -1;
+    }
+    else if (pid == 0)
+    {
+        execle("./main.wasm", "main.wasm", "exec_subprocess", NULL);
+        perror("execle");
+        return -1;
+    }
+    else
+    {
+        int status;
+        if (waitpid(pid, &status, 0) < 0)
+        {
+            perror("waitpid");
+            return -1;
+        }
+
+        if (WIFEXITED(status) && WEXITSTATUS(status) != 0)
+        {
+            printf("Bad status from child process: %d\n", WEXITSTATUS(status));
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+// Since we don't pipe stderr from the child process, this function writes
+// output to a file which can (hopefully!) be inspected
+void write_subprocess_error(const char *msg)
+{
+    FILE *outf = fopen("./output.child", "w");
+    if (!outf)
+    {
+        exit(EXIT_FAILURE);
+    }
+    fprintf(outf, "%s: %s\n", msg, strerror(errno));
+    fclose(outf);
+}
+
+int exec_subprocess()
+{
+    int flags = fcntl(6, F_GETFD);
+    if (flags != -1 || errno != EBADF)
+    {
+        write_subprocess_error("Expected EBADF for fd 6");
+        return 2;
+    }
+
+    flags = fcntl(7, F_GETFD);
+    if (flags == -1)
+    {
+        write_subprocess_error("Error from fcntl in subprocess");
+        return 3;
+    }
+
+    if ((flags & FD_CLOEXEC) != 0)
+    {
+        write_subprocess_error("Expected FD_CLOEXEC to be 0 for fd 7");
+        return 4;
+    }
+
+    return 0;
+}
+
+int main(int argc, char **argv)
+{
+    if (argc < 2)
+    {
+        return -1;
+    }
+
+    if (!strcmp(argv[1], "flag_tests"))
+    {
+        return flag_tests();
+    }
+    else if (!strcmp(argv[1], "exec_tests"))
+    {
+        return exec_tests();
+    }
+    else if (!strcmp(argv[1], "exec_subprocess"))
+    {
+        return exec_subprocess();
+    }
+    else
+    {
+        return -1;
+    }
+}
diff --git a/tests/wasix/cloexec/run.sh b/tests/wasix/cloexec/run.sh
new file mode 100755
index 0000000000..58509c4a6b
--- /dev/null
+++ b/tests/wasix/cloexec/run.sh
@@ -0,0 +1,7 @@
+set -e
+
+# step 1: tests involving the flag itself
+$WASMER -q run main.wasm -- flag_tests
+
+# step 2: tests involving exec
+$WASMER -q run main.wasm --dir . -- exec_tests
diff --git a/tests/wasix/closing-pre-opened-dirs/main.c b/tests/wasix/closing-pre-opened-dirs/main.c
new file mode 100644
index 0000000000..89f084ecd8
--- /dev/null
+++ b/tests/wasix/closing-pre-opened-dirs/main.c
@@ -0,0 +1,82 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <dirent.h>
+#include <unistd.h>
+#include <string.h>
+#include <assert.h>
+
+typedef unsigned char bool;
+#define false (0)
+#define true (1)
+
+int main()
+{
+    const size_t expected_count = 6;
+    const char *expected_entries[] = {".", "..", "main.c", "main.wasm", "output", "run.sh"};
+    bool entries_observed[6] = {false};
+
+    for (int fd = 3; fd <= 5; fd++)
+    {
+        close(fd);
+    }
+
+    DIR *dir = opendir(".");
+    if (!dir)
+    {
+        printf("opendir");
+        exit(EXIT_FAILURE);
+    }
+
+    struct dirent *entry;
+    size_t total_count = 0;
+    while ((entry = readdir(dir)) != NULL)
+    {
+        bool found = false;
+
+        for (int i = 0; i < expected_count; ++i)
+        {
+            if (strcmp(expected_entries[i], entry->d_name) == 0 && entries_observed[i] == false)
+            {
+                entries_observed[i] = true;
+                found = true;
+                break;
+            }
+        }
+
+        if (!found)
+        {
+            printf("Expected file name: %s\n", entry->d_name);
+        }
+
+        total_count++;
+    }
+
+    for (int i = 0; i < expected_count; ++i)
+    {
+        if (!entries_observed[i])
+        {
+            printf("Unobserved entry: %s\n", expected_entries[i]);
+            exit(EXIT_FAILURE);
+        }
+    }
+
+    if (total_count != expected_count)
+    {
+        printf("Mismatch in number of entries\n");
+        exit(EXIT_FAILURE);
+    }
+
+    closedir(dir);
+
+    printf("0");
+
+    // Use fclose instead of close to make sure the write above is flushed
+    fclose(stdin);
+    fclose(stdout);
+    fclose(stderr);
+
+    // If this prints, it'll be caught in the output diff and fail the test.
+    printf("Expected stdout to be closed\n");
+
+    return 0;
+}
diff --git a/tests/wasix/closing-pre-opened-dirs/run.sh b/tests/wasix/closing-pre-opened-dirs/run.sh
new file mode 100755
index 0000000000..2ff4435b54
--- /dev/null
+++ b/tests/wasix/closing-pre-opened-dirs/run.sh
@@ -0,0 +1,5 @@
+rm output
+
+$WASMER -q run main.wasm --dir . > output
+
+printf "0" | diff -u output - 1>/dev/null
diff --git a/tests/wasix/create-and-remove-dirs/main.c b/tests/wasix/create-and-remove-dirs/main.c
new file mode 100644
index 0000000000..a7371e31a1
--- /dev/null
+++ b/tests/wasix/create-and-remove-dirs/main.c
@@ -0,0 +1,99 @@
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+int ensure_dir_accessible(const char *dir_name)
+{
+    struct stat st;
+    char buf[256];
+
+    if (stat(dir_name, &st) != 0 || !S_ISDIR(st.st_mode))
+    {
+        return -1;
+    }
+
+    sprintf(buf, "./%s", dir_name);
+    if (stat(buf, &st) != 0 || !S_ISDIR(st.st_mode))
+    {
+        return -1;
+    }
+
+    sprintf(buf, "/home/%s", dir_name);
+    if (stat(buf, &st) != 0 || !S_ISDIR(st.st_mode))
+    {
+        return -1;
+    }
+
+    return 0;
+}
+
+int ensure_dir_removed(const char *dir_name)
+{
+    struct stat st;
+
+    if (stat(dir_name, &st) == 0 || errno != ENOENT)
+    {
+        return -1;
+    }
+
+    errno = 0;
+    return 0;
+}
+
+void error(const char *message)
+{
+    perror(message);
+    exit(-1);
+}
+
+int main()
+{
+    if (mkdir("test1/test2", S_IRWXU | S_IRWXG | S_IRWXO) == 0)
+    {
+        printf("Expected recursive directory creation to fail\n");
+        return -1;
+    }
+
+    if (mkdir("test1", S_IRWXU | S_IRWXG | S_IRWXO) != 0 || ensure_dir_accessible("test1") != 0)
+    {
+        error("mkdir test1");
+    }
+
+    if (mkdir("test1/test2", S_IRWXU | S_IRWXG | S_IRWXO) != 0 || ensure_dir_accessible("test1/test2") != 0)
+    {
+        error("mkdir test2");
+    }
+
+    if (rmdir("test1") == 0)
+    {
+        printf("Expected removing non-empty directory to fail\n");
+        return -1;
+    }
+
+    if (rmdir("test1/test2") != 0 || ensure_dir_removed("test1/test2") != 0)
+    {
+        error("rmdir test2");
+    }
+
+    if (rmdir("test1") != 0 || ensure_dir_removed("test1") != 0)
+    {
+        error("rmdir test1");
+    }
+
+    if (mkdir("test1", S_IRWXU | S_IRWXG | S_IRWXO) != 0 || ensure_dir_accessible("test1") != 0)
+    {
+        error("re-create test1");
+    }
+
+    if (rmdir("test1") != 0 || ensure_dir_removed("test1") != 0)
+    {
+        error("re-remove test1");
+    }
+
+    printf("0");
+    return 0;
+}
diff --git a/tests/wasix/create-and-remove-dirs/run.sh b/tests/wasix/create-and-remove-dirs/run.sh
new file mode 100755
index 0000000000..12e547d274
--- /dev/null
+++ b/tests/wasix/create-and-remove-dirs/run.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+$WASMER -q run main.wasm --dir . > output
+
+rm -rf test1 2>/dev/null && printf "0" | diff -u output - 1>/dev/null
diff --git a/tests/wasix/create-dir-at-cwd-with-chdir/main.c b/tests/wasix/create-dir-at-cwd-with-chdir/main.c
new file mode 100644
index 0000000000..e91f2fbafa
--- /dev/null
+++ b/tests/wasix/create-dir-at-cwd-with-chdir/main.c
@@ -0,0 +1,78 @@
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+// the difference between this test and the one in create-dir-at-cwd is the
+// presence of chdir.
+
+// this will force chdir to be linked with this binary which in turn will change
+// the behavior of rel_path logic in some versions of wasix-libc.
+//
+// for more info see: libc-find-relpath.h in wasix-libc
+int (*dummy_chdir_ref)(const char *path) = chdir;
+
+int ensure_dir_accessible(const char *dir_name)
+{
+    struct stat st;
+    char buf[256];
+
+    if (stat(dir_name, &st) != 0 || !S_ISDIR(st.st_mode))
+    {
+        return -1;
+    }
+
+    sprintf(buf, "./%s", dir_name);
+    if (stat(buf, &st) != 0 || !S_ISDIR(st.st_mode))
+    {
+        return -1;
+    }
+
+    sprintf(buf, "/home/%s", dir_name);
+    if (stat(buf, &st) != 0 || !S_ISDIR(st.st_mode))
+    {
+        return -1;
+    }
+
+    return 0;
+}
+
+void error(const char *message)
+{
+    perror(message);
+    exit(-1);
+}
+
+int main()
+{
+    if (mkdir("test1", S_IRWXU | S_IRWXG | S_IRWXO) != 0 || ensure_dir_accessible("test1") != 0)
+    {
+        error("test1");
+    }
+
+    if (mkdir("./test2", S_IRWXU | S_IRWXG | S_IRWXO) != 0 || ensure_dir_accessible("test2") != 0)
+    {
+        error("test2");
+    }
+
+    int cwd_fd = open(".", O_RDONLY | O_DIRECTORY);
+    if (cwd_fd < 0)
+    {
+        error("open cwd");
+    }
+
+    if (mkdirat(cwd_fd, "test3", S_IRWXU | S_IRWXG | S_IRWXO) != 0 || ensure_dir_accessible("test3") != 0)
+    {
+        error("test3");
+    }
+
+    if (mkdirat(cwd_fd, "./test4", S_IRWXU | S_IRWXG | S_IRWXO) != 0 || ensure_dir_accessible("test4") != 0)
+    {
+        error("test4");
+    }
+
+    printf("0");
+    return 0;
+}
diff --git a/tests/wasix/create-dir-at-cwd-with-chdir/run.sh b/tests/wasix/create-dir-at-cwd-with-chdir/run.sh
new file mode 100755
index 0000000000..eb6e280047
--- /dev/null
+++ b/tests/wasix/create-dir-at-cwd-with-chdir/run.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+$WASMER -q run main.wasm --dir . > output
+
+rmdir test1 test2 test3 test4 2>/dev/null && printf "0" | diff -u output - 1>/dev/null
diff --git a/tests/wasix/create-dir-at-cwd/main.c b/tests/wasix/create-dir-at-cwd/main.c
new file mode 100644
index 0000000000..eba61784af
--- /dev/null
+++ b/tests/wasix/create-dir-at-cwd/main.c
@@ -0,0 +1,68 @@
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+int ensure_dir_accessible(const char *dir_name)
+{
+    struct stat st;
+    char buf[256];
+
+    if (stat(dir_name, &st) != 0 || !S_ISDIR(st.st_mode))
+    {
+        return -1;
+    }
+
+    sprintf(buf, "./%s", dir_name);
+    if (stat(buf, &st) != 0 || !S_ISDIR(st.st_mode))
+    {
+        return -1;
+    }
+
+    sprintf(buf, "/home/%s", dir_name);
+    if (stat(buf, &st) != 0 || !S_ISDIR(st.st_mode))
+    {
+        return -1;
+    }
+
+    return 0;
+}
+
+void error(const char *message)
+{
+    perror(message);
+    exit(-1);
+}
+
+int main()
+{
+    if (mkdir("test1", S_IRWXU | S_IRWXG | S_IRWXO) != 0 || ensure_dir_accessible("test1") != 0)
+    {
+        error("test1");
+    }
+
+    if (mkdir("./test2", S_IRWXU | S_IRWXG | S_IRWXO) != 0 || ensure_dir_accessible("test2") != 0)
+    {
+        error("test2");
+    }
+
+    int cwd_fd = open(".", O_RDONLY | O_DIRECTORY);
+    if (cwd_fd < 0)
+    {
+        error("open cwd");
+    }
+
+    if (mkdirat(cwd_fd, "test3", S_IRWXU | S_IRWXG | S_IRWXO) != 0 || ensure_dir_accessible("test3") != 0)
+    {
+        error("test3");
+    }
+
+    if (mkdirat(cwd_fd, "./test4", S_IRWXU | S_IRWXG | S_IRWXO) != 0 || ensure_dir_accessible("test4") != 0)
+    {
+        error("test4");
+    }
+
+    printf("0");
+    return 0;
+}
diff --git a/tests/wasix/create-dir-at-cwd/run.sh b/tests/wasix/create-dir-at-cwd/run.sh
new file mode 100755
index 0000000000..eb6e280047
--- /dev/null
+++ b/tests/wasix/create-dir-at-cwd/run.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+$WASMER -q run main.wasm --dir . > output
+
+rmdir test1 test2 test3 test4 2>/dev/null && printf "0" | diff -u output - 1>/dev/null
diff --git a/tests/wasix/create-move-open/main.c b/tests/wasix/create-move-open/main.c
new file mode 100644
index 0000000000..12d3c8da83
--- /dev/null
+++ b/tests/wasix/create-move-open/main.c
@@ -0,0 +1,71 @@
+// There used to be an issue where, when moving a file, you could no longer
+// open it afterwards. This is a regression test for that issue.
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+void error(const char *message)
+{
+    perror(message);
+    exit(-1);
+}
+
+int main()
+{
+    // Create two directories
+    if (mkdir("test1", S_IRWXU))
+    {
+        error("mkdir test1");
+    }
+    if (mkdir("test1/inner", S_IRWXU))
+    {
+        error("mkdir t2");
+    }
+
+    FILE *file;
+    if (!(file = fopen("test1/inner/file", "wt")))
+    {
+        error("create file");
+    }
+    if (!fwrite("hello\n", 1, 6, file))
+    {
+        error("write to file");
+    }
+    if (fflush(file))
+    {
+        error("fflush");
+    }
+    if (fclose(file))
+    {
+        error("fclose");
+    }
+
+    if (rename("test1", "test2"))
+    {
+        error("rename");
+    }
+
+    if (!(file = fopen("test2/inner/file", "rt")))
+    {
+        error("open renamed file");
+    }
+    char buf[7] = {0};
+    if (!fread((void *)buf, 1, 7, file))
+    {
+        error("fread");
+    }
+    if (strcmp(buf, "hello\n"))
+    {
+        printf("Invalid file contents: %s\n", buf);
+        return -1;
+    }
+
+    printf("0");
+    return 0;
+}
diff --git a/tests/wasix/create-move-open/run.sh b/tests/wasix/create-move-open/run.sh
new file mode 100755
index 0000000000..8b18c8e348
--- /dev/null
+++ b/tests/wasix/create-move-open/run.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+$WASMER -q run main.wasm --dir . > output
+
+rm -rf test1 test2 2>/dev/null && printf "0" | diff -u output - 1>/dev/null
diff --git a/tests/wasix/cross-fs-rename/main.c b/tests/wasix/cross-fs-rename/main.c
new file mode 100644
index 0000000000..31f01f52ff
--- /dev/null
+++ b/tests/wasix/cross-fs-rename/main.c
@@ -0,0 +1,89 @@
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+
+void error_exit(const char *desc, const char *call)
+{
+    const char *err_desc = strerror(errno);
+    printf("Test \"%s\" failed at %s: %s\n", desc, call, err_desc);
+    // Make it visible in the output log as well
+    fprintf(stderr, "Test \"%s\" failed at %s: %s\n", desc, call, err_desc);
+    exit(-1);
+}
+
+void create_and_move_file(const char *from_path, const char *to_path)
+{
+    char test_description[1024] = {0};
+    sprintf(test_description, "%s -> %s", from_path, to_path);
+
+    FILE *f = fopen(from_path, "wb");
+    if (!f)
+    {
+        error_exit(test_description, "fopen");
+    }
+
+    char *txt = "hello";
+    if (!fwrite(txt, 1, 6, f))
+    {
+        error_exit(test_description, "fwrite");
+    }
+
+    if (fclose(f))
+    {
+        error_exit(test_description, "fclose");
+    }
+
+    // /home is a host FS mount
+    if (rename(from_path, to_path))
+    {
+        error_exit(test_description, "rename");
+    }
+
+    f = fopen(to_path, "rb");
+    if (!f)
+    {
+        error_exit(test_description, "fopen 2");
+    }
+
+    char buffer[7] = {0};
+    if (!fread(buffer, 1, 7, f))
+    {
+        error_exit(test_description, "fread");
+    }
+
+    if (strcmp(buffer, txt))
+    {
+        fprintf(stderr, "Expected %s to be equal to %s", buffer, txt);
+        exit(-1);
+    }
+
+    if (fclose(f))
+    {
+        error_exit(test_description, "fclose 2");
+    }
+}
+
+int main()
+{
+    // /tmp is on the MemFS, /temp1 and /temp2 are on separate HostFS instances
+
+    // Move file within MemFS
+    create_and_move_file("/tmp/old", "/tmp/new");
+
+    // Move file within single mounted FS
+    create_and_move_file("/temp1/old", "/temp1/new");
+
+    // Move file from MemFS to mounted FS
+    create_and_move_file("/tmp/file", "/temp1/file");
+
+    // Move file from mounted FS to MemFS
+    create_and_move_file("/temp1/file2", "/tmp/file2");
+
+    // Move file between different mounted FS's
+    create_and_move_file("/temp1/file3", "/temp2/file3");
+
+    printf("0");
+    return 0;
+}
diff --git a/tests/wasix/cross-fs-rename/run.sh b/tests/wasix/cross-fs-rename/run.sh
new file mode 100755
index 0000000000..cc783761c4
--- /dev/null
+++ b/tests/wasix/cross-fs-rename/run.sh
@@ -0,0 +1,6 @@
+TEMP_DIR1=$(mktemp -d)
+TEMP_DIR2=$(mktemp -d)
+
+$WASMER -q run main.wasm --mapdir /temp1:$TEMP_DIR1 --mapdir /temp2:$TEMP_DIR2 > output
+
+printf "0" | diff -u output - 1>/dev/null
diff --git a/tests/wasix/dl-cache/.no-build b/tests/wasix/dl-cache/.no-build
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/wasix/dl-cache/main.c b/tests/wasix/dl-cache/main.c
new file mode 100644
index 0000000000..dd653a12ef
--- /dev/null
+++ b/tests/wasix/dl-cache/main.c
@@ -0,0 +1,68 @@
+#include <stdio.h>
+#include <dlfcn.h>
+
+int main()
+{
+    void *handle1 = dlopen("./libside1.so", RTLD_NOW | RTLD_GLOBAL);
+    if (!handle1)
+    {
+        fprintf(stderr, "dlopen failed: %s\n", dlerror());
+        return 1;
+    }
+
+    int (*side_func1)(int) = dlsym(handle1, "side_func");
+    if (!side_func1)
+    {
+        fprintf(stderr, "dlsym failed: %s\n", dlerror());
+        dlclose(handle1);
+        return 1;
+    }
+
+    // side_func1 returns x + 42
+    int res = side_func1(2);
+    if (res != 44)
+    {
+        fprintf(stderr, "side_func returned unexpected value: %d\n", res);
+        dlclose(handle1);
+        return 1;
+    }
+
+    void *handle2 = dlopen("./libside2.so", RTLD_NOW | RTLD_GLOBAL);
+    if (!handle2)
+    {
+        fprintf(stderr, "dlopen failed: %s\n", dlerror());
+        return 1;
+    }
+
+    int (*side_func2)(int) = dlsym(handle2, "side_func");
+    if (!side_func2)
+    {
+        fprintf(stderr, "dlsym failed: %s\n", dlerror());
+        dlclose(handle1);
+        dlclose(handle2);
+        return 1;
+    }
+
+    if (side_func1 == side_func2)
+    {
+        fprintf(stderr, "side_func1 and side_func2 should be different\n");
+        dlclose(handle1);
+        dlclose(handle2);
+        return 1;
+    }
+
+    // side_func2 returns x * 2
+    res = side_func2(2);
+    if (res != 4)
+    {
+        fprintf(stderr, "side_func returned unexpected value: %d\n", res);
+        dlclose(handle1);
+        dlclose(handle2);
+        return 1;
+    }
+
+    dlclose(handle1);
+    dlclose(handle2);
+
+    return 0;
+}
\ No newline at end of file
diff --git a/tests/wasix/dl-cache/run.sh b/tests/wasix/dl-cache/run.sh
new file mode 100755
index 0000000000..10620b3e37
--- /dev/null
+++ b/tests/wasix/dl-cache/run.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+
+set -e
+
+export WASIXCC_WASM_EXCEPTIONS=yes
+export WASIXCC_PIC=yes
+
+wasixcc main.c -o main.wasm -Wl,-pie
+wasixcc side1.c -o libside1.so -Wl,-shared
+wasixcc side2.c -o libside2.so -Wl,-shared
+
+$WASMER -q run main.wasm --dir=.
\ No newline at end of file
diff --git a/tests/wasix/dl-cache/side1.c b/tests/wasix/dl-cache/side1.c
new file mode 100644
index 0000000000..c3d8896293
--- /dev/null
+++ b/tests/wasix/dl-cache/side1.c
@@ -0,0 +1,6 @@
+extern int side_needed_func(int);
+
+int side_func(int x)
+{
+    return x + 42;
+}
\ No newline at end of file
diff --git a/tests/wasix/dl-cache/side2.c b/tests/wasix/dl-cache/side2.c
new file mode 100644
index 0000000000..bcab02e41c
--- /dev/null
+++ b/tests/wasix/dl-cache/side2.c
@@ -0,0 +1,6 @@
+extern int side_needed_func(int);
+
+int side_func(int x)
+{
+    return x * 2;
+}
\ No newline at end of file
diff --git a/tests/wasix/dl-needed/.no-build b/tests/wasix/dl-needed/.no-build
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/wasix/dl-needed/main-needed.c b/tests/wasix/dl-needed/main-needed.c
new file mode 100644
index 0000000000..2b75043c06
--- /dev/null
+++ b/tests/wasix/dl-needed/main-needed.c
@@ -0,0 +1,4 @@
+int main_needed_func(int x)
+{
+    return x + 1;
+}
\ No newline at end of file
diff --git a/tests/wasix/dl-needed/main.c b/tests/wasix/dl-needed/main.c
new file mode 100644
index 0000000000..c8cc8d51ef
--- /dev/null
+++ b/tests/wasix/dl-needed/main.c
@@ -0,0 +1,76 @@
+#include <stdio.h>
+#include <dlfcn.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <signal.h>
+
+extern int main_needed_func(int);
+
+int main_exported()
+{
+    return 85;
+}
+
+// We need a live worker thread so the DlOperation sync logic runs.
+// The thread doesn't need to do anything.
+void *thread_func(void *arg)
+{
+    for (;;)
+    {
+        sleep(1);
+    }
+}
+
+int main()
+{
+    pthread_t thread;
+    if (pthread_create(&thread, NULL, thread_func, NULL) != 0)
+    {
+        fprintf(stderr, "Failed to create thread\n");
+        return 1;
+    }
+
+    if (main_needed_func(42) != 43)
+    {
+        fprintf(stderr, "main_needed_func returned unexpected value\n");
+        return 1;
+    }
+
+    void *handle = dlopen("./libside.so", RTLD_NOW | RTLD_GLOBAL);
+    if (!handle)
+    {
+        fprintf(stderr, "dlopen failed: %s\n", dlerror());
+        return 1;
+    }
+
+    int (*side_func)(int) = dlsym(handle, "side_func");
+    if (!side_func)
+    {
+        fprintf(stderr, "dlsym failed: %s\n", dlerror());
+        dlclose(handle);
+        return 1;
+    }
+
+    // side_func returns (x + 4) * 2
+    int res = side_func(42);
+    if (res != 92)
+    {
+        fprintf(stderr, "side_func returned unexpected value: %d\n", res);
+        dlclose(handle);
+        return 1;
+    }
+
+    if (dlclose(handle) != 0)
+    {
+        fprintf(stderr, "dlclose failed: %s\n", dlerror());
+        return 1;
+    }
+
+    pthread_kill(thread, SIGTERM);
+
+    // Print something to make sure printf and, by extension, data relocations work.
+    // Do *NOT* remote this.
+    printf("All tests passed successfully!\n");
+
+    return 0;
+}
\ No newline at end of file
diff --git a/tests/wasix/dl-needed/run.sh b/tests/wasix/dl-needed/run.sh
new file mode 100755
index 0000000000..c397e92e44
--- /dev/null
+++ b/tests/wasix/dl-needed/run.sh
@@ -0,0 +1,16 @@
+#!/bin/bash
+
+set -e
+
+export WASIXCC_WASM_EXCEPTIONS=yes
+export WASIXCC_PIC=yes
+
+# main module and its needed side
+wasixcc main-needed.c -o libmain-needed.so -Wl,-shared
+wasixcc main.c libmain-needed.so -o main.wasm -Wl,-pie -Wl,-rpath,\$ORIGIN
+
+# dlopen'ed side module and its needed side
+wasixcc side-needed.c -o libside-needed.so -Wl,-shared
+wasixcc side.c libside-needed.so -o libside.so -Wl,-shared -Wl,-rpath,\$ORIGIN
+
+$WASMER -q run main.wasm --dir=.
\ No newline at end of file
diff --git a/tests/wasix/dl-needed/side-needed.c b/tests/wasix/dl-needed/side-needed.c
new file mode 100644
index 0000000000..69dee947a8
--- /dev/null
+++ b/tests/wasix/dl-needed/side-needed.c
@@ -0,0 +1,27 @@
+#include <stdio.h>
+
+// This generates a GOT.func entry that gets resolved between
+// loading this module and side.c, which caused an error in the past.
+extern int main_exported();
+int (*main_exported_ptr)() = main_exported;
+
+int side_needed_func(int x)
+{
+    // We need a function pointer internal to the module to give the module
+    // its own internal table space; this will trigger the GOT.func issue
+    // mentioned above.
+    int (*side_needed_func_ptr)(int) = side_needed_func;
+    if (side_needed_func_ptr != side_needed_func)
+    {
+        printf("side_needed_func pointer mismatch\n");
+        return -1;
+    }
+
+    if (main_exported_ptr() != 85)
+    {
+        printf("main_exported returned unexpected value\n");
+        return -1;
+    }
+
+    return x + 4;
+}
\ No newline at end of file
diff --git a/tests/wasix/dl-needed/side.c b/tests/wasix/dl-needed/side.c
new file mode 100644
index 0000000000..3610023764
--- /dev/null
+++ b/tests/wasix/dl-needed/side.c
@@ -0,0 +1,30 @@
+#include <stdio.h>
+
+extern int side_needed_func(int);
+
+// This generates a GOT.func entry that gets resolved between
+// loading this module and side-needed.c, which caused an
+// error in the past.
+extern int main_exported();
+int (*main_exported_ptr)() = main_exported;
+
+int side_func(int x)
+{
+    // We need a function pointer internal to the module to give the module
+    // its own internal table space; this will trigger the GOT.func issue
+    // mentioned above.
+    int (*side_func_ptr)(int) = side_func;
+    if (side_func_ptr != side_func)
+    {
+        printf("side_needed_func pointer mismatch\n");
+        return -1;
+    }
+
+    if (main_exported_ptr() != 85)
+    {
+        printf("main_exported returned unexpected value\n");
+        return -1;
+    }
+
+    return side_needed_func(x) * 2;
+}
\ No newline at end of file
diff --git a/tests/wasix/dl-tls/.no-build b/tests/wasix/dl-tls/.no-build
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/wasix/dl-tls/common.c b/tests/wasix/dl-tls/common.c
new file mode 100644
index 0000000000..eb0d88a9bf
--- /dev/null
+++ b/tests/wasix/dl-tls/common.c
@@ -0,0 +1,3 @@
+int tls_base[4] = {0, 0, 0, 0};
+
+_Thread_local int tls_var = 0;
diff --git a/tests/wasix/dl-tls/main.c b/tests/wasix/dl-tls/main.c
new file mode 100644
index 0000000000..64f8c25f8e
--- /dev/null
+++ b/tests/wasix/dl-tls/main.c
@@ -0,0 +1,135 @@
+#include <stdio.h>
+#include <stdbool.h>
+#include <dlfcn.h>
+#include <pthread.h>
+
+extern int side_func(int in_thread, int value);
+
+bool all_unequal(int *arr, size_t size)
+{
+    for (size_t i = 0; i < size; i++)
+    {
+        for (size_t j = i + 1; j < size; j++)
+        {
+            if (arr[i] == arr[j])
+            {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+// Common storage where all functions can store data for the final check
+// Indices are: main-main, main-side, thread-main, thread-side
+extern int tls_base[4];
+
+// TLS variable that should be shared between main and side, but be
+// different in the thread
+extern _Thread_local int tls_var;
+
+// A simple global integer with a TLS pointer
+int static_int = 1;
+_Thread_local int *tls_ptr = &static_int;
+
+void *thread_func(void *arg)
+{
+    tls_base[2] = (int)__builtin_wasm_tls_base();
+
+    if (tls_ptr != &static_int)
+    {
+        fprintf(stderr, "TLS pointer does not point to static_int\n");
+        return (void *)1;
+    }
+
+    if (tls_var != 0)
+    {
+        fprintf(stderr, "TLS variable should initially be 0 in thread, got %d\n", tls_var);
+        return (void *)1;
+    }
+    tls_var = 50;
+    if (side_func(1, 100) != 0)
+    {
+        fprintf(stderr, "side_func failed in thread\n");
+        return (void *)1;
+    }
+    if (tls_var != 100)
+    {
+        fprintf(stderr, "TLS variable not set correctly in thread's side, expected 100, got %d\n", tls_var);
+        return (void *)1;
+    }
+
+    return (void *)0;
+}
+
+int do_main_tests()
+{
+    tls_base[0] = (int)__builtin_wasm_tls_base();
+
+    // Test if tls_ptr gets set correctly in __wasm_apply_tls_relocs,
+    // repeated in the thread and the side module as well
+    if (tls_ptr != &static_int)
+    {
+        fprintf(stderr, "TLS pointer does not point to static_int\n");
+        return 1;
+    }
+
+    // Test that the side module gets the correct address for main's TLS vars
+    // from the linker, repeated in the thread as well
+    if (tls_var != 0)
+    {
+        fprintf(stderr, "TLS variable should initially be 0 in main, got %d\n", tls_var);
+        return 1;
+    }
+    tls_var = 20;
+    if (side_func(0, 40) != 0)
+    {
+        fprintf(stderr, "side_func failed in main\n");
+        return 1;
+    }
+    if (tls_var != 40)
+    {
+        fprintf(stderr, "TLS variable not set correctly in main's side, expected 40, got %d\n", tls_var);
+        return 1;
+    }
+
+    return 0;
+}
+
+int main()
+{
+    pthread_t thread;
+    if (pthread_create(&thread, NULL, thread_func, NULL) != 0)
+    {
+        fprintf(stderr, "Failed to create thread\n");
+        return 1;
+    }
+
+    if (do_main_tests())
+    {
+        fprintf(stderr, "Main tests failed\n");
+        return 1;
+    }
+
+    void *thread_ret;
+    if (pthread_join(thread, &thread_ret) != 0)
+    {
+        fprintf(stderr, "Failed to join thread\n");
+        return 1;
+    }
+
+    if ((int)thread_ret != 0)
+    {
+        fprintf(stderr, "Thread function failed\n");
+        return 1;
+    }
+
+    // Make sure each instance got a different TLS base
+    if (!all_unequal(tls_base, 4))
+    {
+        fprintf(stderr, "TLS bases are not unique\n");
+        return 1;
+    }
+
+    return 0;
+}
\ No newline at end of file
diff --git a/tests/wasix/dl-tls/run.sh b/tests/wasix/dl-tls/run.sh
new file mode 100755
index 0000000000..caa7358623
--- /dev/null
+++ b/tests/wasix/dl-tls/run.sh
@@ -0,0 +1,11 @@
+#!/bin/bash
+
+set -e
+
+export WASIXCC_WASM_EXCEPTIONS=yes
+export WASIXCC_PIC=yes
+wasixcc common.c -o libcommon.so -Wl,-shared
+wasixcc side.c libcommon.so -o libside.so -Wl,-shared -Wl,-rpath,\$ORIGIN
+wasixcc main.c libside.so libcommon.so -o main.wasm -Wl,-pie -Wl,-rpath,\$ORIGIN
+
+$WASMER -q run main.wasm --dir=.
\ No newline at end of file
diff --git a/tests/wasix/dl-tls/side.c b/tests/wasix/dl-tls/side.c
new file mode 100644
index 0000000000..7e53a436c0
--- /dev/null
+++ b/tests/wasix/dl-tls/side.c
@@ -0,0 +1,21 @@
+#include <stdio.h>
+
+extern int tls_base[4];
+
+int side_static_int = 1;
+_Thread_local int *side_tls_ptr = &side_static_int;
+
+_Thread_local extern int tls_var;
+
+int side_func(int in_thread, int value)
+{
+    if (side_tls_ptr != &side_static_int)
+    {
+        fprintf(stderr, "TLS pointer does not point to static_int\n");
+        return 1;
+    }
+
+    tls_base[in_thread ? 1 : 3] = (int)__builtin_wasm_tls_base();
+    tls_var = value;
+    return 0;
+}
\ No newline at end of file
diff --git a/tests/wasix/dlopen/.no-build b/tests/wasix/dlopen/.no-build
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/wasix/dlopen/main.c b/tests/wasix/dlopen/main.c
new file mode 100644
index 0000000000..e8660848a4
--- /dev/null
+++ b/tests/wasix/dlopen/main.c
@@ -0,0 +1,53 @@
+#include <stdio.h>
+#include <dlfcn.h>
+
+int main()
+{
+    void *handle = dlopen("./libside.so", RTLD_NOW | RTLD_GLOBAL);
+    if (!handle)
+    {
+        fprintf(stderr, "dlopen failed: %s\n", dlerror());
+        return 1;
+    }
+
+    int (*side_func)(int) = dlsym(handle, "side_func");
+    if (!side_func)
+    {
+        fprintf(stderr, "dlsym failed: %s\n", dlerror());
+        dlclose(handle);
+        return 1;
+    }
+
+    int res = side_func(42);
+    if (res != 84)
+    {
+        fprintf(stderr, "side_func returned unexpected value: %d\n", res);
+        dlclose(handle);
+        return 1;
+    }
+
+    if (dlclose(handle) != 0)
+    {
+        fprintf(stderr, "dlclose failed: %s\n", dlerror());
+        return 1;
+    }
+
+    if (dlclose((void *)0xffffff) == 0)
+    {
+        fprintf(stderr, "expected dlclose to fail for bad handle\n");
+        return 1;
+    }
+
+    char *error = dlerror();
+    if (!error || *error == '\0')
+    {
+        fprintf(stderr, "dlerror should not be empty after bad dlclose\n");
+        return 1;
+    }
+
+    // Print something to make sure printf and, by extension, data relocations work.
+    // Do *NOT* remote this.
+    printf("All tests passed successfully!\n");
+
+    return 0;
+}
\ No newline at end of file
diff --git a/tests/wasix/dlopen/run.sh b/tests/wasix/dlopen/run.sh
new file mode 100755
index 0000000000..9226a9b7ae
--- /dev/null
+++ b/tests/wasix/dlopen/run.sh
@@ -0,0 +1,10 @@
+#!/bin/bash
+
+set -e
+
+export WASIXCC_WASM_EXCEPTIONS=yes
+export WASIXCC_PIC=yes
+wasixcc main.c -o main.wasm -Wl,-pie
+wasixcc side.c -o libside.so -Wl,-shared
+
+$WASMER -q run main.wasm --dir=.
\ No newline at end of file
diff --git a/tests/wasix/dlopen/side.c b/tests/wasix/dlopen/side.c
new file mode 100644
index 0000000000..d34b9d5c1b
--- /dev/null
+++ b/tests/wasix/dlopen/side.c
@@ -0,0 +1,4 @@
+int side_func(int x)
+{
+    return x * 2;
+}
\ No newline at end of file
diff --git a/tests/wasix/fd-close/main.c b/tests/wasix/fd-close/main.c
new file mode 100644
index 0000000000..5f63a4f8a2
--- /dev/null
+++ b/tests/wasix/fd-close/main.c
@@ -0,0 +1,36 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <fcntl.h>
+
+int main()
+{
+    int fd = socket(AF_INET, SOCK_STREAM, 0);
+    if (fd < 0)
+    {
+        perror("socket");
+        return 1;
+    }
+
+    if (close(fd) < 0)
+    {
+        perror("socket close");
+        return 1;
+    }
+
+    fd = open("/bin", O_RDONLY | O_DIRECTORY);
+    if (fd < 0)
+    {
+        perror("open dir");
+        return 1;
+    }
+
+    if (close(fd) < 0)
+    {
+        perror("dir close");
+        return 1;
+    }
+
+    return 0;
+}
\ No newline at end of file
diff --git a/tests/wasix/fd-close/run.sh b/tests/wasix/fd-close/run.sh
new file mode 100755
index 0000000000..e336f6fd17
--- /dev/null
+++ b/tests/wasix/fd-close/run.sh
@@ -0,0 +1,3 @@
+set -e
+
+$WASMER -q run main.wasm
diff --git a/tests/wasix/fd_pipe/main.c b/tests/wasix/fd_pipe/main.c
deleted file mode 100644
index acf76ff902..0000000000
--- a/tests/wasix/fd_pipe/main.c
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <unistd.h>
-
-int main()
-{
-    int status = EXIT_FAILURE;
-
-    int socks[2];
-    char buf[1024];
-    ssize_t numRead;
-
-    if (socketpair(AF_UNIX, SOCK_STREAM, 0, socks) == -1)
-    {
-        goto end;
-    }
-
-    if (write(socks[0], "foo", 3) == -1)
-    {
-        goto end;
-    }
-
-    memset(buf, 0, sizeof(buf));
-    numRead = read(socks[1], buf, sizeof(buf));
-    if (numRead == -1)
-    {
-        goto end;
-    }
-    if (strncmp(buf, "foo", 3) != 0)
-    {
-        goto end;
-    }
-
-    if (write(socks[1], "bar", 3) == -1)
-    {
-        goto end;
-    }
-
-    memset(buf, 0, sizeof(buf));
-    numRead = read(socks[0], buf, sizeof(buf));
-    if (numRead == -1)
-    {
-        goto end;
-    }
-    if (strncmp(buf, "bar", 3) != 0)
-    {
-        goto end;
-    }
-
-    status = EXIT_SUCCESS;
-
-end:
-    printf("%d", status);
-    return status;
-}
diff --git a/tests/wasix/fd_pipe/run.sh b/tests/wasix/fd_pipe/run.sh
deleted file mode 100755
index 3e033fb898..0000000000
--- a/tests/wasix/fd_pipe/run.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-$WASMER -q run main.wasm > output
-
-printf "0" | diff -u output - 1>/dev/null
\ No newline at end of file
diff --git a/tests/wasix/fork/main.c b/tests/wasix/fork/main.c
new file mode 100644
index 0000000000..62cb5b25b5
--- /dev/null
+++ b/tests/wasix/fork/main.c
@@ -0,0 +1,92 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/wait.h>
+
+int failing_exec()
+{
+    int pid = fork();
+
+    if (pid == 0)
+    {
+        execl("./not-here.wasm", NULL);
+        // After the execl fails, this should run and return the correct status
+        exit(30);
+    }
+    else
+    {
+        int status;
+        waitpid(pid, &status, 0);
+        if (WEXITSTATUS(status) != 30)
+        {
+            printf("Expected exit code 30 from subprocess, got %d\n", WEXITSTATUS(status));
+            return 1;
+        }
+
+        return 0;
+    }
+}
+
+// Making sure CLOEXEC FDs are not closed with a failing exec call
+int cloexec()
+{
+    int fd = open("/bin/file", O_RDONLY | O_CREAT | O_CLOEXEC);
+
+    int pid = fork();
+
+    if (pid == 0)
+    {
+        execl("./not-here.wasm", NULL);
+
+        int flags = fcntl(fd, F_GETFD);
+        if (flags == -1)
+        {
+            perror("fcntl");
+            exit(1);
+        }
+
+        if ((flags & FD_CLOEXEC) == 0)
+        {
+            printf("Expected FD_CLOEXEC flag to be set\n");
+            exit(2);
+        }
+
+        exit(40);
+    }
+    else
+    {
+        int status;
+        waitpid(pid, &status, 0);
+        if (WEXITSTATUS(status) != 40)
+        {
+            printf("Expected exit code 40 from subprocess, got %d\n", WEXITSTATUS(status));
+            return 1;
+        }
+
+        return 0;
+    }
+}
+
+int main(int argc, char **argv)
+{
+    if (argc < 2)
+    {
+        return -1;
+    }
+
+    if (!strcmp(argv[1], "failing_exec"))
+    {
+        return failing_exec();
+    }
+    else if (!strcmp(argv[1], "cloexec"))
+    {
+        return cloexec();
+    }
+    else
+    {
+        return -1;
+    }
+}
diff --git a/tests/wasix/fork/run.sh b/tests/wasix/fork/run.sh
new file mode 100755
index 0000000000..71b72a10a9
--- /dev/null
+++ b/tests/wasix/fork/run.sh
@@ -0,0 +1,4 @@
+set -e
+
+$WASMER -q run main.wasm --dir . -- failing_exec
+$WASMER -q run main.wasm --dir . -- cloexec
diff --git a/tests/wasix/fstatat-with-chdir/main.c b/tests/wasix/fstatat-with-chdir/main.c
new file mode 100644
index 0000000000..10cdfdaec0
--- /dev/null
+++ b/tests/wasix/fstatat-with-chdir/main.c
@@ -0,0 +1,57 @@
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+void error(const char *message)
+{
+    perror(message);
+    exit(-1);
+}
+
+int main()
+{
+    // Create two directories
+    if (mkdir("test1", S_IRWXU))
+    {
+        error("mkdir test1");
+    }
+    if (mkdir("test2", S_IRWXU))
+    {
+        error("mkdir test2");
+    }
+
+    // open the second directory for fstatat
+    int fd;
+    if ((fd = open("test2", O_RDONLY | O_DIRECTORY)) < 0)
+    {
+        error("open");
+    }
+
+    // chdir into the first directory
+    if (chdir("/home/test1"))
+    {
+        error("chdir");
+    }
+
+    // Now stat the second directory with a relative path.
+    // CWD should not be taken into account, and the stat
+    // should succeed.
+    struct stat st;
+    if (fstatat(fd, ".", &st, 0))
+    {
+        error("fstatat");
+    }
+
+    if (!S_ISDIR(st.st_mode))
+    {
+        printf("Expected a directory\n");
+        return -1;
+    }
+
+    printf("0");
+    return 0;
+}
diff --git a/tests/wasix/fstatat-with-chdir/run.sh b/tests/wasix/fstatat-with-chdir/run.sh
new file mode 100755
index 0000000000..8b18c8e348
--- /dev/null
+++ b/tests/wasix/fstatat-with-chdir/run.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+$WASMER -q run main.wasm --dir . > output
+
+rm -rf test1 test2 2>/dev/null && printf "0" | diff -u output - 1>/dev/null
diff --git a/tests/wasix/pipes/main.c b/tests/wasix/pipes/main.c
new file mode 100644
index 0000000000..1470c1dce3
--- /dev/null
+++ b/tests/wasix/pipes/main.c
@@ -0,0 +1,477 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/wait.h>
+#include <signal.h>
+
+int read_write()
+{
+    int pipefd[2];
+    if (pipe(pipefd) != 0)
+    {
+        perror("pipe");
+        return 1;
+    }
+
+    if (write(pipefd[1], "hello", 5) <= 0)
+    {
+        perror("write");
+        return 1;
+    }
+
+    char buf[6];
+    int r = read(pipefd[0], buf, 5);
+    if (r <= 0)
+    {
+        perror("read");
+        return 1;
+    }
+
+    buf[r] = '\0';
+
+    if (strcmp(buf, "hello"))
+    {
+        printf("Got bad message from pipe: %s\n", buf);
+        return 1;
+    }
+
+    return 0;
+}
+
+int read_from_closed_pipe()
+{
+    int pipefd[2];
+    if (pipe(pipefd) != 0)
+    {
+        perror("pipe");
+        return 1;
+    }
+
+    if (close(pipefd[1]) != 0)
+    {
+        perror("close");
+        return 1;
+    }
+
+    char buf[1];
+    int r = read(pipefd[0], buf, 1);
+    // Should get EOF when reading from closed pipe
+    if (r != 0)
+    {
+        perror("read");
+        return 1;
+    }
+
+    return 0;
+}
+
+int sigpipe_witnessed = 0;
+
+void handle_sigpipe(int sig)
+{
+    sigpipe_witnessed = 1;
+}
+
+int write_to_closed_pipe()
+{
+    signal(SIGPIPE, handle_sigpipe);
+
+    int pipefd[2];
+    if (pipe(pipefd) != 0)
+    {
+        perror("pipe");
+        return 1;
+    }
+
+    if (close(pipefd[0]) != 0)
+    {
+        perror("close");
+        return 1;
+    }
+
+    sigpipe_witnessed = 0;
+
+    int r = write(pipefd[1], "hello", 5);
+    if (r != -1 || errno != EPIPE)
+    {
+        printf("Expected write to fail with EPIPE, but got %d\n", errno);
+        return 1;
+    }
+
+    if (!sigpipe_witnessed)
+    {
+        printf("Expected to catch SIGPIPE signal\n");
+        return 1;
+    }
+
+    signal(SIGPIPE, SIG_DFL);
+    return 0;
+}
+
+int multiple_readers()
+{
+    int pipefd[2];
+    if (pipe(pipefd) != 0)
+    {
+        perror("pipe");
+        return 1;
+    }
+
+    int read_dup = dup(pipefd[0]);
+    if (read_dup < 0)
+    {
+        perror("dup");
+        return 1;
+    }
+
+    if (write(pipefd[1], "hello and bye", 13) <= 0)
+    {
+        perror("write");
+        return 1;
+    }
+
+    char buf[8];
+    int r = read(pipefd[0], buf, 6);
+    if (r <= 0)
+    {
+        perror("read");
+        return 1;
+    }
+
+    buf[r] = '\0';
+
+    if (strcmp(buf, "hello "))
+    {
+        printf("Got bad message from pipe: %s\n", buf);
+        return 1;
+    }
+
+    r = read(read_dup, buf, 7);
+    if (r <= 0)
+    {
+        perror("read");
+        return 1;
+    }
+
+    buf[r] = '\0';
+
+    if (strcmp(buf, "and bye"))
+    {
+        printf("Got bad message from pipe: %s\n", buf);
+        return 1;
+    }
+
+    return 0;
+}
+
+int multiple_writers()
+{
+    int pipefd[2];
+    if (pipe(pipefd) != 0)
+    {
+        perror("pipe");
+        return 1;
+    }
+
+    int write_dup = dup(pipefd[1]);
+    if (write_dup < 0)
+    {
+        perror("dup");
+        return 1;
+    }
+
+    if (write(pipefd[1], "hello ", 6) <= 0)
+    {
+        perror("write");
+        return 1;
+    }
+
+    // Need to close the write ends, otherwise the read loop below hangs forever
+    if (close(pipefd[1]) != 0)
+    {
+        perror("close");
+        return 1;
+    }
+
+    if (write(write_dup, "and bye", 7) <= 0)
+    {
+        perror("write");
+        return 1;
+    }
+
+    if (close(write_dup) != 0)
+    {
+        perror("close");
+        return 1;
+    }
+
+    char buf[14];
+    char *ptr = buf;
+    int r;
+    for (;;)
+    {
+        r = read(pipefd[0], ptr, 13 - (ptr - buf));
+        if (r < 0)
+        {
+            perror("read");
+            return 1;
+        }
+        else if (r == 0)
+        {
+            break;
+        }
+        ptr += r;
+    }
+
+    *ptr = 0;
+
+    if (strcmp(buf, "hello and bye"))
+    {
+        printf("Got bad message from pipe: %s\n", buf);
+        return 1;
+    }
+
+    return 0;
+}
+
+int fork_subprocess(int fd)
+{
+    char buf[6];
+    int r = read(fd, buf, 5);
+    if (r <= 0)
+    {
+        perror("read");
+        return 1;
+    }
+
+    buf[r] = '\0';
+
+    if (strcmp(buf, "hello"))
+    {
+        printf("Got bad message from pipe: %s\n", buf);
+        return 1;
+    }
+
+    r = read(fd, buf, 5);
+    if (r != 0)
+    {
+        perror("read");
+        return 1;
+    }
+
+    return 0;
+}
+
+int across_fork()
+{
+    int pipefd[2];
+    if (pipe(pipefd) != 0)
+    {
+        perror("pipe");
+        return 1;
+    }
+
+    // Unless the write end is closed in the subprocess as well, the read will hang forever
+    if (fcntl(pipefd[1], F_SETFD, FD_CLOEXEC) != 0)
+    {
+        perror("fcntl");
+        return 1;
+    }
+
+    pid_t pid = fork();
+    if (pid < 0)
+    {
+        perror("fork");
+        return 1;
+    }
+
+    if (pid == 0)
+    {
+        char buf[5];
+        sprintf(buf, "%d", pipefd[0]);
+        execle("./main.wasm", "main.wasm", "fork_subprocess", buf, NULL, NULL);
+        perror("execle");
+        return 1;
+    }
+
+    if (close(pipefd[0]) != 0)
+    {
+        perror("close pipefd[0]");
+        return 1;
+    }
+
+    if (write(pipefd[1], "hello", 5) <= 0)
+    {
+        perror("write");
+        return 1;
+    }
+
+    if (close(pipefd[1]) != 0)
+    {
+        perror("close pipefd[0]");
+        return 1;
+    }
+
+    int status;
+    if (waitpid(pid, &status, 0) != pid)
+    {
+        perror("waitpid");
+        return 1;
+    }
+
+    if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
+    {
+        printf("Subprocess failed\n");
+        return 1;
+    }
+
+    return 0;
+}
+
+int vfork_subprocess(int fd)
+{
+    char buf[6];
+    int r = read(fd, buf, 5);
+    if (r <= 0)
+    {
+        perror("read");
+        return 1;
+    }
+
+    buf[r] = '\0';
+
+    if (strcmp(buf, "hello"))
+    {
+        printf("Got bad message from pipe: %s\n", buf);
+        return 1;
+    }
+
+    r = read(fd, buf, 5);
+    if (r != 0)
+    {
+        perror("read");
+        return 1;
+    }
+
+    return 0;
+}
+
+int across_vfork()
+{
+    int pipefd[2];
+    if (pipe(pipefd) != 0)
+    {
+        perror("pipe");
+        return 1;
+    }
+
+    // Unless the write end is closed in the subprocess as well, the read will hang forever
+    if (fcntl(pipefd[1], F_SETFD, FD_CLOEXEC) != 0)
+    {
+        perror("fcntl");
+        return 1;
+    }
+
+    pid_t pid = vfork();
+    if (pid < 0)
+    {
+        perror("vfork");
+        return 1;
+    }
+
+    if (pid == 0)
+    {
+        char buf[5];
+        sprintf(buf, "%d", pipefd[0]);
+        execle("./main.wasm", "main.wasm", "vfork_subprocess", buf, NULL, NULL);
+        perror("execle");
+        return 1;
+    }
+
+    if (close(pipefd[0]) != 0)
+    {
+        perror("close pipefd[0]");
+        return 1;
+    }
+
+    if (write(pipefd[1], "hello", 5) <= 0)
+    {
+        perror("write");
+        return 1;
+    }
+
+    if (close(pipefd[1]) != 0)
+    {
+        perror("close pipefd[0]");
+        return 1;
+    }
+
+    int status;
+    if (waitpid(pid, &status, 0) != pid)
+    {
+        perror("waitpid");
+        return 1;
+    }
+
+    if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
+    {
+        printf("Subprocess failed\n");
+        return 1;
+    }
+
+    return 0;
+}
+
+int main(int argc, char **argv)
+{
+    if (argc >= 3 && !strcmp(argv[1], "fork_subprocess"))
+    {
+        return fork_subprocess(atoi(argv[2]));
+    }
+
+    if (argc >= 3 && !strcmp(argv[1], "vfork_subprocess"))
+    {
+        return vfork_subprocess(atoi(argv[2]));
+    }
+
+    if (read_write() != 0)
+    {
+        return 1;
+    }
+
+    if (read_from_closed_pipe() != 0)
+    {
+        return 1;
+    }
+
+    if (write_to_closed_pipe() != 0)
+    {
+        return 1;
+    }
+
+    if (multiple_readers() != 0)
+    {
+        return 1;
+    }
+
+    if (multiple_writers() != 0)
+    {
+        return 1;
+    }
+
+    if (across_fork() != 0)
+    {
+        return 1;
+    }
+
+    if (across_vfork() != 0)
+    {
+        return 1;
+    }
+
+    return 0;
+}
diff --git a/tests/wasix/pipes/run.sh b/tests/wasix/pipes/run.sh
new file mode 100755
index 0000000000..5673161f88
--- /dev/null
+++ b/tests/wasix/pipes/run.sh
@@ -0,0 +1,3 @@
+set -e
+
+$WASMER -q run main.wasm --dir .
diff --git a/tests/wasix/posix_spawn/.no-build b/tests/wasix/posix_spawn/.no-build
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/wasix/posix_spawn/main.c b/tests/wasix/posix_spawn/main.c
new file mode 100644
index 0000000000..880fb82b05
--- /dev/null
+++ b/tests/wasix/posix_spawn/main.c
@@ -0,0 +1,306 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+#include <spawn.h>
+#include <signal.h>
+
+int run_tests()
+{
+    posix_spawnattr_t attr;
+    posix_spawn_file_actions_t fdops;
+    sigset_t sigdefault;
+    pid_t pid;
+    char *argv[] = {"main.wasm", "subprocess", NULL};
+    char *envp[] = {"ABCD=1234", NULL};
+
+    // Ignore both SIGTERM and SIGHUP, then set SIGHUP up to be reset to default
+    if (signal(SIGTERM, SIG_IGN) == SIG_ERR)
+    {
+        perror("signal");
+        return 1;
+    }
+    if (signal(SIGHUP, SIG_IGN) == SIG_ERR)
+    {
+        perror("signal");
+        return 1;
+    }
+
+    // Raise the signal once, just to make sure it's _actually_ being ignored
+    raise(SIGTERM);
+
+    if (posix_spawnattr_init(&attr) != 0)
+    {
+        perror("posix_spawnattr_init");
+        return 1;
+    }
+    sigemptyset(&sigdefault);
+    sigaddset(&sigdefault, SIGHUP);
+    if (posix_spawnattr_setsigdefault(&attr, &sigdefault) != 0)
+    {
+        perror("posix_spawnattr_setsigdefault");
+        return 1;
+    }
+    if (posix_spawnattr_setflags(&attr, POSIX_SPAWN_SETSIGDEF) != 0)
+    {
+        perror("posix_spawnattr_setflags");
+        return 1;
+    }
+
+    // Open zzz on 11
+    int fd = open("./output.zzz", O_WRONLY | O_CREAT, 0);
+    if (fd < 0)
+    {
+        perror("open");
+        return 1;
+    }
+    if (dup2(fd, 11) != 11)
+    {
+        perror("dup2");
+        return 1;
+    }
+    if (dup2(fd, 13) != 13)
+    {
+        perror("dup2");
+        return 1;
+    }
+    if (fcntl(13, F_SETFD, FD_CLOEXEC) == -1)
+    {
+        perror("fcntl");
+        return 1;
+    }
+    if (close(fd) != 0)
+    {
+        perror("close");
+        return 1;
+    }
+
+    posix_spawn_file_actions_init(&fdops);
+    // Open yyy on 10
+    posix_spawn_file_actions_addopen(&fdops, 10, "./output.yyy", O_WRONLY | O_CREAT, 0);
+    // Renumber zzz to 12
+    posix_spawn_file_actions_adddup2(&fdops, 11, 12);
+    // Close 11
+    posix_spawn_file_actions_addclose(&fdops, 11);
+    // Request for 3 to be closed, but we expect it to remain open since it's a pre-open
+    posix_spawn_file_actions_addclose(&fdops, 3);
+    // After all of this, the subprocess should have 10 and 12, but not 11
+
+    if (posix_spawn(&pid, "./main-not-asyncified.wasm", &fdops, &attr, argv, envp) != 0)
+    {
+        perror("posix_spawn");
+        return 1;
+    }
+
+    if (posix_spawn_file_actions_destroy(&fdops) != 0)
+    {
+        perror("posix_spawn_file_actions_destroy");
+        return 1;
+    }
+    if (posix_spawnattr_destroy(&attr) != 0)
+    {
+        perror("posix_spawnattr_destroy");
+        return 1;
+    }
+
+    int status;
+    if (waitpid(pid, &status, 0) == -1)
+    {
+        perror("waitpid");
+        return 1;
+    }
+
+    if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
+    {
+        printf("Child process failed with: %d\n", WEXITSTATUS(status));
+        return 1;
+    }
+
+    char buffer[5] = {0};
+    fd = open("./output.yyy", O_RDONLY | O_CREAT, 0);
+    if (fd < 0)
+    {
+        perror("open");
+        return 1;
+    }
+    int r = read(fd, buffer, 5);
+    if (r <= 0)
+    {
+        perror("read from yyy");
+    }
+    if (strcmp(buffer, "yyy"))
+    {
+        printf("Expected yyy, got: %s\n", buffer);
+        return 1;
+    }
+    if (close(fd) != 0)
+    {
+        perror("close");
+        return 1;
+    }
+
+    fd = open("./output.zzz", O_RDONLY | O_CREAT, 0);
+    if (fd < 0)
+    {
+        perror("open");
+        return 1;
+    }
+    r = read(fd, buffer, 5);
+    if (r <= 0)
+    {
+        perror("read from yyy");
+    }
+    if (strcmp(buffer, "zzz"))
+    {
+        printf("Expected zzz, got: %s\n", buffer);
+        return 1;
+    }
+    if (close(fd) != 0)
+    {
+        perror("close");
+        return 1;
+    }
+
+    char *argv2[] = {"main.wasm", "just-return", NULL};
+    putenv("PATH=/home/");
+    status = 0;
+
+    if (posix_spawnp(&pid, "main-not-asyncified.wasm", NULL, NULL, argv2, NULL) != 0)
+    {
+        perror("posix_spawn 2");
+        return 1;
+    }
+
+    if (waitpid(pid, &status, 0) == -1)
+    {
+        perror("waitpid 2");
+        return 1;
+    }
+
+    if (!WIFEXITED(status) || WEXITSTATUS(status) != 70)
+    {
+        printf("Expected exit with status 70, got: %d\n", WEXITSTATUS(status));
+        return 1;
+    }
+
+    return 0;
+}
+
+// Since we don't pipe stderr from the child process, this function writes
+// output to a file which can (hopefully!) be inspected
+void write_subprocess_error(const char *msg)
+{
+    FILE *outf = fopen("./output.child", "w");
+    if (!outf)
+    {
+        exit(EXIT_FAILURE);
+    }
+    fprintf(outf, "%s: %s\n", msg, strerror(errno));
+    fclose(outf);
+    exit(EXIT_FAILURE);
+}
+
+int subprocess(int argc, char **argv)
+{
+    if (argc != 2 || strcmp(argv[0], "main.wasm"))
+    {
+        write_subprocess_error("Got bad CLI args");
+        return 2;
+    }
+
+    if (!strcmp(argv[1], "just-return"))
+    {
+        return 70;
+    }
+    else if (strcmp(argv[1], "subprocess"))
+    {
+        write_subprocess_error("Got bad CLI args");
+        return 2;
+    }
+
+    const char *env = getenv("ABCD");
+    if (strcmp(env, "1234"))
+    {
+        char buf[128];
+        sprintf(buf, "env var not set correctly, value is: %s", env);
+        write_subprocess_error(buf);
+    }
+
+    struct sigaction act = {0};
+    if (sigaction(SIGHUP, NULL, &act) != 0)
+    {
+        write_subprocess_error("sigaction");
+    }
+    if (act.sa_handler != SIG_DFL)
+    {
+        write_subprocess_error("expected SIGHUP to be set to SIG_DFL");
+    }
+
+    if (sigaction(SIGTERM, NULL, &act) != 0)
+    {
+        write_subprocess_error("sigaction");
+    }
+    if (act.sa_handler != SIG_IGN)
+    {
+        write_subprocess_error("expected SIGTERM to be set to SIG_IGN");
+    }
+    // and raise it once, just in case!
+    raise(SIGTERM);
+
+    int flags = fcntl(11, F_GETFD);
+    if (flags != -1 || errno != EBADF)
+    {
+        write_subprocess_error("Expected EBADF for fd 11");
+    }
+    errno = 0;
+
+    // 13 should be closed due to FD_CLOEXEC
+    flags = fcntl(13, F_GETFD);
+    if (flags != -1 || errno != EBADF)
+    {
+        write_subprocess_error("Expected EBADF for fd 11");
+    }
+    errno = 0;
+
+    if (write(10, "yyy", 3) <= 0)
+    {
+        write_subprocess_error("write to yyy failed");
+    }
+    if (close(10) < 0)
+    {
+        write_subprocess_error("close(10) failed");
+    }
+
+    if (write(12, "zzz", 3) <= 0)
+    {
+        write_subprocess_error("write to zzz failed");
+    }
+    if (close(12) < 0)
+    {
+        write_subprocess_error("close(12) failed");
+    }
+
+    // 3 is a pre-open, and should remain open
+    struct stat st;
+    if (fstat(3, &st) != 0)
+    {
+        write_subprocess_error("failed to fstat pre-opened FD 3");
+    }
+
+    return 0;
+}
+
+int main(int argc, char **argv)
+{
+    if (argc >= 2)
+    {
+        return subprocess(argc, argv);
+    }
+
+    return run_tests();
+}
diff --git a/tests/wasix/posix_spawn/run.sh b/tests/wasix/posix_spawn/run.sh
new file mode 100755
index 0000000000..cc46ddc1dc
--- /dev/null
+++ b/tests/wasix/posix_spawn/run.sh
@@ -0,0 +1,9 @@
+set -e
+
+wasixcc -sRUN_WASM_OPT=no main.c -o main-not-asyncified.wasm
+wasm-opt --asyncify main-not-asyncified.wasm -o main.wasm
+
+rm -f output.yyy output.zzz
+
+# Run the not-asyncified variant to make sure posix_spawn doesn't require asyncify
+$WASMER -q run main-not-asyncified.wasm --dir .
diff --git a/tests/wasix/setjmp-longjmp/main.c b/tests/wasix/setjmp-longjmp/main.c
new file mode 100644
index 0000000000..4ff41ba33a
--- /dev/null
+++ b/tests/wasix/setjmp-longjmp/main.c
@@ -0,0 +1,43 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <setjmp.h>
+#include <sys/types.h>
+
+int main()
+{
+    // Put variables on both ends to make sure the setjmp
+    // code doesn't overwrite anything by mistake
+    unsigned long long int before = 10;
+    jmp_buf jmp;
+    unsigned long long int after = 20;
+
+    if (setjmp(jmp) == 0)
+    {
+        if (before != 10 || after != 20)
+        {
+            printf("oops 1\n");
+            exit(1);
+        }
+        longjmp(jmp, 1);
+        printf("oops 2\n");
+        exit(2);
+    }
+    else
+    {
+        if (before != 10 || after != 20)
+        {
+            printf("oops 3\n");
+            exit(3);
+        }
+        before = 50;
+        after = 60;
+    }
+
+    if (before != 50 || after != 60)
+    {
+        printf("oops 4\n");
+        exit(4);
+    }
+
+    return 0;
+}
\ No newline at end of file
diff --git a/tests/wasix/setjmp-longjmp/run.sh b/tests/wasix/setjmp-longjmp/run.sh
new file mode 100755
index 0000000000..692ef72a45
--- /dev/null
+++ b/tests/wasix/setjmp-longjmp/run.sh
@@ -0,0 +1,3 @@
+#!/bin/bash
+
+$WASMER -q run main.wasm
diff --git a/tests/wasix/shared-fd/main.c b/tests/wasix/shared-fd/main.c
new file mode 100644
index 0000000000..29eab82aff
--- /dev/null
+++ b/tests/wasix/shared-fd/main.c
@@ -0,0 +1,102 @@
+/// This test makes sure writing to the same file, when referred to
+/// by multiple FDs (some of which are shared), works correctly. The
+/// trace logs generated by Wasmer are also inspected to make sure
+/// the file is closed properly.
+
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/wait.h>
+
+void error_exit(const char *message)
+{
+    perror(message);
+    exit(-1);
+}
+
+int main(int argc, char *argv[])
+{
+    int fd1 = open("./output", O_CREAT | O_EXCL | O_WRONLY);
+    if (fd1 < 0)
+    {
+        error_exit("open");
+    }
+
+    int fd2 = dup(fd1);
+    if (fd2 < 0 || fd2 == fd1)
+    {
+        error_exit("parent dup");
+    }
+
+    if (!write(fd2, "parent 2\n", 9))
+    {
+        error_exit("parent write 2");
+    }
+
+    pid_t pid = fork();
+    if (pid == -1)
+    {
+        error_exit("fork");
+    }
+    else if (pid == 0)
+    {
+        if (close(fd2))
+        {
+            error_exit("child close parent fd2");
+        }
+
+        fd2 = dup(fd1);
+        if (fd2 < 0 || fd2 == fd1)
+        {
+            error_exit("child dup");
+        }
+
+        if (!write(fd1, "child 1\n", 8))
+        {
+            error_exit("child write 1");
+        }
+        if (close(fd1))
+        {
+            error_exit("child close 1");
+        }
+
+        if (!write(fd2, "child 2\n", 8))
+        {
+            error_exit("child write 2");
+        }
+        if (close(fd2))
+        {
+            error_exit("child close 2");
+        }
+        exit(0);
+    }
+    else
+    {
+        if (close(fd2))
+        {
+            error_exit("parent close 2");
+        }
+
+        int status;
+        waitpid(pid, &status, 0);
+        if (status)
+        {
+            error_exit("child exit code");
+        }
+
+        if (!write(fd1, "parent 1\n", 9))
+        {
+            error_exit("parent write 1");
+        }
+
+        // These prints can be inspected to make sure the file was
+        // closed as a result of the last close() call, see run.sh
+        printf("closing last fd\n");
+        if (close(fd1))
+        {
+            error_exit("parent close 1");
+        }
+        printf("last fd closed\n");
+    }
+}
\ No newline at end of file
diff --git a/tests/wasix/shared-fd/run.sh b/tests/wasix/shared-fd/run.sh
new file mode 100755
index 0000000000..b2283ff9ac
--- /dev/null
+++ b/tests/wasix/shared-fd/run.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+
+set -eu
+
+rm -f output*
+
+RUST_LOG=virtual_fs=trace $WASMER run main.wasm --dir . &> output-wasmer-log
+
+cat output | grep "parent 1" >/dev/null && \
+  cat output | grep "parent 2" >/dev/null && \
+  cat output | grep "child 1" >/dev/null && \
+  cat output | grep "child 2" >/dev/null && \
+  awk '/closing last fd/{m1=1} /Closing host file.*shared-fd\/output/{if(m1) m2=1} /last fd closed/{if(m2) print "found all lines"}' output-wasmer-log | grep "found all lines" >/dev/null
diff --git a/tests/wasix/socket_pair/main.c b/tests/wasix/socket_pair/main.c
new file mode 100644
index 0000000000..551e8d815a
--- /dev/null
+++ b/tests/wasix/socket_pair/main.c
@@ -0,0 +1,320 @@
+// Note: we need this test because we're hacking around
+// socket pairs and using a duplex pipe underneath, which
+// creates huge potential for edge cases and errors.
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <memory.h>
+#include <sys/epoll.h>
+
+int test_communication(int from, int to)
+{
+    int result;
+    char buf[32];
+    ssize_t numRead;
+    fd_set fdset;
+    struct timeval timeout = {
+        .tv_sec = 0,
+        .tv_usec = 0,
+    };
+
+    // Test 1: do it through select, with read and write
+    FD_ZERO(&fdset);
+    FD_SET(to, &fdset);
+    result = select(to + 1, NULL, &fdset, NULL, &timeout);
+    if (result < 0)
+    {
+        perror("select");
+        return -1;
+    }
+    else if (result == 0)
+    {
+        printf("Timeout: nothing can be written.\n");
+        return -1;
+    }
+    else
+    {
+        if (FD_ISSET(to, &fdset))
+        {
+            int bytes_written = write(to, "foo", 3);
+            if (bytes_written < 0)
+            {
+                perror("write");
+                return -1;
+            }
+        }
+        else
+        {
+            printf("Expected send socket to be ready to write to\n");
+            return -1;
+        }
+    }
+
+    FD_ZERO(&fdset);
+    FD_SET(from, &fdset);
+    result = select(from + 1, &fdset, NULL, NULL, &timeout);
+    if (result < 0)
+    {
+        perror("select");
+        return -1;
+    }
+    else if (result == 0)
+    {
+        printf("Timeout: No data available to read.\n");
+        return -1;
+    }
+    else
+    {
+        if (FD_ISSET(from, &fdset))
+        {
+            int bytes_read = read(from, buf, sizeof(buf));
+            if (bytes_read < 0)
+            {
+                perror("read");
+                return -1;
+            }
+            buf[bytes_read] = 0;
+            if (strncmp(buf, "foo", 3) != 0)
+            {
+                printf("expected 'foo', received: %s\n", buf);
+                return -1;
+            }
+        }
+        else
+        {
+            printf("Expected recv socket to be ready to read from\n");
+            return -1;
+        }
+    }
+
+    // test 2: do it through send and recv
+
+    int bytes_sent = send(to, "bar", 3, 0);
+    if (bytes_sent < 0)
+    {
+        perror("send");
+        return -1;
+    }
+
+    int bytes_received = recv(from, buf, sizeof(buf), 0);
+    if (bytes_received < 0)
+    {
+        perror("recv");
+        return -1;
+    }
+    buf[bytes_received] = 0;
+
+    if (strncmp(buf, "bar", 3) != 0)
+    {
+        printf("expected 'bar', received: %s\n", buf);
+        return -1;
+    }
+
+    return 0;
+}
+
+#define BUFFER_SIZE 1024
+#define MAX_EVENTS 10
+
+typedef struct
+{
+    int fd;
+    char buffer[BUFFER_SIZE];
+} socket_data_t;
+
+void *epoll_thread(void *arg)
+{
+    struct epoll_event events[MAX_EVENTS];
+    int n, i;
+    int epoll_fd = *(int *)arg;
+    // Quick'n'dirty way to read exactly 3 packets
+    int num_events = 0;
+    int sum = 0;
+
+    while (1)
+    {
+        n = epoll_wait(epoll_fd, events, MAX_EVENTS, 5000);
+        if (n == -1)
+        {
+            perror("epoll_wait");
+            return (void *)0;
+        }
+        else if (n == 0)
+        {
+            printf("No events occurred within the timeout period.\n");
+            return (void *)0;
+        }
+
+        for (i = 0; i < n; i++)
+        {
+            socket_data_t *data = (socket_data_t *)events[i].data.ptr;
+
+            if (events[i].events & EPOLLIN)
+            {
+                num_events++;
+
+                while (1)
+                {
+                    ssize_t count = read(data->fd, data->buffer, BUFFER_SIZE - 1);
+
+                    if (count == -1)
+                    {
+                        if (errno != EAGAIN)
+                        {
+                            perror("read error");
+                            close(data->fd);
+                            free(data);
+                            return (void *)0;
+                        }
+                        break;
+                    }
+                    else if (count == 0)
+                    {
+                        // Connection closed by client
+                        close(data->fd);
+                        free(data);
+                        return (void *)0;
+                    }
+
+                    // Super-hacky, relies on packets arriving all at once, but
+                    // that should be the case anyway
+                    data->buffer[count] = '\0';
+                    sum += atoi(data->buffer);
+
+                    // Reset for next read
+                    memset(data->buffer, 0, BUFFER_SIZE);
+                }
+
+                if (num_events >= 3)
+                {
+                    close(data->fd);
+                    free(data);
+                    return (void *)sum;
+                }
+            }
+            else
+            {
+                printf("Unexpected event on fd %d\n", data->fd);
+                close(data->fd);
+                free(data);
+                return (void *)0;
+            }
+        }
+    }
+}
+
+int wait_via_epoll()
+{
+    int epoll_fd = epoll_create1(0);
+    if (epoll_fd == -1)
+    {
+        perror("epoll_create1");
+        exit(EXIT_FAILURE);
+    }
+
+    int sockfd[2];
+    if (socketpair(AF_UNIX, SOCK_STREAM, 0, sockfd) == -1)
+    {
+        perror("socketpair");
+        close(epoll_fd);
+        exit(EXIT_FAILURE);
+    }
+
+    int recv_fd = sockfd[0];
+    int send_fd = sockfd[1];
+
+    int flags = fcntl(recv_fd, F_GETFL, 0);
+    fcntl(recv_fd, F_SETFL, flags | O_NONBLOCK);
+
+    socket_data_t *data = malloc(sizeof(socket_data_t));
+    if (!data)
+    {
+        perror("malloc");
+        return -1;
+    }
+
+    data->fd = recv_fd;
+    memset(data->buffer, 0, BUFFER_SIZE);
+
+    struct epoll_event event;
+    event.events = EPOLLIN | EPOLLET; // Edge-triggered mode
+    event.data.ptr = data;
+
+    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, recv_fd, &event) == -1)
+    {
+        perror("epoll_ctl failed");
+        free(data);
+        return -1;
+    }
+
+    pthread_attr_t attr;
+    pthread_attr_init(&attr);
+    pthread_t thread;
+    pthread_create(&thread, &attr, epoll_thread, (void *)&epoll_fd);
+
+    struct timespec ts;
+    ts.tv_sec = 0;
+    ts.tv_nsec = 100000000;
+
+    send(send_fd, "42", 2, 0);
+    nanosleep(&ts, NULL);
+    send(send_fd, "69", 2, 0);
+    nanosleep(&ts, NULL);
+    send(send_fd, "85", 2, 0);
+    nanosleep(&ts, NULL);
+    close(send_fd);
+
+    void *result;
+    pthread_join(thread, &result);
+    int sum = (int)result;
+    if (sum == 0)
+    {
+        printf("Error in epoll thread\n");
+        close(epoll_fd);
+        return -1;
+    }
+    else if (sum != 196)
+    {
+        printf("Expected sum to be 196, got %d\n", sum);
+        close(epoll_fd);
+        return -1;
+    }
+
+    return 0;
+}
+
+int main()
+{
+    int socks[2];
+
+    if (socketpair(AF_UNIX, SOCK_STREAM, 0, socks) == -1)
+    {
+        perror("socketpair");
+        return -1;
+    }
+
+    if (test_communication(socks[0], socks[1]) == -1)
+    {
+        return -1;
+    }
+
+    // try it in reverse as well, since the connection should be duplex
+    if (test_communication(socks[1], socks[0]) == -1)
+    {
+        return -1;
+    }
+
+    if (wait_via_epoll() != 0)
+    {
+        return -1;
+    }
+
+    return 0;
+}
\ No newline at end of file
diff --git a/tests/wasix/socket_pair/run.sh b/tests/wasix/socket_pair/run.sh
new file mode 100755
index 0000000000..0aa1f606b6
--- /dev/null
+++ b/tests/wasix/socket_pair/run.sh
@@ -0,0 +1 @@
+$WASMER -q run main.wasm
\ No newline at end of file
diff --git a/tests/wasix/test.sh b/tests/wasix/test.sh
index 1d85eba2b1..bf0be0bd9a 100755
--- a/tests/wasix/test.sh
+++ b/tests/wasix/test.sh
@@ -1,71 +1,5 @@
 #!/bin/bash
 
-if [[ -z "${WASI_SDK}" ]]; then
-    echo "WASI_SDK is not found"
-    exit 1
-fi
-
-if [[ -z "${WASIX_SYSROOT}" ]]; then
-    echo "WASIX_SYSROOT is not found"
-    exit 1
-fi
-
-export RANLIB="$WASI_SDK/bin/ranlib"
-export AR="$WASI_SDK/bin/ar"
-export NM="$WASI_SDK/bin/nm"
-export CC="$WASI_SDK/bin/clang"
-export CXX="$WASI_SDK/bin/clang"
-export CFLAGS="\
---sysroot=$WASIX_SYSROOT \
--matomics \
--mbulk-memory \
--mmutable-globals \
--pthread \
--mthread-model posix \
--ftls-model=local-exec \
--fno-trapping-math \
--D_WASI_EMULATED_MMAN \
--D_WASI_EMULATED_SIGNAL \
--D_WASI_EMULATED_PROCESS_CLOCKS \
--O3 \
--g \
--flto"
-export LD="$WASI_SDK/bin/wasm-ld"
-export LDFLAGS="\
--Wl,--shared-memory \
--Wl,--max-memory=4294967296 \
--Wl,--import-memory \
--Wl,--export-dynamic \
--Wl,--export=__heap_base \
--Wl,--export=__stack_pointer \
--Wl,--export=__data_end \
--Wl,--export=__wasm_init_tls \
--Wl,--export=__wasm_signal \
--Wl,--export=__tls_size \
--Wl,--export=__tls_align \
--Wl,--export=__tls_base \
--lwasi-emulated-mman \
--O3 \
--g \
--flto"
-export LIBS="\
--Wl,--shared-memory \
--Wl,--max-memory=4294967296 \
--Wl,--import-memory \
--Wl,--export-dynamic \
--Wl,--export=__heap_base \
--Wl,--export=__stack_pointer \
--Wl,--export=__data_end \
--Wl,--export=__wasm_init_tls \
--Wl,--export=__wasm_signal \
--Wl,--export=__tls_size \
--Wl,--export=__tls_align \
--Wl,--export=__tls_base \
--lwasi-emulated-mman \
--O3 \
--g \
--flto"
-
 export WASMER=$(realpath "../../target/release/wasmer")
 
 printf "\n\nStarting WASIX Test Suite:\n"
@@ -75,10 +9,14 @@ while read dir; do
     dir=$(basename "$dir")
     printf "Testing $dir..."
 
-    cmd="cd $dir; \
-        $CC $CFLAGS $LDFLAGS -o main.wasm main.c; \
-        wasm-opt -O4 --asyncify -g main.wasm -o main.wasm; \
-        ./run.sh"
+    if [ -e "$dir/.no-build" ]; then
+        cmd="cd $dir; \
+            ./run.sh"
+    else
+        cmd="cd $dir; \
+            wasixcc main.c -o main.wasm; \
+            ./run.sh"
+    fi
 
     if bash -c "$cmd"; then
         printf "\rTesting $dir ✅\n"
diff --git a/tests/wasix/udp/main.c b/tests/wasix/udp/main.c
new file mode 100644
index 0000000000..da6a5e241c
--- /dev/null
+++ b/tests/wasix/udp/main.c
@@ -0,0 +1,187 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <string.h>
+
+/*
+this is an example of address reuse using UDP sockets
+it set address reuse option to 1 and then bind to the same address
+it set port reuse option to 1 and then bind to the same port
+*/
+int test_addr_reuse()
+{
+    int sock1, sock2;
+    int reuse = 1;
+    struct sockaddr_in addr;
+
+    sock1 = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sock1 < 0)
+    {
+        puts("failed to create the first socket");
+        return EXIT_FAILURE;
+    }
+
+    if (setsockopt(sock1, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0)
+    {
+        puts("setsockopt first socket SO_REUSEADDR failed");
+        return EXIT_FAILURE;
+    }
+
+    if (setsockopt(sock1, SOL_SOCKET, SO_REUSEPORT, &reuse, sizeof(reuse)) < 0)
+    {
+        puts("setsockopt first socket SO_REUSEPORT failed");
+        return EXIT_FAILURE;
+    }
+
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(12345);
+    addr.sin_addr.s_addr = htonl(INADDR_ANY);
+
+    if (bind(sock1, (struct sockaddr *)&addr, sizeof(addr)) < 0)
+    {
+        puts("first socket bind failed");
+        return EXIT_FAILURE;
+    }
+
+    sock2 = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sock2 < 0)
+    {
+        puts("failed to create the second socket");
+        return EXIT_FAILURE;
+    }
+
+    if (setsockopt(sock2, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0)
+    {
+        puts("setsockopt second socket SO_REUSEADDR failed");
+        return EXIT_FAILURE;
+    }
+
+    if (setsockopt(sock2, SOL_SOCKET, SO_REUSEPORT, &reuse, sizeof(reuse)) < 0)
+    {
+        puts("setsockopt second socket SO_REUSEPORT failed");
+        return EXIT_FAILURE;
+    }
+
+    if (bind(sock2, (struct sockaddr *)&addr, sizeof(addr)) < 0)
+    {
+        puts("second socket bind failed");
+        return EXIT_FAILURE;
+    }
+
+    close(sock1);
+    close(sock2);
+
+    return EXIT_SUCCESS;
+}
+
+int test_ipv6()
+{
+    int sock;
+    struct sockaddr_in6 addr;
+
+    sock = socket(AF_INET6, SOCK_DGRAM, 0);
+    if (sock < 0)
+    {
+        puts("failed to create the socket");
+        return EXIT_FAILURE;
+    }
+
+    addr.sin6_family = AF_INET6;
+    addr.sin6_port = htons(0);
+    addr.sin6_addr = in6addr_any;
+
+    if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0)
+    {
+        puts("socket bind failed");
+        close(sock);
+        return EXIT_FAILURE;
+    }
+
+    close(sock);
+    return EXIT_SUCCESS;
+}
+
+int test_autobind_connect()
+{
+    int sock;
+    struct sockaddr_in addr;
+
+    sock = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sock < 0)
+    {
+        puts("failed to create the socket");
+        return EXIT_FAILURE;
+    }
+
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(65535);
+    addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+    if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0)
+    {
+        puts("socket connect failed");
+        close(sock);
+        return EXIT_FAILURE;
+    }
+
+    close(sock);
+    return EXIT_SUCCESS;
+}
+
+int test_autobind_sendto()
+{
+    int sock;
+    struct sockaddr_in addr;
+
+    sock = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sock < 0)
+    {
+        puts("failed to create the socket");
+        return EXIT_FAILURE;
+    }
+
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(65535);
+    addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+    if (sendto(sock, "hello", 5, 0, (struct sockaddr *)&addr, sizeof(addr)) < 0)
+    {
+        puts("sendto failed");
+        close(sock);
+        return EXIT_FAILURE;
+    }
+
+    close(sock);
+    return EXIT_SUCCESS;
+}
+
+int main(int argc, char *argv[])
+{
+    if (argc < 2)
+    {
+        return EXIT_FAILURE;
+    }
+
+    if (!strcmp(argv[1], "addr-reuse"))
+    {
+        return test_addr_reuse();
+    }
+    else if (!strcmp(argv[1], "ipv6"))
+    {
+        return test_ipv6();
+    }
+    else if (!strcmp(argv[1], "autobind-connect"))
+    {
+        return test_autobind_connect();
+    }
+    else if (!strcmp(argv[1], "autobind-sendto"))
+    {
+        return test_autobind_sendto();
+    }
+    else
+    {
+        puts("Unknown test case");
+        return EXIT_FAILURE;
+    }
+}
\ No newline at end of file
diff --git a/tests/wasix/udp/run.sh b/tests/wasix/udp/run.sh
new file mode 100755
index 0000000000..c30d3c7496
--- /dev/null
+++ b/tests/wasix/udp/run.sh
@@ -0,0 +1,6 @@
+set -e
+
+$WASMER -q run main.wasm --net --dir . -- addr-reuse
+$WASMER -q run main.wasm --net --dir . -- ipv6
+$WASMER -q run main.wasm --net --dir . -- autobind-connect
+$WASMER -q run main.wasm --net --dir . -- autobind-sendto
diff --git a/tests/wasix/vfork/main.c b/tests/wasix/vfork/main.c
new file mode 100644
index 0000000000..25ba405417
--- /dev/null
+++ b/tests/wasix/vfork/main.c
@@ -0,0 +1,463 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/wait.h>
+
+int successful_exec()
+{
+    int pid = vfork();
+
+    if (pid == 0)
+    {
+        execl("./main.wasm", "main.wasm", "subprocess", NULL);
+        perror("execl");
+        exit(10);
+    }
+    else
+    {
+        int status;
+        waitpid(pid, &status, 0);
+        if (WEXITSTATUS(status) != 20)
+        {
+            printf("Expected exit code 20 from subprocess, got %d\n", WEXITSTATUS(status));
+            return 1;
+        }
+
+        return 0;
+    }
+}
+
+int successful_execlp()
+{
+    // We should be able to handle an extra / at the end
+    putenv("PATH=/home/");
+
+    int pid = vfork();
+
+    if (pid == 0)
+    {
+        execlp("main.wasm", "main.wasm", "subprocess", NULL);
+        perror("execlp");
+        exit(10);
+    }
+    else
+    {
+        int status;
+        waitpid(pid, &status, 0);
+        if (WEXITSTATUS(status) != 20)
+        {
+            printf("Expected exit code 20 from subprocess, got %d\n", WEXITSTATUS(status));
+            return 1;
+        }
+
+        return 0;
+    }
+}
+
+int subprocess()
+{
+    return 20;
+}
+
+int failing_exec()
+{
+    int pid = vfork();
+
+    if (pid == 0)
+    {
+        execl("./not-here.wasm", NULL);
+        // After the execl fails, this should run and return the correct status
+        exit(30);
+    }
+    else
+    {
+        int status;
+        waitpid(pid, &status, 0);
+        if (WEXITSTATUS(status) != 30)
+        {
+            printf("Expected exit code 30 from subprocess, got %d\n", WEXITSTATUS(status));
+            return 1;
+        }
+
+        return 0;
+    }
+}
+
+int cloexec()
+{
+    int fd = open("/bin/file", O_RDONLY | O_CREAT | O_CLOEXEC);
+
+    int pid = vfork();
+
+    if (pid == 0)
+    {
+        execl("./not-here.wasm", NULL);
+
+        int flags = fcntl(fd, F_GETFD);
+        if (flags == -1)
+        {
+            perror("fcntl");
+            exit(1);
+        }
+
+        if ((flags & FD_CLOEXEC) == 0)
+        {
+            printf("Expected FD_CLOEXEC flag to be set\n");
+            exit(2);
+        }
+
+        exit(40);
+    }
+    else
+    {
+        int status;
+        waitpid(pid, &status, 0);
+        if (WEXITSTATUS(status) != 40)
+        {
+            printf("Expected exit code 40 from subprocess, got %d\n", WEXITSTATUS(status));
+            return 1;
+        }
+
+        return 0;
+    }
+}
+
+int exiting_child()
+{
+    int pipefd[2];
+    if (pipe(pipefd) != 0)
+    {
+        perror("pipe");
+        return -1;
+    }
+
+    fcntl(pipefd[0], F_SETFD, FD_CLOEXEC);
+
+    int pid = vfork();
+
+    if (pid == 0)
+    {
+        char fd_buf[5];
+        sprintf(fd_buf, "%d", pipefd[1]);
+        execl("./main.wasm", "main.wasm", "subprocess_exit", fd_buf, NULL);
+        perror("execl");
+        return -1;
+    }
+
+    close(pipefd[1]);
+
+    int status;
+    if (waitpid(pid, &status, 0) < 0)
+    {
+        perror("waitpid");
+        return -1;
+    }
+
+    if (WEXITSTATUS(status) != 50)
+    {
+        printf("exiting_child: expected child to exit with 50, got status %i\n", WEXITSTATUS(status));
+        return -1;
+    }
+
+    char buf[6];
+    int r = read(pipefd[0], buf, 5);
+    if (r < 0)
+    {
+        perror("read");
+        return -1;
+    }
+
+    buf[r] = 0;
+    if (strcmp(buf, "hello"))
+    {
+        printf("exiting_child: Expected 'hello', got %s\n", buf);
+        return -1;
+    }
+
+    r = read(pipefd[0], buf, 5);
+    if (r != 0)
+    {
+        printf("exiting_child: Expected pipe to be closed after first read\n");
+        return -1;
+    }
+
+    return 0;
+}
+
+int subprocess_exit(int fd)
+{
+    if (write(fd, "hello", 5) < 0)
+    {
+        perror("write");
+        return 1;
+    }
+
+    // The FD should be closed automatically by the runtime
+    return 50;
+}
+
+int trapping_child()
+{
+    int pipefd[2];
+    if (pipe(pipefd) != 0)
+    {
+        perror("pipe");
+        return -1;
+    }
+
+    fcntl(pipefd[0], F_SETFD, FD_CLOEXEC);
+
+    int pid = vfork();
+
+    if (pid == 0)
+    {
+        char fd_buf[5];
+        sprintf(fd_buf, "%d", pipefd[1]);
+        execl("./main.wasm", "main.wasm", "subprocess_trap", fd_buf, NULL);
+        perror("execl");
+        return -1;
+    }
+
+    close(pipefd[1]);
+
+    char buf[6];
+    int r = read(pipefd[0], buf, 5);
+    if (r < 0)
+    {
+        perror("read");
+        return -1;
+    }
+
+    buf[r] = 0;
+    if (strcmp(buf, "hello"))
+    {
+        printf("trapping_child: Expected 'hello', got %s\n", buf);
+        return -1;
+    }
+
+    r = read(pipefd[0], buf, 5);
+    if (r != 0)
+    {
+        printf("trapping_child: Expected pipe to be closed after first read\n");
+        return -1;
+    }
+
+    int status;
+    if (waitpid(pid, &status, 0) < 0)
+    {
+        perror("waitpid");
+        return -1;
+    }
+
+    if (WEXITSTATUS(status) == 0 || WEXITSTATUS(status) == 1)
+    {
+        printf("trapping_child: child appears to not have trapped, got status %i\n", WEXITSTATUS(status));
+        return -1;
+    }
+
+    return 0;
+}
+
+int subprocess_trap(int fd)
+{
+    if (write(fd, "hello", 5) < 0)
+    {
+        perror("write");
+        return 1;
+    }
+
+    // A bad function pointer is guaranteed to trap one way or another
+    void (*f)(void) = (void (*)(void))0x12345678;
+    f();
+
+    return 1;
+}
+
+int trap_before_exec()
+{
+    int pipefd[2];
+    if (pipe(pipefd) != 0)
+    {
+        perror("pipe");
+        return -1;
+    }
+
+    int pid = vfork();
+
+    if (pid == 0)
+    {
+        if (write(pipefd[1], "hello", 5) < 0)
+        {
+            perror("write");
+            return 1;
+        }
+
+        // A bad function pointer is guaranteed to trap one way or another
+        void (*f)(void) = (void (*)(void))0x12345678;
+        f();
+
+        return 100;
+    }
+
+    close(pipefd[1]);
+
+    char buf[6];
+    int r = read(pipefd[0], buf, 5);
+    if (r < 0)
+    {
+        perror("read");
+        return -1;
+    }
+
+    buf[r] = 0;
+    if (strcmp(buf, "hello"))
+    {
+        printf("trap_before_exec: Expected 'hello', got %s\n", buf);
+        return -1;
+    }
+
+    r = read(pipefd[0], buf, 5);
+    if (r != 0)
+    {
+        printf("trap_before_exec: Expected pipe to be closed after first read\n");
+        return -1;
+    }
+
+    int status;
+    if (waitpid(pid, &status, 0) < 0)
+    {
+        perror("waitpid");
+        return -1;
+    }
+
+    if (WEXITSTATUS(status) == 0 || WEXITSTATUS(status) == 1)
+    {
+        printf("trap_before_exec: child appears to not have trapped, got status %i\n", WEXITSTATUS(status));
+        return -1;
+    }
+
+    return 0;
+}
+
+int exit_before_exec()
+{
+    int pipefd[2];
+    if (pipe(pipefd) != 0)
+    {
+        perror("pipe");
+        return -1;
+    }
+
+    int pid = vfork();
+
+    if (pid == 0)
+    {
+        if (write(pipefd[1], "hello", 5) < 0)
+        {
+            perror("write");
+            return 1;
+        }
+
+        return 60;
+    }
+
+    close(pipefd[1]);
+
+    char buf[6];
+    int r = read(pipefd[0], buf, 5);
+    if (r < 0)
+    {
+        perror("read");
+        return -1;
+    }
+
+    buf[r] = 0;
+    if (strcmp(buf, "hello"))
+    {
+        printf("exit_before_exec: Expected 'hello', got %s\n", buf);
+        return -1;
+    }
+
+    r = read(pipefd[0], buf, 5);
+    if (r != 0)
+    {
+        printf("exit_before_exec: Expected pipe to be closed after first read\n");
+        return -1;
+    }
+
+    int status;
+    if (waitpid(pid, &status, 0) < 0)
+    {
+        perror("waitpid");
+        return -1;
+    }
+
+    if (WEXITSTATUS(status) != 60)
+    {
+        printf("exiting_child: expected child to exit with 60, got status %i\n", WEXITSTATUS(status));
+        return -1;
+    }
+
+    return 0;
+}
+
+int main(int argc, char **argv)
+{
+    if (argc < 2)
+    {
+        return -1;
+    }
+
+    if (!strcmp(argv[1], "successful_exec"))
+    {
+        return successful_exec();
+    }
+    if (!strcmp(argv[1], "successful_execlp"))
+    {
+        return successful_execlp();
+    }
+    else if (!strcmp(argv[1], "subprocess"))
+    {
+        return subprocess();
+    }
+    else if (!strcmp(argv[1], "failing_exec"))
+    {
+        return failing_exec();
+    }
+    else if (!strcmp(argv[1], "cloexec"))
+    {
+        return cloexec();
+    }
+    else if (!strcmp(argv[1], "exiting_child"))
+    {
+        return exiting_child();
+    }
+    else if (!strcmp(argv[1], "subprocess_exit"))
+    {
+        return subprocess_exit(atoi(argv[2]));
+    }
+    else if (!strcmp(argv[1], "trapping_child"))
+    {
+        return trapping_child();
+    }
+    else if (!strcmp(argv[1], "subprocess_trap"))
+    {
+        return subprocess_trap(atoi(argv[2]));
+    }
+    else if (!strcmp(argv[1], "trap_before_exec"))
+    {
+        return trap_before_exec();
+    }
+    else if (!strcmp(argv[1], "exit_before_exec"))
+    {
+        return exit_before_exec();
+    }
+    else
+    {
+        printf("bad command %s\n", argv[1]);
+        return 1;
+    }
+}
diff --git a/tests/wasix/vfork/run.sh b/tests/wasix/vfork/run.sh
new file mode 100755
index 0000000000..255e32b87a
--- /dev/null
+++ b/tests/wasix/vfork/run.sh
@@ -0,0 +1,13 @@
+set -e
+
+echo ""
+echo "Note: runtime errors reported from wasmer for this test are expected"
+
+$WASMER -q run main.wasm --dir . -- successful_exec
+$WASMER -q run main.wasm --dir . -- successful_execlp
+$WASMER -q run main.wasm --dir . -- failing_exec
+$WASMER -q run main.wasm --dir . -- cloexec
+$WASMER -q run main.wasm --dir . -- exiting_child
+$WASMER -q run main.wasm --dir . -- trapping_child
+$WASMER -q run main.wasm --dir . -- exit_before_exec
+$WASMER -q run main.wasm --dir . -- trap_before_exec
diff --git a/tests/wasmer-argus/Cargo.toml b/tests/wasmer-argus/Cargo.toml
index 39bddde419..2ec6672242 100644
--- a/tests/wasmer-argus/Cargo.toml
+++ b/tests/wasmer-argus/Cargo.toml
@@ -13,22 +13,22 @@ wasmer_lib = ["dep:wasmer"]
 
 [dependencies]
 indicatif = "0.17.8"
-anyhow = "1.0.80"
-log = "0.4.21"
+anyhow.workspace = true
+log.workspace = true
 cynic = "3.4.3"
-url = "2.5.0"
+url.workspace = true
 futures = "0.3.30"
-tracing = "0.1.40"
-tokio = { version = "1.36.0", features = ["rt-multi-thread", "sync", "time", "fs"] }
+tokio = { workspace = true, features = ["rt", "macros", "rt-multi-thread", "sync", "time", "fs"] }
 clap = {version = "4.4.11", features = ["derive", "string"]}
-tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
-serde = { version = "1.0.197", features = ["derive"] }
-serde_json = "1.0.114"
-wasmer = { version = "4.3.7", path = "../../lib/api", features = ["engine", "core", "singlepass", "cranelift", "llvm"], optional = true }
-derive_more = "0.99.17"
+tracing.workspace = true
+tracing-subscriber = { workspace = true, features = ["env-filter"] }
+serde.workspace = true
+serde_json.workspace = true
+wasmer = { version = "6.1.0", path = "../../lib/api", features = ["core", "singlepass", "cranelift", "llvm"], optional = true }
+derive_more.workspace = true
 webc.workspace = true
-async-trait = "0.1.77"
-wasmer-api = { path = "../../lib/backend-api" }
+async-trait = { workspace = true }
+wasmer-backend-api = { path = "../../lib/backend-api" }
 shared-buffer.workspace = true
 
 
diff --git a/tests/wasmer-argus/src/argus/config.rs b/tests/wasmer-argus/src/argus/config.rs
index 92c7bbdca4..723e8b65ad 100644
--- a/tests/wasmer-argus/src/argus/config.rs
+++ b/tests/wasmer-argus/src/argus/config.rs
@@ -57,7 +57,7 @@ pub struct ArgusConfig {
     #[arg(long)]
     pub cli_path: Option<String>,
 
-    /// Whether or not this run should use the linked [`wasmer-api`] library instead of the CLI.
+    /// Whether or not this run should use the linked [`wasmer-backend-api`] library instead of the CLI.
     #[cfg(feature = "wasmer_lib")]
     #[arg(long, conflicts_with = "cli_path")]
     pub use_lib: bool,
diff --git a/tests/wasmer-argus/src/argus/mod.rs b/tests/wasmer-argus/src/argus/mod.rs
index 6326073059..8abf31d29f 100644
--- a/tests/wasmer-argus/src/argus/mod.rs
+++ b/tests/wasmer-argus/src/argus/mod.rs
@@ -16,7 +16,7 @@ use tokio::{
 };
 use tracing::*;
 use url::Url;
-use wasmer_api::{types::PackageVersionWithPackage, WasmerClient};
+use wasmer_backend_api::{types::PackageVersionWithPackage, WasmerClient};
 
 #[derive(Debug, Clone)]
 pub struct Argus {
@@ -156,12 +156,11 @@ impl Argus {
             }
         };
 
-        p.set_message(format!("[{test_id}] testing package {package_name}",));
+        p.set_message(format!("[{test_id}] testing package {package_name}"));
 
         let path = Argus::get_path(config.clone(), package).await;
         p.set_message(format!(
-            "testing package {package_name} -- path to download to is: {:?}",
-            path
+            "testing package {package_name} -- path to download to is: {path:?}",
         ));
 
         #[cfg(not(feature = "wasmer_lib"))]
diff --git a/tests/wasmer-argus/src/argus/packages.rs b/tests/wasmer-argus/src/argus/packages.rs
index d55dc03a0f..798a106746 100644
--- a/tests/wasmer-argus/src/argus/packages.rs
+++ b/tests/wasmer-argus/src/argus/packages.rs
@@ -11,7 +11,7 @@ use tokio::{
 };
 use tracing::*;
 use url::Url;
-use wasmer_api::{
+use wasmer_backend_api::{
     query::get_package_versions_stream,
     types::{AllPackageVersionsVars, PackageVersionSortBy, PackageVersionWithPackage},
 };
@@ -101,7 +101,7 @@ impl Argus {
     ) -> anyhow::Result<()> {
         info!("downloading package from {} to file {:?}", url, path);
         static APP_USER_AGENT: &str =
-            concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"),);
+            concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"));
 
         let mut dir_path = path.clone();
         dir_path.pop();
diff --git a/tests/wasmer-argus/src/argus/tester/cli_tester.rs b/tests/wasmer-argus/src/argus/tester/cli_tester.rs
index 548a844160..edf9373244 100644
--- a/tests/wasmer-argus/src/argus/tester/cli_tester.rs
+++ b/tests/wasmer-argus/src/argus/tester/cli_tester.rs
@@ -3,7 +3,7 @@ use indicatif::ProgressBar;
 use std::{fs::File, io::BufReader, path::Path, process::Command, sync::Arc};
 use tokio::time::{self, Instant};
 use tracing::*;
-use wasmer_api::types::PackageVersionWithPackage;
+use wasmer_backend_api::types::PackageVersionWithPackage;
 use webc::{v2::read::OwnedReader, v3::read::OwnedReader as OwnedReaderV3, Container, Version};
 
 use super::{TestReport, Tester};
@@ -55,33 +55,33 @@ impl<'a> CLIRunner<'a> {
             Backend::Cranelift => "--cranelift",
         };
 
-        Ok(
-            match std::panic::catch_unwind(move || {
-                let mut cmd = Command::new(cli_path);
+        let res = std::panic::catch_unwind(move || {
+            let mut cmd = Command::new(cli_path);
 
-                let cmd = cmd.args([
-                    "compile",
-                    atom_path.to_str().unwrap(),
-                    backend,
-                    "-o",
-                    output_path.to_str().unwrap(),
-                ]);
+            let cmd = cmd.args([
+                "compile",
+                atom_path.to_str().unwrap(),
+                backend,
+                "-o",
+                output_path.to_str().unwrap(),
+            ]);
 
-                info!("running cmd: {:?}", cmd);
+            info!("running cmd: {:?}", cmd);
 
-                let out = cmd.output();
+            let out = cmd.output();
 
-                info!("run cmd that gave result: {:#?}", out);
+            info!("run cmd that gave result: {:#?}", out);
 
-                out
-            }) {
-                Ok(r) => match r {
-                    Ok(_) => Ok(()),
-                    Err(e) => Err(e.to_string()),
-                },
-                Err(_) => Err(String::from("thread panicked")),
+            out
+        });
+
+        Ok(match res {
+            Ok(r) => match r {
+                Ok(_) => Ok(()),
+                Err(e) => Err(e.to_string()),
             },
-        )
+            Err(_) => Err(String::from("thread panicked")),
+        })
     }
 
     fn ok(&self, version: String, start_time: Instant) -> anyhow::Result<TestReport> {
@@ -143,7 +143,7 @@ impl<'a> CLIRunner<'a> {
 }
 
 #[async_trait::async_trait]
-impl<'a> Tester for CLIRunner<'a> {
+impl Tester for CLIRunner<'_> {
     async fn run_test(&self) -> anyhow::Result<TestReport> {
         let start_time = time::Instant::now();
         let version = self.get_version().await?;
@@ -157,7 +157,7 @@ impl<'a> Tester for CLIRunner<'a> {
         let webc_v2_path = dir_path.join("package_v2.webc");
 
         self.p
-            .set_message(format!("unpacking webc at {:?}", webc_v2_path));
+            .set_message(format!("unpacking webc at {webc_v2_path:?}"));
 
         let v2_bytes = std::fs::read(&webc_v2_path)?;
 
@@ -182,7 +182,7 @@ impl<'a> Tester for CLIRunner<'a> {
         let webc_v3_path = dir_path.join("package_v3.webc");
 
         self.p
-            .set_message(format!("unpacking webc at {:?}", webc_v3_path));
+            .set_message(format!("unpacking webc at {webc_v3_path:?}"));
 
         let v3_bytes = std::fs::read(&webc_v3_path)?;
 
diff --git a/tests/wasmer-argus/src/argus/tester/lib_tester.rs b/tests/wasmer-argus/src/argus/tester/lib_tester.rs
index 8d27bd290e..d44b692980 100644
--- a/tests/wasmer-argus/src/argus/tester/lib_tester.rs
+++ b/tests/wasmer-argus/src/argus/tester/lib_tester.rs
@@ -5,7 +5,7 @@ use std::{fs::File, io::BufReader, sync::Arc};
 use tokio::time;
 use tracing::*;
 use wasmer::{sys::Features, Engine, NativeEngineExt, Target};
-use wasmer_api::types::PackageVersionWithPackage;
+use wasmer_backend_api::types::PackageVersionWithPackage;
 use webc::{v2::read::OwnedReader, v3::read::OwnedReader as OwnedReaderV3, Container, Version};
 
 pub struct LibRunner<'a> {
diff --git a/tests/wasmer-argus/src/argus/tester/mod.rs b/tests/wasmer-argus/src/argus/tester/mod.rs
index ea75446d06..8b8887f148 100644
--- a/tests/wasmer-argus/src/argus/tester/mod.rs
+++ b/tests/wasmer-argus/src/argus/tester/mod.rs
@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 use std::{sync::Arc, time::Duration};
-use wasmer_api::types::PackageVersionWithPackage;
+use wasmer_backend_api::types::PackageVersionWithPackage;
 
 use super::ArgusConfig;
 
diff --git a/tests/wast/spec/align.wast b/tests/wast/spec/align.wast
index 93064649d3..7753df8deb 100644
--- a/tests/wast/spec/align.wast
+++ b/tests/wast/spec/align.wast
@@ -864,3 +864,120 @@
 (assert_trap (invoke "store" (i32.const 65532) (i64.const -1)) "out of bounds memory access")
 ;; No memory was changed
 (assert_return (invoke "load" (i32.const 65532)) (i32.const 0))
+
+;; Test invalid alignment values that may cause overflow when parsed.
+;; These use the binary format, because it stores alignment as a base-2 exponent.
+
+;; Signed 32-bit overflow
+(assert_invalid
+  (module binary 
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section: 1 type
+    "\03\02\01\00"             ;; Function section: 1 function
+    "\05\03\01\00\01"          ;; Memory section: 1 memory
+    "\0a\0a\01"                ;; Code section: 1 function
+
+    ;; function 0
+    "\08\00"
+    "\41\00"                   ;; i32.const 0
+    "\28\1f\00"                ;; i32.load offset=0 align=2**31
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "alignment must not be larger than natural"
+)
+
+;; Unsigned 32-bit overflow
+(assert_malformed
+  (module binary 
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section: 1 type
+    "\03\02\01\00"             ;; Function section: 1 function
+    "\05\03\01\00\01"          ;; Memory section: 1 memory
+    "\0a\0a\01"                ;; Code section: 1 function
+
+    ;; function 0
+    "\08\00"
+    "\41\00"                   ;; i32.const 0
+    "\28\20\00"                ;; i32.load offset=0 align=2**32
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "malformed memop flags"
+)
+
+;; 32-bit out of range
+(assert_malformed
+  (module binary 
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section: 1 type
+    "\03\02\01\00"             ;; Function section: 1 function
+    "\05\03\01\00\01"          ;; Memory section: 1 memory
+    "\0a\0a\01"                ;; Code section: 1 function
+
+    ;; function 0
+    "\08\00"
+    "\41\00"                   ;; i32.const 0
+    "\28\21\00"                ;; i32.load offset=0 align=2**33
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "malformed memop flags"
+)
+
+;; Signed 64-bit overflow
+(assert_malformed
+  (module binary 
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section: 1 type
+    "\03\02\01\00"             ;; Function section: 1 function
+    "\05\03\01\00\01"          ;; Memory section: 1 memory
+    "\0a\0a\01"                ;; Code section: 1 function
+
+    ;; function 0
+    "\08\00"
+    "\41\00"                   ;; i32.const 0
+    "\28\3f\00"                ;; i32.load offset=0 align=2**63
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "malformed memop flags"
+)
+
+;; Unsigned 64-bit overflow
+(assert_malformed
+  (module binary 
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section: 1 type
+    "\03\02\01\00"             ;; Function section: 1 function
+    "\05\03\01\00\01"          ;; Memory section: 1 memory
+    "\0a\0a\01"                ;; Code section: 1 function
+
+    ;; function 0
+    "\08\00"
+    "\41\00"                   ;; i32.const 0
+    "\28\40\00"                ;; i32.load offset=0 align=2**64
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "malformed memop flags"
+)
+
+;; 64-bit out of range
+(assert_malformed
+  (module binary 
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section: 1 type
+    "\03\02\01\00"             ;; Function section: 1 function
+    "\05\03\01\00\01"          ;; Memory section: 1 memory
+    "\0a\0a\01"                ;; Code section: 1 function
+
+    ;; function 0
+    "\08\00"
+    "\41\00"                   ;; i32.const 0
+    "\28\41\00"                ;; i32.load offset=0 align=2**65
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "malformed memop flags"
+)
diff --git a/tests/wast/spec/binary-leb128.wast b/tests/wast/spec/binary-leb128.wast
index 1d67219583..335496f08e 100644
--- a/tests/wast/spec/binary-leb128.wast
+++ b/tests/wast/spec/binary-leb128.wast
@@ -290,7 +290,7 @@
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
-    "\01\08\01"                          ;; type section
+    "\01\0c\01"                          ;; type section
     "\60"                                ;; func type
     "\02"                                ;; num params
     "\7f\7e"                             ;; param type
@@ -404,19 +404,19 @@
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\11\01"                ;; Code section
+    "\01\04\01\60\00\00"                 ;; Type section
+    "\03\02\01\00"                       ;; Function section
+    "\05\03\01\00\01"                    ;; Memory section
+    "\0a\11\01"                          ;; Code section
     ;; function 0
-    "\0f\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\28"                      ;; i32.load
-    "\02"                      ;; alignment 2
-    "\82\80\80\80\80\00"       ;; offset 2 with one byte too many
-    "\1a"                      ;; drop
-    "\0b"                      ;; end
+    "\0f\01\01"                          ;; local type count
+    "\7f"                                ;; i32
+    "\41\00"                             ;; i32.const 0
+    "\28"                                ;; i32.load
+    "\02"                                ;; alignment 2
+    "\82\80\80\80\80\80\80\80\80\80\00"  ;; offset 2 with one byte too many
+    "\1a"                                ;; drop
+    "\0b"                                ;; end
   )
   "integer representation too long"
 )
@@ -461,19 +461,19 @@
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\12\01"                ;; Code section
+    "\01\04\01\60\00\00"                 ;; Type section
+    "\03\02\01\00"                       ;; Function section
+    "\05\03\01\00\01"                    ;; Memory section
+    "\0a\12\01"                          ;; Code section
     ;; function 0
-    "\10\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\41\03"                   ;; i32.const 3
-    "\36"                      ;; i32.store
-    "\02"                      ;; alignment 2
-    "\82\80\80\80\80\00"       ;; offset 2 with one byte too many
-    "\0b"                      ;; end
+    "\10\01\01"                          ;; local type count
+    "\7f"                                ;; i32
+    "\41\00"                             ;; i32.const 0
+    "\41\03"                             ;; i32.const 3
+    "\36"                                ;; i32.store
+    "\02"                                ;; alignment 2
+    "\82\80\80\80\80\80\80\80\80\80\00"  ;; offset 2 with one byte too many
+    "\0b"                                ;; end
   )
   "integer representation too long"
 )
@@ -730,40 +730,42 @@
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\10\01"                ;; Code section
+    "\01\04\01\60\00\00"              ;; Type section
+    "\03\02\01\00"                    ;; Function section
+    "\05\03\01\00\01"                 ;; Memory section
+    "\0a\10\01"                       ;; Code section
     ;; function 0
-    "\0e\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\28"                      ;; i32.load
-    "\02"                      ;; alignment 2
-    "\82\80\80\80\10"          ;; offset 2 with unused bits set
-    "\1a"                      ;; drop
-    "\0b"                      ;; end
+    "\0e\01\01"                       ;; local type count
+    "\7f"                             ;; i32
+    "\41\00"                          ;; i32.const 0
+    "\28"                             ;; i32.load
+    "\02"                             ;; alignment 2
+    "\82\80\80\80\80\80\80\80\80\10"  ;; offset 2 with unused bits set
+    "\1a"                             ;; drop
+    "\0b"                             ;; end
   )
-  "integer too large"
+  ;; TODO: This changes to "integer too large" with memory64.
+  "integer representation too long"
 )
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\10\01"                ;; Code section
+    "\01\04\01\60\00\00"              ;; Type section
+    "\03\02\01\00"                    ;; Function section
+    "\05\03\01\00\01"                 ;; Memory section
+    "\0a\10\01"                       ;; Code section
     ;; function 0
-    "\0e\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\28"                      ;; i32.load
-    "\02"                      ;; alignment 2
-    "\82\80\80\80\40"          ;; offset 2 with some unused bits set
-    "\1a"                      ;; drop
-    "\0b"                      ;; end
+    "\0e\01\01"                       ;; local type count
+    "\7f"                             ;; i32
+    "\41\00"                          ;; i32.const 0
+    "\28"                             ;; i32.load
+    "\02"                             ;; alignment 2
+    "\82\80\80\80\80\80\80\80\80\40"  ;; offset 2 with some unused bits set
+    "\1a"                             ;; drop
+    "\0b"                             ;; end
   )
-  "integer too large"
+  ;; TODO: This changes to "integer too large" with memory64.
+  "integer representation too long"
 )
 (assert_malformed
   (module binary
@@ -843,41 +845,42 @@
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\11\01"                ;; Code section
+    "\01\04\01\60\00\00"              ;; Type section
+    "\03\02\01\00"                    ;; Function section
+    "\05\03\01\00\01"                 ;; Memory section
+    "\0a\11\01"                       ;; Code section
     ;; function 0
-    "\0f\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\41\03"                   ;; i32.const 3
-    "\36"                      ;; i32.store
-    "\02"                      ;; alignment 2
-    "\82\80\80\80\10"          ;; offset 2 with unused bits set
-    "\0b"                      ;; end
+    "\0f\01\01"                       ;; local type count
+    "\7f"                             ;; i32
+    "\41\00"                          ;; i32.const 0
+    "\41\03"                          ;; i32.const 3
+    "\36"                             ;; i32.store
+    "\02"                             ;; alignment 2
+    "\82\80\80\80\80\80\80\80\80\10"  ;; offset 2 with unused bits set
+    "\0b"                             ;; end
   )
-  "integer too large"
+  ;; TODO: This changes to "integer too large" with memory64.
+  "integer representation too long"
 )
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\11\01"                ;; Code section
-
+    "\01\04\01\60\00\00"              ;; Type section
+    "\03\02\01\00"                    ;; Function section
+    "\05\03\01\00\01"                 ;; Memory section
+    "\0a\11\01"                       ;; Code section
     ;; function 0
-    "\0f\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\41\03"                   ;; i32.const 3
-    "\36"                      ;; i32.store
-    "\02"                      ;; alignment 2
-    "\82\80\80\80\40"          ;; offset 2 with some unused bits set
-    "\0b"                      ;; end
+    "\0f\01\01"                       ;; local type count
+    "\7f"                             ;; i32
+    "\41\00"                          ;; i32.const 0
+    "\41\03"                          ;; i32.const 3
+    "\36"                             ;; i32.store
+    "\02"                             ;; alignment 2
+    "\82\80\80\80\80\80\80\80\80\40"  ;; offset 2 with some unused bits set
+    "\0b"                             ;; end
   )
-  "integer too large"
+  ;; TODO: This changes to "integer too large" with memory64.
+  "integer representation too long"
 )
 
 ;; Signed LEB128s sign-extend
@@ -963,7 +966,6 @@
   "integer too large"
 )
 
-
 (module binary
   "\00asm" "\01\00\00\00"
   "\01\04\01"                          ;; type section
@@ -1000,3 +1002,81 @@
   )
   "integer representation too long"
 )
+
+;; Data segment tags and memory index can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\03\01"                          ;; Memory section with 1 entry
+  "\00\00"                             ;; no max, minimum 0
+  "\0b\07\01"                          ;; Data section with 1 entry
+  "\80\00"                             ;; Active segment, encoded with 2 bytes
+  "\41\00\0b\00"                       ;; (i32.const 0) with contents ""
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\03\01"                          ;; Memory section with 1 entry
+  "\00\00"                             ;; no max, minimum 0
+  "\0b\08\01"                          ;; Data section with 1 entry
+  "\82\00"                             ;; Active segment, encoded with 2 bytes
+  "\00"                                ;; explicit memory index
+  "\41\00\0b\00"                       ;; (i32.const 0) with contents ""
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\03\01"                          ;; Memory section with 1 entry
+  "\00\00"                             ;; no max, minimum 0
+  "\0b\09\01"                          ;; Data section with 1 entry
+  "\82\00"                             ;; Active segment, encoded with 2 bytes
+  "\80\00"                             ;; explicit memory index, encoded with 2 bytes
+  "\41\00\0b\00"                       ;; (i32.const 0) with contents ""
+)
+
+;; Element segment tags and table index can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\04\04\01"                          ;; Table section with 1 entry
+  "\70\00\00"                          ;; no max, minimum 0, funcref
+  "\09\07\01"                          ;; Element section with 1 entry
+  "\80\00"                             ;; Active segment
+  "\41\00\0b\00"                       ;; (i32.const 0) with no elements
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\04\04\01"                          ;; Table section with 1 entry
+  "\70\00\00"                          ;; no max, minimum 0, funcref
+  "\09\09\01"                          ;; Element section with 1 entry
+  "\02"                                ;; Active segment
+  "\80\00"                             ;; explicit table index, encoded with 2 bytes
+  "\41\00\0b\00\00"                    ;; (i32.const 0) with no elements
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\04\04\01"                          ;; Table section with 1 entry
+  "\70\00\00"                          ;; no max, minimum 0, funcref
+  "\09\09\01"                          ;; Element section with 1 entry
+  "\82\00"                             ;; Active segment, encoded with 2 bytes
+  "\00"                                ;; explicit table index
+  "\41\00\0b\00\00"                    ;; (i32.const 0) with no elements
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\04\04\01"                          ;; Table section with 1 entry
+  "\70\00\00"                          ;; no max, minimum 0, funcref
+  "\09\0a\01"                          ;; Element section with 1 entry
+  "\82\00"                             ;; Active segment, encoded with 2 bytes
+  "\80\00"                             ;; explicit table index, encoded with 2 bytes
+  "\41\00\0b\00\00"                    ;; (i32.const 0) with no elements
+)
+
+;; Type section with signed LEB128 encoded type
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01"                     ;; Type section id
+    "\05"                     ;; Type section length
+    "\01"                     ;; Types vector length
+    "\e0\7f"                  ;; Malformed functype, -0x20 in signed LEB128 encoding
+    "\00\00"
+  )
+  "integer representation too long"
+)
diff --git a/tests/wast/spec/binary.wast b/tests/wast/spec/binary.wast
index c6f975570b..7b8cec0b60 100644
--- a/tests/wast/spec/binary.wast
+++ b/tests/wast/spec/binary.wast
@@ -45,710 +45,80 @@
 (assert_malformed (module binary "\00asm\00\00\00\01") "unknown binary version")
 
 ;; Invalid section id.
-(assert_malformed (module binary "\00asm" "\01\00\00\00" "\0d\00") "malformed section id")
-(assert_malformed (module binary "\00asm" "\01\00\00\00" "\7f\00") "malformed section id")
-(assert_malformed (module binary "\00asm" "\01\00\00\00" "\80\00\01\00") "malformed section id")
-(assert_malformed (module binary "\00asm" "\01\00\00\00" "\81\00\01\00") "malformed section id")
-(assert_malformed (module binary "\00asm" "\01\00\00\00" "\ff\00\01\00") "malformed section id")
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\0e\01\00") "malformed section id")
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\7f\01\00") "malformed section id")
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\80\01\00\01\01\00") "malformed section id")
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\81\01\00\01\01\00") "malformed section id")
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\ff\01\00\01\01\00") "malformed section id")
 
-;; Unsigned LEB128 can have non-minimal length
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\05\04\01"                          ;; Memory section with 1 entry
-  "\00\82\00"                          ;; no max, minimum 2
-)
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\05\07\01"                          ;; Memory section with 1 entry
-  "\00\82\80\80\80\00"                 ;; no max, minimum 2
-)
-
-;; Signed LEB128 can have non-minimal length
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\06\07\01"                          ;; Global section with 1 entry
-  "\7f\00"                             ;; i32, immutable
-  "\41\80\00"                          ;; i32.const 0
-  "\0b"                                ;; end
-)
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\06\07\01"                          ;; Global section with 1 entry
-  "\7f\00"                             ;; i32, immutable
-  "\41\ff\7f"                          ;; i32.const -1
-  "\0b"                                ;; end
-)
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\06\0a\01"                          ;; Global section with 1 entry
-  "\7f\00"                             ;; i32, immutable
-  "\41\80\80\80\80\00"                 ;; i32.const 0
-  "\0b"                                ;; end
-)
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\06\0a\01"                          ;; Global section with 1 entry
-  "\7f\00"                             ;; i32, immutable
-  "\41\ff\ff\ff\ff\7f"                 ;; i32.const -1
-  "\0b"                                ;; end
-)
-
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\06\07\01"                          ;; Global section with 1 entry
-  "\7e\00"                             ;; i64, immutable
-  "\42\80\00"                          ;; i64.const 0 with unused bits set
-  "\0b"                                ;; end
-)
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\06\07\01"                          ;; Global section with 1 entry
-  "\7e\00"                             ;; i64, immutable
-  "\42\ff\7f"                          ;; i64.const -1 with unused bits unset
-  "\0b"                                ;; end
-)
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\06\0f\01"                          ;; Global section with 1 entry
-  "\7e\00"                             ;; i64, immutable
-  "\42\80\80\80\80\80\80\80\80\80\00"  ;; i64.const 0 with unused bits set
-  "\0b"                                ;; end
-)
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\06\0f\01"                          ;; Global section with 1 entry
-  "\7e\00"                             ;; i64, immutable
-  "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f"  ;; i64.const -1 with unused bits unset
-  "\0b"                                ;; end
-)
-
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\05\03\01"                          ;; Memory section with 1 entry
-  "\00\00"                             ;; no max, minimum 0
-  "\0b\06\01"                          ;; Data section with 1 entry
-  "\00"                                ;; Memory index 0
-  "\41\00\0b\00"                       ;; (i32.const 0) with contents ""
-)
-
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\04\04\01"                          ;; Table section with 1 entry
-  "\70\00\00"                          ;; no max, minimum 0, funcref
-  "\09\06\01"                          ;; Element section with 1 entry
-  "\00"                                ;; Table index 0
-  "\41\00\0b\00"                       ;; (i32.const 0) with no elements
-)
-
-;; Data segment memory index can have non-minimal length
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\05\03\01"                          ;; Memory section with 1 entry
-  "\00\00"                             ;; no max, minimum 0
-  "\0b\07\01"                          ;; Data section with 1 entry
-  "\80\00"                             ;; Memory index 0, encoded with 2 bytes
-  "\41\00\0b\00"                       ;; (i32.const 0) with contents ""
-)
-
-;; Element segment table index can have non-minimal length
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\04\04\01"                          ;; Table section with 1 entry
-  "\70\00\00"                          ;; no max, minimum 0, funcref
-  "\09\09\01"                          ;; Element section with 1 entry
-  "\02\80\00"                          ;; Table index 0, encoded with 2 bytes
-  "\41\00\0b\00\00"                    ;; (i32.const 0) with no elements
-)
-
-;; Type section with signed LEB128 encoded type
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01"                     ;; Type section id
-    "\05"                     ;; Type section length
-    "\01"                     ;; Types vector length
-    "\e0\7f"                  ;; Malformed functype, -0x20 in signed LEB128 encoding
-    "\00\00"
-  )
-  "integer representation too long"
-)
-
-;; Unsigned LEB128 must not be overlong
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\05\08\01"                          ;; Memory section with 1 entry
-    "\00\82\80\80\80\80\00"              ;; no max, minimum 2 with one byte too many
-  )
-  "integer representation too long"
-)
-
-;; Signed LEB128 must not be overlong
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0b\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\80\80\80\80\80\00"              ;; i32.const 0 with one byte too many
-    "\0b"                                ;; end
-  )
-  "integer representation too long"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0b\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\ff\ff\ff\ff\ff\7f"              ;; i32.const -1 with one byte too many
-    "\0b"                                ;; end
-  )
-  "integer representation too long"
-)
-
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\10\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\80\80\80\80\80\80\80\80\80\80\00"  ;; i64.const 0 with one byte too many
-    "\0b"                                ;; end
-  )
-  "integer representation too long"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\10\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f"  ;; i64.const -1 with one byte too many
-    "\0b"                                ;; end
-  )
-  "integer representation too long"
-)
-
-;; Unsigned LEB128s zero-extend
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\05\07\01"                          ;; Memory section with 1 entry
-    "\00\82\80\80\80\70"                 ;; no max, minimum 2 with unused bits set
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\05\07\01"                          ;; Memory section with 1 entry
-    "\00\82\80\80\80\40"                 ;; no max, minimum 2 with some unused bits set
-  )
-  "integer too large"
-)
-
-;; Signed LEB128s sign-extend
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0a\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\80\80\80\80\70"                 ;; i32.const 0 with unused bits set
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0a\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\ff\ff\ff\ff\0f"                 ;; i32.const -1 with unused bits unset
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0a\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\80\80\80\80\1f"                 ;; i32.const 0 with some unused bits set
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0a\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\ff\ff\ff\ff\4f"                 ;; i32.const -1 with some unused bits unset
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\80\80\80\80\80\80\80\80\80\7e"  ;; i64.const 0 with unused bits set
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01"  ;; i64.const -1 with unused bits unset
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\80\80\80\80\80\80\80\80\80\02"  ;; i64.const 0 with some unused bits set
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41"  ;; i64.const -1 with some unused bits unset
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\80\80\80\80\80\80\80\80\80\7e"  ;; i64.const 0 with unused bits set
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01"  ;; i64.const -1 with unused bits unset
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\80\80\80\80\80\80\80\80\80\02"  ;; i64.const 0 with some unused bits set
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41"  ;; i64.const -1 with some unused bits unset
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-
-
-;; Unsigned LEB128 must not be overlong
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\05\08\01"                          ;; Memory section with 1 entry
-    "\00\82\80\80\80\80\00"              ;; no max, minimum 2 with one byte too many
-  )
-  "integer representation too long"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\11\01"                ;; Code section
-    ;; function 0
-    "\0f\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\28"                      ;; i32.load
-    "\02"                      ;; alignment 2
-    "\82\80\80\80\80\00"       ;; offset 2 with one byte too many
-    "\1a"                      ;; drop
-    "\0b"                      ;; end
-  )
-  "integer representation too long"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\11\01"                ;; Code section
-    ;; function 0
-    "\0f\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\28"                      ;; i32.load
-    "\82\80\80\80\80\00"       ;; alignment 2 with one byte too many
-    "\00"                      ;; offset 0
-    "\1a"                      ;; drop
-    "\0b"                      ;; end
-  )
-  "integer representation too long"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\12\01"                ;; Code section
-    ;; function 0
-    "\10\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\41\03"                   ;; i32.const 3
-    "\36"                      ;; i32.store
-    "\82\80\80\80\80\00"       ;; alignment 2 with one byte too many
-    "\03"                      ;; offset 3
-    "\0b"                      ;; end
-  )
-  "integer representation too long"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\12\01"                ;; Code section
-    ;; function 0
-    "\10\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\41\03"                   ;; i32.const 3
-    "\36"                      ;; i32.store
-    "\02"                      ;; alignment 2
-    "\82\80\80\80\80\00"       ;; offset 2 with one byte too many
-    "\0b"                      ;; end
-  )
-  "integer representation too long"
-)
-
-;; Signed LEB128 must not be overlong
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0b\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\80\80\80\80\80\00"              ;; i32.const 0 with one byte too many
-    "\0b"                                ;; end
-  )
-  "integer representation too long"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0b\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\ff\ff\ff\ff\ff\7f"              ;; i32.const -1 with one byte too many
-    "\0b"                                ;; end
-  )
-  "integer representation too long"
-)
-
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\10\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\80\80\80\80\80\80\80\80\80\80\00"  ;; i64.const 0 with one byte too many
-    "\0b"                                ;; end
-  )
-  "integer representation too long"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\10\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f"  ;; i64.const -1 with one byte too many
-    "\0b"                                ;; end
-  )
-  "integer representation too long"
-)
-
-;; Unsigned LEB128s zero-extend
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\05\07\01"                          ;; Memory section with 1 entry
-    "\00\82\80\80\80\70"                 ;; no max, minimum 2 with unused bits set
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\05\07\01"                          ;; Memory section with 1 entry
-    "\00\82\80\80\80\40"                 ;; no max, minimum 2 with some unused bits set
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\10\01"                ;; Code section
-    ;; function 0
-    "\0e\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\28"                      ;; i32.load
-    "\02"                      ;; alignment 2
-    "\82\80\80\80\10"          ;; offset 2 with unused bits set
-    "\1a"                      ;; drop
-    "\0b"                      ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\10\01"                ;; Code section
-    ;; function 0
-    "\0e\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\28"                      ;; i32.load
-    "\02"                      ;; alignment 2
-    "\82\80\80\80\40"          ;; offset 2 with some unused bits set
-    "\1a"                      ;; drop
-    "\0b"                      ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\10\01"                ;; Code section
-    "\0e\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\28"                      ;; i32.load
-    "\82\80\80\80\10"          ;; alignment 2 with unused bits set
-    "\00"                      ;; offset 0
-    "\1a"                      ;; drop
-    "\0b"                      ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\10\01"                ;; Code section
-    ;; function 0
-    "\0e\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\28"                      ;; i32.load
-    "\82\80\80\80\40"          ;; alignment 2 with some unused bits set
-    "\00"                      ;; offset 0
-    "\1a"                      ;; drop
-    "\0b"                      ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\11\01"                ;; Code section
-    ;; function 0
-    "\0f\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\41\03"                   ;; i32.const 3
-    "\36"                      ;; i32.store
-    "\82\80\80\80\10"          ;; alignment 2 with unused bits set
-    "\03"                      ;; offset 3
-    "\0b"                      ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\11\01"                ;; Code section
-    ;; function 0
-    "\0f\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\41\03"                   ;; i32.const 3
-    "\36"                      ;; i32.store
-    "\82\80\80\80\40"          ;; alignment 2 with some unused bits set
-    "\03"                      ;; offset 3
-    "\0b"                      ;; end
-  )
-  "integer too large"
-)
+;; Function with missing end marker (between two functions)
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\11\01"                ;; Code section
+    "\01\04\01\60\00\00"       ;; Type section: 1 type
+    "\03\03\02\00\00"          ;; Function section: 2 functions
+    "\0a\0c\02"                ;; Code section: 2 functions
     ;; function 0
-    "\0f\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\41\03"                   ;; i32.const 3
-    "\36"                      ;; i32.store
-    "\02"                      ;; alignment 2
-    "\82\80\80\80\10"          ;; offset 2 with unused bits set
+    "\04\00"                   ;; Function size and local type count
+    "\41\01"                   ;; i32.const 1
+    "\1a"                      ;; drop
+    ;; Missing end marker here
+    ;; function 1
+    "\05\00"                   ;; Function size and local type count
+    "\41\01"                   ;; i32.const 1
+    "\1a"                      ;; drop
     "\0b"                      ;; end
   )
-  "integer too large"
+  "END opcode expected"
 )
+
+;; Function with missing end marker (at EOF)
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\11\01"                ;; Code section
-
+    "\01\04\01\60\00\00"       ;; Type section: 1 type
+    "\03\02\01\00"             ;; Function section: 1 function
+    "\0a\06\01"                ;; Code section: 1 function
     ;; function 0
-    "\0f\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\41\03"                   ;; i32.const 3
-    "\36"                      ;; i32.store
-    "\02"                      ;; alignment 2
-    "\82\80\80\80\40"          ;; offset 2 with some unused bits set
-    "\0b"                      ;; end
+    "\04\00"                   ;; Function size and local type count
+    "\41\01"                   ;; i32.const 1
+    "\1a"                      ;; drop
+    ;; Missing end marker here
   )
-  "integer too large"
+  "unexpected end of section or function"
 )
 
-;; Signed LEB128s sign-extend
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0a\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\80\80\80\80\70"                 ;; i32.const 0 with unused bits set
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0a\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\ff\ff\ff\ff\0f"                 ;; i32.const -1 with unused bits unset
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
+;; Function with missing end marker (at end of code sections)
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
-    "\06\0a\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\80\80\80\80\1f"                 ;; i32.const 0 with some unused bits set
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0a\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\ff\ff\ff\ff\4f"                 ;; i32.const -1 with some unused bits unset
-    "\0b"                                ;; end
+    "\01\04\01\60\00\00"       ;; Type section: 1 type
+    "\03\02\01\00"             ;; Function section: 1 function
+    "\0a\06\01"                ;; Code section: 1 function
+    ;; function 0
+    "\04\00"                   ;; Function size and local type count
+    "\41\01"                   ;; i32.const 1
+    "\1a"                      ;; drop
+    ;; Missing end marker here
+    "\0b\03\01\01\00"          ;; Data section
   )
-  "integer too large"
+  ;; The spec interpreter consumes the `\0b` (data section start) as an
+  ;; END instruction (also happens to be `\0b`) and reports the code section as
+  ;; being larger than declared.
+  "section size mismatch"
 )
 
+;; Init expression with missing end marker
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\80\80\80\80\80\80\80\80\80\7e"  ;; i64.const 0 with unused bits set
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01"  ;; i64.const -1 with unused bits unset
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\80\80\80\80\80\80\80\80\80\02"  ;; i64.const 0 with some unused bits set
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41"  ;; i64.const -1 with some unused bits unset
-    "\0b"                                ;; end
+    "\01\04\01\60\00\00"       ;; Type section: 1 type
+    "\03\02\01\00"             ;; Function section: 1 function
+    "\06\05\01\7f\00\41\00"    ;; Global section: 1 entry with missing end marker
+    ;; Missing end marker here
+    "\0a\04\01\02\00\0b"       ;; Code section: 1 function
   )
-  "integer too large"
+  "illegal opcode"
 )
 
 ;; memory.grow reserved byte equal to zero.
@@ -1079,27 +449,47 @@
   "\0a\01\00"  ;; Code section with 0 functions
 )
 
-;; Fewer passive segments than datacount
+;; Fewer passive segments than data count
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0c\01\03"                ;; Data count section with value 3
+    "\0b\05\02"                ;; Data section with two entries
+    "\01\00"                   ;; Passive data section
+    "\01\00"                   ;; Passive data section
+  )
+  "data count and data section have inconsistent lengths"
+)
+
+;; More passive segments than data count
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
-    "\0c\01\03"                   ;; Datacount section with value "3"
-    "\0b\05\02"                   ;; Data section with two entries
-    "\01\00"                      ;; Passive data section
-    "\01\00")                     ;; Passive data section
-  "data count and data section have inconsistent lengths")
+    "\0c\01\01"                ;; Data count section with value 1
+    "\0b\05\02"                ;; Data section with two entries
+    "\01\00"                   ;; Passive data section
+    "\01\00"                   ;; Passive data section
+  )
+  "data count and data section have inconsistent lengths"
+)
 
-;; More passive segments than datacount
+;; Non-zero data count section without data section
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
-    "\0c\01\01"                   ;; Datacount section with value "1"
-    "\0b\05\02"                   ;; Data section with two entries
-    "\01\00"                      ;; Passive data section
-    "\01\00")                     ;; Passive data section
-  "data count and data section have inconsistent lengths")
+    "\05\03\01\00\01"          ;; Memory section with one entry
+    "\0c\01\01"                ;; Data count section with value 1
+  )
+  "data count and data section have inconsistent lengths"
+)
 
-;; memory.init requires a datacount section
+;; Zero data count section without data section
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\0c\01\00"                  ;; Data count section with value 0
+)
+
+;; memory.init requires a data count section
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
@@ -1119,9 +509,10 @@
 
     "\0b\03\01\01\00"          ;; Data section
   )                            ;; end
-  "data count section required")
+  "data count section required"
+)
 
-;; data.drop requires a datacount section
+;; data.drop requires a data count section
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
@@ -1138,9 +529,10 @@
 
     "\0b\03\01\01\00"          ;; Data section
   )                            ;; end
-  "data count section required")
+  "data count section required"
+)
 
-;; passive element segment containing opcode other than ref.func or ref.null
+;; passive element segment containing illegal opcode
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
@@ -1157,14 +549,16 @@
     "\09\07\01"                ;; Element section with one segment
     "\05\70"                   ;; Passive, funcref
     "\01"                      ;; 1 element
-    "\d3\00\0b"                ;; bad opcode, index 0, end
+    "\f3\00\0b"                ;; bad opcode, index 0, end
 
     "\0a\04\01"                ;; Code section
 
     ;; function 0
     "\02\00"
-    "\0b")                     ;; end
-  "illegal opcode")
+    "\0b"                      ;; end
+  )
+  "illegal opcode"
+)
 
 ;; passive element segment containing type other than funcref
 (assert_malformed
@@ -1189,8 +583,10 @@
 
     ;; function 0
     "\02\00"
-    "\0b")                     ;; end
-  "malformed reference type")
+    "\0b"                      ;; end
+  )
+  "malformed reference type"
+)
 
 ;; passive element segment containing opcode ref.func
 (module binary
@@ -1214,7 +610,8 @@
 
   ;; function 0
   "\02\00"
-  "\0b")                     ;; end
+  "\0b"                      ;; end
+)
 
 ;; passive element segment containing opcode ref.null
 (module binary
@@ -1238,7 +635,8 @@
 
   ;; function 0
   "\02\00"
-  "\0b")                     ;; end
+  "\0b"                      ;; end
+)
 
 
 ;; Type count can be zero
@@ -1255,7 +653,7 @@
     "\60\00\00"                             ;; 1st type
     ;; "\60\00\00"                          ;; 2nd type (missed)
   )
-  "unexpected end of section or function"
+  "length out of bounds"
 )
 
 ;; 1 type declared, 2 given
@@ -1406,7 +804,7 @@
 (assert_malformed
   (module binary
       "\00asm" "\01\00\00\00"
-      "\05\03\01"                           ;; table section with one entry
+      "\04\03\01"                           ;; table section with one entry
       "\70"                                 ;; anyfunc
       "\02"                                 ;; malformed table limits flag
   )
@@ -1415,7 +813,7 @@
 (assert_malformed
   (module binary
       "\00asm" "\01\00\00\00"
-      "\05\04\01"                           ;; table section with one entry
+      "\04\04\01"                           ;; table section with one entry
       "\70"                                 ;; anyfunc
       "\02"                                 ;; malformed table limits flag
       "\00"                                 ;; dummy byte
@@ -1425,12 +823,12 @@
 (assert_malformed
   (module binary
       "\00asm" "\01\00\00\00"
-      "\05\06\01"                           ;; table section with one entry
+      "\04\06\01"                           ;; table section with one entry
       "\70"                                 ;; anyfunc
       "\81\00"                              ;; malformed table limits flag as LEB128
       "\00\00"                              ;; dummy bytes
   )
-  "integer too large"
+  "integer representation too long"
 )
 
 ;; Memory count can be zero
@@ -1544,7 +942,7 @@
     "\02\00\0b"                             ;; function body 0
     "\02\00\0b"                             ;; function body 1
   )
-  "unexpected end of section or function"
+  "length out of bounds"
 )
 
 ;; 1 export declared, 2 given
@@ -1606,7 +1004,7 @@
     "\03\02\01\00"                          ;; func section
     "\04\04\01"                             ;; table section
     "\70\00\01"                             ;; table 0
-    "\09\07\02"                             ;; elem with inconsistent segment count (2 declared, 1 given)
+    "\09\0a\02"                             ;; elem with inconsistent segment count (2 declared, 1 given)
     "\00\41\00\0b\01\00"                    ;; elem 0
     "\00\41\00"                             ;; elem 1 (partial)
     ;; "\0b\01\00"                          ;; elem 1 (missing part)
@@ -1715,10 +1113,21 @@
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
-    "\01\04\01"                             ;; type section
+    "\01\25\0c"                             ;; type section
     "\60\00\00"                             ;; type 0
+    "\60\00\00"                             ;; type 1
+    "\60\00\00"                             ;; type 2
+    "\60\00\00"                             ;; type 3
+    "\60\00\00"                             ;; type 4
+    "\60\00\00"                             ;; type 5
+    "\60\00\00"                             ;; type 6
+    "\60\00\00"                             ;; type 7
+    "\60\00\00"                             ;; type 8
+    "\60\00\00"                             ;; type 9
+    "\60\00\00"                             ;; type 10
+    "\60\00\00"                             ;; type 11
     "\03\02\01\00"                          ;; func section
-    "\0a\12\01"                             ;; code section
+    "\0a\13\01"                             ;; code section
     "\11\00"                                ;; func 0
     "\02\40"                                ;; block 0
     "\41\01"                                ;; condition of if 0
@@ -1727,8 +1136,9 @@
     "\0e\01"                                ;; br_table with inconsistent target count (1 declared, 2 given)
     "\00"                                   ;; break depth 0
     "\01"                                   ;; break depth 1
-    "\02"                                   ;; break depth for default
-    "\0b\0b\0b"                             ;; end
+    "\02"                                   ;; break depth for default, interpreted as a block
+    "\0b"                                   ;; end, interpreted as type 11 for the block
+    "\0b\0b"                                ;; end
   )
   "unexpected end"
 )
@@ -1760,5 +1170,232 @@
     "\02\00"
     "\0b"                      ;; end
   )
-  "junk after last section"
+  "unexpected content after last section"
+)
+
+;; Multiple function sections
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"           ;; Type section
+    "\03\02\01\00"                 ;; Function section with 1 function
+    "\03\02\01\00"                 ;; Function section with 1 function
+    "\0a\07\02\02\00\0b\02\00\0b"  ;; Code section with 2 empty functions
+  )
+  "unexpected content after last section"
 )
+
+;; Multiple code sections
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"           ;; Type section
+    "\03\03\02\00\00"              ;; Function section with 2 functions
+    "\0a\04\01\02\00\0b"           ;; Code section with 1 empty function
+    "\0a\04\01\02\00\0b"           ;; Code section with 1 empty function
+  )
+  "unexpected content after last section"
+)
+
+;; Multiple data count sections
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0c\01\01"                   ;; Data count section with value "1"
+    "\0c\01\01"                   ;; Data count section with value "1"
+  )
+  "unexpected content after last section"
+)
+
+;; Multiple data sections
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0b\01\00"                   ;; Data section with zero entries
+    "\0b\01\00"                   ;; Data section with zero entries
+  )
+  "unexpected content after last section"
+)
+
+;; Multiple global sections
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\01\00"                   ;; Global section with zero entries
+    "\06\01\00"                   ;; Global section with zero entries
+  )
+  "unexpected content after last section"
+)
+
+;; Multiple export sections
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\07\01\00"                   ;; Export section with zero entries
+    "\07\01\00"                   ;; Export section with zero entries
+  )
+  "unexpected content after last section"
+)
+
+;; Multiple table sections
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\04\01\00"                 ;; Table section with zero entries
+      "\04\01\00"                 ;; Table section with zero entries
+  )
+  "unexpected content after last section"
+)
+
+;; Multiple element sections
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\09\01\00"                 ;; Element section with zero entries
+      "\09\01\00"                 ;; Element section with zero entries
+  )
+  "unexpected content after last section"
+)
+
+;; Multiple import sections
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\02\01\00"                 ;; Import section with zero entries
+      "\02\01\00"                 ;; Import section with zero entries
+  )
+  "unexpected content after last section"
+)
+
+;; Multiple type sections
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\01\00"                   ;; Type section with zero entries
+    "\01\01\00"                   ;; Type section with zero entries
+  )
+  "unexpected content after last section"
+)
+
+;; Multiple memory sections
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\01\00"                   ;; Memory section with zero entries
+    "\05\01\00"                   ;; Memory section with zero entries
+  )
+  "unexpected content after last section"
+)
+
+;; Type section out of order
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\02\01\00"                 ;; Import section with zero entries
+      "\01\01\00"                 ;; Type section with zero entries
+  )
+  "unexpected content after last section"
+)
+
+;; Import section out of order
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\03\01\00"                 ;; Function section with zero entries
+      "\02\01\00"                 ;; Import section with zero entries
+  )
+  "unexpected content after last section"
+)
+
+;; Function section out of order
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\04\01\00"                 ;; Table section with zero entries
+      "\03\01\00"                 ;; Function section with zero entries
+  )
+  "unexpected content after last section"
+)
+
+;; Table section out of order
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\05\01\00"                 ;; Memory section with zero entries
+      "\04\01\00"                 ;; Table section with zero entries
+  )
+  "unexpected content after last section"
+)
+
+;; Memory section out of order
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\06\01\00"                 ;; Global section with zero entries
+      "\05\01\00"                 ;; Memory section with zero entries
+  )
+  "unexpected content after last section"
+)
+
+;; Global section out of order
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\07\01\00"                 ;; Export section with zero entries
+      "\06\01\00"                 ;; Global section with zero entries
+  )
+  "unexpected content after last section"
+)
+
+;; Export section out of order
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\03\02\01\00"              ;; Function section
+      "\08\01\00"                 ;; Start section: function 0
+      "\07\01\00"                 ;; Export section with zero entries
+  )
+  "unexpected content after last section"
+)
+
+;; Start section out of order
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\03\02\01\00"              ;; Function section
+      "\09\01\00"                 ;; Element section with zero entries
+      "\08\01\00"                 ;; Start section: function 0
+  )
+  "unexpected content after last section"
+)
+
+;; Element section out of order
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\0c\01\01"                 ;; Data count section with value "1"
+      "\09\01\00"                 ;; Element section with zero entries
+  )
+  "unexpected content after last section"
+)
+
+;; Data count section out of order
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\0a\01\00"                 ;; Code section with zero entries
+      "\0c\01\01"                 ;; Data count section with value "1"
+  )
+  "unexpected content after last section"
+)
+
+;; Code section out of order
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\0b\01\00"                 ;; Data section with zero entries
+      "\0a\01\00"                 ;; Code section with zero entries
+  )
+  "unexpected content after last section"
+)
+
diff --git a/tests/wast/spec/br_table.wast b/tests/wast/spec/br_table.wast
index b70c102da0..3fc533d56e 100644
--- a/tests/wast/spec/br_table.wast
+++ b/tests/wast/spec/br_table.wast
@@ -583,255 +583,6 @@
           0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
           0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
           0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
           (local.get 0)
         )
         (return (i32.const -1))
@@ -1251,19 +1002,6 @@
     )
   )
 
-  ;; commenting this part out for now as it's a bit odd and we rely on wasmparser for
-  ;; wasm validation. Not meeting this requirement is okay for now
-  ;; (func (export "meet-bottom")
-  ;;   (block (result f64)
-  ;;     (block (result f32)
-  ;;       (unreachable)
-  ;;       (br_table 0 1 1 (i32.const 1))
-  ;;     )
-  ;;     (drop)
-  ;;     (f64.const 0)
-  ;;   )
-  ;;   (drop)
-  ;; )
 )
 
 (assert_return (invoke "type-i32"))
@@ -1614,20 +1352,6 @@
 )
 
 
-(assert_invalid
-  (module (func $meet-bottom (param i32) (result externref)
-    (block $l1 (result externref)
-      (drop
-        (block $l2 (result i32)
-          (br_table $l2 $l1 $l2 (ref.null extern) (local.get 0))
-        )
-      )
-      (ref.null extern)
-    )
-  ))
-  "type mismatch"
-)
-
 (assert_invalid
   (module (func $unbound-label
     (block (br_table 2 1 (i32.const 1)))
diff --git a/tests/wast/spec/call_indirect.wast b/tests/wast/spec/call_indirect.wast
index 1ecd9b7baf..74b5e8d2e8 100644
--- a/tests/wast/spec/call_indirect.wast
+++ b/tests/wast/spec/call_indirect.wast
@@ -990,6 +990,15 @@
   "type mismatch"
 )
 
+;; call_indirect expects funcref type but receives externref
+(assert_invalid
+  (module
+  (type (func))
+  (table 10 externref)
+  (func $call-indirect (call_indirect (type 0) (i32.const 0)))
+  )
+  "type mismatch"
+)
 
 ;; Unbound type
 
@@ -1008,6 +1017,20 @@
   "unknown type"
 )
 
+;; pass very large number to call_indirect
+(assert_invalid
+  (module
+    (type (func (param i32)))
+    (table 1 funcref)
+    (func $conditional-dangling-type
+      (if (i32.const 1)
+        (then (call_indirect (type 0xffffffff) (i32.const 0)))
+      )
+    )
+  )
+  "unknown type"
+)
+
 
 ;; Unbound function in table
 
@@ -1015,3 +1038,23 @@
   (module (table funcref (elem 0 0)))
   "unknown function"
 )
+
+
+
+
+;; Flat syntax
+
+(module
+  (table 1 funcref)
+  (func unreachable call_indirect)
+  (func unreachable call_indirect nop)
+  (func unreachable call_indirect call_indirect)
+  (func unreachable call_indirect (call_indirect))
+  (func unreachable call_indirect call_indirect call_indirect)
+  (func unreachable call_indirect (result))
+  (func unreachable call_indirect (result) (result))
+  (func unreachable call_indirect (result) (result) call_indirect)
+  (func unreachable call_indirect (result) (result) call_indirect (result))
+  (func (result i32) unreachable call_indirect select)
+  (func (result i32) unreachable call_indirect select call_indirect)
+)
diff --git a/tests/wast/spec/comments.wast b/tests/wast/spec/comments.wast
index 90a64b42d9..5ef64a6c1e 100644
Binary files a/tests/wast/spec/comments.wast and b/tests/wast/spec/comments.wast differ
diff --git a/tests/wast/spec/custom.wast b/tests/wast/spec/custom.wast
index b2394f5e3b..12b0476503 100644
--- a/tests/wast/spec/custom.wast
+++ b/tests/wast/spec/custom.wast
@@ -86,7 +86,7 @@
     "\00asm" "\01\00\00\00"
     "\00\26\10" "a custom section" "this is the payload"
   )
-  "unexpected end"
+  "length out of bounds"
 )
 
 (assert_malformed
diff --git a/tests/wast/spec/data.wast b/tests/wast/spec/data.wast
index f7d1f09bca..b1e1239753 100644
--- a/tests/wast/spec/data.wast
+++ b/tests/wast/spec/data.wast
@@ -81,9 +81,15 @@
   (data (global.get $g) "a")
 )
 
-;; Use of internal globals in constant expressions is not allowed in MVP.
-;; (module (memory 1) (data (global.get 0) "a") (global i32 (i32.const 0)))
-;; (module (memory 1) (data (global.get $g) "a") (global $g i32 (i32.const 0)))
+(assert_invalid
+  (module (memory 1) (global i32 (i32.const 0)) (data (global.get 0) "a"))
+  "unknown global"
+)
+(assert_invalid
+  (module (memory 1) (global $g i32 (i32.const 0)) (data (global.get $g) "a"))
+  "unknown global"
+)
+
 
 ;; Corner cases
 
@@ -382,6 +388,14 @@
   "type mismatch"
 )
 
+(assert_invalid
+  (module
+    (memory 1)
+    (data (ref.null func))
+  )
+  "type mismatch"
+)
+
 (assert_invalid
   (module 
     (memory 1)
@@ -448,11 +462,14 @@
   "constant expression required"
 )
 
-;; Use of internal globals in constant expressions is not allowed in MVP.
-;; (assert_invalid
-;;   (module (memory 1) (data (global.get $g)) (global $g (mut i32) (i32.const 0)))
-;;   "constant expression required"
-;; )
+(assert_invalid
+  (module
+    (global $g (import "test" "g") (mut i32))
+    (memory 1)
+    (data (global.get $g))
+  )
+  "constant expression required"
+)
 
 (assert_invalid
    (module 
diff --git a/tests/wast/spec/elem.wast b/tests/wast/spec/elem.wast
index 19b5fe9205..a89c50c6aa 100644
--- a/tests/wast/spec/elem.wast
+++ b/tests/wast/spec/elem.wast
@@ -40,6 +40,7 @@
   (elem (i32.const 0) funcref (ref.func $f) (ref.null func))
   (elem (i32.const 0) func $f $f)
   (elem (i32.const 0) $f $f)
+  (elem (i32.const 0) funcref (item (ref.func $f)) (item (ref.null func)))
 
   (elem $a1 (table $t) (i32.const 0) funcref)
   (elem $a2 (table $t) (i32.const 0) funcref (ref.func $f) (ref.null func))
@@ -147,6 +148,35 @@
 (assert_return (invoke "call-7") (i32.const 65))
 (assert_return (invoke "call-9") (i32.const 66))
 
+;; Same as the above, but use ref.null to ensure the elements use exprs.
+;; Note: some tools like wast2json avoid using exprs when possible.
+(module
+  (type $out-i32 (func (result i32)))
+  (table 11 funcref)
+  (elem (i32.const 6) funcref (ref.null func) (ref.func $const-i32-a))
+  (elem (i32.const 9) funcref (ref.func $const-i32-b) (ref.null func))
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-7") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 7))
+  )
+  (func (export "call-9") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 9))
+  )
+)
+(assert_return (invoke "call-7") (i32.const 65))
+(assert_return (invoke "call-9") (i32.const 66))
+
+(assert_invalid
+  (module (table 1 funcref) (global i32 (i32.const 0)) (elem (global.get 0) $f) (func $f))
+  "unknown global"
+)
+(assert_invalid
+  (module (table 1 funcref) (global $g i32 (i32.const 0)) (elem (global.get $g) $f) (func $f))
+  "unknown global"
+)
+
+
 ;; Corner cases
 
 (module
@@ -349,6 +379,14 @@
   "type mismatch"
 )
 
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (ref.null func))
+  )
+  "type mismatch"
+)
+
 (assert_invalid
   (module 
     (table 1 funcref)
@@ -416,11 +454,14 @@
   "constant expression required"
 )
 
-;; Use of internal globals in constant expressions is not allowed in MVP.
-;; (assert_invalid
-;;   (module (memory 1) (data (global.get $g)) (global $g (mut i32) (i32.const 0)))
-;;   "constant expression required"
-;; )
+(assert_invalid
+  (module
+    (global $g (import "test" "g") (mut i32))
+    (table 1 funcref)
+    (elem (global.get $g))
+  )
+  "constant expression required"
+)
 
 (assert_invalid
    (module 
@@ -448,6 +489,49 @@
    "constant expression required"
 )
 
+;; Invalid elements
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i32.const 0) funcref (ref.null extern))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i32.const 0) funcref (item (ref.null func) (ref.null func)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i32.const 0) funcref (i32.const 0))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i32.const 0) funcref (item (i32.const 0)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i32.const 0) funcref (item (call $f)))
+    (func $f (result funcref) (ref.null func))
+  )
+  "constant expression required"
+)
+
 ;; Two elements target the same slot
 
 (module
@@ -527,3 +611,84 @@
 (assert_return (invoke $module1 "call-7") (i32.const 67))
 (assert_return (invoke $module1 "call-8") (i32.const 69))
 (assert_return (invoke $module1 "call-9") (i32.const 70))
+
+;; Element segments must match element type of table
+
+(assert_invalid
+  (module (func $f) (table 1 externref) (elem (i32.const 0) $f))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (table 1 funcref) (elem (i32.const 0) externref (ref.null extern)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $f)
+    (table $t 1 externref)
+    (elem $e funcref (ref.func $f))
+    (func (table.init $t $e (i32.const 0) (i32.const 0) (i32.const 1))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table $t 1 funcref)
+    (elem $e externref (ref.null extern))
+    (func (table.init $t $e (i32.const 0) (i32.const 0) (i32.const 1))))
+  "type mismatch"
+)
+
+;; Initializing a table with an externref-type element segment
+
+(module $m
+  (table $t (export "table") 2 externref)
+  (func (export "get") (param $i i32) (result externref)
+        (table.get $t (local.get $i)))
+  (func (export "set") (param $i i32) (param $x externref)
+        (table.set $t (local.get $i) (local.get $x))))
+
+(register "exporter" $m)
+
+(assert_return (invoke $m "get" (i32.const 0)) (ref.null extern))
+(assert_return (invoke $m "get" (i32.const 1)) (ref.null extern))
+
+(assert_return (invoke $m "set" (i32.const 0) (ref.extern 42)))
+(assert_return (invoke $m "set" (i32.const 1) (ref.extern 137)))
+
+(assert_return (invoke $m "get" (i32.const 0)) (ref.extern 42))
+(assert_return (invoke $m "get" (i32.const 1)) (ref.extern 137))
+
+(module
+  (import "exporter" "table" (table $t 2 externref))
+  (elem (i32.const 0) externref (ref.null extern)))
+
+(assert_return (invoke $m "get" (i32.const 0)) (ref.null extern))
+(assert_return (invoke $m "get" (i32.const 1)) (ref.extern 137))
+
+;; Initializing a table with imported funcref global
+
+(module $module4
+  (func (result i32)
+    i32.const 42
+  )
+  (global (export "f") funcref (ref.func 0))
+)
+
+(register "module4" $module4)
+
+;; Currently unsupported. 
+;;
+;; (module
+;;   (import "module4" "f" (global funcref))
+;;   (type $out-i32 (func (result i32)))
+;;   (table 10 funcref)
+;;   (elem (offset (i32.const 0)) funcref (global.get 0))
+;;   (func (export "call_imported_elem") (type $out-i32)
+;;     (call_indirect (type $out-i32) (i32.const 0))
+;;   )
+;; )
+;; 
+;; (assert_return (invoke "call_imported_elem") (i32.const 42))
diff --git a/tests/wast/spec/f32.wast b/tests/wast/spec/f32.wast
index 36d81a05bf..0f8ae0aa45 100644
--- a/tests/wast/spec/f32.wast
+++ b/tests/wast/spec/f32.wast
@@ -2531,3 +2531,13 @@
 (assert_invalid (module (func (result f32) (f32.nearest (i64.const 0)))) "type mismatch")
 (assert_invalid (module (func (result f32) (f32.sqrt (i64.const 0)))) "type mismatch")
 (assert_invalid (module (func (result f32) (f32.trunc (i64.const 0)))) "type mismatch")
+
+;; These float literal patterns are only allowed in scripts, not in text format.
+(assert_malformed
+  (module quote "(func (result f32) (f32.const nan:arithmetic))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (result f32) (f32.const nan:canonical))")
+  "unexpected token"
+)
diff --git a/tests/wast/spec/f64.wast b/tests/wast/spec/f64.wast
index 70bb477c77..afd2b2f734 100644
--- a/tests/wast/spec/f64.wast
+++ b/tests/wast/spec/f64.wast
@@ -2531,3 +2531,13 @@
 (assert_invalid (module (func (result f64) (f64.nearest (i64.const 0)))) "type mismatch")
 (assert_invalid (module (func (result f64) (f64.sqrt (i64.const 0)))) "type mismatch")
 (assert_invalid (module (func (result f64) (f64.trunc (i64.const 0)))) "type mismatch")
+
+;; These float literal patterns are only allowed in scripts, not in text format.
+(assert_malformed
+  (module quote "(func (result f64) (f64.const nan:arithmetic))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (result f64) (f64.const nan:canonical))")
+  "unexpected token"
+)
diff --git a/tests/wast/spec/float_exprs.wast b/tests/wast/spec/float_exprs.wast
index 1f88299212..114cc99c7a 100644
--- a/tests/wast/spec/float_exprs.wast
+++ b/tests/wast/spec/float_exprs.wast
@@ -35,7 +35,7 @@
 (assert_return (invoke "f64.no_fma" (f64.const 0x1.7e2c44058a799p+52) (f64.const 0x1.c73b71765b8b2p+685) (f64.const -0x1.16c641df0b108p+690)) (f64.const 0x1.53ccb53de0bd1p+738))
 
 ;; Test that x+0.0 is not folded to x.
-;; See IEEE 754-2008 10.4 "Literal meaning and value-changing optimizations".
+;; See IEEE 754-2019 10.4 "Literal meaning and value-changing optimizations".
 
 (module
   (func (export "f32.no_fold_add_zero") (param $x f32) (result f32)
@@ -94,7 +94,7 @@
 (assert_return (invoke "f64.no_fold_mul_zero" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 
 ;; Test that x*1.0 is not folded to x.
-;; See IEEE 754-2008 10.4 "Literal meaning and value-changing optimizations".
+;; See IEEE 754-2019 10.4 "Literal meaning and value-changing optimizations".
 
 (module
   (func (export "f32.no_fold_mul_one") (param $x f32) (result f32)
@@ -649,7 +649,8 @@
 (assert_return (invoke "no_fold_promote_demote" (f32.const inf)) (f32.const inf))
 (assert_return (invoke "no_fold_promote_demote" (f32.const -inf)) (f32.const -inf))
 
-;; Test that demote(x+promote(y)) is not folded to demote(x)+y.
+;; Test that demote(x+promote(y)) is not folded to demote(x)+y, and that
+;; demote(promote(y)+x) is not folded to y+demote(x).
 
 (module
   (func (export "no_demote_mixed_add") (param $x f64) (param $y f32) (result f32)
@@ -670,11 +671,14 @@
 (assert_return (invoke "no_demote_mixed_add_commuted" (f32.const 0x1.096f4ap-29) (f64.const -0x1.0d5110e3385bbp-20)) (f32.const -0x1.0ccc5ap-20))
 (assert_return (invoke "no_demote_mixed_add_commuted" (f32.const -0x1.24e474p-41) (f64.const -0x1.73852db4e5075p-20)) (f32.const -0x1.738536p-20))
 
-;; Test that demote(x-promote(y)) is not folded to demote(x)-y.
+;; Test that demote(x-promote(y)) is not folded to demote(x)-y, and that
+;; demote(promote(y)-x) is not folded to y-demote(x).
 
 (module
   (func (export "no_demote_mixed_sub") (param $x f64) (param $y f32) (result f32)
     (f32.demote_f64 (f64.sub (local.get $x) (f64.promote_f32 (local.get $y)))))
+  (func (export "no_demote_mixed_sub_commuted") (param $y f32) (param $x f64) (result f32)
+    (f32.demote_f64 (f64.sub (f64.promote_f32 (local.get $y)) (local.get $x))))
 )
 
 (assert_return (invoke "no_demote_mixed_sub" (f64.const 0x1.a0a183220e9b1p+82) (f32.const 0x1.c5acf8p+61)) (f32.const 0x1.a0a174p+82))
@@ -683,6 +687,56 @@
 (assert_return (invoke "no_demote_mixed_sub" (f64.const 0x1.0459f34091dbfp-54) (f32.const 0x1.61ad08p-71)) (f32.const 0x1.045942p-54))
 (assert_return (invoke "no_demote_mixed_sub" (f64.const 0x1.a7498dca3fdb7p+14) (f32.const 0x1.ed21c8p+15)) (f32.const -0x1.197d02p+15))
 
+(assert_return (invoke "no_demote_mixed_sub_commuted" (f32.const 0x1.c5acf8p+61) (f64.const 0x1.a0a183220e9b1p+82)) (f32.const -0x1.a0a174p+82))
+(assert_return (invoke "no_demote_mixed_sub_commuted" (f32.const 0x1.d48ca4p+17) (f64.const -0x1.6e2c5ac39f63ep+30)) (f32.const 0x1.6e3bp+30))
+(assert_return (invoke "no_demote_mixed_sub_commuted" (f32.const 0x1.9d69bcp-12) (f64.const -0x1.98c74350dde6ap+6)) (f32.const 0x1.98c7aap+6))
+(assert_return (invoke "no_demote_mixed_sub_commuted" (f32.const 0x1.61ad08p-71) (f64.const 0x1.0459f34091dbfp-54)) (f32.const -0x1.045942p-54))
+(assert_return (invoke "no_demote_mixed_sub_commuted" (f32.const 0x1.ed21c8p+15) (f64.const 0x1.a7498dca3fdb7p+14)) (f32.const 0x1.197d02p+15))
+
+;; Test that demote(x*promote(y)) is not folded to demote(x)*y, and that
+;; demote(promote(y)*x) is not folded to y*demote(x).
+
+(module
+  (func (export "no_demote_mixed_mul") (param $x f64) (param $y f32) (result f32)
+    (f32.demote_f64 (f64.mul (local.get $x) (f64.promote_f32 (local.get $y)))))
+  (func (export "no_demote_mixed_mul_commuted") (param $y f32) (param $x f64) (result f32)
+    (f32.demote_f64 (f64.mul (f64.promote_f32 (local.get $y)) (local.get $x))))
+)
+
+(assert_return (invoke "no_demote_mixed_mul" (f64.const 0x1.a19789e5aa475p-202) (f32.const 0x1.858cbep+113)) (f32.const 0x1.3db86cp-88))
+(assert_return (invoke "no_demote_mixed_mul" (f64.const 0x1.8f0e6a5a53f15p+140) (f32.const 0x1.2ef826p-107)) (f32.const 0x1.d845d2p+33))
+(assert_return (invoke "no_demote_mixed_mul" (f64.const 0x1.f03aa769e296cp+176) (f32.const 0x1.a9255p-57)) (f32.const 0x1.9c0cdap+120))
+(assert_return (invoke "no_demote_mixed_mul" (f64.const 0x1.9cd70b636bc52p+221) (f32.const 0x1.3f3ac6p-122)) (f32.const 0x1.01676p+100))
+(assert_return (invoke "no_demote_mixed_mul" (f64.const 0x1.c56b4c2991a3cp-170) (f32.const 0x1.1ad242p+48)) (f32.const 0x1.f4ec98p-122))
+
+(assert_return (invoke "no_demote_mixed_mul_commuted" (f32.const 0x1.858cbep+113) (f64.const 0x1.a19789e5aa475p-202)) (f32.const 0x1.3db86cp-88))
+(assert_return (invoke "no_demote_mixed_mul_commuted" (f32.const 0x1.2ef826p-107) (f64.const 0x1.8f0e6a5a53f15p+140)) (f32.const 0x1.d845d2p+33))
+(assert_return (invoke "no_demote_mixed_mul_commuted" (f32.const 0x1.a9255p-57) (f64.const 0x1.f03aa769e296cp+176)) (f32.const 0x1.9c0cdap+120))
+(assert_return (invoke "no_demote_mixed_mul_commuted" (f32.const 0x1.3f3ac6p-122) (f64.const 0x1.9cd70b636bc52p+221)) (f32.const 0x1.01676p+100))
+(assert_return (invoke "no_demote_mixed_mul_commuted" (f32.const 0x1.1ad242p+48) (f64.const 0x1.c56b4c2991a3cp-170)) (f32.const 0x1.f4ec98p-122))
+
+;; Test that demote(x/promote(y)) is not folded to demote(x)/y, and that
+;; demote(promote(y)/x) is not folded to y/demote(x).
+
+(module
+  (func (export "no_demote_mixed_div") (param $x f64) (param $y f32) (result f32)
+    (f32.demote_f64 (f64.div (local.get $x) (f64.promote_f32 (local.get $y)))))
+  (func (export "no_demote_mixed_div_commuted") (param $y f32) (param $x f64) (result f32)
+    (f32.demote_f64 (f64.div (f64.promote_f32 (local.get $y)) (local.get $x))))
+)
+
+(assert_return (invoke "no_demote_mixed_div" (f64.const 0x1.40d0b55d4cee1p+150) (f32.const 0x1.6c7496p+103)) (f32.const 0x1.c2b158p+46))
+(assert_return (invoke "no_demote_mixed_div" (f64.const 0x1.402750f34cd98p-153) (f32.const 0x1.3db8ep-82)) (f32.const 0x1.01f586p-71))
+(assert_return (invoke "no_demote_mixed_div" (f64.const 0x1.3f7ece1a790a7p-37) (f32.const 0x1.a5652p-128)) (f32.const 0x1.8430dp+90))
+(assert_return (invoke "no_demote_mixed_div" (f64.const 0x1.5171328e16885p-138) (f32.const 0x1.10636ap-88)) (f32.const 0x1.3d23cep-50))
+(assert_return (invoke "no_demote_mixed_div" (f64.const 0x1.d3a380fc986ccp+74) (f32.const 0x1.f095b6p+88)) (f32.const 0x1.e227c4p-15))
+
+(assert_return (invoke "no_demote_mixed_div_commuted" (f32.const 0x1.d78ddcp-74) (f64.const 0x1.2c57e125069e2p-42)) (f32.const 0x1.91eed6p-32))
+(assert_return (invoke "no_demote_mixed_div_commuted" (f32.const 0x1.7db224p+26) (f64.const 0x1.1c291ec609ed4p+159)) (f32.const 0x1.57dfp-133))
+(assert_return (invoke "no_demote_mixed_div_commuted" (f32.const 0x1.e7a824p-40) (f64.const 0x1.f4bdb25ff00fcp-137)) (f32.const 0x1.f29f22p+96))
+(assert_return (invoke "no_demote_mixed_div_commuted" (f32.const 0x1.730b8p+80) (f64.const 0x1.880fb331a64cap+210)) (f32.const 0x1.e48ep-131))
+(assert_return (invoke "no_demote_mixed_div_commuted" (f32.const 0x1.7715fcp-73) (f64.const 0x1.6feb1fa66f11bp-198)) (f32.const 0x1.04fcb6p+125))
+
 ;; Test that converting between integer and float and back isn't folded away.
 
 (module
@@ -1986,7 +2040,7 @@
 (assert_return (invoke "f64.xkcd_better_sqrt_5" (f64.const 13.0) (f64.const 4.0) (f64.const 0x1.921fb54442d18p+1) (f64.const 24.0)) (f64.const 0x1.1e3778509a5a3p+1))
 
 ;; Compute the floating-point radix.
-;; M. A. Malcom. Algorithms to reveal properties of floating-point arithmetic.
+;; M. A. Malcolm. Algorithms to reveal properties of floating-point arithmetic.
 ;; Communications of the ACM, 15(11):949-951, November 1972.
 (module
   (func (export "f32.compute_radix") (param $0 f32) (param $1 f32) (result f32)
diff --git a/tests/wast/spec/float_literals.wast b/tests/wast/spec/float_literals.wast
index fefb91fbb7..9f6fa55ad3 100644
--- a/tests/wast/spec/float_literals.wast
+++ b/tests/wast/spec/float_literals.wast
@@ -25,6 +25,10 @@
   (func (export "f32.max_finite") (result i32) (i32.reinterpret_f32 (f32.const 0x1.fffffep+127)))
   (func (export "f32.max_subnormal") (result i32) (i32.reinterpret_f32 (f32.const 0x1.fffffcp-127)))
   (func (export "f32.trailing_dot") (result i32) (i32.reinterpret_f32 (f32.const 0x1.p10)))
+  (func (export "f32.misc_int") (result i32) (i32.reinterpret_f32 (f32.const 0x12345)))
+  (func (export "f32.large_int") (result i32) (i32.reinterpret_f32 (f32.const 0x1_0000_0000_0000_0000_0000)))
+  (func (export "f32.min_int32") (result i32) (i32.reinterpret_f32 (f32.const -0x8000_0000)))
+  (func (export "f32.min_int64") (result i32) (i32.reinterpret_f32 (f32.const -0x8000_0000_0000_0000)))
 
   ;; f32 in decimal format
   (func (export "f32_dec.zero") (result i32) (i32.reinterpret_f32 (f32.const 0.0e0)))
@@ -36,6 +40,10 @@
   (func (export "f32_dec.max_subnormal") (result i32) (i32.reinterpret_f32 (f32.const 1.1754942e-38)))
   (func (export "f32_dec.max_finite") (result i32) (i32.reinterpret_f32 (f32.const 3.4028234e+38)))
   (func (export "f32_dec.trailing_dot") (result i32) (i32.reinterpret_f32 (f32.const 1.e10)))
+  (func (export "f32_dec.misc_int") (result i32) (i32.reinterpret_f32 (f32.const 12345)))
+  (func (export "f32_dec.large_int") (result i32) (i32.reinterpret_f32 (f32.const 100_000_000_000_000_000_000)))
+  (func (export "f32_dec.min_int32") (result i32) (i32.reinterpret_f32 (f32.const -2147483648)))
+  (func (export "f32_dec.min_int64") (result i32) (i32.reinterpret_f32 (f32.const -9223372036854775808)))
 
   ;; https://twitter.com/Archivd/status/994637336506912768
   (func (export "f32_dec.root_beer_float") (result i32) (i32.reinterpret_f32 (f32.const 1.000000119)))
@@ -64,6 +72,10 @@
   (func (export "f64.max_subnormal") (result i64) (i64.reinterpret_f64 (f64.const 0x0.fffffffffffffp-1022)))
   (func (export "f64.max_finite") (result i64) (i64.reinterpret_f64 (f64.const 0x1.fffffffffffffp+1023)))
   (func (export "f64.trailing_dot") (result i64) (i64.reinterpret_f64 (f64.const 0x1.p100)))
+  (func (export "f64.misc_int") (result i64) (i64.reinterpret_f64 (f64.const 0x12345)))
+  (func (export "f64.large_int") (result i64) (i64.reinterpret_f64 (f64.const 0x1_0000_0000_0000_0000_0000)))
+  (func (export "f64.min_int32") (result i64) (i64.reinterpret_f64 (f64.const -0x8000_0000)))
+  (func (export "f64.min_int64") (result i64) (i64.reinterpret_f64 (f64.const -0x8000_0000_0000_0000)))
 
   ;; f64 numbers in decimal format
   (func (export "f64_dec.zero") (result i64) (i64.reinterpret_f64 (f64.const 0.0e0)))
@@ -75,6 +87,10 @@
   (func (export "f64_dec.max_subnormal") (result i64) (i64.reinterpret_f64 (f64.const 2.2250738585072011e-308)))
   (func (export "f64_dec.max_finite") (result i64) (i64.reinterpret_f64 (f64.const 1.7976931348623157e+308)))
   (func (export "f64_dec.trailing_dot") (result i64) (i64.reinterpret_f64 (f64.const 1.e100)))
+  (func (export "f64_dec.misc_int") (result i64) (i64.reinterpret_f64 (f64.const 12345)))
+  (func (export "f64_dec.large_int") (result i64) (i64.reinterpret_f64 (f64.const 100_000_000_000_000_000_000)))
+  (func (export "f64_dec.min_int32") (result i64) (i64.reinterpret_f64 (f64.const -2147483648)))
+  (func (export "f64_dec.min_int64") (result i64) (i64.reinterpret_f64 (f64.const -9223372036854775808)))
 
   ;; https://twitter.com/Archivd/status/994637336506912768
   (func (export "f64_dec.root_beer_float") (result i64) (i64.reinterpret_f64 (f64.const 1.000000119)))
@@ -123,6 +139,10 @@
 (assert_return (invoke "f32.max_subnormal") (i32.const 0x7fffff))
 (assert_return (invoke "f32.max_finite") (i32.const 0x7f7fffff))
 (assert_return (invoke "f32.trailing_dot") (i32.const 0x44800000))
+(assert_return (invoke "f32.misc_int") (i32.const 0x4791a280))
+(assert_return (invoke "f32.large_int") (i32.const 0x67800000))
+(assert_return (invoke "f32.min_int32") (i32.const 0xcf000000))
+(assert_return (invoke "f32.min_int64") (i32.const 0xdf000000))
 (assert_return (invoke "f32_dec.zero") (i32.const 0))
 (assert_return (invoke "f32_dec.positive_zero") (i32.const 0))
 (assert_return (invoke "f32_dec.negative_zero") (i32.const 0x80000000))
@@ -133,6 +153,10 @@
 (assert_return (invoke "f32_dec.max_finite") (i32.const 0x7f7fffff))
 (assert_return (invoke "f32_dec.trailing_dot") (i32.const 0x501502f9))
 (assert_return (invoke "f32_dec.root_beer_float") (i32.const 0x3f800001))
+(assert_return (invoke "f32_dec.misc_int") (i32.const 0x4640e400))
+(assert_return (invoke "f32_dec.large_int") (i32.const 0x60ad78ec))
+(assert_return (invoke "f32_dec.min_int32") (i32.const 0xcf000000))
+(assert_return (invoke "f32_dec.min_int64") (i32.const 0xdf000000))
 
 (assert_return (invoke "f64.nan") (i64.const 0x7ff8000000000000))
 (assert_return (invoke "f64.positive_nan") (i64.const 0x7ff8000000000000))
@@ -155,6 +179,10 @@
 (assert_return (invoke "f64.max_subnormal") (i64.const 0xfffffffffffff))
 (assert_return (invoke "f64.max_finite") (i64.const 0x7fefffffffffffff))
 (assert_return (invoke "f64.trailing_dot") (i64.const 0x4630000000000000))
+(assert_return (invoke "f64.misc_int") (i64.const 0x40f2345000000000))
+(assert_return (invoke "f64.large_int") (i64.const 0x44f0000000000000))
+(assert_return (invoke "f64.min_int32") (i64.const 0xc1e0000000000000))
+(assert_return (invoke "f64.min_int64") (i64.const 0xc3e0000000000000))
 (assert_return (invoke "f64_dec.zero") (i64.const 0))
 (assert_return (invoke "f64_dec.positive_zero") (i64.const 0))
 (assert_return (invoke "f64_dec.negative_zero") (i64.const 0x8000000000000000))
@@ -165,6 +193,10 @@
 (assert_return (invoke "f64_dec.max_finite") (i64.const 0x7fefffffffffffff))
 (assert_return (invoke "f64_dec.trailing_dot") (i64.const 0x54b249ad2594c37d))
 (assert_return (invoke "f64_dec.root_beer_float") (i64.const 0x3ff000001ff19e24))
+(assert_return (invoke "f64_dec.misc_int") (i64.const 0x40c81c8000000000))
+(assert_return (invoke "f64_dec.large_int") (i64.const 0x4415af1d78b58c40))
+(assert_return (invoke "f64_dec.min_int32") (i64.const 0xc1e0000000000000))
+(assert_return (invoke "f64_dec.min_int64") (i64.const 0xc3e0000000000000))
 
 (assert_return (invoke "f32-dec-sep1") (f32.const 1000000))
 (assert_return (invoke "f32-dec-sep2") (f32.const 1000))
@@ -352,6 +384,10 @@
   (module quote "(global f32 (f32.const 0x1.0p_+1))")
   "unknown operator"
 )
+(assert_malformed
+  (module quote "(global f32 (f32.const nan:0x80_0000))")
+  "constant out of range"
+)
 
 (assert_malformed
   (module quote "(global f64 (f64.const _100))")
@@ -505,3 +541,7 @@
   (module quote "(global f64 (f64.const 0x1.0p_+1))")
   "unknown operator"
 )
+(assert_malformed
+  (module quote "(global f64 (f64.const nan:0x10_0000_0000_0000))")
+  "constant out of range"
+)
diff --git a/tests/wast/spec/float_misc.wast b/tests/wast/spec/float_misc.wast
index 3d83281d77..a2153cfabd 100644
--- a/tests/wast/spec/float_misc.wast
+++ b/tests/wast/spec/float_misc.wast
@@ -587,6 +587,50 @@
 (assert_return (invoke "f64.sqrt" (f64.const 0x1.ffffffffffffep-1)) (f64.const 0x1.fffffffffffffp-1))
 (assert_return (invoke "f64.sqrt" (f64.const 0x1.ffffffffffffdp-1)) (f64.const 0x1.ffffffffffffep-1))
 
+;; Test the values of sqrt around ¼, where `sqrt(x) - x` is greatest.
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.fffffep-3)) (f32.const 0x1.fffffep-2))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1p-2)) (f32.const 0x1p-1))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.000002p-2)) (f32.const 0x1p-1))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.000004p-2)) (f32.const 0x1.000002p-1))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.fffffffffffffp-3)) (f64.const 0x1.fffffffffffffp-2))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1p-2)) (f64.const 0x1p-1))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.0000000000001p-2)) (f64.const 0x1p-1))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.0000000000002p-2)) (f64.const 0x1.0000000000001p-1))
+
+;; Test some values that in some systems differ between CPU and DSP.
+;; https://e2e.ti.com/support/processors-group/processors/f/processors-forum/30725/sqrt-function-gives-slightly-different-results---may-be-rounding-problem
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.fb41d4p+37)) (f32.const 0x1.fd9f8p+18))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.fb41d442eeb1bp+37)) (f64.const 0x1.fd9f808a0b68dp+18))
+
+;; Test some values that in some systems differ between CPU and GPU.
+;; https://forums.developer.nvidia.com/t/sqrt-precision/18597
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.3c61b2p+33)) (f32.const 0x1.927ap+16))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.56bd4ep+51)) (f32.const 0x1.a2e80cp+25))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.65f02cp+44)) (f32.const 0x1.2eb544p+22))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.26580cp+30)) (f32.const 0x1.1280d6p+15))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.3c61b112p+33)) (f64.const 0x1.927ap+16))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.56bd4e65c8548p+51)) (f64.const 0x1.a2e80dp+25))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.65f02cc93a1p+44)) (f64.const 0x1.2eb544p+22))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.26580b4cp+30)) (f64.const 0x1.1280d62b818cfp+15))
+
+;; Test some values that in some systems differ between CPU and GPU.
+;; https://github.com/pytorch/pytorch/issues/31250
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.0817fcp-1)) (f32.const 0x1.6fb79ep-1))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.017b98p-1)) (f32.const 0x1.6b15eep-1))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.0817fcp-1)) (f64.const 0x1.6fb79d0dfaffap-1))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.017b98p-1)) (f64.const 0x1.6b15ed0071b95p-1))
+
+;; Test that sqrt is not a "good enough" approximation.
+;; https://sicp.sourceacademy.org/chapters/1.1.7.html
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.2p+3)) (f32.const 0x1.8p+1))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.12p+7)) (f32.const 0x1.768ce6p+3))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.c615dep+0)) (f32.const 0x1.54f2dp+0))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.f4p+9)) (f32.const 0x1.f9f6e4p+4))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.2p+3)) (f64.const 0x1.8p+1))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.12p+7)) (f64.const 0x1.768ce6d3c11ep+3))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.c615df07a57d3p+0)) (f64.const 0x1.54f2d015acf09p+0))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.f4p+9)) (f64.const 0x1.f9f6e4990f227p+4))
+
 ;; Test that the bitwise floating point operators are bitwise on NaN.
 
 (assert_return (invoke "f32.abs" (f32.const nan:0x0f1e2)) (f32.const nan:0x0f1e2))
diff --git a/tests/wast/spec/global.wast b/tests/wast/spec/global.wast
index 9fa5e22311..e40a305f16 100644
--- a/tests/wast/spec/global.wast
+++ b/tests/wast/spec/global.wast
@@ -348,6 +348,15 @@
   "unknown global"
 )
 
+(assert_invalid
+  (module (global i32 (i32.const 0)) (global i32 (global.get 0)))
+  "unknown global"
+)
+(assert_invalid
+  (module (global $g i32 (i32.const 0)) (global i32 (global.get $g)))
+  "unknown global"
+)
+
 (assert_invalid
   (module (global i32 (global.get 1)) (global i32 (i32.const 0)))
   "unknown global"
diff --git a/tests/wast/spec/i32.wast b/tests/wast/spec/i32.wast
index 32862c3475..2e8ab70053 100644
--- a/tests/wast/spec/i32.wast
+++ b/tests/wast/spec/i32.wast
@@ -974,3 +974,12 @@
 (assert_invalid (module (func (result i32) (i32.lt_s (i64.const 0) (f32.const 0)))) "type mismatch")
 (assert_invalid (module (func (result i32) (i32.lt_u (i64.const 0) (f32.const 0)))) "type mismatch")
 (assert_invalid (module (func (result i32) (i32.ne (i64.const 0) (f32.const 0)))) "type mismatch")
+
+(assert_malformed
+  (module quote "(func (result i32) (i32.const nan:arithmetic))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (result i32) (i32.const nan:canonical))")
+  "unexpected token"
+)
diff --git a/tests/wast/spec/i64.wast b/tests/wast/spec/i64.wast
index baeed0ce1b..b662f3d927 100644
--- a/tests/wast/spec/i64.wast
+++ b/tests/wast/spec/i64.wast
@@ -483,3 +483,12 @@
 (assert_invalid (module (func (result i64) (i64.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
 (assert_invalid (module (func (result i64) (i64.lt_u (i32.const 0) (f32.const 0)))) "type mismatch")
 (assert_invalid (module (func (result i64) (i64.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+
+(assert_malformed
+  (module quote "(func (result i64) (i64.const nan:arithmetic))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (result i64) (i64.const nan:canonical))")
+  "unexpected token"
+)
diff --git a/tests/wast/spec/if.wast b/tests/wast/spec/if.wast
index 1cbb617a7f..2ea45f6fa0 100644
--- a/tests/wast/spec/if.wast
+++ b/tests/wast/spec/if.wast
@@ -524,6 +524,14 @@
     )
     (drop) (drop) (drop)
   )
+
+  ;; Atypical folded condition syntax
+
+  (func (export "atypical-condition")
+    i32.const 0
+    (if (then) (else))
+    (if (i32.const 1) (i32.eqz) (then) (else))
+  )
 )
 
 (assert_return (invoke "empty" (i32.const 0)))
@@ -722,6 +730,8 @@
 
 (assert_return (invoke "type-use"))
 
+(assert_return (invoke "atypical-condition"))
+
 (assert_malformed
   (module quote
     "(type $sig (func (param i32) (result i32)))"
@@ -1547,4 +1557,8 @@
 (assert_malformed
   (module quote "(func i32.const 0 if $a else $l end $l)")
   "mismatching label"
+)
+(assert_malformed
+  (module quote "(func (if i32.const 0 (then) (else)))")
+  "unexpected token"
 )
\ No newline at end of file
diff --git a/tests/wast/spec/imports.wast b/tests/wast/spec/imports.wast
index 35e8c917f4..009cc3f345 100644
--- a/tests/wast/spec/imports.wast
+++ b/tests/wast/spec/imports.wast
@@ -30,11 +30,9 @@
   (type $func_f64 (func (param f64)))
 
   (import "spectest" "print_i32" (func (param i32)))
-  ;; JavaScript can't handle i64 yet.
-  ;; (func (import "spectest" "print_i64") (param i64))
+  (func (import "spectest" "print_i64") (param i64))
   (import "spectest" "print_i32" (func $print_i32 (param i32)))
-  ;; JavaScript can't handle i64 yet.
-  ;; (import "spectest" "print_i64" (func $print_i64 (param i64)))
+  (import "spectest" "print_i64" (func $print_i64 (param i64)))
   (import "spectest" "print_f32" (func $print_f32 (param f32)))
   (import "spectest" "print_f64" (func $print_f64 (param f64)))
   (import "spectest" "print_i32_f32" (func $print_i32_f32 (param i32 f32)))
@@ -72,14 +70,12 @@
   (func (export "print64") (param $i i64)
     (local $x f64)
     (local.set $x (f64.convert_i64_s (call $i64->i64 (local.get $i))))
-    ;; JavaScript can't handle i64 yet.
-    ;; (call 1 (local.get $i))
+    (call 1 (local.get $i))
     (call $print_f64_f64
       (f64.add (local.get $x) (f64.const 1))
       (f64.const 53)
     )
-    ;; JavaScript can't handle i64 yet.
-    ;; (call $print_i64 (local.get $i))
+    (call $print_i64 (local.get $i))
     (call $print_f64 (local.get $x))
     (call $print_f64-2 (local.get $x))
     (call_indirect (type $func_f64) (local.get $x) (i32.const 1))
@@ -234,8 +230,7 @@
   (import "spectest" "global_i32" (global $x i32))
   (global $y (import "spectest" "global_i32") i32)
 
-  ;; JavaScript can't handle i64 yet.
-  ;; (import "spectest" "global_i64" (global i64))
+  (import "spectest" "global_i64" (global i64))
   (import "spectest" "global_f32" (global f32))
   (import "spectest" "global_f64" (global f64))
 
@@ -243,12 +238,18 @@
   (func (export "get-1") (result i32) (global.get 1))
   (func (export "get-x") (result i32) (global.get $x))
   (func (export "get-y") (result i32) (global.get $y))
+  (func (export "get-4") (result i64) (global.get 4))
+  (func (export "get-5") (result f32) (global.get 5))
+  (func (export "get-6") (result f64) (global.get 6))
 )
 
 (assert_return (invoke "get-0") (i32.const 666))
 (assert_return (invoke "get-1") (i32.const 666))
 (assert_return (invoke "get-x") (i32.const 666))
 (assert_return (invoke "get-y") (i32.const 666))
+(assert_return (invoke "get-4") (i64.const 666))
+(assert_return (invoke "get-5") (f32.const 666.6))
+(assert_return (invoke "get-6") (f64.const 666.6))
 
 (module (import "test" "global-i32" (global i32)))
 (module (import "test" "global-f32" (global f32)))
@@ -377,7 +378,6 @@
 (assert_trap (invoke "call" (i32.const 3)) "uninitialized element")
 (assert_trap (invoke "call" (i32.const 100)) "undefined element")
 
-
 (module
   (import "spectest" "table" (table 0 funcref))
   (import "spectest" "table" (table 0 funcref))
@@ -577,26 +577,6 @@
 (assert_return (invoke "grow" (i32.const 1)) (i32.const -1))
 (assert_return (invoke "grow" (i32.const 0)) (i32.const 2))
 
-(module $Mgm
-  (memory (export "memory") 1) ;; initial size is 1
-  (func (export "grow") (result i32) (memory.grow (i32.const 1)))
-)
-(register "grown-memory" $Mgm)
-(assert_return (invoke $Mgm "grow") (i32.const 1)) ;; now size is 2
-(module $Mgim1
-  ;; imported memory limits should match, because external memory size is 2 now
-  (memory (export "memory") (import "grown-memory" "memory") 2) 
-  (func (export "grow") (result i32) (memory.grow (i32.const 1)))
-)
-(register "grown-imported-memory" $Mgim1)
-(assert_return (invoke $Mgim1 "grow") (i32.const 2)) ;; now size is 3
-(module $Mgim2
-  ;; imported memory limits should match, because external memory size is 3 now
-  (import "grown-imported-memory" "memory" (memory 3))
-  (func (export "size") (result i32) (memory.size))
-)
-(assert_return (invoke $Mgim2 "size") (i32.const 3))
-
 
 ;; Syntax errors
 
diff --git a/tests/wast/spec/linking.wast b/tests/wast/spec/linking.wast
index 371913cea6..252000d7ef 100644
--- a/tests/wast/spec/linking.wast
+++ b/tests/wast/spec/linking.wast
@@ -290,7 +290,6 @@
 ;; )
 ;; (assert_return (invoke $Mt "call" (i32.const 7)) (i32.const 0))
 
-
 (module $Mtable_ex
   (table $t1 (export "t-func") 1 funcref)
   (table $t2 (export "t-extern") 1 externref)
diff --git a/tests/wast/spec/memory.wast b/tests/wast/spec/memory.wast
index 497b69fc94..baebde35cd 100644
--- a/tests/wast/spec/memory.wast
+++ b/tests/wast/spec/memory.wast
@@ -136,44 +136,44 @@
 
   ;; Sign and zero extending memory loads
   (func (export "i32_load8_s") (param $i i32) (result i32)
-	(i32.store8 (i32.const 8) (local.get $i))
-	(i32.load8_s (i32.const 8))
+    (i32.store8 (i32.const 8) (local.get $i))
+    (i32.load8_s (i32.const 8))
   )
   (func (export "i32_load8_u") (param $i i32) (result i32)
-	(i32.store8 (i32.const 8) (local.get $i))
-	(i32.load8_u (i32.const 8))
+    (i32.store8 (i32.const 8) (local.get $i))
+    (i32.load8_u (i32.const 8))
   )
   (func (export "i32_load16_s") (param $i i32) (result i32)
-	(i32.store16 (i32.const 8) (local.get $i))
-	(i32.load16_s (i32.const 8))
+    (i32.store16 (i32.const 8) (local.get $i))
+    (i32.load16_s (i32.const 8))
   )
   (func (export "i32_load16_u") (param $i i32) (result i32)
-	(i32.store16 (i32.const 8) (local.get $i))
-	(i32.load16_u (i32.const 8))
+    (i32.store16 (i32.const 8) (local.get $i))
+    (i32.load16_u (i32.const 8))
   )
   (func (export "i64_load8_s") (param $i i64) (result i64)
-	(i64.store8 (i32.const 8) (local.get $i))
-	(i64.load8_s (i32.const 8))
+    (i64.store8 (i32.const 8) (local.get $i))
+    (i64.load8_s (i32.const 8))
   )
   (func (export "i64_load8_u") (param $i i64) (result i64)
-	(i64.store8 (i32.const 8) (local.get $i))
-	(i64.load8_u (i32.const 8))
+    (i64.store8 (i32.const 8) (local.get $i))
+    (i64.load8_u (i32.const 8))
   )
   (func (export "i64_load16_s") (param $i i64) (result i64)
-	(i64.store16 (i32.const 8) (local.get $i))
-	(i64.load16_s (i32.const 8))
+    (i64.store16 (i32.const 8) (local.get $i))
+    (i64.load16_s (i32.const 8))
   )
   (func (export "i64_load16_u") (param $i i64) (result i64)
-	(i64.store16 (i32.const 8) (local.get $i))
-	(i64.load16_u (i32.const 8))
+    (i64.store16 (i32.const 8) (local.get $i))
+    (i64.load16_u (i32.const 8))
   )
   (func (export "i64_load32_s") (param $i i64) (result i64)
-	(i64.store32 (i32.const 8) (local.get $i))
-	(i64.load32_s (i32.const 8))
+    (i64.store32 (i32.const 8) (local.get $i))
+    (i64.load32_s (i32.const 8))
   )
   (func (export "i64_load32_u") (param $i i64) (result i64)
-	(i64.store32 (i32.const 8) (local.get $i))
-	(i64.load32_u (i32.const 8))
+    (i64.store32 (i32.const 8) (local.get $i))
+    (i64.load32_u (i32.const 8))
   )
 )
 
@@ -240,3 +240,28 @@
   "(import \"\" \"\" (memory $foo 1))"
   "(import \"\" \"\" (memory $foo 1))")
   "duplicate memory")
+
+;; Test that exporting random globals does not change a memory's semantics.
+
+(module
+  (memory (export "memory") 1 1)
+
+  ;; These should not change the behavior of memory accesses.
+  (global (export "__data_end") i32 (i32.const 10000))
+  (global (export "__stack_top") i32 (i32.const 10000))
+  (global (export "__heap_base") i32 (i32.const 10000))
+
+  (func (export "load") (param i32) (result i32)
+    (i32.load8_u (local.get 0))
+  )
+)
+
+;; None of these memory accesses should trap.
+(assert_return (invoke "load" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load" (i32.const 10000)) (i32.const 0))
+(assert_return (invoke "load" (i32.const 20000)) (i32.const 0))
+(assert_return (invoke "load" (i32.const 30000)) (i32.const 0))
+(assert_return (invoke "load" (i32.const 40000)) (i32.const 0))
+(assert_return (invoke "load" (i32.const 50000)) (i32.const 0))
+(assert_return (invoke "load" (i32.const 60000)) (i32.const 0))
+(assert_return (invoke "load" (i32.const 65535)) (i32.const 0))
diff --git a/tests/wast/spec/memory_grow.wast b/tests/wast/spec/memory_grow.wast
index aa56297d25..882e4b5893 100644
--- a/tests/wast/spec/memory_grow.wast
+++ b/tests/wast/spec/memory_grow.wast
@@ -309,6 +309,27 @@
 (assert_return (invoke "as-memory.grow-size") (i32.const 1))
 
 
+(module $Mgm
+  (memory (export "memory") 1) ;; initial size is 1
+  (func (export "grow") (result i32) (memory.grow (i32.const 1)))
+)
+(register "grown-memory" $Mgm)
+(assert_return (invoke $Mgm "grow") (i32.const 1)) ;; now size is 2
+(module $Mgim1
+  ;; imported memory limits should match, because external memory size is 2 now
+  (memory (export "memory") (import "grown-memory" "memory") 2)
+  (func (export "grow") (result i32) (memory.grow (i32.const 1)))
+)
+(register "grown-imported-memory" $Mgim1)
+(assert_return (invoke $Mgim1 "grow") (i32.const 2)) ;; now size is 3
+(module $Mgim2
+  ;; imported memory limits should match, because external memory size is 3 now
+  (import "grown-imported-memory" "memory" (memory 3))
+  (func (export "size") (result i32) (memory.size))
+)
+(assert_return (invoke $Mgim2 "size") (i32.const 3))
+
+
 (assert_invalid
   (module
     (memory 0)
diff --git a/tests/wast/spec/memory_trap.wast b/tests/wast/spec/memory_trap.wast
index a4156fe2c0..5ce8f5c31a 100644
--- a/tests/wast/spec/memory_trap.wast
+++ b/tests/wast/spec/memory_trap.wast
@@ -20,7 +20,7 @@
 
 (assert_return (invoke "store" (i32.const -4) (i32.const 42)))
 (assert_return (invoke "load" (i32.const -4)) (i32.const 42))
-(assert_trap (invoke "store" (i32.const -3) (i32.const 13)) "out of bounds memory access")
+(assert_trap (invoke "store" (i32.const -3) (i32.const 0x12345678)) "out of bounds memory access")
 (assert_trap (invoke "load" (i32.const -3)) "out of bounds memory access")
 (assert_trap (invoke "store" (i32.const -2) (i32.const 13)) "out of bounds memory access")
 (assert_trap (invoke "load" (i32.const -2)) "out of bounds memory access")
@@ -268,3 +268,15 @@
 ;; No memory was changed
 (assert_return (invoke "i64.load" (i32.const 0xfff8)) (i64.const 0x6867666564636261))
 (assert_return (invoke "i64.load" (i32.const 0)) (i64.const 0x6867666564636261))
+
+;; Check that out of bounds store do not store partial data.
+;; Zero last 8 bytes.
+(assert_return (invoke "i64.store" (i32.const 0xfff8) (i64.const 0)))
+(assert_trap (invoke "i32.store" (i32.const 0xfffd) (i32.const 0x12345678)) "out of bounds memory access")
+(assert_return (invoke "i32.load" (i32.const 0xfffc)) (i32.const 0))
+(assert_trap (invoke "i64.store" (i32.const 0xfff9) (i64.const 0x1234567890abcdef)) "out of bounds memory access")
+(assert_return (invoke "i64.load" (i32.const 0xfff8)) (i64.const 0))
+(assert_trap (invoke "f32.store" (i32.const 0xfffd) (f32.const 0x12345678)) "out of bounds memory access")
+(assert_return (invoke "f32.load" (i32.const 0xfffc)) (f32.const 0))
+(assert_trap (invoke "f64.store" (i32.const 0xfff9) (f64.const 0x1234567890abcdef)) "out of bounds memory access")
+(assert_return (invoke "f64.load" (i32.const 0xfff8)) (f64.const 0))
diff --git a/tests/wast/spec/obsolete-keywords.wast b/tests/wast/spec/obsolete-keywords.wast
new file mode 100644
index 0000000000..a90eb96d23
--- /dev/null
+++ b/tests/wast/spec/obsolete-keywords.wast
@@ -0,0 +1,82 @@
+;; Renamed in https://github.com/WebAssembly/spec/pull/720
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (drop (current_memory)))"
+  )
+  "unknown operator current_memory"
+)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (drop (grow_memory (i32.const 0))))"
+  )
+  "unknown operator grow_memory"
+)
+
+;; Renamed in https://github.com/WebAssembly/spec/pull/926
+(assert_malformed
+  (module quote
+    "(func (local $i i32) (drop (get_local $i)))"
+  )
+  "unknown operator get_local"
+)
+
+(assert_malformed
+  (module quote
+    "(func (local $i i32) (set_local $i (i32.const 0)))"
+  )
+  "unknown operator set_local"
+)
+
+(assert_malformed
+  (module quote
+    "(func (local $i i32) (drop (tee_local $i (i32.const 0))))"
+  )
+  "unknown operator tee_local"
+)
+
+(assert_malformed
+  (module quote
+    "(global $g anyfunc (ref.null func))"
+  )
+  "unknown operator anyfunc"
+)
+
+(assert_malformed
+  (module quote
+    "(global $g i32 (i32.const 0))"
+    "(func (drop (get_global $g)))"
+  )
+  "unknown operator get_global"
+)
+
+(assert_malformed
+  (module quote
+    "(global $g (mut i32) (i32.const 0))"
+    "(func (set_global $g (i32.const 0)))"
+  )
+  "unknown operator set_global"
+)
+
+(assert_malformed
+  (module quote
+    "(func (drop (i32.wrap/i64 (i64.const 0))))"
+  )
+  "unknown operator i32.wrap/i64"
+)
+
+(assert_malformed
+  (module quote
+    "(func (drop (i32.trunc_s:sat/f32 (f32.const 0))))"
+  )
+  "unknown operator i32.trunc_s:sat/f32"
+)
+
+(assert_malformed
+  (module quote
+    "(func (drop (f32x4.convert_s/i32x4 (v128.const i64x2 0 0))))"
+  )
+  "unknown operator f32x4.convert_s/i32x4"
+)
diff --git a/tests/wast/spec/proposals/exception-handling/easy_throw.wast b/tests/wast/spec/proposals/exception-handling/easy_throw.wast
new file mode 100644
index 0000000000..2a3cd1880c
--- /dev/null
+++ b/tests/wast/spec/proposals/exception-handling/easy_throw.wast
@@ -0,0 +1,40 @@
+(module
+  (tag $e0)
+
+  (func (export "simple-catch-all") (param i32) (result i32)
+    (block $h
+      (try_table (catch_all $h) (if (i32.eqz (local.get 0)) (then (throw $e0)) (else))
+		;; No exception thrown.
+		(i32.const 0)
+      	(return)
+	  )
+    )
+
+	;; The exception was thrown. 
+	(i32.const 1)
+	(return)
+  )
+)
+
+(assert_return (invoke "simple-catch-all" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "simple-catch-all" (i32.const 1)) (i32.const 0))
+
+(module
+  (tag $e1-i32 (param i32))
+
+  (func (export "simple-catch-i32") (param i32) (result i32)
+    (block $h (result i32)
+      (try_table (result i32) 
+		  (catch $e1-i32 $h)
+        (throw $e1-i32 (local.get 0))
+
+		;; Never going to be executed, of course.
+        (i32.const 2)
+      )
+    )
+    (return)
+  )
+)
+(assert_return (invoke "simple-catch-i32" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "simple-catch-i32" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "simple-catch-i32" (i32.const 2)) (i32.const 2))
diff --git a/tests/wast/spec/proposals/exception-handling/tag.wast b/tests/wast/spec/proposals/exception-handling/tag.wast
new file mode 100644
index 0000000000..aba017d2c7
--- /dev/null
+++ b/tests/wast/spec/proposals/exception-handling/tag.wast
@@ -0,0 +1,21 @@
+;; Test tag section
+
+(module
+  (tag)
+  (tag (param i32))
+  (tag (export "t2") (param i32))
+  (tag $t3 (param i32 f32))
+  (export "t3" (tag 3))
+)
+
+(register "test")
+
+(module
+  (tag $t0 (import "test" "t2") (param i32))
+  (import "test" "t3" (tag $t1 (param i32 f32)))
+)
+
+(assert_invalid
+  (module (tag (result i32)))
+  "non-empty tag result type"
+)
diff --git a/tests/wast/spec/proposals/exception-handling/throw.wast b/tests/wast/spec/proposals/exception-handling/throw.wast
new file mode 100644
index 0000000000..dc1aa4a98a
--- /dev/null
+++ b/tests/wast/spec/proposals/exception-handling/throw.wast
@@ -0,0 +1,55 @@
+;; Test throw instruction.
+
+(module
+  (tag $e0)
+  (tag $e-i32 (param i32))
+  (tag $e-f32 (param f32))
+  (tag $e-i64 (param i64))
+  (tag $e-f64 (param f64))
+  (tag $e-i32-i32 (param i32 i32))
+
+  (func $throw-if (export "throw-if") (param i32) (result i32)
+    (local.get 0)
+    (i32.const 0) (if (i32.ne) (then (throw $e0)))
+    (i32.const 0)
+  )
+
+  (func (export "throw-param-f32") (param f32) (local.get 0) (throw $e-f32))
+
+  (func (export "throw-param-i64") (param i64) (local.get 0) (throw $e-i64))
+
+  (func (export "throw-param-f64") (param f64) (local.get 0) (throw $e-f64))
+
+  (func (export "throw-polymorphic") (throw $e0) (throw $e-i32))
+
+  (func (export "throw-polymorphic-block") (block (result i32) (throw $e0)) (throw $e-i32))
+
+  (func $throw-1-2 (i32.const 1) (i32.const 2) (throw $e-i32-i32))
+  (func (export "test-throw-1-2")
+    (block $h (result i32 i32)
+      (try_table (catch $e-i32-i32 $h) (call $throw-1-2))
+      (return)
+    )
+    (if (i32.ne (i32.const 2)) (then (unreachable)))
+    (if (i32.ne (i32.const 1)) (then (unreachable)))
+  )
+)
+
+(assert_return (invoke "throw-if" (i32.const 0)) (i32.const 0))
+(assert_exception (invoke "throw-if" (i32.const 10)))
+(assert_exception (invoke "throw-if" (i32.const -1)))
+
+(assert_exception (invoke "throw-param-f32" (f32.const 5.0)))
+(assert_exception (invoke "throw-param-i64" (i64.const 5)))
+(assert_exception (invoke "throw-param-f64" (f64.const 5.0)))
+
+(assert_exception (invoke "throw-polymorphic"))
+(assert_exception (invoke "throw-polymorphic-block"))
+
+(assert_return (invoke "test-throw-1-2"))
+
+(assert_invalid (module (func (throw 0))) "unknown tag 0")
+(assert_invalid (module (tag (param i32)) (func (throw 0)))
+                "type mismatch: instruction requires [i32] but stack has []")
+(assert_invalid (module (tag (param i32)) (func (i64.const 5) (throw 0)))
+                "type mismatch: instruction requires [i32] but stack has [i64]")
diff --git a/tests/wast/spec/proposals/exception-handling/throw_ref.wast b/tests/wast/spec/proposals/exception-handling/throw_ref.wast
new file mode 100644
index 0000000000..f59710a1f9
--- /dev/null
+++ b/tests/wast/spec/proposals/exception-handling/throw_ref.wast
@@ -0,0 +1,118 @@
+;; Test throw_ref instruction.
+
+(module
+  (tag $e0)
+  (tag $e1)
+
+  (func (export "catch-throw_ref-0")
+    (block $h (result exnref)
+      (try_table (catch_ref $e0 $h) (throw $e0))
+      (unreachable)
+    )
+    (throw_ref)
+  )
+
+  (func (export "catch-throw_ref-1") (param i32) (result i32)
+    (block $h (result exnref)
+      (try_table (result i32) (catch_ref $e0 $h) (throw $e0))
+      (return)
+    )
+    (if (param exnref) (i32.eqz (local.get 0))
+      (then (throw_ref))
+      (else (drop))
+    )
+    (i32.const 23)
+  )
+
+  (func (export "catchall-throw_ref-0")
+    (block $h (result exnref)
+      (try_table (result exnref) (catch_all_ref $h) (throw $e0))
+    )
+    (throw_ref)
+  )
+
+  (func (export "catchall-throw_ref-1") (param i32) (result i32)
+    (block $h (result exnref)
+      (try_table (result i32) (catch_all_ref $h) (throw $e0))
+      (return)
+    )
+    (if (param exnref) (i32.eqz (local.get 0))
+      (then (throw_ref))
+      (else (drop))
+    )
+    (i32.const 23)
+  )
+
+  (func (export "throw_ref-nested") (param i32) (result i32)
+    (local $exn1 exnref)
+    (local $exn2 exnref)
+    (block $h1 (result exnref)
+      (try_table (result i32) (catch_ref $e1 $h1) (throw $e1))
+      (return)
+    )
+    (local.set $exn1)
+    (block $h2 (result exnref)
+      (try_table (result i32) (catch_ref $e0 $h2) (throw $e0))
+      (return)
+    )
+    (local.set $exn2)
+    (if (i32.eq (local.get 0) (i32.const 0))
+      (then (throw_ref (local.get $exn1)))
+    )
+    (if (i32.eq (local.get 0) (i32.const 1))
+      (then (throw_ref (local.get $exn2)))
+    )
+    (i32.const 23)
+  )
+
+  (func (export "throw_ref-recatch") (param i32) (result i32)
+    (local $e exnref)
+    (block $h1 (result exnref)
+      (try_table (result i32) (catch_ref $e0 $h1) (throw $e0))
+      (return)
+    )
+    (local.set $e)
+    (block $h2 (result exnref)
+      (try_table (result i32) (catch_ref $e0 $h2)
+        (if (i32.eqz (local.get 0))
+          (then (throw_ref (local.get $e)))
+        )
+        (i32.const 42)
+      )
+      (return)
+    )
+    (drop) (i32.const 23)
+  )
+
+  (func (export "throw_ref-stack-polymorphism")
+    (local $e exnref)
+    (block $h (result exnref)
+      (try_table (result f64) (catch_ref $e0 $h) (throw $e0))
+      (unreachable)
+    )
+    (local.set $e)
+    (i32.const 1)
+    (throw_ref (local.get $e))
+  )
+)
+
+(assert_exception (invoke "catch-throw_ref-0"))
+
+(assert_exception (invoke "catch-throw_ref-1" (i32.const 0)))
+(assert_return (invoke "catch-throw_ref-1" (i32.const 1)) (i32.const 23))
+
+(assert_exception (invoke "catchall-throw_ref-0"))
+
+(assert_exception (invoke "catchall-throw_ref-1" (i32.const 0)))
+(assert_return (invoke "catchall-throw_ref-1" (i32.const 1)) (i32.const 23))
+(assert_exception (invoke "throw_ref-nested" (i32.const 0)))
+(assert_exception (invoke "throw_ref-nested" (i32.const 1)))
+(assert_return (invoke "throw_ref-nested" (i32.const 2)) (i32.const 23))
+
+(assert_return (invoke "throw_ref-recatch" (i32.const 0)) (i32.const 23))
+(assert_return (invoke "throw_ref-recatch" (i32.const 1)) (i32.const 42))
+
+(assert_exception (invoke "throw_ref-stack-polymorphism"))
+
+(assert_invalid (module (func (throw_ref))) "type mismatch")
+(assert_invalid (module (func (block (throw_ref)))) "type mismatch")
diff --git a/tests/wast/spec/proposals/exception-handling/try_table.wast b/tests/wast/spec/proposals/exception-handling/try_table.wast
new file mode 100644
index 0000000000..97a181e201
--- /dev/null
+++ b/tests/wast/spec/proposals/exception-handling/try_table.wast
@@ -0,0 +1,426 @@
+;; Test try-catch blocks.
+
+(module
+  (tag $e0 (export "e0"))
+  (func (export "throw") (throw $e0))
+)
+
+(register "test")
+
+(module
+  (tag $imported-e0 (import "test" "e0"))
+  (tag $imported-e0-alias (import "test" "e0"))
+  (func $imported-throw (import "test" "throw"))
+  (tag $e0)
+  (tag $e1)
+  (tag $e2)
+  (tag $e-i32 (param i32))
+  (tag $e-f32 (param f32))
+  (tag $e-i64 (param i64))
+  (tag $e-f64 (param f64))
+
+ (func $throw-if (param i32) (result i32)
+   (local.get 0)
+   (i32.const 0) (if (i32.ne) (then (throw $e0)))
+   (i32.const 0)
+ )
+
+ (func (export "simple-throw-catch") (param i32) (result i32)
+   (block $h
+     (try_table (result i32) (catch $e0 $h)
+       (if (i32.eqz (local.get 0)) (then (throw $e0)) (else))
+       (i32.const 42)
+     )
+     (return)
+   )
+   (i32.const 23)
+ )
+
+ (func (export "unreachable-not-caught")
+   (block $h
+     (try_table (catch_all $h) (unreachable))
+     (return)
+   )
+ )
+
+ (func $div (param i32 i32) (result i32)
+   (local.get 0) (local.get 1) (i32.div_u)
+ )
+ (func (export "trap-in-callee") (param i32 i32) (result i32)
+   (block $h
+     (try_table (result i32) (catch_all $h)
+       (call $div (local.get 0) (local.get 1))
+     )
+     (return)
+   )
+   (i32.const 11)
+ )
+
+ (func (export "catch-complex-1") (param i32) (result i32)
+   (block $h1
+     (try_table (result i32) (catch $e1 $h1)
+       (block $h0
+         (try_table (result i32) (catch $e0 $h0)
+           (if (i32.eqz (local.get 0))
+             (then (throw $e0))
+             (else
+               (if (i32.eq (local.get 0) (i32.const 1))
+                 (then (throw $e1))
+                 (else (throw $e2))
+               )
+             )
+           )
+           (i32.const 2)
+         )
+         (br 1)
+       )
+       (i32.const 3)
+     )
+     (return)
+   )
+   (i32.const 4)
+ )
+
+ (func (export "catch-complex-2") (param i32) (result i32)
+   (block $h0
+     (block $h1
+       (try_table (result i32) (catch $e0 $h0) (catch $e1 $h1)
+         (if (i32.eqz (local.get 0))
+           (then (throw $e0))
+           (else
+             (if (i32.eq (local.get 0) (i32.const 1))
+               (then (throw $e1))
+               (else (throw $e2))
+             )
+           )
+          )
+         (i32.const 2)
+       )
+       (return)
+     )
+     (return (i32.const 4))
+   )
+   (i32.const 3)
+ )
+
+ (func (export "throw-catch-param-i32") (param i32) (result i32)
+   (block $h (result i32)
+     (try_table (result i32) (catch $e-i32 $h)
+       (throw $e-i32 (local.get 0))
+       (i32.const 2)
+     )
+     (return)
+   )
+   (return)
+ )
+
+ (func (export "throw-catch-param-f32") (param f32) (result f32)
+   (block $h (result f32)
+     (try_table (result f32) (catch $e-f32 $h)
+       (throw $e-f32 (local.get 0))
+       (f32.const 0)
+     )
+     (return)
+   )
+   (return)
+ )
+
+ (func (export "throw-catch-param-i64") (param i64) (result i64)
+   (block $h (result i64)
+     (try_table (result i64) (catch $e-i64 $h)
+       (throw $e-i64 (local.get 0))
+       (i64.const 2)
+     )
+     (return)
+   )
+   (return)
+ )
+
+ (func (export "throw-catch-param-f64") (param f64) (result f64)
+   (block $h (result f64)
+     (try_table (result f64) (catch $e-f64 $h)
+       (throw $e-f64 (local.get 0))
+       (f64.const 0)
+     )
+     (return)
+   )
+   (return)
+ )
+
+ (func (export "throw-catch_ref-param-i32") (param i32) (result i32)
+   (block $h (result i32 exnref)
+     (try_table (result i32) (catch_ref $e-i32 $h)
+       (throw $e-i32 (local.get 0))
+       (i32.const 2)
+     )
+     (return)
+   )
+   (drop) (return)
+ )
+
+ (func (export "throw-catch_ref-param-f32") (param f32) (result f32)
+   (block $h (result f32 exnref)
+     (try_table (result f32) (catch_ref $e-f32 $h)
+       (throw $e-f32 (local.get 0))
+       (f32.const 0)
+     )
+     (return)
+   )
+   (drop) (return)
+ )
+
+ (func (export "throw-catch_ref-param-i64") (param i64) (result i64)
+   (block $h (result i64 exnref)
+     (try_table (result i64) (catch_ref $e-i64 $h)
+       (throw $e-i64 (local.get 0))
+       (i64.const 2)
+     )
+     (return)
+   )
+   (drop) (return)
+ )
+
+ (func (export "throw-catch_ref-param-f64") (param f64) (result f64)
+   (block $h (result f64 exnref)
+     (try_table (result f64) (catch_ref $e-f64 $h)
+       (throw $e-f64 (local.get 0))
+       (f64.const 0)
+     )
+     (return)
+   )
+   (drop) (return)
+ )
+
+ (func $throw-param-i32 (param i32) (throw $e-i32 (local.get 0)))
+ (func (export "catch-param-i32") (param i32) (result i32)
+   (block $h (result i32)
+     (try_table (result i32) (catch $e-i32 $h)
+       (i32.const 0)
+       (call $throw-param-i32 (local.get 0))
+     )
+     (return)
+   )
+ )
+
+ (func (export "catch-imported") (result i32)
+   (block $h
+     (try_table (result i32) (catch $imported-e0 $h)
+       (call $imported-throw (i32.const 1))
+     )
+     (return)
+   )
+   (i32.const 2)
+ )
+
+ (func (export "catch-imported-alias") (result i32)
+   (block $h
+     (try_table (result i32) (catch $imported-e0 $h)
+       (throw $imported-e0-alias (i32.const 1))
+     )
+     (return)
+   )
+   (i32.const 2)
+ )
+
+  (func (export "catchless-try") (param i32) (result i32)
+    (block $h
+      (try_table (result i32) (catch $e0 $h)
+        (try_table (result i32) (call $throw-if (local.get 0)))
+      )
+      (return)
+    )
+    (i32.const 1)
+  )
+
+  (func $throw-void (throw $e0))
+  ;; (xdoardo): Disabled for now (requires tail-call proposal implementation)
+  ;; (func (export "return-call-in-try-catch")
+  ;;   (block $h
+  ;;     (try_table (catch $e0 $h)
+  ;;       (return_call $throw-void)
+  ;;     )
+  ;;   )
+  ;; )
+
+  (table funcref (elem $throw-void))
+  ;; (xdoardo): Disabled for now (requires tail-call proposal implementation)
+  ;; (func (export "return-call-indirect-in-try-catch")
+  ;;   (block $h
+  ;;     (try_table (catch $e0 $h)
+  ;;       (return_call_indirect (i32.const 0))
+  ;;     )
+  ;;   )
+  ;; )
+
+  (func (export "try-with-param")
+    (i32.const 0) (try_table (param i32) (drop))
+  )
+
+  (func (export "multiple-catch-targeting-same-block") (result i32)
+    (block $outer
+        (block $catch
+          try_table (catch $e1 $catch) (catch $e2 $catch) (catch $e2 $outer)
+              throw $e2
+          end
+          unreachable
+        )
+        i32.const 42
+        return
+    )
+    unreachable
+  )
+
+  (func (export "nested-catch-ref") (result i32)
+    (block $outer (result exnref)
+      (try_table (catch_all_ref $outer)
+        (block $inner
+          (try_table (catch $e1 $inner)
+            (throw $e0)
+          )
+          unreachable
+        )
+        unreachable
+      )
+      unreachable
+    )
+    drop
+    i32.const 42
+  )
+)
+
+(assert_return (invoke "simple-throw-catch" (i32.const 0)) (i32.const 23))
+(assert_return (invoke "simple-throw-catch" (i32.const 1)) (i32.const 42))
+
+(assert_trap (invoke "unreachable-not-caught") "unreachable")
+
+(assert_return (invoke "trap-in-callee" (i32.const 7) (i32.const 2)) (i32.const 3))
+(assert_trap (invoke "trap-in-callee" (i32.const 1) (i32.const 0)) "integer divide by zero")
+
+(assert_return (invoke "catch-complex-1" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "catch-complex-1" (i32.const 1)) (i32.const 4))
+(assert_exception (invoke "catch-complex-1" (i32.const 2)))
+
+(assert_return (invoke "catch-complex-2" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "catch-complex-2" (i32.const 1)) (i32.const 4))
+(assert_exception (invoke "catch-complex-2" (i32.const 2)))
+
+(assert_return (invoke "throw-catch-param-i32" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "throw-catch-param-i32" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "throw-catch-param-i32" (i32.const 10)) (i32.const 10))
+
+(assert_return (invoke "throw-catch-param-f32" (f32.const 5.0)) (f32.const 5.0))
+(assert_return (invoke "throw-catch-param-f32" (f32.const 10.5)) (f32.const 10.5))
+
+(assert_return (invoke "throw-catch-param-i64" (i64.const 5)) (i64.const 5))
+(assert_return (invoke "throw-catch-param-i64" (i64.const 0)) (i64.const 0))
+(assert_return (invoke "throw-catch-param-i64" (i64.const -1)) (i64.const -1))
+
+(assert_return (invoke "throw-catch-param-f64" (f64.const 5.0)) (f64.const 5.0))
+(assert_return (invoke "throw-catch-param-f64" (f64.const 10.5)) (f64.const 10.5))
+
+(assert_return (invoke "throw-catch_ref-param-i32" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "throw-catch_ref-param-i32" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "throw-catch_ref-param-i32" (i32.const 10)) (i32.const 10))
+
+(assert_return (invoke "throw-catch_ref-param-f32" (f32.const 5.0)) (f32.const 5.0))
+(assert_return (invoke "throw-catch_ref-param-f32" (f32.const 10.5)) (f32.const 10.5))
+
+(assert_return (invoke "throw-catch_ref-param-i64" (i64.const 5)) (i64.const 5))
+(assert_return (invoke "throw-catch_ref-param-i64" (i64.const 0)) (i64.const 0))
+(assert_return (invoke "throw-catch_ref-param-i64" (i64.const -1)) (i64.const -1))
+
+(assert_return (invoke "throw-catch_ref-param-f64" (f64.const 5.0)) (f64.const 5.0))
+(assert_return (invoke "throw-catch_ref-param-f64" (f64.const 10.5)) (f64.const 10.5))
+
+(assert_return (invoke "catch-param-i32" (i32.const 5)) (i32.const 5))
+
+(assert_return (invoke "catch-imported") (i32.const 2))
+(assert_return (invoke "catch-imported-alias") (i32.const 2))
+
+(assert_return (invoke "catchless-try" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "catchless-try" (i32.const 1)) (i32.const 1))
+
+;; (assert_exception (invoke "return-call-in-try-catch"))
+;; (assert_exception (invoke "return-call-indirect-in-try-catch"))
+
+(assert_return (invoke "try-with-param"))
+
+(assert_return (invoke "multiple-catch-targeting-same-block") (i32.const 42))
+(assert_return (invoke "nested-catch-ref") (i32.const 42))
+
+ (module
+   (func $imported-throw (import "test" "throw"))
+   (tag $e0)
+ 
+   (func (export "imported-mismatch") (result i32)
+     (block $h
+       (try_table (result i32) (catch_all $h)
+         (block $h0
+           (try_table (result i32) (catch $e0 $h0)
+             (i32.const 1)
+             (call $imported-throw)
+           )
+           (return)
+         )
+         (i32.const 2)
+       )
+       (return)
+     )
+     (i32.const 3)
+   )
+ )
+ 
+ (assert_return (invoke "imported-mismatch") (i32.const 3))
+ 
+ (assert_malformed
+   (module quote "(module (func (catch_all)))")
+   "unexpected token"
+ )
+ 
+ (assert_malformed
+   (module quote "(module (tag $e) (func (catch $e)))")
+   "unexpected token"
+ )
+ 
+ (module
+   (tag $e)
+   (func (try_table (catch $e 0) (catch $e 0)))
+   (func (try_table (catch_all 0) (catch $e 0)))
+   (func (try_table (catch_all 0) (catch_all 0)))
+   (func (result exnref) (try_table (catch_ref $e 0) (catch_ref $e 0)) (unreachable))
+   (func (result exnref) (try_table (catch_all_ref 0) (catch_ref $e 0)) (unreachable))
+   (func (result exnref) (try_table (catch_all_ref 0) (catch_all_ref 0)) (unreachable))
+ )
+ 
+ (assert_invalid
+   (module (func (result i32) (try_table (result i32))))
+   "type mismatch"
+ )
+ (assert_invalid
+   (module (func (result i32) (try_table (result i32) (i64.const 42))))
+   "type mismatch"
+ )
+ 
+ (assert_invalid
+   (module (tag) (func (try_table (catch_ref 0 0))))
+   "type mismatch"
+ )
+ (assert_invalid
+   (module (tag) (func (result exnref) (try_table (catch 0 0)) (unreachable)))
+   "type mismatch"
+ )
+ (assert_invalid
+   (module (func (try_table (catch_all_ref 0))))
+   "type mismatch"
+ )
+ (assert_invalid
+   (module (func (result exnref) (try_table (catch_all 0)) (unreachable)))
+   "type mismatch"
+ )
+ (assert_invalid
+   (module
+     (tag (param i64))
+     (func (result i32 exnref) (try_table (result i32) (catch_ref 0 0) (i32.const 42)))
+   )
+   "type mismatch"
+ )
diff --git a/tests/wast/spec/proposals/gc/array.wast b/tests/wast/spec/proposals/gc/array.wast
index 48a58108b7..6ad95c0873 100644
--- a/tests/wast/spec/proposals/gc/array.wast
+++ b/tests/wast/spec/proposals/gc/array.wast
@@ -8,11 +8,9 @@
   (type (array f32))
   (type (array f64))
   (type (array anyref))
-  (type (array (ref data)))
+  (type (array (ref struct)))
   (type (array (ref 0)))
   (type (array (ref null 1)))
-  (type (array (rtt 1)))
-  (type (array (rtt 10 1)))
   (type (array (mut i8)))
   (type (array (mut i16)))
   (type (array (mut i32)))
@@ -20,11 +18,9 @@
   (type (array (mut i32)))
   (type (array (mut i64)))
   (type (array (mut anyref)))
-  (type (array (mut (ref data))))
+  (type (array (mut (ref struct))))
   (type (array (mut (ref 0))))
   (type (array (mut (ref null i31))))
-  (type (array (mut (rtt 0))))
-  (type (array (mut (rtt 10 0))))
 )
 
 
@@ -39,8 +35,10 @@
 ;; Binding structure
 
 (module
-  (type $s0 (array (ref $s1)))
-  (type $s1 (array (ref $s0)))
+  (rec
+    (type $s0 (array (ref $s1)))
+    (type $s1 (array (ref $s0)))
+  )
 
   (func (param (ref $forward)))
 
@@ -63,13 +61,18 @@
   (type $vec (array f32))
   (type $mvec (array (mut f32)))
 
+  (global (ref $vec) (array.new $vec (f32.const 1) (i32.const 3)))
+  (global (ref $vec) (array.new_default $vec (i32.const 3)))
+
+  (func $new (export "new") (result (ref $vec))
+    (array.new_default $vec (i32.const 3))
+  )
+
   (func $get (param $i i32) (param $v (ref $vec)) (result f32)
     (array.get $vec (local.get $v) (local.get $i))
   )
   (func (export "get") (param $i i32) (result f32)
-    (call $get (local.get $i)
-      (array.new_default $vec (i32.const 3) (rtt.canon $vec))
-    )
+    (call $get (local.get $i) (call $new))
   )
 
   (func $set_get (param $i i32) (param $v (ref $mvec)) (param $y f32) (result f32)
@@ -78,25 +81,185 @@
   )
   (func (export "set_get") (param $i i32) (param $y f32) (result f32)
     (call $set_get (local.get $i)
-      (array.new_default $mvec (i32.const 3) (rtt.canon $mvec))
+      (array.new_default $mvec (i32.const 3))
       (local.get $y)
     )
   )
 
-  (func $len (param $v (ref $vec)) (result i32)
-    (array.len $vec (local.get $v))
+  (func $len (param $v (ref array)) (result i32)
+    (array.len (local.get $v))
   )
   (func (export "len") (result i32)
-    (call $len (array.new_default $vec (i32.const 3) (rtt.canon $vec)))
+    (call $len (call $new))
   )
 )
 
+(assert_return (invoke "new") (ref.array))
+(assert_return (invoke "new") (ref.eq))
 (assert_return (invoke "get" (i32.const 0)) (f32.const 0))
 (assert_return (invoke "set_get" (i32.const 1) (f32.const 7)) (f32.const 7))
 (assert_return (invoke "len") (i32.const 3))
 
-(assert_trap (invoke "get" (i32.const 10)) "out of bounds")
-(assert_trap (invoke "set_get" (i32.const 10) (f32.const 7)) "out of bounds")
+(assert_trap (invoke "get" (i32.const 10)) "out of bounds array access")
+(assert_trap (invoke "set_get" (i32.const 10) (f32.const 7)) "out of bounds array access")
+
+(module
+  (type $vec (array f32))
+  (type $mvec (array (mut f32)))
+
+  (global (ref $vec) (array.new_fixed $vec 2 (f32.const 1) (f32.const 2)))
+
+  (func $new (export "new") (result (ref $vec))
+    (array.new_fixed $vec 2 (f32.const 1) (f32.const 2))
+  )
+
+  (func $get (param $i i32) (param $v (ref $vec)) (result f32)
+    (array.get $vec (local.get $v) (local.get $i))
+  )
+  (func (export "get") (param $i i32) (result f32)
+    (call $get (local.get $i) (call $new))
+  )
+
+  (func $set_get (param $i i32) (param $v (ref $mvec)) (param $y f32) (result f32)
+    (array.set $mvec (local.get $v) (local.get $i) (local.get $y))
+    (array.get $mvec (local.get $v) (local.get $i))
+  )
+  (func (export "set_get") (param $i i32) (param $y f32) (result f32)
+    (call $set_get (local.get $i)
+      (array.new_fixed $mvec 3 (f32.const 1) (f32.const 2) (f32.const 3))
+      (local.get $y)
+    )
+  )
+
+  (func $len (param $v (ref array)) (result i32)
+    (array.len (local.get $v))
+  )
+  (func (export "len") (result i32)
+    (call $len (call $new))
+  )
+)
+
+(assert_return (invoke "new") (ref.array))
+(assert_return (invoke "new") (ref.eq))
+(assert_return (invoke "get" (i32.const 0)) (f32.const 1))
+(assert_return (invoke "set_get" (i32.const 1) (f32.const 7)) (f32.const 7))
+(assert_return (invoke "len") (i32.const 2))
+
+(assert_trap (invoke "get" (i32.const 10)) "out of bounds array access")
+(assert_trap (invoke "set_get" (i32.const 10) (f32.const 7)) "out of bounds array access")
+
+(module
+  (type $vec (array i8))
+  (type $mvec (array (mut i8)))
+
+  (data $d "\00\01\02\ff\04")
+
+  (func $new (export "new") (result (ref $vec))
+    (array.new_data $vec $d (i32.const 1) (i32.const 3))
+  )
+
+  (func $get_u (param $i i32) (param $v (ref $vec)) (result i32)
+    (array.get_u $vec (local.get $v) (local.get $i))
+  )
+  (func (export "get_u") (param $i i32) (result i32)
+    (call $get_u (local.get $i) (call $new))
+  )
+
+  (func $get_s (param $i i32) (param $v (ref $vec)) (result i32)
+    (array.get_s $vec (local.get $v) (local.get $i))
+  )
+  (func (export "get_s") (param $i i32) (result i32)
+    (call $get_s (local.get $i) (call $new))
+  )
+
+  (func $set_get (param $i i32) (param $v (ref $mvec)) (param $y i32) (result i32)
+    (array.set $mvec (local.get $v) (local.get $i) (local.get $y))
+    (array.get_u $mvec (local.get $v) (local.get $i))
+  )
+  (func (export "set_get") (param $i i32) (param $y i32) (result i32)
+    (call $set_get (local.get $i)
+      (array.new_data $mvec $d (i32.const 1) (i32.const 3))
+      (local.get $y)
+    )
+  )
+
+  (func $len (param $v (ref array)) (result i32)
+    (array.len (local.get $v))
+  )
+  (func (export "len") (result i32)
+    (call $len (call $new))
+  )
+)
+
+(assert_return (invoke "new") (ref.array))
+(assert_return (invoke "new") (ref.eq))
+(assert_return (invoke "get_u" (i32.const 2)) (i32.const 0xff))
+(assert_return (invoke "get_s" (i32.const 2)) (i32.const -1))
+(assert_return (invoke "set_get" (i32.const 1) (i32.const 7)) (i32.const 7))
+(assert_return (invoke "len") (i32.const 3))
+
+(assert_trap (invoke "get_u" (i32.const 10)) "out of bounds array access")
+(assert_trap (invoke "get_s" (i32.const 10)) "out of bounds array access")
+(assert_trap (invoke "set_get" (i32.const 10) (i32.const 7)) "out of bounds array access")
+
+(module
+  (type $bvec (array i8))
+  (type $vec (array (ref $bvec)))
+  (type $mvec (array (mut (ref $bvec))))
+  (type $nvec (array (ref null $bvec)))
+  (type $avec (array (mut anyref)))
+
+  (elem $e (ref $bvec)
+    (array.new $bvec (i32.const 7) (i32.const 3))
+    (array.new_fixed $bvec 2 (i32.const 1) (i32.const 2))
+  )
+
+  (func $new (export "new") (result (ref $vec))
+    (array.new_elem $vec $e (i32.const 0) (i32.const 2))
+  )
+
+  (func $sub1 (result (ref $nvec))
+    (array.new_elem $nvec $e (i32.const 0) (i32.const 2))
+  )
+  (func $sub2 (result (ref $avec))
+    (array.new_elem $avec $e (i32.const 0) (i32.const 2))
+  )
+
+  (func $get (param $i i32) (param $j i32) (param $v (ref $vec)) (result i32)
+    (array.get_u $bvec (array.get $vec (local.get $v) (local.get $i)) (local.get $j))
+  )
+  (func (export "get") (param $i i32) (param $j i32) (result i32)
+    (call $get (local.get $i) (local.get $j) (call $new))
+  )
+
+  (func $set_get (param $i i32) (param $j i32) (param $v (ref $mvec)) (param $y i32) (result i32)
+    (array.set $mvec (local.get $v) (local.get $i) (array.get $mvec (local.get $v) (local.get $y)))
+    (array.get_u $bvec (array.get $mvec (local.get $v) (local.get $i)) (local.get $j))
+  )
+  (func (export "set_get") (param $i i32) (param $j i32) (param $y i32) (result i32)
+    (call $set_get (local.get $i) (local.get $j)
+      (array.new_elem $mvec $e (i32.const 0) (i32.const 2))
+      (local.get $y)
+    )
+  )
+
+  (func $len (param $v (ref array)) (result i32)
+    (array.len (local.get $v))
+  )
+  (func (export "len") (result i32)
+    (call $len (call $new))
+  )
+)
+
+(assert_return (invoke "new") (ref.array))
+(assert_return (invoke "new") (ref.eq))
+(assert_return (invoke "get" (i32.const 0) (i32.const 0)) (i32.const 7))
+(assert_return (invoke "get" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "set_get" (i32.const 0) (i32.const 1) (i32.const 1)) (i32.const 2))
+(assert_return (invoke "len") (i32.const 2))
+
+(assert_trap (invoke "get" (i32.const 10) (i32.const 0)) "out of bounds array access")
+(assert_trap (invoke "set_get" (i32.const 10) (i32.const 0) (i32.const 0)) "out of bounds array access")
 
 (assert_invalid
   (module
@@ -108,6 +271,33 @@
   "array is immutable"
 )
 
+(assert_invalid
+  (module
+    (type $bvec (array i8))
+
+    (data $d "\00\01\02\03\04")
+
+    (global (ref $bvec)
+      (array.new_data $bvec $d (i32.const 1) (i32.const 3))
+    )
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (type $bvec (array i8))
+    (type $vvec (array (ref $bvec)))
+
+    (elem $e (ref $bvec) (ref.null $bvec))
+
+    (global (ref $vvec)
+      (array.new_elem $vvec $e (i32.const 0) (i32.const 1))
+    )
+  )
+  "constant expression required"
+)
+
 
 ;; Null dereference
 
@@ -121,24 +311,5 @@
   )
 )
 
-(assert_trap (invoke "array.get-null") "null array")
-(assert_trap (invoke "array.set-null") "null array")
-
-(assert_invalid
-  (module
-    (type $t (array i32))
-    (func (export "array.new-null")
-      (local (ref null (rtt $t))) (drop (array.new_default $t (i32.const 1) (i32.const 3) (local.get 0)))
-    )
-  )
-  "type mismatch"
-)
-(assert_invalid
-  (module
-    (type $t (array (mut i32)))
-    (func (export "array.new_default-null")
-      (local (ref null (rtt $t))) (drop (array.new_default $t (i32.const 3) (local.get 0)))
-    )
-  )
-  "type mismatch"
-)
+(assert_trap (invoke "array.get-null") "null array reference")
+(assert_trap (invoke "array.set-null") "null array reference")
diff --git a/tests/wast/spec/proposals/gc/array_copy.wast b/tests/wast/spec/proposals/gc/array_copy.wast
new file mode 100644
index 0000000000..d1caf12647
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/array_copy.wast
@@ -0,0 +1,139 @@
+;; Bulk instructions
+
+;; invalid uses
+
+(assert_invalid
+  (module
+    (type $a (array i8))
+    (type $b (array (mut i8)))
+
+    (func (export "array.copy-immutable") (param $1 (ref $a)) (param $2 (ref $b))
+      (array.copy $a $b (local.get $1) (i32.const 0) (local.get $2) (i32.const 0) (i32.const 0))
+    )
+  )
+  "array is immutable"
+)
+
+(assert_invalid
+  (module
+    (type $a (array (mut i8)))
+    (type $b (array i16))
+
+    (func (export "array.copy-packed-invalid") (param $1 (ref $a)) (param $2 (ref $b))
+      (array.copy $a $b (local.get $1) (i32.const 0) (local.get $2) (i32.const 0) (i32.const 0))
+    )
+  )
+  "array types do not match"
+)
+
+(assert_invalid
+  (module
+    (type $a (array (mut i8)))
+    (type $b (array (mut (ref $a))))
+
+    (func (export "array.copy-ref-invalid-1") (param $1 (ref $a)) (param $2 (ref $b))
+      (array.copy $a $b (local.get $1) (i32.const 0) (local.get $2) (i32.const 0) (i32.const 0))
+    )
+  )
+  "array types do not match"
+)
+
+(assert_invalid
+  (module
+    (type $a (array (mut i8)))
+    (type $b (array (mut (ref $a))))
+    (type $c (array (mut (ref $b))))
+
+    (func (export "array.copy-ref-invalid-1") (param $1 (ref $b)) (param $2 (ref $c))
+      (array.copy $b $c (local.get $1) (i32.const 0) (local.get $2) (i32.const 0) (i32.const 0))
+    )
+  )
+  "array types do not match"
+)
+
+(module
+  (type $arr8 (array i8))
+  (type $arr8_mut (array (mut i8)))
+
+  (global $g_arr8 (ref $arr8) (array.new $arr8 (i32.const 10) (i32.const 12)))
+  (global $g_arr8_mut (mut (ref $arr8_mut)) (array.new_default $arr8_mut (i32.const 12)))
+
+  (data $d1 "abcdefghijkl")
+
+  (func (export "array_get_nth") (param $1 i32) (result i32)
+    (array.get_u $arr8_mut (global.get $g_arr8_mut) (local.get $1))
+  )
+
+  (func (export "array_copy-null-left")
+    (array.copy $arr8_mut $arr8 (ref.null $arr8_mut) (i32.const 0) (global.get $g_arr8) (i32.const 0) (i32.const 0))
+  )
+
+  (func (export "array_copy-null-right")
+    (array.copy $arr8_mut $arr8 (global.get $g_arr8_mut) (i32.const 0) (ref.null $arr8) (i32.const 0) (i32.const 0))
+  )
+
+  (func (export "array_copy") (param $1 i32) (param $2 i32) (param $3 i32)
+    (array.copy $arr8_mut $arr8 (global.get $g_arr8_mut) (local.get $1) (global.get $g_arr8) (local.get $2) (local.get $3))
+  )
+
+  (func (export "array_copy_overlap_test-1")
+    (local $1 (ref $arr8_mut))
+    (array.new_data $arr8_mut $d1 (i32.const 0) (i32.const 12))
+    (local.set $1)
+    (array.copy $arr8_mut $arr8_mut (local.get $1) (i32.const 1) (local.get $1) (i32.const 0) (i32.const 11))
+    (global.set $g_arr8_mut (local.get $1))
+  )
+
+  (func (export "array_copy_overlap_test-2")
+    (local $1 (ref $arr8_mut))
+    (array.new_data $arr8_mut $d1 (i32.const 0) (i32.const 12))
+    (local.set $1)
+    (array.copy $arr8_mut $arr8_mut (local.get $1) (i32.const 0) (local.get $1) (i32.const 1) (i32.const 11))
+    (global.set $g_arr8_mut (local.get $1))
+  )
+)
+
+;; null array argument traps
+(assert_trap (invoke "array_copy-null-left") "null array reference")
+(assert_trap (invoke "array_copy-null-right") "null array reference")
+
+;; OOB initial index traps
+(assert_trap (invoke "array_copy" (i32.const 13) (i32.const 0) (i32.const 0)) "out of bounds array access")
+(assert_trap (invoke "array_copy" (i32.const 0) (i32.const 13) (i32.const 0)) "out of bounds array access")
+
+;; OOB length traps
+(assert_trap (invoke "array_copy" (i32.const 0) (i32.const 0) (i32.const 13)) "out of bounds array access")
+(assert_trap (invoke "array_copy" (i32.const 0) (i32.const 0) (i32.const 13)) "out of bounds array access")
+
+;; start index = array size, len = 0 doesn't trap
+(assert_return (invoke "array_copy" (i32.const 12) (i32.const 0) (i32.const 0)))
+(assert_return (invoke "array_copy" (i32.const 0) (i32.const 12) (i32.const 0)))
+
+;; check arrays were not modified
+(assert_return (invoke "array_get_nth" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "array_get_nth" (i32.const 5)) (i32.const 0))
+(assert_return (invoke "array_get_nth" (i32.const 11)) (i32.const 0))
+(assert_trap (invoke "array_get_nth" (i32.const 12)) "out of bounds array access")
+
+;; normal case
+(assert_return (invoke "array_copy" (i32.const 0) (i32.const 0) (i32.const 2)))
+(assert_return (invoke "array_get_nth" (i32.const 0)) (i32.const 10))
+(assert_return (invoke "array_get_nth" (i32.const 1)) (i32.const 10))
+(assert_return (invoke "array_get_nth" (i32.const 2)) (i32.const 0))
+
+;; test that overlapping array.copy works as if intermediate copy taken
+(assert_return (invoke "array_copy_overlap_test-1"))
+(assert_return (invoke "array_get_nth" (i32.const 0)) (i32.const 97))
+(assert_return (invoke "array_get_nth" (i32.const 1)) (i32.const 97))
+(assert_return (invoke "array_get_nth" (i32.const 2)) (i32.const 98))
+(assert_return (invoke "array_get_nth" (i32.const 5)) (i32.const 101))
+(assert_return (invoke "array_get_nth" (i32.const 10)) (i32.const 106))
+(assert_return (invoke "array_get_nth" (i32.const 11)) (i32.const 107))
+
+(assert_return (invoke "array_copy_overlap_test-2"))
+(assert_return (invoke "array_get_nth" (i32.const 0)) (i32.const 98))
+(assert_return (invoke "array_get_nth" (i32.const 1)) (i32.const 99))
+(assert_return (invoke "array_get_nth" (i32.const 5)) (i32.const 103))
+(assert_return (invoke "array_get_nth" (i32.const 9)) (i32.const 107))
+(assert_return (invoke "array_get_nth" (i32.const 10)) (i32.const 108))
+(assert_return (invoke "array_get_nth" (i32.const 11)) (i32.const 108))
diff --git a/tests/wast/spec/proposals/gc/array_fill.wast b/tests/wast/spec/proposals/gc/array_fill.wast
new file mode 100644
index 0000000000..0379ad537e
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/array_fill.wast
@@ -0,0 +1,81 @@
+;; Bulk instructions
+
+;; invalid uses
+
+(assert_invalid
+  (module
+    (type $a (array i8))
+
+    (func (export "array.fill-immutable") (param $1 (ref $a)) (param $2 i32)
+      (array.fill $a (local.get $1) (i32.const 0) (local.get $2) (i32.const 0))
+    )
+  )
+  "array is immutable"
+)
+
+(assert_invalid
+  (module
+    (type $a (array (mut i8)))
+
+    (func (export "array.fill-invalid-1") (param $1 (ref $a)) (param $2 funcref)
+      (array.fill $a (local.get $1) (i32.const 0) (local.get $2) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $b (array (mut funcref)))
+
+    (func (export "array.fill-invalid-1") (param $1 (ref $b)) (param $2 i32)
+      (array.fill $b (local.get $1) (i32.const 0) (local.get $2) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+
+(module
+  (type $arr8 (array i8))
+  (type $arr8_mut (array (mut i8)))
+
+  (global $g_arr8 (ref $arr8) (array.new $arr8 (i32.const 10) (i32.const 12)))
+  (global $g_arr8_mut (mut (ref $arr8_mut)) (array.new_default $arr8_mut (i32.const 12)))
+
+  (func (export "array_get_nth") (param $1 i32) (result i32)
+    (array.get_u $arr8_mut (global.get $g_arr8_mut) (local.get $1))
+  )
+
+  (func (export "array_fill-null")
+    (array.fill $arr8_mut (ref.null $arr8_mut) (i32.const 0) (i32.const 0) (i32.const 0))
+  )
+
+  (func (export "array_fill") (param $1 i32) (param $2 i32) (param $3 i32)
+    (array.fill $arr8_mut (global.get $g_arr8_mut) (local.get $1) (local.get $2) (local.get $3))
+  )
+)
+
+;; null array argument traps
+(assert_trap (invoke "array_fill-null") "null array reference")
+
+;; OOB initial index traps
+(assert_trap (invoke "array_fill" (i32.const 13) (i32.const 0) (i32.const 0)) "out of bounds array access")
+
+;; OOB length traps
+(assert_trap (invoke "array_fill" (i32.const 0) (i32.const 0) (i32.const 13)) "out of bounds array access")
+
+;; start index = array size, len = 0 doesn't trap
+(assert_return (invoke "array_fill" (i32.const 12) (i32.const 0) (i32.const 0)))
+
+;; check arrays were not modified
+(assert_return (invoke "array_get_nth" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "array_get_nth" (i32.const 5)) (i32.const 0))
+(assert_return (invoke "array_get_nth" (i32.const 11)) (i32.const 0))
+(assert_trap (invoke "array_get_nth" (i32.const 12)) "out of bounds array access")
+
+;; normal case
+(assert_return (invoke "array_fill" (i32.const 2) (i32.const 11) (i32.const 2)))
+(assert_return (invoke "array_get_nth" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "array_get_nth" (i32.const 2)) (i32.const 11))
+(assert_return (invoke "array_get_nth" (i32.const 3)) (i32.const 11))
+(assert_return (invoke "array_get_nth" (i32.const 4)) (i32.const 0))
diff --git a/tests/wast/spec/proposals/gc/array_init_data.wast b/tests/wast/spec/proposals/gc/array_init_data.wast
new file mode 100644
index 0000000000..3bee026474
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/array_init_data.wast
@@ -0,0 +1,110 @@
+;; Bulk instructions
+
+;; invalid uses
+
+(assert_invalid
+  (module
+    (type $a (array i8))
+
+    (data $d1 "a")
+
+    (func (export "array.init_data-immutable") (param $1 (ref $a))
+      (array.init_data $a $d1 (local.get $1) (i32.const 0) (i32.const 0) (i32.const 0))
+    )
+  )
+  "array is immutable"
+)
+
+(assert_invalid
+  (module
+    (type $a (array (mut funcref)))
+
+    (data $d1 "a")
+
+    (func (export "array.init_data-invalid-1") (param $1 (ref $a))
+      (array.init_data $a $d1 (local.get $1) (i32.const 0) (i32.const 0) (i32.const 0))
+    )
+  )
+  "array type is not numeric or vector"
+)
+
+(module
+  (type $arr8 (array i8))
+  (type $arr8_mut (array (mut i8)))
+  (type $arr16_mut (array (mut i16)))
+
+  (global $g_arr8 (ref $arr8) (array.new $arr8 (i32.const 10) (i32.const 12)))
+  (global $g_arr8_mut (mut (ref $arr8_mut)) (array.new_default $arr8_mut (i32.const 12)))
+  (global $g_arr16_mut (ref $arr16_mut) (array.new_default $arr16_mut (i32.const 6)))
+
+  (data $d1 "abcdefghijkl")
+
+  (func (export "array_get_nth") (param $1 i32) (result i32)
+    (array.get_u $arr8_mut (global.get $g_arr8_mut) (local.get $1))
+  )
+
+  (func (export "array_get_nth_i16") (param $1 i32) (result i32)
+    (array.get_u $arr16_mut (global.get $g_arr16_mut) (local.get $1))
+  )
+
+  (func (export "array_init_data-null")
+    (array.init_data $arr8_mut $d1 (ref.null $arr8_mut) (i32.const 0) (i32.const 0) (i32.const 0))
+  )
+
+  (func (export "array_init_data") (param $1 i32) (param $2 i32) (param $3 i32)
+    (array.init_data $arr8_mut $d1 (global.get $g_arr8_mut) (local.get $1) (local.get $2) (local.get $3))
+  )
+
+  (func (export "array_init_data_i16") (param $1 i32) (param $2 i32) (param $3 i32)
+    (array.init_data $arr16_mut $d1 (global.get $g_arr16_mut) (local.get $1) (local.get $2) (local.get $3))
+  )
+
+  (func (export "drop_segs")
+    (data.drop $d1)
+  )
+)
+
+;; null array argument traps
+(assert_trap (invoke "array_init_data-null") "null array reference")
+
+;; OOB initial index traps
+(assert_trap (invoke "array_init_data" (i32.const 13) (i32.const 0) (i32.const 0)) "out of bounds array access")
+(assert_trap (invoke "array_init_data" (i32.const 0) (i32.const 13) (i32.const 0)) "out of bounds memory access")
+
+;; OOB length traps
+(assert_trap (invoke "array_init_data" (i32.const 0) (i32.const 0) (i32.const 13)) "out of bounds array access")
+(assert_trap (invoke "array_init_data" (i32.const 0) (i32.const 0) (i32.const 13)) "out of bounds array access")
+(assert_trap (invoke "array_init_data_i16" (i32.const 0) (i32.const 0) (i32.const 7)) "out of bounds array access")
+
+;; start index = array size, len = 0 doesn't trap
+(assert_return (invoke "array_init_data" (i32.const 12) (i32.const 0) (i32.const 0)))
+(assert_return (invoke "array_init_data" (i32.const 0) (i32.const 12) (i32.const 0)))
+(assert_return (invoke "array_init_data_i16" (i32.const 0) (i32.const 6) (i32.const 0)))
+
+;; check arrays were not modified
+(assert_return (invoke "array_get_nth" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "array_get_nth" (i32.const 5)) (i32.const 0))
+(assert_return (invoke "array_get_nth" (i32.const 11)) (i32.const 0))
+(assert_trap (invoke "array_get_nth" (i32.const 12)) "out of bounds array access")
+(assert_return (invoke "array_get_nth_i16" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "array_get_nth_i16" (i32.const 2)) (i32.const 0))
+(assert_return (invoke "array_get_nth_i16" (i32.const 5)) (i32.const 0))
+(assert_trap (invoke "array_get_nth_i16" (i32.const 6)) "out of bounds array access")
+
+;; normal cases
+(assert_return (invoke "array_init_data" (i32.const 4) (i32.const 2) (i32.const 2)))
+(assert_return (invoke "array_get_nth" (i32.const 3)) (i32.const 0))
+(assert_return (invoke "array_get_nth" (i32.const 4)) (i32.const 99))
+(assert_return (invoke "array_get_nth" (i32.const 5)) (i32.const 100))
+(assert_return (invoke "array_get_nth" (i32.const 6)) (i32.const 0))
+
+(assert_return (invoke "array_init_data_i16" (i32.const 2) (i32.const 5) (i32.const 2)))
+(assert_return (invoke "array_get_nth_i16" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "array_get_nth_i16" (i32.const 2)) (i32.const 0x6766))
+(assert_return (invoke "array_get_nth_i16" (i32.const 3)) (i32.const 0x6968))
+(assert_return (invoke "array_get_nth_i16" (i32.const 4)) (i32.const 0))
+
+;; init_data/elem with dropped segments traps for non-zero length
+(assert_return (invoke "drop_segs"))
+(assert_return (invoke "array_init_data" (i32.const 0) (i32.const 0) (i32.const 0)))
+(assert_trap (invoke "array_init_data" (i32.const 0) (i32.const 0) (i32.const 1)) "out of bounds memory access")
diff --git a/tests/wast/spec/proposals/gc/array_init_elem.wast b/tests/wast/spec/proposals/gc/array_init_elem.wast
new file mode 100644
index 0000000000..34a12599b0
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/array_init_elem.wast
@@ -0,0 +1,108 @@
+;; Bulk instructions
+
+;; invalid uses
+
+(assert_invalid
+  (module
+    (type $a (array funcref))
+
+    (elem $e1 funcref)
+
+    (func (export "array.init_elem-immutable") (param $1 (ref $a))
+      (array.init_elem $a $e1 (local.get $1) (i32.const 0) (i32.const 0) (i32.const 0))
+    )
+  )
+  "array is immutable"
+)
+
+(assert_invalid
+  (module
+    (type $a (array (mut i8)))
+
+    (elem $e1 funcref)
+
+    (func (export "array.init_elem-invalid-1") (param $1 (ref $a))
+      (array.init_elem $a $e1 (local.get $1) (i32.const 0) (i32.const 0) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $a (array (mut funcref)))
+
+    (elem $e1 externref)
+
+    (func (export "array.init_elem-invalid-2") (param $1 (ref $a))
+      (array.init_elem $a $e1 (local.get $1) (i32.const 0) (i32.const 0) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+
+(module
+  (type $t_f (func))
+  (type $arrref (array (ref $t_f)))
+  (type $arrref_mut (array (mut funcref)))
+
+  (global $g_arrref (ref $arrref) (array.new $arrref (ref.func $dummy) (i32.const 12)))
+  (global $g_arrref_mut (ref $arrref_mut) (array.new_default $arrref_mut (i32.const 12)))
+
+  (table $t 1 funcref)
+
+  (elem $e1 func $dummy $dummy $dummy $dummy $dummy $dummy $dummy $dummy $dummy $dummy $dummy $dummy)
+
+  (func $dummy
+  )
+
+  (func (export "array_call_nth") (param $1 i32)
+    (table.set $t (i32.const 0) (array.get $arrref_mut (global.get $g_arrref_mut) (local.get $1)))
+    (call_indirect $t (i32.const 0))
+  )
+
+  (func (export "array_init_elem-null")
+    (array.init_elem $arrref_mut $e1 (ref.null $arrref_mut) (i32.const 0) (i32.const 0) (i32.const 0))
+  )
+
+  (func (export "array_init_elem") (param $1 i32) (param $2 i32) (param $3 i32)
+    (array.init_elem $arrref_mut $e1 (global.get $g_arrref_mut) (local.get $1) (local.get $2) (local.get $3))
+  )
+
+  (func (export "drop_segs")
+    (elem.drop $e1)
+  )
+)
+
+;; null array argument traps
+(assert_trap (invoke "array_init_elem-null") "null array reference")
+
+;; OOB initial index traps
+(assert_trap (invoke "array_init_elem" (i32.const 13) (i32.const 0) (i32.const 0)) "out of bounds array access")
+(assert_trap (invoke "array_init_elem" (i32.const 0) (i32.const 13) (i32.const 0)) "out of bounds table access")
+
+;; OOB length traps
+(assert_trap (invoke "array_init_elem" (i32.const 0) (i32.const 0) (i32.const 13)) "out of bounds array access")
+(assert_trap (invoke "array_init_elem" (i32.const 0) (i32.const 0) (i32.const 13)) "out of bounds array access")
+
+;; start index = array size, len = 0 doesn't trap
+(assert_return (invoke "array_init_elem" (i32.const 12) (i32.const 0) (i32.const 0)))
+(assert_return (invoke "array_init_elem" (i32.const 0) (i32.const 12) (i32.const 0)))
+
+;; check arrays were not modified
+(assert_trap (invoke "array_call_nth" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "array_call_nth" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "array_call_nth" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "array_call_nth" (i32.const 12)) "out of bounds array access")
+
+;; normal cases
+(assert_return (invoke "array_init_elem" (i32.const 2) (i32.const 3) (i32.const 2)))
+(assert_trap (invoke "array_call_nth" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "array_call_nth" (i32.const 2)))
+(assert_return (invoke "array_call_nth" (i32.const 3)))
+(assert_trap (invoke "array_call_nth" (i32.const 4)) "uninitialized element")
+
+;; init_data/elem with dropped segments traps for non-zero length
+(assert_return (invoke "drop_segs"))
+(assert_return (invoke "array_init_elem" (i32.const 0) (i32.const 0) (i32.const 0)))
+(assert_trap (invoke "array_init_elem" (i32.const 0) (i32.const 0) (i32.const 1)) "out of bounds table access")
diff --git a/tests/wast/spec/proposals/gc/binary-gc.wast b/tests/wast/spec/proposals/gc/binary-gc.wast
new file mode 100644
index 0000000000..589573f2cc
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/binary-gc.wast
@@ -0,0 +1,12 @@
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01"                     ;; Type section id
+    "\04"                     ;; Type section length
+    "\01"                     ;; Types vector length
+    "\5e"                     ;; Array type, -0x22
+    "\78"                     ;; Storage type: i8 or -0x08
+    "\02"                     ;; Mutability, should be 0 or 1, but isn't
+  )
+  "malformed mutability"
+)
diff --git a/tests/wast/spec/proposals/gc/binary.wast b/tests/wast/spec/proposals/gc/binary.wast
index 1f76dc136a..ae49d07f56 100644
--- a/tests/wast/spec/proposals/gc/binary.wast
+++ b/tests/wast/spec/proposals/gc/binary.wast
@@ -45,710 +45,80 @@
 (assert_malformed (module binary "\00asm\00\00\00\01") "unknown binary version")
 
 ;; Invalid section id.
-(assert_malformed (module binary "\00asm" "\01\00\00\00" "\0d\00") "malformed section id")
-(assert_malformed (module binary "\00asm" "\01\00\00\00" "\7f\00") "malformed section id")
-(assert_malformed (module binary "\00asm" "\01\00\00\00" "\80\00\01\00") "malformed section id")
-(assert_malformed (module binary "\00asm" "\01\00\00\00" "\81\00\01\00") "malformed section id")
-(assert_malformed (module binary "\00asm" "\01\00\00\00" "\ff\00\01\00") "malformed section id")
-
-;; Unsigned LEB128 can have non-minimal length
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\05\04\01"                          ;; Memory section with 1 entry
-  "\00\82\00"                          ;; no max, minimum 2
-)
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\05\07\01"                          ;; Memory section with 1 entry
-  "\00\82\80\80\80\00"                 ;; no max, minimum 2
-)
-
-;; Signed LEB128 can have non-minimal length
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\06\07\01"                          ;; Global section with 1 entry
-  "\7f\00"                             ;; i32, immutable
-  "\41\80\00"                          ;; i32.const 0
-  "\0b"                                ;; end
-)
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\06\07\01"                          ;; Global section with 1 entry
-  "\7f\00"                             ;; i32, immutable
-  "\41\ff\7f"                          ;; i32.const -1
-  "\0b"                                ;; end
-)
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\06\0a\01"                          ;; Global section with 1 entry
-  "\7f\00"                             ;; i32, immutable
-  "\41\80\80\80\80\00"                 ;; i32.const 0
-  "\0b"                                ;; end
-)
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\06\0a\01"                          ;; Global section with 1 entry
-  "\7f\00"                             ;; i32, immutable
-  "\41\ff\ff\ff\ff\7f"                 ;; i32.const -1
-  "\0b"                                ;; end
-)
-
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\06\07\01"                          ;; Global section with 1 entry
-  "\7e\00"                             ;; i64, immutable
-  "\42\80\00"                          ;; i64.const 0 with unused bits set
-  "\0b"                                ;; end
-)
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\06\07\01"                          ;; Global section with 1 entry
-  "\7e\00"                             ;; i64, immutable
-  "\42\ff\7f"                          ;; i64.const -1 with unused bits unset
-  "\0b"                                ;; end
-)
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\06\0f\01"                          ;; Global section with 1 entry
-  "\7e\00"                             ;; i64, immutable
-  "\42\80\80\80\80\80\80\80\80\80\00"  ;; i64.const 0 with unused bits set
-  "\0b"                                ;; end
-)
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\06\0f\01"                          ;; Global section with 1 entry
-  "\7e\00"                             ;; i64, immutable
-  "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f"  ;; i64.const -1 with unused bits unset
-  "\0b"                                ;; end
-)
-
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\05\03\01"                          ;; Memory section with 1 entry
-  "\00\00"                             ;; no max, minimum 0
-  "\0b\06\01"                          ;; Data section with 1 entry
-  "\00"                                ;; Memory index 0
-  "\41\00\0b\00"                       ;; (i32.const 0) with contents ""
-)
-
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\04\04\01"                          ;; Table section with 1 entry
-  "\70\00\00"                          ;; no max, minimum 0, funcref
-  "\09\06\01"                          ;; Element section with 1 entry
-  "\00"                                ;; Table index 0
-  "\41\00\0b\00"                       ;; (i32.const 0) with no elements
-)
-
-;; Data segment memory index can have non-minimal length
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\05\03\01"                          ;; Memory section with 1 entry
-  "\00\00"                             ;; no max, minimum 0
-  "\0b\07\01"                          ;; Data section with 1 entry
-  "\80\00"                             ;; Memory index 0, encoded with 2 bytes
-  "\41\00\0b\00"                       ;; (i32.const 0) with contents ""
-)
-
-;; Element segment table index can have non-minimal length
-(module binary
-  "\00asm" "\01\00\00\00"
-  "\04\04\01"                          ;; Table section with 1 entry
-  "\70\00\00"                          ;; no max, minimum 0, funcref
-  "\09\09\01"                          ;; Element section with 1 entry
-  "\02\80\00"                          ;; Table index 0, encoded with 2 bytes
-  "\41\00\0b\00\00"                    ;; (i32.const 0) with no elements
-)
-
-;; Type section with signed LEB128 encoded type
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01"                     ;; Type section id
-    "\05"                     ;; Type section length
-    "\01"                     ;; Types vector length
-    "\e0\7f"                  ;; Malformed functype, -0x20 in signed LEB128 encoding
-    "\00\00"
-  )
-  "integer representation too long"
-)
-
-;; Unsigned LEB128 must not be overlong
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\05\08\01"                          ;; Memory section with 1 entry
-    "\00\82\80\80\80\80\00"              ;; no max, minimum 2 with one byte too many
-  )
-  "integer representation too long"
-)
-
-;; Signed LEB128 must not be overlong
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0b\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\80\80\80\80\80\00"              ;; i32.const 0 with one byte too many
-    "\0b"                                ;; end
-  )
-  "integer representation too long"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0b\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\ff\ff\ff\ff\ff\7f"              ;; i32.const -1 with one byte too many
-    "\0b"                                ;; end
-  )
-  "integer representation too long"
-)
-
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\10\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\80\80\80\80\80\80\80\80\80\80\00"  ;; i64.const 0 with one byte too many
-    "\0b"                                ;; end
-  )
-  "integer representation too long"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\10\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f"  ;; i64.const -1 with one byte too many
-    "\0b"                                ;; end
-  )
-  "integer representation too long"
-)
-
-;; Unsigned LEB128s zero-extend
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\05\07\01"                          ;; Memory section with 1 entry
-    "\00\82\80\80\80\70"                 ;; no max, minimum 2 with unused bits set
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\05\07\01"                          ;; Memory section with 1 entry
-    "\00\82\80\80\80\40"                 ;; no max, minimum 2 with some unused bits set
-  )
-  "integer too large"
-)
-
-;; Signed LEB128s sign-extend
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0a\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\80\80\80\80\70"                 ;; i32.const 0 with unused bits set
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0a\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\ff\ff\ff\ff\0f"                 ;; i32.const -1 with unused bits unset
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0a\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\80\80\80\80\1f"                 ;; i32.const 0 with some unused bits set
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0a\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\ff\ff\ff\ff\4f"                 ;; i32.const -1 with some unused bits unset
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\80\80\80\80\80\80\80\80\80\7e"  ;; i64.const 0 with unused bits set
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01"  ;; i64.const -1 with unused bits unset
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\80\80\80\80\80\80\80\80\80\02"  ;; i64.const 0 with some unused bits set
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41"  ;; i64.const -1 with some unused bits unset
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\0e\01\00") "malformed section id")
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\7f\01\00") "malformed section id")
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\80\01\00\01\01\00") "malformed section id")
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\81\01\00\01\01\00") "malformed section id")
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\ff\01\00\01\01\00") "malformed section id")
 
+;; Function with missing end marker (between two functions)
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\80\80\80\80\80\80\80\80\80\7e"  ;; i64.const 0 with unused bits set
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01"  ;; i64.const -1 with unused bits unset
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\80\80\80\80\80\80\80\80\80\02"  ;; i64.const 0 with some unused bits set
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41"  ;; i64.const -1 with some unused bits unset
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-
-
-;; Unsigned LEB128 must not be overlong
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\05\08\01"                          ;; Memory section with 1 entry
-    "\00\82\80\80\80\80\00"              ;; no max, minimum 2 with one byte too many
-  )
-  "integer representation too long"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\11\01"                ;; Code section
+    "\01\04\01\60\00\00"       ;; Type section: 1 type
+    "\03\03\02\00\00"          ;; Function section: 2 functions
+    "\0a\0c\02"                ;; Code section: 2 functions
     ;; function 0
-    "\0f\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\28"                      ;; i32.load
-    "\02"                      ;; alignment 2
-    "\82\80\80\80\80\00"       ;; offset 2 with one byte too many
+    "\04\00"                   ;; Function size and local type count
+    "\41\01"                   ;; i32.const 1
     "\1a"                      ;; drop
-    "\0b"                      ;; end
-  )
-  "integer representation too long"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\11\01"                ;; Code section
-    ;; function 0
-    "\0f\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\28"                      ;; i32.load
-    "\82\80\80\80\80\00"       ;; alignment 2 with one byte too many
-    "\00"                      ;; offset 0
+    ;; Missing end marker here
+    ;; function 1
+    "\05\00"                   ;; Function size and local type count
+    "\41\01"                   ;; i32.const 1
     "\1a"                      ;; drop
     "\0b"                      ;; end
   )
-  "integer representation too long"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\12\01"                ;; Code section
-    ;; function 0
-    "\10\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\41\03"                   ;; i32.const 3
-    "\36"                      ;; i32.store
-    "\82\80\80\80\80\00"       ;; alignment 2 with one byte too many
-    "\03"                      ;; offset 3
-    "\0b"                      ;; end
-  )
-  "integer representation too long"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\12\01"                ;; Code section
-    ;; function 0
-    "\10\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\41\03"                   ;; i32.const 3
-    "\36"                      ;; i32.store
-    "\02"                      ;; alignment 2
-    "\82\80\80\80\80\00"       ;; offset 2 with one byte too many
-    "\0b"                      ;; end
-  )
-  "integer representation too long"
-)
-
-;; Signed LEB128 must not be overlong
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0b\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\80\80\80\80\80\00"              ;; i32.const 0 with one byte too many
-    "\0b"                                ;; end
-  )
-  "integer representation too long"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0b\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\ff\ff\ff\ff\ff\7f"              ;; i32.const -1 with one byte too many
-    "\0b"                                ;; end
-  )
-  "integer representation too long"
-)
-
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\10\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\80\80\80\80\80\80\80\80\80\80\00"  ;; i64.const 0 with one byte too many
-    "\0b"                                ;; end
-  )
-  "integer representation too long"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\10\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f"  ;; i64.const -1 with one byte too many
-    "\0b"                                ;; end
-  )
-  "integer representation too long"
+  "END opcode expected"
 )
 
-;; Unsigned LEB128s zero-extend
+;; Function with missing end marker (at EOF)
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
-    "\05\07\01"                          ;; Memory section with 1 entry
-    "\00\82\80\80\80\70"                 ;; no max, minimum 2 with unused bits set
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\05\07\01"                          ;; Memory section with 1 entry
-    "\00\82\80\80\80\40"                 ;; no max, minimum 2 with some unused bits set
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\10\01"                ;; Code section
+    "\01\04\01\60\00\00"       ;; Type section: 1 type
+    "\03\02\01\00"             ;; Function section: 1 function
+    "\0a\06\01"                ;; Code section: 1 function
     ;; function 0
-    "\0e\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\28"                      ;; i32.load
-    "\02"                      ;; alignment 2
-    "\82\80\80\80\10"          ;; offset 2 with unused bits set
+    "\04\00"                   ;; Function size and local type count
+    "\41\01"                   ;; i32.const 1
     "\1a"                      ;; drop
-    "\0b"                      ;; end
+    ;; Missing end marker here
   )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\10\01"                ;; Code section
-    ;; function 0
-    "\0e\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\28"                      ;; i32.load
-    "\02"                      ;; alignment 2
-    "\82\80\80\80\40"          ;; offset 2 with some unused bits set
-    "\1a"                      ;; drop
-    "\0b"                      ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\10\01"                ;; Code section
-    "\0e\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\28"                      ;; i32.load
-    "\82\80\80\80\10"          ;; alignment 2 with unused bits set
-    "\00"                      ;; offset 0
-    "\1a"                      ;; drop
-    "\0b"                      ;; end
-  )
-  "integer too large"
+  "unexpected end of section or function"
 )
+
+;; Function with missing end marker (at end of code sections)
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\10\01"                ;; Code section
+    "\01\04\01\60\00\00"       ;; Type section: 1 type
+    "\03\02\01\00"             ;; Function section: 1 function
+    "\0a\06\01"                ;; Code section: 1 function
     ;; function 0
-    "\0e\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\28"                      ;; i32.load
-    "\82\80\80\80\40"          ;; alignment 2 with some unused bits set
-    "\00"                      ;; offset 0
+    "\04\00"                   ;; Function size and local type count
+    "\41\01"                   ;; i32.const 1
     "\1a"                      ;; drop
-    "\0b"                      ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\11\01"                ;; Code section
-    ;; function 0
-    "\0f\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\41\03"                   ;; i32.const 3
-    "\36"                      ;; i32.store
-    "\82\80\80\80\10"          ;; alignment 2 with unused bits set
-    "\03"                      ;; offset 3
-    "\0b"                      ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\11\01"                ;; Code section
-    ;; function 0
-    "\0f\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\41\03"                   ;; i32.const 3
-    "\36"                      ;; i32.store
-    "\82\80\80\80\40"          ;; alignment 2 with some unused bits set
-    "\03"                      ;; offset 3
-    "\0b"                      ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\11\01"                ;; Code section
-    ;; function 0
-    "\0f\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\41\03"                   ;; i32.const 3
-    "\36"                      ;; i32.store
-    "\02"                      ;; alignment 2
-    "\82\80\80\80\10"          ;; offset 2 with unused bits set
-    "\0b"                      ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\01\04\01\60\00\00"       ;; Type section
-    "\03\02\01\00"             ;; Function section
-    "\05\03\01\00\01"          ;; Memory section
-    "\0a\11\01"                ;; Code section
-
-    ;; function 0
-    "\0f\01\01"                ;; local type count
-    "\7f"                      ;; i32
-    "\41\00"                   ;; i32.const 0
-    "\41\03"                   ;; i32.const 3
-    "\36"                      ;; i32.store
-    "\02"                      ;; alignment 2
-    "\82\80\80\80\40"          ;; offset 2 with some unused bits set
-    "\0b"                      ;; end
-  )
-  "integer too large"
-)
-
-;; Signed LEB128s sign-extend
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0a\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\80\80\80\80\70"                 ;; i32.const 0 with unused bits set
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0a\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\ff\ff\ff\ff\0f"                 ;; i32.const -1 with unused bits unset
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0a\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\80\80\80\80\1f"                 ;; i32.const 0 with some unused bits set
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0a\01"                          ;; Global section with 1 entry
-    "\7f\00"                             ;; i32, immutable
-    "\41\ff\ff\ff\ff\4f"                 ;; i32.const -1 with some unused bits unset
-    "\0b"                                ;; end
+    ;; Missing end marker here
+    "\0b\03\01\01\00"          ;; Data section
   )
-  "integer too large"
+  ;; The spec interpreter consumes the `\0b` (data section start) as an
+  ;; END instruction (also happens to be `\0b`) and reports the code section as
+  ;; being larger than declared.
+  "section size mismatch"
 )
 
+;; Init expression with missing end marker
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\80\80\80\80\80\80\80\80\80\7e"  ;; i64.const 0 with unused bits set
-    "\0b"                                ;; end
+    "\01\04\01\60\00\00"       ;; Type section: 1 type
+    "\03\02\01\00"             ;; Function section: 1 function
+    "\06\05\01\7f\00\41\00"    ;; Global section: 1 entry with missing end marker
+    ;; Missing end marker here
+    "\0a\04\01\02\00\0b"       ;; Code section: 1 function
   )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01"  ;; i64.const -1 with unused bits unset
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\80\80\80\80\80\80\80\80\80\02"  ;; i64.const 0 with some unused bits set
-    "\0b"                                ;; end
-  )
-  "integer too large"
-)
-(assert_malformed
-  (module binary
-    "\00asm" "\01\00\00\00"
-    "\06\0f\01"                          ;; Global section with 1 entry
-    "\7e\00"                             ;; i64, immutable
-    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41"  ;; i64.const -1 with some unused bits unset
-    "\0b"                                ;; end
-  )
-  "integer too large"
+  "illegal opcode"
 )
 
 ;; memory.grow reserved byte equal to zero.
@@ -1140,7 +510,7 @@
   )                            ;; end
   "data count section required")
 
-;; passive element segment containing opcode other than ref.func or ref.null
+;; passive element segment containing illegal opcode
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
@@ -1157,7 +527,7 @@
     "\09\07\01"                ;; Element section with one segment
     "\05\70"                   ;; Passive, funcref
     "\01"                      ;; 1 element
-    "\ff\00\0b"                ;; bad opcode, index 0, end
+    "\f3\00\0b"                ;; bad opcode, index 0, end
 
     "\0a\04\01"                ;; Code section
 
@@ -1255,7 +625,7 @@
     "\60\00\00"                             ;; 1st type
     ;; "\60\00\00"                          ;; 2nd type (missed)
   )
-  "unexpected end of section or function"
+  "length out of bounds"
 )
 
 ;; 1 type declared, 2 given
@@ -1406,7 +776,7 @@
 (assert_malformed
   (module binary
       "\00asm" "\01\00\00\00"
-      "\05\03\01"                           ;; table section with one entry
+      "\04\03\01"                           ;; table section with one entry
       "\70"                                 ;; anyfunc
       "\02"                                 ;; malformed table limits flag
   )
@@ -1415,7 +785,7 @@
 (assert_malformed
   (module binary
       "\00asm" "\01\00\00\00"
-      "\05\04\01"                           ;; table section with one entry
+      "\04\04\01"                           ;; table section with one entry
       "\70"                                 ;; anyfunc
       "\02"                                 ;; malformed table limits flag
       "\00"                                 ;; dummy byte
@@ -1425,12 +795,12 @@
 (assert_malformed
   (module binary
       "\00asm" "\01\00\00\00"
-      "\05\06\01"                           ;; table section with one entry
+      "\04\06\01"                           ;; table section with one entry
       "\70"                                 ;; anyfunc
       "\81\00"                              ;; malformed table limits flag as LEB128
       "\00\00"                              ;; dummy bytes
   )
-  "integer too large"
+  "integer representation too long"
 )
 
 ;; Memory count can be zero
@@ -1544,7 +914,7 @@
     "\02\00\0b"                             ;; function body 0
     "\02\00\0b"                             ;; function body 1
   )
-  "unexpected end of section or function"
+  "length out of bounds"
 )
 
 ;; 1 export declared, 2 given
@@ -1606,7 +976,7 @@
     "\03\02\01\00"                          ;; func section
     "\04\04\01"                             ;; table section
     "\70\00\01"                             ;; table 0
-    "\09\07\02"                             ;; elem with inconsistent segment count (2 declared, 1 given)
+    "\09\0a\02"                             ;; elem with inconsistent segment count (2 declared, 1 given)
     "\00\41\00\0b\01\00"                    ;; elem 0
     "\00\41\00"                             ;; elem 1 (partial)
     ;; "\0b\01\00"                          ;; elem 1 (missing part)
@@ -1715,10 +1085,21 @@
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
-    "\01\04\01"                             ;; type section
+    "\01\25\0c"                             ;; type section
     "\60\00\00"                             ;; type 0
+    "\60\00\00"                             ;; type 1
+    "\60\00\00"                             ;; type 2
+    "\60\00\00"                             ;; type 3
+    "\60\00\00"                             ;; type 4
+    "\60\00\00"                             ;; type 5
+    "\60\00\00"                             ;; type 6
+    "\60\00\00"                             ;; type 7
+    "\60\00\00"                             ;; type 8
+    "\60\00\00"                             ;; type 9
+    "\60\00\00"                             ;; type 10
+    "\60\00\00"                             ;; type 11
     "\03\02\01\00"                          ;; func section
-    "\0a\12\01"                             ;; code section
+    "\0a\13\01"                             ;; code section
     "\11\00"                                ;; func 0
     "\02\40"                                ;; block 0
     "\41\01"                                ;; condition of if 0
@@ -1727,8 +1108,9 @@
     "\0e\01"                                ;; br_table with inconsistent target count (1 declared, 2 given)
     "\00"                                   ;; break depth 0
     "\01"                                   ;; break depth 1
-    "\02"                                   ;; break depth for default
-    "\0b\0b\0b"                             ;; end
+    "\02"                                   ;; break depth for default, interpreted as a block
+    "\0b"                                   ;; end, interpreted as type 11 for the block
+    "\0b\0b"                                ;; end
   )
   "unexpected end of section or function"
 )
@@ -1760,6 +1142,5 @@
     "\02\00"
     "\0b"                      ;; end
   )
-  "junk after last section"
+  "unexpected content after last section"
 )
-
diff --git a/tests/wast/spec/proposals/gc/br_if.wast b/tests/wast/spec/proposals/gc/br_if.wast
new file mode 100644
index 0000000000..9d0cdd81fa
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/br_if.wast
@@ -0,0 +1,679 @@
+;; Test `br_if` operator
+
+(module
+  (func $dummy)
+
+  (func (export "type-i32")
+    (block (drop (i32.ctz (br_if 0 (i32.const 0) (i32.const 1)))))
+  )
+  (func (export "type-i64")
+    (block (drop (i64.ctz (br_if 0 (i64.const 0) (i32.const 1)))))
+  )
+  (func (export "type-f32")
+    (block (drop (f32.neg (br_if 0 (f32.const 0) (i32.const 1)))))
+  )
+  (func (export "type-f64")
+    (block (drop (f64.neg (br_if 0 (f64.const 0) (i32.const 1)))))
+  )
+
+  (func (export "type-i32-value") (result i32)
+    (block (result i32) (i32.ctz (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+  (func (export "type-i64-value") (result i64)
+    (block (result i64) (i64.ctz (br_if 0 (i64.const 2) (i32.const 1))))
+  )
+  (func (export "type-f32-value") (result f32)
+    (block (result f32) (f32.neg (br_if 0 (f32.const 3) (i32.const 1))))
+  )
+  (func (export "type-f64-value") (result f64)
+    (block (result f64) (f64.neg (br_if 0 (f64.const 4) (i32.const 1))))
+  )
+
+  (func (export "as-block-first") (param i32) (result i32)
+    (block (br_if 0 (local.get 0)) (return (i32.const 2))) (i32.const 3)
+  )
+  (func (export "as-block-mid") (param i32) (result i32)
+    (block (call $dummy) (br_if 0 (local.get 0)) (return (i32.const 2)))
+    (i32.const 3)
+  )
+  (func (export "as-block-last") (param i32)
+    (block (call $dummy) (call $dummy) (br_if 0 (local.get 0)))
+  )
+  (func (export "as-block-first-value") (param i32) (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 10) (local.get 0))) (return (i32.const 11))
+    )
+  )
+  (func (export "as-block-mid-value") (param i32) (result i32)
+    (block (result i32)
+      (call $dummy)
+      (drop (br_if 0 (i32.const 20) (local.get 0)))
+      (return (i32.const 21))
+    )
+  )
+  (func (export "as-block-last-value") (param i32) (result i32)
+    (block (result i32)
+      (call $dummy) (call $dummy) (br_if 0 (i32.const 11) (local.get 0))
+    )
+  )
+
+  (func (export "as-loop-first") (param i32) (result i32)
+    (block (loop (br_if 1 (local.get 0)) (return (i32.const 2)))) (i32.const 3)
+  )
+  (func (export "as-loop-mid") (param i32) (result i32)
+    (block (loop (call $dummy) (br_if 1 (local.get 0)) (return (i32.const 2))))
+    (i32.const 4)
+  )
+  (func (export "as-loop-last") (param i32)
+    (loop (call $dummy) (br_if 1 (local.get 0)))
+  )
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (br_if 0 (i32.const 1) (i32.const 2))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (br_if 0 (i32.const 1) (i32.const 2)) (i32.const 3)))
+      (i32.const 4)
+    )
+  )
+  (func (export "as-br_if-value-cond") (param i32) (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 2) (br_if 0 (i32.const 1) (local.get 0))))
+      (i32.const 4)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (br_if 0 (i32.const 1) (i32.const 2))))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (br_if 0 (i32.const 1) (i32.const 2)) (i32.const 3)) (i32.const 4)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 2) (br_if 0 (i32.const 1) (i32.const 3))) (i32.const 4)
+    )
+  )
+  (func (export "as-return-value") (result i64)
+    (block (result i64) (return (br_if 0 (i64.const 1) (i32.const 2))))
+  )
+
+  (func (export "as-if-cond") (param i32) (result i32)
+    (block (result i32)
+      (if (result i32)
+        (br_if 0 (i32.const 1) (local.get 0))
+        (then (i32.const 2))
+        (else (i32.const 3))
+      )
+    )
+  )
+  (func (export "as-if-then") (param i32 i32)
+    (block
+      (if (local.get 0) (then (br_if 1 (local.get 1))) (else (call $dummy)))
+    )
+  )
+  (func (export "as-if-else") (param i32 i32)
+    (block
+      (if (local.get 0) (then (call $dummy)) (else (br_if 1 (local.get 1))))
+    )
+  )
+
+  (func (export "as-select-first") (param i32) (result i32)
+    (block (result i32)
+      (select (br_if 0 (i32.const 3) (i32.const 10)) (i32.const 2) (local.get 0))
+    )
+  )
+  (func (export "as-select-second") (param i32) (result i32)
+    (block (result i32)
+      (select (i32.const 1) (br_if 0 (i32.const 3) (i32.const 10)) (local.get 0))
+    )
+  )
+  (func (export "as-select-cond") (result i32)
+    (block (result i32)
+      (select (i32.const 1) (i32.const 2) (br_if 0 (i32.const 3) (i32.const 10)))
+    )
+  )
+
+ (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (block (result i32)
+      (call $f
+        (br_if 0 (i32.const 12) (i32.const 1)) (i32.const 2) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call-mid") (result i32)
+    (block (result i32)
+      (call $f
+        (i32.const 1) (br_if 0 (i32.const 13) (i32.const 1)) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call-last") (result i32)
+    (block (result i32)
+      (call $f
+        (i32.const 1) (i32.const 2) (br_if 0 (i32.const 14) (i32.const 1))
+      )
+    )
+  )
+
+  (func $func (param i32 i32 i32) (result i32) (local.get 0))
+  (type $check (func (param i32 i32 i32) (result i32)))
+  (table funcref (elem $func))
+  (func (export "as-call_indirect-func") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (br_if 0 (i32.const 4) (i32.const 10))
+        (i32.const 1) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 1) (br_if 0 (i32.const 4) (i32.const 10)) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 1) (i32.const 2) (br_if 0 (i32.const 4) (i32.const 10)) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 1) (i32.const 2) (i32.const 3) (br_if 0 (i32.const 4) (i32.const 10))
+      )
+    )
+  )
+
+  (func (export "as-local.set-value") (param i32) (result i32)
+    (local i32)
+    (block (result i32)
+      (local.set 0 (br_if 0 (i32.const 17) (local.get 0)))
+      (i32.const -1)
+    )
+  )
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (block (result i32)
+      (local.tee 0 (br_if 0 (i32.const 1) (local.get 0)))
+      (return (i32.const -1))
+    )
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (param i32) (result i32)
+    (block (result i32)
+      (global.set $a (br_if 0 (i32.const 1) (local.get 0)))
+      (return (i32.const -1))
+    )
+  )
+
+  (memory 1)
+  (func (export "as-load-address") (result i32)
+    (block (result i32) (i32.load (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+  (func (export "as-loadN-address") (result i32)
+    (block (result i32) (i32.load8_s (br_if 0 (i32.const 30) (i32.const 1))))
+  )
+
+  (func (export "as-store-address") (result i32)
+    (block (result i32)
+      (i32.store (br_if 0 (i32.const 30) (i32.const 1)) (i32.const 7)) (i32.const -1)
+    )
+  )
+  (func (export "as-store-value") (result i32)
+    (block (result i32)
+      (i32.store (i32.const 2) (br_if 0 (i32.const 31) (i32.const 1))) (i32.const -1)
+    )
+  )
+
+  (func (export "as-storeN-address") (result i32)
+    (block (result i32)
+      (i32.store8 (br_if 0 (i32.const 32) (i32.const 1)) (i32.const 7)) (i32.const -1)
+    )
+  )
+  (func (export "as-storeN-value") (result i32)
+    (block (result i32)
+      (i32.store16 (i32.const 2) (br_if 0 (i32.const 33) (i32.const 1))) (i32.const -1)
+    )
+  )
+
+  (func (export "as-unary-operand") (result f64)
+    (block (result f64) (f64.neg (br_if 0 (f64.const 1.0) (i32.const 1))))
+  )
+  (func (export "as-binary-left") (result i32)
+    (block (result i32) (i32.add (br_if 0 (i32.const 1) (i32.const 1)) (i32.const 10)))
+  )
+  (func (export "as-binary-right") (result i32)
+    (block (result i32) (i32.sub (i32.const 10) (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+  (func (export "as-test-operand") (result i32)
+    (block (result i32) (i32.eqz (br_if 0 (i32.const 0) (i32.const 1))))
+  )
+  (func (export "as-compare-left") (result i32)
+    (block (result i32) (i32.le_u (br_if 0 (i32.const 1) (i32.const 1)) (i32.const 10)))
+  )
+  (func (export "as-compare-right") (result i32)
+    (block (result i32) (i32.ne (i32.const 10) (br_if 0 (i32.const 1) (i32.const 42))))
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (block (result i32) (memory.grow (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+
+  (func (export "nested-block-value") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (i32.add
+          (i32.const 4)
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0)))
+            (i32.const 16)
+          )
+        )
+      )
+    )
+  )
+
+  (func (export "nested-br-value") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (br 0
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4)
+          )
+        )
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_if-value") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (drop (br_if 0
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4)
+          )
+          (i32.const 1)
+        ))
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_if-value-cond") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (drop (br_if 0
+          (i32.const 4)
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 1)
+          )
+        ))
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_table-value") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (br_table 0
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4)
+          )
+          (i32.const 1)
+        )
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_table-value-index") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (br_table 0
+          (i32.const 4)
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 1)
+          )
+        )
+        (i32.const 16)
+      )
+    )
+  )
+
+)
+
+(assert_return (invoke "type-i32"))
+(assert_return (invoke "type-i64"))
+(assert_return (invoke "type-f32"))
+(assert_return (invoke "type-f64"))
+
+(assert_return (invoke "type-i32-value") (i32.const 1))
+(assert_return (invoke "type-i64-value") (i64.const 2))
+(assert_return (invoke "type-f32-value") (f32.const 3))
+(assert_return (invoke "type-f64-value") (f64.const 4))
+
+(assert_return (invoke "as-block-first" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-block-first" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "as-block-mid" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-block-mid" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "as-block-last" (i32.const 0)))
+(assert_return (invoke "as-block-last" (i32.const 1)))
+
+(assert_return (invoke "as-block-first-value" (i32.const 0)) (i32.const 11))
+(assert_return (invoke "as-block-first-value" (i32.const 1)) (i32.const 10))
+(assert_return (invoke "as-block-mid-value" (i32.const 0)) (i32.const 21))
+(assert_return (invoke "as-block-mid-value" (i32.const 1)) (i32.const 20))
+(assert_return (invoke "as-block-last-value" (i32.const 0)) (i32.const 11))
+(assert_return (invoke "as-block-last-value" (i32.const 1)) (i32.const 11))
+
+(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-loop-first" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-loop-mid" (i32.const 1)) (i32.const 4))
+(assert_return (invoke "as-loop-last" (i32.const 0)))
+(assert_return (invoke "as-loop-last" (i32.const 1)))
+
+(assert_return (invoke "as-br-value") (i32.const 1))
+
+(assert_return (invoke "as-br_if-cond"))
+(assert_return (invoke "as-br_if-value") (i32.const 1))
+(assert_return (invoke "as-br_if-value-cond" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-br_if-value-cond" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-br_table-index"))
+(assert_return (invoke "as-br_table-value") (i32.const 1))
+(assert_return (invoke "as-br_table-value-index") (i32.const 1))
+
+(assert_return (invoke "as-return-value") (i64.const 1))
+
+(assert_return (invoke "as-if-cond" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-if-cond" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 0)))
+(assert_return (invoke "as-if-then" (i32.const 4) (i32.const 0)))
+(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 1)))
+(assert_return (invoke "as-if-then" (i32.const 4) (i32.const 1)))
+(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 0)))
+(assert_return (invoke "as-if-else" (i32.const 3) (i32.const 0)))
+(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 1)))
+(assert_return (invoke "as-if-else" (i32.const 3) (i32.const 1)))
+
+(assert_return (invoke "as-select-first" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-select-first" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "as-select-second" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-select-second" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "as-select-cond") (i32.const 3))
+
+(assert_return (invoke "as-call-first") (i32.const 12))
+(assert_return (invoke "as-call-mid") (i32.const 13))
+(assert_return (invoke "as-call-last") (i32.const 14))
+
+(assert_return (invoke "as-call_indirect-func") (i32.const 4))
+(assert_return (invoke "as-call_indirect-first") (i32.const 4))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 4))
+(assert_return (invoke "as-call_indirect-last") (i32.const 4))
+
+(assert_return (invoke "as-local.set-value" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 17))
+
+(assert_return (invoke "as-local.tee-value" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-local.tee-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-global.set-value" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-global.set-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-load-address") (i32.const 1))
+(assert_return (invoke "as-loadN-address") (i32.const 30))
+
+(assert_return (invoke "as-store-address") (i32.const 30))
+(assert_return (invoke "as-store-value") (i32.const 31))
+(assert_return (invoke "as-storeN-address") (i32.const 32))
+(assert_return (invoke "as-storeN-value") (i32.const 33))
+
+(assert_return (invoke "as-unary-operand") (f64.const 1.0))
+(assert_return (invoke "as-binary-left") (i32.const 1))
+(assert_return (invoke "as-binary-right") (i32.const 1))
+(assert_return (invoke "as-test-operand") (i32.const 0))
+(assert_return (invoke "as-compare-left") (i32.const 1))
+(assert_return (invoke "as-compare-right") (i32.const 1))
+(assert_return (invoke "as-memory.grow-size") (i32.const 1))
+
+(assert_return (invoke "nested-block-value" (i32.const 0)) (i32.const 21))
+(assert_return (invoke "nested-block-value" (i32.const 1)) (i32.const 9))
+(assert_return (invoke "nested-br-value" (i32.const 0)) (i32.const 5))
+(assert_return (invoke "nested-br-value" (i32.const 1)) (i32.const 9))
+(assert_return (invoke "nested-br_if-value" (i32.const 0)) (i32.const 5))
+(assert_return (invoke "nested-br_if-value" (i32.const 1)) (i32.const 9))
+(assert_return (invoke "nested-br_if-value-cond" (i32.const 0)) (i32.const 5))
+(assert_return (invoke "nested-br_if-value-cond" (i32.const 1)) (i32.const 9))
+(assert_return (invoke "nested-br_table-value" (i32.const 0)) (i32.const 5))
+(assert_return (invoke "nested-br_table-value" (i32.const 1)) (i32.const 9))
+(assert_return (invoke "nested-br_table-value-index" (i32.const 0)) (i32.const 5))
+(assert_return (invoke "nested-br_table-value-index" (i32.const 1)) (i32.const 9))
+
+(assert_invalid
+  (module (func $type-false-i32 (block (i32.ctz (br_if 0 (i32.const 0))))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-false-i64 (block (i64.ctz (br_if 0 (i32.const 0))))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-false-f32 (block (f32.neg (br_if 0 (i32.const 0))))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-false-f64 (block (f64.neg (br_if 0 (i32.const 0))))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-true-i32 (block (i32.ctz (br_if 0 (i32.const 1))))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-true-i64 (block (i64.ctz (br_if 0 (i64.const 1))))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-true-f32 (block (f32.neg (br_if 0 (f32.const 1))))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-true-f64 (block (f64.neg (br_if 0 (i64.const 1))))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-false-arg-void-vs-num (result i32)
+    (block (result i32) (br_if 0 (i32.const 0)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-true-arg-void-vs-num (result i32)
+    (block (result i32) (br_if 0 (i32.const 1)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-false-arg-num-vs-void
+    (block (br_if 0 (i32.const 0) (i32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-true-arg-num-vs-void
+    (block (br_if 0 (i32.const 0) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-false-arg-void-vs-num (result i32)
+    (block (result i32) (br_if 0 (nop) (i32.const 0)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-true-arg-void-vs-num (result i32)
+    (block (result i32) (br_if 0 (nop) (i32.const 1)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-false-arg-num-vs-num (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i64.const 1) (i32.const 0))) (i32.const 1)
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-true-arg-num-vs-num (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i64.const 1) (i32.const 0))) (i32.const 1)
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-cond-empty-vs-i32
+    (block (br_if 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-cond-void-vs-i32
+    (block (br_if 0 (nop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-cond-num-vs-i32
+    (block (br_if 0 (i64.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-cond-void-vs-i32 (result i32)
+    (block (result i32) (br_if 0 (i32.const 0) (nop)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-void-vs-num-nested (result i32)
+    (block (result i32) (i32.const 0) (block (br_if 1 (i32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-cond-num-vs-i32 (result i32)
+    (block (result i32) (br_if 0 (i32.const 0) (i64.const 0)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-1st-cond-empty-in-then
+      (block
+        (i32.const 0) (i32.const 0)
+        (if (result i32) (then (br_if 0)))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-2nd-cond-empty-in-then
+      (block
+        (i32.const 0) (i32.const 0)
+        (if (result i32) (then (br_if 0 (i32.const 1))))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-1st-cond-empty-in-return
+      (block (result i32)
+        (return (br_if 0))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-2nd-cond-empty-in-return
+      (block (result i32)
+        (return (br_if 0 (i32.const 1)))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+
+
+(assert_invalid
+  (module (func $unbound-label (br_if 1 (i32.const 1))))
+  "unknown label"
+)
+(assert_invalid
+  (module (func $unbound-nested-label (block (block (br_if 5 (i32.const 1))))))
+  "unknown label"
+)
+(assert_invalid
+  (module (func $large-label (br_if 0x10000001 (i32.const 1))))
+  "unknown label"
+)
+
+;; https://github.com/WebAssembly/gc/issues/516
+(assert_invalid
+  (module
+    (type $t (func))
+    (func $f (param (ref null $t)) (result funcref) (local.get 0))
+    (func (result funcref)
+      (ref.null $t)
+      (i32.const 0)
+      (br_if 0)  ;; only leaves funcref on the stack
+      (call $f)
+    )
+  )
+  "type mismatch"
+)
diff --git a/tests/wast/spec/proposals/gc/br_on_cast.wast b/tests/wast/spec/proposals/gc/br_on_cast.wast
index 89ebc608a0..3c895c0710 100644
--- a/tests/wast/spec/proposals/gc/br_on_cast.wast
+++ b/tests/wast/spec/proposals/gc/br_on_cast.wast
@@ -1,76 +1,172 @@
+;; Abstract Types
+
 (module
-  (type $t0 (struct))
-  (type $t1 (struct (field i32)))
-  (type $t1' (struct (field i32)))
-  (type $t2 (struct (field i32 i32)))
-  (type $t2' (struct (field i32 i32)))
-  (type $t3 (struct (field i32 i32)))
-
-  (global $t0 (rtt $t0) (rtt.canon $t0))
-  (global $t0' (rtt $t0) (rtt.canon $t0))
-  (global $t1 (rtt $t1) (rtt.sub $t1 (global.get $t0)))
-  (global $t1' (rtt $t1') (rtt.sub $t1' (global.get $t0)))
-  (global $t2 (rtt $t2) (rtt.sub $t2 (global.get $t1)))
-  (global $t2' (rtt $t2') (rtt.sub $t2' (global.get $t1')))
-  (global $t3 (rtt $t3) (rtt.sub $t3 (global.get $t0)))
-  (global $t4 (rtt $t3) (rtt.sub $t3 (rtt.sub $t0 (global.get $t0))))
-
-  (table 20 dataref)
+  (type $ft (func (result i32)))
+  (type $st (struct (field i16)))
+  (type $at (array i8))
+
+  (table 10 anyref)
+
+  (elem declare func $f)
+  (func $f (result i32) (i32.const 9))
+
+  (func (export "init") (param $x externref)
+    (table.set (i32.const 0) (ref.null any))
+    (table.set (i32.const 1) (ref.i31 (i32.const 7)))
+    (table.set (i32.const 2) (struct.new $st (i32.const 6)))
+    (table.set (i32.const 3) (array.new $at (i32.const 5) (i32.const 3)))
+    (table.set (i32.const 4) (any.convert_extern (local.get $x)))
+  )
+
+  (func (export "br_on_null") (param $i i32) (result i32)
+    (block $l
+      (br_on_null $l (table.get (local.get $i)))
+      (return (i32.const -1))
+    )
+    (i32.const 0)
+  )
+  (func (export "br_on_i31") (param $i i32) (result i32)
+    (block $l (result (ref i31))
+      (br_on_cast $l anyref (ref i31) (table.get (local.get $i)))
+      (return (i32.const -1))
+    )
+    (i31.get_u)
+  )
+  (func (export "br_on_struct") (param $i i32) (result i32)
+    (block $l (result (ref struct))
+      (br_on_cast $l anyref (ref struct) (table.get (local.get $i)))
+      (return (i32.const -1))
+    )
+    (block $l2 (param structref) (result (ref $st))
+      (block $l3 (param structref) (result (ref $at))
+        (br_on_cast $l2 structref (ref $st))
+        (br_on_cast $l3 anyref (ref $at))
+        (return (i32.const -2))
+      )
+      (return (array.get_u $at (i32.const 0)))
+    )
+    (struct.get_s $st 0)
+  )
+  (func (export "br_on_array") (param $i i32) (result i32)
+    (block $l (result (ref array))
+      (br_on_cast $l anyref (ref array) (table.get (local.get $i)))
+      (return (i32.const -1))
+    )
+    (array.len)
+  )
+
+  (func (export "null-diff") (param $i i32) (result i32)
+    (block $l (result (ref null struct))
+      (block (result (ref any))
+        (br_on_cast $l (ref null any) (ref null struct) (table.get (local.get $i)))
+      )
+      (return (i32.const 0))
+    )
+    (return (i32.const 1))
+  )
+)
+
+(invoke "init" (ref.extern 0))
+
+(assert_return (invoke "br_on_null" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "br_on_null" (i32.const 1)) (i32.const -1))
+(assert_return (invoke "br_on_null" (i32.const 2)) (i32.const -1))
+(assert_return (invoke "br_on_null" (i32.const 3)) (i32.const -1))
+(assert_return (invoke "br_on_null" (i32.const 4)) (i32.const -1))
+
+(assert_return (invoke "br_on_i31" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "br_on_i31" (i32.const 1)) (i32.const 7))
+(assert_return (invoke "br_on_i31" (i32.const 2)) (i32.const -1))
+(assert_return (invoke "br_on_i31" (i32.const 3)) (i32.const -1))
+(assert_return (invoke "br_on_i31" (i32.const 4)) (i32.const -1))
+
+(assert_return (invoke "br_on_struct" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "br_on_struct" (i32.const 1)) (i32.const -1))
+(assert_return (invoke "br_on_struct" (i32.const 2)) (i32.const 6))
+(assert_return (invoke "br_on_struct" (i32.const 3)) (i32.const -1))
+(assert_return (invoke "br_on_struct" (i32.const 4)) (i32.const -1))
+
+(assert_return (invoke "br_on_array" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "br_on_array" (i32.const 1)) (i32.const -1))
+(assert_return (invoke "br_on_array" (i32.const 2)) (i32.const -1))
+(assert_return (invoke "br_on_array" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "br_on_array" (i32.const 4)) (i32.const -1))
+
+(assert_return (invoke "null-diff" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "null-diff" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "null-diff" (i32.const 2)) (i32.const 1))
+(assert_return (invoke "null-diff" (i32.const 3)) (i32.const 0))
+(assert_return (invoke "null-diff" (i32.const 4)) (i32.const 0))
+
+
+;; Concrete Types
+
+(module
+  (type $t0 (sub (struct)))
+  (type $t1 (sub $t0 (struct (field i32))))
+  (type $t1' (sub $t0 (struct (field i32))))
+  (type $t2 (sub $t1 (struct (field i32 i32))))
+  (type $t2' (sub $t1' (struct (field i32 i32))))
+  (type $t3 (sub $t0 (struct (field i32 i32))))
+  (type $t0' (sub $t0 (struct)))
+  (type $t4 (sub $t0' (struct (field i32 i32))))
+
+  (table 20 structref)
 
   (func $init
-    (table.set (i32.const 0) (struct.new_default $t0 (global.get $t0)))
-    (table.set (i32.const 10) (struct.new_default $t0 (global.get $t0')))
-    (table.set (i32.const 1) (struct.new_default $t1 (global.get $t1)))
-    (table.set (i32.const 11) (struct.new_default $t1' (global.get $t1')))
-    (table.set (i32.const 2) (struct.new_default $t2 (global.get $t2)))
-    (table.set (i32.const 12) (struct.new_default $t2' (global.get $t2')))
-    (table.set (i32.const 3) (struct.new_default $t3 (global.get $t3)))
-    (table.set (i32.const 4) (struct.new_default $t3 (global.get $t4)))
+    (table.set (i32.const 0) (struct.new_default $t0))
+    (table.set (i32.const 10) (struct.new_default $t0'))
+    (table.set (i32.const 1) (struct.new_default $t1))
+    (table.set (i32.const 11) (struct.new_default $t1'))
+    (table.set (i32.const 2) (struct.new_default $t2))
+    (table.set (i32.const 12) (struct.new_default $t2'))
+    (table.set (i32.const 3) (struct.new_default $t3))
+    (table.set (i32.const 4) (struct.new_default $t4))
   )
 
   (func (export "test-sub")
     (call $init)
-    (block $l (result dataref)
+    (block $l (result structref)
       ;; must succeed
-      (drop (block (result dataref) (br_on_cast 0 (ref.null data) (global.get $t0))))
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 0)) (global.get $t0))))
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 1)) (global.get $t0))))
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 2)) (global.get $t0))))
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 3)) (global.get $t0))))
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 4)) (global.get $t0))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t0) (ref.null struct))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t0) (table.get (i32.const 0)))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t0) (table.get (i32.const 1)))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t0) (table.get (i32.const 2)))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t0) (table.get (i32.const 3)))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t0) (table.get (i32.const 4)))))
 
-      (drop (block (result dataref) (br_on_cast 0 (ref.null data) (global.get $t1))))
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 1)) (global.get $t1))))
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 2)) (global.get $t1))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t1) (ref.null struct))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t1) (table.get (i32.const 1)))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t1) (table.get (i32.const 2)))))
 
-      (drop (block (result dataref) (br_on_cast 0 (ref.null data) (global.get $t2))))
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 2)) (global.get $t2))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t2) (ref.null struct))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t2) (table.get (i32.const 2)))))
 
-      (drop (block (result dataref) (br_on_cast 0 (ref.null data) (global.get $t3))))
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 3)) (global.get $t3))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t3) (ref.null struct))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t3) (table.get (i32.const 3)))))
 
-      (drop (block (result dataref) (br_on_cast 0 (ref.null data) (global.get $t4))))
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 4)) (global.get $t4))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t4) (ref.null struct))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t4) (table.get (i32.const 4)))))
 
       ;; must not succeed
-      (br_on_cast $l (table.get (i32.const 0)) (global.get $t1))
-      (br_on_cast $l (table.get (i32.const 3)) (global.get $t1))
-      (br_on_cast $l (table.get (i32.const 4)) (global.get $t1))
+      (br_on_cast $l anyref (ref $t1) (table.get (i32.const 0)))
+      (br_on_cast $l anyref (ref $t1) (table.get (i32.const 3)))
+      (br_on_cast $l anyref (ref $t1) (table.get (i32.const 4)))
 
-      (br_on_cast $l (table.get (i32.const 0)) (global.get $t2))
-      (br_on_cast $l (table.get (i32.const 1)) (global.get $t2))
-      (br_on_cast $l (table.get (i32.const 3)) (global.get $t2))
-      (br_on_cast $l (table.get (i32.const 4)) (global.get $t2))
+      (br_on_cast $l anyref (ref $t2) (table.get (i32.const 0)))
+      (br_on_cast $l anyref (ref $t2) (table.get (i32.const 1)))
+      (br_on_cast $l anyref (ref $t2) (table.get (i32.const 3)))
+      (br_on_cast $l anyref (ref $t2) (table.get (i32.const 4)))
 
-      (br_on_cast $l (table.get (i32.const 0)) (global.get $t3))
-      (br_on_cast $l (table.get (i32.const 1)) (global.get $t3))
-      (br_on_cast $l (table.get (i32.const 2)) (global.get $t3))
-      (br_on_cast $l (table.get (i32.const 4)) (global.get $t3))
+      (br_on_cast $l anyref (ref $t3) (table.get (i32.const 0)))
+      (br_on_cast $l anyref (ref $t3) (table.get (i32.const 1)))
+      (br_on_cast $l anyref (ref $t3) (table.get (i32.const 2)))
+      (br_on_cast $l anyref (ref $t3) (table.get (i32.const 4)))
 
-      (br_on_cast $l (table.get (i32.const 0)) (global.get $t4))
-      (br_on_cast $l (table.get (i32.const 1)) (global.get $t4))
-      (br_on_cast $l (table.get (i32.const 2)) (global.get $t4))
-      (br_on_cast $l (table.get (i32.const 3)) (global.get $t4))
+      (br_on_cast $l anyref (ref $t4) (table.get (i32.const 0)))
+      (br_on_cast $l anyref (ref $t4) (table.get (i32.const 1)))
+      (br_on_cast $l anyref (ref $t4) (table.get (i32.const 2)))
+      (br_on_cast $l anyref (ref $t4) (table.get (i32.const 3)))
 
       (return)
     )
@@ -80,25 +176,25 @@
   (func (export "test-canon")
     (call $init)
     (block $l
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 0)) (global.get $t0'))))
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 1)) (global.get $t0'))))
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 2)) (global.get $t0'))))
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 3)) (global.get $t0'))))
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 4)) (global.get $t0'))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t0') (table.get (i32.const 0)))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t0') (table.get (i32.const 1)))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t0') (table.get (i32.const 2)))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t0') (table.get (i32.const 3)))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t0') (table.get (i32.const 4)))))
 
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 10)) (global.get $t0))))
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 11)) (global.get $t0))))
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 12)) (global.get $t0))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t0) (table.get (i32.const 10)))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t0) (table.get (i32.const 11)))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t0) (table.get (i32.const 12)))))
 
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 1)) (global.get $t1'))))
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 2)) (global.get $t1'))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t1') (table.get (i32.const 1)))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t1') (table.get (i32.const 2)))))
 
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 11)) (global.get $t1))))
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 12)) (global.get $t1))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t1) (table.get (i32.const 11)))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t1) (table.get (i32.const 12)))))
 
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 2)) (global.get $t2'))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t2') (table.get (i32.const 2)))))
 
-      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 12)) (global.get $t2))))
+      (drop (block (result structref) (br_on_cast 0 structref (ref $t2) (table.get (i32.const 12)))))
 
       (return)
     )
@@ -108,3 +204,82 @@
 
 (invoke "test-sub")
 (invoke "test-canon")
+
+
+;; Cases of nullability
+
+(module
+  (type $t (struct))
+
+  (func (param (ref any)) (result (ref $t))
+    (block (result (ref any)) (br_on_cast 1 (ref any) (ref $t) (local.get 0))) (unreachable)
+  )
+  (func (param (ref null any)) (result (ref $t))
+    (block (result (ref null any)) (br_on_cast 1 (ref null any) (ref $t) (local.get 0))) (unreachable)
+  )
+  (func (param (ref null any)) (result (ref null $t))
+    (block (result (ref null any)) (br_on_cast 1 (ref null any) (ref null $t) (local.get 0))) (unreachable)
+  )
+)
+
+(assert_invalid
+  (module
+    (type $t (struct))
+    (func (param (ref any)) (result (ref $t))
+      (block (result (ref any)) (br_on_cast 1 (ref null any) (ref null $t) (local.get 0))) (unreachable)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type $t (struct))
+    (func (param (ref any)) (result (ref null $t))
+      (block (result (ref any)) (br_on_cast 1 (ref any) (ref null $t) (local.get 0))) (unreachable)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type $t (struct))
+    (func (param (ref null any)) (result (ref $t))
+      (block (result (ref any)) (br_on_cast 1 (ref null any) (ref $t) (local.get 0))) (unreachable)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func (result anyref)
+      (br_on_cast 0 eqref anyref (unreachable))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func (result anyref)
+      (br_on_cast 0 structref arrayref (unreachable))
+    )
+  )
+  "type mismatch"
+)
+
+
+;; https://github.com/WebAssembly/gc/issues/516
+(assert_invalid
+  (module
+    (type $t (func))
+    (func $f (param (ref null $t)) (result funcref) (local.get 0))
+    (func (param funcref) (result funcref funcref)
+      (ref.null $t)
+      (local.get 0)
+      (br_on_cast 0 funcref (ref $t))  ;; only leaves two funcref's on the stack
+      (drop)
+      (call $f)
+      (local.get 0)
+    )
+  )
+  "type mismatch"
+)
diff --git a/tests/wast/spec/proposals/gc/br_on_cast_fail.wast b/tests/wast/spec/proposals/gc/br_on_cast_fail.wast
new file mode 100644
index 0000000000..db6db11b05
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/br_on_cast_fail.wast
@@ -0,0 +1,300 @@
+;; Abstract Types
+
+(module
+  (type $ft (func (result i32)))
+  (type $st (struct (field i16)))
+  (type $at (array i8))
+
+  (table 10 anyref)
+
+  (elem declare func $f)
+  (func $f (result i32) (i32.const 9))
+
+  (func (export "init") (param $x externref)
+    (table.set (i32.const 0) (ref.null any))
+    (table.set (i32.const 1) (ref.i31 (i32.const 7)))
+    (table.set (i32.const 2) (struct.new $st (i32.const 6)))
+    (table.set (i32.const 3) (array.new $at (i32.const 5) (i32.const 3)))
+    (table.set (i32.const 4) (any.convert_extern (local.get $x)))
+  )
+
+  (func (export "br_on_non_null") (param $i i32) (result i32)
+    (block $l (result (ref any))
+      (br_on_non_null $l (table.get (local.get $i)))
+      (return (i32.const 0))
+    )
+    (return (i32.const -1))
+  )
+  (func (export "br_on_non_i31") (param $i i32) (result i32)
+    (block $l (result anyref)
+      (br_on_cast_fail $l anyref (ref i31) (table.get (local.get $i)))
+      (return (i31.get_u))
+    )
+    (return (i32.const -1))
+  )
+  (func (export "br_on_non_struct") (param $i i32) (result i32)
+    (block $l (result anyref)
+      (br_on_cast_fail $l anyref (ref struct) (table.get (local.get $i)))
+      (block $l2 (param structref) (result (ref $st))
+        (block $l3 (param structref) (result (ref $at))
+          (br_on_cast $l2 structref (ref $st))
+          (br_on_cast $l3 anyref (ref $at))
+          (return (i32.const -2))
+        )
+        (return (array.get_u $at (i32.const 0)))
+      )
+      (return (struct.get_s $st 0))
+    )
+    (return (i32.const -1))
+  )
+  (func (export "br_on_non_array") (param $i i32) (result i32)
+    (block $l (result anyref)
+      (br_on_cast_fail $l anyref (ref array) (table.get (local.get $i)))
+      (return (array.len))
+    )
+    (return (i32.const -1))
+  )
+
+  (func (export "null-diff") (param $i i32) (result i32)
+    (block $l (result (ref any))
+      (block (result (ref null struct))
+        (br_on_cast_fail $l (ref null any) (ref null struct) (table.get (local.get $i)))
+      )
+      (return (i32.const 1))
+    )
+    (return (i32.const 0))
+  )
+)
+
+(invoke "init" (ref.extern 0))
+
+(assert_return (invoke "br_on_non_null" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "br_on_non_null" (i32.const 1)) (i32.const -1))
+(assert_return (invoke "br_on_non_null" (i32.const 2)) (i32.const -1))
+(assert_return (invoke "br_on_non_null" (i32.const 3)) (i32.const -1))
+(assert_return (invoke "br_on_non_null" (i32.const 4)) (i32.const -1))
+
+(assert_return (invoke "br_on_non_i31" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "br_on_non_i31" (i32.const 1)) (i32.const 7))
+(assert_return (invoke "br_on_non_i31" (i32.const 2)) (i32.const -1))
+(assert_return (invoke "br_on_non_i31" (i32.const 3)) (i32.const -1))
+(assert_return (invoke "br_on_non_i31" (i32.const 4)) (i32.const -1))
+
+(assert_return (invoke "br_on_non_struct" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "br_on_non_struct" (i32.const 1)) (i32.const -1))
+(assert_return (invoke "br_on_non_struct" (i32.const 2)) (i32.const 6))
+(assert_return (invoke "br_on_non_struct" (i32.const 3)) (i32.const -1))
+(assert_return (invoke "br_on_non_struct" (i32.const 4)) (i32.const -1))
+
+(assert_return (invoke "br_on_non_array" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "br_on_non_array" (i32.const 1)) (i32.const -1))
+(assert_return (invoke "br_on_non_array" (i32.const 2)) (i32.const -1))
+(assert_return (invoke "br_on_non_array" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "br_on_non_array" (i32.const 4)) (i32.const -1))
+
+(assert_return (invoke "null-diff" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "null-diff" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "null-diff" (i32.const 2)) (i32.const 1))
+(assert_return (invoke "null-diff" (i32.const 3)) (i32.const 0))
+(assert_return (invoke "null-diff" (i32.const 4)) (i32.const 0))
+
+
+;; Concrete Types
+
+(module
+  (type $t0 (sub (struct)))
+  (type $t1 (sub $t0 (struct (field i32))))
+  (type $t1' (sub $t0 (struct (field i32))))
+  (type $t2 (sub $t1 (struct (field i32 i32))))
+  (type $t2' (sub $t1' (struct (field i32 i32))))
+  (type $t3 (sub $t0 (struct (field i32 i32))))
+  (type $t0' (sub $t0 (struct)))
+  (type $t4 (sub $t0' (struct (field i32 i32))))
+
+  (table 20 structref)
+
+  (func $init
+    (table.set (i32.const 0) (struct.new_default $t0))
+    (table.set (i32.const 10) (struct.new_default $t0))
+    (table.set (i32.const 1) (struct.new_default $t1))
+    (table.set (i32.const 11) (struct.new_default $t1'))
+    (table.set (i32.const 2) (struct.new_default $t2))
+    (table.set (i32.const 12) (struct.new_default $t2'))
+    (table.set (i32.const 3) (struct.new_default $t3 ))
+    (table.set (i32.const 4) (struct.new_default $t4))
+  )
+
+  (func (export "test-sub")
+    (call $init)
+    (block $l (result structref)
+      ;; must not succeed
+      (br_on_cast_fail $l structref (ref null $t0) (ref.null struct))
+      (br_on_cast_fail $l structref (ref null $t0) (table.get (i32.const 0)))
+      (br_on_cast_fail $l structref (ref null $t0) (table.get (i32.const 1)))
+      (br_on_cast_fail $l structref (ref null $t0) (table.get (i32.const 2)))
+      (br_on_cast_fail $l structref (ref null $t0) (table.get (i32.const 3)))
+      (br_on_cast_fail $l structref (ref null $t0) (table.get (i32.const 4)))
+      (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 0)))
+      (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 1)))
+      (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 2)))
+      (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 3)))
+      (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 4)))
+
+      (br_on_cast_fail $l structref (ref null $t1) (ref.null struct))
+      (br_on_cast_fail $l structref (ref null $t1) (table.get (i32.const 1)))
+      (br_on_cast_fail $l structref (ref null $t1) (table.get (i32.const 2)))
+      (br_on_cast_fail $l structref (ref $t1) (table.get (i32.const 1)))
+      (br_on_cast_fail $l structref (ref $t1) (table.get (i32.const 2)))
+
+      (br_on_cast_fail $l structref (ref null $t2) (ref.null struct))
+      (br_on_cast_fail $l structref (ref null $t2) (table.get (i32.const 2)))
+      (br_on_cast_fail $l structref (ref $t2) (table.get (i32.const 2)))
+
+      (br_on_cast_fail $l structref (ref null $t3) (ref.null struct))
+      (br_on_cast_fail $l structref (ref null $t3) (table.get (i32.const 3)))
+      (br_on_cast_fail $l structref (ref $t3) (table.get (i32.const 3)))
+
+      (br_on_cast_fail $l structref (ref null $t4) (ref.null struct))
+      (br_on_cast_fail $l structref (ref null $t4) (table.get (i32.const 4)))
+      (br_on_cast_fail $l structref (ref $t4) (table.get (i32.const 4)))
+
+      ;; must succeed
+      (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t0) (ref.null struct))))
+
+      (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t1) (ref.null struct))))
+      (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t1) (table.get (i32.const 0)))))
+      (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t1) (table.get (i32.const 3)))))
+      (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t1) (table.get (i32.const 4)))))
+
+      (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t2) (ref.null struct))))
+      (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t2) (table.get (i32.const 0)))))
+      (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t2) (table.get (i32.const 1)))))
+      (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t2) (table.get (i32.const 3)))))
+      (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t2) (table.get (i32.const 4)))))
+
+      (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t3) (ref.null struct))))
+      (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t3) (table.get (i32.const 0)))))
+      (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t3) (table.get (i32.const 1)))))
+      (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t3) (table.get (i32.const 2)))))
+      (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t3) (table.get (i32.const 4)))))
+
+      (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t4) (ref.null struct))))
+      (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t4) (table.get (i32.const 0)))))
+      (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t4) (table.get (i32.const 1)))))
+      (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t4) (table.get (i32.const 2)))))
+      (drop (block (result structref) (br_on_cast_fail 0 structref (ref $t4) (table.get (i32.const 3)))))
+
+      (return)
+    )
+    (unreachable)
+  )
+
+  (func (export "test-canon")
+    (call $init)
+    (block $l (result structref)
+      (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 0)))
+      (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 1)))
+      (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 2)))
+      (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 3)))
+      (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 4)))
+      (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 10)))
+      (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 11)))
+      (br_on_cast_fail $l structref (ref $t0) (table.get (i32.const 12)))
+
+      (br_on_cast_fail $l structref (ref $t1') (table.get (i32.const 1)))
+      (br_on_cast_fail $l structref (ref $t1') (table.get (i32.const 2)))
+
+      (br_on_cast_fail $l structref (ref $t1) (table.get (i32.const 11)))
+      (br_on_cast_fail $l structref (ref $t1) (table.get (i32.const 12)))
+
+      (br_on_cast_fail $l structref (ref $t2') (table.get (i32.const 2)))
+
+      (br_on_cast_fail $l structref (ref $t2) (table.get (i32.const 12)))
+
+      (return)
+    )
+    (unreachable)
+  )
+)
+
+(invoke "test-sub")
+(invoke "test-canon")
+
+
+;; Cases of nullability
+
+(module
+  (type $t (struct))
+
+  (func (param (ref any)) (result (ref any))
+    (block (result (ref $t)) (br_on_cast_fail 1 (ref any) (ref $t) (local.get 0)))
+  )
+  (func (param (ref null any)) (result (ref null any))
+    (block (result (ref $t)) (br_on_cast_fail 1 (ref null any) (ref $t) (local.get 0)))
+  )
+  (func (param (ref null any)) (result (ref null any))
+    (block (result (ref null $t)) (br_on_cast_fail 1 (ref null any) (ref null $t) (local.get 0)))
+  )
+)
+
+(assert_invalid
+  (module
+    (type $t (struct))
+    (func (param (ref any)) (result (ref any))
+      (block (result (ref $t)) (br_on_cast_fail 1 (ref null any) (ref null $t) (local.get 0)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type $t (struct))
+    (func (param (ref any)) (result (ref any))
+      (block (result (ref null $t)) (br_on_cast_fail 1 (ref any) (ref null $t) (local.get 0))) (ref.as_non_null)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type $t (struct))
+    (func (param (ref null any)) (result (ref any))
+      (block (result (ref $t)) (br_on_cast_fail 1 (ref null any) (ref $t) (local.get 0)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func (result anyref)
+      (br_on_cast_fail 0 eqref anyref (unreachable))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func (result anyref)
+      (br_on_cast_fail 0 structref arrayref (unreachable))
+    )
+  )
+  "type mismatch"
+)
+
+
+;; https://github.com/WebAssembly/gc/issues/516
+(assert_invalid
+  (module
+    (type $t (func))
+    (func $f (param (ref null $t)) (result funcref) (local.get 0))
+    (func (param funcref) (result funcref funcref)
+      (ref.null $t)
+      (local.get 0)
+      (br_on_cast_fail 0 funcref (ref $t))  ;; only leaves two funcref's on the stack
+      (drop)
+      (call $f)
+      (local.get 0)
+    )
+  )
+  "type mismatch"
+)
diff --git a/tests/wast/spec/proposals/gc/br_on_non_null.wast b/tests/wast/spec/proposals/gc/br_on_non_null.wast
new file mode 100644
index 0000000000..43800194fe
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/br_on_non_null.wast
@@ -0,0 +1,90 @@
+(module
+  (type $t (func (result i32)))
+
+  (func $nn (param $r (ref $t)) (result i32)
+    (call_ref $t
+      (block $l (result (ref $t))
+        (br_on_non_null $l (local.get $r))
+        (return (i32.const -1))
+      )
+    )
+  )
+  (func $n (param $r (ref null $t)) (result i32)
+    (call_ref $t
+      (block $l (result (ref $t))
+        (br_on_non_null $l (local.get $r))
+        (return (i32.const -1))
+      )
+    )
+  )
+
+  (elem func $f)
+  (func $f (result i32) (i32.const 7))
+
+  (func (export "nullable-null") (result i32) (call $n (ref.null $t)))
+  (func (export "nonnullable-f") (result i32) (call $nn (ref.func $f)))
+  (func (export "nullable-f") (result i32) (call $n (ref.func $f)))
+
+  (func (export "unreachable") (result i32)
+    (block $l (result (ref $t))
+      (br_on_non_null $l (unreachable))
+      (return (i32.const -1))
+    )
+    (call_ref $t)
+  )
+)
+
+(assert_trap (invoke "unreachable") "unreachable")
+
+(assert_return (invoke "nullable-null") (i32.const -1))
+(assert_return (invoke "nonnullable-f") (i32.const 7))
+(assert_return (invoke "nullable-f") (i32.const 7))
+
+(module
+  (type $t (func))
+  (func (param $r (ref null $t)) (drop (block (result (ref $t)) (br_on_non_null 0 (local.get $r)) (unreachable))))
+  (func (param $r (ref null func)) (drop (block (result (ref func)) (br_on_non_null 0 (local.get $r)) (unreachable))))
+  (func (param $r (ref null extern)) (drop (block (result (ref extern)) (br_on_non_null 0 (local.get $r)) (unreachable))))
+)
+
+
+(module
+  (type $t (func (param i32) (result i32)))
+  (elem func $f)
+  (func $f (param i32) (result i32) (i32.mul (local.get 0) (local.get 0)))
+
+  (func $a (param $n i32) (param $r (ref null $t)) (result i32)
+    (call_ref $t
+      (block $l (result i32 (ref $t))
+        (return (br_on_non_null $l (local.get $n) (local.get $r)))
+      )
+    )
+  )
+
+  (func (export "args-null") (param $n i32) (result i32)
+    (call $a (local.get $n) (ref.null $t))
+  )
+  (func (export "args-f") (param $n i32) (result i32)
+    (call $a (local.get $n) (ref.func $f))
+  )
+)
+
+(assert_return (invoke "args-null" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "args-f" (i32.const 3)) (i32.const 9))
+
+
+;; https://github.com/WebAssembly/gc/issues/516
+(assert_invalid
+  (module
+    (type $t (func))
+    (func $f (param (ref null $t)) (result funcref) (local.get 0))
+    (func (param funcref) (result funcref funcref)
+      (ref.null $t)
+      (local.get 0)
+      (br_on_non_null 0)  ;; only leaves a funcref on the stack
+      (call $f)
+      (local.get 0)
+    )
+  )
+  "type mismatch"
+)
diff --git a/tests/wast/spec/proposals/gc/br_on_null.wast b/tests/wast/spec/proposals/gc/br_on_null.wast
index 3bae85000f..e47dae50a3 100644
--- a/tests/wast/spec/proposals/gc/br_on_null.wast
+++ b/tests/wast/spec/proposals/gc/br_on_null.wast
@@ -3,13 +3,13 @@
 
   (func $nn (param $r (ref $t)) (result i32)
     (block $l
-      (return (call_ref (br_on_null $l (local.get $r))))
+      (return (call_ref $t (br_on_null $l (local.get $r))))
     )
     (i32.const -1)
   )
   (func $n (param $r (ref null $t)) (result i32)
     (block $l
-      (return (call_ref (br_on_null $l (local.get $r))))
+      (return (call_ref $t (br_on_null $l (local.get $r))))
     )
     (i32.const -1)
   )
@@ -23,7 +23,7 @@
 
   (func (export "unreachable") (result i32)
     (block $l
-      (return (call_ref (br_on_null $l (unreachable))))
+      (return (call_ref $t (br_on_null $l (unreachable))))
     )
     (i32.const -1)
   )
@@ -35,20 +35,11 @@
 (assert_return (invoke "nonnullable-f") (i32.const 7))
 (assert_return (invoke "nullable-f") (i32.const 7))
 
-(assert_invalid
-  (module
-    (type $t (func (result i32)))
-    (func $g (param $r (ref $t)) (drop (br_on_null 0 (local.get $r))))
-    (func (call $g (ref.null $t)))
-  )
-  "type mismatch"
-)
-
 (module
   (type $t (func))
-  (func (param $r (ref $t)) (drop (br_on_null 0 (local.get $r))))
-  (func (param $r (ref func)) (drop (br_on_null 0 (local.get $r))))
-  (func (param $r (ref extern)) (drop (br_on_null 0 (local.get $r))))
+  (func (param $r (ref null $t)) (drop (br_on_null 0 (local.get $r))))
+  (func (param $r (ref null func)) (drop (br_on_null 0 (local.get $r))))
+  (func (param $r (ref null extern)) (drop (br_on_null 0 (local.get $r))))
 )
 
 
@@ -59,7 +50,7 @@
 
   (func $a (param $n i32) (param $r (ref null $t)) (result i32)
     (block $l (result i32)
-      (return (call_ref (br_on_null $l (local.get $n) (local.get $r))))
+      (return (call_ref $t (br_on_null $l (local.get $n) (local.get $r))))
     )
   )
 
@@ -73,3 +64,31 @@
 
 (assert_return (invoke "args-null" (i32.const 3)) (i32.const 3))
 (assert_return (invoke "args-f" (i32.const 3)) (i32.const 9))
+
+
+;; https://github.com/WebAssembly/gc/issues/516
+;; Tests that validators are correctly doing
+;;
+;;     pop_operands(label_types)
+;;     push_operands(label_types)
+;;
+;; for validating br_on_null, rather than incorrectly doing either
+;;
+;;     push_operands(pop_operands(label_types))
+;;
+;; or just inspecting the types on the stack without any pushing or
+;; popping, neither of which handle subtyping correctly.
+(assert_invalid
+  (module
+    (type $t (func))
+    (func $f (param (ref null $t)) (result funcref) (local.get 0))
+    (func (param funcref) (result funcref)
+      (ref.null $t)
+      (local.get 0)
+      (br_on_null 0)  ;; only leaves two funcref's on the stack
+      (drop)
+      (call $f)
+    )
+  )
+  "type mismatch"
+)
diff --git a/tests/wast/spec/proposals/gc/br_table.wast b/tests/wast/spec/proposals/gc/br_table.wast
index 33650e2157..2a5197ce14 100644
--- a/tests/wast/spec/proposals/gc/br_table.wast
+++ b/tests/wast/spec/proposals/gc/br_table.wast
@@ -583,255 +583,6 @@
           0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
           0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
           0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
           (local.get 0)
         )
         (return (i32.const -1))
@@ -1675,20 +1426,6 @@
 )
 
 
-(assert_invalid
-  (module (func $meet-bottom (param i32) (result externref)
-    (block $l1 (result externref)
-      (drop
-        (block $l2 (result i32)
-          (br_table $l2 $l1 $l2 (ref.null extern) (local.get 0))
-        )
-      )
-      (ref.null extern)
-    )
-  ))
-  "type mismatch"
-)
-
 (assert_invalid
   (module (func $unbound-label
     (block (br_table 2 1 (i32.const 1)))
diff --git a/tests/wast/spec/proposals/gc/call_ref.wast b/tests/wast/spec/proposals/gc/call_ref.wast
index 503c4e8613..aa9ac7b873 100644
--- a/tests/wast/spec/proposals/gc/call_ref.wast
+++ b/tests/wast/spec/proposals/gc/call_ref.wast
@@ -2,7 +2,7 @@
   (type $ii (func (param i32) (result i32)))
 
   (func $apply (param $f (ref $ii)) (param $x i32) (result i32)
-    (call_ref (local.get $x) (local.get $f))
+    (call_ref $ii (local.get $x) (local.get $f))
   )
 
   (func $f (type $ii) (i32.mul (local.get 0) (local.get 0)))
@@ -15,11 +15,11 @@
     (local $rg (ref null $ii))
     (local.set $rf (ref.func $f))
     (local.set $rg (ref.func $g))
-    (call_ref (call_ref (local.get $x) (local.get $rf)) (local.get $rg))
+    (call_ref $ii (call_ref $ii (local.get $x) (local.get $rf)) (local.get $rg))
   )
 
   (func (export "null") (result i32)
-    (call_ref (i32.const 1) (ref.null $ii))
+    (call_ref $ii (i32.const 1) (ref.null $ii))
   )
 
   ;; Recursion
@@ -36,7 +36,7 @@
       (else
         (i64.mul
           (local.get 0)
-          (call_ref (i64.sub (local.get 0) (i64.const 1)) (global.get $fac))
+          (call_ref $ll (i64.sub (local.get 0) (i64.const 1)) (global.get $fac))
         )
       )
     )
@@ -49,7 +49,7 @@
     (if (result i64) (i64.eqz (local.get 0))
       (then (local.get 1))
       (else
-        (call_ref
+        (call_ref $lll
           (i64.sub (local.get 0) (i64.const 1))
           (i64.mul (local.get 0) (local.get 1))
           (global.get $fac-acc)
@@ -66,8 +66,8 @@
       (then (i64.const 1))
       (else
         (i64.add
-          (call_ref (i64.sub (local.get 0) (i64.const 2)) (global.get $fib))
-          (call_ref (i64.sub (local.get 0) (i64.const 1)) (global.get $fib))
+          (call_ref $ll (i64.sub (local.get 0) (i64.const 2)) (global.get $fib))
+          (call_ref $ll (i64.sub (local.get 0) (i64.const 1)) (global.get $fib))
         )
       )
     )
@@ -80,13 +80,13 @@
   (func $even (export "even") (type $ll)
     (if (result i64) (i64.eqz (local.get 0))
       (then (i64.const 44))
-      (else (call_ref (i64.sub (local.get 0) (i64.const 1)) (global.get $odd)))
+      (else (call_ref $ll (i64.sub (local.get 0) (i64.const 1)) (global.get $odd)))
     )
   )
   (func $odd (export "odd") (type $ll)
     (if (result i64) (i64.eqz (local.get 0))
       (then (i64.const 99))
-      (else (call_ref (i64.sub (local.get 0) (i64.const 1)) (global.get $even)))
+      (else (call_ref $ll (i64.sub (local.get 0) (i64.const 1)) (global.get $even)))
     )
   )
 )
@@ -94,7 +94,7 @@
 (assert_return (invoke "run" (i32.const 0)) (i32.const 0))
 (assert_return (invoke "run" (i32.const 3)) (i32.const -9))
 
-(assert_trap (invoke "null") "null function")
+(assert_trap (invoke "null") "null function reference")
 
 (assert_return (invoke "fac" (i64.const 0)) (i64.const 1))
 (assert_return (invoke "fac" (i64.const 1)) (i64.const 1))
@@ -127,34 +127,37 @@
 ;; Unreachable typing.
 
 (module
+  (type $t (func))
   (func (export "unreachable") (result i32)
     (unreachable)
-    (call_ref)
+    (call_ref $t)
   )
 )
 (assert_trap (invoke "unreachable") "unreachable")
 
 (module
   (elem declare func $f)
+  (type $t (func (param i32) (result i32)))
   (func $f (param i32) (result i32) (local.get 0))
 
   (func (export "unreachable") (result i32)
     (unreachable)
     (ref.func $f)
-    (call_ref)
+    (call_ref $t)
   )
 )
 (assert_trap (invoke "unreachable") "unreachable")
 
 (module
   (elem declare func $f)
+  (type $t (func (param i32) (result i32)))
   (func $f (param i32) (result i32) (local.get 0))
 
   (func (export "unreachable") (result i32)
     (unreachable)
     (i32.const 0)
     (ref.func $f)
-    (call_ref)
+    (call_ref $t)
     (drop)
     (i32.const 0)
   )
@@ -164,13 +167,14 @@
 (assert_invalid
   (module
     (elem declare func $f)
+    (type $t (func (param i32) (result i32)))
     (func $f (param i32) (result i32) (local.get 0))
 
     (func (export "unreachable") (result i32)
       (unreachable)
       (i64.const 0)
       (ref.func $f)
-      (call_ref)
+      (call_ref $t)
     )
   )
   "type mismatch"
@@ -179,12 +183,13 @@
 (assert_invalid
   (module
     (elem declare func $f)
+    (type $t (func (param i32) (result i32)))
     (func $f (param i32) (result i32) (local.get 0))
 
     (func (export "unreachable") (result i32)
       (unreachable)
       (ref.func $f)
-      (call_ref)
+      (call_ref $t)
       (drop)
       (i64.const 0)
     )
@@ -194,8 +199,19 @@
 
 (assert_invalid
   (module
+    (type $t (func))
     (func $f (param $r externref)
-      (call_ref (local.get $r))
+      (call_ref $t (local.get $r))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $t (func))
+    (func $f (param $r funcref)
+      (call_ref $t (local.get $r))
     )
   )
   "type mismatch"
diff --git a/tests/wast/spec/proposals/gc/data.wast b/tests/wast/spec/proposals/gc/data.wast
new file mode 100644
index 0000000000..a5c87fbbc9
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/data.wast
@@ -0,0 +1,492 @@
+;; Test the data section
+
+;; Syntax
+
+(module
+  (memory $m 1)
+  (data (i32.const 0))
+  (data (i32.const 1) "a" "" "bcd")
+  (data (offset (i32.const 0)))
+  (data (offset (i32.const 0)) "" "a" "bc" "")
+  (data (memory 0) (i32.const 0))
+  (data (memory 0x0) (i32.const 1) "a" "" "bcd")
+  (data (memory 0x000) (offset (i32.const 0)))
+  (data (memory 0) (offset (i32.const 0)) "" "a" "bc" "")
+  (data (memory $m) (i32.const 0))
+  (data (memory $m) (i32.const 1) "a" "" "bcd")
+  (data (memory $m) (offset (i32.const 0)))
+  (data (memory $m) (offset (i32.const 0)) "" "a" "bc" "")
+  (data $d1 (i32.const 0))
+  (data $d2 (i32.const 1) "a" "" "bcd")
+  (data $d3 (offset (i32.const 0)))
+  (data $d4 (offset (i32.const 0)) "" "a" "bc" "")
+  (data $d5 (memory 0) (i32.const 0))
+  (data $d6 (memory 0x0) (i32.const 1) "a" "" "bcd")
+  (data $d7 (memory 0x000) (offset (i32.const 0)))
+  (data $d8 (memory 0) (offset (i32.const 0)) "" "a" "bc" "")
+  (data $d9 (memory $m) (i32.const 0))
+  (data $d10 (memory $m) (i32.const 1) "a" "" "bcd")
+  (data $d11 (memory $m) (offset (i32.const 0)))
+  (data $d12 (memory $m) (offset (i32.const 0)) "" "a" "bc" "")
+)
+
+;; Basic use
+
+(module
+  (memory 1)
+  (data (i32.const 0) "a")
+)
+(module
+  (import "spectest" "memory" (memory 1))
+  (data (i32.const 0) "a")
+)
+
+(module
+  (memory 1)
+  (data (i32.const 0) "a")
+  (data (i32.const 3) "b")
+  (data (i32.const 100) "cde")
+  (data (i32.const 5) "x")
+  (data (i32.const 3) "c")
+)
+(module
+  (import "spectest" "memory" (memory 1))
+  (data (i32.const 0) "a")
+  (data (i32.const 1) "b")
+  (data (i32.const 2) "cde")
+  (data (i32.const 3) "f")
+  (data (i32.const 2) "g")
+  (data (i32.const 1) "h")
+)
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (memory 1)
+  (data (global.get 0) "a")
+)
+(module
+  (global (import "spectest" "global_i32") i32)
+  (import "spectest" "memory" (memory 1))
+  (data (global.get 0) "a")
+)
+
+(module
+  (global $g (import "spectest" "global_i32") i32)
+  (memory 1)
+  (data (global.get $g) "a")
+)
+(module
+  (global $g (import "spectest" "global_i32") i32)
+  (import "spectest" "memory" (memory 1))
+  (data (global.get $g) "a")
+)
+
+(module (memory 1) (global i32 (i32.const 0)) (data (global.get 0) "a"))
+(module (memory 1) (global $g i32 (i32.const 0)) (data (global.get $g) "a"))
+
+
+;; Corner cases
+
+(module
+  (memory 1)
+  (data (i32.const 0) "a")
+  (data (i32.const 0xffff) "b")
+)
+(module
+  (import "spectest" "memory" (memory 1))
+  (data (i32.const 0) "a")
+  (data (i32.const 0xffff) "b")
+)
+
+(module
+  (memory 2)
+  (data (i32.const 0x1_ffff) "a")
+)
+
+(module
+  (memory 0)
+  (data (i32.const 0))
+)
+(module
+  (import "spectest" "memory" (memory 0))
+  (data (i32.const 0))
+)
+
+(module
+  (memory 0 0)
+  (data (i32.const 0))
+)
+
+(module
+  (memory 1)
+  (data (i32.const 0x1_0000) "")
+)
+
+(module
+  (memory 0)
+  (data (i32.const 0) "" "")
+)
+(module
+  (import "spectest" "memory" (memory 0))
+  (data (i32.const 0) "" "")
+)
+
+(module
+  (memory 0 0)
+  (data (i32.const 0) "" "")
+)
+
+(module
+  (import "spectest" "memory" (memory 0))
+  (data (i32.const 0) "a")
+)
+
+(module
+  (import "spectest" "memory" (memory 0 3))
+  (data (i32.const 0) "a")
+)
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (import "spectest" "memory" (memory 0))
+  (data (global.get 0) "a")
+)
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (import "spectest" "memory" (memory 0 3))
+  (data (global.get 0) "a")
+)
+
+(module
+  (import "spectest" "memory" (memory 0))
+  (data (i32.const 1) "a")
+)
+
+(module
+  (import "spectest" "memory" (memory 0 3))
+  (data (i32.const 1) "a")
+)
+
+;; Invalid bounds for data
+
+(assert_trap
+  (module
+    (memory 0)
+    (data (i32.const 0) "a")
+  )
+  "out of bounds memory access"
+)
+
+(assert_trap
+  (module
+    (memory 0 0)
+    (data (i32.const 0) "a")
+  )
+  "out of bounds memory access"
+)
+
+(assert_trap
+  (module
+    (memory 0 1)
+    (data (i32.const 0) "a")
+  )
+  "out of bounds memory access"
+)
+(assert_trap
+  (module
+    (memory 0)
+    (data (i32.const 1))
+  )
+  "out of bounds memory access"
+)
+(assert_trap
+  (module
+    (memory 0 1)
+    (data (i32.const 1))
+  )
+  "out of bounds memory access"
+)
+
+;; This seems to cause a time-out on Travis.
+(;assert_unlinkable
+  (module
+    (memory 0x10000)
+    (data (i32.const 0xffffffff) "ab")
+  )
+  ""  ;; either out of memory or out of bounds
+;)
+
+(assert_trap
+  (module
+    (global (import "spectest" "global_i32") i32)
+    (memory 0)
+    (data (global.get 0) "a")
+  )
+  "out of bounds memory access"
+)
+
+(assert_trap
+  (module
+    (memory 1 2)
+    (data (i32.const 0x1_0000) "a")
+  )
+  "out of bounds memory access"
+)
+(assert_trap
+  (module
+    (import "spectest" "memory" (memory 1))
+    (data (i32.const 0x1_0000) "a")
+  )
+  "out of bounds memory access"
+)
+
+(assert_trap
+  (module
+    (memory 2)
+    (data (i32.const 0x2_0000) "a")
+  )
+  "out of bounds memory access"
+)
+
+(assert_trap
+  (module
+    (memory 2 3)
+    (data (i32.const 0x2_0000) "a")
+  )
+  "out of bounds memory access"
+)
+
+(assert_trap
+  (module
+    (memory 1)
+    (data (i32.const -1) "a")
+  )
+  "out of bounds memory access"
+)
+(assert_trap
+  (module
+    (import "spectest" "memory" (memory 1))
+    (data (i32.const -1) "a")
+  )
+  "out of bounds memory access"
+)
+
+(assert_trap
+  (module
+    (memory 2)
+    (data (i32.const -100) "a")
+  )
+  "out of bounds memory access"
+)
+(assert_trap
+  (module
+    (import "spectest" "memory" (memory 1))
+    (data (i32.const -100) "a")
+  )
+  "out of bounds memory access"
+)
+
+;; Data without memory
+
+(assert_invalid
+  (module
+    (data (i32.const 0) "")
+  )
+  "unknown memory"
+)
+
+;; Data segment with memory index 1 (only memory 0 available)
+(assert_invalid
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\00"                                ;; memory 0
+    "\0b\07\01"                             ;; data section
+    "\02\01\41\00\0b"                       ;; active data segment 0 for memory 1
+    "\00"                                   ;; empty vec(byte)
+  )
+  "unknown memory 1"
+)
+
+;; Data segment with memory index 0 (no memory section)
+(assert_invalid
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0b\06\01"                             ;; data section
+    "\00\41\00\0b"                          ;; active data segment 0 for memory 0
+    "\00"                                   ;; empty vec(byte)
+  )
+  "unknown memory 0"
+)
+
+;; Data segment with memory index 1 (no memory section)
+(assert_invalid
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0b\07\01"                             ;; data section
+    "\02\01\41\00\0b"                       ;; active data segment 0 for memory 1
+    "\00"                                   ;; empty vec(byte)
+  )
+  "unknown memory 1"
+)
+
+;; Data segment with memory index 1 and vec(byte) as above,
+;; only memory 0 available.
+(assert_invalid
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\00"                                ;; memory 0
+    "\0b\45\01"                             ;; data section
+    "\02"                                   ;; active segment
+    "\01"                                   ;; memory index
+    "\41\00\0b"                             ;; offset constant expression
+    "\3e"                                   ;; vec(byte) length
+    "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f"
+    "\10\11\12\13\14\15\16\17\18\19\1a\1b\1c\1d\1e\1f"
+    "\20\21\22\23\24\25\26\27\28\29\2a\2b\2c\2d\2e\2f"
+    "\30\31\32\33\34\35\36\37\38\39\3a\3b\3c\3d"
+  )
+  "unknown memory 1"
+)
+
+;; Data segment with memory index 1 and specially crafted vec(byte) after.
+;; This is to detect incorrect validation where memory index is interpreted
+;; as a flag followed by "\41" interpreted as the size of vec(byte)
+;; with the expected number of bytes following.
+(assert_invalid
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0b\45\01"                             ;; data section
+    "\02"                                   ;; active segment
+    "\01"                                   ;; memory index
+    "\41\00\0b"                             ;; offset constant expression
+    "\3e"                                   ;; vec(byte) length
+    "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f"
+    "\10\11\12\13\14\15\16\17\18\19\1a\1b\1c\1d\1e\1f"
+    "\20\21\22\23\24\25\26\27\28\29\2a\2b\2c\2d\2e\2f"
+    "\30\31\32\33\34\35\36\37\38\39\3a\3b\3c\3d"
+  )
+  "unknown memory 1"
+)
+
+
+;; Invalid offsets
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (i64.const 0))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (ref.null func))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module 
+    (memory 1)
+    (data (offset (;empty instruction sequence;)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (offset (i32.const 0) (i32.const 0)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (global (import "test" "global-i32") i32)
+    (memory 1)
+    (data (offset (global.get 0) (global.get 0)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (global (import "test" "global-i32") i32)
+    (memory 1)
+    (data (offset (global.get 0) (i32.const 0)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (i32.ctz (i32.const 0)))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (nop))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (offset (nop) (i32.const 0)))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (offset (i32.const 0) (nop)))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (global $g (import "test" "g") (mut i32))
+    (memory 1)
+    (data (global.get $g))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+   (module 
+     (memory 1)
+     (data (global.get 0))
+   )
+   "unknown global 0"
+)
+
+(assert_invalid
+   (module
+     (global (import "test" "global-i32") i32)
+     (memory 1)
+     (data (global.get 1))
+   )
+   "unknown global 1"
+)
+
+(assert_invalid
+   (module 
+     (global (import "test" "global-mut-i32") (mut i32))
+     (memory 1)
+     (data (global.get 0))
+   )
+   "constant expression required"
+)
diff --git a/tests/wast/spec/proposals/gc/elem.wast b/tests/wast/spec/proposals/gc/elem.wast
new file mode 100644
index 0000000000..bc1cc32407
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/elem.wast
@@ -0,0 +1,1061 @@
+;; Test the element section
+
+;; Syntax
+(module
+  (table $t 10 funcref)
+  (func $f)
+  (func $g)
+
+  ;; Passive
+  (elem funcref)
+  (elem funcref (ref.func $f) (item ref.func $f) (item (ref.null func)) (ref.func $g))
+  (elem func)
+  (elem func $f $f $g $g)
+
+  (elem $p1 funcref)
+  (elem $p2 funcref (ref.func $f) (ref.func $f) (ref.null func) (ref.func $g))
+  (elem $p3 func)
+  (elem $p4 func $f $f $g $g)
+
+  ;; Active
+  (elem (table $t) (i32.const 0) funcref)
+  (elem (table $t) (i32.const 0) funcref (ref.func $f) (ref.null func))
+  (elem (table $t) (i32.const 0) func)
+  (elem (table $t) (i32.const 0) func $f $g)
+  (elem (table $t) (offset (i32.const 0)) funcref)
+  (elem (table $t) (offset (i32.const 0)) func $f $g)
+  (elem (table 0) (i32.const 0) func)
+  (elem (table 0x0) (i32.const 0) func $f $f)
+  (elem (table 0x000) (offset (i32.const 0)) func)
+  (elem (table 0) (offset (i32.const 0)) func $f $f)
+  (elem (table $t) (i32.const 0) func)
+  (elem (table $t) (i32.const 0) func $f $f)
+  (elem (table $t) (offset (i32.const 0)) func)
+  (elem (table $t) (offset (i32.const 0)) func $f $f)
+  (elem (offset (i32.const 0)))
+  (elem (offset (i32.const 0)) funcref (ref.func $f) (ref.null func))
+  (elem (offset (i32.const 0)) func $f $f)
+  (elem (offset (i32.const 0)) $f $f)
+  (elem (i32.const 0))
+  (elem (i32.const 0) funcref (ref.func $f) (ref.null func))
+  (elem (i32.const 0) func $f $f)
+  (elem (i32.const 0) $f $f)
+  (elem (i32.const 0) funcref (item (ref.func $f)) (item (ref.null func)))
+
+  (elem $a1 (table $t) (i32.const 0) funcref)
+  (elem $a2 (table $t) (i32.const 0) funcref (ref.func $f) (ref.null func))
+  (elem $a3 (table $t) (i32.const 0) func)
+  (elem $a4 (table $t) (i32.const 0) func $f $g)
+  (elem $a9 (table $t) (offset (i32.const 0)) funcref)
+  (elem $a10 (table $t) (offset (i32.const 0)) func $f $g)
+  (elem $a11 (table 0) (i32.const 0) func)
+  (elem $a12 (table 0x0) (i32.const 0) func $f $f)
+  (elem $a13 (table 0x000) (offset (i32.const 0)) func)
+  (elem $a14 (table 0) (offset (i32.const 0)) func $f $f)
+  (elem $a15 (table $t) (i32.const 0) func)
+  (elem $a16 (table $t) (i32.const 0) func $f $f)
+  (elem $a17 (table $t) (offset (i32.const 0)) func)
+  (elem $a18 (table $t) (offset (i32.const 0)) func $f $f)
+  (elem $a19 (offset (i32.const 0)))
+  (elem $a20 (offset (i32.const 0)) funcref (ref.func $f) (ref.null func))
+  (elem $a21 (offset (i32.const 0)) func $f $f)
+  (elem $a22 (offset (i32.const 0)) $f $f)
+  (elem $a23 (i32.const 0))
+  (elem $a24 (i32.const 0) funcref (ref.func $f) (ref.null func))
+  (elem $a25 (i32.const 0) func $f $f)
+  (elem $a26 (i32.const 0) $f $f)
+
+  ;; Declarative
+  (elem declare funcref)
+  (elem declare funcref (ref.func $f) (ref.func $f) (ref.null func) (ref.func $g))
+  (elem declare func)
+  (elem declare func $f $f $g $g)
+
+  (elem $d1 declare funcref)
+  (elem $d2 declare funcref (ref.func $f) (ref.func $f) (ref.null func) (ref.func $g))
+  (elem $d3 declare func)
+  (elem $d4 declare func $f $f $g $g)
+)
+
+(module
+  (func $f)
+  (func $g)
+
+  (table $t funcref (elem (ref.func $f) (ref.null func) (ref.func $g)))
+)
+
+(module
+  (func $f)
+  (func $g)
+
+  (table $t 10 (ref func) (ref.func $f))
+  (elem (i32.const 3) $g)
+)
+
+
+;; Basic use
+
+(module
+  (table 10 funcref)
+  (func $f)
+  (elem (i32.const 0) $f)
+)
+(module
+  (import "spectest" "table" (table 10 funcref))
+  (func $f)
+  (elem (i32.const 0) $f)
+)
+
+(module
+  (table 10 funcref)
+  (func $f)
+  (elem (i32.const 0) $f)
+  (elem (i32.const 3) $f)
+  (elem (i32.const 7) $f)
+  (elem (i32.const 5) $f)
+  (elem (i32.const 3) $f)
+)
+(module
+  (import "spectest" "table" (table 10 funcref))
+  (func $f)
+  (elem (i32.const 9) $f)
+  (elem (i32.const 3) $f)
+  (elem (i32.const 7) $f)
+  (elem (i32.const 3) $f)
+  (elem (i32.const 5) $f)
+)
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (table 1000 funcref)
+  (func $f)
+  (elem (global.get 0) $f)
+)
+
+(module
+  (global $g (import "spectest" "global_i32") i32)
+  (table 1000 funcref)
+  (func $f)
+  (elem (global.get $g) $f)
+)
+
+(module
+  (type $out-i32 (func (result i32)))
+  (table 10 funcref)
+  (elem (i32.const 7) $const-i32-a)
+  (elem (i32.const 9) $const-i32-b)
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-7") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 7))
+  )
+  (func (export "call-9") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 9))
+  )
+)
+(assert_return (invoke "call-7") (i32.const 65))
+(assert_return (invoke "call-9") (i32.const 66))
+
+;; Same as the above, but use ref.null to ensure the elements use exprs.
+;; Note: some tools like wast2json avoid using exprs when possible.
+(module
+  (type $out-i32 (func (result i32)))
+  (table 11 funcref)
+  (elem (i32.const 6) funcref (ref.null func) (ref.func $const-i32-a))
+  (elem (i32.const 9) funcref (ref.func $const-i32-b) (ref.null func))
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-7") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 7))
+  )
+  (func (export "call-9") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 9))
+  )
+)
+(assert_return (invoke "call-7") (i32.const 65))
+(assert_return (invoke "call-9") (i32.const 66))
+
+(module
+  (global i32 (i32.const 0))
+  (table 1 funcref) (elem (global.get 0) $f) (func $f)
+)
+(module
+  (global $g i32 (i32.const 0))
+  (table 1 funcref) (elem (global.get $g) $f) (func $f)
+)
+
+
+;; Corner cases
+
+(module
+  (table 10 funcref)
+  (func $f)
+  (elem (i32.const 9) $f)
+)
+(module
+  (import "spectest" "table" (table 10 funcref))
+  (func $f)
+  (elem (i32.const 9) $f)
+)
+
+(module
+  (table 0 funcref)
+  (elem (i32.const 0))
+)
+(module
+  (import "spectest" "table" (table 0 funcref))
+  (elem (i32.const 0))
+)
+
+(module
+  (table 0 0 funcref)
+  (elem (i32.const 0))
+)
+
+(module
+  (table 20 funcref)
+  (elem (i32.const 20))
+)
+
+(module
+  (import "spectest" "table" (table 0 funcref))
+  (func $f)
+  (elem (i32.const 0) $f)
+)
+
+(module
+  (import "spectest" "table" (table 0 100 funcref))
+  (func $f)
+  (elem (i32.const 0) $f)
+)
+
+(module
+  (import "spectest" "table" (table 0 funcref))
+  (func $f)
+  (elem (i32.const 1) $f)
+)
+
+(module
+  (import "spectest" "table" (table 0 30 funcref))
+  (func $f)
+  (elem (i32.const 1) $f)
+)
+
+
+;; Binary format variations
+
+(module
+  (func)
+  (table 1 funcref)
+  (elem (i32.const 0) func 0)
+)
+(module binary
+  "\00asm" "\01\00\00\00"    ;; Magic
+  "\01\04\01\60\00\00"       ;; Type section: 1 type
+  "\03\02\01\00"             ;; Function section: 1 function
+  "\04\04\01"                ;; Table section: 1 table
+    "\70\00\01"              ;; Table 0: [1..] funcref
+  "\09\07\01"                ;; Elem section: 1 element segment
+    "\00\41\00\0b\01\00"     ;; Segment 0: (i32.const 0) func 0
+  "\0a\04\01"                ;; Code section: 1 function
+    "\02\00\0b"              ;; Function 0: empty
+)
+
+(module
+  (func)
+  (table 1 funcref)
+  (elem func 0)
+)
+(module binary
+  "\00asm" "\01\00\00\00"    ;; Magic
+  "\01\04\01\60\00\00"       ;; Type section: 1 type
+  "\03\02\01\00"             ;; Function section: 1 function
+  "\04\04\01"                ;; Table section: 1 table
+    "\70\00\01"              ;; Table 0: [1..] funcref
+  "\09\05\01"                ;; Elem section: 1 element segment
+    "\01\00\01\00"           ;; Segment 0: func 0
+  "\0a\04\01"                ;; Code section: 1 function
+    "\02\00\0b"              ;; Function 0: empty
+)
+
+(module
+  (func)
+  (table 1 funcref)
+  (elem (table 0) (i32.const 0) func 0)
+)
+(module binary
+  "\00asm" "\01\00\00\00"    ;; Magic
+  "\01\04\01\60\00\00"       ;; Type section: 1 type
+  "\03\02\01\00"             ;; Function section: 1 function
+  "\04\04\01"                ;; Table section: 1 table
+    "\70\00\01"              ;; Table 0: [1..] funcref
+  "\09\09\01"                ;; Elem section: 1 element segment
+    "\02\00\41\00\0b\00\01\00"  ;; Segment 0: (table 0) (i32.const 0) func 0
+  "\0a\04\01"                ;; Code section: 1 function
+    "\02\00\0b"              ;; Function 0: empty
+)
+
+(module
+  (func)
+  (table 1 funcref)
+  (elem declare func 0)
+)
+(module binary
+  "\00asm" "\01\00\00\00"    ;; Magic
+  "\01\04\01\60\00\00"       ;; Type section: 1 type
+  "\03\02\01\00"             ;; Function section: 1 function
+  "\04\04\01"                ;; Table section: 1 table
+    "\70\00\01"              ;; Table 0: [1..] funcref
+  "\09\05\01"                ;; Elem section: 1 element segment
+    "\03\00\01\00"           ;; Segment 0: declare func 0
+  "\0a\04\01"                ;; Code section: 1 function
+    "\02\00\0b"              ;; Function 0: empty
+)
+
+(module
+  (func)
+  (table 1 funcref)
+  (elem (i32.const 0) (;;)(ref func) (ref.func 0))
+)
+(module binary
+  "\00asm" "\01\00\00\00"    ;; Magic
+  "\01\04\01\60\00\00"       ;; Type section: 1 type
+  "\03\02\01\00"             ;; Function section: 1 function
+  "\04\04\01"                ;; Table section: 1 table
+    "\70\00\01"              ;; Table 0: [1..] funcref
+  "\09\09\01"                ;; Elem section: 1 element segment
+    "\04\41\00\0b\01\d2\00\0b"  ;; Segment 0: (i32.const 0) (ref.func 0)
+  "\0a\04\01"                ;; Code section: 1 function
+    "\02\00\0b"              ;; Function 0: empty
+)
+(module
+  (func)
+  (table 1 funcref)
+  (elem (i32.const 0) funcref (ref.null func))
+)
+(module binary
+  "\00asm" "\01\00\00\00"    ;; Magic
+  "\01\04\01\60\00\00"       ;; Type section: 1 type
+  "\03\02\01\00"             ;; Function section: 1 function
+  "\04\04\01"                ;; Table section: 1 table
+    "\70\00\01"              ;; Table 0: [1..] funcref
+  "\09\09\01"                ;; Elem section: 1 element segment
+    "\04\41\00\0b\01\d0\70\0b"  ;; Segment 0: (i32.const 0) (ref.null func)
+  "\0a\04\01"                ;; Code section: 1 function
+    "\02\00\0b"              ;; Function 0: empty
+)
+
+(module
+  (func)
+  (table 1 funcref)
+  (elem (i32.const 0) funcref (ref.func 0))
+)
+(module binary
+  "\00asm" "\01\00\00\00"    ;; Magic
+  "\01\04\01\60\00\00"       ;; Type section: 1 type
+  "\03\02\01\00"             ;; Function section: 1 function
+  "\04\04\01"                ;; Table section: 1 table
+    "\70\00\01"              ;; Table 0: [1..] funcref
+  "\09\07\01"                ;; Elem section: 1 element segment
+    "\05\70\01\d2\00\0b"     ;; Segment 0: funcref (ref.func 0)
+  "\0a\04\01"                ;; Code section: 1 function
+    "\02\00\0b"              ;; Function 0: empty
+)
+(module
+  (func)
+  (table 1 funcref)
+  (elem (i32.const 0) funcref (ref.null func))
+)
+(module binary
+  "\00asm" "\01\00\00\00"    ;; Magic
+  "\01\04\01\60\00\00"       ;; Type section: 1 type
+  "\03\02\01\00"             ;; Function section: 1 function
+  "\04\04\01"                ;; Table section: 1 table
+    "\70\00\01"              ;; Table 0: [1..] funcref
+  "\09\07\01"                ;; Elem section: 1 element segment
+    "\05\70\01\d0\70\0b"     ;; Segment 0: funcref (ref.null func)
+  "\0a\04\01"                ;; Code section: 1 function
+    "\02\00\0b"              ;; Function 0: empty
+)
+
+(module
+  (func)
+  (table 1 funcref)
+  (elem (table 0) (i32.const 0) funcref (ref.func 0))
+)
+(module binary
+  "\00asm" "\01\00\00\00"    ;; Magic
+  "\01\04\01\60\00\00"       ;; Type section: 1 type
+  "\03\02\01\00"             ;; Function section: 1 function
+  "\04\04\01"                ;; Table section: 1 table
+    "\70\00\01"              ;; Table 0: [1..] funcref
+  "\09\0b\01"                ;; Elem section: 1 element segment
+    "\06\00\41\00\0b\70\01\d2\00\0b"  ;; Segment 0: (table 0) (i32.const 0) funcref (ref.func 0)
+  "\0a\04\01"                ;; Code section: 1 function
+    "\02\00\0b"              ;; Function 0: empty
+)
+(module
+  (func)
+  (table 1 funcref)
+  (elem (table 0) (i32.const 0) funcref (ref.null func))
+)
+(module binary
+  "\00asm" "\01\00\00\00"    ;; Magic
+  "\01\04\01\60\00\00"       ;; Type section: 1 type
+  "\03\02\01\00"             ;; Function section: 1 function
+  "\04\04\01"                ;; Table section: 1 table
+    "\70\00\01"              ;; Table 0: [1..] funcref
+  "\09\0b\01"                ;; Elem section: 1 element segment
+    "\06\00\41\00\0b\70\01\d0\70\0b"  ;; Segment 0: (table 0) (i32.const 0) funcref (ref.null func)
+  "\0a\04\01"                ;; Code section: 1 function
+    "\02\00\0b"              ;; Function 0: empty
+)
+
+(module
+  (func)
+  (table 1 funcref)
+  (elem declare funcref (ref.func 0))
+)
+(module binary
+  "\00asm" "\01\00\00\00"    ;; Magic
+  "\01\04\01\60\00\00"       ;; Type section: 1 type
+  "\03\02\01\00"             ;; Function section: 1 function
+  "\04\04\01"                ;; Table section: 1 table
+    "\70\00\01"              ;; Table 0: [1..] funcref
+  "\09\07\01"                ;; Elem section: 1 element segment
+    "\07\70\01\d2\00\0b"     ;; Segment 0: declare funcref (ref.func 0)
+  "\0a\04\01"                ;; Code section: 1 function
+    "\02\00\0b"              ;; Function 0: empty
+)
+(module
+  (func)
+  (table 1 funcref)
+  (elem declare funcref (ref.null func))
+)
+(module binary
+  "\00asm" "\01\00\00\00"    ;; Magic
+  "\01\04\01\60\00\00"       ;; Type section: 1 type
+  "\03\02\01\00"             ;; Function section: 1 function
+  "\04\04\01"                ;; Table section: 1 table
+    "\70\00\01"              ;; Table 0: [1..] funcref
+  "\09\07\01"                ;; Elem section: 1 element segment
+    "\07\70\01\d0\70\0b"     ;; Segment 0: declare funcref (ref.null func)
+  "\0a\04\01"                ;; Code section: 1 function
+    "\02\00\0b"              ;; Function 0: empty
+)
+
+
+(module
+  (func)
+  (table 1 (ref func) (ref.func 0))
+  (elem (i32.const 0) func 0)
+)
+(module binary
+  "\00asm" "\01\00\00\00"    ;; Magic
+  "\01\04\01\60\00\00"       ;; Type section: 1 type
+  "\03\02\01\00"             ;; Function section: 1 function
+  "\04\0a\01"                ;; Table section: 1 table
+    "\40\00\64\70\00\01\d2\00\0b"  ;; Table 0: [1..] (ref func) (ref.func 0)
+  "\09\07\01"                ;; Elem section: 1 element segment
+    "\00\41\00\0b\01\00"     ;; Segment 0: (i32.const 0) func 0
+  "\0a\04\01"                ;; Code section: 1 function
+    "\02\00\0b"              ;; Function 0: empty
+)
+
+(module
+  (func)
+  (table 1 (ref func) (ref.func 0))
+  (elem func 0)
+)
+(module binary
+  "\00asm" "\01\00\00\00"    ;; Magic
+  "\01\04\01\60\00\00"       ;; Type section: 1 type
+  "\03\02\01\00"             ;; Function section: 1 function
+  "\04\0a\01"                ;; Table section: 1 table
+    "\40\00\64\70\00\01\d2\00\0b"  ;; Table 0: [1..] (ref func) (ref.func 0)
+  "\09\05\01"                ;; Elem section: 1 element segment
+    "\01\00\01\00"           ;; Segment 0: func 0
+  "\0a\04\01"                ;; Code section: 1 function
+    "\02\00\0b"              ;; Function 0: empty
+)
+
+(module
+  (func)
+  (table 1 (ref func) (ref.func 0))
+  (elem (table 0) (i32.const 0) func 0)
+)
+(module binary
+  "\00asm" "\01\00\00\00"    ;; Magic
+  "\01\04\01\60\00\00"       ;; Type section: 1 type
+  "\03\02\01\00"             ;; Function section: 1 function
+  "\04\0a\01"                ;; Table section: 1 table
+    "\40\00\64\70\00\01\d2\00\0b"  ;; Table 0: [1..] (ref func) (ref.func 0)
+  "\09\09\01"                ;; Elem section: 1 element segment
+    "\02\00\41\00\0b\00\01\00"  ;; Segment 0: (table 0) (i32.const 0) func 0
+  "\0a\04\01"                ;; Code section: 1 function
+    "\02\00\0b"              ;; Function 0: empty
+)
+
+(module
+  (func)
+  (table 1 (ref func) (ref.func 0))
+  (elem declare func 0)
+)
+(module binary
+  "\00asm" "\01\00\00\00"    ;; Magic
+  "\01\04\01\60\00\00"       ;; Type section: 1 type
+  "\03\02\01\00"             ;; Function section: 1 function
+  "\04\0a\01"                ;; Table section: 1 table
+    "\40\00\64\70\00\01\d2\00\0b"  ;; Table 0: [1..] (ref func) (ref.func 0)
+  "\09\05\01"                ;; Elem section: 1 element segment
+    "\03\00\01\00"           ;; Segment 0: declare func 0
+  "\0a\04\01"                ;; Code section: 1 function
+    "\02\00\0b"              ;; Function 0: empty
+)
+
+(assert_invalid
+  (module
+    (func)
+    (table 1 (ref func) (ref.func 0))
+    (elem (i32.const 0) funcref (ref.func 0))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module binary
+    "\00asm" "\01\00\00\00"    ;; Magic
+    "\01\04\01\60\00\00"       ;; Type section: 1 type
+    "\03\02\01\00"             ;; Function section: 1 function
+    "\04\0a\01"                ;; Table section: 1 table
+      "\40\00\64\70\00\01\d2\00\0b"  ;; Table 0: [1..] (ref func) (ref.func 0)
+    "\09\09\01"                ;; Elem section: 1 element segment
+      "\04\41\00\0b\01\d2\00\0b"  ;; Segment 0: (i32.const 0) (ref.func 0)
+    "\0a\04\01"                ;; Code section: 1 function
+      "\02\00\0b"              ;; Function 0: empty
+  )
+  "type mismatch"
+)
+
+(module
+  (func)
+  (table 1 (ref func) (ref.func 0))
+  (elem (ref func) (ref.func 0))
+)
+(module binary
+  "\00asm" "\01\00\00\00"    ;; Magic
+  "\01\04\01\60\00\00"       ;; Type section: 1 type
+  "\03\02\01\00"             ;; Function section: 1 function
+  "\04\0a\01"                ;; Table section: 1 table
+    "\40\00\64\70\00\01\d2\00\0b"  ;; Table 0: [1..] (ref func) (ref.func 0)
+  "\09\08\01"                ;; Elem section: 1 element segment
+    "\05\64\70\01\d2\00\0b"  ;; Segment 0: (ref func) (ref.func 0)
+  "\0a\04\01"                ;; Code section: 1 function
+    "\02\00\0b"              ;; Function 0: empty
+)
+
+(module
+  (func)
+  (table 1 (ref func) (ref.func 0))
+  (elem (table 0) (i32.const 0) (ref func) (ref.func 0))
+)
+(module binary
+  "\00asm" "\01\00\00\00"    ;; Magic
+  "\01\04\01\60\00\00"       ;; Type section: 1 type
+  "\03\02\01\00"             ;; Function section: 1 function
+  "\04\0a\01"                ;; Table section: 1 table
+    "\40\00\64\70\00\01\d2\00\0b"  ;; Table 0: [1..] (ref func) (ref.func 0)
+  "\09\0c\01"                ;; Elem section: 1 element segment
+    "\06\00\41\00\0b\64\70\01\d2\00\0b"  ;; Segment 0: (table 0) (i32.const 0) (ref func) (ref.func 0)
+  "\0a\04\01"                ;; Code section: 1 function
+    "\02\00\0b"              ;; Function 0: empty
+)
+
+(module
+  (func)
+  (table 1 (ref func) (ref.func 0))
+  (elem declare (ref func) (ref.func 0))
+)
+(module binary
+  "\00asm" "\01\00\00\00"    ;; Magic
+  "\01\04\01\60\00\00"       ;; Type section: 1 type
+  "\03\02\01\00"             ;; Function section: 1 function
+  "\04\0a\01"                ;; Table section: 1 table
+    "\40\00\64\70\00\01\d2\00\0b"  ;; Table 0: [1..] (ref func) (ref.func 0)
+  "\09\08\01"                ;; Elem section: 1 element segment
+    "\07\64\70\01\d2\00\0b"  ;; Segment 0: declare (ref func) (ref.func 0)
+  "\0a\04\01"                ;; Code section: 1 function
+    "\02\00\0b"              ;; Function 0: empty
+)
+
+
+;; Invalid bounds for elements
+
+(assert_trap
+  (module
+    (table 0 funcref)
+    (func $f)
+    (elem (i32.const 0) $f)
+  )
+  "out of bounds table access"
+)
+
+(assert_trap
+  (module
+    (table 0 0 funcref)
+    (func $f)
+    (elem (i32.const 0) $f)
+  )
+  "out of bounds table access"
+)
+
+(assert_trap
+  (module
+    (table 0 1 funcref)
+    (func $f)
+    (elem (i32.const 0) $f)
+  )
+  "out of bounds table access"
+)
+
+(assert_trap
+  (module
+    (table 0 funcref)
+    (elem (i32.const 1))
+  )
+  "out of bounds table access"
+)
+(assert_trap
+  (module
+    (table 10 funcref)
+    (func $f)
+    (elem (i32.const 10) $f)
+  )
+  "out of bounds table access"
+)
+(assert_trap
+  (module
+    (import "spectest" "table" (table 10 funcref))
+    (func $f)
+    (elem (i32.const 10) $f)
+  )
+  "out of bounds table access"
+)
+
+(assert_trap
+  (module
+    (table 10 20 funcref)
+    (func $f)
+    (elem (i32.const 10) $f)
+  )
+  "out of bounds table access"
+)
+(assert_trap
+  (module
+    (import "spectest" "table" (table 10 funcref))
+    (func $f)
+    (elem (i32.const 10) $f)
+  )
+  "out of bounds table access"
+)
+
+(assert_trap
+  (module
+    (table 10 funcref)
+    (func $f)
+    (elem (i32.const -1) $f)
+  )
+  "out of bounds table access"
+)
+(assert_trap
+  (module
+    (import "spectest" "table" (table 10 funcref))
+    (func $f)
+    (elem (i32.const -1) $f)
+  )
+  "out of bounds table access"
+)
+
+(assert_trap
+  (module
+    (table 10 funcref)
+    (func $f)
+    (elem (i32.const -10) $f)
+  )
+  "out of bounds table access"
+)
+(assert_trap
+  (module
+    (import "spectest" "table" (table 10 funcref))
+    (func $f)
+    (elem (i32.const -10) $f)
+  )
+  "out of bounds table access"
+)
+
+
+;; Implicitly dropped elements
+
+(module
+  (table 10 funcref)
+  (elem $e (i32.const 0) func $f)
+  (func $f)
+  (func (export "init")
+    (table.init $e (i32.const 0) (i32.const 0) (i32.const 1))
+  )
+)
+(assert_trap (invoke "init") "out of bounds table access")
+
+(module
+  (table 10 funcref)
+  (elem $e declare func $f)
+  (func $f)
+  (func (export "init")
+    (table.init $e (i32.const 0) (i32.const 0) (i32.const 1))
+  )
+)
+(assert_trap (invoke "init") "out of bounds table access")
+
+
+;; Element without table
+
+(assert_invalid
+  (module
+    (func $f)
+    (elem (i32.const 0) $f)
+  )
+  "unknown table"
+)
+
+
+;; Invalid offsets
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i64.const 0))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (ref.null func))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module 
+    (table 1 funcref)
+    (elem (offset (;empty instruction sequence;)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (offset (i32.const 0) (i32.const 0)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (global (import "test" "global-i32") i32)
+    (table 1 funcref)
+    (elem (offset (global.get 0) (global.get 0)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (global (import "test" "global-i32") i32)
+    (table 1 funcref)
+    (elem (offset (global.get 0) (i32.const 0)))
+  )
+  "type mismatch"
+)
+
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i32.ctz (i32.const 0)))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (nop))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (offset (nop) (i32.const 0)))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (offset (i32.const 0) (nop)))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (global $g (import "test" "g") (mut i32))
+    (table 1 funcref)
+    (elem (global.get $g))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+   (module 
+     (table 1 funcref)
+     (elem (global.get 0))
+   )
+   "unknown global 0"
+)
+
+(assert_invalid
+   (module
+     (global (import "test" "global-i32") i32)
+     (table 1 funcref)
+     (elem (global.get 1))
+   )
+   "unknown global 1"
+)
+
+(assert_invalid
+   (module 
+     (global (import "test" "global-mut-i32") (mut i32))
+     (table 1 funcref)
+     (elem (global.get 0))
+   )
+   "constant expression required"
+)
+
+
+;; Invalid elements
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i32.const 0) funcref (ref.null extern))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i32.const 0) funcref (item (ref.null func) (ref.null func)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i32.const 0) funcref (i32.const 0))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i32.const 0) funcref (item (i32.const 0)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i32.const 0) funcref (item (call $f)))
+    (func $f (result funcref) (ref.null func))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i32.const 0) funcref (item (i32.add (i32.const 0) (i32.const 1))))
+  )
+  "constant expression required"
+)
+
+
+;; Two elements target the same slot
+
+(module
+  (type $out-i32 (func (result i32)))
+  (table 10 funcref)
+  (elem (i32.const 9) $const-i32-a)
+  (elem (i32.const 9) $const-i32-b)
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-overwritten") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 9))
+  )
+)
+(assert_return (invoke "call-overwritten") (i32.const 66))
+
+(module
+  (type $out-i32 (func (result i32)))
+  (import "spectest" "table" (table 10 funcref))
+  (elem (i32.const 9) $const-i32-a)
+  (elem (i32.const 9) $const-i32-b)
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-overwritten-element") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 9))
+  )
+)
+(assert_return (invoke "call-overwritten-element") (i32.const 66))
+
+
+;; Element sections across multiple modules change the same table
+
+(module $module1
+  (type $out-i32 (func (result i32)))
+  (table (export "shared-table") 10 funcref)
+  (elem (i32.const 8) $const-i32-a)
+  (elem (i32.const 9) $const-i32-b)
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-7") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 7))
+  )
+  (func (export "call-8") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 8))
+  )
+  (func (export "call-9") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 9))
+  )
+)
+
+(register "module1" $module1)
+
+(assert_trap (invoke $module1 "call-7") "uninitialized element")
+(assert_return (invoke $module1 "call-8") (i32.const 65))
+(assert_return (invoke $module1 "call-9") (i32.const 66))
+
+(module $module2
+  (type $out-i32 (func (result i32)))
+  (import "module1" "shared-table" (table 10 funcref))
+  (elem (i32.const 7) $const-i32-c)
+  (elem (i32.const 8) $const-i32-d)
+  (func $const-i32-c (type $out-i32) (i32.const 67))
+  (func $const-i32-d (type $out-i32) (i32.const 68))
+)
+
+(assert_return (invoke $module1 "call-7") (i32.const 67))
+(assert_return (invoke $module1 "call-8") (i32.const 68))
+(assert_return (invoke $module1 "call-9") (i32.const 66))
+
+(module $module3
+  (type $out-i32 (func (result i32)))
+  (import "module1" "shared-table" (table 10 funcref))
+  (elem (i32.const 8) $const-i32-e)
+  (elem (i32.const 9) $const-i32-f)
+  (func $const-i32-e (type $out-i32) (i32.const 69))
+  (func $const-i32-f (type $out-i32) (i32.const 70))
+)
+
+(assert_return (invoke $module1 "call-7") (i32.const 67))
+(assert_return (invoke $module1 "call-8") (i32.const 69))
+(assert_return (invoke $module1 "call-9") (i32.const 70))
+
+;; Element segments must match element type of table
+
+(assert_invalid
+  (module (func $f) (table 1 externref) (elem (i32.const 0) $f))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (table 1 funcref) (elem (i32.const 0) externref (ref.null extern)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $f)
+    (table $t 1 externref)
+    (elem $e funcref (ref.func $f))
+    (func (table.init $t $e (i32.const 0) (i32.const 0) (i32.const 1))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table $t 1 funcref)
+    (elem $e externref (ref.null extern))
+    (func (table.init $t $e (i32.const 0) (i32.const 0) (i32.const 1))))
+  "type mismatch"
+)
+
+;; Initializing a table with an externref-type element segment
+
+(module $m
+  (table $t (export "table") 2 externref)
+  (func (export "get") (param $i i32) (result externref)
+        (table.get $t (local.get $i)))
+  (func (export "set") (param $i i32) (param $x externref)
+        (table.set $t (local.get $i) (local.get $x))))
+
+(register "exporter" $m)
+
+(assert_return (invoke $m "get" (i32.const 0)) (ref.null extern))
+(assert_return (invoke $m "get" (i32.const 1)) (ref.null extern))
+
+(assert_return (invoke $m "set" (i32.const 0) (ref.extern 42)))
+(assert_return (invoke $m "set" (i32.const 1) (ref.extern 137)))
+
+(assert_return (invoke $m "get" (i32.const 0)) (ref.extern 42))
+(assert_return (invoke $m "get" (i32.const 1)) (ref.extern 137))
+
+(module
+  (import "exporter" "table" (table $t 2 externref))
+  (elem (i32.const 0) externref (ref.null extern)))
+
+(assert_return (invoke $m "get" (i32.const 0)) (ref.null extern))
+(assert_return (invoke $m "get" (i32.const 1)) (ref.extern 137))
+
+;; Initializing a table with imported funcref global
+
+(module $module4
+  (func (result i32)
+    i32.const 42
+  )
+  (global (export "f") funcref (ref.func 0))
+)
+
+(register "module4" $module4)
+
+(module
+  (import "module4" "f" (global funcref))
+  (type $out-i32 (func (result i32)))
+  (table 10 funcref)
+  (elem (offset (i32.const 0)) funcref (global.get 0))
+  (func (export "call_imported_elem") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 0))
+  )
+)
+
+(assert_return (invoke "call_imported_elem") (i32.const 42))
diff --git a/tests/wast/spec/proposals/gc/extern.wast b/tests/wast/spec/proposals/gc/extern.wast
new file mode 100644
index 0000000000..abf31669eb
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/extern.wast
@@ -0,0 +1,54 @@
+(module
+  (type $ft (func))
+  (type $st (struct))
+  (type $at (array i8))
+
+  (table 10 anyref)
+
+  (elem declare func $f)
+  (func $f)
+
+  (func (export "init") (param $x externref)
+    (table.set (i32.const 0) (ref.null any))
+    (table.set (i32.const 1) (ref.i31 (i32.const 7)))
+    (table.set (i32.const 2) (struct.new_default $st))
+    (table.set (i32.const 3) (array.new_default $at (i32.const 0)))
+    (table.set (i32.const 4) (any.convert_extern (local.get $x)))
+  )
+
+  (func (export "internalize") (param externref) (result anyref)
+    (any.convert_extern (local.get 0))
+  )
+  (func (export "externalize") (param anyref) (result externref)
+    (extern.convert_any (local.get 0))
+  )
+
+  (func (export "externalize-i") (param i32) (result externref)
+    (extern.convert_any (table.get (local.get 0)))
+  )
+  (func (export "externalize-ii") (param i32) (result anyref)
+    (any.convert_extern (extern.convert_any (table.get (local.get 0))))
+  )
+)
+
+(invoke "init" (ref.extern 0))
+
+(assert_return (invoke "internalize" (ref.extern 1)) (ref.host 1))
+(assert_return (invoke "internalize" (ref.null extern)) (ref.null any))
+
+(assert_return (invoke "externalize" (ref.host 2)) (ref.extern 2))
+(assert_return (invoke "externalize" (ref.null any)) (ref.null extern))
+
+(assert_return (invoke "externalize-i" (i32.const 0)) (ref.null extern))
+(assert_return (invoke "externalize-i" (i32.const 1)) (ref.extern))
+(assert_return (invoke "externalize-i" (i32.const 2)) (ref.extern))
+(assert_return (invoke "externalize-i" (i32.const 3)) (ref.extern))
+(assert_return (invoke "externalize-i" (i32.const 4)) (ref.extern))
+(assert_return (invoke "externalize-i" (i32.const 5)) (ref.null extern))
+
+(assert_return (invoke "externalize-ii" (i32.const 0)) (ref.null any))
+(assert_return (invoke "externalize-ii" (i32.const 1)) (ref.i31))
+(assert_return (invoke "externalize-ii" (i32.const 2)) (ref.struct))
+(assert_return (invoke "externalize-ii" (i32.const 3)) (ref.array))
+(assert_return (invoke "externalize-ii" (i32.const 4)) (ref.host 0))
+(assert_return (invoke "externalize-ii" (i32.const 5)) (ref.null any))
diff --git a/tests/wast/spec/proposals/gc/float_exprs.wast b/tests/wast/spec/proposals/gc/float_exprs.wast
new file mode 100644
index 0000000000..1f88299212
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/float_exprs.wast
@@ -0,0 +1,2570 @@
+;; Test interesting floating-point "expressions". These tests contain code
+;; patterns which tempt common value-changing optimizations.
+
+;; Test that x*y+z is not done with x87-style intermediate precision.
+
+(module
+  (func (export "f64.no_contraction") (param $x f64) (param $y f64) (param $z f64) (result f64)
+    (f64.add (f64.mul (local.get $x) (local.get $y)) (local.get $z)))
+)
+
+(assert_return (invoke "f64.no_contraction" (f64.const -0x1.9e87ce14273afp-103) (f64.const 0x1.2515ad31db63ep+664) (f64.const 0x1.868c6685e6185p+533)) (f64.const -0x1.da94885b11493p+561))
+(assert_return (invoke "f64.no_contraction" (f64.const 0x1.da21c460a6f44p+52) (f64.const 0x1.60859d2e7714ap-321) (f64.const 0x1.e63f1b7b660e1p-302)) (f64.const 0x1.4672f256d1794p-268))
+(assert_return (invoke "f64.no_contraction" (f64.const -0x1.f3eaf43f327cp-594) (f64.const 0x1.dfcc009906b57p+533) (f64.const 0x1.5984e03c520a1p-104)) (f64.const -0x1.d4797fb3db166p-60))
+(assert_return (invoke "f64.no_contraction" (f64.const 0x1.dab6c772cb2e2p-69) (f64.const -0x1.d761663679a84p-101) (f64.const 0x1.f22f92c843226p-218)) (f64.const -0x1.b50d72dfcef68p-169))
+(assert_return (invoke "f64.no_contraction" (f64.const -0x1.87c5def1e4d3dp-950) (f64.const -0x1.50cd5dab2207fp+935) (f64.const 0x1.e629bd0da8c5dp-54)) (f64.const 0x1.01b6feb4e78a7p-14))
+
+;; Test that x*y+z is not folded to fma.
+
+(module
+  (func (export "f32.no_fma") (param $x f32) (param $y f32) (param $z f32) (result f32)
+    (f32.add (f32.mul (local.get $x) (local.get $y)) (local.get $z)))
+  (func (export "f64.no_fma") (param $x f64) (param $y f64) (param $z f64) (result f64)
+    (f64.add (f64.mul (local.get $x) (local.get $y)) (local.get $z)))
+)
+
+(assert_return (invoke "f32.no_fma" (f32.const 0x1.a78402p+124) (f32.const 0x1.cf8548p-23) (f32.const 0x1.992adap+107)) (f32.const 0x1.a5262cp+107))
+(assert_return (invoke "f32.no_fma" (f32.const 0x1.ed15a4p-28) (f32.const -0x1.613c72p-50) (f32.const 0x1.4757bp-88)) (f32.const -0x1.5406b8p-77))
+(assert_return (invoke "f32.no_fma" (f32.const 0x1.ae63a2p+37) (f32.const 0x1.b3a59ap-13) (f32.const 0x1.c16918p+10)) (f32.const 0x1.6e385cp+25))
+(assert_return (invoke "f32.no_fma" (f32.const 0x1.2a77fap-8) (f32.const -0x1.bb7356p+22) (f32.const -0x1.32be2ap+1)) (f32.const -0x1.0286d4p+15))
+(assert_return (invoke "f32.no_fma" (f32.const 0x1.298fb6p+126) (f32.const -0x1.03080cp-70) (f32.const -0x1.418de6p+34)) (f32.const -0x1.2d15c6p+56))
+(assert_return (invoke "f64.no_fma" (f64.const 0x1.ac357ff46eed4p+557) (f64.const 0x1.852c01a5e7297p+430) (f64.const -0x1.05995704eda8ap+987)) (f64.const 0x1.855d905d338ep+987))
+(assert_return (invoke "f64.no_fma" (f64.const 0x1.e2fd6bf32010cp+749) (f64.const 0x1.01c2238d405e4p-130) (f64.const 0x1.2ecc0db4b9f94p+573)) (f64.const 0x1.e64eb07e063bcp+619))
+(assert_return (invoke "f64.no_fma" (f64.const 0x1.92b7c7439ede3p-721) (f64.const -0x1.6aa97586d3de6p+1011) (f64.const 0x1.8de4823f6358ap+237)) (f64.const -0x1.1d4139fd20ecdp+291))
+(assert_return (invoke "f64.no_fma" (f64.const -0x1.466d30bddb453p-386) (f64.const -0x1.185a4d739c7aap+443) (f64.const 0x1.5f9c436fbfc7bp+55)) (f64.const 0x1.bd61a350fcc1ap+57))
+(assert_return (invoke "f64.no_fma" (f64.const 0x1.7e2c44058a799p+52) (f64.const 0x1.c73b71765b8b2p+685) (f64.const -0x1.16c641df0b108p+690)) (f64.const 0x1.53ccb53de0bd1p+738))
+
+;; Test that x+0.0 is not folded to x.
+;; See IEEE 754-2008 10.4 "Literal meaning and value-changing optimizations".
+
+(module
+  (func (export "f32.no_fold_add_zero") (param $x f32) (result f32)
+    (f32.add (local.get $x) (f32.const 0.0)))
+  (func (export "f64.no_fold_add_zero") (param $x f64) (result f64)
+    (f64.add (local.get $x) (f64.const 0.0)))
+)
+
+(assert_return (invoke "f32.no_fold_add_zero" (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f64.no_fold_add_zero" (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f32.no_fold_add_zero" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_add_zero" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that 0.0 - x is not folded to -x.
+
+(module
+  (func (export "f32.no_fold_zero_sub") (param $x f32) (result f32)
+    (f32.sub (f32.const 0.0) (local.get $x)))
+  (func (export "f64.no_fold_zero_sub") (param $x f64) (result f64)
+    (f64.sub (f64.const 0.0) (local.get $x)))
+)
+
+(assert_return (invoke "f32.no_fold_zero_sub" (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f64.no_fold_zero_sub" (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f32.no_fold_zero_sub" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_zero_sub" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that x - 0.0 is not folded to x.
+
+(module
+  (func (export "f32.no_fold_sub_zero") (param $x f32) (result f32)
+    (f32.sub (local.get $x) (f32.const 0.0)))
+  (func (export "f64.no_fold_sub_zero") (param $x f64) (result f64)
+    (f64.sub (local.get $x) (f64.const 0.0)))
+)
+
+(assert_return (invoke "f32.no_fold_sub_zero" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_sub_zero" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that x*0.0 is not folded to 0.0.
+
+(module
+  (func (export "f32.no_fold_mul_zero") (param $x f32) (result f32)
+    (f32.mul (local.get $x) (f32.const 0.0)))
+  (func (export "f64.no_fold_mul_zero") (param $x f64) (result f64)
+    (f64.mul (local.get $x) (f64.const 0.0)))
+)
+
+(assert_return (invoke "f32.no_fold_mul_zero" (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_mul_zero" (f32.const -1.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_mul_zero" (f32.const -2.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_mul_zero" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_mul_zero" (f64.const -0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_mul_zero" (f64.const -1.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_mul_zero" (f64.const -2.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_mul_zero" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that x*1.0 is not folded to x.
+;; See IEEE 754-2008 10.4 "Literal meaning and value-changing optimizations".
+
+(module
+  (func (export "f32.no_fold_mul_one") (param $x f32) (result f32)
+    (f32.mul (local.get $x) (f32.const 1.0)))
+  (func (export "f64.no_fold_mul_one") (param $x f64) (result f64)
+    (f64.mul (local.get $x) (f64.const 1.0)))
+)
+
+(assert_return (invoke "f32.no_fold_mul_one" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_mul_one" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that 0.0/x is not folded to 0.0.
+
+(module
+  (func (export "f32.no_fold_zero_div") (param $x f32) (result f32)
+    (f32.div (f32.const 0.0) (local.get $x)))
+  (func (export "f64.no_fold_zero_div") (param $x f64) (result f64)
+    (f64.div (f64.const 0.0) (local.get $x)))
+)
+
+(assert_return (invoke "f32.no_fold_zero_div" (f32.const 0.0)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_zero_div" (f32.const -0.0)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_zero_div" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_zero_div" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_zero_div" (f64.const 0.0)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_zero_div" (f64.const -0.0)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_zero_div" (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_zero_div" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that x/1.0 is not folded to x.
+
+(module
+  (func (export "f32.no_fold_div_one") (param $x f32) (result f32)
+    (f32.div (local.get $x) (f32.const 1.0)))
+  (func (export "f64.no_fold_div_one") (param $x f64) (result f64)
+    (f64.div (local.get $x) (f64.const 1.0)))
+)
+
+(assert_return (invoke "f32.no_fold_div_one" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_div_one" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that x/-1.0 is not folded to -x.
+
+(module
+  (func (export "f32.no_fold_div_neg1") (param $x f32) (result f32)
+    (f32.div (local.get $x) (f32.const -1.0)))
+  (func (export "f64.no_fold_div_neg1") (param $x f64) (result f64)
+    (f64.div (local.get $x) (f64.const -1.0)))
+)
+
+(assert_return (invoke "f32.no_fold_div_neg1" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_div_neg1" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that -0.0 - x is not folded to -x.
+
+(module
+  (func (export "f32.no_fold_neg0_sub") (param $x f32) (result f32)
+    (f32.sub (f32.const -0.0) (local.get $x)))
+  (func (export "f64.no_fold_neg0_sub") (param $x f64) (result f64)
+    (f64.sub (f64.const -0.0) (local.get $x)))
+)
+
+(assert_return (invoke "f32.no_fold_neg0_sub" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_neg0_sub" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that -1.0 * x is not folded to -x.
+
+(module
+  (func (export "f32.no_fold_neg1_mul") (param $x f32) (result f32)
+    (f32.mul (f32.const -1.0) (local.get $x)))
+  (func (export "f64.no_fold_neg1_mul") (param $x f64) (result f64)
+    (f64.mul (f64.const -1.0) (local.get $x)))
+)
+
+(assert_return (invoke "f32.no_fold_neg1_mul" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_neg1_mul" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that x == x is not folded to true.
+
+(module
+  (func (export "f32.no_fold_eq_self") (param $x f32) (result i32)
+    (f32.eq (local.get $x) (local.get $x)))
+  (func (export "f64.no_fold_eq_self") (param $x f64) (result i32)
+    (f64.eq (local.get $x) (local.get $x)))
+)
+
+(assert_return (invoke "f32.no_fold_eq_self" (f32.const nan)) (i32.const 0))
+(assert_return (invoke "f64.no_fold_eq_self" (f64.const nan)) (i32.const 0))
+
+;; Test that x != x is not folded to false.
+
+(module
+  (func (export "f32.no_fold_ne_self") (param $x f32) (result i32)
+    (f32.ne (local.get $x) (local.get $x)))
+  (func (export "f64.no_fold_ne_self") (param $x f64) (result i32)
+    (f64.ne (local.get $x) (local.get $x)))
+)
+
+(assert_return (invoke "f32.no_fold_ne_self" (f32.const nan)) (i32.const 1))
+(assert_return (invoke "f64.no_fold_ne_self" (f64.const nan)) (i32.const 1))
+
+;; Test that x - x is not folded to 0.0.
+
+(module
+  (func (export "f32.no_fold_sub_self") (param $x f32) (result f32)
+    (f32.sub (local.get $x) (local.get $x)))
+  (func (export "f64.no_fold_sub_self") (param $x f64) (result f64)
+    (f64.sub (local.get $x) (local.get $x)))
+)
+
+(assert_return (invoke "f32.no_fold_sub_self" (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_sub_self" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "f64.no_fold_sub_self" (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_sub_self" (f64.const nan)) (f64.const nan:canonical))
+
+;; Test that x / x is not folded to 1.0.
+
+(module
+  (func (export "f32.no_fold_div_self") (param $x f32) (result f32)
+    (f32.div (local.get $x) (local.get $x)))
+  (func (export "f64.no_fold_div_self") (param $x f64) (result f64)
+    (f64.div (local.get $x) (local.get $x)))
+)
+
+(assert_return (invoke "f32.no_fold_div_self" (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_self" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_self" (f32.const 0.0)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_self" (f32.const -0.0)) (f32.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_self" (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_self" (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_self" (f64.const 0.0)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_self" (f64.const -0.0)) (f64.const nan:canonical))
+
+;; Test that x/3 is not folded to x*(1/3).
+
+(module
+  (func (export "f32.no_fold_div_3") (param $x f32) (result f32)
+    (f32.div (local.get $x) (f32.const 3.0)))
+  (func (export "f64.no_fold_div_3") (param $x f64) (result f64)
+    (f64.div (local.get $x) (f64.const 3.0)))
+)
+
+(assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.359c26p+50)) (f32.const -0x1.9cd032p+48))
+(assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.e45646p+93)) (f32.const -0x1.42e42ep+92))
+(assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.2a3916p-83)) (f32.const -0x1.8da172p-85))
+(assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.1f8b38p-124)) (f32.const -0x1.7f644ap-126))
+(assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.d64f64p-56)) (f32.const -0x1.398a42p-57))
+(assert_return (invoke "f64.no_fold_div_3" (f64.const -0x1.a8a88d29e2cc3p+632)) (f64.const -0x1.1b1b08c69732dp+631))
+(assert_return (invoke "f64.no_fold_div_3" (f64.const -0x1.bcf52dc950972p-167)) (f64.const -0x1.28a373db8b0f7p-168))
+(assert_return (invoke "f64.no_fold_div_3" (f64.const 0x1.bd3c0d989f7a4p-874)) (f64.const 0x1.28d2b3bb14fc3p-875))
+(assert_return (invoke "f64.no_fold_div_3" (f64.const -0x1.0138bf530a53cp+1007)) (f64.const -0x1.56f6546eb86fbp+1005))
+(assert_return (invoke "f64.no_fold_div_3" (f64.const 0x1.052b87f9d794dp+415)) (f64.const 0x1.5c3a0aa274c67p+413))
+
+;; Test that (x*z)+(y*z) is not folded to (x+y)*z.
+
+(module
+  (func (export "f32.no_factor") (param $x f32) (param $y f32) (param $z f32) (result f32)
+    (f32.add (f32.mul (local.get $x) (local.get $z)) (f32.mul (local.get $y) (local.get $z))))
+  (func (export "f64.no_factor") (param $x f64) (param $y f64) (param $z f64) (result f64)
+    (f64.add (f64.mul (local.get $x) (local.get $z)) (f64.mul (local.get $y) (local.get $z))))
+)
+
+(assert_return (invoke "f32.no_factor" (f32.const -0x1.4e2352p+40) (f32.const -0x1.842e2cp+49) (f32.const 0x1.eea602p+59)) (f32.const -0x1.77a7dp+109))
+(assert_return (invoke "f32.no_factor" (f32.const -0x1.b4e7f6p-6) (f32.const 0x1.8c990cp-5) (f32.const -0x1.70cc02p-9)) (f32.const -0x1.00a342p-14))
+(assert_return (invoke "f32.no_factor" (f32.const -0x1.06722ep-41) (f32.const 0x1.eed3cep-64) (f32.const 0x1.5c5558p+123)) (f32.const -0x1.651aaep+82))
+(assert_return (invoke "f32.no_factor" (f32.const -0x1.f8c6a4p-64) (f32.const 0x1.08c806p-83) (f32.const 0x1.b5ceccp+118)) (f32.const -0x1.afa15p+55))
+(assert_return (invoke "f32.no_factor" (f32.const -0x1.3aaa1ep-84) (f32.const 0x1.c6d5eep-71) (f32.const 0x1.8d2924p+20)) (f32.const 0x1.60c9cep-50))
+(assert_return (invoke "f64.no_factor" (f64.const 0x1.3adeda9144977p-424) (f64.const 0x1.c15af887049e1p-462) (f64.const -0x1.905179c4c4778p-225)) (f64.const -0x1.ec606bcb87b1ap-649))
+(assert_return (invoke "f64.no_factor" (f64.const 0x1.3c84821c1d348p-662) (f64.const -0x1.4ffd4c77ad037p-1009) (f64.const -0x1.dd275335c6f4p-957)) (f64.const 0x0p+0))
+(assert_return (invoke "f64.no_factor" (f64.const -0x1.074f372347051p-334) (f64.const -0x1.aaeef661f4c96p-282) (f64.const -0x1.9bd34abe8696dp+479)) (f64.const 0x1.5767029593e2p+198))
+(assert_return (invoke "f64.no_factor" (f64.const -0x1.c4ded58a6f389p-289) (f64.const 0x1.ba6fdef5d59c9p-260) (f64.const -0x1.c1201c0470205p-253)) (f64.const -0x1.841ada2e0f184p-512))
+(assert_return (invoke "f64.no_factor" (f64.const 0x1.9d3688f8e375ap-608) (f64.const 0x1.bf91311588256p-579) (f64.const -0x1.1605a6b5d5ff8p+489)) (f64.const -0x1.e6118ca76af53p-90))
+
+;; Test that (x+y)*z is not folded to (x*z)+(y*z).
+
+(module
+  (func (export "f32.no_distribute") (param $x f32) (param $y f32) (param $z f32) (result f32)
+    (f32.mul (f32.add (local.get $x) (local.get $y)) (local.get $z)))
+  (func (export "f64.no_distribute") (param $x f64) (param $y f64) (param $z f64) (result f64)
+    (f64.mul (f64.add (local.get $x) (local.get $y)) (local.get $z)))
+)
+
+(assert_return (invoke "f32.no_distribute" (f32.const -0x1.4e2352p+40) (f32.const -0x1.842e2cp+49) (f32.const 0x1.eea602p+59)) (f32.const -0x1.77a7d2p+109))
+(assert_return (invoke "f32.no_distribute" (f32.const -0x1.b4e7f6p-6) (f32.const 0x1.8c990cp-5) (f32.const -0x1.70cc02p-9)) (f32.const -0x1.00a34p-14))
+(assert_return (invoke "f32.no_distribute" (f32.const -0x1.06722ep-41) (f32.const 0x1.eed3cep-64) (f32.const 0x1.5c5558p+123)) (f32.const -0x1.651abp+82))
+(assert_return (invoke "f32.no_distribute" (f32.const -0x1.f8c6a4p-64) (f32.const 0x1.08c806p-83) (f32.const 0x1.b5ceccp+118)) (f32.const -0x1.afa14ep+55))
+(assert_return (invoke "f32.no_distribute" (f32.const -0x1.3aaa1ep-84) (f32.const 0x1.c6d5eep-71) (f32.const 0x1.8d2924p+20)) (f32.const 0x1.60c9ccp-50))
+(assert_return (invoke "f64.no_distribute" (f64.const 0x1.3adeda9144977p-424) (f64.const 0x1.c15af887049e1p-462) (f64.const -0x1.905179c4c4778p-225)) (f64.const -0x1.ec606bcb87b1bp-649))
+(assert_return (invoke "f64.no_distribute" (f64.const 0x1.3c84821c1d348p-662) (f64.const -0x1.4ffd4c77ad037p-1009) (f64.const -0x1.dd275335c6f4p-957)) (f64.const -0x0p+0))
+(assert_return (invoke "f64.no_distribute" (f64.const -0x1.074f372347051p-334) (f64.const -0x1.aaeef661f4c96p-282) (f64.const -0x1.9bd34abe8696dp+479)) (f64.const 0x1.5767029593e1fp+198))
+(assert_return (invoke "f64.no_distribute" (f64.const -0x1.c4ded58a6f389p-289) (f64.const 0x1.ba6fdef5d59c9p-260) (f64.const -0x1.c1201c0470205p-253)) (f64.const -0x1.841ada2e0f183p-512))
+(assert_return (invoke "f64.no_distribute" (f64.const 0x1.9d3688f8e375ap-608) (f64.const 0x1.bf91311588256p-579) (f64.const -0x1.1605a6b5d5ff8p+489)) (f64.const -0x1.e6118ca76af52p-90))
+
+;; Test that x*(y/z) is not folded to (x*y)/z.
+
+(module
+  (func (export "f32.no_regroup_div_mul") (param $x f32) (param $y f32) (param $z f32) (result f32)
+    (f32.mul (local.get $x) (f32.div (local.get $y) (local.get $z))))
+  (func (export "f64.no_regroup_div_mul") (param $x f64) (param $y f64) (param $z f64) (result f64)
+    (f64.mul (local.get $x) (f64.div (local.get $y) (local.get $z))))
+)
+
+(assert_return (invoke "f32.no_regroup_div_mul" (f32.const -0x1.2d14a6p-115) (f32.const -0x1.575a6cp-64) (f32.const 0x1.5cee0ep-116)) (f32.const 0x1.2844cap-63))
+(assert_return (invoke "f32.no_regroup_div_mul" (f32.const -0x1.454738p+91) (f32.const -0x1.b28a66p-115) (f32.const -0x1.f53908p+72)) (f32.const -0x0p+0))
+(assert_return (invoke "f32.no_regroup_div_mul" (f32.const -0x1.6be56ep+16) (f32.const -0x1.b46fc6p-21) (f32.const -0x1.a51df6p-123)) (f32.const -0x1.792258p+118))
+(assert_return (invoke "f32.no_regroup_div_mul" (f32.const -0x1.c343f8p-94) (f32.const 0x1.e4d906p+73) (f32.const 0x1.be69f8p+68)) (f32.const -0x1.ea1df2p-89))
+(assert_return (invoke "f32.no_regroup_div_mul" (f32.const 0x1.c6ae76p+112) (f32.const 0x1.fc953cp+24) (f32.const -0x1.60b3e8p+71)) (f32.const -0x1.47d0eap+66))
+(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.3c04b815e30bp-423) (f64.const -0x1.379646fd98127p-119) (f64.const 0x1.bddb158506031p-642)) (f64.const -0x1.b9b3301f2dd2dp+99))
+(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.46b3a402f86d5p+337) (f64.const 0x1.6fbf1b9e1798dp-447) (f64.const -0x1.bd9704a5a6a06p+797)) (f64.const -0x0p+0))
+(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.6c9765bb4347fp-479) (f64.const 0x1.a4af42e34a141p+902) (f64.const 0x1.d2dde70eb68f9p-448)) (f64.const inf))
+(assert_return (invoke "f64.no_regroup_div_mul" (f64.const -0x1.706023645be72p+480) (f64.const -0x1.6c229f7d9101dp+611) (f64.const -0x1.4d50fa68d3d9ep+836)) (f64.const -0x1.926fa3cacc651p+255))
+(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.8cc63d8caf4c7p-599) (f64.const 0x1.8671ac4c35753p-878) (f64.const -0x1.ef35b1695e659p-838)) (f64.const -0x1.38d55f56406dp-639))
+
+;; Test that (x*y)/z is not folded to x*(y/z).
+
+(module
+  (func (export "f32.no_regroup_mul_div") (param $x f32) (param $y f32) (param $z f32) (result f32)
+    (f32.div (f32.mul (local.get $x) (local.get $y)) (local.get $z)))
+  (func (export "f64.no_regroup_mul_div") (param $x f64) (param $y f64) (param $z f64) (result f64)
+    (f64.div (f64.mul (local.get $x) (local.get $y)) (local.get $z)))
+)
+
+(assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.2d14a6p-115) (f32.const -0x1.575a6cp-64) (f32.const 0x1.5cee0ep-116)) (f32.const 0x0p+0))
+(assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.454738p+91) (f32.const -0x1.b28a66p-115) (f32.const -0x1.f53908p+72)) (f32.const -0x1.1a00e8p-96))
+(assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.6be56ep+16) (f32.const -0x1.b46fc6p-21) (f32.const -0x1.a51df6p-123)) (f32.const -0x1.79225ap+118))
+(assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.c343f8p-94) (f32.const 0x1.e4d906p+73) (f32.const 0x1.be69f8p+68)) (f32.const -0x1.ea1df4p-89))
+(assert_return (invoke "f32.no_regroup_mul_div" (f32.const 0x1.c6ae76p+112) (f32.const 0x1.fc953cp+24) (f32.const -0x1.60b3e8p+71)) (f32.const -inf))
+(assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.3c04b815e30bp-423) (f64.const -0x1.379646fd98127p-119) (f64.const 0x1.bddb158506031p-642)) (f64.const -0x1.b9b3301f2dd2ep+99))
+(assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.46b3a402f86d5p+337) (f64.const 0x1.6fbf1b9e1798dp-447) (f64.const -0x1.bd9704a5a6a06p+797)) (f64.const -0x1.0da0b6328e09p-907))
+(assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.6c9765bb4347fp-479) (f64.const 0x1.a4af42e34a141p+902) (f64.const 0x1.d2dde70eb68f9p-448)) (f64.const 0x1.4886b6d9a9a79p+871))
+(assert_return (invoke "f64.no_regroup_mul_div" (f64.const -0x1.706023645be72p+480) (f64.const -0x1.6c229f7d9101dp+611) (f64.const -0x1.4d50fa68d3d9ep+836)) (f64.const -inf))
+(assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.8cc63d8caf4c7p-599) (f64.const 0x1.8671ac4c35753p-878) (f64.const -0x1.ef35b1695e659p-838)) (f64.const -0x0p+0))
+
+;; Test that x+y+z+w is not reassociated.
+
+(module
+  (func (export "f32.no_reassociate_add") (param $x f32) (param $y f32) (param $z f32) (param $w f32) (result f32)
+    (f32.add (f32.add (f32.add (local.get $x) (local.get $y)) (local.get $z)) (local.get $w)))
+  (func (export "f64.no_reassociate_add") (param $x f64) (param $y f64) (param $z f64) (param $w f64) (result f64)
+    (f64.add (f64.add (f64.add (local.get $x) (local.get $y)) (local.get $z)) (local.get $w)))
+)
+
+(assert_return (invoke "f32.no_reassociate_add" (f32.const -0x1.5f7ddcp+44) (f32.const 0x1.854e1p+34) (f32.const -0x1.b2068cp+47) (f32.const -0x1.209692p+41)) (f32.const -0x1.e26c76p+47))
+(assert_return (invoke "f32.no_reassociate_add" (f32.const 0x1.da3b78p-9) (f32.const -0x1.4312fap-7) (f32.const 0x1.0395e6p-4) (f32.const -0x1.6d5ea6p-7)) (f32.const 0x1.78b31ap-5))
+(assert_return (invoke "f32.no_reassociate_add" (f32.const -0x1.fdb93ap+34) (f32.const -0x1.b6fce6p+41) (f32.const 0x1.c131d8p+44) (f32.const 0x1.8835b6p+38)) (f32.const 0x1.8ff3a2p+44))
+(assert_return (invoke "f32.no_reassociate_add" (f32.const 0x1.1739fcp+47) (f32.const 0x1.a4b186p+49) (f32.const -0x1.0c623cp+35) (f32.const 0x1.16a102p+51)) (f32.const 0x1.913ff6p+51))
+(assert_return (invoke "f32.no_reassociate_add" (f32.const 0x1.733cfap+108) (f32.const -0x1.38d30cp+108) (f32.const 0x1.2f5854p+105) (f32.const -0x1.ccb058p+94)) (f32.const 0x1.813716p+106))
+(assert_return (invoke "f64.no_reassociate_add" (f64.const -0x1.697a4d9ff19a6p+841) (f64.const 0x1.b305466238397p+847) (f64.const 0x1.e0b2d9bfb4e72p+855) (f64.const -0x1.6e1f3ae2b06bbp+857)) (f64.const -0x1.eb0e5936f087ap+856))
+(assert_return (invoke "f64.no_reassociate_add" (f64.const 0x1.00ef6746b30e1p-543) (f64.const 0x1.cc1cfafdf3fe1p-544) (f64.const -0x1.f7726df3ecba6p-543) (f64.const -0x1.b26695f99d307p-594)) (f64.const -0x1.074892e3fad76p-547))
+(assert_return (invoke "f64.no_reassociate_add" (f64.const -0x1.e807b3bd6d854p+440) (f64.const 0x1.cedae26c2c5fp+407) (f64.const -0x1.00ab6e1442541p+437) (f64.const 0x1.28538a55997bdp+397)) (f64.const -0x1.040e90bf871ebp+441))
+(assert_return (invoke "f64.no_reassociate_add" (f64.const -0x1.ba2b6f35a2402p-317) (f64.const 0x1.ad1c3fea7cd9ep-307) (f64.const -0x1.93aace2bf1261p-262) (f64.const 0x1.9fddbe472847ep-260)) (f64.const 0x1.3af30abc2c01bp-260))
+(assert_return (invoke "f64.no_reassociate_add" (f64.const -0x1.ccb9c6092fb1dp+641) (f64.const -0x1.4b7c28c108244p+614) (f64.const 0x1.8a7cefef4bde1p+646) (f64.const -0x1.901b28b08b482p+644)) (f64.const 0x1.1810579194126p+646))
+
+;; Test that x*y*z*w is not reassociated.
+
+(module
+  (func (export "f32.no_reassociate_mul") (param $x f32) (param $y f32) (param $z f32) (param $w f32) (result f32)
+    (f32.mul (f32.mul (f32.mul (local.get $x) (local.get $y)) (local.get $z)) (local.get $w)))
+  (func (export "f64.no_reassociate_mul") (param $x f64) (param $y f64) (param $z f64) (param $w f64) (result f64)
+    (f64.mul (f64.mul (f64.mul (local.get $x) (local.get $y)) (local.get $z)) (local.get $w)))
+)
+
+(assert_return (invoke "f32.no_reassociate_mul" (f32.const 0x1.950ba8p-116) (f32.const 0x1.efdacep-33) (f32.const -0x1.5f9bcp+102) (f32.const 0x1.f04508p-56)) (f32.const -0x1.ff356ep-101))
+(assert_return (invoke "f32.no_reassociate_mul" (f32.const 0x1.5990aep-56) (f32.const -0x1.7dfb04p+102) (f32.const -0x1.4f774ap-125) (f32.const -0x1.595fe6p+70)) (f32.const -0x1.c7c8fcp-8))
+(assert_return (invoke "f32.no_reassociate_mul" (f32.const 0x1.6ad9a4p-48) (f32.const -0x1.9138aap+55) (f32.const -0x1.4a774ep-40) (f32.const 0x1.1ff08p+76)) (f32.const 0x1.9cd8ecp+44))
+(assert_return (invoke "f32.no_reassociate_mul" (f32.const 0x1.e1caecp-105) (f32.const 0x1.af0dd2p+77) (f32.const -0x1.016eep+56) (f32.const -0x1.ab70d6p+59)) (f32.const 0x1.54870ep+89))
+(assert_return (invoke "f32.no_reassociate_mul" (f32.const -0x1.3b1dcp-99) (f32.const 0x1.4e5a34p-49) (f32.const -0x1.38ba5ap+3) (f32.const 0x1.7fb8eep+59)) (f32.const 0x1.5bbf98p-85))
+(assert_return (invoke "f64.no_reassociate_mul" (f64.const -0x1.e7842ab7181p-667) (f64.const -0x1.fabf40ceeceafp+990) (f64.const -0x1.1a38a825ab01ap-376) (f64.const -0x1.27e8ea469b14fp+664)) (f64.const 0x1.336eb428af4f3p+613))
+(assert_return (invoke "f64.no_reassociate_mul" (f64.const 0x1.4ca2292a6acbcp+454) (f64.const 0x1.6ffbab850089ap-516) (f64.const -0x1.547c32e1f5b93p-899) (f64.const -0x1.c7571d9388375p+540)) (f64.const 0x1.1ac796954fc1p-419))
+(assert_return (invoke "f64.no_reassociate_mul" (f64.const 0x1.73881a52e0401p-501) (f64.const -0x1.1b68dd9efb1a7p+788) (f64.const 0x1.d1c5e6a3eb27cp-762) (f64.const -0x1.56cb2fcc7546fp+88)) (f64.const 0x1.f508db92c34efp-386))
+(assert_return (invoke "f64.no_reassociate_mul" (f64.const 0x1.2efa87859987cp+692) (f64.const 0x1.68e4373e241p-423) (f64.const 0x1.4e2d0fb383a57p+223) (f64.const -0x1.301d3265c737bp-23)) (f64.const -0x1.4b2b6c393f30cp+470))
+(assert_return (invoke "f64.no_reassociate_mul" (f64.const 0x1.1013f7498b95fp-234) (f64.const 0x1.d2d1c36fff138p-792) (f64.const -0x1.cbf1824ea7bfdp+728) (f64.const -0x1.440da9c8b836dp-599)) (f64.const 0x1.1a16512881c91p-895))
+
+;; Test that x/0 is not folded away.
+
+(module
+  (func (export "f32.no_fold_div_0") (param $x f32) (result f32)
+    (f32.div (local.get $x) (f32.const 0.0)))
+  (func (export "f64.no_fold_div_0") (param $x f64) (result f64)
+    (f64.div (local.get $x) (f64.const 0.0)))
+)
+
+(assert_return (invoke "f32.no_fold_div_0" (f32.const 1.0)) (f32.const inf))
+(assert_return (invoke "f32.no_fold_div_0" (f32.const -1.0)) (f32.const -inf))
+(assert_return (invoke "f32.no_fold_div_0" (f32.const inf)) (f32.const inf))
+(assert_return (invoke "f32.no_fold_div_0" (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "f32.no_fold_div_0" (f32.const 0)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_0" (f32.const -0)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_0" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f32.no_fold_div_0" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const 1.0)) (f64.const inf))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const -1.0)) (f64.const -inf))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const inf)) (f64.const inf))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const 0)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const -0)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that x/-0 is not folded away.
+
+(module
+  (func (export "f32.no_fold_div_neg0") (param $x f32) (result f32)
+    (f32.div (local.get $x) (f32.const -0.0)))
+  (func (export "f64.no_fold_div_neg0") (param $x f64) (result f64)
+    (f64.div (local.get $x) (f64.const -0.0)))
+)
+
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const 1.0)) (f32.const -inf))
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const -1.0)) (f32.const inf))
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const 0)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const -0)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const 1.0)) (f64.const -inf))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const -1.0)) (f64.const inf))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const 0)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const -0)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that sqrt(x*x+y*y) is not folded to hypot.
+
+(module
+  (func (export "f32.no_fold_to_hypot") (param $x f32) (param $y f32) (result f32)
+    (f32.sqrt (f32.add (f32.mul (local.get $x) (local.get $x))
+                       (f32.mul (local.get $y) (local.get $y)))))
+  (func (export "f64.no_fold_to_hypot") (param $x f64) (param $y f64) (result f64)
+    (f64.sqrt (f64.add (f64.mul (local.get $x) (local.get $x))
+                       (f64.mul (local.get $y) (local.get $y)))))
+)
+
+(assert_return (invoke "f32.no_fold_to_hypot" (f32.const 0x1.c2f338p-81) (f32.const 0x1.401b5ep-68)) (f32.const 0x1.401cccp-68))
+(assert_return (invoke "f32.no_fold_to_hypot" (f32.const -0x1.c38d1p-71) (f32.const -0x1.359ddp-107)) (f32.const 0x1.c36a62p-71))
+(assert_return (invoke "f32.no_fold_to_hypot" (f32.const -0x1.99e0cap-114) (f32.const -0x1.ed0c6cp-69)) (f32.const 0x1.ed0e48p-69))
+(assert_return (invoke "f32.no_fold_to_hypot" (f32.const -0x1.1b6ceap+5) (f32.const 0x1.5440bep+17)) (f32.const 0x1.5440cp+17))
+(assert_return (invoke "f32.no_fold_to_hypot" (f32.const 0x1.8f019ep-76) (f32.const -0x1.182308p-71)) (f32.const 0x1.17e2bcp-71))
+(assert_return (invoke "f64.no_fold_to_hypot" (f64.const 0x1.1a0ac4f7c8711p-636) (f64.const 0x1.1372ebafff551p-534)) (f64.const 0x1.13463fa37014ep-534))
+(assert_return (invoke "f64.no_fold_to_hypot" (f64.const 0x1.b793512167499p+395) (f64.const -0x1.11cbc52af4c36p+410)) (f64.const 0x1.11cbc530783a2p+410))
+(assert_return (invoke "f64.no_fold_to_hypot" (f64.const 0x1.76777f44ff40bp-536) (f64.const -0x1.c3896e4dc1fbp-766)) (f64.const 0x1.8p-536))
+(assert_return (invoke "f64.no_fold_to_hypot" (f64.const -0x1.889ac72cc6b5dp-521) (f64.const 0x1.8d7084e659f3bp-733)) (f64.const 0x1.889ac72ca843ap-521))
+(assert_return (invoke "f64.no_fold_to_hypot" (f64.const 0x1.5ee588c02cb08p-670) (f64.const -0x1.05ce25788d9ecp-514)) (f64.const 0x1.05ce25788d9dfp-514))
+
+;; Test that 1.0/x isn't approximated.
+
+(module
+  (func (export "f32.no_approximate_reciprocal") (param $x f32) (result f32)
+    (f32.div (f32.const 1.0) (local.get $x)))
+)
+
+(assert_return (invoke "f32.no_approximate_reciprocal" (f32.const -0x1.2900b6p-10)) (f32.const -0x1.b950d4p+9))
+(assert_return (invoke "f32.no_approximate_reciprocal" (f32.const 0x1.e7212p+127)) (f32.const 0x1.0d11f8p-128))
+(assert_return (invoke "f32.no_approximate_reciprocal" (f32.const -0x1.42a466p-93)) (f32.const -0x1.963ee6p+92))
+(assert_return (invoke "f32.no_approximate_reciprocal" (f32.const 0x1.5d0c32p+76)) (f32.const 0x1.778362p-77))
+(assert_return (invoke "f32.no_approximate_reciprocal" (f32.const -0x1.601de2p-82)) (f32.const -0x1.743d7ep+81))
+
+;; Test that 1.0/sqrt(x) isn't approximated or fused.
+
+(module
+  (func (export "f32.no_approximate_reciprocal_sqrt") (param $x f32) (result f32)
+    (f32.div (f32.const 1.0) (f32.sqrt (local.get $x))))
+  (func (export "f64.no_fuse_reciprocal_sqrt") (param $x f64) (result f64)
+    (f64.div (f64.const 1.0) (f64.sqrt (local.get $x))))
+)
+
+(assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.6af12ap-43)) (f32.const 0x1.300ed4p+21))
+(assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.e82fc6p-8)) (f32.const 0x1.72c376p+3))
+(assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.b9fa9cp-66)) (f32.const 0x1.85a9bap+32))
+(assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.f4f546p-44)) (f32.const 0x1.6e01c2p+21))
+(assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.5da7aap-86)) (f32.const 0x1.b618cap+42))
+
+(assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.1568a63b55fa3p+889)) (f64.const 0x1.5bc9c74c9952p-445))
+(assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.239fcd0939cafp+311)) (f64.const 0x1.5334a922b4818p-156))
+(assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.6e36a24e11054p+104)) (f64.const 0x1.ac13f20977f29p-53))
+(assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.23ee173219f83p+668)) (f64.const 0x1.df753e055862dp-335))
+(assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.b30f74caf9babp+146)) (f64.const 0x1.88bfc3d1764a9p-74))
+
+;; Test that sqrt(1.0/x) isn't approximated.
+
+(module
+  (func (export "f32.no_approximate_sqrt_reciprocal") (param $x f32) (result f32)
+    (f32.sqrt (f32.div (f32.const 1.0) (local.get $x))))
+)
+
+(assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.a4c986p+60)) (f32.const 0x1.8f5ac6p-31))
+(assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.50511ep-9)) (f32.const 0x1.3bdd46p+4))
+(assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.125ec2p+69)) (f32.const 0x1.5db572p-35))
+(assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.ba4c5p+13)) (f32.const 0x1.136f16p-7))
+(assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.4a5be2p+104)) (f32.const 0x1.c2b5bp-53))
+
+;; Test that converting i32/i64 to f32/f64 and back isn't folded away.
+
+(module
+  (func (export "i32.no_fold_f32_s") (param i32) (result i32)
+    (i32.trunc_f32_s (f32.convert_i32_s (local.get 0))))
+  (func (export "i32.no_fold_f32_u") (param i32) (result i32)
+    (i32.trunc_f32_u (f32.convert_i32_u (local.get 0))))
+  (func (export "i64.no_fold_f64_s") (param i64) (result i64)
+    (i64.trunc_f64_s (f64.convert_i64_s (local.get 0))))
+  (func (export "i64.no_fold_f64_u") (param i64) (result i64)
+    (i64.trunc_f64_u (f64.convert_i64_u (local.get 0))))
+)
+
+(assert_return (invoke "i32.no_fold_f32_s" (i32.const 0x1000000)) (i32.const 0x1000000))
+(assert_return (invoke "i32.no_fold_f32_s" (i32.const 0x1000001)) (i32.const 0x1000000))
+(assert_return (invoke "i32.no_fold_f32_s" (i32.const 0xf0000010)) (i32.const 0xf0000010))
+
+(assert_return (invoke "i32.no_fold_f32_u" (i32.const 0x1000000)) (i32.const 0x1000000))
+(assert_return (invoke "i32.no_fold_f32_u" (i32.const 0x1000001)) (i32.const 0x1000000))
+(assert_return (invoke "i32.no_fold_f32_u" (i32.const 0xf0000010)) (i32.const 0xf0000000))
+
+(assert_return (invoke "i64.no_fold_f64_s" (i64.const 0x20000000000000)) (i64.const 0x20000000000000))
+(assert_return (invoke "i64.no_fold_f64_s" (i64.const 0x20000000000001)) (i64.const 0x20000000000000))
+(assert_return (invoke "i64.no_fold_f64_s" (i64.const 0xf000000000000400)) (i64.const 0xf000000000000400))
+
+(assert_return (invoke "i64.no_fold_f64_u" (i64.const 0x20000000000000)) (i64.const 0x20000000000000))
+(assert_return (invoke "i64.no_fold_f64_u" (i64.const 0x20000000000001)) (i64.const 0x20000000000000))
+(assert_return (invoke "i64.no_fold_f64_u" (i64.const 0xf000000000000400)) (i64.const 0xf000000000000000))
+
+;; Test that x+y-y is not folded to x.
+
+(module
+  (func (export "f32.no_fold_add_sub") (param $x f32) (param $y f32) (result f32)
+    (f32.sub (f32.add (local.get $x) (local.get $y)) (local.get $y)))
+  (func (export "f64.no_fold_add_sub") (param $x f64) (param $y f64) (result f64)
+    (f64.sub (f64.add (local.get $x) (local.get $y)) (local.get $y)))
+)
+
+(assert_return (invoke "f32.no_fold_add_sub" (f32.const 0x1.b553e4p-47) (f32.const -0x1.67db2cp-26)) (f32.const 0x1.cp-47))
+(assert_return (invoke "f32.no_fold_add_sub" (f32.const -0x1.a884dp-23) (f32.const 0x1.f2ae1ep-19)) (f32.const -0x1.a884ep-23))
+(assert_return (invoke "f32.no_fold_add_sub" (f32.const -0x1.fc04fp+82) (f32.const -0x1.65403ap+101)) (f32.const -0x1p+83))
+(assert_return (invoke "f32.no_fold_add_sub" (f32.const 0x1.870fa2p-78) (f32.const 0x1.c54916p-56)) (f32.const 0x1.8p-78))
+(assert_return (invoke "f32.no_fold_add_sub" (f32.const -0x1.17e966p-108) (f32.const -0x1.5fa61ap-84)) (f32.const -0x1p-107))
+
+(assert_return (invoke "f64.no_fold_add_sub" (f64.const -0x1.1053ea172dba8p-874) (f64.const 0x1.113c413408ac8p-857)) (f64.const -0x1.1053ea172p-874))
+(assert_return (invoke "f64.no_fold_add_sub" (f64.const 0x1.e377d54807972p-546) (f64.const 0x1.040a0a4d1ff7p-526)) (f64.const 0x1.e377d548p-546))
+(assert_return (invoke "f64.no_fold_add_sub" (f64.const -0x1.75f53cd926b62p-30) (f64.const -0x1.66b176e602bb5p-3)) (f64.const -0x1.75f53dp-30))
+(assert_return (invoke "f64.no_fold_add_sub" (f64.const -0x1.c450ff28332ap-341) (f64.const 0x1.15a5855023baep-305)) (f64.const -0x1.c451p-341))
+(assert_return (invoke "f64.no_fold_add_sub" (f64.const -0x1.1ad4a596d3ea8p-619) (f64.const -0x1.17d81a41c0ea8p-588)) (f64.const -0x1.1ad4a8p-619))
+
+;; Test that x-y+y is not folded to x.
+
+(module
+  (func (export "f32.no_fold_sub_add") (param $x f32) (param $y f32) (result f32)
+    (f32.add (f32.sub (local.get $x) (local.get $y)) (local.get $y)))
+  (func (export "f64.no_fold_sub_add") (param $x f64) (param $y f64) (result f64)
+    (f64.add (f64.sub (local.get $x) (local.get $y)) (local.get $y)))
+)
+
+(assert_return (invoke "f32.no_fold_sub_add" (f32.const -0x1.523cb8p+9) (f32.const 0x1.93096cp+8)) (f32.const -0x1.523cbap+9))
+(assert_return (invoke "f32.no_fold_sub_add" (f32.const -0x1.a31a1p-111) (f32.const 0x1.745efp-95)) (f32.const -0x1.a4p-111))
+(assert_return (invoke "f32.no_fold_sub_add" (f32.const 0x1.3d5328p+26) (f32.const 0x1.58567p+35)) (f32.const 0x1.3d54p+26))
+(assert_return (invoke "f32.no_fold_sub_add" (f32.const 0x1.374e26p-39) (f32.const -0x1.66a5p-27)) (f32.const 0x1.374p-39))
+(assert_return (invoke "f32.no_fold_sub_add" (f32.const 0x1.320facp-3) (f32.const -0x1.ac069ap+14)) (f32.const 0x1.34p-3))
+
+(assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.8f92aad2c9b8dp+255) (f64.const -0x1.08cd4992266cbp+259)) (f64.const 0x1.8f92aad2c9b9p+255))
+(assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.5aaff55742c8bp-666) (f64.const 0x1.8f5f47181f46dp-647)) (f64.const 0x1.5aaff5578p-666))
+(assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.21bc52967a98dp+251) (f64.const -0x1.fcffaa32d0884p+300)) (f64.const 0x1.2p+251))
+(assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.9c78361f47374p-26) (f64.const -0x1.69d69f4edc61cp-13)) (f64.const 0x1.9c78361f48p-26))
+(assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.4dbe68e4afab2p-367) (f64.const -0x1.dc24e5b39cd02p-361)) (f64.const 0x1.4dbe68e4afacp-367))
+
+;; Test that x*y/y is not folded to x.
+
+(module
+  (func (export "f32.no_fold_mul_div") (param $x f32) (param $y f32) (result f32)
+    (f32.div (f32.mul (local.get $x) (local.get $y)) (local.get $y)))
+  (func (export "f64.no_fold_mul_div") (param $x f64) (param $y f64) (result f64)
+    (f64.div (f64.mul (local.get $x) (local.get $y)) (local.get $y)))
+)
+
+(assert_return (invoke "f32.no_fold_mul_div" (f32.const -0x1.cd859ap+54) (f32.const 0x1.6ca936p-47)) (f32.const -0x1.cd8598p+54))
+(assert_return (invoke "f32.no_fold_mul_div" (f32.const -0x1.0b56b8p-26) (f32.const 0x1.48264cp-106)) (f32.const -0x1.0b56a4p-26))
+(assert_return (invoke "f32.no_fold_mul_div" (f32.const -0x1.e7555cp-48) (f32.const -0x1.9161cp+48)) (f32.const -0x1.e7555ap-48))
+(assert_return (invoke "f32.no_fold_mul_div" (f32.const 0x1.aaa50ep+52) (f32.const -0x1.dfb39ep+60)) (f32.const 0x1.aaa50cp+52))
+(assert_return (invoke "f32.no_fold_mul_div" (f32.const -0x1.2b7dfap-92) (f32.const -0x1.7c4ca6p-37)) (f32.const -0x1.2b7dfep-92))
+
+(assert_return (invoke "f64.no_fold_mul_div" (f64.const -0x1.3d79ff4118a1ap-837) (f64.const -0x1.b8b5dda31808cp-205)) (f64.const -0x1.3d79ff412263ep-837))
+(assert_return (invoke "f64.no_fold_mul_div" (f64.const 0x1.f894d1ee6b3a4p+384) (f64.const 0x1.8c2606d03d58ap+585)) (f64.const 0x1.f894d1ee6b3a5p+384))
+(assert_return (invoke "f64.no_fold_mul_div" (f64.const -0x1.a022260acc993p+238) (f64.const -0x1.5fbc128fc8e3cp-552)) (f64.const -0x1.a022260acc992p+238))
+(assert_return (invoke "f64.no_fold_mul_div" (f64.const 0x1.9d4b8ed174f54p-166) (f64.const 0x1.ee3d467aeeac6p-906)) (f64.const 0x1.8dcc95a053b2bp-166))
+(assert_return (invoke "f64.no_fold_mul_div" (f64.const -0x1.e95ea897cdcd4p+660) (f64.const -0x1.854d5df085f2ep-327)) (f64.const -0x1.e95ea897cdcd5p+660))
+
+;; Test that x/y*y is not folded to x.
+
+(module
+  (func (export "f32.no_fold_div_mul") (param $x f32) (param $y f32) (result f32)
+    (f32.mul (f32.div (local.get $x) (local.get $y)) (local.get $y)))
+  (func (export "f64.no_fold_div_mul") (param $x f64) (param $y f64) (result f64)
+    (f64.mul (f64.div (local.get $x) (local.get $y)) (local.get $y)))
+)
+
+(assert_return (invoke "f32.no_fold_div_mul" (f32.const -0x1.dc6364p+38) (f32.const 0x1.d630ecp+29)) (f32.const -0x1.dc6362p+38))
+(assert_return (invoke "f32.no_fold_div_mul" (f32.const -0x1.1f9836p-52) (f32.const -0x1.16c4e4p-18)) (f32.const -0x1.1f9838p-52))
+(assert_return (invoke "f32.no_fold_div_mul" (f32.const 0x1.c5972cp-126) (f32.const -0x1.d6659ep+7)) (f32.const 0x1.c5980ep-126))
+(assert_return (invoke "f32.no_fold_div_mul" (f32.const -0x1.2e3a9ep-74) (f32.const -0x1.353994p+59)) (f32.const -0x1.2e3a4p-74))
+(assert_return (invoke "f32.no_fold_div_mul" (f32.const 0x1.d96b82p-98) (f32.const 0x1.95d908p+27)) (f32.const 0x1.d96b84p-98))
+
+(assert_return (invoke "f64.no_fold_div_mul" (f64.const 0x1.d01f913a52481p-876) (f64.const -0x1.2cd0668b28344p+184)) (f64.const 0x1.d020daf71cdcp-876))
+(assert_return (invoke "f64.no_fold_div_mul" (f64.const -0x1.81cb7d400918dp-714) (f64.const 0x1.7caa643586d6ep-53)) (f64.const -0x1.81cb7d400918ep-714))
+(assert_return (invoke "f64.no_fold_div_mul" (f64.const -0x1.66904c97b5c8ep-145) (f64.const 0x1.5c3481592ad4cp+428)) (f64.const -0x1.66904c97b5c8dp-145))
+(assert_return (invoke "f64.no_fold_div_mul" (f64.const -0x1.e75859d2f0765p-278) (f64.const -0x1.5f19b6ab497f9p+283)) (f64.const -0x1.e75859d2f0764p-278))
+(assert_return (invoke "f64.no_fold_div_mul" (f64.const -0x1.515fe9c3b5f5p+620) (f64.const 0x1.36be869c99f7ap+989)) (f64.const -0x1.515fe9c3b5f4fp+620))
+
+;; Test that x/2*2 is not folded to x.
+
+(module
+  (func (export "f32.no_fold_div2_mul2") (param $x f32) (result f32)
+    (f32.mul (f32.div (local.get $x) (f32.const 2.0)) (f32.const 2.0)))
+  (func (export "f64.no_fold_div2_mul2") (param $x f64) (result f64)
+    (f64.mul (f64.div (local.get $x) (f64.const 2.0)) (f64.const 2.0)))
+)
+
+(assert_return (invoke "f32.no_fold_div2_mul2" (f32.const 0x1.fffffep-126)) (f32.const 0x1p-125))
+(assert_return (invoke "f64.no_fold_div2_mul2" (f64.const 0x1.fffffffffffffp-1022)) (f64.const 0x1p-1021))
+
+;; Test that promote(demote(x)) is not folded to x.
+
+(module
+  (func (export "no_fold_demote_promote") (param $x f64) (result f64)
+    (f64.promote_f32 (f32.demote_f64 (local.get $x))))
+)
+
+(assert_return (invoke "no_fold_demote_promote" (f64.const -0x1.dece272390f5dp-133)) (f64.const -0x1.decep-133))
+(assert_return (invoke "no_fold_demote_promote" (f64.const -0x1.19e6c79938a6fp-85)) (f64.const -0x1.19e6c8p-85))
+(assert_return (invoke "no_fold_demote_promote" (f64.const 0x1.49b297ec44dc1p+107)) (f64.const 0x1.49b298p+107))
+(assert_return (invoke "no_fold_demote_promote" (f64.const -0x1.74f5bd865163p-88)) (f64.const -0x1.74f5bep-88))
+(assert_return (invoke "no_fold_demote_promote" (f64.const 0x1.26d675662367ep+104)) (f64.const 0x1.26d676p+104))
+
+;; Test that demote(promote(x)) is not folded to x, and aside from NaN is
+;; bit-preserving.
+
+(module
+  (func (export "no_fold_promote_demote") (param $x f32) (result f32)
+    (f32.demote_f64 (f64.promote_f32 (local.get $x))))
+)
+
+(assert_return (invoke "no_fold_promote_demote" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "no_fold_promote_demote" (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "no_fold_promote_demote" (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "no_fold_promote_demote" (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "no_fold_promote_demote" (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "no_fold_promote_demote" (f32.const 0x1.fffffcp-127)) (f32.const 0x1.fffffcp-127))
+(assert_return (invoke "no_fold_promote_demote" (f32.const -0x1.fffffcp-127)) (f32.const -0x1.fffffcp-127))
+(assert_return (invoke "no_fold_promote_demote" (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "no_fold_promote_demote" (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "no_fold_promote_demote" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "no_fold_promote_demote" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "no_fold_promote_demote" (f32.const inf)) (f32.const inf))
+(assert_return (invoke "no_fold_promote_demote" (f32.const -inf)) (f32.const -inf))
+
+;; Test that demote(x+promote(y)) is not folded to demote(x)+y.
+
+(module
+  (func (export "no_demote_mixed_add") (param $x f64) (param $y f32) (result f32)
+    (f32.demote_f64 (f64.add (local.get $x) (f64.promote_f32 (local.get $y)))))
+  (func (export "no_demote_mixed_add_commuted") (param $y f32) (param $x f64) (result f32)
+    (f32.demote_f64 (f64.add (f64.promote_f32 (local.get $y)) (local.get $x))))
+)
+
+(assert_return (invoke "no_demote_mixed_add" (f64.const 0x1.f51a9d04854f9p-95) (f32.const 0x1.3f4e9cp-119)) (f32.const 0x1.f51a9ep-95))
+(assert_return (invoke "no_demote_mixed_add" (f64.const 0x1.065b3d81ad8dp+37) (f32.const 0x1.758cd8p+38)) (f32.const 0x1.f8ba76p+38))
+(assert_return (invoke "no_demote_mixed_add" (f64.const 0x1.626c80963bd17p-119) (f32.const -0x1.9bbf86p-121)) (f32.const 0x1.f6f93ep-120))
+(assert_return (invoke "no_demote_mixed_add" (f64.const -0x1.0d5110e3385bbp-20) (f32.const 0x1.096f4ap-29)) (f32.const -0x1.0ccc5ap-20))
+(assert_return (invoke "no_demote_mixed_add" (f64.const -0x1.73852db4e5075p-20) (f32.const -0x1.24e474p-41)) (f32.const -0x1.738536p-20))
+
+(assert_return (invoke "no_demote_mixed_add_commuted" (f32.const 0x1.3f4e9cp-119) (f64.const 0x1.f51a9d04854f9p-95)) (f32.const 0x1.f51a9ep-95))
+(assert_return (invoke "no_demote_mixed_add_commuted" (f32.const 0x1.758cd8p+38) (f64.const 0x1.065b3d81ad8dp+37)) (f32.const 0x1.f8ba76p+38))
+(assert_return (invoke "no_demote_mixed_add_commuted" (f32.const -0x1.9bbf86p-121) (f64.const 0x1.626c80963bd17p-119)) (f32.const 0x1.f6f93ep-120))
+(assert_return (invoke "no_demote_mixed_add_commuted" (f32.const 0x1.096f4ap-29) (f64.const -0x1.0d5110e3385bbp-20)) (f32.const -0x1.0ccc5ap-20))
+(assert_return (invoke "no_demote_mixed_add_commuted" (f32.const -0x1.24e474p-41) (f64.const -0x1.73852db4e5075p-20)) (f32.const -0x1.738536p-20))
+
+;; Test that demote(x-promote(y)) is not folded to demote(x)-y.
+
+(module
+  (func (export "no_demote_mixed_sub") (param $x f64) (param $y f32) (result f32)
+    (f32.demote_f64 (f64.sub (local.get $x) (f64.promote_f32 (local.get $y)))))
+)
+
+(assert_return (invoke "no_demote_mixed_sub" (f64.const 0x1.a0a183220e9b1p+82) (f32.const 0x1.c5acf8p+61)) (f32.const 0x1.a0a174p+82))
+(assert_return (invoke "no_demote_mixed_sub" (f64.const -0x1.6e2c5ac39f63ep+30) (f32.const 0x1.d48ca4p+17)) (f32.const -0x1.6e3bp+30))
+(assert_return (invoke "no_demote_mixed_sub" (f64.const -0x1.98c74350dde6ap+6) (f32.const 0x1.9d69bcp-12)) (f32.const -0x1.98c7aap+6))
+(assert_return (invoke "no_demote_mixed_sub" (f64.const 0x1.0459f34091dbfp-54) (f32.const 0x1.61ad08p-71)) (f32.const 0x1.045942p-54))
+(assert_return (invoke "no_demote_mixed_sub" (f64.const 0x1.a7498dca3fdb7p+14) (f32.const 0x1.ed21c8p+15)) (f32.const -0x1.197d02p+15))
+
+;; Test that converting between integer and float and back isn't folded away.
+
+(module
+  (func (export "f32.i32.no_fold_trunc_s_convert_s") (param $x f32) (result f32)
+    (f32.convert_i32_s (i32.trunc_f32_s (local.get $x))))
+  (func (export "f32.i32.no_fold_trunc_u_convert_s") (param $x f32) (result f32)
+    (f32.convert_i32_s (i32.trunc_f32_u (local.get $x))))
+  (func (export "f32.i32.no_fold_trunc_s_convert_u") (param $x f32) (result f32)
+    (f32.convert_i32_u (i32.trunc_f32_s (local.get $x))))
+  (func (export "f32.i32.no_fold_trunc_u_convert_u") (param $x f32) (result f32)
+    (f32.convert_i32_u (i32.trunc_f32_u (local.get $x))))
+  (func (export "f64.i32.no_fold_trunc_s_convert_s") (param $x f64) (result f64)
+    (f64.convert_i32_s (i32.trunc_f64_s (local.get $x))))
+  (func (export "f64.i32.no_fold_trunc_u_convert_s") (param $x f64) (result f64)
+    (f64.convert_i32_s (i32.trunc_f64_u (local.get $x))))
+  (func (export "f64.i32.no_fold_trunc_s_convert_u") (param $x f64) (result f64)
+    (f64.convert_i32_u (i32.trunc_f64_s (local.get $x))))
+  (func (export "f64.i32.no_fold_trunc_u_convert_u") (param $x f64) (result f64)
+    (f64.convert_i32_u (i32.trunc_f64_u (local.get $x))))
+  (func (export "f32.i64.no_fold_trunc_s_convert_s") (param $x f32) (result f32)
+    (f32.convert_i64_s (i64.trunc_f32_s (local.get $x))))
+  (func (export "f32.i64.no_fold_trunc_u_convert_s") (param $x f32) (result f32)
+    (f32.convert_i64_s (i64.trunc_f32_u (local.get $x))))
+  (func (export "f32.i64.no_fold_trunc_s_convert_u") (param $x f32) (result f32)
+    (f32.convert_i64_u (i64.trunc_f32_s (local.get $x))))
+  (func (export "f32.i64.no_fold_trunc_u_convert_u") (param $x f32) (result f32)
+    (f32.convert_i64_u (i64.trunc_f32_u (local.get $x))))
+  (func (export "f64.i64.no_fold_trunc_s_convert_s") (param $x f64) (result f64)
+    (f64.convert_i64_s (i64.trunc_f64_s (local.get $x))))
+  (func (export "f64.i64.no_fold_trunc_u_convert_s") (param $x f64) (result f64)
+    (f64.convert_i64_s (i64.trunc_f64_u (local.get $x))))
+  (func (export "f64.i64.no_fold_trunc_s_convert_u") (param $x f64) (result f64)
+    (f64.convert_i64_u (i64.trunc_f64_s (local.get $x))))
+  (func (export "f64.i64.no_fold_trunc_u_convert_u") (param $x f64) (result f64)
+    (f64.convert_i64_u (i64.trunc_f64_u (local.get $x))))
+)
+
+(assert_return (invoke "f32.i32.no_fold_trunc_s_convert_s" (f32.const 1.5)) (f32.const 1.0))
+(assert_return (invoke "f32.i32.no_fold_trunc_s_convert_s" (f32.const -1.5)) (f32.const -1.0))
+(assert_return (invoke "f32.i32.no_fold_trunc_u_convert_s" (f32.const 1.5)) (f32.const 1.0))
+(assert_return (invoke "f32.i32.no_fold_trunc_u_convert_s" (f32.const -0.5)) (f32.const 0.0))
+(assert_return (invoke "f32.i32.no_fold_trunc_s_convert_u" (f32.const 1.5)) (f32.const 1.0))
+(assert_return (invoke "f32.i32.no_fold_trunc_s_convert_u" (f32.const -1.5)) (f32.const 0x1p+32))
+(assert_return (invoke "f32.i32.no_fold_trunc_u_convert_u" (f32.const 1.5)) (f32.const 1.0))
+(assert_return (invoke "f32.i32.no_fold_trunc_u_convert_u" (f32.const -0.5)) (f32.const 0.0))
+
+(assert_return (invoke "f64.i32.no_fold_trunc_s_convert_s" (f64.const 1.5)) (f64.const 1.0))
+(assert_return (invoke "f64.i32.no_fold_trunc_s_convert_s" (f64.const -1.5)) (f64.const -1.0))
+(assert_return (invoke "f64.i32.no_fold_trunc_u_convert_s" (f64.const 1.5)) (f64.const 1.0))
+(assert_return (invoke "f64.i32.no_fold_trunc_u_convert_s" (f64.const -0.5)) (f64.const 0.0))
+(assert_return (invoke "f64.i32.no_fold_trunc_s_convert_u" (f64.const 1.5)) (f64.const 1.0))
+(assert_return (invoke "f64.i32.no_fold_trunc_s_convert_u" (f64.const -1.5)) (f64.const 0x1.fffffffep+31))
+(assert_return (invoke "f64.i32.no_fold_trunc_u_convert_u" (f64.const 1.5)) (f64.const 1.0))
+(assert_return (invoke "f64.i32.no_fold_trunc_u_convert_u" (f64.const -0.5)) (f64.const 0.0))
+
+(assert_return (invoke "f32.i64.no_fold_trunc_s_convert_s" (f32.const 1.5)) (f32.const 1.0))
+(assert_return (invoke "f32.i64.no_fold_trunc_s_convert_s" (f32.const -1.5)) (f32.const -1.0))
+(assert_return (invoke "f32.i64.no_fold_trunc_u_convert_s" (f32.const 1.5)) (f32.const 1.0))
+(assert_return (invoke "f32.i64.no_fold_trunc_u_convert_s" (f32.const -0.5)) (f32.const 0.0))
+(assert_return (invoke "f32.i64.no_fold_trunc_s_convert_u" (f32.const 1.5)) (f32.const 1.0))
+(assert_return (invoke "f32.i64.no_fold_trunc_s_convert_u" (f32.const -1.5)) (f32.const 0x1p+64))
+(assert_return (invoke "f32.i64.no_fold_trunc_u_convert_u" (f32.const 1.5)) (f32.const 1.0))
+(assert_return (invoke "f32.i64.no_fold_trunc_u_convert_u" (f32.const -0.5)) (f32.const 0.0))
+
+(assert_return (invoke "f64.i64.no_fold_trunc_s_convert_s" (f64.const 1.5)) (f64.const 1.0))
+(assert_return (invoke "f64.i64.no_fold_trunc_s_convert_s" (f64.const -1.5)) (f64.const -1.0))
+(assert_return (invoke "f64.i64.no_fold_trunc_u_convert_s" (f64.const 1.5)) (f64.const 1.0))
+(assert_return (invoke "f64.i64.no_fold_trunc_u_convert_s" (f64.const -0.5)) (f64.const 0.0))
+(assert_return (invoke "f64.i64.no_fold_trunc_s_convert_u" (f64.const 1.5)) (f64.const 1.0))
+(assert_return (invoke "f64.i64.no_fold_trunc_s_convert_u" (f64.const -1.5)) (f64.const 0x1p+64))
+(assert_return (invoke "f64.i64.no_fold_trunc_u_convert_u" (f64.const 1.5)) (f64.const 1.0))
+(assert_return (invoke "f64.i64.no_fold_trunc_u_convert_u" (f64.const -0.5)) (f64.const 0.0))
+
+;; Test that dividing by a loop-invariant constant isn't optimized to be a
+;; multiplication by a reciprocal, which would be particularly tempting since
+;; the reciprocal computation could be hoisted.
+
+(module
+  (memory 1 1)
+  (func (export "init") (param $i i32) (param $x f32) (f32.store (local.get $i) (local.get $x)))
+
+  (func (export "run") (param $n i32) (param $z f32)
+    (local $i i32)
+    (block $exit
+      (loop $cont
+        (f32.store
+          (local.get $i)
+          (f32.div (f32.load (local.get $i)) (local.get $z))
+        )
+        (local.set $i (i32.add (local.get $i) (i32.const 4)))
+        (br_if $cont (i32.lt_u (local.get $i) (local.get $n)))
+      )
+    )
+  )
+
+  (func (export "check") (param $i i32) (result f32) (f32.load (local.get $i)))
+)
+
+(invoke "init" (i32.const  0) (f32.const 15.1))
+(invoke "init" (i32.const  4) (f32.const 15.2))
+(invoke "init" (i32.const  8) (f32.const 15.3))
+(invoke "init" (i32.const 12) (f32.const 15.4))
+(assert_return (invoke "check" (i32.const  0)) (f32.const 15.1))
+(assert_return (invoke "check" (i32.const  4)) (f32.const 15.2))
+(assert_return (invoke "check" (i32.const  8)) (f32.const 15.3))
+(assert_return (invoke "check" (i32.const 12)) (f32.const 15.4))
+(invoke "run" (i32.const 16) (f32.const 3.0))
+(assert_return (invoke "check" (i32.const  0)) (f32.const 0x1.422222p+2))
+(assert_return (invoke "check" (i32.const  4)) (f32.const 0x1.444444p+2))
+(assert_return (invoke "check" (i32.const  8)) (f32.const 0x1.466666p+2))
+(assert_return (invoke "check" (i32.const 12)) (f32.const 0x1.488888p+2))
+
+(module
+  (memory 1 1)
+  (func (export "init") (param $i i32) (param $x f64) (f64.store (local.get $i) (local.get $x)))
+
+  (func (export "run") (param $n i32) (param $z f64)
+    (local $i i32)
+    (block $exit
+      (loop $cont
+        (f64.store
+          (local.get $i)
+          (f64.div (f64.load (local.get $i)) (local.get $z))
+        )
+        (local.set $i (i32.add (local.get $i) (i32.const 8)))
+        (br_if $cont (i32.lt_u (local.get $i) (local.get $n)))
+      )
+    )
+  )
+
+  (func (export "check") (param $i i32) (result f64) (f64.load (local.get $i)))
+)
+
+(invoke "init" (i32.const  0) (f64.const 15.1))
+(invoke "init" (i32.const  8) (f64.const 15.2))
+(invoke "init" (i32.const 16) (f64.const 15.3))
+(invoke "init" (i32.const 24) (f64.const 15.4))
+(assert_return (invoke "check" (i32.const  0)) (f64.const 15.1))
+(assert_return (invoke "check" (i32.const  8)) (f64.const 15.2))
+(assert_return (invoke "check" (i32.const 16)) (f64.const 15.3))
+(assert_return (invoke "check" (i32.const 24)) (f64.const 15.4))
+(invoke "run" (i32.const 32) (f64.const 3.0))
+(assert_return (invoke "check" (i32.const 0)) (f64.const 0x1.4222222222222p+2))
+(assert_return (invoke "check" (i32.const 8)) (f64.const 0x1.4444444444444p+2))
+(assert_return (invoke "check" (i32.const 16)) (f64.const 0x1.4666666666667p+2))
+(assert_return (invoke "check" (i32.const 24)) (f64.const 0x1.4888888888889p+2))
+
+;; Test that ult/ugt/etc. aren't folded to olt/ogt/etc.
+
+(module
+  (func (export "f32.ult") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.ge (local.get $x) (local.get $y))))
+  (func (export "f32.ule") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.gt (local.get $x) (local.get $y))))
+  (func (export "f32.ugt") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.le (local.get $x) (local.get $y))))
+  (func (export "f32.uge") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.lt (local.get $x) (local.get $y))))
+
+  (func (export "f64.ult") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.ge (local.get $x) (local.get $y))))
+  (func (export "f64.ule") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.gt (local.get $x) (local.get $y))))
+  (func (export "f64.ugt") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.le (local.get $x) (local.get $y))))
+  (func (export "f64.uge") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.lt (local.get $x) (local.get $y))))
+)
+
+(assert_return (invoke "f32.ult" (f32.const 3.0) (f32.const 2.0)) (i32.const 0))
+(assert_return (invoke "f32.ult" (f32.const 2.0) (f32.const 2.0)) (i32.const 0))
+(assert_return (invoke "f32.ult" (f32.const 2.0) (f32.const 3.0)) (i32.const 1))
+(assert_return (invoke "f32.ult" (f32.const 2.0) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "f32.ule" (f32.const 3.0) (f32.const 2.0)) (i32.const 0))
+(assert_return (invoke "f32.ule" (f32.const 2.0) (f32.const 2.0)) (i32.const 1))
+(assert_return (invoke "f32.ule" (f32.const 2.0) (f32.const 3.0)) (i32.const 1))
+(assert_return (invoke "f32.ule" (f32.const 2.0) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "f32.ugt" (f32.const 3.0) (f32.const 2.0)) (i32.const 1))
+(assert_return (invoke "f32.ugt" (f32.const 2.0) (f32.const 2.0)) (i32.const 0))
+(assert_return (invoke "f32.ugt" (f32.const 2.0) (f32.const 3.0)) (i32.const 0))
+(assert_return (invoke "f32.ugt" (f32.const 2.0) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "f32.uge" (f32.const 3.0) (f32.const 2.0)) (i32.const 1))
+(assert_return (invoke "f32.uge" (f32.const 2.0) (f32.const 2.0)) (i32.const 1))
+(assert_return (invoke "f32.uge" (f32.const 2.0) (f32.const 3.0)) (i32.const 0))
+(assert_return (invoke "f32.uge" (f32.const 2.0) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "f64.ult" (f64.const 3.0) (f64.const 2.0)) (i32.const 0))
+(assert_return (invoke "f64.ult" (f64.const 2.0) (f64.const 2.0)) (i32.const 0))
+(assert_return (invoke "f64.ult" (f64.const 2.0) (f64.const 3.0)) (i32.const 1))
+(assert_return (invoke "f64.ult" (f64.const 2.0) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "f64.ule" (f64.const 3.0) (f64.const 2.0)) (i32.const 0))
+(assert_return (invoke "f64.ule" (f64.const 2.0) (f64.const 2.0)) (i32.const 1))
+(assert_return (invoke "f64.ule" (f64.const 2.0) (f64.const 3.0)) (i32.const 1))
+(assert_return (invoke "f64.ule" (f64.const 2.0) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "f64.ugt" (f64.const 3.0) (f64.const 2.0)) (i32.const 1))
+(assert_return (invoke "f64.ugt" (f64.const 2.0) (f64.const 2.0)) (i32.const 0))
+(assert_return (invoke "f64.ugt" (f64.const 2.0) (f64.const 3.0)) (i32.const 0))
+(assert_return (invoke "f64.ugt" (f64.const 2.0) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "f64.uge" (f64.const 3.0) (f64.const 2.0)) (i32.const 1))
+(assert_return (invoke "f64.uge" (f64.const 2.0) (f64.const 2.0)) (i32.const 1))
+(assert_return (invoke "f64.uge" (f64.const 2.0) (f64.const 3.0)) (i32.const 0))
+(assert_return (invoke "f64.uge" (f64.const 2.0) (f64.const nan)) (i32.const 1))
+
+;; Test that x<y?x:y, etc. using select aren't folded to min, etc.
+
+(module
+  (func (export "f32.no_fold_lt_select") (param $x f32) (param $y f32) (result f32) (select (local.get $x) (local.get $y) (f32.lt (local.get $x) (local.get $y))))
+  (func (export "f32.no_fold_le_select") (param $x f32) (param $y f32) (result f32) (select (local.get $x) (local.get $y) (f32.le (local.get $x) (local.get $y))))
+  (func (export "f32.no_fold_gt_select") (param $x f32) (param $y f32) (result f32) (select (local.get $x) (local.get $y) (f32.gt (local.get $x) (local.get $y))))
+  (func (export "f32.no_fold_ge_select") (param $x f32) (param $y f32) (result f32) (select (local.get $x) (local.get $y) (f32.ge (local.get $x) (local.get $y))))
+
+  (func (export "f64.no_fold_lt_select") (param $x f64) (param $y f64) (result f64) (select (local.get $x) (local.get $y) (f64.lt (local.get $x) (local.get $y))))
+  (func (export "f64.no_fold_le_select") (param $x f64) (param $y f64) (result f64) (select (local.get $x) (local.get $y) (f64.le (local.get $x) (local.get $y))))
+  (func (export "f64.no_fold_gt_select") (param $x f64) (param $y f64) (result f64) (select (local.get $x) (local.get $y) (f64.gt (local.get $x) (local.get $y))))
+  (func (export "f64.no_fold_ge_select") (param $x f64) (param $y f64) (result f64) (select (local.get $x) (local.get $y) (f64.ge (local.get $x) (local.get $y))))
+)
+
+(assert_return (invoke "f32.no_fold_lt_select" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_lt_select" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_lt_select" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_lt_select" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_le_select" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_le_select" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_le_select" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_le_select" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_gt_select" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_gt_select" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_gt_select" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_gt_select" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_ge_select" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_ge_select" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_ge_select" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_ge_select" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0))
+(assert_return (invoke "f64.no_fold_lt_select" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_lt_select" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_lt_select" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_lt_select" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_le_select" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_le_select" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_le_select" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_le_select" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_gt_select" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_gt_select" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_gt_select" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_gt_select" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_ge_select" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_ge_select" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_ge_select" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_ge_select" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0))
+
+;; Test that x<y?x:y, etc. using if and else aren't folded to min, etc.
+
+(module
+  (func (export "f32.no_fold_lt_if") (param $x f32) (param $y f32) (result f32)
+    (if (result f32) (f32.lt (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
+    )
+  )
+  (func (export "f32.no_fold_le_if") (param $x f32) (param $y f32) (result f32)
+    (if (result f32) (f32.le (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
+    )
+  )
+  (func (export "f32.no_fold_gt_if") (param $x f32) (param $y f32) (result f32)
+    (if (result f32) (f32.gt (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
+    )
+  )
+  (func (export "f32.no_fold_ge_if") (param $x f32) (param $y f32) (result f32)
+    (if (result f32) (f32.ge (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
+    )
+  )
+
+  (func (export "f64.no_fold_lt_if") (param $x f64) (param $y f64) (result f64)
+    (if (result f64) (f64.lt (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
+    )
+  )
+  (func (export "f64.no_fold_le_if") (param $x f64) (param $y f64) (result f64)
+    (if (result f64) (f64.le (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
+    )
+  )
+  (func (export "f64.no_fold_gt_if") (param $x f64) (param $y f64) (result f64)
+    (if (result f64) (f64.gt (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
+    )
+  )
+  (func (export "f64.no_fold_ge_if") (param $x f64) (param $y f64) (result f64)
+    (if (result f64) (f64.ge (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
+    )
+  )
+)
+
+(assert_return (invoke "f32.no_fold_lt_if" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_lt_if" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_lt_if" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_lt_if" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_le_if" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_le_if" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_le_if" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_le_if" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_gt_if" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_gt_if" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_gt_if" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_gt_if" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_ge_if" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_ge_if" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_ge_if" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_ge_if" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0))
+(assert_return (invoke "f64.no_fold_lt_if" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_lt_if" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_lt_if" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_lt_if" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_le_if" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_le_if" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_le_if" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_le_if" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_gt_if" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_gt_if" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_gt_if" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_gt_if" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_ge_if" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_ge_if" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_ge_if" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_ge_if" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0))
+
+;; Test that x<0?-x:x, etc. using select aren't folded to abs.
+
+(module
+  (func (export "f32.no_fold_lt_select_to_abs") (param $x f32) (result f32) (select (f32.neg (local.get $x)) (local.get $x) (f32.lt (local.get $x) (f32.const 0.0))))
+  (func (export "f32.no_fold_le_select_to_abs") (param $x f32) (result f32) (select (f32.neg (local.get $x)) (local.get $x) (f32.le (local.get $x) (f32.const -0.0))))
+  (func (export "f32.no_fold_gt_select_to_abs") (param $x f32) (result f32) (select (local.get $x) (f32.neg (local.get $x)) (f32.gt (local.get $x) (f32.const -0.0))))
+  (func (export "f32.no_fold_ge_select_to_abs") (param $x f32) (result f32) (select (local.get $x) (f32.neg (local.get $x)) (f32.ge (local.get $x) (f32.const 0.0))))
+
+  (func (export "f64.no_fold_lt_select_to_abs") (param $x f64) (result f64) (select (f64.neg (local.get $x)) (local.get $x) (f64.lt (local.get $x) (f64.const 0.0))))
+  (func (export "f64.no_fold_le_select_to_abs") (param $x f64) (result f64) (select (f64.neg (local.get $x)) (local.get $x) (f64.le (local.get $x) (f64.const -0.0))))
+  (func (export "f64.no_fold_gt_select_to_abs") (param $x f64) (result f64) (select (local.get $x) (f64.neg (local.get $x)) (f64.gt (local.get $x) (f64.const -0.0))))
+  (func (export "f64.no_fold_ge_select_to_abs") (param $x f64) (result f64) (select (local.get $x) (f64.neg (local.get $x)) (f64.ge (local.get $x) (f64.const 0.0))))
+)
+
+(assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000))
+(assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const -nan)) (f32.const -nan))
+(assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000))
+(assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const -nan)) (f32.const -nan))
+(assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const 0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_gt_select_to_abs" (f32.const nan:0x200000)) (f32.const -nan:0x200000))
+(assert_return (invoke "f32.no_fold_gt_select_to_abs" (f32.const -nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_gt_select_to_abs" (f32.const 0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_gt_select_to_abs" (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_ge_select_to_abs" (f32.const nan:0x200000)) (f32.const -nan:0x200000))
+(assert_return (invoke "f32.no_fold_ge_select_to_abs" (f32.const -nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_ge_select_to_abs" (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_ge_select_to_abs" (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f64.no_fold_lt_select_to_abs" (f64.const nan:0x4000000000000)) (f64.const nan:0x4000000000000))
+(assert_return (invoke "f64.no_fold_lt_select_to_abs" (f64.const -nan)) (f64.const -nan))
+(assert_return (invoke "f64.no_fold_lt_select_to_abs" (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_lt_select_to_abs" (f64.const -0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_le_select_to_abs" (f64.const nan:0x4000000000000)) (f64.const nan:0x4000000000000))
+(assert_return (invoke "f64.no_fold_le_select_to_abs" (f64.const -nan)) (f64.const -nan))
+(assert_return (invoke "f64.no_fold_le_select_to_abs" (f64.const 0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_le_select_to_abs" (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_gt_select_to_abs" (f64.const nan:0x4000000000000)) (f64.const -nan:0x4000000000000))
+(assert_return (invoke "f64.no_fold_gt_select_to_abs" (f64.const -nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_gt_select_to_abs" (f64.const 0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_gt_select_to_abs" (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_ge_select_to_abs" (f64.const nan:0x4000000000000)) (f64.const -nan:0x4000000000000))
+(assert_return (invoke "f64.no_fold_ge_select_to_abs" (f64.const -nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_ge_select_to_abs" (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_ge_select_to_abs" (f64.const -0.0)) (f64.const -0.0))
+
+;; Test that x<0?-x:x, etc. using if aren't folded to abs.
+
+(module
+  (func (export "f32.no_fold_lt_if_to_abs") (param $x f32) (result f32)
+    (if (result f32) (f32.lt (local.get $x) (f32.const 0.0))
+      (then (f32.neg (local.get $x))) (else (local.get $x))
+    )
+  )
+  (func (export "f32.no_fold_le_if_to_abs") (param $x f32) (result f32)
+    (if (result f32) (f32.le (local.get $x) (f32.const -0.0))
+      (then (f32.neg (local.get $x))) (else (local.get $x))
+    )
+  )
+  (func (export "f32.no_fold_gt_if_to_abs") (param $x f32) (result f32)
+    (if (result f32) (f32.gt (local.get $x) (f32.const -0.0))
+      (then (local.get $x)) (else (f32.neg (local.get $x)))
+    )
+  )
+  (func (export "f32.no_fold_ge_if_to_abs") (param $x f32) (result f32)
+    (if (result f32) (f32.ge (local.get $x) (f32.const 0.0))
+      (then (local.get $x)) (else (f32.neg (local.get $x)))
+    )
+  )
+
+  (func (export "f64.no_fold_lt_if_to_abs") (param $x f64) (result f64)
+    (if (result f64) (f64.lt (local.get $x) (f64.const 0.0))
+      (then (f64.neg (local.get $x))) (else (local.get $x))
+    )
+  )
+  (func (export "f64.no_fold_le_if_to_abs") (param $x f64) (result f64)
+    (if (result f64) (f64.le (local.get $x) (f64.const -0.0))
+      (then (f64.neg (local.get $x))) (else (local.get $x))
+    )
+  )
+  (func (export "f64.no_fold_gt_if_to_abs") (param $x f64) (result f64)
+    (if (result f64) (f64.gt (local.get $x) (f64.const -0.0))
+      (then (local.get $x)) (else (f64.neg (local.get $x)))
+    )
+  )
+  (func (export "f64.no_fold_ge_if_to_abs") (param $x f64) (result f64)
+    (if (result f64) (f64.ge (local.get $x) (f64.const 0.0))
+      (then (local.get $x)) (else (f64.neg (local.get $x)))
+    )
+  )
+)
+
+(assert_return (invoke "f32.no_fold_lt_if_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000))
+(assert_return (invoke "f32.no_fold_lt_if_to_abs" (f32.const -nan)) (f32.const -nan))
+(assert_return (invoke "f32.no_fold_lt_if_to_abs" (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_lt_if_to_abs" (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_le_if_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000))
+(assert_return (invoke "f32.no_fold_le_if_to_abs" (f32.const -nan)) (f32.const -nan))
+(assert_return (invoke "f32.no_fold_le_if_to_abs" (f32.const 0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_le_if_to_abs" (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_gt_if_to_abs" (f32.const nan:0x200000)) (f32.const -nan:0x200000))
+(assert_return (invoke "f32.no_fold_gt_if_to_abs" (f32.const -nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_gt_if_to_abs" (f32.const 0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_gt_if_to_abs" (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_ge_if_to_abs" (f32.const nan:0x200000)) (f32.const -nan:0x200000))
+(assert_return (invoke "f32.no_fold_ge_if_to_abs" (f32.const -nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_ge_if_to_abs" (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_ge_if_to_abs" (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f64.no_fold_lt_if_to_abs" (f64.const nan:0x4000000000000)) (f64.const nan:0x4000000000000))
+(assert_return (invoke "f64.no_fold_lt_if_to_abs" (f64.const -nan)) (f64.const -nan))
+(assert_return (invoke "f64.no_fold_lt_if_to_abs" (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_lt_if_to_abs" (f64.const -0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_le_if_to_abs" (f64.const nan:0x4000000000000)) (f64.const nan:0x4000000000000))
+(assert_return (invoke "f64.no_fold_le_if_to_abs" (f64.const -nan)) (f64.const -nan))
+(assert_return (invoke "f64.no_fold_le_if_to_abs" (f64.const 0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_le_if_to_abs" (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_gt_if_to_abs" (f64.const nan:0x4000000000000)) (f64.const -nan:0x4000000000000))
+(assert_return (invoke "f64.no_fold_gt_if_to_abs" (f64.const -nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_gt_if_to_abs" (f64.const 0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_gt_if_to_abs" (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_ge_if_to_abs" (f64.const nan:0x4000000000000)) (f64.const -nan:0x4000000000000))
+(assert_return (invoke "f64.no_fold_ge_if_to_abs" (f64.const -nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_ge_if_to_abs" (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_ge_if_to_abs" (f64.const -0.0)) (f64.const -0.0))
+
+;; Test for a historic spreadsheet bug.
+;; https://support.microsoft.com/en-us/kb/78113
+
+(module
+  (func (export "f32.incorrect_correction") (result f32)
+    (f32.sub (f32.sub (f32.add (f32.const 1.333) (f32.const 1.225)) (f32.const 1.333)) (f32.const 1.225))
+  )
+  (func (export "f64.incorrect_correction") (result f64)
+    (f64.sub (f64.sub (f64.add (f64.const 1.333) (f64.const 1.225)) (f64.const 1.333)) (f64.const 1.225))
+  )
+)
+
+(assert_return (invoke "f32.incorrect_correction") (f32.const 0x1p-23))
+(assert_return (invoke "f64.incorrect_correction") (f64.const -0x1p-52))
+
+;; Test for a historical calculator bug.
+;; http://www.hpmuseum.org/cgi-sys/cgiwrap/hpmuseum/articles.cgi?read=735
+
+(module
+  (func (export "calculate") (result f32)
+    (local $x f32)
+    (local $r f32)
+    (local $q f32)
+    (local $z0 f32)
+    (local $z1 f32)
+    (local.set $x (f32.const 156.25))
+    (local.set $r (f32.const 208.333333334))
+    (local.set $q (f32.const 1.77951304201))
+    (local.set $z0 (f32.div (f32.mul (f32.neg (local.get $r)) (local.get $x)) (f32.sub (f32.mul (local.get $x) (local.get $q)) (local.get $r))))
+    (local.set $z1 (f32.div (f32.mul (f32.neg (local.get $r)) (local.get $x)) (f32.sub (f32.mul (local.get $x) (local.get $q)) (local.get $r))))
+    (block (br_if 0 (f32.eq (local.get $z0) (local.get $z1))) (unreachable))
+    (local.get $z1)
+  )
+)
+
+(assert_return (invoke "calculate") (f32.const -0x1.d2ed46p+8))
+
+(module
+  (func (export "calculate") (result f64)
+    (local $x f64)
+    (local $r f64)
+    (local $q f64)
+    (local $z0 f64)
+    (local $z1 f64)
+    (local.set $x (f64.const 156.25))
+    (local.set $r (f64.const 208.333333334))
+    (local.set $q (f64.const 1.77951304201))
+    (local.set $z0 (f64.div (f64.mul (f64.neg (local.get $r)) (local.get $x)) (f64.sub (f64.mul (local.get $x) (local.get $q)) (local.get $r))))
+    (local.set $z1 (f64.div (f64.mul (f64.neg (local.get $r)) (local.get $x)) (f64.sub (f64.mul (local.get $x) (local.get $q)) (local.get $r))))
+    (block (br_if 0 (f64.eq (local.get $z0) (local.get $z1))) (unreachable))
+    (local.get $z1)
+  )
+)
+
+(assert_return (invoke "calculate") (f64.const -0x1.d2ed4d0218c93p+8))
+
+;; Test that 0 - (-0 - x) is not optimized to x.
+;; https://llvm.org/bugs/show_bug.cgi?id=26746
+
+(module
+  (func (export "llvm_pr26746") (param $x f32) (result f32)
+    (f32.sub (f32.const 0.0) (f32.sub (f32.const -0.0) (local.get $x)))
+  )
+)
+
+(assert_return (invoke "llvm_pr26746" (f32.const -0.0)) (f32.const 0.0))
+
+;; Test for improperly reassociating an addition and a conversion.
+;; https://llvm.org/bugs/show_bug.cgi?id=27153
+
+(module
+  (func (export "llvm_pr27153") (param $x i32) (result f32)
+    (f32.add (f32.convert_i32_s (i32.and (local.get $x) (i32.const 268435455))) (f32.const -8388608.0))
+  )
+)
+
+(assert_return (invoke "llvm_pr27153" (i32.const 33554434)) (f32.const 25165824.000000))
+
+;; Test that (float)x + (float)y is not optimized to (float)(x + y) when unsafe.
+;; https://llvm.org/bugs/show_bug.cgi?id=27036
+
+(module
+  (func (export "llvm_pr27036") (param $x i32) (param $y i32) (result f32)
+    (f32.add (f32.convert_i32_s (i32.or (local.get $x) (i32.const -25034805)))
+             (f32.convert_i32_s (i32.and (local.get $y) (i32.const 14942208))))
+  )
+)
+
+(assert_return (invoke "llvm_pr27036" (i32.const -25034805) (i32.const 14942208)) (f32.const -0x1.340068p+23))
+
+;; Test for bugs in old versions of historic IEEE 754 platforms as reported in:
+;;
+;; N. L. Schryer. 1981. A Test of a Computer's Floating-Point Arithmetic Unit.
+;; Tech. Rep. Computer Science Technical Report 89, AT&T Bell Laboratories, Feb.
+;;
+;; specifically, the appendices describing IEEE systems with "The Past" sections
+;; describing specific bugs. The 0 < 0 bug is omitted here due to being already
+;; covered elsewhere.
+(module
+  (func (export "thepast0") (param $a f64) (param $b f64) (param $c f64) (param $d f64) (result f64)
+    (f64.div (f64.mul (local.get $a) (local.get $b)) (f64.mul (local.get $c) (local.get $d)))
+  )
+
+  (func (export "thepast1") (param $a f64) (param $b f64) (param $c f64) (result f64)
+    (f64.sub (f64.mul (local.get $a) (local.get $b)) (local.get $c))
+  )
+
+  (func (export "thepast2") (param $a f32) (param $b f32) (param $c f32) (result f32)
+    (f32.mul (f32.mul (local.get $a) (local.get $b)) (local.get $c))
+  )
+)
+
+(assert_return (invoke "thepast0" (f64.const 0x1p-1021) (f64.const 0x1.fffffffffffffp-1) (f64.const 0x1p1) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp-1022))
+(assert_return (invoke "thepast1" (f64.const 0x1p-54) (f64.const 0x1.fffffffffffffp-1) (f64.const 0x1p-54)) (f64.const -0x1p-107))
+(assert_return (invoke "thepast2" (f32.const 0x1p-125) (f32.const 0x1p-1) (f32.const 0x1p0)) (f32.const 0x1p-126))
+
+;; Test for floating point tolerances observed in some GPUs.
+;; https://community.amd.com/thread/145582
+
+(module
+  (func (export "inverse") (param $x f32) (result f32)
+    (f32.div (f32.const 1.0) (local.get $x))
+  )
+)
+
+(assert_return (invoke "inverse" (f32.const 96.0)) (f32.const 0x1.555556p-7))
+
+;; Test for incorrect rounding on sqrt(4.0).
+;; http://www.askvg.com/microsoft-windows-calculator-bug/
+
+(module
+  (func (export "f32_sqrt_minus_2") (param $x f32) (result f32)
+    (f32.sub (f32.sqrt (local.get $x)) (f32.const 2.0))
+  )
+
+  (func (export "f64_sqrt_minus_2") (param $x f64) (result f64)
+    (f64.sub (f64.sqrt (local.get $x)) (f64.const 2.0))
+  )
+)
+
+(assert_return (invoke "f32_sqrt_minus_2" (f32.const 4.0)) (f32.const 0.0))
+(assert_return (invoke "f64_sqrt_minus_2" (f64.const 4.0)) (f64.const 0.0))
+
+;; Test that 1.0 / (1.0 / x) is not optimized to x.
+
+(module
+  (func (export "f32.no_fold_recip_recip") (param $x f32) (result f32)
+    (f32.div (f32.const 1.0) (f32.div (f32.const 1.0) (local.get $x))))
+
+  (func (export "f64.no_fold_recip_recip") (param $x f64) (result f64)
+    (f64.div (f64.const 1.0) (f64.div (f64.const 1.0) (local.get $x))))
+)
+
+(assert_return (invoke "f32.no_fold_recip_recip" (f32.const -0x1.e8bf18p+65)) (f32.const -0x1.e8bf16p+65))
+(assert_return (invoke "f32.no_fold_recip_recip" (f32.const 0x1.e24248p-77)) (f32.const 0x1.e24246p-77))
+(assert_return (invoke "f32.no_fold_recip_recip" (f32.const 0x1.caf0e8p-64)) (f32.const 0x1.caf0eap-64))
+(assert_return (invoke "f32.no_fold_recip_recip" (f32.const -0x1.e66982p+4)) (f32.const -0x1.e66984p+4))
+(assert_return (invoke "f32.no_fold_recip_recip" (f32.const 0x1.f99916p+70)) (f32.const 0x1.f99914p+70))
+
+(assert_return (invoke "f32.no_fold_recip_recip" (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "f32.no_fold_recip_recip" (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "f32.no_fold_recip_recip" (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "f32.no_fold_recip_recip" (f32.const inf)) (f32.const inf))
+
+(assert_return (invoke "f64.no_fold_recip_recip" (f64.const -0x1.d81248dda63dp+148)) (f64.const -0x1.d81248dda63d1p+148))
+(assert_return (invoke "f64.no_fold_recip_recip" (f64.const -0x1.f4750312039e3p+66)) (f64.const -0x1.f4750312039e2p+66))
+(assert_return (invoke "f64.no_fold_recip_recip" (f64.const 0x1.fa50630eec7f6p+166)) (f64.const 0x1.fa50630eec7f5p+166))
+(assert_return (invoke "f64.no_fold_recip_recip" (f64.const 0x1.db0598617ba92p-686)) (f64.const 0x1.db0598617ba91p-686))
+(assert_return (invoke "f64.no_fold_recip_recip" (f64.const 0x1.85f1638a0c82bp+902)) (f64.const 0x1.85f1638a0c82ap+902))
+
+(assert_return (invoke "f64.no_fold_recip_recip" (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "f64.no_fold_recip_recip" (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "f64.no_fold_recip_recip" (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "f64.no_fold_recip_recip" (f64.const inf)) (f64.const inf))
+
+;; Test that (x+y) * (x-y) is not optimized to x*x - y*y.
+
+(module
+  (func (export "f32.no_algebraic_factoring") (param $x f32) (param $y f32) (result f32)
+    (f32.mul (f32.add (local.get $x) (local.get $y))
+             (f32.sub (local.get $x) (local.get $y))))
+
+  (func (export "f64.no_algebraic_factoring") (param $x f64) (param $y f64) (result f64)
+    (f64.mul (f64.add (local.get $x) (local.get $y))
+             (f64.sub (local.get $x) (local.get $y))))
+)
+
+(assert_return (invoke "f32.no_algebraic_factoring" (f32.const -0x1.ef678ep-55) (f32.const 0x1.c160b8p-54)) (f32.const -0x1.129402p-107))
+(assert_return (invoke "f32.no_algebraic_factoring" (f32.const -0x1.2d76bcp+24) (f32.const 0x1.f4089cp+24)) (f32.const -0x1.36d89ap+49))
+(assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.7ca2b2p+45) (f32.const -0x1.08513cp+47)) (f32.const -0x1.db10dep+93))
+(assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.7d5e3p+17) (f32.const -0x1.c783b4p+7)) (f32.const 0x1.1c10a6p+35))
+(assert_return (invoke "f32.no_algebraic_factoring" (f32.const -0x1.daf96p+7) (f32.const -0x1.dac6bp+19)) (f32.const -0x1.b8422ep+39))
+
+(assert_return (invoke "f64.no_algebraic_factoring" (f64.const 0x1.e17c0a02ac6b5p-476) (f64.const 0x1.e8f13f1fcdc14p-463)) (f64.const -0x1.d2ec518f62863p-925))
+(assert_return (invoke "f64.no_algebraic_factoring" (f64.const 0x1.971b55a57e3a3p-377) (f64.const 0x1.edeb4233c1b27p-399)) (f64.const 0x1.43b3f69fb258bp-753))
+(assert_return (invoke "f64.no_algebraic_factoring" (f64.const -0x1.c3b9dc02472fap-378) (f64.const -0x1.74e9faebaff14p-369)) (f64.const -0x1.0f9c07e8caa25p-737))
+(assert_return (invoke "f64.no_algebraic_factoring" (f64.const -0x1.afaf4688ed019p+179) (f64.const 0x1.b07171cb49e94p+188)) (f64.const -0x1.6d3f2e2bebcf7p+377))
+(assert_return (invoke "f64.no_algebraic_factoring" (f64.const 0x1.4377a98948f12p+114) (f64.const -0x1.500c05bd24c97p+90)) (f64.const 0x1.98b72dbf7bf72p+228))
+
+;; Test that x*x - y*y is not optimized to (x+y) * (x-y).
+
+(module
+  (func (export "f32.no_algebraic_factoring") (param $x f32) (param $y f32) (result f32)
+    (f32.sub (f32.mul (local.get $x) (local.get $x))
+             (f32.mul (local.get $y) (local.get $y))))
+
+  (func (export "f64.no_algebraic_factoring") (param $x f64) (param $y f64) (result f64)
+    (f64.sub (f64.mul (local.get $x) (local.get $x))
+             (f64.mul (local.get $y) (local.get $y))))
+)
+
+(assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.8e2c14p-46) (f32.const 0x1.bad59ap-39)) (f32.const -0x1.7efe5p-77))
+(assert_return (invoke "f32.no_algebraic_factoring" (f32.const -0x1.7ef192p+41) (f32.const -0x1.db184ap+33)) (f32.const 0x1.1e6932p+83))
+(assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.7eb458p-12) (f32.const -0x1.52c498p-13)) (f32.const 0x1.cc0bc6p-24))
+(assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.2675c6p-44) (f32.const -0x1.edd31ap-46)) (f32.const 0x1.17294cp-88))
+(assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.9a5f92p+51) (f32.const -0x1.2b0098p+52)) (f32.const -0x1.7189a6p+103))
+
+(assert_return (invoke "f64.no_algebraic_factoring" (f64.const 0x1.749a128f18f69p+356) (f64.const -0x1.0bc97ee1354e1p+337)) (f64.const 0x1.0f28115518d74p+713))
+(assert_return (invoke "f64.no_algebraic_factoring" (f64.const -0x1.2dab01b2215eap+309) (f64.const -0x1.e12b288bff2bdp+331)) (f64.const -0x1.c4319ad25d201p+663))
+(assert_return (invoke "f64.no_algebraic_factoring" (f64.const 0x1.3ed898431e102p+42) (f64.const -0x1.c409183fa92e6p+39)) (f64.const 0x1.80a611103c71dp+84))
+(assert_return (invoke "f64.no_algebraic_factoring" (f64.const -0x1.be663e4c0e4b2p+182) (f64.const -0x1.da85703760d25p+166)) (f64.const 0x1.853434f1a2ffep+365))
+(assert_return (invoke "f64.no_algebraic_factoring" (f64.const -0x1.230e09952df1cp-236) (f64.const -0x1.fa2752adfadc9p-237)) (f64.const 0x1.42e43156bd1b8p-474))
+
+;; Test that platforms where SIMD instructions flush subnormals don't implicitly
+;; optimize using SIMD instructions.
+
+(module
+  (memory (data
+    "\01\00\00\00\01\00\00\80\01\00\00\00\01\00\00\80"
+    "\01\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00"
+    "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
+  ))
+
+  (func (export "f32.simple_x4_sum")
+    (param $i i32)
+    (param $j i32)
+    (param $k i32)
+    (local $x0 f32) (local $x1 f32) (local $x2 f32) (local $x3 f32)
+    (local $y0 f32) (local $y1 f32) (local $y2 f32) (local $y3 f32)
+    (local.set $x0 (f32.load offset=0 (local.get $i)))
+    (local.set $x1 (f32.load offset=4 (local.get $i)))
+    (local.set $x2 (f32.load offset=8 (local.get $i)))
+    (local.set $x3 (f32.load offset=12 (local.get $i)))
+    (local.set $y0 (f32.load offset=0 (local.get $j)))
+    (local.set $y1 (f32.load offset=4 (local.get $j)))
+    (local.set $y2 (f32.load offset=8 (local.get $j)))
+    (local.set $y3 (f32.load offset=12 (local.get $j)))
+    (f32.store offset=0 (local.get $k) (f32.add (local.get $x0) (local.get $y0)))
+    (f32.store offset=4 (local.get $k) (f32.add (local.get $x1) (local.get $y1)))
+    (f32.store offset=8 (local.get $k) (f32.add (local.get $x2) (local.get $y2)))
+    (f32.store offset=12 (local.get $k) (f32.add (local.get $x3) (local.get $y3)))
+  )
+
+  (func (export "f32.load")
+    (param $k i32) (result f32)
+    (f32.load (local.get $k))
+  )
+)
+
+(assert_return (invoke "f32.simple_x4_sum" (i32.const 0) (i32.const 16) (i32.const 32)))
+(assert_return (invoke "f32.load" (i32.const 32)) (f32.const 0x1p-148))
+(assert_return (invoke "f32.load" (i32.const 36)) (f32.const 0x0p+0))
+(assert_return (invoke "f32.load" (i32.const 40)) (f32.const 0x1p-149))
+(assert_return (invoke "f32.load" (i32.const 44)) (f32.const -0x1p-149))
+
+(module
+  (memory (data
+    "\01\00\00\00\00\00\00\00\01\00\00\00\00\00\00\80\01\00\00\00\00\00\00\00\01\00\00\00\00\00\00\80"
+    "\01\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
+    "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
+  ))
+
+  (func (export "f64.simple_x4_sum")
+    (param $i i32)
+    (param $j i32)
+    (param $k i32)
+    (local $x0 f64) (local $x1 f64) (local $x2 f64) (local $x3 f64)
+    (local $y0 f64) (local $y1 f64) (local $y2 f64) (local $y3 f64)
+    (local.set $x0 (f64.load offset=0 (local.get $i)))
+    (local.set $x1 (f64.load offset=8 (local.get $i)))
+    (local.set $x2 (f64.load offset=16 (local.get $i)))
+    (local.set $x3 (f64.load offset=24 (local.get $i)))
+    (local.set $y0 (f64.load offset=0 (local.get $j)))
+    (local.set $y1 (f64.load offset=8 (local.get $j)))
+    (local.set $y2 (f64.load offset=16 (local.get $j)))
+    (local.set $y3 (f64.load offset=24 (local.get $j)))
+    (f64.store offset=0 (local.get $k) (f64.add (local.get $x0) (local.get $y0)))
+    (f64.store offset=8 (local.get $k) (f64.add (local.get $x1) (local.get $y1)))
+    (f64.store offset=16 (local.get $k) (f64.add (local.get $x2) (local.get $y2)))
+    (f64.store offset=24 (local.get $k) (f64.add (local.get $x3) (local.get $y3)))
+  )
+
+  (func (export "f64.load")
+    (param $k i32) (result f64)
+    (f64.load (local.get $k))
+  )
+)
+
+(assert_return (invoke "f64.simple_x4_sum" (i32.const 0) (i32.const 32) (i32.const 64)))
+(assert_return (invoke "f64.load" (i32.const 64)) (f64.const 0x0.0000000000001p-1021))
+(assert_return (invoke "f64.load" (i32.const 72)) (f64.const 0x0p+0))
+(assert_return (invoke "f64.load" (i32.const 80)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "f64.load" (i32.const 88)) (f64.const -0x0.0000000000001p-1022))
+
+;; Test that plain summation is not reassociated, and that Kahan summation
+;; isn't optimized into plain summation.
+
+(module
+  (memory (data
+    "\c4\c5\57\24\a5\84\c8\0b\6d\b8\4b\2e\f2\76\17\1c\ca\4a\56\1e\1b\6e\71\22"
+    "\5d\17\1e\6e\bf\cd\14\5c\c7\21\55\51\39\9c\1f\b2\51\f0\a3\93\d7\c1\2c\ae"
+    "\7e\a8\28\3a\01\21\f4\0a\58\93\f8\42\77\9f\83\39\6a\5f\ba\f7\0a\d8\51\6a"
+    "\34\ca\ad\c6\34\0e\d8\26\dc\4c\33\1c\ed\29\90\a8\78\0f\d1\ce\76\31\23\83"
+    "\b8\35\e8\f2\44\b0\d3\a1\fc\bb\32\e1\b0\ba\69\44\09\d6\d9\7d\ff\2e\c0\5a"
+    "\36\14\33\14\3e\a9\fa\87\6d\8b\bc\ce\9d\a7\fd\c4\e9\85\3f\dd\d7\e1\18\a6"
+    "\50\26\72\6e\3f\73\0f\f8\12\93\23\34\61\76\12\48\c0\9b\05\93\eb\ac\86\de"
+    "\94\3e\55\e8\8c\e8\dd\e4\fc\95\47\be\56\03\21\20\4c\e6\bf\7b\f6\7f\d5\ba"
+    "\73\1c\c1\14\8f\c4\27\96\b3\bd\33\ff\78\41\5f\c0\5a\ce\f6\67\6e\73\9a\17"
+    "\66\70\03\f8\ce\27\a3\52\b2\9f\3b\bf\fb\ae\ed\d3\5a\f8\37\57\f0\f5\6e\ef"
+    "\b1\4d\70\3d\54\a7\01\9a\85\08\48\91\f5\9d\0c\60\87\5b\d9\54\1e\51\6d\88"
+    "\8e\08\8c\a5\71\3a\56\08\67\46\8f\8f\13\2a\2c\ec\2c\1f\b4\62\2b\6f\41\0a"
+    "\c4\65\42\a2\31\6b\2c\7d\3e\bb\75\ac\86\97\30\d9\48\cd\9a\1f\56\c4\c6\e4"
+    "\12\c0\9d\fb\ee\02\8c\ce\1c\f2\1e\a1\78\23\db\c4\1e\49\03\d3\71\cc\08\50"
+    "\c5\d8\5c\ed\d5\b5\65\ac\b5\c9\21\d2\c9\29\76\de\f0\30\1a\5b\3c\f2\3b\db"
+    "\3a\39\82\3a\16\08\6f\a8\f1\be\69\69\99\71\a6\05\d3\14\93\2a\16\f2\2f\11"
+    "\c7\7e\20\bb\91\44\ee\f8\e4\01\53\c0\b9\7f\f0\bf\f0\03\9c\6d\b1\df\a2\44"
+    "\01\6d\6b\71\2b\5c\b3\21\19\46\5e\8f\db\91\d3\7c\78\6b\b7\12\00\8f\eb\bd"
+    "\8a\f5\d4\2e\c4\c1\1e\df\73\63\59\47\49\03\0a\b7\cf\24\cf\9c\0e\44\7a\9e"
+    "\14\fb\42\bf\9d\39\30\9e\a0\ab\2f\d1\ae\9e\6a\83\43\e3\55\7d\85\bf\63\8a"
+    "\f8\96\10\1f\fe\6d\e7\22\1b\e1\69\46\8a\44\c8\c8\f9\0c\2b\19\07\a5\02\3e"
+    "\f2\30\10\9a\85\8a\5f\ef\81\45\a0\77\b1\03\10\73\4b\ae\98\9d\47\bf\9a\2d"
+    "\3a\d5\0f\03\66\e3\3d\53\d9\40\ce\1f\6f\32\2f\21\2b\23\21\6c\62\d4\a7\3e"
+    "\a8\ce\28\31\2d\00\3d\67\5e\af\a0\cf\2e\d2\b9\6b\84\eb\69\08\3c\62\36\be"
+    "\12\fd\36\7f\88\3e\ad\bc\0b\c0\41\c4\50\b6\e3\50\31\e8\ce\e2\96\65\55\9c"
+    "\16\46\e6\b0\2d\3a\e8\81\05\b0\bf\34\f7\bc\10\1c\fb\cc\3c\f1\85\97\42\9f"
+    "\eb\14\8d\3c\bf\d7\17\88\49\9d\8b\2b\b2\3a\83\d1\4f\04\9e\a1\0f\ad\08\9d"
+    "\54\af\d1\82\c3\ec\32\2f\02\8f\05\21\2d\a2\b7\e4\f4\6f\2e\81\2b\0b\9c\fc"
+    "\cb\fe\74\02\f9\db\f4\f3\ea\00\a8\ec\d1\99\74\26\dd\d6\34\d5\25\b1\46\dd"
+    "\9c\aa\71\f5\60\b0\88\c8\e0\0b\59\5a\25\4f\29\66\f9\e3\2e\fe\e9\da\e5\18"
+    "\4f\27\62\f4\ce\a4\21\95\74\c7\57\64\27\9a\4c\fd\54\7d\61\ce\c3\ac\87\46"
+    "\9c\fa\ff\09\ca\79\97\67\24\74\ca\d4\21\83\26\25\19\12\37\64\19\e5\65\e0"
+    "\74\75\8e\dd\c8\ef\74\c7\d8\21\2b\79\04\51\46\65\60\03\5d\fa\d8\f4\65\a4"
+    "\9e\5d\23\da\d7\8a\92\80\a4\de\78\3c\f1\57\42\6d\cd\c9\2f\d5\a4\9e\ab\40"
+    "\f4\cb\1b\d7\a3\ca\fc\eb\a7\01\b2\9a\69\4e\46\9b\18\4e\dd\79\a7\aa\a6\52"
+    "\39\1e\ef\30\cc\9b\bd\5b\ee\4c\21\6d\30\00\72\b0\46\5f\08\cf\c5\b9\e0\3e"
+    "\c2\b3\0c\dc\8e\64\de\19\42\79\cf\43\ea\43\5d\8e\88\f7\ab\15\dc\3f\c8\67"
+    "\20\db\b8\64\b1\47\1f\de\f2\cb\3f\59\9f\d8\46\90\dc\ae\2f\22\f9\e2\31\89"
+    "\d9\9c\1c\4c\d3\a9\4a\57\84\9c\9f\ea\2c\3c\ae\3c\c3\1e\8b\e5\4e\17\01\25"
+    "\db\34\46\5f\15\ea\05\0c\7c\d9\45\8c\19\d0\73\8a\96\16\dd\44\f9\05\b7\5b"
+    "\71\b0\e6\21\36\5f\75\89\91\73\75\ab\7d\ae\d3\73\ec\37\c6\ea\55\75\ef\ea"
+    "\ab\8b\7b\11\dc\6d\1a\b2\6a\c4\25\cf\aa\e3\9f\49\49\89\cb\37\9b\0a\a7\01"
+    "\60\70\dc\b7\c8\83\e1\42\f5\be\ad\62\94\ad\8d\a1"
+  ))
+
+  (func (export "f32.kahan_sum") (param $p i32) (param $n i32) (result f32)
+    (local $sum f32)
+    (local $c f32)
+    (local $t f32)
+    (block $exit
+      (loop $top
+        (local.set $t
+          (f32.sub
+            (f32.sub
+              (local.tee $sum
+                (f32.add
+                  (local.get $c)
+                  (local.tee $t
+                    (f32.sub (f32.load (local.get $p)) (local.get $t))
+                  )
+                )
+              )
+              (local.get $c)
+            )
+            (local.get $t)
+          )
+        )
+        (local.set $p (i32.add (local.get $p) (i32.const 4)))
+        (local.set $c (local.get $sum))
+        (br_if $top (local.tee $n (i32.add (local.get $n) (i32.const -1))))
+      )
+    )
+    (local.get $sum)
+  )
+
+  (func (export "f32.plain_sum") (param $p i32) (param $n i32) (result f32)
+    (local $sum f32)
+    (block $exit
+      (loop $top
+        (local.set $sum (f32.add (local.get $sum) (f32.load (local.get $p))))
+        (local.set $p (i32.add (local.get $p) (i32.const 4)))
+        (local.set $n (i32.add (local.get $n) (i32.const -1)))
+        (br_if $top (local.get $n))
+      )
+    )
+    (local.get $sum)
+  )
+)
+
+(assert_return (invoke "f32.kahan_sum" (i32.const 0) (i32.const 256)) (f32.const -0x1.101a1ap+104))
+(assert_return (invoke "f32.plain_sum" (i32.const 0) (i32.const 256)) (f32.const -0x1.a0343ap+103))
+
+(module
+  (memory (data "\13\05\84\42\5d\a2\2c\c6\43\db\55\a9\cd\da\55\e3\73\fc\58\d6\ba\d5\00\fd\83\35\42\88\8b\13\5d\38\4a\47\0d\72\73\a1\1a\ef\c4\45\17\57\d8\c9\46\e0\8d\6c\e1\37\70\c8\83\5b\55\5e\5a\2d\73\1e\56\c8\e1\6d\69\14\78\0a\8a\5a\64\3a\09\c7\a8\87\c5\f0\d3\5d\e6\03\fc\93\be\26\ca\d6\a9\91\60\bd\b0\ed\ae\f7\30\7e\92\3a\6f\a7\59\8e\aa\7d\bf\67\58\2a\54\f8\4e\fe\ed\35\58\a6\51\bf\42\e5\4b\66\27\24\6d\7f\42\2d\28\92\18\ec\08\ae\e7\55\da\b1\a6\65\a5\72\50\47\1b\b8\a9\54\d7\a6\06\5b\0f\42\58\83\8a\17\82\c6\10\43\a0\c0\2e\6d\bc\5a\85\53\72\7f\ad\44\bc\30\3c\55\b2\24\9a\74\3a\9e\e1\d8\0f\70\fc\a9\3a\cd\93\4b\ec\e3\7e\dd\5d\27\cd\f8\a0\9d\1c\11\c0\57\2e\fd\c8\13\32\cc\3a\1a\7d\a3\41\55\ed\c3\82\49\2a\04\1e\ef\73\b9\2e\2e\e3\5f\f4\df\e6\b2\33\0c\39\3f\6f\44\6a\03\c1\42\b9\fa\b1\c8\ed\a5\58\99\7f\ed\b4\72\9e\79\eb\fb\43\82\45\aa\bb\95\d2\ff\28\9e\f6\a1\ad\95\d6\55\95\0d\6f\60\11\c7\78\3e\49\f2\7e\48\f4\a2\71\d0\13\8e\b3\de\99\52\e3\45\74\ea\76\0e\1b\2a\c8\ee\14\01\c4\50\5b\36\3c\ef\ba\72\a2\a6\08\f8\7b\36\9d\f9\ef\0b\c7\56\2d\5c\f0\9d\5d\de\fc\b8\ad\0f\64\0e\97\15\32\26\c2\31\e6\05\1e\ef\cb\17\1b\6d\15\0b\74\5d\d3\2e\f8\6b\86\b4\ba\73\52\53\99\a9\76\20\45\c9\40\80\6b\14\ed\a1\fa\80\46\e6\26\d2\e6\98\c4\57\bf\c4\1c\a4\90\7a\36\94\14\ba\15\89\6e\e6\9c\37\8c\f4\de\12\22\5d\a1\79\50\67\0d\3d\7a\e9\d4\aa\2e\7f\2a\7a\30\3d\ea\5d\12\48\fe\e1\18\cd\a4\57\a2\87\3e\b6\9a\8b\db\da\9d\78\9c\cf\8d\b1\4f\90\b4\34\e0\9d\f6\ca\fe\4c\3b\78\6d\0a\5c\18\9f\61\b9\dd\b4\e0\0f\76\e0\1b\69\0d\5e\58\73\70\5e\0e\2d\a1\7d\ff\20\eb\91\34\92\ac\38\72\2a\1f\8e\71\2e\6a\f1\af\c7\27\70\d9\c4\57\f7\d2\3c\1d\b8\f0\f0\64\cf\dc\ae\be\a3\cc\3e\22\7d\4e\69\21\63\17\ed\03\02\54\9a\0f\50\4e\13\5a\35\a1\22\a4\df\86\c2\74\79\16\b8\69\69\a0\52\5d\11\64\bd\5b\93\fc\69\a0\f4\13\d0\81\51\dd\fa\0c\15\c3\7a\c9\62\7a\a9\1d\c9\e6\5a\b3\5b\97\02\3c\64\22\12\3c\22\90\64\2d\30\54\4c\b4\a1\22\09\57\22\5e\8e\38\2b\02\a8\ae\f6\be\0d\2b\f2\03\ad\fa\10\01\71\77\2a\30\02\95\f6\00\3e\d0\c4\8d\34\19\50\21\0a\bc\50\da\3c\30\d6\3a\31\94\8d\3a\fe\ef\14\57\9d\4b\93\00\96\24\0c\6f\fd\bc\23\76\02\6c\eb\52\72\80\11\7e\80\3a\13\12\38\1d\38\49\95\40\27\8a\44\7b\e8\dc\6d\8c\8c\8e\3c\b5\b3\18\0e\f6\08\1a\84\41\35\ff\8b\b8\93\40\ea\e1\51\1d\89\a5\8d\42\68\29\ea\2f\c1\7a\52\eb\90\5d\4d\d6\80\e3\d7\75\48\ce\ed\d3\01\1c\8d\5b\a5\94\0d\78\cf\f1\06\13\2f\98\02\a4\6d\2e\6c\f2\d5\74\29\89\4c\f9\03\f5\c7\18\ad\7a\f0\68\f8\5c\d6\59\87\6e\d6\3f\06\be\86\20\e3\41\91\22\f3\6e\8b\f0\68\1c\57\a7\fc\b0\7c\9e\99\0b\96\1a\89\5f\e6\0d\7c\08\51\a0\a2\67\9a\47\00\93\6b\f9\28\f0\68\db\62\f1\e0\65\2c\53\33\e0\a7\ca\11\42\30\f6\af\01\c1\65\3d\32\01\6f\ab\2e\be\d3\8b\be\14\c3\ff\ec\fb\f0\f9\c5\0c\05\6f\01\09\6b\e3\34\31\0c\1f\66\a6\42\bc\1a\87\49\16\16\8c\b0\90\0d\34\8c\0a\e1\09\5e\10\a4\6b\56\cc\f0\c9\bb\dc\b8\5c\ce\f6\cc\8d\75\7e\b3\07\88\04\2f\b4\5e\c9\e3\4a\23\73\19\62\6c\9a\03\76\44\86\9c\60\fc\db\72\8f\27\a0\dd\b3\c5\da\ff\f9\ec\6a\b1\7b\d3\cf\50\37\c9\7a\78\0c\e4\3a\b6\f5\e6\f4\98\6e\42\7d\35\73\8b\45\c0\56\97\cd\6d\ce\cf\ad\31\b3\c3\54\fa\ef\d5\c0\f4\6a\5f\54\e7\49\3e\33\0a\30\38\fd\d9\05\ff\a5\3f\57\46\14\b5\91\17\ca\6b\98\23\7a\65\b3\6c\02\b4\cc\79\5d\58\d8\b3\d5\94\ae\f4\6d\75\65\f7\92\bf\7e\47\4c\3c\ee\db\ac\f1\32\5d\fb\6f\41\1c\34\c8\83\4f\c2\58\01\be\05\3e\66\16\a6\04\6d\5d\4f\86\09\27\82\25\12\cd\3a\cd\ce\6b\bc\ca\ac\28\9b\ee\6a\25\86\9e\45\70\c6\d2\bd\3b\7d\42\e5\27\af\c7\1d\f4\81\c8\b3\76\8a\a8\36\a3\ae\2a\e6\18\e1\36\22\ad\f6\25\72\b0\39\8b\01\9a\22\7b\84\c3\2d\5f\72\a4\98\ac\15\70\e7\d4\18\e2\7d\d2\30\7c\33\08\cd\ca\c4\22\85\88\75\81\c6\4a\74\58\8d\e0\e8\ac\c5\ab\75\5a\f4\28\12\f0\18\45\52\f2\97\b2\93\41\6f\8d\7f\db\70\fb\a3\5d\1f\a7\8d\98\20\2b\22\9f\3a\01\b5\8b\1b\d2\cb\14\03\0e\14\14\d2\19\5a\1f\ce\5e\cd\81\79\15\01\ca\de\73\74\8c\56\20\9f\77\2d\25\16\f6\61\51\1d\a4\8e\9b\98\a5\c6\ec\a8\45\57\82\59\78\0d\90\b4\df\51\b0\c3\82\94\cc\b3\53\09\15\6d\96\6c\3a\40\47\b7\4a\7a\05\2f\a1\1e\8c\9d\a0\20\88\fb\52\b7\9f\f3\f3\bb\5f\e7\8a\61\a7\21\b1\ac\fa\09\aa\a4\6c\bc\24\80\ba\2a\e9\65\ff\70\ff\cc\fa\65\87\76\f3\c5\15\ce\cb\e8\42\31\00\0c\91\57\d9\e0\9d\35\54\24\ad\a4\d8\f9\08\67\63\c8\cf\81\dd\90\a2\d7\c4\07\4a\e6\10\6f\67\e7\27\d4\23\59\18\f2\a8\9d\5f\d8\94\30\aa\54\86\4f\87\9d\82\b5\26\ca\a6\96\bf\cf\55\f9\9d\37\01\19\48\43\c5\94\6c\f3\74\97\58\4c\3c\9d\08\e8\04\c2\58\30\76\e1\a0\f8\ea\e9\c5\ae\cf\78\9e\a9\0c\ac\b3\44\42\e0\bc\5d\1b\9c\49\58\4a\1c\19\49\c1\3a\ea\f5\eb\3b\81\a9\4b\70\0c\cc\9e\1a\d3\2f\b7\52\2f\20\3b\eb\64\51\1d\a0\2d\b2\3e\be\13\85\48\92\32\2e\db\5c\a1\e7\8c\45\91\35\01\0a\93\c2\eb\09\ce\f3\d2\22\24\d0\8c\cc\1d\9d\38\c8\4d\e3\82\cc\64\15\06\2d\e7\01\2f\ab\bb\b5\04\4c\92\1c\7a\d6\3f\e8\5f\31\15\0c\dc\e4\31\b4\c4\25\3e\2a\aa\00\9e\c8\e5\21\7a\7f\29\f1\c0\af\1d\5e\e8\63\39\ad\f8\7e\6c\c8\c5\7f\c2\a8\97\27\0a\d9\f4\21\6a\ea\03\09\fb\f7\96\3b\83\79\5f\7c\4b\30\9f\56\35\de\b4\73\d4\95\f0\14\c3\74\2f\0d\a3\1d\4e\8d\31\24\b3\1a\84\85\62\5a\7b\3c\14\39\17\e6\6d\eb\37\c2\00\58\5b\0b\e3\3c\8a\62\e1\f8\35\4b\56\e2\87\60\8b\be\a7\38\91\77\54\a9\5a\24\25\90\9f\a5\42\77\f3\5c\39\df\ff\74\07\76\a1\cd\1f\62\0b\81\81\68\af\05\c1\c0\7f\26\ee\c0\91\a3\6a\7d\29\61\45\27\e5\57\88\dc\0d\97\04\1a\33\a9\44\8a\da\02\10\45\3f\8e\55\a6\76\8c\4d\e3\f1\89\83\c8\d0\f8\9b\50\77\9f\47\df\4c\9c\66\0d\aa\18\b8\5f\4f\c4\01\ce\dc\84\ac\46\9e\69\e1\76\45\6b\61\89\e4\5d\94\bb\11\83\9f\78\d8\0a\d2\f5\7e\5d\43\ea\bc\10\f1\3a\c9\e2\64\fb\53\65\d0\c7\b4\a7\fb\d4\05\53\25\d0\cd\29\88\00\56\25\24\7d\5d\b4\f3\41\9f\e9\b5\f7\ae\64\2c\e3\c9\6d\d5\84\3a\72\12\b8\7a\d9\1b\09\e8\38\da\26\4f\04\ce\03\71\6e\8a\44\7b\5c\81\59\9c\d2\e4\c3\ba\59\a6\e5\28\a7\8f\9a\e4\d5\4e\b9\ca\7f\cb\75\b8\2b\43\3e\b3\15\46\b1\a5\bc\9d\9e\38\15\f1\bd\1b\21\aa\f1\82\00\95\fc\a7\77\47\39\a7\33\43\92\d7\52\40\4b\06\81\8a\a0\bd\f1\6b\99\84\42\5b\e2\3b\c5\5e\12\5c\28\4d\b6\0e\4e\c8\5c\e8\01\8a\c5\e7\e4\9d\42\ee\5d\9c\c4\eb\eb\68\09\27\92\95\9a\11\54\73\c4\12\80\fb\7d\fe\c5\08\60\7f\36\41\e0\10\ba\d6\2b\6c\f1\b4\17\fe\26\34\e3\4b\f8\a8\e3\91\be\4f\2a\fc\da\81\b8\e7\fe\d5\26\50\47\f3\1a\65\32\81\e0\05\b8\4f\32\31\26\00\4a\53\97\c2\c3\0e\2e\a1\26\54\ab\05\8e\56\2f\7d\af\22\84\68\a5\8b\97\f6\a4\fd\a8\cc\75\41\96\86\fd\27\3d\29\86\8d\7f\4c\d4\8e\73\41\f4\1e\e2\dd\58\27\97\ce\9c\94\cf\7a\04\2f\dc\ed"
+  ))
+
+  (func (export "f64.kahan_sum") (param $p i32) (param $n i32) (result f64)
+    (local $sum f64)
+    (local $c f64)
+    (local $t f64)
+    (block $exit
+      (loop $top
+        (local.set $t
+          (f64.sub
+            (f64.sub
+              (local.tee $sum
+                (f64.add
+                  (local.get $c)
+                  (local.tee $t
+                    (f64.sub (f64.load (local.get $p)) (local.get $t))
+                  )
+                )
+              )
+              (local.get $c)
+            )
+            (local.get $t)
+          )
+        )
+        (local.set $p (i32.add (local.get $p) (i32.const 8)))
+        (local.set $c (local.get $sum))
+        (br_if $top (local.tee $n (i32.add (local.get $n) (i32.const -1))))
+      )
+    )
+    (local.get $sum)
+  )
+
+  (func (export "f64.plain_sum") (param $p i32) (param $n i32) (result f64)
+    (local $sum f64)
+    (block $exit
+      (loop $top
+        (local.set $sum (f64.add (local.get $sum) (f64.load (local.get $p))))
+        (local.set $p (i32.add (local.get $p) (i32.const 8)))
+        (local.set $n (i32.add (local.get $n) (i32.const -1)))
+        (br_if $top (local.get $n))
+      )
+    )
+    (local.get $sum)
+  )
+)
+
+(assert_return (invoke "f64.kahan_sum" (i32.const 0) (i32.const 256)) (f64.const 0x1.dd7cb2a5ffc88p+998))
+(assert_return (invoke "f64.plain_sum" (i32.const 0) (i32.const 256)) (f64.const 0x1.dd7cb2a63fc87p+998))
+
+;; Test that -(x - y) is not folded to y - x.
+
+(module
+  (func (export "f32.no_fold_neg_sub") (param $x f32) (param $y f32) (result f32)
+    (f32.neg (f32.sub (local.get $x) (local.get $y))))
+
+  (func (export "f64.no_fold_neg_sub") (param $x f64) (param $y f64) (result f64)
+    (f64.neg (f64.sub (local.get $x) (local.get $y))))
+)
+
+(assert_return (invoke "f32.no_fold_neg_sub" (f32.const -0.0) (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_neg_sub" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_neg_sub" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_neg_sub" (f32.const 0.0) (f32.const 0.0)) (f32.const -0.0))
+
+(assert_return (invoke "f64.no_fold_neg_sub" (f64.const -0.0) (f64.const -0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_neg_sub" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_neg_sub" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_neg_sub" (f64.const 0.0) (f64.const 0.0)) (f64.const -0.0))
+
+;; Test that -(x + y) is not folded to (-x + -y).
+
+(module
+  (func (export "f32.no_fold_neg_add") (param $x f32) (param $y f32) (result f32)
+    (f32.neg (f32.add (local.get $x) (local.get $y))))
+
+  (func (export "f64.no_fold_neg_add") (param $x f64) (param $y f64) (result f64)
+    (f64.neg (f64.add (local.get $x) (local.get $y))))
+)
+
+(assert_return (invoke "f32.no_fold_neg_add" (f32.const -0.0) (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_neg_add" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_neg_add" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_neg_add" (f32.const 0.0) (f32.const 0.0)) (f32.const -0.0))
+
+(assert_return (invoke "f64.no_fold_neg_add" (f64.const -0.0) (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_neg_add" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_neg_add" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_neg_add" (f64.const 0.0) (f64.const 0.0)) (f64.const -0.0))
+
+;; Test that (-x + -y) is not folded to -(x + y).
+
+(module
+  (func (export "f32.no_fold_add_neg_neg") (param $x f32) (param $y f32) (result f32)
+    (f32.add (f32.neg (local.get $x)) (f32.neg (local.get $y))))
+
+  (func (export "f64.no_fold_add_neg_neg") (param $x f64) (param $y f64) (result f64)
+    (f64.add (f64.neg (local.get $x)) (f64.neg (local.get $y))))
+)
+
+(assert_return (invoke "f32.no_fold_add_neg_neg" (f32.const -0.0) (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_add_neg_neg" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_add_neg_neg" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_add_neg_neg" (f32.const 0.0) (f32.const 0.0)) (f32.const -0.0))
+
+(assert_return (invoke "f64.no_fold_add_neg_neg" (f64.const -0.0) (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_add_neg_neg" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_add_neg_neg" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_add_neg_neg" (f64.const 0.0) (f64.const 0.0)) (f64.const -0.0))
+
+;; Test that -x + x is not folded to 0.0.
+
+(module
+  (func (export "f32.no_fold_add_neg") (param $x f32) (result f32)
+    (f32.add (f32.neg (local.get $x)) (local.get $x)))
+
+  (func (export "f64.no_fold_add_neg") (param $x f64) (result f64)
+    (f64.add (f64.neg (local.get $x)) (local.get $x)))
+)
+
+(assert_return (invoke "f32.no_fold_add_neg" (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_add_neg" (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_add_neg" (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_add_neg" (f32.const -inf)) (f32.const nan:canonical))
+
+(assert_return (invoke "f64.no_fold_add_neg" (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_add_neg" (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_add_neg" (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_add_neg" (f64.const -inf)) (f64.const nan:canonical))
+
+;; Test that x+x+x+x+x+x is not folded to x * 6.
+
+(module
+  (func (export "f32.no_fold_6x_via_add") (param $x f32) (result f32)
+    (f32.add (f32.add (f32.add (f32.add (f32.add
+    (local.get $x)
+    (local.get $x)) (local.get $x)) (local.get $x))
+    (local.get $x)) (local.get $x)))
+
+  (func (export "f64.no_fold_6x_via_add") (param $x f64) (result f64)
+    (f64.add (f64.add (f64.add (f64.add (f64.add
+    (local.get $x)
+    (local.get $x)) (local.get $x)) (local.get $x))
+    (local.get $x)) (local.get $x)))
+)
+
+(assert_return (invoke "f32.no_fold_6x_via_add" (f32.const -0x1.598a0cp+99)) (f32.const -0x1.03278ap+102))
+(assert_return (invoke "f32.no_fold_6x_via_add" (f32.const -0x1.d3e7acp-77)) (f32.const -0x1.5eedc2p-74))
+(assert_return (invoke "f32.no_fold_6x_via_add" (f32.const 0x1.00fa02p-77)) (f32.const 0x1.817702p-75))
+(assert_return (invoke "f32.no_fold_6x_via_add" (f32.const -0x1.51f434p-31)) (f32.const -0x1.faee4cp-29))
+(assert_return (invoke "f32.no_fold_6x_via_add" (f32.const -0x1.00328ap+80)) (f32.const -0x1.804bcep+82))
+
+(assert_return (invoke "f64.no_fold_6x_via_add" (f64.const -0x1.310e15acaffe6p+68)) (f64.const -0x1.c995208307fdap+70))
+(assert_return (invoke "f64.no_fold_6x_via_add" (f64.const -0x1.aad62c78fa9b4p-535)) (f64.const -0x1.4020a15abbf46p-532))
+(assert_return (invoke "f64.no_fold_6x_via_add" (f64.const -0x1.f8fbfa94f6ab2p+271)) (f64.const -0x1.7abcfbefb9005p+274))
+(assert_return (invoke "f64.no_fold_6x_via_add" (f64.const 0x1.756ccc2830a8ep+751)) (f64.const 0x1.1811991e247ebp+754))
+(assert_return (invoke "f64.no_fold_6x_via_add" (f64.const -0x1.8fd1ab1d2402ap+234)) (f64.const -0x1.2bdd4055db01fp+237))
+
+;; Test that (x/y)/z is not optimized to x/(y*z),
+;; which is an "allowable alternative Form" in Fortran.
+
+(module
+  (func (export "f32.no_fold_div_div") (param $x f32) (param $y f32) (param $z f32) (result f32)
+    (f32.div (f32.div (local.get $x) (local.get $y)) (local.get $z)))
+
+  (func (export "f64.no_fold_div_div") (param $x f64) (param $y f64) (param $z f64) (result f64)
+    (f64.div (f64.div (local.get $x) (local.get $y)) (local.get $z)))
+)
+
+(assert_return (invoke "f32.no_fold_div_div" (f32.const -0x1.f70228p+78) (f32.const -0x1.fbc612p-16) (f32.const -0x1.8c379p+10)) (f32.const -0x1.47b43cp+83))
+(assert_return (invoke "f32.no_fold_div_div" (f32.const 0x1.d29d2ep-70) (f32.const 0x1.f3a17ep+110) (f32.const -0x1.64d41p-112)) (f32.const -0x0p+0))
+(assert_return (invoke "f32.no_fold_div_div" (f32.const 0x1.867f98p+43) (f32.const 0x1.30acfcp-105) (f32.const 0x1.e210d8p+105)) (f32.const inf))
+(assert_return (invoke "f32.no_fold_div_div" (f32.const -0x1.c4001ap-14) (f32.const -0x1.9beb6cp+124) (f32.const -0x1.74f34cp-43)) (f32.const -0x1.819874p-96))
+(assert_return (invoke "f32.no_fold_div_div" (f32.const 0x1.db0e6ep+46) (f32.const 0x1.55eea2p+56) (f32.const -0x1.f3134p+124)) (f32.const -0x1.6cep-135))
+
+(assert_return (invoke "f64.no_fold_div_div" (f64.const 0x1.b4dc8ec3c7777p+337) (f64.const 0x1.9f95ac2d1863p+584) (f64.const -0x1.d4318abba341ep-782)) (f64.const -0x1.2649159d87e02p+534))
+(assert_return (invoke "f64.no_fold_div_div" (f64.const -0x1.ac53af5eb445fp+791) (f64.const 0x1.8549c0a4ceb13p-29) (f64.const 0x1.64e384003c801p+316)) (f64.const -0x1.9417cdccbae91p+503))
+(assert_return (invoke "f64.no_fold_div_div" (f64.const -0x1.d2685afb27327p+2) (f64.const -0x1.abb1eeed3dbebp+880) (f64.const 0x1.a543e2e6968a3p+170)) (f64.const 0x0.0000002a69a5fp-1022))
+(assert_return (invoke "f64.no_fold_div_div" (f64.const -0x1.47ddede78ad1cp+825) (f64.const 0x1.6d932d070a367p-821) (f64.const 0x1.79cf18cc64fp+961)) (f64.const -inf))
+(assert_return (invoke "f64.no_fold_div_div" (f64.const -0x1.f73d4979a9379p-888) (f64.const 0x1.4d83b53e97788p-596) (f64.const -0x1.f8f86c9603b5bp-139)) (f64.const 0x1.87a7bd89c586cp-154))
+
+;; Test that (x/y)*(z/w) is not optimized to (x*z)/(y*w), example from
+;; http://perso.ens-lyon.fr/jean-michel.muller/Handbook.html
+;; section 7.4.1: FORTRAN Floating Point in a Nutshell: Philosophy
+
+(module
+  (func (export "f32.no_fold_mul_divs") (param $x f32) (param $y f32) (param $z f32) (param $w f32) (result f32)
+    (f32.mul (f32.div (local.get $x) (local.get $y)) (f32.div (local.get $z) (local.get $w))))
+
+  (func (export "f64.no_fold_mul_divs") (param $x f64) (param $y f64) (param $z f64) (param $w f64) (result f64)
+    (f64.mul (f64.div (local.get $x) (local.get $y)) (f64.div (local.get $z) (local.get $w))))
+)
+
+(assert_return (invoke "f32.no_fold_mul_divs" (f32.const -0x1.c483bep-109) (f32.const 0x1.ee1c3cp-92) (f32.const 0x1.800756p-88) (f32.const -0x1.95b972p+4)) (f32.const 0x1.bbd30cp-110))
+(assert_return (invoke "f32.no_fold_mul_divs" (f32.const -0x1.0f4262p+102) (f32.const 0x1.248498p+25) (f32.const 0x1.f66a7cp-17) (f32.const 0x1.897fc8p-3)) (f32.const -0x1.2f1aa4p+63))
+(assert_return (invoke "f32.no_fold_mul_divs" (f32.const -0x1.df5f22p+33) (f32.const -0x1.fcee3ep+39) (f32.const -0x1.9ea914p+29) (f32.const -0x1.2c4d3p+10)) (f32.const 0x1.4cf51cp+13))
+(assert_return (invoke "f32.no_fold_mul_divs" (f32.const -0x1.f568bcp+109) (f32.const 0x1.d9963p-34) (f32.const 0x1.37a87ap-16) (f32.const 0x1.a1524ap+78)) (f32.const -inf))
+(assert_return (invoke "f32.no_fold_mul_divs" (f32.const 0x1.3dd592p-53) (f32.const -0x1.332c22p-64) (f32.const 0x1.b01064p-91) (f32.const 0x1.92bb3ap-36)) (f32.const -0x1.1c2dbp-44))
+
+(assert_return (invoke "f64.no_fold_mul_divs" (f64.const -0x1.363d6764f7b12p-819) (f64.const -0x1.ed5471f660b5fp-464) (f64.const -0x1.671b0a7f3a42p+547) (f64.const 0x1.0633be34ba1f2p+186)) (f64.const -0x1.b8fa2b76baeebp+5))
+(assert_return (invoke "f64.no_fold_mul_divs" (f64.const -0x1.37880182e0fa8p+115) (f64.const 0x1.f842631576147p-920) (f64.const -0x1.999372231d156p+362) (f64.const -0x1.d5db481ab9554p+467)) (f64.const -inf))
+(assert_return (invoke "f64.no_fold_mul_divs" (f64.const -0x1.9a747c8d4b541p+308) (f64.const -0x1.99092ad6bbdc8p+192) (f64.const -0x1.cb23755c20101p-140) (f64.const -0x1.de8716f6b0b6ap+732)) (f64.const 0x1.ecf584c8466a5p-757))
+(assert_return (invoke "f64.no_fold_mul_divs" (f64.const -0x1.c424b2ece903dp+129) (f64.const -0x1.568ce281db37fp-347) (f64.const 0x1.53900b99fd3dp-957) (f64.const 0x1.5c33952254dadp+223)) (f64.const 0x0p+0))
+(assert_return (invoke "f64.no_fold_mul_divs" (f64.const 0x1.a8ec2cecb32a9p-18) (f64.const 0x1.58acab0051851p-277) (f64.const 0x1.35e87c9077f7fp-620) (f64.const -0x1.925ee37ffb386p+352)) (f64.const -0x1.e6286970b31bfp-714))
+
+;; Test that (x/z)+(y/z) is not optimized to (x+y)/z.
+
+(module
+  (func (export "f32.no_fold_add_divs") (param $x f32) (param $y f32) (param $z f32) (result f32)
+    (f32.add (f32.div (local.get $x) (local.get $z)) (f32.div (local.get $y) (local.get $z))))
+
+  (func (export "f64.no_fold_add_divs") (param $x f64) (param $y f64) (param $z f64) (result f64)
+    (f64.add (f64.div (local.get $x) (local.get $z)) (f64.div (local.get $y) (local.get $z))))
+)
+
+(assert_return (invoke "f32.no_fold_add_divs" (f32.const 0x1.795e7p+8) (f32.const -0x1.48a5eep-5) (f32.const -0x1.9a244cp+126)) (f32.const -0x1.d709b6p-119))
+(assert_return (invoke "f32.no_fold_add_divs" (f32.const -0x1.ae89e8p-63) (f32.const -0x1.e9903ep-49) (f32.const -0x1.370a8cp+47)) (f32.const 0x1.92f3f6p-96))
+(assert_return (invoke "f32.no_fold_add_divs" (f32.const -0x1.626408p-46) (f32.const 0x1.2ee5b2p-64) (f32.const -0x1.ecefaap+48)) (f32.const 0x1.701864p-95))
+(assert_return (invoke "f32.no_fold_add_divs" (f32.const -0x1.061d3p-101) (f32.const 0x1.383492p-98) (f32.const -0x1.1d92d2p+88)) (f32.const 0x0p+0))
+(assert_return (invoke "f32.no_fold_add_divs" (f32.const 0x1.1ea39ep-10) (f32.const 0x1.a7fffep-3) (f32.const 0x1.6fc574p-123)) (f32.const 0x1.28b2dep+120))
+
+(assert_return (invoke "f64.no_fold_add_divs" (f64.const -0x1.c5fcc3273b136p+430) (f64.const 0x1.892a09eed8f6fp+434) (f64.const 0x1.8258b71e64397p+911)) (f64.const 0x1.e36eb9706ad82p-478))
+(assert_return (invoke "f64.no_fold_add_divs" (f64.const -0x1.2215d4061b5b3p+53) (f64.const 0x1.fb6184d97f27cp+5) (f64.const -0x1.f3bb59dacc0ebp-957)) (f64.const 0x1.2934eb0118be3p+1009))
+(assert_return (invoke "f64.no_fold_add_divs" (f64.const -0x1.e7a4533741d8ep-967) (f64.const 0x1.a519bb7feb802p-976) (f64.const 0x1.1f8a43454e51ap+504)) (f64.const 0x0p+0))
+(assert_return (invoke "f64.no_fold_add_divs" (f64.const 0x1.991c6cf93e2b4p+313) (f64.const -0x1.f2f7432698d11p+329) (f64.const 0x1.0d8c1b2453617p-126)) (f64.const -0x1.d9e1d84ddd1d4p+455))
+(assert_return (invoke "f64.no_fold_add_divs" (f64.const -0x1.d436849dc1271p-728) (f64.const 0x1.19d1c1450e52dp-755) (f64.const 0x1.fa1be69ea06fep-70)) (f64.const -0x1.d9a9b1c2f5623p-659))
+
+;; Test that sqrt(x*x) is not optimized to abs(x).
+
+(module
+  (func (export "f32.no_fold_sqrt_square") (param $x f32) (result f32)
+    (f32.sqrt (f32.mul (local.get $x) (local.get $x))))
+
+  (func (export "f64.no_fold_sqrt_square") (param $x f64) (result f64)
+    (f64.sqrt (f64.mul (local.get $x) (local.get $x))))
+)
+
+(assert_return (invoke "f32.no_fold_sqrt_square" (f32.const -0x1.5cb316p-66)) (f32.const 0x1.5cb322p-66))
+(assert_return (invoke "f32.no_fold_sqrt_square" (f32.const -0x1.b0f9e4p-73)) (f32.const 0x1.b211b2p-73))
+(assert_return (invoke "f32.no_fold_sqrt_square" (f32.const -0x1.de417cp-71)) (f32.const 0x1.de65b8p-71))
+(assert_return (invoke "f32.no_fold_sqrt_square" (f32.const 0x1.64c872p-86)) (f32.const 0x0p+0))
+(assert_return (invoke "f32.no_fold_sqrt_square" (f32.const 0x1.e199e4p+108)) (f32.const inf))
+
+(assert_return (invoke "f64.no_fold_sqrt_square" (f64.const 0x1.1759d657203fdp-529)) (f64.const 0x1.1759dd57545f3p-529))
+(assert_return (invoke "f64.no_fold_sqrt_square" (f64.const -0x1.4c68de1c78d83p-514)) (f64.const 0x1.4c68de1c78d81p-514))
+(assert_return (invoke "f64.no_fold_sqrt_square" (f64.const -0x1.214736edb6e1ep-521)) (f64.const 0x1.214736ed9cf8dp-521))
+(assert_return (invoke "f64.no_fold_sqrt_square" (f64.const -0x1.0864b9f68457p-616)) (f64.const 0x0p+0))
+(assert_return (invoke "f64.no_fold_sqrt_square" (f64.const 0x1.b2a9855995abap+856)) (f64.const inf))
+
+;; Test that sqrt(x)*sqrt(y) is not optimized to sqrt(x*y).
+
+(module
+  (func (export "f32.no_fold_mul_sqrts") (param $x f32) (param $y f32) (result f32)
+    (f32.mul (f32.sqrt (local.get $x)) (f32.sqrt (local.get $y))))
+
+  (func (export "f64.no_fold_mul_sqrts") (param $x f64) (param $y f64) (result f64)
+    (f64.mul (f64.sqrt (local.get $x)) (f64.sqrt (local.get $y))))
+)
+
+(assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.dddda8p-125) (f32.const -0x1.25d22ap-83)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.418d14p-92) (f32.const 0x1.c6535cp-32)) (f32.const 0x1.7e373ap-62))
+(assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.4de7ep-88) (f32.const 0x1.84ff18p+6)) (f32.const 0x1.686668p-41))
+(assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.78091ep+101) (f32.const 0x1.81feb8p-9)) (f32.const 0x1.7cfb98p+46))
+(assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.583ap-56) (f32.const 0x1.14ba2ap-9)) (f32.const 0x1.b47a8ep-33))
+
+(assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const -0x1.d1144cc28cdbep-635) (f64.const -0x1.bf9bc373d3b6ap-8)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const 0x1.5a7eb976bebc9p-643) (f64.const 0x1.f30cb8865a4cap-404)) (f64.const 0x1.260a1032d6e76p-523))
+(assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const 0x1.711a0c1707935p-89) (f64.const 0x1.6fb5de51a20d3p-913)) (f64.const 0x1.7067ca28e31ecp-501))
+(assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const 0x1.fb0bbea33b076p-363) (f64.const 0x1.d963b34894158p-573)) (f64.const 0x1.e9edc1fa624afp-468))
+(assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const 0x1.8676eab7a4d0dp+24) (f64.const 0x1.75a58231ba7a5p+513)) (f64.const 0x1.0e16aebe203b3p+269))
+
+;; Test that sqrt(x)/sqrt(y) is not optimized to sqrt(x/y).
+
+(module
+  (func (export "f32.no_fold_div_sqrts") (param $x f32) (param $y f32) (result f32)
+    (f32.div (f32.sqrt (local.get $x)) (f32.sqrt (local.get $y))))
+
+  (func (export "f64.no_fold_div_sqrts") (param $x f64) (param $y f64) (result f64)
+    (f64.div (f64.sqrt (local.get $x)) (f64.sqrt (local.get $y))))
+)
+
+(assert_return (invoke "f32.no_fold_div_sqrts" (f32.const -0x1.bea9bap+25) (f32.const -0x1.db776ep-58)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_sqrts" (f32.const 0x1.b983b6p+32) (f32.const 0x1.901f1ep+27)) (f32.const 0x1.7c4df6p+2))
+(assert_return (invoke "f32.no_fold_div_sqrts" (f32.const 0x1.d45e72p-120) (f32.const 0x1.ab49ccp+15)) (f32.const 0x1.7b0b04p-68))
+(assert_return (invoke "f32.no_fold_div_sqrts" (f32.const 0x1.b2e444p+59) (f32.const 0x1.5b8b16p-30)) (f32.const 0x1.94fca8p+44))
+(assert_return (invoke "f32.no_fold_div_sqrts" (f32.const 0x1.835aa6p-112) (f32.const 0x1.d17128p-103)) (f32.const 0x1.4a468p-5))
+
+(assert_return (invoke "f64.no_fold_div_sqrts" (f64.const -0x1.509fc16411167p-711) (f64.const -0x1.9c4255f5d6517p-187)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_sqrts" (f64.const 0x1.b6897bddac76p-587) (f64.const 0x1.104578b4c91f3p+541)) (f64.const 0x1.44e4f21f26cc9p-564))
+(assert_return (invoke "f64.no_fold_div_sqrts" (f64.const 0x1.ac83451b08989p+523) (f64.const 0x1.8da575c6d12b8p-109)) (f64.const 0x1.09c003991ce17p+316))
+(assert_return (invoke "f64.no_fold_div_sqrts" (f64.const 0x1.bab7836456417p-810) (f64.const 0x1.1ff60d03ba607p+291)) (f64.const 0x1.c0e6c833bf657p-551))
+(assert_return (invoke "f64.no_fold_div_sqrts" (f64.const 0x1.a957816ad9515p-789) (f64.const 0x1.8c18a3a222ab1p+945)) (f64.const 0x1.0948539781e92p-867))
+
+;; Test that (x*sqrt(y))/y is not optimized to x/sqrt(y).
+
+(module
+  (func (export "f32.no_fold_mul_sqrt_div") (param $x f32) (param $y f32) (result f32)
+    (f32.div (f32.mul (local.get $x) (f32.sqrt (local.get $y))) (local.get $y)))
+
+  (func (export "f64.no_fold_mul_sqrt_div") (param $x f64) (param $y f64) (result f64)
+    (f64.div (f64.mul (local.get $x) (f64.sqrt (local.get $y))) (local.get $y)))
+)
+
+(assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const -0x1.f4a7cap+81) (f32.const 0x1.c09adep+92)) (f32.const -inf))
+(assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const -0x1.90bf1cp-120) (f32.const 0x1.8dbe88p-97)) (f32.const -0x0p+0))
+(assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const 0x1.8570e8p+29) (f32.const 0x1.217d3p-128)) (f32.const 0x1.6e391ap+93))
+(assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const -0x1.5b4652p+43) (f32.const 0x1.a9d71cp+112)) (f32.const -0x1.0d423ap-13))
+(assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const -0x1.910604p+8) (f32.const 0x1.0ca912p+7)) (f32.const -0x1.14cdecp+5))
+
+(assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const 0x1.1dcdeb857305fp+698) (f64.const 0x1.a066171c40eb9p+758)) (f64.const inf))
+(assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const -0x1.8b4f1c218e2abp-827) (f64.const 0x1.5e1ee65953b0bp-669)) (f64.const -0x0p+0))
+(assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const 0x1.74ee531ddba38p-425) (f64.const 0x1.f370f758857f3p+560)) (f64.const 0x1.0aff34269583ep-705))
+(assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const -0x1.27f216b0da6c5p+352) (f64.const 0x1.8e0b4e0b9fd7ep-483)) (f64.const -0x1.4fa558aad514ep+593))
+(assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const 0x1.4c6955df9912bp+104) (f64.const 0x1.0cca42c9d371ep+842)) (f64.const 0x1.4468072f54294p-317))
+
+;; Test that subnormals are not flushed even in an intermediate value in an
+;; expression with a normal result.
+
+(module
+  (func (export "f32.no_flush_intermediate_subnormal") (param $x f32) (param $y f32) (param $z f32) (result f32)
+    (f32.mul (f32.mul (local.get $x) (local.get $y)) (local.get $z)))
+
+  (func (export "f64.no_flush_intermediate_subnormal") (param $x f64) (param $y f64) (param $z f64) (result f64)
+    (f64.mul (f64.mul (local.get $x) (local.get $y)) (local.get $z)))
+)
+
+(assert_return (invoke "f32.no_flush_intermediate_subnormal" (f32.const 0x1p-126) (f32.const 0x1p-23) (f32.const 0x1p23)) (f32.const 0x1p-126))
+(assert_return (invoke "f64.no_flush_intermediate_subnormal" (f64.const 0x1p-1022) (f64.const 0x1p-52) (f64.const 0x1p52)) (f64.const 0x1p-1022))
+
+;; Test corner cases of John Hauser's microarchitectural recoding scheme.
+;; https://github.com/riscv/riscv-tests/blob/695b86a6fcbe06ffbed8891af7e6fe7bf2062543/isa/rv64uf/recoding.S
+
+(module
+  (func (export "f32.recoding_eq") (param $x f32) (param $y f32) (result i32)
+    (f32.eq (f32.mul (local.get $x) (local.get $y)) (local.get $x)))
+
+  (func (export "f32.recoding_le") (param $x f32) (param $y f32) (result i32)
+    (f32.le (f32.mul (local.get $x) (local.get $y)) (local.get $x)))
+
+  (func (export "f32.recoding_lt") (param $x f32) (param $y f32) (result i32)
+    (f32.lt (f32.mul (local.get $x) (local.get $y)) (local.get $x)))
+
+  (func (export "f64.recoding_eq") (param $x f64) (param $y f64) (result i32)
+    (f64.eq (f64.mul (local.get $x) (local.get $y)) (local.get $x)))
+
+  (func (export "f64.recoding_le") (param $x f64) (param $y f64) (result i32)
+    (f64.le (f64.mul (local.get $x) (local.get $y)) (local.get $x)))
+
+  (func (export "f64.recoding_lt") (param $x f64) (param $y f64) (result i32)
+    (f64.lt (f64.mul (local.get $x) (local.get $y)) (local.get $x)))
+
+  (func (export "recoding_demote") (param $x f64) (param $y f32) (result f32)
+    (f32.mul (f32.demote_f64 (local.get $x)) (local.get $y)))
+)
+
+(assert_return (invoke "f32.recoding_eq" (f32.const -inf) (f32.const 3.0)) (i32.const 1))
+(assert_return (invoke "f32.recoding_le" (f32.const -inf) (f32.const 3.0)) (i32.const 1))
+(assert_return (invoke "f32.recoding_lt" (f32.const -inf) (f32.const 3.0)) (i32.const 0))
+
+(assert_return (invoke "f32.recoding_eq" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "f32.recoding_le" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "f32.recoding_lt" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 0))
+
+(assert_return (invoke "f64.recoding_eq" (f64.const -inf) (f64.const 3.0)) (i32.const 1))
+(assert_return (invoke "f64.recoding_le" (f64.const -inf) (f64.const 3.0)) (i32.const 1))
+(assert_return (invoke "f64.recoding_lt" (f64.const -inf) (f64.const 3.0)) (i32.const 0))
+
+(assert_return (invoke "f64.recoding_eq" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "f64.recoding_le" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "f64.recoding_lt" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 0))
+
+(assert_return (invoke "recoding_demote" (f64.const 0x1.4c8f8p-132) (f32.const 1221)) (f32.const 0x1.8c8a1cp-122))
+
+;; Test that division is not done as on an extended-base system.
+;; http://www.ucbtest.org/goldberg/addendum.html
+
+(module
+  (func (export "f32.no_extended_precision_div") (param $x f32) (param $y f32) (param $z f32) (result i32)
+    (f32.eq (f32.div (local.get $x) (local.get $y)) (local.get $z)))
+
+  (func (export "f64.no_extended_precision_div") (param $x f64) (param $y f64) (param $z f64) (result i32)
+    (f64.eq (f64.div (local.get $x) (local.get $y)) (local.get $z)))
+)
+
+(assert_return (invoke "f32.no_extended_precision_div" (f32.const 3.0) (f32.const 7.0) (f32.const 0x1.b6db6ep-2)) (i32.const 1))
+(assert_return (invoke "f64.no_extended_precision_div" (f64.const 3.0) (f64.const 7.0) (f64.const 0x1.b6db6db6db6dbp-2)) (i32.const 1))
+
+;; a*x + b*x == (a+b)*x for all x only if the operations a*x, b*x, and (a+b)
+;; are all exact operations, which is true only if a and b are exact powers of
+;; 2. Even then, if a==-b and x==-0, then a*x+b*x==0.0, (a+b)*x==-0.0.
+;; https://dlang.org/d-floating-point.html
+
+(module
+  (func (export "f32.no_distribute_exact") (param $x f32) (result f32)
+    (f32.add (f32.mul (f32.const -8.0) (local.get $x)) (f32.mul (f32.const 8.0) (local.get $x))))
+
+  (func (export "f64.no_distribute_exact") (param $x f64) (result f64)
+    (f64.add (f64.mul (f64.const -8.0) (local.get $x)) (f64.mul (f64.const 8.0) (local.get $x))))
+)
+
+(assert_return (invoke "f32.no_distribute_exact" (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f64.no_distribute_exact" (f64.const -0.0)) (f64.const 0.0))
+
+;; Test that various approximations of sqrt(2), sqrt(3), and sqrt(5) compute the
+;; expected approximation.
+;; https://xkcd.com/1047/
+(module
+  (func (export "f32.sqrt") (param f32) (result f32)
+    (f32.sqrt (local.get 0)))
+
+  (func (export "f32.xkcd_sqrt_2") (param f32) (param f32) (param f32) (param f32) (result f32)
+    (f32.add (f32.div (local.get 0) (local.get 1)) (f32.div (local.get 2) (f32.sub (local.get 3) (local.get 2)))))
+
+  (func (export "f32.xkcd_sqrt_3") (param f32) (param f32) (param f32) (result f32)
+    (f32.div (f32.mul (local.get 0) (local.get 1)) (local.get 2)))
+
+  (func (export "f32.xkcd_sqrt_5") (param f32) (param f32) (param f32) (result f32)
+    (f32.add (f32.div (local.get 0) (local.get 1)) (f32.div (local.get 2) (local.get 0))))
+
+  (func (export "f32.xkcd_better_sqrt_5") (param f32) (param f32) (param f32) (param f32) (result f32)
+    (f32.div (f32.add (local.get 0) (f32.mul (local.get 1) (local.get 2))) (f32.sub (local.get 3) (f32.mul (local.get 1) (local.get 2)))))
+
+  (func (export "f64.sqrt") (param f64) (result f64)
+    (f64.sqrt (local.get 0)))
+
+  (func (export "f64.xkcd_sqrt_2") (param f64) (param f64) (param f64) (param f64) (result f64)
+    (f64.add (f64.div (local.get 0) (local.get 1)) (f64.div (local.get 2) (f64.sub (local.get 3) (local.get 2)))))
+
+  (func (export "f64.xkcd_sqrt_3") (param f64) (param f64) (param f64) (result f64)
+    (f64.div (f64.mul (local.get 0) (local.get 1)) (local.get 2)))
+
+  (func (export "f64.xkcd_sqrt_5") (param f64) (param f64) (param f64) (result f64)
+    (f64.add (f64.div (local.get 0) (local.get 1)) (f64.div (local.get 2) (local.get 0))))
+
+  (func (export "f64.xkcd_better_sqrt_5") (param f64) (param f64) (param f64) (param f64) (result f64)
+    (f64.div (f64.add (local.get 0) (f64.mul (local.get 1) (local.get 2))) (f64.sub (local.get 3) (f64.mul (local.get 1) (local.get 2)))))
+)
+
+(assert_return (invoke "f32.sqrt" (f32.const 2.0)) (f32.const 0x1.6a09e6p+0))
+(assert_return (invoke "f32.xkcd_sqrt_2" (f32.const 3.0) (f32.const 5.0) (f32.const 0x1.921fb6p+1) (f32.const 7.0)) (f32.const 0x1.6a0a54p+0))
+(assert_return (invoke "f32.sqrt" (f32.const 3.0)) (f32.const 0x1.bb67aep+0))
+(assert_return (invoke "f32.xkcd_sqrt_3" (f32.const 2.0) (f32.const 0x1.5bf0a8p+1) (f32.const 0x1.921fb6p+1)) (f32.const 0x1.bb02d4p+0))
+(assert_return (invoke "f32.sqrt" (f32.const 5.0)) (f32.const 0x1.1e377ap+1))
+(assert_return (invoke "f32.xkcd_sqrt_5" (f32.const 2.0) (f32.const 0x1.5bf0a8p+1) (f32.const 3.0)) (f32.const 0x1.1e2d58p+1))
+(assert_return (invoke "f32.xkcd_better_sqrt_5" (f32.const 13.0) (f32.const 4.0) (f32.const 0x1.921fb6p+1) (f32.const 24.0)) (f32.const 0x1.1e377ap+1))
+
+(assert_return (invoke "f64.sqrt" (f64.const 2.0)) (f64.const 0x1.6a09e667f3bcdp+0))
+(assert_return (invoke "f64.xkcd_sqrt_2" (f64.const 3.0) (f64.const 5.0) (f64.const 0x1.921fb54442d18p+1) (f64.const 7.0)) (f64.const 0x1.6a0a5362b055fp+0))
+(assert_return (invoke "f64.sqrt" (f64.const 3.0)) (f64.const 0x1.bb67ae8584caap+0))
+(assert_return (invoke "f64.xkcd_sqrt_3" (f64.const 2.0) (f64.const 0x1.5bf0a8b145769p+1) (f64.const 0x1.921fb54442d18p+1)) (f64.const 0x1.bb02d4eca8f95p+0))
+(assert_return (invoke "f64.sqrt" (f64.const 5.0)) (f64.const 0x1.1e3779b97f4a8p+1))
+(assert_return (invoke "f64.xkcd_sqrt_5" (f64.const 2.0) (f64.const 0x1.5bf0a8b145769p+1) (f64.const 3.0)) (f64.const 0x1.1e2d58d8b3bcep+1))
+(assert_return (invoke "f64.xkcd_better_sqrt_5" (f64.const 13.0) (f64.const 4.0) (f64.const 0x1.921fb54442d18p+1) (f64.const 24.0)) (f64.const 0x1.1e3778509a5a3p+1))
+
+;; Compute the floating-point radix.
+;; M. A. Malcom. Algorithms to reveal properties of floating-point arithmetic.
+;; Communications of the ACM, 15(11):949-951, November 1972.
+(module
+  (func (export "f32.compute_radix") (param $0 f32) (param $1 f32) (result f32)
+    (loop $label$0
+      (br_if $label$0
+        (f32.eq
+          (f32.add
+            (f32.sub
+              (f32.add
+                (local.tee $0 (f32.add (local.get $0) (local.get $0)))
+                (f32.const 1)
+              )
+              (local.get $0)
+            )
+            (f32.const -1)
+          )
+          (f32.const 0)
+        )
+      )
+    )
+    (loop $label$2
+      (br_if $label$2
+        (f32.ne
+          (f32.sub
+            (f32.sub
+              (f32.add
+                (local.get $0)
+                (local.tee $1 (f32.add (local.get $1) (f32.const 1)))
+              )
+              (local.get $0)
+            )
+            (local.get $1)
+          )
+          (f32.const 0)
+        )
+      )
+    )
+    (local.get $1)
+  )
+
+  (func (export "f64.compute_radix") (param $0 f64) (param $1 f64) (result f64)
+    (loop $label$0
+      (br_if $label$0
+        (f64.eq
+          (f64.add
+            (f64.sub
+              (f64.add
+                (local.tee $0 (f64.add (local.get $0) (local.get $0)))
+                (f64.const 1)
+              )
+              (local.get $0)
+            )
+            (f64.const -1)
+          )
+          (f64.const 0)
+        )
+      )
+    )
+    (loop $label$2
+      (br_if $label$2
+        (f64.ne
+          (f64.sub
+            (f64.sub
+              (f64.add
+                (local.get $0)
+                (local.tee $1 (f64.add (local.get $1) (f64.const 1)))
+              )
+              (local.get $0)
+            )
+            (local.get $1)
+          )
+          (f64.const 0)
+        )
+      )
+    )
+    (local.get $1)
+  )
+)
+
+(assert_return (invoke "f32.compute_radix" (f32.const 1.0) (f32.const 1.0)) (f32.const 2.0))
+(assert_return (invoke "f64.compute_radix" (f64.const 1.0) (f64.const 1.0)) (f64.const 2.0))
+
+;; Test that (x - 1) * y + y is not optimized to x * y.
+;; http://blog.frama-c.com/index.php?post/2013/05/14/Contrarianism
+
+(module
+  (func (export "f32.no_fold_sub1_mul_add") (param $x f32) (param $y f32) (result f32)
+    (f32.add (f32.mul (f32.sub (local.get $x) (f32.const 1.0)) (local.get $y)) (local.get $y)))
+
+  (func (export "f64.no_fold_sub1_mul_add") (param $x f64) (param $y f64) (result f64)
+    (f64.add (f64.mul (f64.sub (local.get $x) (f64.const 1.0)) (local.get $y)) (local.get $y)))
+)
+
+(assert_return (invoke "f32.no_fold_sub1_mul_add" (f32.const 0x1p-32) (f32.const 1.0)) (f32.const 0x0p+0))
+(assert_return (invoke "f64.no_fold_sub1_mul_add" (f64.const 0x1p-64) (f64.const 1.0)) (f64.const 0x0p+0))
+
+;; Test that x+z >= y+z is not optimized to x >= y (monotonicity).
+;; http://cs.nyu.edu/courses/spring13/CSCI-UA.0201-003/lecture6.pdf
+
+(module
+  (func (export "f32.no_fold_add_le_monotonicity") (param $x f32) (param $y f32) (param $z f32) (result i32)
+    (f32.le (f32.add (local.get $x) (local.get $z)) (f32.add (local.get $y) (local.get $z))))
+
+  (func (export "f32.no_fold_add_ge_monotonicity") (param $x f32) (param $y f32) (param $z f32) (result i32)
+    (f32.ge (f32.add (local.get $x) (local.get $z)) (f32.add (local.get $y) (local.get $z))))
+
+  (func (export "f64.no_fold_add_le_monotonicity") (param $x f64) (param $y f64) (param $z f64) (result i32)
+    (f64.le (f64.add (local.get $x) (local.get $z)) (f64.add (local.get $y) (local.get $z))))
+
+  (func (export "f64.no_fold_add_ge_monotonicity") (param $x f64) (param $y f64) (param $z f64) (result i32)
+    (f64.ge (f64.add (local.get $x) (local.get $z)) (f64.add (local.get $y) (local.get $z))))
+)
+
+(assert_return (invoke "f32.no_fold_add_le_monotonicity" (f32.const 0.0) (f32.const 0.0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "f32.no_fold_add_le_monotonicity" (f32.const inf) (f32.const -inf) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "f64.no_fold_add_le_monotonicity" (f64.const 0.0) (f64.const 0.0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "f64.no_fold_add_le_monotonicity" (f64.const inf) (f64.const -inf) (f64.const inf)) (i32.const 0))
+
+;; Test that !(x < y) and friends are not optimized to x >= y and friends.
+
+(module
+  (func (export "f32.not_lt") (param $x f32) (param $y f32) (result i32)
+    (i32.eqz (f32.lt (local.get $x) (local.get $y))))
+
+  (func (export "f32.not_le") (param $x f32) (param $y f32) (result i32)
+    (i32.eqz (f32.le (local.get $x) (local.get $y))))
+
+  (func (export "f32.not_gt") (param $x f32) (param $y f32) (result i32)
+    (i32.eqz (f32.gt (local.get $x) (local.get $y))))
+
+  (func (export "f32.not_ge") (param $x f32) (param $y f32) (result i32)
+    (i32.eqz (f32.ge (local.get $x) (local.get $y))))
+
+  (func (export "f64.not_lt") (param $x f64) (param $y f64) (result i32)
+    (i32.eqz (f64.lt (local.get $x) (local.get $y))))
+
+  (func (export "f64.not_le") (param $x f64) (param $y f64) (result i32)
+    (i32.eqz (f64.le (local.get $x) (local.get $y))))
+
+  (func (export "f64.not_gt") (param $x f64) (param $y f64) (result i32)
+    (i32.eqz (f64.gt (local.get $x) (local.get $y))))
+
+  (func (export "f64.not_ge") (param $x f64) (param $y f64) (result i32)
+    (i32.eqz (f64.ge (local.get $x) (local.get $y))))
+)
+
+(assert_return (invoke "f32.not_lt" (f32.const nan) (f32.const 0.0)) (i32.const 1))
+(assert_return (invoke "f32.not_le" (f32.const nan) (f32.const 0.0)) (i32.const 1))
+(assert_return (invoke "f32.not_gt" (f32.const nan) (f32.const 0.0)) (i32.const 1))
+(assert_return (invoke "f32.not_ge" (f32.const nan) (f32.const 0.0)) (i32.const 1))
+(assert_return (invoke "f64.not_lt" (f64.const nan) (f64.const 0.0)) (i32.const 1))
+(assert_return (invoke "f64.not_le" (f64.const nan) (f64.const 0.0)) (i32.const 1))
+(assert_return (invoke "f64.not_gt" (f64.const nan) (f64.const 0.0)) (i32.const 1))
+(assert_return (invoke "f64.not_ge" (f64.const nan) (f64.const 0.0)) (i32.const 1))
+
+;; Test that a method for approximating a "machine epsilon" produces the expected
+;; approximation.
+;; http://blogs.mathworks.com/cleve/2014/07/07/floating-point-numbers/#24cb4f4d-b8a9-4c19-b22b-9d2a9f7f3812
+
+(module
+  (func (export "f32.epsilon") (result f32)
+    (f32.sub (f32.const 1.0) (f32.mul (f32.const 3.0) (f32.sub (f32.div (f32.const 4.0) (f32.const 3.0)) (f32.const 1.0)))))
+
+  (func (export "f64.epsilon") (result f64)
+    (f64.sub (f64.const 1.0) (f64.mul (f64.const 3.0) (f64.sub (f64.div (f64.const 4.0) (f64.const 3.0)) (f64.const 1.0)))))
+)
+
+(assert_return (invoke "f32.epsilon") (f32.const -0x1p-23))
+(assert_return (invoke "f64.epsilon") (f64.const 0x1p-52))
+
+;; Test that a method for computing a "machine epsilon" produces the expected
+;; result.
+;; https://www.math.utah.edu/~beebe/software/ieee/
+
+(module
+  (func (export "f32.epsilon") (result f32)
+    (local $x f32)
+    (local $result f32)
+    (local.set $x (f32.const 1))
+    (loop $loop
+      (br_if $loop
+        (f32.gt
+          (f32.add
+            (local.tee $x
+              (f32.mul
+                (local.tee $result (local.get $x))
+                (f32.const 0.5)
+              )
+            )
+            (f32.const 1)
+          )
+          (f32.const 1)
+        )
+      )
+    )
+    (local.get $result)
+  )
+
+  (func (export "f64.epsilon") (result f64)
+    (local $x f64)
+    (local $result f64)
+    (local.set $x (f64.const 1))
+    (loop $loop
+      (br_if $loop
+        (f64.gt
+          (f64.add
+            (local.tee $x
+              (f64.mul
+                (local.tee $result (local.get $x))
+                (f64.const 0.5)
+              )
+            )
+            (f64.const 1)
+          )
+          (f64.const 1)
+        )
+      )
+    )
+    (local.get $result)
+  )
+)
+
+(assert_return (invoke "f32.epsilon") (f32.const 0x1p-23))
+(assert_return (invoke "f64.epsilon") (f64.const 0x1p-52))
+
+;; Test that floating-point numbers are not optimized as if they form a
+;; trichotomy.
+
+(module
+  (func (export "f32.no_trichotomy_lt") (param $x f32) (param $y f32) (result i32)
+    (i32.or (f32.lt (local.get $x) (local.get $y)) (f32.ge (local.get $x) (local.get $y))))
+  (func (export "f32.no_trichotomy_le") (param $x f32) (param $y f32) (result i32)
+    (i32.or (f32.le (local.get $x) (local.get $y)) (f32.gt (local.get $x) (local.get $y))))
+  (func (export "f32.no_trichotomy_gt") (param $x f32) (param $y f32) (result i32)
+    (i32.or (f32.gt (local.get $x) (local.get $y)) (f32.le (local.get $x) (local.get $y))))
+  (func (export "f32.no_trichotomy_ge") (param $x f32) (param $y f32) (result i32)
+    (i32.or (f32.ge (local.get $x) (local.get $y)) (f32.lt (local.get $x) (local.get $y))))
+
+  (func (export "f64.no_trichotomy_lt") (param $x f64) (param $y f64) (result i32)
+    (i32.or (f64.lt (local.get $x) (local.get $y)) (f64.ge (local.get $x) (local.get $y))))
+  (func (export "f64.no_trichotomy_le") (param $x f64) (param $y f64) (result i32)
+    (i32.or (f64.le (local.get $x) (local.get $y)) (f64.gt (local.get $x) (local.get $y))))
+  (func (export "f64.no_trichotomy_gt") (param $x f64) (param $y f64) (result i32)
+    (i32.or (f64.gt (local.get $x) (local.get $y)) (f64.le (local.get $x) (local.get $y))))
+  (func (export "f64.no_trichotomy_ge") (param $x f64) (param $y f64) (result i32)
+    (i32.or (f64.ge (local.get $x) (local.get $y)) (f64.lt (local.get $x) (local.get $y))))
+)
+
+(assert_return (invoke "f32.no_trichotomy_lt" (f32.const 0.0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "f32.no_trichotomy_le" (f32.const 0.0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "f32.no_trichotomy_gt" (f32.const 0.0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "f32.no_trichotomy_ge" (f32.const 0.0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "f64.no_trichotomy_lt" (f64.const 0.0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "f64.no_trichotomy_le" (f64.const 0.0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "f64.no_trichotomy_gt" (f64.const 0.0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "f64.no_trichotomy_ge" (f64.const 0.0) (f64.const nan)) (i32.const 0))
+
+;; Some test harnesses which can run this testsuite are unable to perform tests
+;; of NaN bitpatterns. The following tests whether the underlying platform is
+;; generally producing the kinds of NaNs expected.
+(module
+  (func (export "f32.arithmetic_nan_bitpattern")
+        (param $x i32) (param $y i32) (result i32)
+    (i32.and (i32.reinterpret_f32
+               (f32.div
+                 (f32.reinterpret_i32 (local.get $x))
+                 (f32.reinterpret_i32 (local.get $y))))
+             (i32.const 0x7fc00000)))
+  (func (export "f32.canonical_nan_bitpattern")
+        (param $x i32) (param $y i32) (result i32)
+    (i32.and (i32.reinterpret_f32
+               (f32.div
+                 (f32.reinterpret_i32 (local.get $x))
+                 (f32.reinterpret_i32 (local.get $y))))
+             (i32.const 0x7fffffff)))
+  (func (export "f32.nonarithmetic_nan_bitpattern")
+        (param $x i32) (result i32)
+    (i32.reinterpret_f32 (f32.neg (f32.reinterpret_i32 (local.get $x)))))
+
+  (func (export "f64.arithmetic_nan_bitpattern")
+        (param $x i64) (param $y i64) (result i64)
+    (i64.and (i64.reinterpret_f64
+               (f64.div
+                 (f64.reinterpret_i64 (local.get $x))
+                 (f64.reinterpret_i64 (local.get $y))))
+             (i64.const 0x7ff8000000000000)))
+  (func (export "f64.canonical_nan_bitpattern")
+        (param $x i64) (param $y i64) (result i64)
+    (i64.and (i64.reinterpret_f64
+               (f64.div
+                 (f64.reinterpret_i64 (local.get $x))
+                 (f64.reinterpret_i64 (local.get $y))))
+             (i64.const 0x7fffffffffffffff)))
+  (func (export "f64.nonarithmetic_nan_bitpattern")
+        (param $x i64) (result i64)
+    (i64.reinterpret_f64 (f64.neg (f64.reinterpret_i64 (local.get $x)))))
+
+  ;; Versions of no_fold testcases that only care about NaN bitpatterns.
+  (func (export "f32.no_fold_sub_zero") (param $x i32) (result i32)
+    (i32.and (i32.reinterpret_f32 (f32.sub (f32.reinterpret_i32 (local.get $x)) (f32.const 0.0)))
+             (i32.const 0x7fc00000)))
+  (func (export "f32.no_fold_neg0_sub") (param $x i32) (result i32)
+    (i32.and (i32.reinterpret_f32 (f32.sub (f32.const -0.0) (f32.reinterpret_i32 (local.get $x))))
+             (i32.const 0x7fc00000)))
+  (func (export "f32.no_fold_mul_one") (param $x i32) (result i32)
+    (i32.and (i32.reinterpret_f32 (f32.mul (f32.reinterpret_i32 (local.get $x)) (f32.const 1.0)))
+             (i32.const 0x7fc00000)))
+  (func (export "f32.no_fold_neg1_mul") (param $x i32) (result i32)
+    (i32.and (i32.reinterpret_f32 (f32.mul (f32.const -1.0) (f32.reinterpret_i32 (local.get $x))))
+             (i32.const 0x7fc00000)))
+  (func (export "f32.no_fold_div_one") (param $x i32) (result i32)
+    (i32.and (i32.reinterpret_f32 (f32.div (f32.reinterpret_i32 (local.get $x)) (f32.const 1.0)))
+             (i32.const 0x7fc00000)))
+  (func (export "f32.no_fold_div_neg1") (param $x i32) (result i32)
+    (i32.and (i32.reinterpret_f32 (f32.div (f32.reinterpret_i32 (local.get $x)) (f32.const -1.0)))
+             (i32.const 0x7fc00000)))
+  (func (export "f64.no_fold_sub_zero") (param $x i64) (result i64)
+    (i64.and (i64.reinterpret_f64 (f64.sub (f64.reinterpret_i64 (local.get $x)) (f64.const 0.0)))
+             (i64.const 0x7ff8000000000000)))
+  (func (export "f64.no_fold_neg0_sub") (param $x i64) (result i64)
+    (i64.and (i64.reinterpret_f64 (f64.sub (f64.const -0.0) (f64.reinterpret_i64 (local.get $x))))
+             (i64.const 0x7ff8000000000000)))
+  (func (export "f64.no_fold_mul_one") (param $x i64) (result i64)
+    (i64.and (i64.reinterpret_f64 (f64.mul (f64.reinterpret_i64 (local.get $x)) (f64.const 1.0)))
+             (i64.const 0x7ff8000000000000)))
+  (func (export "f64.no_fold_neg1_mul") (param $x i64) (result i64)
+    (i64.and (i64.reinterpret_f64 (f64.mul (f64.const -1.0) (f64.reinterpret_i64 (local.get $x))))
+             (i64.const 0x7ff8000000000000)))
+  (func (export "f64.no_fold_div_one") (param $x i64) (result i64)
+    (i64.and (i64.reinterpret_f64 (f64.div (f64.reinterpret_i64 (local.get $x)) (f64.const 1.0)))
+             (i64.const 0x7ff8000000000000)))
+  (func (export "f64.no_fold_div_neg1") (param $x i64) (result i64)
+    (i64.and (i64.reinterpret_f64 (f64.div (f64.reinterpret_i64 (local.get $x)) (f64.const -1.0)))
+             (i64.const 0x7ff8000000000000)))
+  (func (export "no_fold_promote_demote") (param $x i32) (result i32)
+    (i32.and (i32.reinterpret_f32 (f32.demote_f64 (f64.promote_f32 (f32.reinterpret_i32 (local.get $x)))))
+             (i32.const 0x7fc00000)))
+)
+
+(assert_return (invoke "f32.arithmetic_nan_bitpattern" (i32.const 0x7f803210) (i32.const 0x7f803210)) (i32.const 0x7fc00000))
+(assert_return (invoke "f32.canonical_nan_bitpattern" (i32.const 0) (i32.const 0)) (i32.const 0x7fc00000))
+(assert_return (invoke "f32.canonical_nan_bitpattern" (i32.const 0x7fc00000) (i32.const 0x7fc00000)) (i32.const 0x7fc00000))
+(assert_return (invoke "f32.canonical_nan_bitpattern" (i32.const 0xffc00000) (i32.const 0x7fc00000)) (i32.const 0x7fc00000))
+(assert_return (invoke "f32.canonical_nan_bitpattern" (i32.const 0x7fc00000) (i32.const 0xffc00000)) (i32.const 0x7fc00000))
+(assert_return (invoke "f32.canonical_nan_bitpattern" (i32.const 0xffc00000) (i32.const 0xffc00000)) (i32.const 0x7fc00000))
+(assert_return (invoke "f32.nonarithmetic_nan_bitpattern" (i32.const 0x7fc03210)) (i32.const 0xffc03210))
+(assert_return (invoke "f32.nonarithmetic_nan_bitpattern" (i32.const 0xffc03210)) (i32.const 0x7fc03210))
+(assert_return (invoke "f32.nonarithmetic_nan_bitpattern" (i32.const 0x7f803210)) (i32.const 0xff803210))
+(assert_return (invoke "f32.nonarithmetic_nan_bitpattern" (i32.const 0xff803210)) (i32.const 0x7f803210))
+(assert_return (invoke "f64.arithmetic_nan_bitpattern" (i64.const 0x7ff0000000003210) (i64.const 0x7ff0000000003210)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.canonical_nan_bitpattern" (i64.const 0) (i64.const 0)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.canonical_nan_bitpattern" (i64.const 0x7ff8000000000000) (i64.const 0x7ff8000000000000)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.canonical_nan_bitpattern" (i64.const 0xfff8000000000000) (i64.const 0x7ff8000000000000)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.canonical_nan_bitpattern" (i64.const 0x7ff8000000000000) (i64.const 0xfff8000000000000)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.canonical_nan_bitpattern" (i64.const 0xfff8000000000000) (i64.const 0xfff8000000000000)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.nonarithmetic_nan_bitpattern" (i64.const 0x7ff8000000003210)) (i64.const 0xfff8000000003210))
+(assert_return (invoke "f64.nonarithmetic_nan_bitpattern" (i64.const 0xfff8000000003210)) (i64.const 0x7ff8000000003210))
+(assert_return (invoke "f64.nonarithmetic_nan_bitpattern" (i64.const 0x7ff0000000003210)) (i64.const 0xfff0000000003210))
+(assert_return (invoke "f64.nonarithmetic_nan_bitpattern" (i64.const 0xfff0000000003210)) (i64.const 0x7ff0000000003210))
+(assert_return (invoke "f32.no_fold_sub_zero" (i32.const 0x7fa00000)) (i32.const 0x7fc00000))
+(assert_return (invoke "f32.no_fold_neg0_sub" (i32.const 0x7fa00000)) (i32.const 0x7fc00000))
+(assert_return (invoke "f32.no_fold_mul_one" (i32.const 0x7fa00000)) (i32.const 0x7fc00000))
+(assert_return (invoke "f32.no_fold_neg1_mul" (i32.const 0x7fa00000)) (i32.const 0x7fc00000))
+(assert_return (invoke "f32.no_fold_div_one" (i32.const 0x7fa00000)) (i32.const 0x7fc00000))
+(assert_return (invoke "f32.no_fold_div_neg1" (i32.const 0x7fa00000)) (i32.const 0x7fc00000))
+(assert_return (invoke "f64.no_fold_sub_zero" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.no_fold_neg0_sub" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.no_fold_mul_one" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.no_fold_neg1_mul" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.no_fold_div_one" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.no_fold_div_neg1" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "no_fold_promote_demote" (i32.const 0x7fa00000)) (i32.const 0x7fc00000))
+
+;; Test that IEEE 754 double precision does, in fact, compute a certain dot
+;; product correctly.
+
+(module
+  (func (export "dot_product_example")
+        (param $x0 f64) (param $x1 f64) (param $x2 f64) (param $x3 f64)
+        (param $y0 f64) (param $y1 f64) (param $y2 f64) (param $y3 f64)
+        (result f64)
+    (f64.add (f64.add (f64.add
+      (f64.mul (local.get $x0) (local.get $y0))
+      (f64.mul (local.get $x1) (local.get $y1)))
+      (f64.mul (local.get $x2) (local.get $y2)))
+      (f64.mul (local.get $x3) (local.get $y3)))
+  )
+
+  (func (export "with_binary_sum_collapse")
+        (param $x0 f64) (param $x1 f64) (param $x2 f64) (param $x3 f64)
+        (param $y0 f64) (param $y1 f64) (param $y2 f64) (param $y3 f64)
+        (result f64)
+      (f64.add (f64.add (f64.mul (local.get $x0) (local.get $y0))
+                        (f64.mul (local.get $x1) (local.get $y1)))
+               (f64.add (f64.mul (local.get $x2) (local.get $y2))
+                        (f64.mul (local.get $x3) (local.get $y3))))
+  )
+)
+
+(assert_return (invoke "dot_product_example"
+    (f64.const 3.2e7) (f64.const 1.0) (f64.const -1.0) (f64.const 8.0e7)
+    (f64.const 4.0e7) (f64.const 1.0) (f64.const -1.0) (f64.const -1.6e7))
+  (f64.const 2.0))
+(assert_return (invoke "with_binary_sum_collapse"
+    (f64.const 3.2e7) (f64.const 1.0) (f64.const -1.0) (f64.const 8.0e7)
+    (f64.const 4.0e7) (f64.const 1.0) (f64.const -1.0) (f64.const -1.6e7))
+  (f64.const 2.0))
+
+;; http://www.vinc17.org/research/fptest.en.html#contract2fma
+
+(module
+  (func (export "f32.contract2fma")
+        (param $x f32) (param $y f32) (result f32)
+    (f32.sqrt (f32.sub (f32.mul (local.get $x) (local.get $x))
+                       (f32.mul (local.get $y) (local.get $y)))))
+  (func (export "f64.contract2fma")
+        (param $x f64) (param $y f64) (result f64)
+    (f64.sqrt (f64.sub (f64.mul (local.get $x) (local.get $x))
+                       (f64.mul (local.get $y) (local.get $y)))))
+)
+
+(assert_return (invoke "f32.contract2fma" (f32.const 1.0) (f32.const 1.0)) (f32.const 0.0))
+(assert_return (invoke "f32.contract2fma" (f32.const 0x1.19999ap+0) (f32.const 0x1.19999ap+0)) (f32.const 0.0))
+(assert_return (invoke "f32.contract2fma" (f32.const 0x1.333332p+0) (f32.const 0x1.333332p+0)) (f32.const 0.0))
+(assert_return (invoke "f64.contract2fma" (f64.const 1.0) (f64.const 1.0)) (f64.const 0.0))
+(assert_return (invoke "f64.contract2fma" (f64.const 0x1.199999999999ap+0) (f64.const 0x1.199999999999ap+0)) (f64.const 0.0))
+(assert_return (invoke "f64.contract2fma" (f64.const 0x1.3333333333333p+0) (f64.const 0x1.3333333333333p+0)) (f64.const 0.0))
+
+;; Test that floating-point isn't implemented with QuickBasic for MS-DOS.
+;; https://support.microsoft.com/en-us/help/42980/-complete-tutorial-to-understand-ieee-floating-point-errors
+
+(module
+  (func (export "f32.division_by_small_number")
+        (param $a f32) (param $b f32) (param $c f32) (result f32)
+    (f32.sub (local.get $a) (f32.div (local.get $b) (local.get $c))))
+  (func (export "f64.division_by_small_number")
+        (param $a f64) (param $b f64) (param $c f64) (result f64)
+    (f64.sub (local.get $a) (f64.div (local.get $b) (local.get $c))))
+)
+
+(assert_return (invoke "f32.division_by_small_number" (f32.const 112000000) (f32.const 100000) (f32.const 0.0009)) (f32.const 888888))
+(assert_return (invoke "f64.division_by_small_number" (f64.const 112000000) (f64.const 100000) (f64.const 0.0009)) (f64.const 888888.8888888806))
+
+;; Test a simple golden ratio computation.
+;; http://mathworld.wolfram.com/GoldenRatio.html
+
+(module
+  (func (export "f32.golden_ratio") (param $a f32) (param $b f32) (param $c f32) (result f32)
+    (f32.mul (local.get 0) (f32.add (local.get 1) (f32.sqrt (local.get 2)))))
+  (func (export "f64.golden_ratio") (param $a f64) (param $b f64) (param $c f64) (result f64)
+    (f64.mul (local.get 0) (f64.add (local.get 1) (f64.sqrt (local.get 2)))))
+)
+
+(assert_return (invoke "f32.golden_ratio" (f32.const 0.5) (f32.const 1.0) (f32.const 5.0)) (f32.const 1.618034))
+(assert_return (invoke "f64.golden_ratio" (f64.const 0.5) (f64.const 1.0) (f64.const 5.0)) (f64.const 1.618033988749895))
+
+;; Test some silver means computations.
+;; http://mathworld.wolfram.com/SilverRatio.html
+
+(module
+  (func (export "f32.silver_means") (param $n f32) (result f32)
+    (f32.mul (f32.const 0.5)
+             (f32.add (local.get $n)
+                      (f32.sqrt (f32.add (f32.mul (local.get $n) (local.get $n))
+                                         (f32.const 4.0))))))
+  (func (export "f64.silver_means") (param $n f64) (result f64)
+    (f64.mul (f64.const 0.5)
+             (f64.add (local.get $n)
+                      (f64.sqrt (f64.add (f64.mul (local.get $n) (local.get $n))
+                                         (f64.const 4.0))))))
+)
+
+(assert_return (invoke "f32.silver_means" (f32.const 0.0)) (f32.const 1.0))
+(assert_return (invoke "f32.silver_means" (f32.const 1.0)) (f32.const 1.6180340))
+(assert_return (invoke "f32.silver_means" (f32.const 2.0)) (f32.const 2.4142136))
+(assert_return (invoke "f32.silver_means" (f32.const 3.0)) (f32.const 3.3027756))
+(assert_return (invoke "f32.silver_means" (f32.const 4.0)) (f32.const 4.2360680))
+(assert_return (invoke "f32.silver_means" (f32.const 5.0)) (f32.const 5.1925821))
+(assert_return (invoke "f64.silver_means" (f64.const 0.0)) (f64.const 1.0))
+(assert_return (invoke "f64.silver_means" (f64.const 1.0)) (f64.const 1.618033988749895))
+(assert_return (invoke "f64.silver_means" (f64.const 2.0)) (f64.const 2.414213562373095))
+(assert_return (invoke "f64.silver_means" (f64.const 3.0)) (f64.const 3.302775637731995))
+(assert_return (invoke "f64.silver_means" (f64.const 4.0)) (f64.const 4.236067977499790))
+(assert_return (invoke "f64.silver_means" (f64.const 5.0)) (f64.const 5.192582403567252))
+
+;; Test that an f64 0.4 isn't double-rounded as via extended precision.
+;; https://bugs.llvm.org/show_bug.cgi?id=11200
+
+(module
+  (func (export "point_four") (param $four f64) (param $ten f64) (result i32)
+    (f64.lt (f64.div (local.get $four) (local.get $ten)) (f64.const 0.4)))
+)
+
+(assert_return (invoke "point_four" (f64.const 4.0) (f64.const 10.0)) (i32.const 0))
+
+;; Test an approximation function for tau; it should produces the correctly
+;; rounded result after (and only after) the expected number of iterations.
+
+(module
+  (func (export "tau") (param i32) (result f64)
+    (local f64 f64 f64 f64)
+    f64.const 0x0p+0
+    local.set 1
+    block
+      local.get 0
+      i32.const 1
+      i32.lt_s
+      br_if 0
+      f64.const 0x1p+0
+      local.set 2
+      f64.const 0x0p+0
+      local.set 3
+      loop
+        local.get 1
+        local.get 2
+        f64.const 0x1p+3
+        local.get 3
+        f64.const 0x1p+3
+        f64.mul
+        local.tee 4
+        f64.const 0x1p+0
+        f64.add
+        f64.div
+        f64.const 0x1p+2
+        local.get 4
+        f64.const 0x1p+2
+        f64.add
+        f64.div
+        f64.sub
+        f64.const 0x1p+1
+        local.get 4
+        f64.const 0x1.4p+2
+        f64.add
+        f64.div
+        f64.sub
+        f64.const 0x1p+1
+        local.get 4
+        f64.const 0x1.8p+2
+        f64.add
+        f64.div
+        f64.sub
+        f64.mul
+        f64.add
+        local.set 1
+        local.get 3
+        f64.const 0x1p+0
+        f64.add
+        local.set 3
+        local.get 2
+        f64.const 0x1p-4
+        f64.mul
+        local.set 2
+        local.get 0
+        i32.const -1
+        i32.add
+        local.tee 0
+        br_if 0
+      end
+    end
+    local.get 1
+  )
+)
+
+(assert_return (invoke "tau" (i32.const 10)) (f64.const 0x1.921fb54442d14p+2))
+(assert_return (invoke "tau" (i32.const 11)) (f64.const 0x1.921fb54442d18p+2))
+
+;; Test that y < 0 ? x : (x + 1) is not folded to x + (y < 0).
+
+(module
+  (func (export "f32.no_fold_conditional_inc") (param $x f32) (param $y f32) (result f32)
+    (select (local.get $x)
+            (f32.add (local.get $x) (f32.const 1.0))
+            (f32.lt (local.get $y) (f32.const 0.0))))
+  (func (export "f64.no_fold_conditional_inc") (param $x f64) (param $y f64) (result f64)
+    (select (local.get $x)
+            (f64.add (local.get $x) (f64.const 1.0))
+            (f64.lt (local.get $y) (f64.const 0.0))))
+)
+
+(assert_return (invoke "f32.no_fold_conditional_inc" (f32.const -0.0) (f32.const -1.0)) (f32.const -0.0))
+(assert_return (invoke "f64.no_fold_conditional_inc" (f64.const -0.0) (f64.const -1.0)) (f64.const -0.0))
diff --git a/tests/wast/spec/proposals/gc/float_misc.wast b/tests/wast/spec/proposals/gc/float_misc.wast
new file mode 100644
index 0000000000..3d83281d77
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/float_misc.wast
@@ -0,0 +1,678 @@
+;; Platforms intended to run WebAssembly must support IEEE 754 arithmetic.
+;; This testsuite is not currently sufficient for full IEEE 754 conformance
+;; testing; platforms are currently expected to meet these requirements in
+;; their own way (widely-used hardware platforms already do this).
+;;
+;; What this testsuite does test is that (a) the platform is basically IEEE 754
+;; rather than something else entirely, (b) it's configured correctly for
+;; WebAssembly (rounding direction, exception masks, precision level, subnormal
+;; mode, etc.), (c) the WebAssembly implementation doesn't perform any common
+;; value-changing optimizations, and (d) that the WebAssembly implementation
+;; doesn't exhibit any known implementation bugs.
+;;
+;; This file supplements f32.wast, f64.wast, f32_bitwise.wast, f64_bitwise.wast,
+;; f32_cmp.wast, and f64_cmp.wast with additional single-instruction tests
+;; covering additional miscellaneous interesting cases.
+
+(module
+  (func (export "f32.add") (param $x f32) (param $y f32) (result f32) (f32.add (local.get $x) (local.get $y)))
+  (func (export "f32.sub") (param $x f32) (param $y f32) (result f32) (f32.sub (local.get $x) (local.get $y)))
+  (func (export "f32.mul") (param $x f32) (param $y f32) (result f32) (f32.mul (local.get $x) (local.get $y)))
+  (func (export "f32.div") (param $x f32) (param $y f32) (result f32) (f32.div (local.get $x) (local.get $y)))
+  (func (export "f32.sqrt") (param $x f32) (result f32) (f32.sqrt (local.get $x)))
+  (func (export "f32.abs") (param $x f32) (result f32) (f32.abs (local.get $x)))
+  (func (export "f32.neg") (param $x f32) (result f32) (f32.neg (local.get $x)))
+  (func (export "f32.copysign") (param $x f32) (param $y f32) (result f32) (f32.copysign (local.get $x) (local.get $y)))
+  (func (export "f32.ceil") (param $x f32) (result f32) (f32.ceil (local.get $x)))
+  (func (export "f32.floor") (param $x f32) (result f32) (f32.floor (local.get $x)))
+  (func (export "f32.trunc") (param $x f32) (result f32) (f32.trunc (local.get $x)))
+  (func (export "f32.nearest") (param $x f32) (result f32) (f32.nearest (local.get $x)))
+  (func (export "f32.min") (param $x f32) (param $y f32) (result f32) (f32.min (local.get $x) (local.get $y)))
+  (func (export "f32.max") (param $x f32) (param $y f32) (result f32) (f32.max (local.get $x) (local.get $y)))
+
+  (func (export "f64.add") (param $x f64) (param $y f64) (result f64) (f64.add (local.get $x) (local.get $y)))
+  (func (export "f64.sub") (param $x f64) (param $y f64) (result f64) (f64.sub (local.get $x) (local.get $y)))
+  (func (export "f64.mul") (param $x f64) (param $y f64) (result f64) (f64.mul (local.get $x) (local.get $y)))
+  (func (export "f64.div") (param $x f64) (param $y f64) (result f64) (f64.div (local.get $x) (local.get $y)))
+  (func (export "f64.sqrt") (param $x f64) (result f64) (f64.sqrt (local.get $x)))
+  (func (export "f64.abs") (param $x f64) (result f64) (f64.abs (local.get $x)))
+  (func (export "f64.neg") (param $x f64) (result f64) (f64.neg (local.get $x)))
+  (func (export "f64.copysign") (param $x f64) (param $y f64) (result f64) (f64.copysign (local.get $x) (local.get $y)))
+  (func (export "f64.ceil") (param $x f64) (result f64) (f64.ceil (local.get $x)))
+  (func (export "f64.floor") (param $x f64) (result f64) (f64.floor (local.get $x)))
+  (func (export "f64.trunc") (param $x f64) (result f64) (f64.trunc (local.get $x)))
+  (func (export "f64.nearest") (param $x f64) (result f64) (f64.nearest (local.get $x)))
+  (func (export "f64.min") (param $x f64) (param $y f64) (result f64) (f64.min (local.get $x) (local.get $y)))
+  (func (export "f64.max") (param $x f64) (param $y f64) (result f64) (f64.max (local.get $x) (local.get $y)))
+)
+
+;; Miscellaneous values.
+(assert_return (invoke "f32.add" (f32.const 1.1234567890) (f32.const 1.2345e-10)) (f32.const 1.123456789))
+(assert_return (invoke "f64.add" (f64.const 1.1234567890) (f64.const 1.2345e-10)) (f64.const 0x1.1f9add37c11f7p+0))
+
+;; Test adding the greatest value to 1.0 that rounds back to 1.0, and the
+;; least that rounds to something greater.
+(assert_return (invoke "f32.add" (f32.const 1.0) (f32.const 0x1p-24)) (f32.const 0x1.0p+0))
+(assert_return (invoke "f32.add" (f32.const 1.0) (f32.const 0x1.000002p-24)) (f32.const 0x1.000002p+0))
+(assert_return (invoke "f64.add" (f64.const 1.0) (f64.const 0x1p-53)) (f64.const 0x1.0p+0))
+(assert_return (invoke "f64.add" (f64.const 1.0) (f64.const 0x1.0000000000001p-53)) (f64.const 0x1.0000000000001p+0))
+
+;; Max subnormal + min subnormal = min normal.
+(assert_return (invoke "f32.add" (f32.const 0x1p-149) (f32.const 0x1.fffffcp-127)) (f32.const 0x1p-126))
+(assert_return (invoke "f64.add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.fffffffffffffp-1022)) (f64.const 0x1p-1022))
+
+;; Test for a case of double rounding, example from:
+;; http://perso.ens-lyon.fr/jean-michel.muller/Handbook.html
+;; section 3.3.1: A typical problem: "double rounding"
+(assert_return (invoke "f32.add" (f32.const 0x1p+31) (f32.const 1024.25)) (f32.const 0x1.000008p+31))
+(assert_return (invoke "f64.add" (f64.const 0x1p+63) (f64.const 1024.25)) (f64.const 0x1.0000000000001p+63))
+
+;; Test a case that was "tricky" on MMIX.
+;; http://mmix.cs.hm.edu/bugs/bug_rounding.html
+(assert_return (invoke "f64.add" (f64.const -0x1p-1008) (f64.const 0x0.0000000001716p-1022)) (f64.const -0x1.fffffffffffffp-1009))
+
+;; http://www.vinc17.org/software/tst-ieee754.xsl
+(assert_return (invoke "f64.add" (f64.const 9007199254740992) (f64.const 1.00001)) (f64.const 9007199254740994))
+
+;; http://www.vinc17.org/software/test.java
+(assert_return (invoke "f64.add" (f64.const 9007199254740994) (f64.const 0x1.fffep-1)) (f64.const 9007199254740994))
+
+;; Computations that round differently in ties-to-odd mode.
+(assert_return (invoke "f32.add" (f32.const 0x1p23) (f32.const 0x1p-1)) (f32.const 0x1p23))
+(assert_return (invoke "f32.add" (f32.const 0x1.000002p+23) (f32.const 0x1p-1)) (f32.const 0x1.000004p+23))
+(assert_return (invoke "f64.add" (f64.const 0x1p52) (f64.const 0x1p-1)) (f64.const 0x1p52))
+(assert_return (invoke "f64.add" (f64.const 0x1.0000000000001p+52) (f64.const 0x1p-1)) (f64.const 0x1.0000000000002p+52))
+
+;; Computations that round differently in round-upward mode.
+(assert_return (invoke "f32.add" (f32.const -0x1.39675ap+102) (f32.const 0x1.76c94cp-99)) (f32.const -0x1.39675ap+102))
+(assert_return (invoke "f32.add" (f32.const 0x1.6c0f24p+67) (f32.const -0x1.2b92dp+52)) (f32.const 0x1.6c0cccp+67))
+(assert_return (invoke "f32.add" (f32.const 0x1.e62318p-83) (f32.const 0x1.f74abep-125)) (f32.const 0x1.e62318p-83))
+(assert_return (invoke "f32.add" (f32.const 0x1.2a71d4p+39) (f32.const -0x1.c9f10cp+55)) (f32.const -0x1.c9efe2p+55))
+(assert_return (invoke "f32.add" (f32.const 0x1.f8f736p-15) (f32.const 0x1.7bd45ep+106)) (f32.const 0x1.7bd45ep+106))
+(assert_return (invoke "f64.add" (f64.const 0x1.f33e1fbca27aap-413) (f64.const -0x1.6b192891ed61p+249)) (f64.const -0x1.6b192891ed61p+249))
+(assert_return (invoke "f64.add" (f64.const -0x1.46f75d130eeb1p+76) (f64.const 0x1.25275d6f7a4acp-184)) (f64.const -0x1.46f75d130eeb1p+76))
+(assert_return (invoke "f64.add" (f64.const 0x1.04dec9265a731p-148) (f64.const -0x1.11eed4e8c127cp-12)) (f64.const -0x1.11eed4e8c127cp-12))
+(assert_return (invoke "f64.add" (f64.const 0x1.05773b7166b0ap+497) (f64.const 0x1.134022f2da37bp+66)) (f64.const 0x1.05773b7166b0ap+497))
+(assert_return (invoke "f64.add" (f64.const 0x1.ef4f794282a82p+321) (f64.const 0x1.14a82266badep+394)) (f64.const 0x1.14a82266badep+394))
+
+;; Computations that round differently in round-downward mode.
+(assert_return (invoke "f32.add" (f32.const 0x1.1bf976p+72) (f32.const -0x1.7f5868p+20)) (f32.const 0x1.1bf976p+72))
+(assert_return (invoke "f32.add" (f32.const 0x1.7f9c6cp-45) (f32.const -0x1.b9bb0ep-78)) (f32.const 0x1.7f9c6cp-45))
+(assert_return (invoke "f32.add" (f32.const -0x1.32d1bcp-42) (f32.const 0x1.f7d214p+125)) (f32.const 0x1.f7d214p+125))
+(assert_return (invoke "f32.add" (f32.const -0x1.8e5c0ep-44) (f32.const -0x1.3afa4cp-106)) (f32.const -0x1.8e5c0ep-44))
+(assert_return (invoke "f32.add" (f32.const 0x1.13cd78p-10) (f32.const -0x1.3af316p-107)) (f32.const 0x1.13cd78p-10))
+(assert_return (invoke "f64.add" (f64.const 0x1.f8dd15ca97d4ap+179) (f64.const -0x1.367317d1fe8bfp-527)) (f64.const 0x1.f8dd15ca97d4ap+179))
+(assert_return (invoke "f64.add" (f64.const 0x1.5db08d739228cp+155) (f64.const -0x1.fb316fa147dcbp-61)) (f64.const 0x1.5db08d739228cp+155))
+(assert_return (invoke "f64.add" (f64.const 0x1.bbb403cb85c07p-404) (f64.const -0x1.7e44046b8bbf3p-979)) (f64.const 0x1.bbb403cb85c07p-404))
+(assert_return (invoke "f64.add" (f64.const -0x1.34d38af291831p+147) (f64.const -0x1.9890b47439953p+139)) (f64.const -0x1.366c1ba705bcap+147))
+(assert_return (invoke "f64.add" (f64.const -0x1.b61dedf4e0306p+3) (f64.const 0x1.09e2f31773c4ap+290)) (f64.const 0x1.09e2f31773c4ap+290))
+
+;; Computations that round differently in round-toward-zero mode.
+(assert_return (invoke "f32.add" (f32.const -0x1.129bd8p-117) (f32.const 0x1.c75012p-43)) (f32.const 0x1.c75012p-43))
+(assert_return (invoke "f32.add" (f32.const -0x1.c204a2p-16) (f32.const 0x1.80b132p-27)) (f32.const -0x1.c1d48cp-16))
+(assert_return (invoke "f32.add" (f32.const -0x1.decc1cp+36) (f32.const 0x1.c688dap-109)) (f32.const -0x1.decc1cp+36))
+(assert_return (invoke "f32.add" (f32.const 0x1.61ce6ap-118) (f32.const -0x1.772892p+30)) (f32.const -0x1.772892p+30))
+(assert_return (invoke "f32.add" (f32.const -0x1.3dc826p-120) (f32.const 0x1.fc3f66p+95)) (f32.const 0x1.fc3f66p+95))
+(assert_return (invoke "f64.add" (f64.const 0x1.bf68acc263a0fp-777) (f64.const -0x1.5f9352965e5a6p+1004)) (f64.const -0x1.5f9352965e5a6p+1004))
+(assert_return (invoke "f64.add" (f64.const -0x1.76eaa70911f51p+516) (f64.const -0x1.2d746324ce47ap+493)) (f64.const -0x1.76eaa963fabb6p+516))
+(assert_return (invoke "f64.add" (f64.const -0x1.b637d82c15a7ap-967) (f64.const 0x1.cc654ccab4152p-283)) (f64.const 0x1.cc654ccab4152p-283))
+(assert_return (invoke "f64.add" (f64.const -0x1.a5b1fb66e846ep-509) (f64.const 0x1.4bdd36f0bb5ccp-860)) (f64.const -0x1.a5b1fb66e846ep-509))
+(assert_return (invoke "f64.add" (f64.const -0x1.14108da880f9ep+966) (f64.const 0x1.417f35701e89fp+800)) (f64.const -0x1.14108da880f9ep+966))
+
+;; Computations that round differently on x87.
+(assert_return (invoke "f64.add" (f64.const -0x1.fa0caf21ffebcp+804) (f64.const 0x1.4ca8fdcff89f9p+826)) (f64.const 0x1.4ca8f5e7c5e31p+826))
+(assert_return (invoke "f64.add" (f64.const 0x1.016f1fcbdfd38p+784) (f64.const 0x1.375dffcbc9a2cp+746)) (f64.const 0x1.016f1fcbe4b0fp+784))
+(assert_return (invoke "f64.add" (f64.const -0x1.dffda6d5bff3ap+624) (f64.const 0x1.f9e8cc2dff782p+674)) (f64.const 0x1.f9e8cc2dff77bp+674))
+(assert_return (invoke "f64.add" (f64.const 0x1.fff4b43687dfbp+463) (f64.const 0x1.0fd5617c4a809p+517)) (f64.const 0x1.0fd5617c4a809p+517))
+(assert_return (invoke "f64.add" (f64.const 0x1.535d380035da2p-995) (f64.const 0x1.cce37dddbb73bp-963)) (f64.const 0x1.cce37ddf0ed0fp-963))
+
+;; Computations that round differently when computed via f32.
+(assert_return (invoke "f64.add" (f64.const -0x1.d91cd3fc0c66fp+752) (f64.const -0x1.4e18c80229734p+952)) (f64.const -0x1.4e18c80229734p+952))
+(assert_return (invoke "f64.add" (f64.const 0x1.afc70fd36e372p+193) (f64.const -0x1.bd10a9b377b46p+273)) (f64.const -0x1.bd10a9b377b46p+273))
+(assert_return (invoke "f64.add" (f64.const -0x1.2abd570b078b2p+302) (f64.const 0x1.b3c1ad759cb5bp-423)) (f64.const -0x1.2abd570b078b2p+302))
+(assert_return (invoke "f64.add" (f64.const -0x1.5b2ae84c0686cp-317) (f64.const -0x1.dba7a1c022823p+466)) (f64.const -0x1.dba7a1c022823p+466))
+(assert_return (invoke "f64.add" (f64.const -0x1.ac627bd7cbf38p-198) (f64.const 0x1.2312e265b8d59p-990)) (f64.const -0x1.ac627bd7cbf38p-198))
+
+;; Computations that utilize the maximum exponent value to avoid overflow.
+(assert_return (invoke "f32.add" (f32.const 0x1.2b91ap+116) (f32.const 0x1.cbcd52p+127)) (f32.const 0x1.cbf2c4p+127))
+(assert_return (invoke "f32.add" (f32.const 0x1.96f392p+127) (f32.const -0x1.6b3fecp+107)) (f32.const 0x1.96f37cp+127))
+(assert_return (invoke "f32.add" (f32.const 0x1.132f1cp+118) (f32.const -0x1.63d632p+127)) (f32.const -0x1.634c9ap+127))
+(assert_return (invoke "f32.add" (f32.const -0x1.1dda64p+120) (f32.const -0x1.ef02ep+127)) (f32.const -0x1.f13e94p+127))
+(assert_return (invoke "f32.add" (f32.const -0x1.4ad8dap+127) (f32.const -0x1.eae082p+125)) (f32.const -0x1.c590fap+127))
+(assert_return (invoke "f64.add" (f64.const 0x1.017099f2a4b8bp+1023) (f64.const 0x1.1f63b28f05454p+981)) (f64.const 0x1.017099f2a5009p+1023))
+(assert_return (invoke "f64.add" (f64.const 0x1.d88b6c74984efp+1023) (f64.const 0x1.33b444775eabcp+990)) (f64.const 0x1.d88b6c7532291p+1023))
+(assert_return (invoke "f64.add" (f64.const -0x1.84576422fdf5p+1023) (f64.const 0x1.60ee6aa12fb9cp+1012)) (f64.const -0x1.842b4655a9cf1p+1023))
+(assert_return (invoke "f64.add" (f64.const -0x1.9aaace3e79f7dp+1001) (f64.const 0x1.e4068af295cb6p+1023)) (f64.const 0x1.e4068487ea926p+1023))
+(assert_return (invoke "f64.add" (f64.const 0x1.06cdae79f27b9p+1023) (f64.const -0x1.e05cb0c96f975p+991)) (f64.const 0x1.06cdae78121eep+1023))
+
+;; Computations that utilize the minimum exponent value.
+(assert_return (invoke "f32.add" (f32.const 0x1.6a1a2p-127) (f32.const 0x1.378p-140)) (f32.const 0x1.6a23dcp-127))
+(assert_return (invoke "f32.add" (f32.const 0x1.28p-144) (f32.const -0x1p-148)) (f32.const 0x1.18p-144))
+(assert_return (invoke "f32.add" (f32.const -0x1p-146) (f32.const 0x1.c3cap-128)) (f32.const 0x1.c3c9cp-128))
+(assert_return (invoke "f32.add" (f32.const -0x1.4p-145) (f32.const 0x1.424052p-122)) (f32.const 0x1.42405p-122))
+(assert_return (invoke "f32.add" (f32.const 0x1.c5p-141) (f32.const -0x1.72f8p-135)) (f32.const -0x1.6be4p-135))
+(assert_return (invoke "f64.add" (f64.const 0x1.4774c681d1e21p-1022) (f64.const -0x1.271e58e9f58cap-1021)) (f64.const -0x1.06c7eb5219373p-1022))
+(assert_return (invoke "f64.add" (f64.const 0x1.10b3a75e31916p-1021) (f64.const -0x1.ffb82b0e868a7p-1021)) (f64.const -0x1.de090760a9f22p-1022))
+(assert_return (invoke "f64.add" (f64.const -0x0.6b58448b8098ap-1022) (f64.const -0x1.579796ed04cbep-1022)) (f64.const -0x1.c2efdb7885648p-1022))
+(assert_return (invoke "f64.add" (f64.const 0x1.9eb9e7baae8d1p-1020) (f64.const -0x1.d58e136f8c6eep-1020)) (f64.const -0x0.db50aed377874p-1022))
+(assert_return (invoke "f64.add" (f64.const -0x1.f1115deeafa0bp-1022) (f64.const 0x1.221b1c87dca29p-1022)) (f64.const -0x0.cef64166d2fe2p-1022))
+
+;; Test an add of the second-greatest finite value with the distance to greatest
+;; finite value.
+(assert_return (invoke "f32.add" (f32.const 0x1.fffffcp+127) (f32.const 0x1p+104)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "f64.add" (f64.const 0x1.ffffffffffffep+1023) (f64.const 0x1p+971)) (f64.const 0x1.fffffffffffffp+1023))
+
+;; http://news.harvard.edu/gazette/story/2013/09/dawn-of-a-revolution/
+(assert_return (invoke "f32.add" (f32.const 2.0) (f32.const 2.0)) (f32.const 4.0))
+(assert_return (invoke "f64.add" (f64.const 2.0) (f64.const 2.0)) (f64.const 4.0))
+
+;; Test rounding above the greatest finite value.
+(assert_return (invoke "f32.add" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+102)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "f32.add" (f32.const 0x1.fffffep+127) (f32.const 0x1p+103)) (f32.const inf))
+(assert_return (invoke "f64.add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+969)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64.add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+970)) (f64.const inf))
+
+;; Test for a historic spreadsheet bug.
+;; https://blogs.office.com/2007/09/25/calculation-issue-update/
+(assert_return (invoke "f32.sub" (f32.const 65536.0) (f32.const 0x1p-37)) (f32.const 65536.0))
+(assert_return (invoke "f64.sub" (f64.const 65536.0) (f64.const 0x1p-37)) (f64.const 0x1.fffffffffffffp+15))
+
+;; Test subtracting the greatest value from 1.0 that rounds back to 1.0, and the
+;; least that rounds to something less.
+(assert_return (invoke "f32.sub" (f32.const 1.0) (f32.const 0x1p-25)) (f32.const 0x1.0p+0))
+(assert_return (invoke "f32.sub" (f32.const 1.0) (f32.const 0x1.000002p-25)) (f32.const 0x1.fffffep-1))
+(assert_return (invoke "f64.sub" (f64.const 1.0) (f64.const 0x1p-54)) (f64.const 0x1.0p+0))
+(assert_return (invoke "f64.sub" (f64.const 1.0) (f64.const 0x1.0000000000001p-54)) (f64.const 0x1.fffffffffffffp-1))
+
+;; Computations that round differently in round-upward mode.
+(assert_return (invoke "f32.sub" (f32.const 0x1.ee2466p-106) (f32.const -0x1.16277ep+119)) (f32.const 0x1.16277ep+119))
+(assert_return (invoke "f32.sub" (f32.const -0x1.446f9ep+119) (f32.const -0x1.4396a4p+43)) (f32.const -0x1.446f9ep+119))
+(assert_return (invoke "f32.sub" (f32.const 0x1.74773cp+0) (f32.const -0x1.a25512p-82)) (f32.const 0x1.74773cp+0))
+(assert_return (invoke "f32.sub" (f32.const 0x1.9345c4p-117) (f32.const 0x1.6792c2p-76)) (f32.const -0x1.6792c2p-76))
+(assert_return (invoke "f32.sub" (f32.const 0x1.9ecfa4p-18) (f32.const -0x1.864b44p-107)) (f32.const 0x1.9ecfa4p-18))
+(assert_return (invoke "f64.sub" (f64.const -0x1.5b798875e7845p-333) (f64.const -0x1.b5147117452fep-903)) (f64.const -0x1.5b798875e7845p-333))
+(assert_return (invoke "f64.sub" (f64.const -0x1.6c87baeb6d72dp+552) (f64.const -0x1.64fb35d4b5571p-158)) (f64.const -0x1.6c87baeb6d72dp+552))
+(assert_return (invoke "f64.sub" (f64.const 0x1.b3d369fcf74bp-461) (f64.const -0x1.ea1668c0dec93p-837)) (f64.const 0x1.b3d369fcf74bp-461))
+(assert_return (invoke "f64.sub" (f64.const 0x1.0abd449353eadp-1005) (f64.const -0x1.0422ea3e82ee9p+154)) (f64.const 0x1.0422ea3e82ee9p+154))
+(assert_return (invoke "f64.sub" (f64.const -0x1.aadbc6b43cc3dp-143) (f64.const -0x1.e7f922ef1ee58p-539)) (f64.const -0x1.aadbc6b43cc3dp-143))
+
+;; Computations that round differently in round-downward mode.
+(assert_return (invoke "f32.sub" (f32.const -0x1.61e262p+108) (f32.const -0x1.baf3e4p+112)) (f32.const 0x1.a4d5bep+112))
+(assert_return (invoke "f32.sub" (f32.const -0x1.62c2f6p+109) (f32.const 0x1.6e514ap+6)) (f32.const -0x1.62c2f6p+109))
+(assert_return (invoke "f32.sub" (f32.const -0x1.287c94p-83) (f32.const 0x1.0f2f9cp-24)) (f32.const -0x1.0f2f9cp-24))
+(assert_return (invoke "f32.sub" (f32.const -0x1.c8825cp-77) (f32.const -0x1.4aead6p-12)) (f32.const 0x1.4aead6p-12))
+(assert_return (invoke "f32.sub" (f32.const -0x1.2976a4p+99) (f32.const 0x1.c6e3b8p-59)) (f32.const -0x1.2976a4p+99))
+(assert_return (invoke "f64.sub" (f64.const -0x1.76cb28ae6c045p+202) (f64.const -0x1.0611f2af4e9b9p+901)) (f64.const 0x1.0611f2af4e9b9p+901))
+(assert_return (invoke "f64.sub" (f64.const 0x1.baf35eff22e9ep-368) (f64.const 0x1.5c3e08ecf73ecp-451)) (f64.const 0x1.baf35eff22e9ep-368))
+(assert_return (invoke "f64.sub" (f64.const -0x1.8fd354b376f1fp-200) (f64.const 0x1.513c860f386ffp-508)) (f64.const -0x1.8fd354b376f1fp-200))
+(assert_return (invoke "f64.sub" (f64.const -0x1.760d447230ae6p-992) (f64.const -0x1.16f788438ae3ep-328)) (f64.const 0x1.16f788438ae3ep-328))
+(assert_return (invoke "f64.sub" (f64.const -0x1.73aab4fcfc7ap+112) (f64.const 0x1.7c589f990b884p+171)) (f64.const -0x1.7c589f990b884p+171))
+
+;; Computations that round differently in round-toward-zero mode.
+(assert_return (invoke "f32.sub" (f32.const 0x1.ea264cp+95) (f32.const 0x1.852988p-15)) (f32.const 0x1.ea264cp+95))
+(assert_return (invoke "f32.sub" (f32.const -0x1.14ec7cp+19) (f32.const -0x1.0ad3fep-35)) (f32.const -0x1.14ec7cp+19))
+(assert_return (invoke "f32.sub" (f32.const -0x1.3251dap-36) (f32.const -0x1.49c97ep-56)) (f32.const -0x1.3251c6p-36))
+(assert_return (invoke "f32.sub" (f32.const -0x1.13565ep-14) (f32.const 0x1.2f89a8p-13)) (f32.const -0x1.b934d8p-13))
+(assert_return (invoke "f32.sub" (f32.const -0x1.6032b6p-33) (f32.const -0x1.bb5196p-104)) (f32.const -0x1.6032b6p-33))
+(assert_return (invoke "f64.sub" (f64.const -0x1.b5b0797af491p-157) (f64.const -0x1.694b8348189e8p+722)) (f64.const 0x1.694b8348189e8p+722))
+(assert_return (invoke "f64.sub" (f64.const -0x1.72b142826ed73p+759) (f64.const -0x1.010477bc9afbdp+903)) (f64.const 0x1.010477bc9afbdp+903))
+(assert_return (invoke "f64.sub" (f64.const 0x1.83273b6bb94cfp-796) (f64.const 0x1.1a93f948a2abbp+181)) (f64.const -0x1.1a93f948a2abbp+181))
+(assert_return (invoke "f64.sub" (f64.const -0x1.207e7156cbf2p-573) (f64.const 0x1.cf3f12fd3814dp-544)) (f64.const -0x1.cf3f13063c086p-544))
+(assert_return (invoke "f64.sub" (f64.const -0x1.837e6844f1718p-559) (f64.const -0x1.1c29b757f98abp-14)) (f64.const 0x1.1c29b757f98abp-14))
+
+;; Computations that round differently on x87.
+(assert_return (invoke "f64.sub" (f64.const 0x1.c21151a709b6cp-78) (f64.const 0x1.0a12fff8910f6p-115)) (f64.const 0x1.c21151a701663p-78))
+(assert_return (invoke "f64.sub" (f64.const 0x1.c57912aae2f64p-982) (f64.const 0x1.dbfbd4800b7cfp-1010)) (f64.const 0x1.c579128d2338fp-982))
+(assert_return (invoke "f64.sub" (f64.const 0x1.ffef4399af9c6p-254) (f64.const 0x1.edb96dfaea8b1p-200)) (f64.const -0x1.edb96dfaea8b1p-200))
+(assert_return (invoke "f64.sub" (f64.const -0x1.363eee391cde2p-39) (f64.const -0x1.a65462000265fp-69)) (f64.const -0x1.363eee32838c9p-39))
+(assert_return (invoke "f64.sub" (f64.const 0x1.59016dba002a1p-25) (f64.const 0x1.5d4374f124cccp-3)) (f64.const -0x1.5d436f8d1f15dp-3))
+
+;; Computations that round differently when computed via f32.
+(assert_return (invoke "f64.sub" (f64.const -0x1.18196bca005cfp-814) (f64.const -0x1.db7b01ce3f52fp-766)) (f64.const 0x1.db7b01ce3f51dp-766))
+(assert_return (invoke "f64.sub" (f64.const -0x1.d17b3528d219p+33) (f64.const 0x1.fd739d4ea220ap+367)) (f64.const -0x1.fd739d4ea220ap+367))
+(assert_return (invoke "f64.sub" (f64.const 0x1.dea46994de319p+114) (f64.const 0x1.b5b19cd55c7d3p-590)) (f64.const 0x1.dea46994de319p+114))
+(assert_return (invoke "f64.sub" (f64.const 0x1.b60f9b2fbd9ecp-489) (f64.const -0x1.6f81c59ec5b8ep-694)) (f64.const 0x1.b60f9b2fbd9ecp-489))
+(assert_return (invoke "f64.sub" (f64.const 0x1.5e423fe8571f4p-57) (f64.const 0x1.9624ed7c162dfp-618)) (f64.const 0x1.5e423fe8571f4p-57))
+
+;; pow(e, π) - π
+;; https://xkcd.com/217/
+(assert_return (invoke "f32.sub" (f32.const 0x1.724046p+4) (f32.const 0x1.921fb6p+1)) (f32.const 0x1.3ffc5p+4))
+(assert_return (invoke "f64.sub" (f64.const 0x1.724046eb0933ap+4) (f64.const 0x1.921fb54442d18p+1)) (f64.const 0x1.3ffc504280d97p+4))
+
+;; https://www.cnet.com/news/googles-calculator-muffs-some-math-problems/
+(assert_return (invoke "f32.sub" (f32.const 2999999) (f32.const 2999998)) (f32.const 1.0))
+(assert_return (invoke "f32.sub" (f32.const 1999999) (f32.const 1999995)) (f32.const 4.0))
+(assert_return (invoke "f32.sub" (f32.const 1999999) (f32.const 1999993)) (f32.const 6.0))
+(assert_return (invoke "f32.sub" (f32.const 400002) (f32.const 400001)) (f32.const 1.0))
+(assert_return (invoke "f32.sub" (f32.const 400002) (f32.const 400000)) (f32.const 2.0))
+(assert_return (invoke "f64.sub" (f64.const 2999999999999999) (f64.const 2999999999999998)) (f64.const 1.0))
+(assert_return (invoke "f64.sub" (f64.const 1999999999999999) (f64.const 1999999999999995)) (f64.const 4.0))
+(assert_return (invoke "f64.sub" (f64.const 1999999999999999) (f64.const 1999999999999993)) (f64.const 6.0))
+(assert_return (invoke "f64.sub" (f64.const 400000000000002) (f64.const 400000000000001)) (f64.const 1.0))
+(assert_return (invoke "f64.sub" (f64.const 400000000000002) (f64.const 400000000000000)) (f64.const 2.0))
+
+;; Min normal - max subnormal = min subnormal.
+(assert_return (invoke "f32.sub" (f32.const 0x1p-126) (f32.const 0x1.fffffcp-127)) (f32.const 0x1p-149))
+(assert_return (invoke "f64.sub" (f64.const 0x1p-1022) (f64.const 0x0.fffffffffffffp-1022)) (f64.const 0x0.0000000000001p-1022))
+
+;; Test subtraction of numbers very close to 1.
+(assert_return (invoke "f32.sub" (f32.const 0x1.000002p+0) (f32.const 0x1.fffffep-1)) (f32.const 0x1.8p-23))
+(assert_return (invoke "f32.sub" (f32.const 0x1.000002p+0) (f32.const 0x1.0p+0)) (f32.const 0x1p-23))
+(assert_return (invoke "f32.sub" (f32.const 0x1p+0) (f32.const 0x1.fffffep-1)) (f32.const 0x1p-24))
+(assert_return (invoke "f64.sub" (f64.const 0x1.0000000000001p+0) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1.8p-52))
+(assert_return (invoke "f64.sub" (f64.const 0x1.0000000000001p+0) (f64.const 0x1.0p+0)) (f64.const 0x1p-52))
+(assert_return (invoke "f64.sub" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1p-53))
+
+;; Test the least value that can be subtracted from the max value to produce a
+;; different value.
+(assert_return (invoke "f32.sub" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+102)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "f32.sub" (f32.const 0x1.fffffep+127) (f32.const 0x1p+103)) (f32.const 0x1.fffffcp+127))
+(assert_return (invoke "f64.sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+969)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64.sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+970)) (f64.const 0x1.ffffffffffffep+1023))
+
+;; Miscellaneous values.
+(assert_return (invoke "f32.mul" (f32.const 1e15) (f32.const 1e15)) (f32.const 0x1.93e592p+99))
+(assert_return (invoke "f32.mul" (f32.const 1e20) (f32.const 1e20)) (f32.const inf))
+(assert_return (invoke "f32.mul" (f32.const 1e25) (f32.const 1e25)) (f32.const inf))
+(assert_return (invoke "f64.mul" (f64.const 1e15) (f64.const 1e15)) (f64.const 0x1.93e5939a08ceap+99))
+(assert_return (invoke "f64.mul" (f64.const 1e20) (f64.const 1e20)) (f64.const 0x1.d6329f1c35ca5p+132))
+(assert_return (invoke "f64.mul" (f64.const 1e25) (f64.const 1e25)) (f64.const 0x1.11b0ec57e649bp+166))
+
+;; Test for a case of double rounding, example from:
+;; http://perso.ens-lyon.fr/jean-michel.muller/Handbook.html
+;; section 3.3.1: A typical problem: "double rounding"
+(assert_return (invoke "f32.mul" (f32.const 1848874880.0) (f32.const 19954563072.0)) (f32.const 0x1.000002p+65))
+(assert_return (invoke "f64.mul" (f64.const 1848874847.0) (f64.const 19954562207.0)) (f64.const 3.6893488147419111424e+19))
+
+;; Test for a historic spreadsheet bug.
+;; http://www.joelonsoftware.com/items/2007/09/26b.html
+(assert_return (invoke "f32.mul" (f32.const 77.1) (f32.const 850)) (f32.const 65535))
+(assert_return (invoke "f64.mul" (f64.const 77.1) (f64.const 850)) (f64.const 65534.99999999999272404))
+
+;; Computations that round differently in round-upward mode.
+(assert_return (invoke "f32.mul" (f32.const -0x1.14df2ep+61) (f32.const 0x1.748878p-36)) (f32.const -0x1.92e7e8p+25))
+(assert_return (invoke "f32.mul" (f32.const -0x1.5629e2p+102) (f32.const -0x1.c33012p-102)) (f32.const 0x1.2d8604p+1))
+(assert_return (invoke "f32.mul" (f32.const -0x1.b17694p+92) (f32.const -0x1.e4b56ap-97)) (f32.const 0x1.9a5baep-4))
+(assert_return (invoke "f32.mul" (f32.const -0x1.1626a6p+79) (f32.const -0x1.c57d7p-75)) (f32.const 0x1.ecbaaep+4))
+(assert_return (invoke "f32.mul" (f32.const 0x1.7acf72p+53) (f32.const 0x1.6c89acp+5)) (f32.const 0x1.0db556p+59))
+(assert_return (invoke "f64.mul" (f64.const -0x1.25c293f6f37e4p+425) (f64.const 0x1.f5fd4fa41c6d8p+945)) (f64.const -inf))
+(assert_return (invoke "f64.mul" (f64.const -0x1.cc1ae79fffc5bp-986) (f64.const -0x1.c36ccc2861ca6p-219)) (f64.const 0x0p+0))
+(assert_return (invoke "f64.mul" (f64.const 0x1.c0232b3e64b56p+606) (f64.const -0x1.f6939cf3affaap+106)) (f64.const -0x1.b7e3aedf190d3p+713))
+(assert_return (invoke "f64.mul" (f64.const -0x1.60f289966b271p-313) (f64.const 0x1.28a5497f0c259p+583)) (f64.const -0x1.98fc50bcec259p+270))
+(assert_return (invoke "f64.mul" (f64.const 0x1.37dab12d3afa2p+795) (f64.const 0x1.81e156bd393f1p-858)) (f64.const 0x1.d6126554b8298p-63))
+
+;; Computations that round differently in round-downward mode.
+(assert_return (invoke "f32.mul" (f32.const -0x1.3f57a2p-89) (f32.const -0x1.041d68p+92)) (f32.const 0x1.4479bp+3))
+(assert_return (invoke "f32.mul" (f32.const 0x1.4d0582p+73) (f32.const 0x1.6e043ap+19)) (f32.const 0x1.dc236p+92))
+(assert_return (invoke "f32.mul" (f32.const -0x1.2fdap-32) (f32.const -0x1.e1731cp+74)) (f32.const 0x1.1db89ep+43))
+(assert_return (invoke "f32.mul" (f32.const 0x1.7bc8fep+67) (f32.const -0x1.3ad592p+15)) (f32.const -0x1.d3115ep+82))
+(assert_return (invoke "f32.mul" (f32.const 0x1.936742p+30) (f32.const -0x1.a7a19p+66)) (f32.const -0x1.4dc71ap+97))
+(assert_return (invoke "f64.mul" (f64.const -0x1.ba737b4ca3b13p-639) (f64.const 0x1.8923309857438p-314)) (f64.const -0x1.53bc0d07baa37p-952))
+(assert_return (invoke "f64.mul" (f64.const 0x1.7c1932e610219p-276) (f64.const -0x1.2605db646489fp-635)) (f64.const -0x1.b48da2b0d2ae3p-911))
+(assert_return (invoke "f64.mul" (f64.const -0x1.e43cdf3b2108p+329) (f64.const -0x1.99d96abbd61d1p+835)) (f64.const inf))
+(assert_return (invoke "f64.mul" (f64.const 0x1.4c19466551da3p+947) (f64.const 0x1.0bdcd6c7646e9p-439)) (f64.const 0x1.5b7cd8c3f638ap+508))
+(assert_return (invoke "f64.mul" (f64.const 0x1.ff1da1726e3dfp+339) (f64.const -0x1.043c44f52b158p+169)) (f64.const -0x1.03c9364bb585cp+509))
+
+;; Computations that round differently in round-toward-zero mode.
+(assert_return (invoke "f32.mul" (f32.const -0x1.907e8ap+46) (f32.const -0x1.5d3668p+95)) (f32.const inf))
+(assert_return (invoke "f32.mul" (f32.const -0x1.8c9f74p-3) (f32.const 0x1.e2b452p-99)) (f32.const -0x1.75edccp-101))
+(assert_return (invoke "f32.mul" (f32.const -0x1.cc605ap-19) (f32.const 0x1.ec321ap+105)) (f32.const -0x1.ba91a4p+87))
+(assert_return (invoke "f32.mul" (f32.const -0x1.5fbb7ap+56) (f32.const 0x1.a8965ep-96)) (f32.const -0x1.23ae8ep-39))
+(assert_return (invoke "f32.mul" (f32.const -0x1.fb7f12p+16) (f32.const 0x1.3a701ap-119)) (f32.const -0x1.37ac0cp-102))
+(assert_return (invoke "f64.mul" (f64.const -0x1.5b0266454c26bp-496) (f64.const -0x1.af5787e3e0399p+433)) (f64.const 0x1.2457d81949e0bp-62))
+(assert_return (invoke "f64.mul" (f64.const 0x1.0d54a82393d45p+478) (f64.const -0x1.425760807ceaep-764)) (f64.const -0x1.532068c8d0d5dp-286))
+(assert_return (invoke "f64.mul" (f64.const -0x1.b532af981786p+172) (f64.const 0x1.ada95085ba36fp+359)) (f64.const -0x1.6ee38c1e01864p+532))
+(assert_return (invoke "f64.mul" (f64.const 0x1.e132f4d49d1cep+768) (f64.const -0x1.a75afe9a7d864p+374)) (f64.const -inf))
+(assert_return (invoke "f64.mul" (f64.const 0x1.68bbf1cfff90ap+81) (f64.const 0x1.09cd17d652c5p+70)) (f64.const 0x1.768b8d67d794p+151))
+
+;; Computations that round differently on x87.
+(assert_return (invoke "f64.mul" (f64.const 0x1.f99fb602c89b7p-341) (f64.const 0x1.6caab46a31a2ep-575)) (f64.const 0x1.68201f986e9d7p-915))
+(assert_return (invoke "f64.mul" (f64.const -0x1.86999c5eee379p-9) (f64.const 0x1.6e3b9e0d53e0dp+723)) (f64.const -0x1.17654a0ef35f5p+715))
+(assert_return (invoke "f64.mul" (f64.const -0x1.069571b176f9p+367) (f64.const -0x1.e248b6ab0a0e3p-652)) (f64.const 0x1.eeaff575cae1dp-285))
+(assert_return (invoke "f64.mul" (f64.const 0x1.c217645777dd2p+775) (f64.const 0x1.d93f5715dd646p+60)) (f64.const 0x1.a0064aa1d920dp+836))
+(assert_return (invoke "f64.mul" (f64.const -0x1.848981b6e694ap-276) (f64.const 0x1.f5aacb64a0d19p+896)) (f64.const -0x1.7cb2296e6c2e5p+621))
+
+;; Computations that round differently on x87 in double-precision mode.
+(assert_return (invoke "f64.mul" (f64.const 0x1.db3bd2a286944p-599) (f64.const 0x1.ce910af1d55cap-425)) (f64.const 0x0.d6accdd538a39p-1022))
+(assert_return (invoke "f64.mul" (f64.const -0x1.aca223916012p-57) (f64.const -0x1.2b2b4958dd228p-966)) (f64.const 0x0.fa74eccae5615p-1022))
+(assert_return (invoke "f64.mul" (f64.const -0x1.bd062def16cffp-488) (f64.const -0x1.7ddd91a0c4c0ep-536)) (f64.const 0x0.a5f4d7769d90dp-1022))
+(assert_return (invoke "f64.mul" (f64.const -0x1.c6a56169e9cep-772) (f64.const 0x1.517d55a474122p-255)) (f64.const -0x0.12baf260afb77p-1022))
+(assert_return (invoke "f64.mul" (f64.const -0x1.08951b0b41705p-516) (f64.const -0x1.102dc27168d09p-507)) (f64.const 0x0.8ca6dbf3f592bp-1022))
+
+;; Computations that round differently when computed via f32.
+(assert_return (invoke "f64.mul" (f64.const 0x1.8d0dea50c8c9bp+852) (f64.const 0x1.21cac31d87a24p-881)) (f64.const 0x1.c177311f7cd73p-29))
+(assert_return (invoke "f64.mul" (f64.const 0x1.98049118e3063p-7) (f64.const 0x1.6362525151b58p-149)) (f64.const 0x1.1b358514103f9p-155))
+(assert_return (invoke "f64.mul" (f64.const -0x1.ea65cb0631323p+1) (f64.const 0x1.fce683201a19bp-41)) (f64.const -0x1.e76dc8c223667p-39))
+(assert_return (invoke "f64.mul" (f64.const 0x1.e4d235961d543p-373) (f64.const 0x1.bc56f20ef9a48p-205)) (f64.const 0x1.a4c09efcb71d6p-577))
+(assert_return (invoke "f64.mul" (f64.const -0x1.b9612e66faba8p+77) (f64.const 0x1.e2bc6aa782273p-348)) (f64.const -0x1.a026ea4f81db1p-270))
+
+;; Test the least positive value with a positive square.
+(assert_return (invoke "f32.mul" (f32.const 0x1p-75) (f32.const 0x1p-75)) (f32.const 0x0p+0))
+(assert_return (invoke "f32.mul" (f32.const 0x1.000002p-75) (f32.const 0x1.000002p-75)) (f32.const 0x1p-149))
+(assert_return (invoke "f64.mul" (f64.const 0x1.6a09e667f3bccp-538) (f64.const 0x1.6a09e667f3bccp-538)) (f64.const 0x0p+0))
+(assert_return (invoke "f64.mul" (f64.const 0x1.6a09e667f3bcdp-538) (f64.const 0x1.6a09e667f3bcdp-538)) (f64.const 0x0.0000000000001p-1022))
+
+;; Test the greatest positive value with a finite square.
+(assert_return (invoke "f32.mul" (f32.const 0x1.fffffep+63) (f32.const 0x1.fffffep+63)) (f32.const 0x1.fffffcp+127))
+(assert_return (invoke "f32.mul" (f32.const 0x1p+64) (f32.const 0x1p+64)) (f32.const inf))
+(assert_return (invoke "f64.mul" (f64.const 0x1.fffffffffffffp+511) (f64.const 0x1.fffffffffffffp+511)) (f64.const 0x1.ffffffffffffep+1023))
+(assert_return (invoke "f64.mul" (f64.const 0x1p+512) (f64.const 0x1p+512)) (f64.const inf))
+
+;; Test the squares of values very close to 1.
+(assert_return (invoke "f32.mul" (f32.const 0x1.000002p+0) (f32.const 0x1.000002p+0)) (f32.const 0x1.000004p+0))
+(assert_return (invoke "f32.mul" (f32.const 0x1.fffffep-1) (f32.const 0x1.fffffep-1)) (f32.const 0x1.fffffcp-1))
+(assert_return (invoke "f64.mul" (f64.const 0x1.0000000000001p+0) (f64.const 0x1.0000000000001p+0)) (f64.const 0x1.0000000000002p+0))
+(assert_return (invoke "f64.mul" (f64.const 0x1.fffffffffffffp-1) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1.ffffffffffffep-1))
+
+;; Test multiplication of numbers very close to 1.
+(assert_return (invoke "f32.mul" (f32.const 0x1.000002p+0) (f32.const 0x1.fffffep-1)) (f32.const 0x1p+0))
+(assert_return (invoke "f32.mul" (f32.const 0x1.000004p+0) (f32.const 0x1.fffffcp-1)) (f32.const 0x1.000002p+0))
+(assert_return (invoke "f64.mul" (f64.const 0x1.0000000000001p+0) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1p+0))
+(assert_return (invoke "f64.mul" (f64.const 0x1.0000000000002p+0) (f64.const 0x1.ffffffffffffep-1)) (f64.const 0x1.0000000000001p+0))
+
+;; Test MIN * EPSILON.
+;; http://www.mpfr.org/mpfr-2.0.1/patch2
+(assert_return (invoke "f32.mul" (f32.const 0x1p-126) (f32.const 0x1p-23)) (f32.const 0x1p-149))
+(assert_return (invoke "f64.mul" (f64.const 0x1p-1022) (f64.const 0x1p-52)) (f64.const 0x0.0000000000001p-1022))
+
+;; http://opencores.org/bug,view,2454
+(assert_return (invoke "f32.mul" (f32.const -0x1.0006p+4) (f32.const 0x1.ap-132)) (f32.const -0x1.a009cp-128))
+
+;; Miscellaneous values.
+(assert_return (invoke "f32.div" (f32.const 1.123456789) (f32.const 100)) (f32.const 0x1.702264p-7))
+(assert_return (invoke "f32.div" (f32.const 8391667.0) (f32.const 12582905.0)) (f32.const 0x1.55754p-1))
+(assert_return (invoke "f32.div" (f32.const 65536.0) (f32.const 0x1p-37)) (f32.const 0x1p+53))
+(assert_return (invoke "f32.div" (f32.const 0x1.dcbf6ap+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.dcbf68p-128))
+(assert_return (invoke "f32.div" (f32.const 4) (f32.const 3)) (f32.const 0x1.555556p+0))
+(assert_return (invoke "f64.div" (f64.const 1.123456789) (f64.const 100)) (f64.const 0.01123456789))
+(assert_return (invoke "f64.div" (f64.const 8391667.0) (f64.const 12582905.0)) (f64.const 0x1.55753f1d9ba27p-1))
+(assert_return (invoke "f64.div" (f64.const 65536.0) (f64.const 0x1p-37)) (f64.const 0x1p+53))
+(assert_return (invoke "f64.div" (f64.const 0x1.dcbf6ap+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.772fda8p-1022))
+(assert_return (invoke "f64.div" (f64.const 4) (f64.const 3)) (f64.const 0x1.5555555555555p+0))
+
+;; Test for a historic hardware bug.
+;; https://en.wikipedia.org/wiki/Pentium_FDIV_bug
+(assert_return (invoke "f32.div" (f32.const 4195835) (f32.const 3145727)) (f32.const 0x1.557542p+0))
+(assert_return (invoke "f64.div" (f64.const 4195835) (f64.const 3145727)) (f64.const 0x1.557541c7c6b43p+0))
+
+;; Computations that round differently in round-upward mode.
+(assert_return (invoke "f32.div" (f32.const 0x1.6a6c5ap-48) (f32.const 0x1.fa0b7p+127)) (f32.const 0x0p+0))
+(assert_return (invoke "f32.div" (f32.const 0x1.616fb2p-87) (f32.const 0x1.332172p+68)) (f32.const 0x0p+0))
+(assert_return (invoke "f32.div" (f32.const -0x1.96e778p+16) (f32.const 0x1.eb0c56p-80)) (f32.const -0x1.a8440ap+95))
+(assert_return (invoke "f32.div" (f32.const -0x1.e2624p-76) (f32.const -0x1.ed236ep-122)) (f32.const 0x1.f4d584p+45))
+(assert_return (invoke "f32.div" (f32.const -0x1.e2374ep+41) (f32.const 0x1.71fcdcp-80)) (f32.const -0x1.4da706p+121))
+(assert_return (invoke "f64.div" (f64.const 0x1.163c09d0c38c1p+147) (f64.const 0x1.e04cc737348e6p+223)) (f64.const 0x1.289921caeed23p-77))
+(assert_return (invoke "f64.div" (f64.const 0x1.d6867e741e0a9p-626) (f64.const 0x1.335eb19a9aae4p-972)) (f64.const 0x1.87e342d11f519p+346))
+(assert_return (invoke "f64.div" (f64.const -0x1.d5edf648aeb98p+298) (f64.const 0x1.0dda15b079355p+640)) (f64.const -0x1.bdceaf9734b5cp-342))
+(assert_return (invoke "f64.div" (f64.const -0x1.b683e3934aedap+691) (f64.const 0x1.c364e1df00dffp+246)) (f64.const -0x1.f16456e7afe3bp+444))
+(assert_return (invoke "f64.div" (f64.const -0x1.44ca7539cc851p+540) (f64.const 0x1.58501bccc58fep+453)) (f64.const -0x1.e2f8657e0924ep+86))
+
+;; Computations that round differently in round-downward mode.
+(assert_return (invoke "f32.div" (f32.const -0x1.c2c54ap+69) (f32.const -0x1.00d142p-86)) (f32.const inf))
+(assert_return (invoke "f32.div" (f32.const 0x1.e35abep-46) (f32.const 0x1.c69dfp+44)) (f32.const 0x1.102eb4p-90))
+(assert_return (invoke "f32.div" (f32.const 0x1.45ff2ap+0) (f32.const -0x1.1e8754p+89)) (f32.const -0x1.23434ep-89))
+(assert_return (invoke "f32.div" (f32.const 0x1.8db18ap-51) (f32.const 0x1.47c678p-128)) (f32.const 0x1.369b96p+77))
+(assert_return (invoke "f32.div" (f32.const 0x1.78599p+90) (f32.const 0x1.534144p+87)) (f32.const 0x1.1bfddcp+3))
+(assert_return (invoke "f64.div" (f64.const 0x0.f331c4f47eb51p-1022) (f64.const -0x1.c7ff45bf6f03ap+362)) (f64.const -0x0p+0))
+(assert_return (invoke "f64.div" (f64.const -0x1.0fc8707b9d19cp-987) (f64.const 0x1.77524d5f4a563p-536)) (f64.const -0x1.72c1a937d231p-452))
+(assert_return (invoke "f64.div" (f64.const -0x1.edb3aa64bb338p-403) (f64.const -0x1.1c7c164320e4p+45)) (f64.const 0x1.bc44cc1c5ae63p-448))
+(assert_return (invoke "f64.div" (f64.const -0x1.6534b34e8686bp+80) (f64.const 0x1.c34a7fc59e3c3p-791)) (f64.const -0x1.95421bf291b66p+870))
+(assert_return (invoke "f64.div" (f64.const -0x1.91f58d7ed1237p+236) (f64.const -0x1.f190d808383c8p+55)) (f64.const 0x1.9d9eb0836f906p+180))
+
+;; Computations that round differently in round-toward-zero mode.
+(assert_return (invoke "f32.div" (f32.const 0x1.64b2a4p+26) (f32.const 0x1.e95752p-119)) (f32.const inf))
+(assert_return (invoke "f32.div" (f32.const -0x1.53c9b6p+77) (f32.const 0x1.d689ap+27)) (f32.const -0x1.71baa4p+49))
+(assert_return (invoke "f32.div" (f32.const 0x1.664a8ap+38) (f32.const -0x1.59dba2p+96)) (f32.const -0x1.0933f4p-58))
+(assert_return (invoke "f32.div" (f32.const -0x1.99e0fap+111) (f32.const -0x1.c2b5a8p+9)) (f32.const 0x1.d19de6p+101))
+(assert_return (invoke "f32.div" (f32.const -0x1.5a815ap+92) (f32.const -0x1.b5820ap+13)) (f32.const 0x1.9580b8p+78))
+(assert_return (invoke "f64.div" (f64.const -0x1.81fd1e2af7bebp-655) (f64.const 0x1.edefc4eae536cp-691)) (f64.const -0x1.901abdd91b661p+35))
+(assert_return (invoke "f64.div" (f64.const -0x1.47cf932953c43p+782) (f64.const -0x1.bc40496b1f2a1p-553)) (f64.const inf))
+(assert_return (invoke "f64.div" (f64.const -0x1.2bd2e8fbdcad7p-746) (f64.const 0x1.b115674cc476ep-65)) (f64.const -0x1.62752bf19fa81p-682))
+(assert_return (invoke "f64.div" (f64.const -0x1.f923e3fea9efep+317) (f64.const -0x1.8044c74d27a39p-588)) (f64.const 0x1.5086518cc7186p+905))
+(assert_return (invoke "f64.div" (f64.const 0x1.516ed2051d6bbp+181) (f64.const -0x1.c9f455eb9c2eep+214)) (f64.const -0x1.79414d67f2889p-34))
+
+;; Computations that round differently on x87.
+(assert_return (invoke "f64.div" (f64.const -0x1.9c52726aed366p+585) (f64.const -0x1.7d0568c75660fp+195)) (f64.const 0x1.1507ca2a65f23p+390))
+(assert_return (invoke "f64.div" (f64.const -0x1.522672f461667p+546) (f64.const -0x1.36d36572c9f71p+330)) (f64.const 0x1.1681369370619p+216))
+(assert_return (invoke "f64.div" (f64.const 0x1.01051b4e8cd61p+185) (f64.const -0x1.2cbb5ca3d33ebp+965)) (f64.const -0x1.b59471598a2f3p-781))
+(assert_return (invoke "f64.div" (f64.const 0x1.5f93bb80fc2cbp+217) (f64.const 0x1.7e051aae9f0edp+427)) (f64.const 0x1.d732fa926ba4fp-211))
+(assert_return (invoke "f64.div" (f64.const -0x1.e251d762163ccp+825) (f64.const 0x1.3ee63581e1796p+349)) (f64.const -0x1.8330077d90a07p+476))
+
+;; Computations that round differently on x87 in double-precision mode.
+(assert_return (invoke "f64.div" (f64.const 0x1.dcbf69f10006dp+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.772fda7c4001bp-1022))
+(assert_return (invoke "f64.div" (f64.const 0x1.e14169442fbcap-1011) (f64.const 0x1.505451d62ff7dp+12)) (f64.const 0x0.b727e85f38b39p-1022))
+(assert_return (invoke "f64.div" (f64.const -0x1.d3ebe726ec964p-144) (f64.const -0x1.4a7bfc0b83608p+880)) (f64.const 0x0.5a9d8c50cbf87p-1022))
+(assert_return (invoke "f64.div" (f64.const -0x1.6c3def770aee1p-393) (f64.const -0x1.8b84724347598p+631)) (f64.const 0x0.3af0707fcd0c7p-1022))
+(assert_return (invoke "f64.div" (f64.const 0x1.16abda1bb3cb3p-856) (f64.const 0x1.6c9c7198eb1e6p+166)) (f64.const 0x0.c3a8fd6741649p-1022))
+(assert_return (invoke "f64.div" (f64.const 0x1.7057d6ab553cap-1005) (f64.const -0x1.2abf1e98660ebp+23)) (f64.const -0x0.04ee8d8ec01cdp-1022))
+
+;; Computations that round differently when div is mul by reciprocal.
+(assert_return (invoke "f32.div" (f32.const 0x1.ada9aap+89) (f32.const 0x1.69884cp+42)) (f32.const 0x1.303e2ep+47))
+(assert_return (invoke "f32.div" (f32.const 0x1.8281c8p+90) (f32.const -0x1.62883cp+106)) (f32.const -0x1.17169cp-16))
+(assert_return (invoke "f32.div" (f32.const 0x1.5c6be2p+81) (f32.const 0x1.d01dfep-1)) (f32.const 0x1.805e32p+81))
+(assert_return (invoke "f32.div" (f32.const -0x1.bbd252p+19) (f32.const -0x1.fba95p+33)) (f32.const 0x1.bf9d56p-15))
+(assert_return (invoke "f32.div" (f32.const -0x1.0f41d6p-42) (f32.const -0x1.3f2dbep+56)) (f32.const 0x1.b320d8p-99))
+(assert_return (invoke "f64.div" (f64.const 0x1.b2348a1c81899p+61) (f64.const -0x1.4a58aad903dd3p-861)) (f64.const -0x1.507c1e2a41b35p+922))
+(assert_return (invoke "f64.div" (f64.const 0x1.23fa5137a918ap-130) (f64.const -0x1.7268db1951263p-521)) (f64.const -0x1.93965e0d896bep+390))
+(assert_return (invoke "f64.div" (f64.const 0x1.dcb3915d82deep+669) (f64.const 0x1.50caaa1dc6b19p+638)) (f64.const 0x1.6a58ec814b09dp+31))
+(assert_return (invoke "f64.div" (f64.const -0x1.046e378c0cc46p+182) (f64.const 0x1.ac925009a922bp+773)) (f64.const -0x1.3720aa94dab18p-592))
+(assert_return (invoke "f64.div" (f64.const -0x1.8945fd69d8e11p-871) (f64.const -0x1.0a37870af809ap-646)) (f64.const 0x1.7a2e286c62382p-225))
+
+;; Computations that round differently when computed via f32.
+(assert_return (invoke "f64.div" (f64.const 0x1.82002af0ea1f3p-57) (f64.const 0x1.d0a9b0c2fa339p+0)) (f64.const 0x1.a952fbd1fc17cp-58))
+(assert_return (invoke "f64.div" (f64.const 0x1.1e12b515db471p-102) (f64.const -0x1.41fc3c94fba5p-42)) (f64.const -0x1.c6e50cccb7cb6p-61))
+(assert_return (invoke "f64.div" (f64.const 0x1.aba5adcd6f583p-41) (f64.const 0x1.17dfac639ce0fp-112)) (f64.const 0x1.872b0a008c326p+71))
+(assert_return (invoke "f64.div" (f64.const 0x1.cf82510d0ae6bp+89) (f64.const 0x1.0207d86498053p+97)) (f64.const 0x1.cbdc804e2cf14p-8))
+(assert_return (invoke "f64.div" (f64.const 0x1.4c82cbb508e21p-11) (f64.const -0x1.6b57208c2d5d5p+52)) (f64.const -0x1.d48e8b369129ap-64))
+
+;; Division involving the maximum subnormal value and the minimum normal value.
+(assert_return (invoke "f32.div" (f32.const 0x1p-126) (f32.const 0x1.fffffcp-127)) (f32.const 0x1.000002p+0))
+(assert_return (invoke "f32.div" (f32.const 0x1.fffffcp-127) (f32.const 0x1p-126)) (f32.const 0x1.fffffcp-1))
+(assert_return (invoke "f64.div" (f64.const 0x1p-1022) (f64.const 0x0.fffffffffffffp-1022)) (f64.const 0x1.0000000000001p+0))
+(assert_return (invoke "f64.div" (f64.const 0x0.fffffffffffffp-1022) (f64.const 0x1p-1022)) (f64.const 0x1.ffffffffffffep-1))
+
+;; Test the least positive value with a positive quotient with the maximum value.
+(assert_return (invoke "f32.div" (f32.const 0x1.fffffep-23) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
+(assert_return (invoke "f32.div" (f32.const 0x1p-22) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-149))
+(assert_return (invoke "f64.div" (f64.const 0x1.fffffffffffffp-52) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
+(assert_return (invoke "f64.div" (f64.const 0x1p-51) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022))
+
+;; Test the least positive value with a finite reciprocal.
+(assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1p-128)) (f32.const inf))
+(assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1.000008p-128)) (f32.const 0x1.fffffp+127))
+(assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x0.4p-1022)) (f64.const inf))
+(assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x0.4000000000001p-1022)) (f64.const 0x1.ffffffffffff8p+1023))
+
+;; Test the least positive value that has a subnormal reciprocal.
+(assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1.000002p+126)) (f32.const 0x1.fffffcp-127))
+(assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1p+126)) (f32.const 0x1p-126))
+(assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x1.0000000000001p+1022)) (f64.const 0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x1p+1022)) (f64.const 0x1p-1022))
+
+;; Test that the last binary digit of 1.0/3.0 is even in f32,
+;; https://en.wikipedia.org/wiki/Single-precision_floating-point_format#Single-precision_examples
+;;
+;; and odd in f64,
+;; https://en.wikipedia.org/wiki/Double-precision_floating-point_format#Double-precision_examples
+;;
+;; and that 1.0/3.0, 3.0/9.0, and 9.0/27.0 all agree.
+;; http://www.netlib.org/paranoia
+(assert_return (invoke "f32.div" (f32.const 0x1p+0) (f32.const 0x1.8p+1)) (f32.const 0x1.555556p-2))
+(assert_return (invoke "f32.div" (f32.const 0x3p+0) (f32.const 0x1.2p+3)) (f32.const 0x1.555556p-2))
+(assert_return (invoke "f32.div" (f32.const 0x1.2p+3) (f32.const 0x1.bp+4)) (f32.const 0x1.555556p-2))
+(assert_return (invoke "f64.div" (f64.const 0x1p+0) (f64.const 0x1.8p+1)) (f64.const 0x1.5555555555555p-2))
+(assert_return (invoke "f64.div" (f64.const 0x3p+0) (f64.const 0x1.2p+3)) (f64.const 0x1.5555555555555p-2))
+(assert_return (invoke "f64.div" (f64.const 0x1.2p+3) (f64.const 0x1.bp+4)) (f64.const 0x1.5555555555555p-2))
+
+;; Test division of numbers very close to 1.
+(assert_return (invoke "f32.div" (f32.const 0x1.000002p+0) (f32.const 0x1.fffffep-1)) (f32.const 0x1.000004p+0))
+(assert_return (invoke "f32.div" (f32.const 0x1.fffffep-1) (f32.const 0x1.000002p+0)) (f32.const 0x1.fffffap-1))
+(assert_return (invoke "f32.div" (f32.const 0x1.0p+0) (f32.const 0x1.fffffep-1)) (f32.const 0x1.000002p+0))
+(assert_return (invoke "f32.div" (f32.const 0x1.0p+0) (f32.const 0x1.000002p+0)) (f32.const 0x1.fffffcp-1))
+(assert_return (invoke "f64.div" (f64.const 0x1.0000000000001p+0) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1.0000000000002p+0))
+(assert_return (invoke "f64.div" (f64.const 0x1.fffffffffffffp-1) (f64.const 0x1.0000000000001p+0)) (f64.const 0x1.ffffffffffffdp-1))
+(assert_return (invoke "f64.div" (f64.const 0x1.0p+0) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1.0000000000001p+0))
+(assert_return (invoke "f64.div" (f64.const 0x1.0p+0) (f64.const 0x1.0000000000001p+0)) (f64.const 0x1.ffffffffffffep-1))
+
+;; Test for bugs found in an early RISC-V implementation.
+;; https://github.com/riscv/riscv-tests/pull/8
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.56p+7)) (f32.const 0x1.a2744cp+3))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.594dfcp-23)) (f32.const 0x1.a4789cp-12))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.56p+7)) (f64.const 0x1.a2744ce9674f5p+3))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.594dfc70aa105p-23)) (f64.const 0x1.a4789c0e37f99p-12))
+
+;; Computations that round differently on x87.
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.0263fcc94f259p-164)) (f64.const 0x1.0131485de579fp-82))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.352dfa278c43dp+338)) (f64.const 0x1.195607dac5417p+169))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.b15daa23924fap+402)) (f64.const 0x1.4d143db561493p+201))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.518c8e68cb753p-37)) (f64.const 0x1.9fb8ef1ad5bfdp-19))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.86d8b6518078ep-370)) (f64.const 0x1.3c5142a48fcadp-185))
+
+;; Test another sqrt case on x87.
+;; https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52593
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1.fffffffffffffp-1))
+
+;; Computations that round differently in round-upward mode.
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.098064p-3)) (f32.const 0x1.70b23p-2))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.d9befp+100)) (f32.const 0x1.5c4052p+50))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.42b5b6p-4)) (f32.const 0x1.1f6d0ep-2))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.3684dp-71)) (f32.const 0x1.8ebae2p-36))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.d8bc4ep-11)) (f32.const 0x1.ebf9eap-6))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.5c39f220d5704p-924)) (f64.const 0x1.2a92bc24ceae9p-462))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.53521a635745cp+727)) (f64.const 0x1.a0cfdc4ef8ff1p+363))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.dfd5bbc9f4678p+385)) (f64.const 0x1.efa817117c94cp+192))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.33f9640811cd4p+105)) (f64.const 0x1.8d17c9243baa3p+52))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.6c0ef0267ff45p+999)) (f64.const 0x1.afbcfae3f2b4p+499))
+
+;; Computations that round differently in round-downward mode.
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.26a62ep+27)) (f32.const 0x1.84685p+13))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.166002p-113)) (f32.const 0x1.798762p-57))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.3dfb5p-15)) (f32.const 0x1.937e38p-8))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.30eb2cp-120)) (f32.const 0x1.176406p-60))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.cb705cp-123)) (f32.const 0x1.e5020ap-62))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.edae8aea0543p+695)) (f64.const 0x1.f6c1ea4fc8dd2p+347))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.f7ee4bda5c9c3p-763)) (f64.const 0x1.fbf30bdaf11c5p-382))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.a48f348266ad1p-30)) (f64.const 0x1.481ee7540baf7p-15))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.feb5a1ce3ed9cp-242)) (f64.const 0x1.6995060c20d46p-121))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.957d9796e3834p+930)) (f64.const 0x1.42305213157bap+465))
+
+;; Computations that round differently in round-toward-zero mode.
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.65787cp+118)) (f32.const 0x1.2e82a4p+59))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.736044p+15)) (f32.const 0x1.b40e4p+7))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.a00edp-1)) (f32.const 0x1.cd8aecp-1))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.7a4c8p-87)) (f32.const 0x1.b819e4p-44))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.5d24d4p-94)) (f32.const 0x1.2af75ep-47))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.a008948ead274p+738)) (f64.const 0x1.4659b37c39b19p+369))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.70f6199ed21f5p-381)) (f64.const 0x1.b2a2bddf3300dp-191))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.35c1d49f2a352p+965)) (f64.const 0x1.8e3d9f01a9716p+482))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.3fbdcfb2b2a15p-45)) (f64.const 0x1.949ba4feca42ap-23))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.c201b94757145p-492)) (f64.const 0x1.5369ee6bf2967p-246))
+
+;; Computations that round differently when computed via f32.
+(assert_return (invoke "f64.sqrt" (f64.const -0x1.360e8d0032adp-963)) (f64.const nan:canonical))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.d9a6f5eef0503p+103)) (f64.const 0x1.ec73f56c166f6p+51))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.aa051a5c4ec27p-760)) (f64.const 0x1.4a3e771ff5149p-380))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.e5522a741babep-276)) (f64.const 0x1.607ae2b6feb7dp-138))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.4832badc0c061p+567)) (f64.const 0x1.99ec7934139b2p+283))
+
+;; Test the least value with a sqrt that rounds to one.
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.000002p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.000004p+0)) (f32.const 0x1.000002p+0))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.0000000000001p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.0000000000002p+0)) (f64.const 0x1.0000000000001p+0))
+
+;; Test the greatest value less than one for which sqrt is not an identity.
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.fffffcp-1)) (f32.const 0x1.fffffep-1))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.fffffap-1)) (f32.const 0x1.fffffcp-1))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.ffffffffffffep-1)) (f64.const 0x1.fffffffffffffp-1))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.ffffffffffffdp-1)) (f64.const 0x1.ffffffffffffep-1))
+
+;; Test that the bitwise floating point operators are bitwise on NaN.
+
+(assert_return (invoke "f32.abs" (f32.const nan:0x0f1e2)) (f32.const nan:0x0f1e2))
+(assert_return (invoke "f32.abs" (f32.const -nan:0x0f1e2)) (f32.const nan:0x0f1e2))
+(assert_return (invoke "f64.abs" (f64.const nan:0x0f1e27a6b)) (f64.const nan:0x0f1e27a6b))
+(assert_return (invoke "f64.abs" (f64.const -nan:0x0f1e27a6b)) (f64.const nan:0x0f1e27a6b))
+
+(assert_return (invoke "f32.neg" (f32.const nan:0x0f1e2)) (f32.const -nan:0x0f1e2))
+(assert_return (invoke "f32.neg" (f32.const -nan:0x0f1e2)) (f32.const nan:0x0f1e2))
+(assert_return (invoke "f64.neg" (f64.const nan:0x0f1e27a6b)) (f64.const -nan:0x0f1e27a6b))
+(assert_return (invoke "f64.neg" (f64.const -nan:0x0f1e27a6b)) (f64.const nan:0x0f1e27a6b))
+
+(assert_return (invoke "f32.copysign" (f32.const nan:0x0f1e2) (f32.const nan)) (f32.const nan:0x0f1e2))
+(assert_return (invoke "f32.copysign" (f32.const nan:0x0f1e2) (f32.const -nan)) (f32.const -nan:0x0f1e2))
+(assert_return (invoke "f32.copysign" (f32.const -nan:0x0f1e2) (f32.const nan)) (f32.const nan:0x0f1e2))
+(assert_return (invoke "f32.copysign" (f32.const -nan:0x0f1e2) (f32.const -nan)) (f32.const -nan:0x0f1e2))
+(assert_return (invoke "f64.copysign" (f64.const nan:0x0f1e27a6b) (f64.const nan)) (f64.const nan:0x0f1e27a6b))
+(assert_return (invoke "f64.copysign" (f64.const nan:0x0f1e27a6b) (f64.const -nan)) (f64.const -nan:0x0f1e27a6b))
+(assert_return (invoke "f64.copysign" (f64.const -nan:0x0f1e27a6b) (f64.const nan)) (f64.const nan:0x0f1e27a6b))
+(assert_return (invoke "f64.copysign" (f64.const -nan:0x0f1e27a6b) (f64.const -nan)) (f64.const -nan:0x0f1e27a6b))
+
+;; Test values close to 1.0.
+(assert_return (invoke "f32.ceil" (f32.const 0x1.fffffep-1)) (f32.const 1.0))
+(assert_return (invoke "f32.ceil" (f32.const 0x1.000002p+0)) (f32.const 2.0))
+(assert_return (invoke "f64.ceil" (f64.const 0x1.fffffffffffffp-1)) (f64.const 1.0))
+(assert_return (invoke "f64.ceil" (f64.const 0x1.0000000000001p+0)) (f64.const 2.0))
+
+;; Test the maximum and minimum value for which ceil is not an identity operator.
+(assert_return (invoke "f32.ceil" (f32.const 0x1.fffffep+22)) (f32.const 0x1p+23))
+(assert_return (invoke "f32.ceil" (f32.const -0x1.fffffep+22)) (f32.const -0x1.fffffcp+22))
+(assert_return (invoke "f64.ceil" (f64.const 0x1.fffffffffffffp+51)) (f64.const 0x1p+52))
+(assert_return (invoke "f64.ceil" (f64.const -0x1.fffffffffffffp+51)) (f64.const -0x1.ffffffffffffep+51))
+
+;; Test that implementations don't do the x+0x1p52-0x1p52 trick outside the
+;; range where it's safe.
+(assert_return (invoke "f32.ceil" (f32.const 0x1.fffffep+23)) (f32.const 0x1.fffffep+23))
+(assert_return (invoke "f32.ceil" (f32.const -0x1.fffffep+23)) (f32.const -0x1.fffffep+23))
+(assert_return (invoke "f64.ceil" (f64.const 0x1.fffffffffffffp+52)) (f64.const 0x1.fffffffffffffp+52))
+(assert_return (invoke "f64.ceil" (f64.const -0x1.fffffffffffffp+52)) (f64.const -0x1.fffffffffffffp+52))
+
+;; Test values close to -1.0.
+(assert_return (invoke "f32.floor" (f32.const -0x1.fffffep-1)) (f32.const -1.0))
+(assert_return (invoke "f32.floor" (f32.const -0x1.000002p+0)) (f32.const -2.0))
+(assert_return (invoke "f64.floor" (f64.const -0x1.fffffffffffffp-1)) (f64.const -1.0))
+(assert_return (invoke "f64.floor" (f64.const -0x1.0000000000001p+0)) (f64.const -2.0))
+
+;; Test the maximum and minimum value for which floor is not an identity operator.
+(assert_return (invoke "f32.floor" (f32.const -0x1.fffffep+22)) (f32.const -0x1p+23))
+(assert_return (invoke "f32.floor" (f32.const 0x1.fffffep+22)) (f32.const 0x1.fffffcp+22))
+(assert_return (invoke "f64.floor" (f64.const -0x1.fffffffffffffp+51)) (f64.const -0x1p+52))
+(assert_return (invoke "f64.floor" (f64.const 0x1.fffffffffffffp+51)) (f64.const 0x1.ffffffffffffep+51))
+
+;; Test that floor isn't implemented as XMVectorFloor.
+;; http://dss.stephanierct.com/DevBlog/?p=8#comment-4
+(assert_return (invoke "f32.floor" (f32.const 88607.0)) (f32.const 88607.0))
+(assert_return (invoke "f64.floor" (f64.const 88607.0)) (f64.const 88607.0))
+
+;; Test the maximum and minimum value for which trunc is not an identity operator.
+(assert_return (invoke "f32.trunc" (f32.const -0x1.fffffep+22)) (f32.const -0x1.fffffcp+22))
+(assert_return (invoke "f32.trunc" (f32.const 0x1.fffffep+22)) (f32.const 0x1.fffffcp+22))
+(assert_return (invoke "f64.trunc" (f64.const -0x1.fffffffffffffp+51)) (f64.const -0x1.ffffffffffffep+51))
+(assert_return (invoke "f64.trunc" (f64.const 0x1.fffffffffffffp+51)) (f64.const 0x1.ffffffffffffep+51))
+
+;; Test that nearest isn't implemented naively.
+;; http://blog.frama-c.com/index.php?post/2013/05/02/nearbyintf1
+;; http://blog.frama-c.com/index.php?post/2013/05/04/nearbyintf3
+(assert_return (invoke "f32.nearest" (f32.const 0x1.000002p+23)) (f32.const 0x1.000002p+23))
+(assert_return (invoke "f32.nearest" (f32.const 0x1.000004p+23)) (f32.const 0x1.000004p+23))
+(assert_return (invoke "f32.nearest" (f32.const 0x1.fffffep-2)) (f32.const 0.0))
+(assert_return (invoke "f32.nearest" (f32.const 0x1.fffffep+47)) (f32.const 0x1.fffffep+47))
+(assert_return (invoke "f64.nearest" (f64.const 0x1.0000000000001p+52)) (f64.const 0x1.0000000000001p+52))
+(assert_return (invoke "f64.nearest" (f64.const 0x1.0000000000002p+52)) (f64.const 0x1.0000000000002p+52))
+(assert_return (invoke "f64.nearest" (f64.const 0x1.fffffffffffffp-2)) (f64.const 0.0))
+(assert_return (invoke "f64.nearest" (f64.const 0x1.fffffffffffffp+105)) (f64.const 0x1.fffffffffffffp+105))
+
+;; Nearest should not round halfway cases away from zero (as C's round(3) does)
+;; or up (as JS's Math.round does).
+(assert_return (invoke "f32.nearest" (f32.const 4.5)) (f32.const 4.0))
+(assert_return (invoke "f32.nearest" (f32.const -4.5)) (f32.const -4.0))
+(assert_return (invoke "f32.nearest" (f32.const -3.5)) (f32.const -4.0))
+(assert_return (invoke "f64.nearest" (f64.const 4.5)) (f64.const 4.0))
+(assert_return (invoke "f64.nearest" (f64.const -4.5)) (f64.const -4.0))
+(assert_return (invoke "f64.nearest" (f64.const -3.5)) (f64.const -4.0))
+
+;; Test the maximum and minimum value for which nearest is not an identity operator.
+(assert_return (invoke "f32.nearest" (f32.const -0x1.fffffep+22)) (f32.const -0x1p+23))
+(assert_return (invoke "f32.nearest" (f32.const 0x1.fffffep+22)) (f32.const 0x1p+23))
+(assert_return (invoke "f64.nearest" (f64.const -0x1.fffffffffffffp+51)) (f64.const -0x1p+52))
+(assert_return (invoke "f64.nearest" (f64.const 0x1.fffffffffffffp+51)) (f64.const 0x1p+52))
diff --git a/tests/wast/spec/proposals/gc/func.wast b/tests/wast/spec/proposals/gc/func.wast
index a5e0ec7574..f2d18cc9f1 100644
--- a/tests/wast/spec/proposals/gc/func.wast
+++ b/tests/wast/spec/proposals/gc/func.wast
@@ -639,15 +639,6 @@
   )
   "unknown type"
 )
-(assert_invalid
-  (module
-    (type $t (func))
-    (func $f (drop (let (result (ref $t)) (ref.func $g))))
-    (func $g (type 4))
-    (elem declare func $g)
-  )
-  "unknown type"
-)
 
 
 ;; Invalid typing of locals
@@ -666,8 +657,11 @@
 )
 
 (assert_invalid
-  (module (type $t (func)) (func $type-local-no-default (local (ref $t))))
-  "non-defaultable local type"
+  (module
+    (type $t (func))
+    (func $type-local-uninitialized (local $x (ref $t)) (drop (local.get $x)))
+  )
+  "uninitialized local"
 )
 
 
@@ -967,22 +961,28 @@
 
 ;; Duplicate name errors
 
-(assert_malformed (module quote
-  "(func $foo)"
-  "(func $foo)")
-  "duplicate func")
-(assert_malformed (module quote
-  "(import \"\" \"\" (func $foo))"
-  "(func $foo)")
-  "duplicate func")
-(assert_malformed (module quote
-  "(import \"\" \"\" (func $foo))"
-  "(import \"\" \"\" (func $foo))")
-  "duplicate func")
-
-(assert_malformed (module quote "(func (param $foo i32) (param $foo i32))")
-  "duplicate local")
-(assert_malformed (module quote "(func (param $foo i32) (local $foo i32))")
-  "duplicate local")
-(assert_malformed (module quote "(func (local $foo i32) (local $foo i32))")
-  "duplicate local")
+(assert_malformed
+  (module quote "(func $foo)" "(func $foo)")
+  "duplicate func"
+)
+(assert_malformed
+  (module quote "(import \"\" \"\" (func $foo))" "(func $foo)")
+  "duplicate func"
+)
+(assert_malformed
+  (module quote "(import \"\" \"\" (func $foo))" "(import \"\" \"\" (func $foo))")
+  "duplicate func"
+)
+
+(assert_malformed
+  (module quote "(func (param $foo i32) (param $foo i32))")
+  "duplicate local"
+)
+(assert_malformed
+  (module quote "(func (param $foo i32) (local $foo i32))")
+  "duplicate local"
+)
+(assert_malformed
+  (module quote "(func (local $foo i32) (local $foo i32))")
+  "duplicate local"
+)
diff --git a/tests/wast/spec/proposals/gc/global.wast b/tests/wast/spec/proposals/gc/global.wast
new file mode 100644
index 0000000000..8c47fde2f1
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/global.wast
@@ -0,0 +1,693 @@
+;; Test globals
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (global (import "spectest" "global_i64") i64)
+
+  (global $a i32 (i32.const -2))
+  (global (;3;) f32 (f32.const -3))
+  (global (;4;) f64 (f64.const -4))
+  (global $b i64 (i64.const -5))
+
+  (global $x (mut i32) (i32.const -12))
+  (global (;7;) (mut f32) (f32.const -13))
+  (global (;8;) (mut f64) (f64.const -14))
+  (global $y (mut i64) (i64.const -15))
+
+  (global $z1 i32 (global.get 0))
+  (global $z2 i64 (global.get 1))
+
+  (global $r externref (ref.null extern))
+  (global $mr (mut externref) (ref.null extern))
+  (global funcref (ref.null func))
+
+  (func (export "get-a") (result i32) (global.get $a))
+  (func (export "get-b") (result i64) (global.get $b))
+  (func (export "get-r") (result externref) (global.get $r))
+  (func (export "get-mr") (result externref) (global.get $mr))
+  (func (export "get-x") (result i32) (global.get $x))
+  (func (export "get-y") (result i64) (global.get $y))
+  (func (export "get-z1") (result i32) (global.get $z1))
+  (func (export "get-z2") (result i64) (global.get $z2))
+  (func (export "set-x") (param i32) (global.set $x (local.get 0)))
+  (func (export "set-y") (param i64) (global.set $y (local.get 0)))
+  (func (export "set-mr") (param externref) (global.set $mr (local.get 0)))
+
+  (func (export "get-3") (result f32) (global.get 3))
+  (func (export "get-4") (result f64) (global.get 4))
+  (func (export "get-7") (result f32) (global.get 7))
+  (func (export "get-8") (result f64) (global.get 8))
+  (func (export "set-7") (param f32) (global.set 7 (local.get 0)))
+  (func (export "set-8") (param f64) (global.set 8 (local.get 0)))
+
+  ;; As the argument of control constructs and instructions
+
+  (memory 1)
+
+  (func $dummy)
+
+  (func (export "as-select-first") (result i32)
+    (select (global.get $x) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (global.get $x) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (global.get $x))
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (loop (result i32)
+      (global.get $x) (call $dummy) (call $dummy)
+    )
+  )
+  (func (export "as-loop-mid") (result i32)
+    (loop (result i32)
+      (call $dummy) (global.get $x) (call $dummy)
+    )
+  )
+  (func (export "as-loop-last") (result i32)
+    (loop (result i32)
+      (call $dummy) (call $dummy) (global.get $x)
+    )
+  )
+
+  (func (export "as-if-condition") (result i32)
+    (if (result i32) (global.get $x)
+      (then (call $dummy) (i32.const 2))
+      (else (call $dummy) (i32.const 3))
+    )
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1)
+      (then (global.get $x)) (else (i32.const 2))
+    )
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 0)
+      (then (i32.const 2)) (else (global.get $x))
+    )
+  )
+
+  (func (export "as-br_if-first") (result i32)
+    (block (result i32)
+      (br_if 0 (global.get $x) (i32.const 2))
+      (return (i32.const 3))
+    )
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32)
+      (br_if 0 (i32.const 2) (global.get $x))
+      (return (i32.const 3))
+    )
+  )
+
+  (func (export "as-br_table-first") (result i32)
+    (block (result i32)
+      (global.get $x) (i32.const 2) (br_table 0 0)
+    )
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32)
+      (i32.const 2) (global.get $x) (br_table 0 0)
+    )
+  )
+
+  (func $func (param i32 i32) (result i32) (local.get 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table funcref (elem $func))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (global.get $x) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2) (global.get $x) (i32.const 0)
+      )
+    )
+  )
+ (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2) (i32.const 0) (global.get $x)
+      )
+    )
+  )
+
+  (func (export "as-store-first")
+    (global.get $x) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 0) (global.get $x) (i32.store)
+  )
+  (func (export "as-load-operand") (result i32)
+    (i32.load (global.get $x))
+  )
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (global.get $x))
+  )
+
+  (func $f (param i32) (result i32) (local.get 0))
+  (func (export "as-call-value") (result i32)
+    (call $f (global.get $x))
+  )
+
+  (func (export "as-return-value") (result i32)
+    (global.get $x) (return)
+  )
+  (func (export "as-drop-operand")
+    (drop (global.get $x))
+  )
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (global.get $x)))
+  )
+
+  (func (export "as-local.set-value") (param i32) (result i32)
+    (local.set 0 (global.get $x))
+    (local.get 0)
+  )
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (local.tee 0 (global.get $x))
+  )
+  (func (export "as-global.set-value") (result i32)
+    (global.set $x (global.get $x))
+    (global.get $x)
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.eqz (global.get $x))
+  )
+  (func (export "as-binary-operand") (result i32)
+    (i32.mul
+      (global.get $x) (global.get $x)
+    )
+  )
+  (func (export "as-compare-operand") (result i32)
+    (i32.gt_u
+      (global.get 0) (i32.const 1)
+    )
+  )
+)
+
+(assert_return (invoke "get-a") (i32.const -2))
+(assert_return (invoke "get-b") (i64.const -5))
+(assert_return (invoke "get-r") (ref.null extern))
+(assert_return (invoke "get-mr") (ref.null extern))
+(assert_return (invoke "get-x") (i32.const -12))
+(assert_return (invoke "get-y") (i64.const -15))
+(assert_return (invoke "get-z1") (i32.const 666))
+(assert_return (invoke "get-z2") (i64.const 666))
+
+(assert_return (invoke "get-3") (f32.const -3))
+(assert_return (invoke "get-4") (f64.const -4))
+(assert_return (invoke "get-7") (f32.const -13))
+(assert_return (invoke "get-8") (f64.const -14))
+
+(assert_return (invoke "set-x" (i32.const 6)))
+(assert_return (invoke "set-y" (i64.const 7)))
+
+(assert_return (invoke "set-7" (f32.const 8)))
+(assert_return (invoke "set-8" (f64.const 9)))
+
+(assert_return (invoke "get-x") (i32.const 6))
+(assert_return (invoke "get-y") (i64.const 7))
+(assert_return (invoke "get-7") (f32.const 8))
+(assert_return (invoke "get-8") (f64.const 9))
+
+(assert_return (invoke "set-7" (f32.const 8)))
+(assert_return (invoke "set-8" (f64.const 9)))
+(assert_return (invoke "set-mr" (ref.extern 10)))
+
+(assert_return (invoke "get-x") (i32.const 6))
+(assert_return (invoke "get-y") (i64.const 7))
+(assert_return (invoke "get-7") (f32.const 8))
+(assert_return (invoke "get-8") (f64.const 9))
+(assert_return (invoke "get-mr") (ref.extern 10))
+
+(assert_return (invoke "as-select-first") (i32.const 6))
+(assert_return (invoke "as-select-mid") (i32.const 2))
+(assert_return (invoke "as-select-last") (i32.const 2))
+
+(assert_return (invoke "as-loop-first") (i32.const 6))
+(assert_return (invoke "as-loop-mid") (i32.const 6))
+(assert_return (invoke "as-loop-last") (i32.const 6))
+
+(assert_return (invoke "as-if-condition") (i32.const 2))
+(assert_return (invoke "as-if-then") (i32.const 6))
+(assert_return (invoke "as-if-else") (i32.const 6))
+
+(assert_return (invoke "as-br_if-first") (i32.const 6))
+(assert_return (invoke "as-br_if-last") (i32.const 2))
+
+(assert_return (invoke "as-br_table-first") (i32.const 6))
+(assert_return (invoke "as-br_table-last") (i32.const 2))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const 6))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 2))
+(assert_trap (invoke "as-call_indirect-last") "undefined element")
+
+(assert_return (invoke "as-store-first"))
+(assert_return (invoke "as-store-last"))
+(assert_return (invoke "as-load-operand") (i32.const 1))
+(assert_return (invoke "as-memory.grow-value") (i32.const 1))
+
+(assert_return (invoke "as-call-value") (i32.const 6))
+
+(assert_return (invoke "as-return-value") (i32.const 6))
+(assert_return (invoke "as-drop-operand"))
+(assert_return (invoke "as-br-value") (i32.const 6))
+
+(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 6))
+(assert_return (invoke "as-local.tee-value" (i32.const 1)) (i32.const 6))
+(assert_return (invoke "as-global.set-value") (i32.const 6))
+
+(assert_return (invoke "as-unary-operand") (i32.const 0))
+(assert_return (invoke "as-binary-operand") (i32.const 36))
+(assert_return (invoke "as-compare-operand") (i32.const 1))
+
+(assert_invalid
+  (module (global f32 (f32.const 0)) (func (global.set 0 (f32.const 1))))
+  "immutable global"
+)
+
+(assert_invalid
+  (module (import "spectest" "global_i32" (global i32)) (func (global.set 0 (i32.const 1))))
+  "immutable global"
+)
+
+;; mutable globals can be exported
+(module (global (mut f32) (f32.const 0)) (export "a" (global 0)))
+(module (global (export "a") (mut f32) (f32.const 0)))
+
+(assert_invalid
+  (module (global f32 (f32.neg (f32.const 0))))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global f32 (local.get 0)))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global f32 (f32.neg (f32.const 1))))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global i32 (i32.const 0) (nop)))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global i32 (i32.ctz (i32.const 0))))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global i32 (nop)))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global i32 (f32.const 0)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (global i32 (i32.const 0) (i32.const 0)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (global i32 (;empty instruction sequence;)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (global (import "" "") externref) (global funcref (global.get 0)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (global (import "test" "global-i32") i32) (global i32 (global.get 0) (global.get 0)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (global (import "test" "global-i32") i32) (global i32 (i32.const 0) (global.get 0)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (global i32 (global.get 0)))
+  "unknown global"
+)
+
+(assert_invalid
+  (module (global i32 (global.get 1)) (global i32 (i32.const 0)))
+  "unknown global"
+)
+
+(assert_invalid
+  (module (global (import "test" "global-i32") i32) (global i32 (global.get 2)))
+  "unknown global"
+)
+
+(module (global i32 (i32.const 0)) (global i32 (global.get 0)))
+(module (global $g i32 (i32.const 0)) (global i32 (global.get $g)))
+
+(assert_invalid
+  (module (global (import "test" "global-mut-i32") (mut i32)) (global i32 (global.get 0)))
+  "constant expression required"
+)
+
+(module
+  (import "spectest" "global_i32" (global i32))
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\98\80\80\80\00"             ;; import section
+      "\01"                          ;; length 1
+      "\08\73\70\65\63\74\65\73\74"  ;; "spectest"
+      "\0a\67\6c\6f\62\61\6c\5f\69\33\32" ;; "global_i32"
+      "\03"                          ;; GlobalImport
+      "\7f"                          ;; i32
+      "\02"                          ;; malformed mutability
+  )
+  "malformed mutability"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\98\80\80\80\00"             ;; import section
+      "\01"                          ;; length 1
+      "\08\73\70\65\63\74\65\73\74"  ;; "spectest"
+      "\0a\67\6c\6f\62\61\6c\5f\69\33\32" ;; "global_i32"
+      "\03"                          ;; GlobalImport
+      "\7f"                          ;; i32
+      "\ff"                          ;; malformed mutability
+  )
+  "malformed mutability"
+)
+
+(module
+  (global i32 (i32.const 0))
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\86\80\80\80\00"  ;; global section
+      "\01"               ;; length 1
+      "\7f"               ;; i32
+      "\02"               ;; malformed mutability
+      "\41\00"            ;; i32.const 0
+      "\0b"               ;; end
+  )
+  "malformed mutability"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\86\80\80\80\00"  ;; global section
+      "\01"               ;; length 1
+      "\7f"               ;; i32
+      "\ff"               ;; malformed mutability
+      "\41\00"            ;; i32.const 0
+      "\0b"               ;; end
+  )
+  "malformed mutability"
+)
+
+;; global.get with invalid index
+(assert_invalid
+  (module (func (result i32) (global.get 0)))
+  "unknown global"
+)
+
+(assert_invalid
+  (module
+    (global i32 (i32.const 0))
+    (func (result i32) (global.get 1))
+  )
+  "unknown global"
+)
+
+(assert_invalid
+  (module
+    (import "spectest" "global_i32" (global i32))
+    (func (result i32) (global.get 1))
+  )
+  "unknown global"
+)
+
+(assert_invalid
+  (module
+    (import "spectest" "global_i32" (global i32))
+    (global i32 (i32.const 0))
+    (func (result i32) (global.get 2))
+  )
+  "unknown global"
+)
+
+;; global.set with invalid index
+(assert_invalid
+  (module (func (i32.const 0) (global.set 0)))
+  "unknown global"
+)
+
+(assert_invalid
+  (module
+    (global i32 (i32.const 0))
+    (func (i32.const 0) (global.set 1))
+  )
+  "unknown global"
+)
+
+(assert_invalid
+  (module
+    (import "spectest" "global_i32" (global i32))
+    (func (i32.const 0) (global.set 1))
+  )
+  "unknown global"
+)
+
+(assert_invalid
+  (module
+    (import "spectest" "global_i32" (global i32))
+    (global i32 (i32.const 0))
+    (func (i32.const 0) (global.set 2))
+  )
+  "unknown global"
+)
+
+
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty
+      (global.set $x)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-block
+      (i32.const 0)
+      (block (global.set $x))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-loop
+      (i32.const 0)
+      (loop (global.set $x))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (global.set $x)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-else
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (global.set $x)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-br
+      (i32.const 0)
+      (block (br 0 (global.set $x)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-br_if
+      (i32.const 0)
+      (block (br_if 0 (global.set $x)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-br_table
+      (i32.const 0)
+      (block (br_table 0 (global.set $x)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-return
+      (return (global.set $x))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-select
+      (select (global.set $x) (i32.const 1) (i32.const 2))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-call
+      (call 1 (global.set $x))
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $f (param i32) (result i32) (local.get 0))
+    (type $sig (func (param i32) (result i32)))
+    (table funcref (elem $f))
+    (func $type-global.set-value-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $sig)
+          (global.set $x) (i32.const 0)
+        )
+      )
+    )
+  )
+  "type mismatch"
+)
+
+
+;; Definition order
+
+(module
+  (global (export "g") i32 (i32.const 4))
+)
+(register "G")
+
+(module
+  (global $g0 (import "G" "g") i32)
+  (global $g1 i32 (i32.const 8))
+  (global $g2 i32 (global.get $g0))
+  (global $g3 i32 (global.get $g1))
+
+  (global $gf funcref (ref.func $f))
+  (func $f)
+
+  (table $t 10 funcref (ref.null func))
+  (elem (table $t) (global.get $g2) funcref (ref.func $f))
+  (elem (table $t) (global.get $g3) funcref (global.get $gf))
+
+  (memory $m 1)
+  (data (global.get $g2) "\44\44\44\44")
+  (data (global.get $g3) "\88\88\88\88")
+
+  (func (export "get-elem") (param $i i32) (result funcref)
+    (table.get $t (local.get $i))
+  )
+  (func (export "get-data") (param $i i32) (result i32)
+    (i32.load (local.get $i))
+  )
+)
+
+(assert_return (invoke "get-elem" (i32.const 0)) (ref.null))
+(assert_return (invoke "get-elem" (i32.const 4)) (ref.func))
+(assert_return (invoke "get-elem" (i32.const 8)) (ref.func))
+
+(assert_return (invoke "get-data" (i32.const 4)) (i32.const 0x44444444))
+(assert_return (invoke "get-data" (i32.const 8)) (i32.const 0x88888888))
+
+(assert_invalid
+  (module 
+    (global $g1 i32 (global.get $g2))
+    (global $g2 i32 (i32.const 0))
+  )
+  "unknown global"
+)
+
+(assert_invalid
+  (module
+    (global $g funcref (ref.null func))
+    (table $t 10 funcref (global.get $g))
+  )
+  "unknown global"
+)
+
+
+;; Duplicate identifier errors
+
+(assert_malformed
+  (module quote
+    "(global $foo i32 (i32.const 0))"
+    "(global $foo i32 (i32.const 0))"
+  )
+  "duplicate global"
+)
+(assert_malformed
+  (module quote
+    "(import \"\" \"\" (global $foo i32))"
+    "(global $foo i32 (i32.const 0))"
+  )
+  "duplicate global"
+)
+(assert_malformed
+  (module quote
+    "(import \"\" \"\" (global $foo i32))"
+    "(import \"\" \"\" (global $foo i32))"
+  )
+  "duplicate global"
+)
diff --git a/tests/wast/spec/proposals/gc/i31.wast b/tests/wast/spec/proposals/gc/i31.wast
index ade957fc41..7485650454 100644
--- a/tests/wast/spec/proposals/gc/i31.wast
+++ b/tests/wast/spec/proposals/gc/i31.wast
@@ -1,13 +1,32 @@
 (module
   (func (export "new") (param $i i32) (result (ref i31))
-    (i31.new (local.get $i))
+    (ref.i31 (local.get $i))
   )
 
   (func (export "get_u") (param $i i32) (result i32)
-    (i31.get_u (i31.new (local.get $i)))
+    (i31.get_u (ref.i31 (local.get $i)))
   )
   (func (export "get_s") (param $i i32) (result i32)
-    (i31.get_s (i31.new (local.get $i)))
+    (i31.get_s (ref.i31 (local.get $i)))
+  )
+
+  (func (export "get_u-null") (result i32)
+    (i31.get_u (ref.null i31))
+  )
+  (func (export "get_s-null") (result i32)
+    (i31.get_u (ref.null i31))
+  )
+
+  (global $i (ref i31) (ref.i31 (i32.const 2)))
+  (global $m (mut (ref i31)) (ref.i31 (i32.const 3)))
+
+  (func (export "get_globals") (result i32 i32)
+    (i31.get_u (global.get $i))
+    (i31.get_u (global.get $m))
+  )
+
+  (func (export "set_global") (param i32)
+    (global.set $m (ref.i31 (local.get 0)))
   )
 )
 
@@ -30,3 +49,180 @@
 (assert_return (invoke "get_s" (i32.const 0x7fff_ffff)) (i32.const -1))
 (assert_return (invoke "get_s" (i32.const 0xaaaa_aaaa)) (i32.const 0x2aaa_aaaa))
 (assert_return (invoke "get_s" (i32.const 0xcaaa_aaaa)) (i32.const 0xcaaa_aaaa))
+
+(assert_trap (invoke "get_u-null") "null i31 reference")
+(assert_trap (invoke "get_s-null") "null i31 reference")
+
+(assert_return (invoke "get_globals") (i32.const 2) (i32.const 3))
+
+(invoke "set_global" (i32.const 1234))
+(assert_return (invoke "get_globals") (i32.const 2) (i32.const 1234))
+
+(module $tables_of_i31ref
+  (table $table 3 10 i31ref)
+  (elem (table $table) (i32.const 0) i31ref (item (ref.i31 (i32.const 999)))
+                                            (item (ref.i31 (i32.const 888)))
+                                            (item (ref.i31 (i32.const 777))))
+
+  (func (export "size") (result i32)
+    table.size $table
+  )
+
+  (func (export "get") (param i32) (result i32)
+    (i31.get_u (table.get $table (local.get 0)))
+  )
+
+  (func (export "grow") (param i32 i32) (result i32)
+    (table.grow $table (ref.i31 (local.get 1)) (local.get 0))
+  )
+
+  (func (export "fill") (param i32 i32 i32)
+    (table.fill $table (local.get 0) (ref.i31 (local.get 1)) (local.get 2))
+  )
+
+  (func (export "copy") (param i32 i32 i32)
+    (table.copy $table $table (local.get 0) (local.get 1) (local.get 2))
+  )
+
+  (elem $elem i31ref (item (ref.i31 (i32.const 123)))
+                     (item (ref.i31 (i32.const 456)))
+                     (item (ref.i31 (i32.const 789))))
+  (func (export "init") (param i32 i32 i32)
+    (table.init $table $elem (local.get 0) (local.get 1) (local.get 2))
+  )
+)
+
+;; Initial state.
+(assert_return (invoke "size") (i32.const 3))
+(assert_return (invoke "get" (i32.const 0)) (i32.const 999))
+(assert_return (invoke "get" (i32.const 1)) (i32.const 888))
+(assert_return (invoke "get" (i32.const 2)) (i32.const 777))
+
+;; Grow from size 3 to size 5.
+(assert_return (invoke "grow" (i32.const 2) (i32.const 333)) (i32.const 3))
+(assert_return (invoke "size") (i32.const 5))
+(assert_return (invoke "get" (i32.const 3)) (i32.const 333))
+(assert_return (invoke "get" (i32.const 4)) (i32.const 333))
+
+;; Fill table[2..4] = 111.
+(invoke "fill" (i32.const 2) (i32.const 111) (i32.const 2))
+(assert_return (invoke "get" (i32.const 2)) (i32.const 111))
+(assert_return (invoke "get" (i32.const 3)) (i32.const 111))
+
+;; Copy from table[0..2] to table[3..5].
+(invoke "copy" (i32.const 3) (i32.const 0) (i32.const 2))
+(assert_return (invoke "get" (i32.const 3)) (i32.const 999))
+(assert_return (invoke "get" (i32.const 4)) (i32.const 888))
+
+;; Initialize the passive element at table[1..4].
+(invoke "init" (i32.const 1) (i32.const 0) (i32.const 3))
+(assert_return (invoke "get" (i32.const 1)) (i32.const 123))
+(assert_return (invoke "get" (i32.const 2)) (i32.const 456))
+(assert_return (invoke "get" (i32.const 3)) (i32.const 789))
+
+(module $env
+  (global (export "g") i32 (i32.const 42))
+)
+(register "env")
+
+(module $i31ref_of_global_table_initializer
+  (global $g (import "env" "g") i32)
+  (table $t 3 3 (ref i31) (ref.i31 (global.get $g)))
+  (func (export "get") (param i32) (result i32)
+    (i31.get_u (local.get 0) (table.get $t))
+  )
+)
+
+(assert_return (invoke "get" (i32.const 0)) (i32.const 42))
+(assert_return (invoke "get" (i32.const 1)) (i32.const 42))
+(assert_return (invoke "get" (i32.const 2)) (i32.const 42))
+
+(module $i31ref_of_global_global_initializer
+  (global $g0 (import "env" "g") i32)
+  (global $g1 i31ref (ref.i31 (global.get $g0)))
+  (func (export "get") (result i32)
+    (i31.get_u (global.get $g1))
+  )
+)
+
+(assert_return (invoke "get") (i32.const 42))
+
+(module $anyref_global_of_i31ref
+  (global $c anyref (ref.i31 (i32.const 1234)))
+  (global $m (mut anyref) (ref.i31 (i32.const 5678)))
+
+  (func (export "get_globals") (result i32 i32)
+    (i31.get_u (ref.cast i31ref (global.get $c)))
+    (i31.get_u (ref.cast i31ref (global.get $m)))
+  )
+
+  (func (export "set_global") (param i32)
+    (global.set $m (ref.i31 (local.get 0)))
+  )
+)
+
+(assert_return (invoke "get_globals") (i32.const 1234) (i32.const 5678))
+(invoke "set_global" (i32.const 0))
+(assert_return (invoke "get_globals") (i32.const 1234) (i32.const 0))
+
+(module $anyref_table_of_i31ref
+  (table $table 3 10 anyref)
+  (elem (table $table) (i32.const 0) i31ref (item (ref.i31 (i32.const 999)))
+                                            (item (ref.i31 (i32.const 888)))
+                                            (item (ref.i31 (i32.const 777))))
+
+  (func (export "size") (result i32)
+    table.size $table
+  )
+
+  (func (export "get") (param i32) (result i32)
+    (i31.get_u (ref.cast i31ref (table.get $table (local.get 0))))
+  )
+
+  (func (export "grow") (param i32 i32) (result i32)
+    (table.grow $table (ref.i31 (local.get 1)) (local.get 0))
+  )
+
+  (func (export "fill") (param i32 i32 i32)
+    (table.fill $table (local.get 0) (ref.i31 (local.get 1)) (local.get 2))
+  )
+
+  (func (export "copy") (param i32 i32 i32)
+    (table.copy $table $table (local.get 0) (local.get 1) (local.get 2))
+  )
+
+  (elem $elem i31ref (item (ref.i31 (i32.const 123)))
+                     (item (ref.i31 (i32.const 456)))
+                     (item (ref.i31 (i32.const 789))))
+  (func (export "init") (param i32 i32 i32)
+    (table.init $table $elem (local.get 0) (local.get 1) (local.get 2))
+  )
+)
+
+;; Initial state.
+(assert_return (invoke "size") (i32.const 3))
+(assert_return (invoke "get" (i32.const 0)) (i32.const 999))
+(assert_return (invoke "get" (i32.const 1)) (i32.const 888))
+(assert_return (invoke "get" (i32.const 2)) (i32.const 777))
+
+;; Grow from size 3 to size 5.
+(assert_return (invoke "grow" (i32.const 2) (i32.const 333)) (i32.const 3))
+(assert_return (invoke "size") (i32.const 5))
+(assert_return (invoke "get" (i32.const 3)) (i32.const 333))
+(assert_return (invoke "get" (i32.const 4)) (i32.const 333))
+
+;; Fill table[2..4] = 111.
+(invoke "fill" (i32.const 2) (i32.const 111) (i32.const 2))
+(assert_return (invoke "get" (i32.const 2)) (i32.const 111))
+(assert_return (invoke "get" (i32.const 3)) (i32.const 111))
+
+;; Copy from table[0..2] to table[3..5].
+(invoke "copy" (i32.const 3) (i32.const 0) (i32.const 2))
+(assert_return (invoke "get" (i32.const 3)) (i32.const 999))
+(assert_return (invoke "get" (i32.const 4)) (i32.const 888))
+
+;; Initialize the passive element at table[1..4].
+(invoke "init" (i32.const 1) (i32.const 0) (i32.const 3))
+(assert_return (invoke "get" (i32.const 1)) (i32.const 123))
+(assert_return (invoke "get" (i32.const 2)) (i32.const 456))
+(assert_return (invoke "get" (i32.const 3)) (i32.const 789))
diff --git a/tests/wast/spec/proposals/gc/if.wast b/tests/wast/spec/proposals/gc/if.wast
index 553f90d20e..35a4cf6cb9 100644
--- a/tests/wast/spec/proposals/gc/if.wast
+++ b/tests/wast/spec/proposals/gc/if.wast
@@ -524,6 +524,14 @@
     )
     (drop) (drop) (drop)
   )
+
+  ;; Atypical folded condition syntax
+
+  (func (export "atypical-condition")
+    i32.const 0
+    (if (then) (else))
+    (if (i32.const 1) (i32.eqz) (then) (else))
+  )
 )
 
 (assert_return (invoke "empty" (i32.const 0)))
@@ -722,6 +730,8 @@
 
 (assert_return (invoke "type-use"))
 
+(assert_return (invoke "atypical-condition"))
+
 (assert_malformed
   (module quote
     "(type $sig (func (param i32) (result i32)))"
@@ -1548,3 +1558,7 @@
   (module quote "(func i32.const 0 if $a else $l end $l)")
   "mismatching label"
 )
+(assert_malformed
+  (module quote "(func (if i32.const 0 (then) (else)))")
+  "unexpected token"
+)
diff --git a/tests/wast/spec/proposals/gc/imports.wast b/tests/wast/spec/proposals/gc/imports.wast
new file mode 100644
index 0000000000..0cc07cb1a9
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/imports.wast
@@ -0,0 +1,697 @@
+;; Auxiliary module to import from
+
+(module
+  (func (export "func"))
+  (func (export "func-i32") (param i32))
+  (func (export "func-f32") (param f32))
+  (func (export "func->i32") (result i32) (i32.const 22))
+  (func (export "func->f32") (result f32) (f32.const 11))
+  (func (export "func-i32->i32") (param i32) (result i32) (local.get 0))
+  (func (export "func-i64->i64") (param i64) (result i64) (local.get 0))
+  (global (export "global-i32") i32 (i32.const 55))
+  (global (export "global-f32") f32 (f32.const 44))
+  (global (export "global-mut-i64") (mut i64) (i64.const 66))
+  (table (export "table-10-inf") 10 funcref)
+  (table (export "table-10-20") 10 20 funcref)
+  (memory (export "memory-2-inf") 2)
+  ;; Multiple memories are not yet supported
+  ;; (memory (export "memory-2-4") 2 4)
+)
+
+(register "test")
+
+
+;; Functions
+
+(module
+  (type $func_i32 (func (param i32)))
+  (type $func_i64 (func (param i64)))
+  (type $func_f32 (func (param f32)))
+  (type $func_f64 (func (param f64)))
+
+  (import "spectest" "print_i32" (func (param i32)))
+  (func (import "spectest" "print_i64") (param i64))
+  (import "spectest" "print_i32" (func $print_i32 (param i32)))
+  (import "spectest" "print_i64" (func $print_i64 (param i64)))
+  (import "spectest" "print_f32" (func $print_f32 (param f32)))
+  (import "spectest" "print_f64" (func $print_f64 (param f64)))
+  (import "spectest" "print_i32_f32" (func $print_i32_f32 (param i32 f32)))
+  (import "spectest" "print_f64_f64" (func $print_f64_f64 (param f64 f64)))
+  (func $print_i32-2 (import "spectest" "print_i32") (param i32))
+  (func $print_f64-2 (import "spectest" "print_f64") (param f64))
+  (import "test" "func-i64->i64" (func $i64->i64 (param i64) (result i64)))
+
+  (func (export "p1") (import "spectest" "print_i32") (param i32))
+  (func $p (export "p2") (import "spectest" "print_i32") (param i32))
+  (func (export "p3") (export "p4") (import "spectest" "print_i32") (param i32))
+  (func (export "p5") (import "spectest" "print_i32") (type 0))
+  (func (export "p6") (import "spectest" "print_i32") (type 0) (param i32) (result))
+
+  (import "spectest" "print_i32" (func (type $forward)))
+  (func (import "spectest" "print_i32") (type $forward))
+  (type $forward (func (param i32)))
+
+  (table funcref (elem $print_i32 $print_f64))
+
+  (func (export "print32") (param $i i32)
+    (local $x f32)
+    (local.set $x (f32.convert_i32_s (local.get $i)))
+    (call 0 (local.get $i))
+    (call $print_i32_f32
+      (i32.add (local.get $i) (i32.const 1))
+      (f32.const 42)
+    )
+    (call $print_i32 (local.get $i))
+    (call $print_i32-2 (local.get $i))
+    (call $print_f32 (local.get $x))
+    (call_indirect (type $func_i32) (local.get $i) (i32.const 0))
+  )
+
+  (func (export "print64") (param $i i64)
+    (local $x f64)
+    (local.set $x (f64.convert_i64_s (call $i64->i64 (local.get $i))))
+    (call 1 (local.get $i))
+    (call $print_f64_f64
+      (f64.add (local.get $x) (f64.const 1))
+      (f64.const 53)
+    )
+    (call $print_i64 (local.get $i))
+    (call $print_f64 (local.get $x))
+    (call $print_f64-2 (local.get $x))
+    (call_indirect (type $func_f64) (local.get $x) (i32.const 1))
+  )
+)
+
+(assert_return (invoke "print32" (i32.const 13)))
+(assert_return (invoke "print64" (i64.const 24)))
+
+(assert_invalid
+  (module 
+    (type (func (result i32)))
+    (import "test" "func" (func (type 1)))
+  )
+  "unknown type"
+)
+
+;; Export sharing name with import
+(module
+  (import "spectest" "print_i32" (func $imported_print (param i32)))
+  (func (export "print_i32") (param $i i32)
+    (call $imported_print (local.get $i))
+  )
+)
+
+(assert_return (invoke "print_i32" (i32.const 13)))
+
+;; Export sharing name with import
+(module
+  (import "spectest" "print_i32" (func $imported_print (param i32)))
+  (func (export "print_i32") (param $i i32) (param $j i32) (result i32)
+    (i32.add (local.get $i) (local.get $j))
+  )
+)
+
+(assert_return (invoke "print_i32" (i32.const 5) (i32.const 11)) (i32.const 16))
+
+(module (import "test" "func" (func)))
+(module (import "test" "func-i32" (func (param i32))))
+(module (import "test" "func-f32" (func (param f32))))
+(module (import "test" "func->i32" (func (result i32))))
+(module (import "test" "func->f32" (func (result f32))))
+(module (import "test" "func-i32->i32" (func (param i32) (result i32))))
+(module (import "test" "func-i64->i64" (func (param i64) (result i64))))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (func)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (func)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "func" (func (param i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func" (func (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (param f32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (param i64))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (param i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (result f32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (result i64))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32->i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32->i32" (func (param i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32->i32" (func (result i32))))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "test" "global-i32" (func (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "global_i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (func)))
+  "incompatible import type"
+)
+
+
+;; Globals
+
+(module
+  (import "spectest" "global_i32" (global i32))
+  (global (import "spectest" "global_i32") i32)
+
+  (import "spectest" "global_i32" (global $x i32))
+  (global $y (import "spectest" "global_i32") i32)
+
+  (import "spectest" "global_i64" (global i64))
+  (import "spectest" "global_f32" (global f32))
+  (import "spectest" "global_f64" (global f64))
+
+  (func (export "get-0") (result i32) (global.get 0))
+  (func (export "get-1") (result i32) (global.get 1))
+  (func (export "get-x") (result i32) (global.get $x))
+  (func (export "get-y") (result i32) (global.get $y))
+  (func (export "get-4") (result i64) (global.get 4))
+  (func (export "get-5") (result f32) (global.get 5))
+  (func (export "get-6") (result f64) (global.get 6))
+)
+
+(assert_return (invoke "get-0") (i32.const 666))
+(assert_return (invoke "get-1") (i32.const 666))
+(assert_return (invoke "get-x") (i32.const 666))
+(assert_return (invoke "get-y") (i32.const 666))
+(assert_return (invoke "get-4") (i64.const 666))
+(assert_return (invoke "get-5") (f32.const 666.6))
+(assert_return (invoke "get-6") (f64.const 666.6))
+
+(module (import "test" "global-i32" (global i32)))
+(module (import "test" "global-f32" (global f32)))
+(module (import "test" "global-mut-i64" (global (mut i64))))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (global i32)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (global i32)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "global-i32" (global i64)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-i32" (global f32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-i32" (global f64)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-i32" (global (mut i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-f32" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-f32" (global i64)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-f32" (global f64)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-f32" (global (mut f32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-mut-i64" (global (mut i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-mut-i64" (global (mut f32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-mut-i64" (global (mut f64))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-mut-i64" (global i64)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "test" "func" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "print_i32" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (global i32)))
+  "incompatible import type"
+)
+
+
+;; Tables
+
+(module
+  (type (func (result i32)))
+  (import "spectest" "table" (table $tab 10 20 funcref))
+  (elem (table $tab) (i32.const 1) func $f $g)
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect $tab (type 0) (local.get 0))
+  )
+  (func $f (result i32) (i32.const 11))
+  (func $g (result i32) (i32.const 22))
+)
+
+(assert_trap (invoke "call" (i32.const 0)) "uninitialized element")
+(assert_return (invoke "call" (i32.const 1)) (i32.const 11))
+(assert_return (invoke "call" (i32.const 2)) (i32.const 22))
+(assert_trap (invoke "call" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "call" (i32.const 100)) "undefined element")
+
+
+(module
+  (type (func (result i32)))
+  (table $tab (import "spectest" "table") 10 20 funcref)
+  (elem (table $tab) (i32.const 1) func $f $g)
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect $tab (type 0) (local.get 0))
+  )
+  (func $f (result i32) (i32.const 11))
+  (func $g (result i32) (i32.const 22))
+)
+
+(assert_trap (invoke "call" (i32.const 0)) "uninitialized element")
+(assert_return (invoke "call" (i32.const 1)) (i32.const 11))
+(assert_return (invoke "call" (i32.const 2)) (i32.const 22))
+(assert_trap (invoke "call" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "call" (i32.const 100)) "undefined element")
+
+
+(module
+  (import "spectest" "table" (table 0 funcref))
+  (import "spectest" "table" (table 0 funcref))
+  (table 10 funcref)
+  (table 10 funcref)
+)
+
+(module (import "test" "table-10-inf" (table 10 funcref)))
+(module (import "test" "table-10-inf" (table 5 funcref)))
+(module (import "test" "table-10-inf" (table 0 funcref)))
+(module (import "test" "table-10-20" (table 10 funcref)))
+(module (import "test" "table-10-20" (table 5 funcref)))
+(module (import "test" "table-10-20" (table 0 funcref)))
+(module (import "test" "table-10-20" (table 10 20 funcref)))
+(module (import "test" "table-10-20" (table 5 20 funcref)))
+(module (import "test" "table-10-20" (table 0 20 funcref)))
+(module (import "test" "table-10-20" (table 10 25 funcref)))
+(module (import "test" "table-10-20" (table 5 25 funcref)))
+(module (import "test" "table-10-20" (table 0 25 funcref)))
+(module (import "spectest" "table" (table 10 funcref)))
+(module (import "spectest" "table" (table 5 funcref)))
+(module (import "spectest" "table" (table 0 funcref)))
+(module (import "spectest" "table" (table 10 20 funcref)))
+(module (import "spectest" "table" (table 5 20 funcref)))
+(module (import "spectest" "table" (table 0 20 funcref)))
+(module (import "spectest" "table" (table 10 25 funcref)))
+(module (import "spectest" "table" (table 5 25 funcref)))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (table 10 funcref)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (table 10 funcref)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (table 12 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (table 10 20 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-20" (table 12 20 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-20" (table 10 18 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (table 12 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (table 10 15 funcref)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "test" "func" (table 10 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-i32" (table 10 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (table 10 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "print_i32" (table 10 funcref)))
+  "incompatible import type"
+)
+
+
+
+;; Memories
+
+(module
+  (import "spectest" "memory" (memory 1 2))
+  (data (memory 0) (i32.const 10) "\10")
+
+  (func (export "load") (param i32) (result i32) (i32.load (local.get 0)))
+)
+
+(assert_return (invoke "load" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load" (i32.const 10)) (i32.const 16))
+(assert_return (invoke "load" (i32.const 8)) (i32.const 0x100000))
+(assert_trap (invoke "load" (i32.const 1000000)) "out of bounds memory access")
+
+(module
+  (memory (import "spectest" "memory") 1 2)
+  (data (memory 0) (i32.const 10) "\10")
+
+  (func (export "load") (param i32) (result i32) (i32.load (local.get 0)))
+)
+(assert_return (invoke "load" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load" (i32.const 10)) (i32.const 16))
+(assert_return (invoke "load" (i32.const 8)) (i32.const 0x100000))
+(assert_trap (invoke "load" (i32.const 1000000)) "out of bounds memory access")
+
+(assert_invalid
+  (module (import "" "" (memory 1)) (import "" "" (memory 1)))
+  "multiple memories"
+)
+(assert_invalid
+  (module (import "" "" (memory 1)) (memory 0))
+  "multiple memories"
+)
+(assert_invalid
+  (module (memory 0) (memory 0))
+  "multiple memories"
+)
+
+(module (import "test" "memory-2-inf" (memory 2)))
+(module (import "test" "memory-2-inf" (memory 1)))
+(module (import "test" "memory-2-inf" (memory 0)))
+(module (import "spectest" "memory" (memory 1)))
+(module (import "spectest" "memory" (memory 0)))
+(module (import "spectest" "memory" (memory 1 2)))
+(module (import "spectest" "memory" (memory 0 2)))
+(module (import "spectest" "memory" (memory 1 3)))
+(module (import "spectest" "memory" (memory 0 3)))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (memory 1)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (memory 1)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (memory 3)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (memory 2 3)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 2)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 1 1)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "test" "func-i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "print_i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "global_i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (memory 1)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 2)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 1 1)))
+  "incompatible import type"
+)
+
+(module
+  (import "spectest" "memory" (memory 0 3))  ;; actual has max size 2
+  (func (export "grow") (param i32) (result i32) (memory.grow (local.get 0)))
+)
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const -1))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 2))
+
+(module $Mgm
+  (memory (export "memory") 1) ;; initial size is 1
+  (func (export "grow") (result i32) (memory.grow (i32.const 1)))
+)
+(register "grown-memory" $Mgm)
+(assert_return (invoke $Mgm "grow") (i32.const 1)) ;; now size is 2
+(module $Mgim1
+  ;; imported memory limits should match, because external memory size is 2 now
+  (memory (export "memory") (import "grown-memory" "memory") 2) 
+  (func (export "grow") (result i32) (memory.grow (i32.const 1)))
+)
+(register "grown-imported-memory" $Mgim1)
+(assert_return (invoke $Mgim1 "grow") (i32.const 2)) ;; now size is 3
+(module $Mgim2
+  ;; imported memory limits should match, because external memory size is 3 now
+  (import "grown-imported-memory" "memory" (memory 3))
+  (func (export "size") (result i32) (memory.size))
+)
+(assert_return (invoke $Mgim2 "size") (i32.const 3))
+
+
+;; Syntax errors
+
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (func))")
+  "import after function"
+)
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (global i64))")
+  "import after function"
+)
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (table 0 funcref))")
+  "import after function"
+)
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (memory 0))")
+  "import after function"
+)
+
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (func))")
+  "import after global"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (global f32))")
+  "import after global"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (table 0 funcref))")
+  "import after global"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (memory 0))")
+  "import after global"
+)
+
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (func))")
+  "import after table"
+)
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (global i32))")
+  "import after table"
+)
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (table 0 funcref))")
+  "import after table"
+)
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (memory 0))")
+  "import after table"
+)
+
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (func))")
+  "import after memory"
+)
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (global i32))")
+  "import after memory"
+)
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (table 1 3 funcref))")
+  "import after memory"
+)
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (memory 1 2))")
+  "import after memory"
+)
+
+;; This module is required to validate, regardless of whether it can be
+;; linked. Overloading is not possible in wasm itself, but it is possible
+;; in modules from which wasm can import.
+(module)
+(register "not wasm")
+(assert_unlinkable
+  (module
+    (import "not wasm" "overloaded" (func))
+    (import "not wasm" "overloaded" (func (param i32)))
+    (import "not wasm" "overloaded" (func (param i32 i32)))
+    (import "not wasm" "overloaded" (func (param i64)))
+    (import "not wasm" "overloaded" (func (param f32)))
+    (import "not wasm" "overloaded" (func (param f64)))
+    (import "not wasm" "overloaded" (func (result i32)))
+    (import "not wasm" "overloaded" (func (result i64)))
+    (import "not wasm" "overloaded" (func (result f32)))
+    (import "not wasm" "overloaded" (func (result f64)))
+    (import "not wasm" "overloaded" (global i32))
+    (import "not wasm" "overloaded" (global i64))
+    (import "not wasm" "overloaded" (global f32))
+    (import "not wasm" "overloaded" (global f64))
+    (import "not wasm" "overloaded" (table 0 funcref))
+    (import "not wasm" "overloaded" (memory 0))
+  )
+  "unknown import"
+)
diff --git a/tests/wast/spec/proposals/gc/linking.wast b/tests/wast/spec/proposals/gc/linking.wast
index 85de43d8f9..6a8ba1d0cc 100644
--- a/tests/wast/spec/proposals/gc/linking.wast
+++ b/tests/wast/spec/proposals/gc/linking.wast
@@ -177,23 +177,6 @@
   "incompatible import type"
 )
 
-(assert_unlinkable
-  (module (global (import "Mref_ex" "g-const-funcnull") externref))
-  "incompatible import type"
-)
-(assert_unlinkable
-  (module (global (import "Mref_ex" "g-const-func") externref))
-  "incompatible import type"
-)
-(assert_unlinkable
-  (module (global (import "Mref_ex" "g-const-refnull") externref))
-  "incompatible import type"
-)
-(assert_unlinkable
-  (module (global (import "Mref_ex" "g-const-ref") externref))
-  "incompatible import type"
-)
-
 
 (assert_unlinkable
   (module (global (import "Mref_ex" "g-var-func") (mut (ref null func))))
diff --git a/tests/wast/spec/proposals/gc/local_get.wast b/tests/wast/spec/proposals/gc/local_get.wast
new file mode 100644
index 0000000000..45dbcaeeb4
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/local_get.wast
@@ -0,0 +1,225 @@
+;; Test `local.get` operator
+
+(module
+  ;; Typing
+
+  (func (export "type-local-i32") (result i32) (local i32) (local.get 0))
+  (func (export "type-local-i64") (result i64) (local i64) (local.get 0))
+  (func (export "type-local-f32") (result f32) (local f32) (local.get 0))
+  (func (export "type-local-f64") (result f64) (local f64) (local.get 0))
+
+  (func (export "type-param-i32") (param i32) (result i32) (local.get 0))
+  (func (export "type-param-i64") (param i64) (result i64) (local.get 0))
+  (func (export "type-param-f32") (param f32) (result f32) (local.get 0))
+  (func (export "type-param-f64") (param f64) (result f64) (local.get 0))
+
+  (func (export "type-mixed") (param i64 f32 f64 i32 i32)
+    (local f32 i64 i64 f64)
+    (drop (i64.eqz (local.get 0)))
+    (drop (f32.neg (local.get 1)))
+    (drop (f64.neg (local.get 2)))
+    (drop (i32.eqz (local.get 3)))
+    (drop (i32.eqz (local.get 4)))
+    (drop (f32.neg (local.get 5)))
+    (drop (i64.eqz (local.get 6)))
+    (drop (i64.eqz (local.get 7)))
+    (drop (f64.neg (local.get 8)))
+  )
+
+  ;; Reading
+
+  (func (export "read") (param i64 f32 f64 i32 i32) (result f64)
+    (local f32 i64 i64 f64)
+    (local.set 5 (f32.const 5.5))
+    (local.set 6 (i64.const 6))
+    (local.set 8 (f64.const 8))
+    (f64.add
+      (f64.convert_i64_u (local.get 0))
+      (f64.add
+        (f64.promote_f32 (local.get 1))
+        (f64.add
+          (local.get 2)
+          (f64.add
+            (f64.convert_i32_u (local.get 3))
+            (f64.add
+              (f64.convert_i32_s (local.get 4))
+              (f64.add
+                (f64.promote_f32 (local.get 5))
+                (f64.add
+                  (f64.convert_i64_u (local.get 6))
+                  (f64.add
+                    (f64.convert_i64_u (local.get 7))
+                    (local.get 8)
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+  ;; As parameter of control constructs and instructions
+
+  (func (export "as-block-value") (param i32) (result i32)
+    (block (result i32) (local.get 0))
+  )
+  (func (export "as-loop-value") (param i32) (result i32)
+    (loop (result i32) (local.get 0))
+  )
+  (func (export "as-br-value") (param i32) (result i32)
+    (block (result i32) (br 0 (local.get 0)))
+  )
+  (func (export "as-br_if-value") (param i32) (result i32)
+    (block $l0 (result i32) (br_if $l0 (local.get 0) (i32.const 1)))
+  )
+
+  (func (export "as-br_if-value-cond") (param i32) (result i32)
+    (block (result i32)
+      (br_if 0 (local.get 0) (local.get 0))
+    )
+  )
+  (func (export "as-br_table-value") (param i32) (result i32)
+    (block
+      (block
+        (block
+          (br_table 0 1 2 (local.get 0))
+          (return (i32.const 0))
+        )
+        (return (i32.const 1))
+      )
+      (return (i32.const 2))
+    )
+    (i32.const 3)
+  )
+
+  (func (export "as-return-value") (param i32) (result i32)
+    (return (local.get 0))
+  )
+
+  (func (export "as-if-then") (param i32) (result i32)
+    (if (result i32) (local.get 0) (then (local.get 0)) (else (i32.const 0)))
+  )
+  (func (export "as-if-else") (param i32) (result i32)
+    (if (result i32) (local.get 0) (then (i32.const 1)) (else (local.get 0)))
+  )
+)
+
+(assert_return (invoke "type-local-i32") (i32.const 0))
+(assert_return (invoke "type-local-i64") (i64.const 0))
+(assert_return (invoke "type-local-f32") (f32.const 0))
+(assert_return (invoke "type-local-f64") (f64.const 0))
+
+(assert_return (invoke "type-param-i32" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "type-param-i64" (i64.const 3)) (i64.const 3))
+(assert_return (invoke "type-param-f32" (f32.const 4.4)) (f32.const 4.4))
+(assert_return (invoke "type-param-f64" (f64.const 5.5)) (f64.const 5.5))
+
+(assert_return (invoke "as-block-value" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-loop-value" (i32.const 7)) (i32.const 7))
+
+(assert_return (invoke "as-br-value" (i32.const 8)) (i32.const 8))
+(assert_return (invoke "as-br_if-value" (i32.const 9)) (i32.const 9))
+(assert_return (invoke "as-br_if-value-cond" (i32.const 10)) (i32.const 10))
+(assert_return (invoke "as-br_table-value" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-return-value" (i32.const 0)) (i32.const 0))
+
+(assert_return (invoke "as-if-then" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-if-else" (i32.const 0)) (i32.const 0))
+
+(assert_return
+  (invoke "type-mixed"
+    (i64.const 1) (f32.const 2.2) (f64.const 3.3) (i32.const 4) (i32.const 5)
+  )
+)
+
+(assert_return
+  (invoke "read"
+    (i64.const 1) (f32.const 2) (f64.const 3.3) (i32.const 4) (i32.const 5)
+  )
+  (f64.const 34.8)
+)
+
+
+;; Invalid typing of access to locals
+
+(assert_invalid
+  (module (func $type-local-num-vs-num (result i64) (local i32) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-num-vs-num (result i32) (local f32) (i32.eqz (local.get 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-num-vs-num (result f64) (local f64 i64) (f64.neg (local.get 1))))
+  "type mismatch"
+)
+
+
+;; Invalid typing of access to parameters
+
+(assert_invalid
+  (module (func $type-param-num-vs-num (param i32) (result i64) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num (param f32) (result i32) (i32.eqz (local.get 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num (param f64 i64) (result f64) (f64.neg (local.get 1))))
+  "type mismatch"
+)
+
+
+;; Invalid result type
+
+(assert_invalid
+  (module (func $type-empty-vs-i32 (local i32) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-vs-i64 (local i64) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-vs-f32 (local f32) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-vs-f64 (local f64) (local.get 0)))
+  "type mismatch"
+)
+
+
+;; Invalid local index
+
+(assert_invalid
+  (module (func $unbound-local (local i32 i64) (local.get 3) drop))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-local (local i32 i64) (local.get 14324343) drop))
+  "unknown local"
+)
+
+(assert_invalid
+  (module (func $unbound-param (param i32 i64) (local.get 2) drop))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-param (param i32 i64) (local.get 714324343) drop))
+  "unknown local"
+)
+
+(assert_invalid
+  (module (func $unbound-mixed (param i32) (local i32 i64) (local.get 3) drop))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-mixed (param i64) (local i32 i64) (local.get 214324343) drop))
+  "unknown local"
+)
diff --git a/tests/wast/spec/proposals/gc/local_init.wast b/tests/wast/spec/proposals/gc/local_init.wast
new file mode 100644
index 0000000000..176ccc64bb
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/local_init.wast
@@ -0,0 +1,74 @@
+;; Uninitialized undefaulted locals
+
+(module
+  (func (export "get-after-set") (param $p (ref extern)) (result (ref extern))
+    (local $x (ref extern))
+    (local.set $x (local.get $p))
+    (local.get $x)
+  )
+  (func (export "get-after-tee") (param $p (ref extern)) (result (ref extern))
+    (local $x (ref extern))
+    (drop (local.tee $x (local.get $p)))
+    (local.get $x)
+  )
+  (func (export "get-in-block-after-set") (param $p (ref extern)) (result (ref extern))
+    (local $x (ref extern))
+    (local.set $x (local.get $p))
+    (block (result (ref extern)) (local.get $x))
+  )
+)
+
+(assert_return (invoke "get-after-set" (ref.extern 1)) (ref.extern 1))
+(assert_return (invoke "get-after-tee" (ref.extern 2)) (ref.extern 2))
+(assert_return (invoke "get-in-block-after-set" (ref.extern 3)) (ref.extern 3))
+
+(assert_invalid
+  (module (func $uninit (local $x (ref extern)) (drop (local.get $x))))
+  "uninitialized local"
+)
+(assert_invalid
+  (module
+    (func $uninit-after-end (param $p (ref extern))
+      (local $x (ref extern))
+      (block (local.set $x (local.get $p)) (drop (local.tee $x (local.get $p))))
+      (drop (local.get $x))
+    )
+  )
+  "uninitialized local"
+)
+(assert_invalid
+  (module
+    (func $uninit-in-else (param $p (ref extern))
+      (local $x (ref extern))
+      (if (i32.const 0)
+        (then (local.set $x (local.get $p)))
+	(else (local.get $x))
+      )
+    )
+  )
+  "uninitialized local"
+)
+
+(assert_invalid
+  (module
+    (func $uninit-from-if (param $p (ref extern))
+      (local $x (ref extern))
+      (if (i32.const 0)
+        (then (local.set $x (local.get $p)))
+	(else (local.set $x (local.get $p)))
+      )
+      (drop (local.get $x))
+    )
+  )
+  "uninitialized local"
+)
+
+(module
+  (func (export "tee-init") (param $p (ref extern)) (result (ref extern))
+    (local $x (ref extern))
+    (drop (local.tee $x (local.get $p)))
+    (local.get $x)
+  )
+)
+
+(assert_return (invoke "tee-init" (ref.extern 1)) (ref.extern 1))
diff --git a/tests/wast/spec/proposals/gc/local_tee.wast b/tests/wast/spec/proposals/gc/local_tee.wast
new file mode 100644
index 0000000000..eeb26e6e01
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/local_tee.wast
@@ -0,0 +1,654 @@
+;; Test `local.tee` operator
+
+(module
+  ;; Typing
+
+  (func (export "type-local-i32") (result i32) (local i32) (local.tee 0 (i32.const 0)))
+  (func (export "type-local-i64") (result i64) (local i64) (local.tee 0 (i64.const 0)))
+  (func (export "type-local-f32") (result f32) (local f32) (local.tee 0 (f32.const 0)))
+  (func (export "type-local-f64") (result f64) (local f64) (local.tee 0 (f64.const 0)))
+
+  (func (export "type-param-i32") (param i32) (result i32) (local.tee 0 (i32.const 10)))
+  (func (export "type-param-i64") (param i64) (result i64) (local.tee 0 (i64.const 11)))
+  (func (export "type-param-f32") (param f32) (result f32) (local.tee 0 (f32.const 11.1)))
+  (func (export "type-param-f64") (param f64) (result f64) (local.tee 0 (f64.const 12.2)))
+
+  (func (export "type-mixed") (param i64 f32 f64 i32 i32) (local f32 i64 i64 f64)
+    (drop (i64.eqz (local.tee 0 (i64.const 0))))
+    (drop (f32.neg (local.tee 1 (f32.const 0))))
+    (drop (f64.neg (local.tee 2 (f64.const 0))))
+    (drop (i32.eqz (local.tee 3 (i32.const 0))))
+    (drop (i32.eqz (local.tee 4 (i32.const 0))))
+    (drop (f32.neg (local.tee 5 (f32.const 0))))
+    (drop (i64.eqz (local.tee 6 (i64.const 0))))
+    (drop (i64.eqz (local.tee 7 (i64.const 0))))
+    (drop (f64.neg (local.tee 8 (f64.const 0))))
+  )
+
+  ;; Writing
+
+  (func (export "write") (param i64 f32 f64 i32 i32) (result i64) (local f32 i64 i64 f64)
+    (drop (local.tee 1 (f32.const -0.3)))
+    (drop (local.tee 3 (i32.const 40)))
+    (drop (local.tee 4 (i32.const -7)))
+    (drop (local.tee 5 (f32.const 5.5)))
+    (drop (local.tee 6 (i64.const 6)))
+    (drop (local.tee 8 (f64.const 8)))
+    (i64.trunc_f64_s
+      (f64.add
+        (f64.convert_i64_u (local.get 0))
+        (f64.add
+          (f64.promote_f32 (local.get 1))
+          (f64.add
+            (local.get 2)
+            (f64.add
+              (f64.convert_i32_u (local.get 3))
+              (f64.add
+                (f64.convert_i32_s (local.get 4))
+                (f64.add
+                  (f64.promote_f32 (local.get 5))
+                  (f64.add
+                    (f64.convert_i64_u (local.get 6))
+                    (f64.add
+                      (f64.convert_i64_u (local.get 7))
+                      (local.get 8)
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+  ;; Result
+
+  (func (export "result") (param i64 f32 f64 i32 i32) (result f64)
+    (local f32 i64 i64 f64)
+    (f64.add
+      (f64.convert_i64_u (local.tee 0 (i64.const 1)))
+      (f64.add
+        (f64.promote_f32 (local.tee 1 (f32.const 2)))
+        (f64.add
+          (local.tee 2 (f64.const 3.3))
+          (f64.add
+            (f64.convert_i32_u (local.tee 3 (i32.const 4)))
+            (f64.add
+              (f64.convert_i32_s (local.tee 4 (i32.const 5)))
+              (f64.add
+                (f64.promote_f32 (local.tee 5 (f32.const 5.5)))
+                (f64.add
+                  (f64.convert_i64_u (local.tee 6 (i64.const 6)))
+                  (f64.add
+                    (f64.convert_i64_u (local.tee 7 (i64.const 0)))
+                    (local.tee 8 (f64.const 8))
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+  (func $dummy)
+
+  (func (export "as-block-first") (param i32) (result i32)
+    (block (result i32) (local.tee 0 (i32.const 1)) (call $dummy))
+  )
+  (func (export "as-block-mid") (param i32) (result i32)
+    (block (result i32) (call $dummy) (local.tee 0 (i32.const 1)) (call $dummy))
+  )
+  (func (export "as-block-last") (param i32) (result i32)
+    (block (result i32) (call $dummy) (call $dummy) (local.tee 0 (i32.const 1)))
+  )
+
+  (func (export "as-loop-first") (param i32) (result i32)
+    (loop (result i32) (local.tee 0 (i32.const 3)) (call $dummy))
+  )
+  (func (export "as-loop-mid") (param i32) (result i32)
+    (loop (result i32) (call $dummy) (local.tee 0 (i32.const 4)) (call $dummy))
+  )
+  (func (export "as-loop-last") (param i32) (result i32)
+    (loop (result i32) (call $dummy) (call $dummy) (local.tee 0 (i32.const 5)))
+  )
+
+  (func (export "as-br-value") (param i32) (result i32)
+    (block (result i32) (br 0 (local.tee 0 (i32.const 9))))
+  )
+
+  (func (export "as-br_if-cond") (param i32)
+    (block (br_if 0 (local.tee 0 (i32.const 1))))
+  )
+  (func (export "as-br_if-value") (param i32) (result i32)
+    (block (result i32)
+      (drop (br_if 0 (local.tee 0 (i32.const 8)) (i32.const 1))) (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (param i32) (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (local.tee 0 (i32.const 9)))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index") (param i32)
+    (block (br_table 0 0 0 (local.tee 0 (i32.const 0))))
+  )
+  (func (export "as-br_table-value") (param i32) (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (local.tee 0 (i32.const 10)) (i32.const 1)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-index") (param i32) (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (local.tee 0 (i32.const 11))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-return-value") (param i32) (result i32)
+    (return (local.tee 0 (i32.const 7)))
+  )
+
+  (func (export "as-if-cond") (param i32) (result i32)
+    (if (result i32) (local.tee 0 (i32.const 2))
+      (then (i32.const 0)) (else (i32.const 1))
+    )
+  )
+  (func (export "as-if-then") (param i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then (local.tee 0 (i32.const 3))) (else (local.get 0))
+    )
+  )
+  (func (export "as-if-else") (param i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then (local.get 0)) (else (local.tee 0 (i32.const 4)))
+    )
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (select (local.tee 0 (i32.const 5)) (local.get 0) (local.get 1))
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (select (local.get 0) (local.tee 0 (i32.const 6)) (local.get 1))
+  )
+  (func (export "as-select-cond") (param i32) (result i32)
+    (select (i32.const 0) (i32.const 1) (local.tee 0 (i32.const 7)))
+  )
+
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (param i32) (result i32)
+    (call $f (local.tee 0 (i32.const 12)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-call-mid") (param i32) (result i32)
+    (call $f (i32.const 1) (local.tee 0 (i32.const 13)) (i32.const 3))
+  )
+  (func (export "as-call-last") (param i32) (result i32)
+    (call $f (i32.const 1) (i32.const 2) (local.tee 0 (i32.const 14)))
+  )
+
+  (type $sig (func (param i32 i32 i32) (result i32)))
+  (table funcref (elem $f))
+  (func (export "as-call_indirect-first") (param i32) (result i32)
+    (call_indirect (type $sig)
+      (local.tee 0 (i32.const 1)) (i32.const 2) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-mid") (param i32) (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (local.tee 0 (i32.const 2)) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-last") (param i32) (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.const 2) (local.tee 0 (i32.const 3)) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-index") (param i32) (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.const 2) (i32.const 3) (local.tee 0 (i32.const 0))
+    )
+  )
+
+  (func (export "as-local.set-value") (local i32)
+    (local.set 0 (local.tee 0 (i32.const 1)))
+  )
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (local.tee 0 (local.tee 0 (i32.const 1)))
+  )
+  (global $g (mut i32) (i32.const 0))
+  (func (export "as-global.set-value") (local i32)
+    (global.set $g (local.tee 0 (i32.const 1)))
+  )
+
+  (memory 1)
+  (func (export "as-load-address") (param i32) (result i32)
+    (i32.load (local.tee 0 (i32.const 1)))
+  )
+  (func (export "as-loadN-address") (param i32) (result i32)
+    (i32.load8_s (local.tee 0 (i32.const 3)))
+  )
+
+  (func (export "as-store-address") (param i32)
+    (i32.store (local.tee 0 (i32.const 30)) (i32.const 7))
+  )
+  (func (export "as-store-value") (param i32)
+    (i32.store (i32.const 2) (local.tee 0 (i32.const 1)))
+  )
+
+  (func (export "as-storeN-address") (param i32)
+    (i32.store8 (local.tee 0 (i32.const 1)) (i32.const 7))
+  )
+  (func (export "as-storeN-value") (param i32)
+    (i32.store16 (i32.const 2) (local.tee 0 (i32.const 1)))
+  )
+
+  (func (export "as-unary-operand") (param f32) (result f32)
+    (f32.neg (local.tee 0 (f32.const nan:0x0f1e2)))
+  )
+
+  (func (export "as-binary-left") (param i32) (result i32)
+    (i32.add (local.tee 0 (i32.const 3)) (i32.const 10))
+  )
+  (func (export "as-binary-right") (param i32) (result i32)
+    (i32.sub (i32.const 10) (local.tee 0 (i32.const 4)))
+  )
+
+  (func (export "as-test-operand") (param i32) (result i32)
+    (i32.eqz (local.tee 0 (i32.const 0)))
+  )
+
+  (func (export "as-compare-left") (param i32) (result i32)
+    (i32.le_s (local.tee 0 (i32.const 43)) (i32.const 10))
+  )
+  (func (export "as-compare-right") (param i32) (result i32)
+    (i32.ne (i32.const 10) (local.tee 0 (i32.const 42)))
+  )
+
+  (func (export "as-convert-operand") (param i64) (result i32)
+    (i32.wrap_i64 (local.tee 0 (i64.const 41)))
+  )
+
+  (func (export "as-memory.grow-size") (param i32) (result i32)
+    (memory.grow (local.tee 0 (i32.const 40)))
+  )
+
+)
+
+(assert_return (invoke "type-local-i32") (i32.const 0))
+(assert_return (invoke "type-local-i64") (i64.const 0))
+(assert_return (invoke "type-local-f32") (f32.const 0))
+(assert_return (invoke "type-local-f64") (f64.const 0))
+
+(assert_return (invoke "type-param-i32" (i32.const 2)) (i32.const 10))
+(assert_return (invoke "type-param-i64" (i64.const 3)) (i64.const 11))
+(assert_return (invoke "type-param-f32" (f32.const 4.4)) (f32.const 11.1))
+(assert_return (invoke "type-param-f64" (f64.const 5.5)) (f64.const 12.2))
+
+(assert_return (invoke "as-block-first" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-block-mid" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-block-last" (i32.const 0)) (i32.const 1))
+
+(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 4))
+(assert_return (invoke "as-loop-last" (i32.const 0)) (i32.const 5))
+
+(assert_return (invoke "as-br-value" (i32.const 0)) (i32.const 9))
+
+(assert_return (invoke "as-br_if-cond" (i32.const 0)))
+(assert_return (invoke "as-br_if-value" (i32.const 0)) (i32.const 8))
+(assert_return (invoke "as-br_if-value-cond" (i32.const 0)) (i32.const 6))
+
+(assert_return (invoke "as-br_table-index" (i32.const 0)))
+(assert_return (invoke "as-br_table-value" (i32.const 0)) (i32.const 10))
+(assert_return (invoke "as-br_table-value-index" (i32.const 0)) (i32.const 6))
+
+(assert_return (invoke "as-return-value" (i32.const 0)) (i32.const 7))
+
+(assert_return (invoke "as-if-cond" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-if-then" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "as-if-else" (i32.const 0)) (i32.const 4))
+
+(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 1)) (i32.const 5))
+(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 0)) (i32.const 6))
+(assert_return (invoke "as-select-cond" (i32.const 0)) (i32.const 0))
+
+(assert_return (invoke "as-call-first" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-call-mid" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-call-last" (i32.const 0)) (i32.const -1))
+
+(assert_return (invoke "as-call_indirect-first" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-call_indirect-mid" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-call_indirect-last" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-call_indirect-index" (i32.const 0)) (i32.const -1))
+
+(assert_return (invoke "as-local.set-value"))
+(assert_return (invoke "as-local.tee-value" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-global.set-value"))
+
+(assert_return (invoke "as-load-address" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-loadN-address" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-store-address" (i32.const 0)))
+(assert_return (invoke "as-store-value" (i32.const 0)))
+(assert_return (invoke "as-storeN-address" (i32.const 0)))
+(assert_return (invoke "as-storeN-value" (i32.const 0)))
+
+(assert_return (invoke "as-unary-operand" (f32.const 0)) (f32.const -nan:0x0f1e2))
+(assert_return (invoke "as-binary-left" (i32.const 0)) (i32.const 13))
+(assert_return (invoke "as-binary-right" (i32.const 0)) (i32.const 6))
+(assert_return (invoke "as-test-operand" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-compare-left" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-compare-right" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-convert-operand" (i64.const 0)) (i32.const 41))
+(assert_return (invoke "as-memory.grow-size" (i32.const 0)) (i32.const 1))
+
+(assert_return
+  (invoke "type-mixed"
+    (i64.const 1) (f32.const 2.2) (f64.const 3.3) (i32.const 4) (i32.const 5)
+  )
+)
+
+(assert_return
+  (invoke "write"
+    (i64.const 1) (f32.const 2) (f64.const 3.3) (i32.const 4) (i32.const 5)
+  )
+  (i64.const 56)
+)
+
+(assert_return
+  (invoke "result"
+    (i64.const -1) (f32.const -2) (f64.const -3.3) (i32.const -4) (i32.const -5)
+  )
+  (f64.const 34.8)
+)
+
+
+;; Invalid typing of access to locals
+
+(assert_invalid
+  (module (func $type-local-num-vs-num (result i64) (local i32) (local.tee 0 (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-num-vs-num (local f32) (i32.eqz (local.tee 0 (f32.const 0)))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-num-vs-num (local f64 i64) (f64.neg (local.tee 1 (i64.const 0)))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-local-arg-void-vs-num (local i32) (local.tee 0 (nop))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-arg-num-vs-num (local i32) (local.tee 0 (f32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-arg-num-vs-num (local f32) (local.tee 0 (f64.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-arg-num-vs-num (local f64 i64) (local.tee 1 (f64.const 0))))
+  "type mismatch"
+)
+
+
+;; Invalid typing of access to parameters
+
+(assert_invalid
+  (module (func $type-param-num-vs-num (param i32) (result i64) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num (param f32) (i32.eqz (local.get 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (local.get 1))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-param-arg-void-vs-num (param i32) (local.tee 0 (nop))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-arg-num-vs-num (param i32) (local.tee 0 (f32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-arg-num-vs-num (param f32) (local.tee 0 (f64.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-arg-num-vs-num (param f64 i64) (local.tee 1 (f64.const 0))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num (param i32)
+      (local.tee 0) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-block (param i32)
+      (i32.const 0)
+      (block (local.tee 0) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-loop (param i32)
+      (i32.const 0)
+      (loop (local.tee 0) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-then (param i32)
+      (i32.const 0) (i32.const 0)
+      (if (then (local.tee 0) (drop)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-else (param i32)
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (local.tee 0))) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-br (param i32)
+      (i32.const 0)
+      (block (br 0 (local.tee 0)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-br_if (param i32)
+      (i32.const 0)
+      (block (br_if 0 (local.tee 0) (i32.const 1)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-br_table (param i32)
+      (i32.const 0)
+      (block (br_table 0 (local.tee 0)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-return (param i32)
+      (return (local.tee 0)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-select (param i32)
+      (select (local.tee 0) (i32.const 1) (i32.const 2)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-call (param i32)
+      (call 1 (local.tee 0)) (drop)
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32) (result i32) (local.get 0))
+    (type $sig (func (param i32) (result i32)))
+    (table funcref (elem $f))
+    (func $type-param-arg-empty-vs-num-in-call_indirect (param i32)
+      (block (result i32)
+        (call_indirect (type $sig)
+          (local.tee 0) (i32.const 0)
+        )
+        (drop)
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-local.set (param i32)
+      (local.set 0 (local.tee 0)) (local.get 0) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-local.tee (param i32)
+      (local.tee 0 (local.tee 0)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-param-arg-empty-vs-num-in-global.set (param i32)
+      (global.set $x (local.tee 0)) (global.get $x) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-param-arg-empty-vs-num-in-memory.grow (param i32)
+      (memory.grow (local.tee 0)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-param-arg-empty-vs-num-in-load (param i32)
+      (i32.load (local.tee 0)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-param-arg-empty-vs-num-in-store (param i32)
+      (i32.store (local.tee 0) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-mixed-arg-num-vs-num (param f32) (local i32) (local.tee 1 (f32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-mixed-arg-num-vs-num (param i64 i32) (local f32) (local.tee 1 (f32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-mixed-arg-num-vs-num (param i64) (local f64 i64) (local.tee 1 (i64.const 0))))
+  "type mismatch"
+)
+
+;; https://github.com/WebAssembly/gc/issues/516
+(assert_invalid
+  (module
+    (type $t (func))
+    (func $f (param (ref null $t)))
+    (func
+      (local $x funcref)
+      (ref.null $t)
+      (local.tee $x)  ;; leaves only a funcref on the stack
+      (call $f)
+    )
+  )
+  "type mismatch"
+)
+
+
+;; Invalid local index
+
+(assert_invalid
+  (module (func $unbound-local (local i32 i64) (local.tee 3 (i32.const 0)) drop))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-local (local i32 i64) (local.tee 14324343 (i32.const 0)) drop))
+  "unknown local"
+)
+
+(assert_invalid
+  (module (func $unbound-param (param i32 i64) (local.tee 2 (i32.const 0)) drop))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-param (param i32 i64) (local.tee 714324343 (i32.const 0)) drop))
+  "unknown local"
+)
+
+(assert_invalid
+  (module (func $unbound-mixed (param i32) (local i32 i64) (local.tee 3 (i32.const 0)) drop))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-mixed (param i64) (local i32 i64) (local.tee 214324343 (i32.const 0)) drop))
+  "unknown local"
+)
diff --git a/tests/wast/spec/proposals/gc/memory_grow.wast b/tests/wast/spec/proposals/gc/memory_grow.wast
new file mode 100644
index 0000000000..aa56297d25
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/memory_grow.wast
@@ -0,0 +1,379 @@
+(module
+    (memory 0)
+
+    (func (export "load_at_zero") (result i32) (i32.load (i32.const 0)))
+    (func (export "store_at_zero") (i32.store (i32.const 0) (i32.const 2)))
+
+    (func (export "load_at_page_size") (result i32) (i32.load (i32.const 0x10000)))
+    (func (export "store_at_page_size") (i32.store (i32.const 0x10000) (i32.const 3)))
+
+    (func (export "grow") (param $sz i32) (result i32) (memory.grow (local.get $sz)))
+    (func (export "size") (result i32) (memory.size))
+)
+
+(assert_return (invoke "size") (i32.const 0))
+(assert_trap (invoke "store_at_zero") "out of bounds memory access")
+(assert_trap (invoke "load_at_zero") "out of bounds memory access")
+(assert_trap (invoke "store_at_page_size") "out of bounds memory access")
+(assert_trap (invoke "load_at_page_size") "out of bounds memory access")
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "size") (i32.const 1))
+(assert_return (invoke "load_at_zero") (i32.const 0))
+(assert_return (invoke "store_at_zero"))
+(assert_return (invoke "load_at_zero") (i32.const 2))
+(assert_trap (invoke "store_at_page_size") "out of bounds memory access")
+(assert_trap (invoke "load_at_page_size") "out of bounds memory access")
+(assert_return (invoke "grow" (i32.const 4)) (i32.const 1))
+(assert_return (invoke "size") (i32.const 5))
+(assert_return (invoke "load_at_zero") (i32.const 2))
+(assert_return (invoke "store_at_zero"))
+(assert_return (invoke "load_at_zero") (i32.const 2))
+(assert_return (invoke "load_at_page_size") (i32.const 0))
+(assert_return (invoke "store_at_page_size"))
+(assert_return (invoke "load_at_page_size") (i32.const 3))
+
+
+(module
+  (memory 0)
+  (func (export "grow") (param i32) (result i32) (memory.grow (local.get 0)))
+)
+
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 2)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 800)) (i32.const 3))
+(assert_return (invoke "grow" (i32.const 0x10000)) (i32.const -1))
+(assert_return (invoke "grow" (i32.const 64736)) (i32.const -1))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 803))
+
+(module
+  (memory 0 10)
+  (func (export "grow") (param i32) (result i32) (memory.grow (local.get 0)))
+)
+
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "grow" (i32.const 6)) (i32.const 4))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 10))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const -1))
+(assert_return (invoke "grow" (i32.const 0x10000)) (i32.const -1))
+
+;; Test that newly allocated memory (program start and memory.grow) is zeroed
+
+(module
+  (memory 1)
+  (func (export "grow") (param i32) (result i32)
+    (memory.grow (local.get 0))
+  )
+  (func (export "check-memory-zero") (param i32 i32) (result i32)
+    (local i32)
+    (local.set 2 (i32.const 1))
+    (block
+      (loop
+        (local.set 2 (i32.load8_u (local.get 0)))
+        (br_if 1 (i32.ne (local.get 2) (i32.const 0)))
+        (br_if 1 (i32.ge_u (local.get 0) (local.get 1)))
+        (local.set 0 (i32.add (local.get 0) (i32.const 1)))
+        (br_if 0 (i32.le_u (local.get 0) (local.get 1)))
+      )
+    )
+    (local.get 2)
+  )
+)
+
+(assert_return (invoke "check-memory-zero" (i32.const 0) (i32.const 0xffff)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "check-memory-zero" (i32.const 0x10000) (i32.const 0x1_ffff)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "check-memory-zero" (i32.const 0x20000) (i32.const 0x2_ffff)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "check-memory-zero" (i32.const 0x30000) (i32.const 0x3_ffff)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 4))
+(assert_return (invoke "check-memory-zero" (i32.const 0x40000) (i32.const 0x4_ffff)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 5))
+(assert_return (invoke "check-memory-zero" (i32.const 0x50000) (i32.const 0x5_ffff)) (i32.const 0))
+
+;; As the argument of control constructs and instructions
+
+(module
+  (memory 1)
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (memory.grow (i32.const 0))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (memory.grow (i32.const 0))))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (memory.grow (i32.const 0)) (i32.const 1))) (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (memory.grow (i32.const 0)))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (memory.grow (i32.const 0))))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (memory.grow (i32.const 0)) (i32.const 1)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (memory.grow (i32.const 0))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-return-value") (result i32)
+    (return (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-if-cond") (result i32)
+    (if (result i32) (memory.grow (i32.const 0))
+      (then (i32.const 0)) (else (i32.const 1))
+    )
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1)
+      (then (memory.grow (i32.const 0))) (else (i32.const 0))
+    )
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 0)
+      (then (i32.const 0)) (else (memory.grow (i32.const 0)))
+    )
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (select (memory.grow (i32.const 0)) (local.get 0) (local.get 1))
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (select (local.get 0) (memory.grow (i32.const 0)) (local.get 1))
+  )
+  (func (export "as-select-cond") (result i32)
+    (select (i32.const 0) (i32.const 1) (memory.grow (i32.const 0)))
+  )
+
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (call $f (memory.grow (i32.const 0)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-call-mid") (result i32)
+    (call $f (i32.const 1) (memory.grow (i32.const 0)) (i32.const 3))
+  )
+  (func (export "as-call-last") (result i32)
+    (call $f (i32.const 1) (i32.const 2) (memory.grow (i32.const 0)))
+  )
+
+  (type $sig (func (param i32 i32 i32) (result i32)))
+  (table funcref (elem $f))
+  (func (export "as-call_indirect-first") (result i32)
+    (call_indirect (type $sig)
+      (memory.grow (i32.const 0)) (i32.const 2) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (memory.grow (i32.const 0)) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.const 2) (memory.grow (i32.const 0)) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-index") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.const 2) (i32.const 3) (memory.grow (i32.const 0))
+    )
+  )
+
+  (func (export "as-local.set-value") (local i32)
+    (local.set 0 (memory.grow (i32.const 0)))
+  )
+  (func (export "as-local.tee-value") (result i32) (local i32)
+    (local.tee 0 (memory.grow (i32.const 0)))
+  )
+  (global $g (mut i32) (i32.const 0))
+  (func (export "as-global.set-value") (local i32)
+    (global.set $g (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-load-address") (result i32)
+    (i32.load (memory.grow (i32.const 0)))
+  )
+  (func (export "as-loadN-address") (result i32)
+    (i32.load8_s (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-store-address")
+    (i32.store (memory.grow (i32.const 0)) (i32.const 7))
+  )
+  (func (export "as-store-value")
+    (i32.store (i32.const 2) (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-storeN-address")
+    (i32.store8 (memory.grow (i32.const 0)) (i32.const 7))
+  )
+  (func (export "as-storeN-value")
+    (i32.store16 (i32.const 2) (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.clz (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (i32.add (memory.grow (i32.const 0)) (i32.const 10))
+  )
+  (func (export "as-binary-right") (result i32)
+    (i32.sub (i32.const 10) (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (i32.eqz (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (i32.le_s (memory.grow (i32.const 0)) (i32.const 10))
+  )
+  (func (export "as-compare-right") (result i32)
+    (i32.ne (i32.const 10) (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (memory.grow (memory.grow (i32.const 0)))
+  )
+)
+
+(assert_return (invoke "as-br-value") (i32.const 1))
+
+(assert_return (invoke "as-br_if-cond"))
+(assert_return (invoke "as-br_if-value") (i32.const 1))
+(assert_return (invoke "as-br_if-value-cond") (i32.const 6))
+
+(assert_return (invoke "as-br_table-index"))
+(assert_return (invoke "as-br_table-value") (i32.const 1))
+(assert_return (invoke "as-br_table-value-index") (i32.const 6))
+
+(assert_return (invoke "as-return-value") (i32.const 1))
+
+(assert_return (invoke "as-if-cond") (i32.const 0))
+(assert_return (invoke "as-if-then") (i32.const 1))
+(assert_return (invoke "as-if-else") (i32.const 1))
+
+(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-select-cond") (i32.const 0))
+
+(assert_return (invoke "as-call-first") (i32.const -1))
+(assert_return (invoke "as-call-mid") (i32.const -1))
+(assert_return (invoke "as-call-last") (i32.const -1))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const -1))
+(assert_return (invoke "as-call_indirect-mid") (i32.const -1))
+(assert_return (invoke "as-call_indirect-last") (i32.const -1))
+(assert_trap (invoke "as-call_indirect-index") "undefined element")
+
+(assert_return (invoke "as-local.set-value"))
+(assert_return (invoke "as-local.tee-value") (i32.const 1))
+(assert_return (invoke "as-global.set-value"))
+
+(assert_return (invoke "as-load-address") (i32.const 0))
+(assert_return (invoke "as-loadN-address") (i32.const 0))
+(assert_return (invoke "as-store-address"))
+(assert_return (invoke "as-store-value"))
+(assert_return (invoke "as-storeN-address"))
+(assert_return (invoke "as-storeN-value"))
+
+(assert_return (invoke "as-unary-operand") (i32.const 31))
+
+(assert_return (invoke "as-binary-left") (i32.const 11))
+(assert_return (invoke "as-binary-right") (i32.const 9))
+
+(assert_return (invoke "as-test-operand") (i32.const 0))
+
+(assert_return (invoke "as-compare-left") (i32.const 1))
+(assert_return (invoke "as-compare-right") (i32.const 1))
+
+(assert_return (invoke "as-memory.grow-size") (i32.const 1))
+
+
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-size-empty-vs-i32 (result i32)
+      (memory.grow)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-size-empty-vs-i32-in-block (result i32)
+      (i32.const 0)
+      (block (result i32) (memory.grow))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-size-empty-vs-i32-in-loop (result i32)
+      (i32.const 0)
+      (loop (result i32) (memory.grow))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-size-empty-vs-i32-in-then (result i32)
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (memory.grow)))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-size-f32-vs-i32 (result i32)
+      (memory.grow (f32.const 0))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-result-i32-vs-empty
+      (memory.grow (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-result-i32-vs-f32 (result f32)
+      (memory.grow (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
diff --git a/tests/wast/spec/proposals/gc/ref_as_non_null.wast b/tests/wast/spec/proposals/gc/ref_as_non_null.wast
index ba5c454701..6b3380fc59 100644
--- a/tests/wast/spec/proposals/gc/ref_as_non_null.wast
+++ b/tests/wast/spec/proposals/gc/ref_as_non_null.wast
@@ -2,10 +2,10 @@
   (type $t (func (result i32)))
 
   (func $nn (param $r (ref $t)) (result i32)
-    (call_ref (ref.as_non_null (local.get $r)))
+    (call_ref $t (ref.as_non_null (local.get $r)))
   )
   (func $n (param $r (ref null $t)) (result i32)
-    (call_ref (ref.as_non_null (local.get $r)))
+    (call_ref $t (ref.as_non_null (local.get $r)))
   )
 
   (elem func $f)
diff --git a/tests/wast/spec/proposals/gc/ref_cast.wast b/tests/wast/spec/proposals/gc/ref_cast.wast
index 9a74a2800e..8e35431193 100644
--- a/tests/wast/spec/proposals/gc/ref_cast.wast
+++ b/tests/wast/spec/proposals/gc/ref_cast.wast
@@ -1,79 +1,184 @@
+;; Abstract Types
+
+(module
+  (type $ft (func))
+  (type $st (struct))
+  (type $at (array i8))
+
+  (table 10 anyref)
+
+  (elem declare func $f)
+  (func $f)
+
+  (func (export "init") (param $x externref)
+    (table.set (i32.const 0) (ref.null any))
+    (table.set (i32.const 1) (ref.i31 (i32.const 7)))
+    (table.set (i32.const 2) (struct.new_default $st))
+    (table.set (i32.const 3) (array.new_default $at (i32.const 0)))
+    (table.set (i32.const 4) (any.convert_extern (local.get $x)))
+    (table.set (i32.const 5) (ref.null i31))
+    (table.set (i32.const 6) (ref.null struct))
+    (table.set (i32.const 7) (ref.null none))
+  )
+
+  (func (export "ref_cast_non_null") (param $i i32)
+    (drop (ref.as_non_null (table.get (local.get $i))))
+    (drop (ref.cast (ref null any) (table.get (local.get $i))))
+  )
+  (func (export "ref_cast_null") (param $i i32)
+    (drop (ref.cast anyref (table.get (local.get $i))))
+    (drop (ref.cast structref (table.get (local.get $i))))
+    (drop (ref.cast arrayref (table.get (local.get $i))))
+    (drop (ref.cast i31ref (table.get (local.get $i))))
+    (drop (ref.cast nullref (table.get (local.get $i))))
+  )
+  (func (export "ref_cast_i31") (param $i i32)
+    (drop (ref.cast (ref i31) (table.get (local.get $i))))
+    (drop (ref.cast i31ref (table.get (local.get $i))))
+  )
+  (func (export "ref_cast_struct") (param $i i32)
+    (drop (ref.cast (ref struct) (table.get (local.get $i))))
+    (drop (ref.cast structref (table.get (local.get $i))))
+  )
+  (func (export "ref_cast_array") (param $i i32)
+    (drop (ref.cast (ref array) (table.get (local.get $i))))
+    (drop (ref.cast arrayref (table.get (local.get $i))))
+  )
+)
+
+(invoke "init" (ref.extern 0))
+
+(assert_trap (invoke "ref_cast_non_null" (i32.const 0)) "null reference")
+(assert_return (invoke "ref_cast_non_null" (i32.const 1)))
+(assert_return (invoke "ref_cast_non_null" (i32.const 2)))
+(assert_return (invoke "ref_cast_non_null" (i32.const 3)))
+(assert_return (invoke "ref_cast_non_null" (i32.const 4)))
+(assert_trap (invoke "ref_cast_non_null" (i32.const 5)) "null reference")
+(assert_trap (invoke "ref_cast_non_null" (i32.const 6)) "null reference")
+(assert_trap (invoke "ref_cast_non_null" (i32.const 7)) "null reference")
+
+(assert_return (invoke "ref_cast_null" (i32.const 0)))
+(assert_trap (invoke "ref_cast_null" (i32.const 1)) "cast failure")
+(assert_trap (invoke "ref_cast_null" (i32.const 2)) "cast failure")
+(assert_trap (invoke "ref_cast_null" (i32.const 3)) "cast failure")
+(assert_trap (invoke "ref_cast_null" (i32.const 4)) "cast failure")
+(assert_return (invoke "ref_cast_null" (i32.const 5)))
+(assert_return (invoke "ref_cast_null" (i32.const 6)))
+(assert_return (invoke "ref_cast_null" (i32.const 7)))
+
+(assert_trap (invoke "ref_cast_i31" (i32.const 0)) "cast failure")
+(assert_return (invoke "ref_cast_i31" (i32.const 1)))
+(assert_trap (invoke "ref_cast_i31" (i32.const 2)) "cast failure")
+(assert_trap (invoke "ref_cast_i31" (i32.const 3)) "cast failure")
+(assert_trap (invoke "ref_cast_i31" (i32.const 4)) "cast failure")
+(assert_trap (invoke "ref_cast_i31" (i32.const 5)) "cast failure")
+(assert_trap (invoke "ref_cast_i31" (i32.const 6)) "cast failure")
+(assert_trap (invoke "ref_cast_i31" (i32.const 7)) "cast failure")
+
+(assert_trap (invoke "ref_cast_struct" (i32.const 0)) "cast failure")
+(assert_trap (invoke "ref_cast_struct" (i32.const 1)) "cast failure")
+(assert_return (invoke "ref_cast_struct" (i32.const 2)))
+(assert_trap (invoke "ref_cast_struct" (i32.const 3)) "cast failure")
+(assert_trap (invoke "ref_cast_struct" (i32.const 4)) "cast failure")
+(assert_trap (invoke "ref_cast_struct" (i32.const 5)) "cast failure")
+(assert_trap (invoke "ref_cast_struct" (i32.const 6)) "cast failure")
+(assert_trap (invoke "ref_cast_struct" (i32.const 7)) "cast failure")
+
+(assert_trap (invoke "ref_cast_array" (i32.const 0)) "cast failure")
+(assert_trap (invoke "ref_cast_array" (i32.const 1)) "cast failure")
+(assert_trap (invoke "ref_cast_array" (i32.const 2)) "cast failure")
+(assert_return (invoke "ref_cast_array" (i32.const 3)))
+(assert_trap (invoke "ref_cast_array" (i32.const 4)) "cast failure")
+(assert_trap (invoke "ref_cast_array" (i32.const 5)) "cast failure")
+(assert_trap (invoke "ref_cast_array" (i32.const 6)) "cast failure")
+(assert_trap (invoke "ref_cast_array" (i32.const 7)) "cast failure")
+
+
+;; Concrete Types
+
 (module
-  (type $t0 (struct))
-  (type $t1 (struct (field i32)))
-  (type $t1' (struct (field i32)))
-  (type $t2 (struct (field i32 i32)))
-  (type $t2' (struct (field i32 i32)))
-  (type $t3 (struct (field i32 i32)))
-
-  (global $t0 (rtt $t0) (rtt.canon $t0))
-  (global $t0' (rtt $t0) (rtt.canon $t0))
-  (global $t1 (rtt $t1) (rtt.sub $t1 (global.get $t0)))
-  (global $t1' (rtt $t1') (rtt.sub $t1' (global.get $t0)))
-  (global $t2 (rtt $t2) (rtt.sub $t2 (global.get $t1)))
-  (global $t2' (rtt $t2') (rtt.sub $t2' (global.get $t1')))
-  (global $t3 (rtt $t3) (rtt.sub $t3 (global.get $t0)))
-  (global $t4 (rtt $t3) (rtt.sub $t3 (rtt.sub $t0 (global.get $t0))))
-
-  (table 20 dataref)
+  (type $t0 (sub (struct)))
+  (type $t1 (sub $t0 (struct (field i32))))
+  (type $t1' (sub $t0 (struct (field i32))))
+  (type $t2 (sub $t1 (struct (field i32 i32))))
+  (type $t2' (sub $t1' (struct (field i32 i32))))
+  (type $t3 (sub $t0 (struct (field i32 i32))))
+  (type $t0' (sub $t0 (struct)))
+  (type $t4 (sub $t0' (struct (field i32 i32))))
+
+  (table 20 (ref null struct))
 
   (func $init
-    (table.set (i32.const 0) (struct.new_default $t0 (global.get $t0)))
-    (table.set (i32.const 10) (struct.new_default $t0 (global.get $t0')))
-    (table.set (i32.const 1) (struct.new_default $t1 (global.get $t1)))
-    (table.set (i32.const 11) (struct.new_default $t1' (global.get $t1')))
-    (table.set (i32.const 2) (struct.new_default $t2 (global.get $t2)))
-    (table.set (i32.const 12) (struct.new_default $t2' (global.get $t2')))
-    (table.set (i32.const 3) (struct.new_default $t3 (global.get $t3)))
-    (table.set (i32.const 4) (struct.new_default $t3 (global.get $t4)))
+    (table.set (i32.const 0) (struct.new_default $t0))
+    (table.set (i32.const 10) (struct.new_default $t0))
+    (table.set (i32.const 1) (struct.new_default $t1))
+    (table.set (i32.const 11) (struct.new_default $t1'))
+    (table.set (i32.const 2) (struct.new_default $t2))
+    (table.set (i32.const 12) (struct.new_default $t2'))
+    (table.set (i32.const 3) (struct.new_default $t3))
+    (table.set (i32.const 4) (struct.new_default $t4))
   )
 
   (func (export "test-sub")
     (call $init)
 
-    (drop (ref.cast (ref.null data) (global.get $t0)))
-    (drop (ref.cast (table.get (i32.const 0)) (global.get $t0)))
-    (drop (ref.cast (table.get (i32.const 1)) (global.get $t0)))
-    (drop (ref.cast (table.get (i32.const 2)) (global.get $t0)))
-    (drop (ref.cast (table.get (i32.const 3)) (global.get $t0)))
-    (drop (ref.cast (table.get (i32.const 4)) (global.get $t0)))
+    (drop (ref.cast (ref null $t0) (ref.null struct)))
+    (drop (ref.cast (ref null $t0) (table.get (i32.const 0))))
+    (drop (ref.cast (ref null $t0) (table.get (i32.const 1))))
+    (drop (ref.cast (ref null $t0) (table.get (i32.const 2))))
+    (drop (ref.cast (ref null $t0) (table.get (i32.const 3))))
+    (drop (ref.cast (ref null $t0) (table.get (i32.const 4))))
+
+    (drop (ref.cast (ref null $t0) (ref.null struct)))
+    (drop (ref.cast (ref null $t1) (table.get (i32.const 1))))
+    (drop (ref.cast (ref null $t1) (table.get (i32.const 2))))
+
+    (drop (ref.cast (ref null $t0) (ref.null struct)))
+    (drop (ref.cast (ref null $t2) (table.get (i32.const 2))))
+
+    (drop (ref.cast (ref null $t0) (ref.null struct)))
+    (drop (ref.cast (ref null $t3) (table.get (i32.const 3))))
+
+    (drop (ref.cast (ref null $t4) (table.get (i32.const 4))))
+
+    (drop (ref.cast (ref $t0) (table.get (i32.const 0))))
+    (drop (ref.cast (ref $t0) (table.get (i32.const 1))))
+    (drop (ref.cast (ref $t0) (table.get (i32.const 2))))
+    (drop (ref.cast (ref $t0) (table.get (i32.const 3))))
+    (drop (ref.cast (ref $t0) (table.get (i32.const 4))))
 
-    (drop (ref.cast (ref.null data) (global.get $t0)))
-    (drop (ref.cast (table.get (i32.const 1)) (global.get $t1)))
-    (drop (ref.cast (table.get (i32.const 2)) (global.get $t1)))
+    (drop (ref.cast (ref $t1) (table.get (i32.const 1))))
+    (drop (ref.cast (ref $t1) (table.get (i32.const 2))))
 
-    (drop (ref.cast (ref.null data) (global.get $t0)))
-    (drop (ref.cast (table.get (i32.const 2)) (global.get $t2)))
+    (drop (ref.cast (ref $t2) (table.get (i32.const 2))))
 
-    (drop (ref.cast (ref.null data) (global.get $t0)))
-    (drop (ref.cast (table.get (i32.const 3)) (global.get $t3)))
+    (drop (ref.cast (ref $t3) (table.get (i32.const 3))))
 
-    (drop (ref.cast (ref.null data) (global.get $t0)))
-    (drop (ref.cast (table.get (i32.const 4)) (global.get $t4)))
+    (drop (ref.cast (ref $t4) (table.get (i32.const 4))))
   )
 
   (func (export "test-canon")
     (call $init)
 
-    (drop (ref.cast (table.get (i32.const 0)) (global.get $t0')))
-    (drop (ref.cast (table.get (i32.const 1)) (global.get $t0')))
-    (drop (ref.cast (table.get (i32.const 2)) (global.get $t0')))
-    (drop (ref.cast (table.get (i32.const 3)) (global.get $t0')))
-    (drop (ref.cast (table.get (i32.const 4)) (global.get $t0')))
+    (drop (ref.cast (ref $t0) (table.get (i32.const 0))))
+    (drop (ref.cast (ref $t0) (table.get (i32.const 1))))
+    (drop (ref.cast (ref $t0) (table.get (i32.const 2))))
+    (drop (ref.cast (ref $t0) (table.get (i32.const 3))))
+    (drop (ref.cast (ref $t0) (table.get (i32.const 4))))
 
-    (drop (ref.cast (table.get (i32.const 10)) (global.get $t0)))
-    (drop (ref.cast (table.get (i32.const 11)) (global.get $t0)))
-    (drop (ref.cast (table.get (i32.const 12)) (global.get $t0)))
+    (drop (ref.cast (ref $t0) (table.get (i32.const 10))))
+    (drop (ref.cast (ref $t0) (table.get (i32.const 11))))
+    (drop (ref.cast (ref $t0) (table.get (i32.const 12))))
 
-    (drop (ref.cast (table.get (i32.const 1)) (global.get $t1')))
-    (drop (ref.cast (table.get (i32.const 2)) (global.get $t1')))
+    (drop (ref.cast (ref $t1') (table.get (i32.const 1))))
+    (drop (ref.cast (ref $t1') (table.get (i32.const 2))))
 
-    (drop (ref.cast (table.get (i32.const 11)) (global.get $t1)))
-    (drop (ref.cast (table.get (i32.const 12)) (global.get $t1)))
+    (drop (ref.cast (ref $t1) (table.get (i32.const 11))))
+    (drop (ref.cast (ref $t1) (table.get (i32.const 12))))
 
-    (drop (ref.cast (table.get (i32.const 2)) (global.get $t2')))
+    (drop (ref.cast (ref $t2') (table.get (i32.const 2))))
 
-    (drop (ref.cast (table.get (i32.const 12)) (global.get $t2)))
+    (drop (ref.cast (ref $t2) (table.get (i32.const 12))))
   )
 )
 
diff --git a/tests/wast/spec/proposals/gc/ref_eq.wast b/tests/wast/spec/proposals/gc/ref_eq.wast
index 5542f264ae..001efd69f8 100644
--- a/tests/wast/spec/proposals/gc/ref_eq.wast
+++ b/tests/wast/spec/proposals/gc/ref_eq.wast
@@ -1,27 +1,24 @@
 (module
-  (type $st (struct))
-  (type $st' (struct (field i32)))
+  (type $st (sub (struct)))
+  (type $st' (sub (struct (field i32))))
   (type $at (array i8))
+  (type $st-sub1 (sub $st (struct)))
+  (type $st-sub2 (sub $st (struct)))
+  (type $st'-sub1 (sub $st' (struct (field i32))))
+  (type $st'-sub2 (sub $st' (struct (field i32))))
 
   (table 20 (ref null eq))
 
   (func (export "init")
     (table.set (i32.const 0) (ref.null eq))
     (table.set (i32.const 1) (ref.null i31))
-    (table.set (i32.const 2) (i31.new (i32.const 7)))
-    (table.set (i32.const 3) (i31.new (i32.const 7)))
-    (table.set (i32.const 4) (i31.new (i32.const 8)))
-    (table.set (i32.const 5) (struct.new_default $st (rtt.canon $st)))
-    (table.set (i32.const 6) (struct.new_default $st (rtt.canon $st)))
-    (table.set (i32.const 7) (array.new_default $at (i32.const 0) (rtt.canon $at)))
-    (table.set (i32.const 8) (array.new_default $at (i32.const 0) (rtt.canon $at)))
-    (table.set (i32.const 9) (rtt.canon $st))
-    (table.set (i32.const 10) (rtt.canon $st))
-    (table.set (i32.const 11) (rtt.canon $at))
-    (table.set (i32.const 12) (rtt.sub $st (rtt.canon $st)))
-    (table.set (i32.const 13) (rtt.sub $st (rtt.canon $st)))
-    (table.set (i32.const 14) (rtt.sub $st' (rtt.canon $st)))
-    (table.set (i32.const 15) (rtt.sub $st' (rtt.canon $st)))
+    (table.set (i32.const 2) (ref.i31 (i32.const 7)))
+    (table.set (i32.const 3) (ref.i31 (i32.const 7)))
+    (table.set (i32.const 4) (ref.i31 (i32.const 8)))
+    (table.set (i32.const 5) (struct.new_default $st))
+    (table.set (i32.const 6) (struct.new_default $st))
+    (table.set (i32.const 7) (array.new_default $at (i32.const 0)))
+    (table.set (i32.const 8) (array.new_default $at (i32.const 0)))
   )
 
   (func (export "eq") (param $i i32) (param $j i32) (result i32)
@@ -40,13 +37,6 @@
 (assert_return (invoke "eq" (i32.const 0) (i32.const 6)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 0) (i32.const 7)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 0) (i32.const 8)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 0) (i32.const 9)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 0) (i32.const 10)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 0) (i32.const 11)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 0) (i32.const 12)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 0) (i32.const 13)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 0) (i32.const 14)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 0) (i32.const 15)) (i32.const 0))
 
 (assert_return (invoke "eq" (i32.const 1) (i32.const 0)) (i32.const 1))
 (assert_return (invoke "eq" (i32.const 1) (i32.const 1)) (i32.const 1))
@@ -57,13 +47,6 @@
 (assert_return (invoke "eq" (i32.const 1) (i32.const 6)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 1) (i32.const 7)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 1) (i32.const 8)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 1) (i32.const 9)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 1) (i32.const 10)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 1) (i32.const 11)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 1) (i32.const 12)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 1) (i32.const 13)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 1) (i32.const 14)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 1) (i32.const 15)) (i32.const 0))
 
 (assert_return (invoke "eq" (i32.const 2) (i32.const 0)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 2) (i32.const 1)) (i32.const 0))
@@ -74,13 +57,6 @@
 (assert_return (invoke "eq" (i32.const 2) (i32.const 6)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 2) (i32.const 7)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 2) (i32.const 8)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 2) (i32.const 9)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 2) (i32.const 10)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 2) (i32.const 11)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 2) (i32.const 12)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 2) (i32.const 13)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 2) (i32.const 14)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 2) (i32.const 15)) (i32.const 0))
 
 (assert_return (invoke "eq" (i32.const 3) (i32.const 0)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 3) (i32.const 1)) (i32.const 0))
@@ -91,13 +67,6 @@
 (assert_return (invoke "eq" (i32.const 3) (i32.const 6)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 3) (i32.const 7)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 3) (i32.const 8)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 3) (i32.const 9)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 3) (i32.const 10)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 3) (i32.const 11)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 3) (i32.const 12)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 3) (i32.const 13)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 3) (i32.const 14)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 3) (i32.const 15)) (i32.const 0))
 
 (assert_return (invoke "eq" (i32.const 4) (i32.const 0)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 4) (i32.const 1)) (i32.const 0))
@@ -108,13 +77,6 @@
 (assert_return (invoke "eq" (i32.const 4) (i32.const 6)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 4) (i32.const 7)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 4) (i32.const 8)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 4) (i32.const 9)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 4) (i32.const 10)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 4) (i32.const 11)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 4) (i32.const 12)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 4) (i32.const 13)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 4) (i32.const 14)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 4) (i32.const 15)) (i32.const 0))
 
 (assert_return (invoke "eq" (i32.const 5) (i32.const 0)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 5) (i32.const 1)) (i32.const 0))
@@ -125,13 +87,6 @@
 (assert_return (invoke "eq" (i32.const 5) (i32.const 6)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 5) (i32.const 7)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 5) (i32.const 8)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 5) (i32.const 9)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 5) (i32.const 10)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 5) (i32.const 11)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 5) (i32.const 12)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 5) (i32.const 13)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 5) (i32.const 14)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 5) (i32.const 15)) (i32.const 0))
 
 (assert_return (invoke "eq" (i32.const 6) (i32.const 0)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 6) (i32.const 1)) (i32.const 0))
@@ -142,13 +97,6 @@
 (assert_return (invoke "eq" (i32.const 6) (i32.const 6)) (i32.const 1))
 (assert_return (invoke "eq" (i32.const 6) (i32.const 7)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 6) (i32.const 8)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 6) (i32.const 9)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 6) (i32.const 10)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 6) (i32.const 11)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 6) (i32.const 12)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 6) (i32.const 13)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 6) (i32.const 14)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 6) (i32.const 15)) (i32.const 0))
 
 (assert_return (invoke "eq" (i32.const 7) (i32.const 0)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 7) (i32.const 1)) (i32.const 0))
@@ -159,13 +107,6 @@
 (assert_return (invoke "eq" (i32.const 7) (i32.const 6)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 7) (i32.const 7)) (i32.const 1))
 (assert_return (invoke "eq" (i32.const 7) (i32.const 8)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 7) (i32.const 9)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 7) (i32.const 10)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 7) (i32.const 11)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 7) (i32.const 12)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 7) (i32.const 13)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 7) (i32.const 14)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 7) (i32.const 15)) (i32.const 0))
 
 (assert_return (invoke "eq" (i32.const 8) (i32.const 0)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 8) (i32.const 1)) (i32.const 0))
@@ -176,132 +117,6 @@
 (assert_return (invoke "eq" (i32.const 8) (i32.const 6)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 8) (i32.const 7)) (i32.const 0))
 (assert_return (invoke "eq" (i32.const 8) (i32.const 8)) (i32.const 1))
-(assert_return (invoke "eq" (i32.const 8) (i32.const 9)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 8) (i32.const 10)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 8) (i32.const 11)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 8) (i32.const 12)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 8) (i32.const 13)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 8) (i32.const 14)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 8) (i32.const 15)) (i32.const 0))
-
-(assert_return (invoke "eq" (i32.const 9) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 9) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 9) (i32.const 2)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 9) (i32.const 3)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 9) (i32.const 4)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 9) (i32.const 5)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 9) (i32.const 6)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 9) (i32.const 7)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 9) (i32.const 8)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 9) (i32.const 9)) (i32.const 1))
-(assert_return (invoke "eq" (i32.const 9) (i32.const 10)) (i32.const 1))
-(assert_return (invoke "eq" (i32.const 9) (i32.const 11)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 9) (i32.const 12)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 9) (i32.const 13)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 9) (i32.const 14)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 9) (i32.const 15)) (i32.const 0))
-
-(assert_return (invoke "eq" (i32.const 10) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 10) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 10) (i32.const 2)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 10) (i32.const 3)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 10) (i32.const 4)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 10) (i32.const 5)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 10) (i32.const 6)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 10) (i32.const 7)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 10) (i32.const 8)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 10) (i32.const 9)) (i32.const 1))
-(assert_return (invoke "eq" (i32.const 10) (i32.const 10)) (i32.const 1))
-(assert_return (invoke "eq" (i32.const 10) (i32.const 11)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 10) (i32.const 12)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 10) (i32.const 13)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 10) (i32.const 14)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 10) (i32.const 15)) (i32.const 0))
-
-(assert_return (invoke "eq" (i32.const 11) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 11) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 11) (i32.const 2)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 11) (i32.const 3)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 11) (i32.const 4)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 11) (i32.const 5)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 11) (i32.const 6)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 11) (i32.const 7)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 11) (i32.const 8)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 11) (i32.const 9)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 11) (i32.const 10)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 11) (i32.const 11)) (i32.const 1))
-(assert_return (invoke "eq" (i32.const 11) (i32.const 12)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 11) (i32.const 13)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 11) (i32.const 14)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 11) (i32.const 15)) (i32.const 0))
-
-(assert_return (invoke "eq" (i32.const 12) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 12) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 12) (i32.const 2)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 12) (i32.const 3)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 12) (i32.const 4)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 12) (i32.const 5)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 12) (i32.const 6)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 12) (i32.const 7)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 12) (i32.const 8)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 12) (i32.const 9)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 12) (i32.const 10)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 12) (i32.const 11)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 12) (i32.const 12)) (i32.const 1))
-(assert_return (invoke "eq" (i32.const 12) (i32.const 13)) (i32.const 1))
-(assert_return (invoke "eq" (i32.const 12) (i32.const 14)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 12) (i32.const 15)) (i32.const 0))
-
-(assert_return (invoke "eq" (i32.const 13) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 13) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 13) (i32.const 2)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 13) (i32.const 3)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 13) (i32.const 4)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 13) (i32.const 5)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 13) (i32.const 6)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 13) (i32.const 7)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 13) (i32.const 8)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 13) (i32.const 9)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 13) (i32.const 10)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 13) (i32.const 11)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 13) (i32.const 12)) (i32.const 1))
-(assert_return (invoke "eq" (i32.const 13) (i32.const 13)) (i32.const 1))
-(assert_return (invoke "eq" (i32.const 13) (i32.const 14)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 13) (i32.const 15)) (i32.const 0))
-
-(assert_return (invoke "eq" (i32.const 14) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 14) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 14) (i32.const 2)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 14) (i32.const 3)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 14) (i32.const 4)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 14) (i32.const 5)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 14) (i32.const 6)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 14) (i32.const 7)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 14) (i32.const 8)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 14) (i32.const 9)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 14) (i32.const 10)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 14) (i32.const 11)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 14) (i32.const 12)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 14) (i32.const 13)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 14) (i32.const 14)) (i32.const 1))
-(assert_return (invoke "eq" (i32.const 14) (i32.const 15)) (i32.const 1))
-
-(assert_return (invoke "eq" (i32.const 15) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 15) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 15) (i32.const 2)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 15) (i32.const 3)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 15) (i32.const 4)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 15) (i32.const 5)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 15) (i32.const 6)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 15) (i32.const 7)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 15) (i32.const 8)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 15) (i32.const 9)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 15) (i32.const 10)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 15) (i32.const 11)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 15) (i32.const 12)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 15) (i32.const 13)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 15) (i32.const 14)) (i32.const 1))
-(assert_return (invoke "eq" (i32.const 15) (i32.const 15)) (i32.const 1))
 
 (assert_invalid
   (module
diff --git a/tests/wast/spec/proposals/gc/ref_null.wast b/tests/wast/spec/proposals/gc/ref_null.wast
index ab3a8b4ea0..1ffd03f8a4 100644
--- a/tests/wast/spec/proposals/gc/ref_null.wast
+++ b/tests/wast/spec/proposals/gc/ref_null.wast
@@ -1,14 +1,63 @@
 (module
   (type $t (func))
-  (func (export "externref") (result externref) (ref.null extern))
+  (func (export "anyref") (result anyref) (ref.null any))
   (func (export "funcref") (result funcref) (ref.null func))
   (func (export "ref") (result (ref null $t)) (ref.null $t))
 
-  (global externref (ref.null extern))
+  (global anyref (ref.null any))
   (global funcref (ref.null func))
   (global (ref null $t) (ref.null $t))
 )
 
-(assert_return (invoke "externref") (ref.null extern))
+(assert_return (invoke "anyref") (ref.null any))
 (assert_return (invoke "funcref") (ref.null func))
 (assert_return (invoke "ref") (ref.null))
+
+
+(module
+  (type $t (func))
+  (global $null nullref (ref.null none))
+  (global $nullfunc nullfuncref (ref.null nofunc))
+  (global $nullextern nullexternref (ref.null noextern))
+  (func (export "anyref") (result anyref) (global.get $null))
+  (func (export "nullref") (result nullref) (global.get $null))
+  (func (export "funcref") (result funcref) (global.get $nullfunc))
+  (func (export "nullfuncref") (result nullfuncref) (global.get $nullfunc))
+  (func (export "externref") (result externref) (global.get $nullextern))
+  (func (export "nullexternref") (result nullexternref) (global.get $nullextern))
+  (func (export "ref") (result (ref null $t)) (global.get $nullfunc))
+
+  (global anyref (ref.null any))
+  (global anyref (ref.null none))
+  (global funcref (ref.null func))
+  (global funcref (ref.null nofunc))
+  (global externref (ref.null extern))
+  (global externref (ref.null noextern))
+  (global nullref (ref.null none))
+  (global nullfuncref (ref.null nofunc))
+  (global nullexternref (ref.null noextern))
+  (global (ref null $t) (ref.null $t))
+  (global (ref null $t) (ref.null nofunc))
+)
+
+(assert_return (invoke "anyref") (ref.null any))
+(assert_return (invoke "anyref") (ref.null none))
+(assert_return (invoke "anyref") (ref.null))
+(assert_return (invoke "nullref") (ref.null any))
+(assert_return (invoke "nullref") (ref.null none))
+(assert_return (invoke "nullref") (ref.null))
+(assert_return (invoke "funcref") (ref.null func))
+(assert_return (invoke "funcref") (ref.null nofunc))
+(assert_return (invoke "funcref") (ref.null))
+(assert_return (invoke "nullfuncref") (ref.null func))
+(assert_return (invoke "nullfuncref") (ref.null nofunc))
+(assert_return (invoke "nullfuncref") (ref.null))
+(assert_return (invoke "externref") (ref.null extern))
+(assert_return (invoke "externref") (ref.null noextern))
+(assert_return (invoke "externref") (ref.null))
+(assert_return (invoke "nullexternref") (ref.null extern))
+(assert_return (invoke "nullexternref") (ref.null noextern))
+(assert_return (invoke "nullexternref") (ref.null))
+(assert_return (invoke "ref") (ref.null func))
+(assert_return (invoke "ref") (ref.null nofunc))
+(assert_return (invoke "ref") (ref.null))
diff --git a/tests/wast/spec/proposals/gc/ref_test.wast b/tests/wast/spec/proposals/gc/ref_test.wast
index 7012939575..590b81b8a4 100644
--- a/tests/wast/spec/proposals/gc/ref_test.wast
+++ b/tests/wast/spec/proposals/gc/ref_test.wast
@@ -1,77 +1,296 @@
+;; Abstract Types
+
+(module
+  (type $ft (func))
+  (type $st (struct))
+  (type $at (array i8))
+
+  (table $ta 10 anyref)
+  (table $tf 10 funcref)
+  (table $te 10 externref)
+
+  (elem declare func $f)
+  (func $f)
+
+  (func (export "init") (param $x externref)
+    (table.set $ta (i32.const 0) (ref.null any))
+    (table.set $ta (i32.const 1) (ref.null struct))
+    (table.set $ta (i32.const 2) (ref.null none))
+    (table.set $ta (i32.const 3) (ref.i31 (i32.const 7)))
+    (table.set $ta (i32.const 4) (struct.new_default $st))
+    (table.set $ta (i32.const 5) (array.new_default $at (i32.const 0)))
+    (table.set $ta (i32.const 6) (any.convert_extern (local.get $x)))
+    (table.set $ta (i32.const 7) (any.convert_extern (ref.null extern)))
+
+    (table.set $tf (i32.const 0) (ref.null nofunc))
+    (table.set $tf (i32.const 1) (ref.null func))
+    (table.set $tf (i32.const 2) (ref.func $f))
+
+    (table.set $te (i32.const 0) (ref.null noextern))
+    (table.set $te (i32.const 1) (ref.null extern))
+    (table.set $te (i32.const 2) (local.get $x))
+    (table.set $te (i32.const 3) (extern.convert_any (ref.i31 (i32.const 8))))
+    (table.set $te (i32.const 4) (extern.convert_any (struct.new_default $st)))
+    (table.set $te (i32.const 5) (extern.convert_any (ref.null any)))
+  )
+
+  (func (export "ref_test_null_data") (param $i i32) (result i32)
+    (i32.add
+      (ref.is_null (table.get $ta (local.get $i)))
+      (ref.test nullref (table.get $ta (local.get $i)))
+    )
+  )
+  (func (export "ref_test_any") (param $i i32) (result i32)
+    (i32.add
+      (ref.test (ref any) (table.get $ta (local.get $i)))
+      (ref.test anyref (table.get $ta (local.get $i)))
+    )
+  )
+  (func (export "ref_test_eq") (param $i i32) (result i32)
+    (i32.add
+      (ref.test (ref eq) (table.get $ta (local.get $i)))
+      (ref.test eqref (table.get $ta (local.get $i)))
+    )
+  )
+  (func (export "ref_test_i31") (param $i i32) (result i32)
+    (i32.add
+      (ref.test (ref i31) (table.get $ta (local.get $i)))
+      (ref.test i31ref (table.get $ta (local.get $i)))
+    )
+  )
+  (func (export "ref_test_struct") (param $i i32) (result i32)
+    (i32.add
+      (ref.test (ref struct) (table.get $ta (local.get $i)))
+      (ref.test structref (table.get $ta (local.get $i)))
+    )
+  )
+  (func (export "ref_test_array") (param $i i32) (result i32)
+    (i32.add
+      (ref.test (ref array) (table.get $ta (local.get $i)))
+      (ref.test arrayref (table.get $ta (local.get $i)))
+    )
+  )
+
+  (func (export "ref_test_null_func") (param $i i32) (result i32)
+    (i32.add
+      (ref.is_null (table.get $tf (local.get $i)))
+      (ref.test (ref null nofunc) (table.get $tf (local.get $i)))
+    )
+  )
+  (func (export "ref_test_func") (param $i i32) (result i32)
+    (i32.add
+      (ref.test (ref func) (table.get $tf (local.get $i)))
+      (ref.test funcref (table.get $tf (local.get $i)))
+    )
+  )
+
+  (func (export "ref_test_null_extern") (param $i i32) (result i32)
+    (i32.add
+      (ref.is_null (table.get $te (local.get $i)))
+      (ref.test (ref null noextern) (table.get $te (local.get $i)))
+    )
+  )
+  (func (export "ref_test_extern") (param $i i32) (result i32)
+    (i32.add
+      (ref.test (ref extern) (table.get $te (local.get $i)))
+      (ref.test externref (table.get $te (local.get $i)))
+    )
+  )
+)
+
+(invoke "init" (ref.extern 0))
+
+(assert_return (invoke "ref_test_null_data" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "ref_test_null_data" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "ref_test_null_data" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "ref_test_null_data" (i32.const 3)) (i32.const 0))
+(assert_return (invoke "ref_test_null_data" (i32.const 4)) (i32.const 0))
+(assert_return (invoke "ref_test_null_data" (i32.const 5)) (i32.const 0))
+(assert_return (invoke "ref_test_null_data" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "ref_test_null_data" (i32.const 7)) (i32.const 2))
+
+(assert_return (invoke "ref_test_any" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ref_test_any" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "ref_test_any" (i32.const 2)) (i32.const 1))
+(assert_return (invoke "ref_test_any" (i32.const 3)) (i32.const 2))
+(assert_return (invoke "ref_test_any" (i32.const 4)) (i32.const 2))
+(assert_return (invoke "ref_test_any" (i32.const 5)) (i32.const 2))
+(assert_return (invoke "ref_test_any" (i32.const 6)) (i32.const 2))
+(assert_return (invoke "ref_test_any" (i32.const 7)) (i32.const 1))
+
+(assert_return (invoke "ref_test_eq" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ref_test_eq" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "ref_test_eq" (i32.const 2)) (i32.const 1))
+(assert_return (invoke "ref_test_eq" (i32.const 3)) (i32.const 2))
+(assert_return (invoke "ref_test_eq" (i32.const 4)) (i32.const 2))
+(assert_return (invoke "ref_test_eq" (i32.const 5)) (i32.const 2))
+(assert_return (invoke "ref_test_eq" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "ref_test_eq" (i32.const 7)) (i32.const 1))
+
+(assert_return (invoke "ref_test_i31" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ref_test_i31" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "ref_test_i31" (i32.const 2)) (i32.const 1))
+(assert_return (invoke "ref_test_i31" (i32.const 3)) (i32.const 2))
+(assert_return (invoke "ref_test_i31" (i32.const 4)) (i32.const 0))
+(assert_return (invoke "ref_test_i31" (i32.const 5)) (i32.const 0))
+(assert_return (invoke "ref_test_i31" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "ref_test_i31" (i32.const 7)) (i32.const 1))
+
+(assert_return (invoke "ref_test_struct" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ref_test_struct" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "ref_test_struct" (i32.const 2)) (i32.const 1))
+(assert_return (invoke "ref_test_struct" (i32.const 3)) (i32.const 0))
+(assert_return (invoke "ref_test_struct" (i32.const 4)) (i32.const 2))
+(assert_return (invoke "ref_test_struct" (i32.const 5)) (i32.const 0))
+(assert_return (invoke "ref_test_struct" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "ref_test_struct" (i32.const 7)) (i32.const 1))
+
+(assert_return (invoke "ref_test_array" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ref_test_array" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "ref_test_array" (i32.const 2)) (i32.const 1))
+(assert_return (invoke "ref_test_array" (i32.const 3)) (i32.const 0))
+(assert_return (invoke "ref_test_array" (i32.const 4)) (i32.const 0))
+(assert_return (invoke "ref_test_array" (i32.const 5)) (i32.const 2))
+(assert_return (invoke "ref_test_array" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "ref_test_array" (i32.const 7)) (i32.const 1))
+
+(assert_return (invoke "ref_test_null_func" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "ref_test_null_func" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "ref_test_null_func" (i32.const 2)) (i32.const 0))
+
+(assert_return (invoke "ref_test_func" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ref_test_func" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "ref_test_func" (i32.const 2)) (i32.const 2))
+
+(assert_return (invoke "ref_test_null_extern" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "ref_test_null_extern" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "ref_test_null_extern" (i32.const 2)) (i32.const 0))
+(assert_return (invoke "ref_test_null_extern" (i32.const 3)) (i32.const 0))
+(assert_return (invoke "ref_test_null_extern" (i32.const 4)) (i32.const 0))
+(assert_return (invoke "ref_test_null_extern" (i32.const 5)) (i32.const 2))
+
+(assert_return (invoke "ref_test_extern" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ref_test_extern" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "ref_test_extern" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "ref_test_extern" (i32.const 3)) (i32.const 2))
+(assert_return (invoke "ref_test_extern" (i32.const 4)) (i32.const 2))
+(assert_return (invoke "ref_test_extern" (i32.const 5)) (i32.const 1))
+
+
+;; Concrete Types
+
 (module
-  (type $t0 (struct))
-  (type $t1 (struct (field i32)))
-  (type $t1' (struct (field i32)))
-  (type $t2 (struct (field i32 i32)))
-  (type $t2' (struct (field i32 i32)))
-  (type $t3 (struct (field i32 i32)))
-
-  (global $t0 (rtt $t0) (rtt.canon $t0))
-  (global $t0' (rtt $t0) (rtt.canon $t0))
-  (global $t1 (rtt $t1) (rtt.sub $t1 (global.get $t0)))
-  (global $t1' (rtt $t1') (rtt.sub $t1' (global.get $t0)))
-  (global $t2 (rtt $t2) (rtt.sub $t2 (global.get $t1)))
-  (global $t2' (rtt $t2') (rtt.sub $t2' (global.get $t1')))
-  (global $t3 (rtt $t3) (rtt.sub $t3 (global.get $t0)))
-  (global $t4 (rtt $t3) (rtt.sub $t3 (rtt.sub $t0 (global.get $t0))))
-
-  (table 20 dataref)
+  (type $t0 (sub (struct)))
+  (type $t1 (sub $t0 (struct (field i32))))
+  (type $t1' (sub $t0 (struct (field i32))))
+  (type $t2 (sub $t1 (struct (field i32 i32))))
+  (type $t2' (sub $t1' (struct (field i32 i32))))
+  (type $t3 (sub $t0 (struct (field i32 i32))))
+  (type $t0' (sub $t0 (struct)))
+  (type $t4 (sub $t0' (struct (field i32 i32))))
+
+  (table 20 (ref null struct))
 
   (func $init
-    (table.set (i32.const 0) (struct.new_default $t0 (global.get $t0)))
-    (table.set (i32.const 10) (struct.new_default $t0 (global.get $t0')))
-    (table.set (i32.const 1) (struct.new_default $t1 (global.get $t1)))
-    (table.set (i32.const 11) (struct.new_default $t1' (global.get $t1')))
-    (table.set (i32.const 2) (struct.new_default $t2 (global.get $t2)))
-    (table.set (i32.const 12) (struct.new_default $t2' (global.get $t2')))
-    (table.set (i32.const 3) (struct.new_default $t3 (global.get $t3)))
-    (table.set (i32.const 4) (struct.new_default $t3 (global.get $t4)))
+    (table.set (i32.const 0) (struct.new_default $t0))
+    (table.set (i32.const 10) (struct.new_default $t0))
+    (table.set (i32.const 1) (struct.new_default $t1))
+    (table.set (i32.const 11) (struct.new_default $t1'))
+    (table.set (i32.const 2) (struct.new_default $t2))
+    (table.set (i32.const 12) (struct.new_default $t2'))
+    (table.set (i32.const 3) (struct.new_default $t3))
+    (table.set (i32.const 4) (struct.new_default $t4))
   )
 
   (func (export "test-sub")
     (call $init)
     (block $l
       ;; must hold
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 0)) (global.get $t0))))
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 1)) (global.get $t0))))
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 2)) (global.get $t0))))
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 3)) (global.get $t0))))
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 4)) (global.get $t0))))
+      (br_if $l (i32.eqz (ref.test (ref null $t0) (ref.null struct))))
+      (br_if $l (i32.eqz (ref.test (ref null $t0) (ref.null $t0))))
+      (br_if $l (i32.eqz (ref.test (ref null $t0) (ref.null $t1))))
+      (br_if $l (i32.eqz (ref.test (ref null $t0) (ref.null $t2))))
+      (br_if $l (i32.eqz (ref.test (ref null $t0) (ref.null $t3))))
+      (br_if $l (i32.eqz (ref.test (ref null $t0) (ref.null $t4))))
+      (br_if $l (i32.eqz (ref.test (ref null $t0) (table.get (i32.const 0)))))
+      (br_if $l (i32.eqz (ref.test (ref null $t0) (table.get (i32.const 1)))))
+      (br_if $l (i32.eqz (ref.test (ref null $t0) (table.get (i32.const 2)))))
+      (br_if $l (i32.eqz (ref.test (ref null $t0) (table.get (i32.const 3)))))
+      (br_if $l (i32.eqz (ref.test (ref null $t0) (table.get (i32.const 4)))))
+
+      (br_if $l (i32.eqz (ref.test (ref null $t1) (ref.null struct))))
+      (br_if $l (i32.eqz (ref.test (ref null $t1) (ref.null $t0))))
+      (br_if $l (i32.eqz (ref.test (ref null $t1) (ref.null $t1))))
+      (br_if $l (i32.eqz (ref.test (ref null $t1) (ref.null $t2))))
+      (br_if $l (i32.eqz (ref.test (ref null $t1) (ref.null $t3))))
+      (br_if $l (i32.eqz (ref.test (ref null $t1) (ref.null $t4))))
+      (br_if $l (i32.eqz (ref.test (ref null $t1) (table.get (i32.const 1)))))
+      (br_if $l (i32.eqz (ref.test (ref null $t1) (table.get (i32.const 2)))))
+
+      (br_if $l (i32.eqz (ref.test (ref null $t2) (ref.null struct))))
+      (br_if $l (i32.eqz (ref.test (ref null $t2) (ref.null $t0))))
+      (br_if $l (i32.eqz (ref.test (ref null $t2) (ref.null $t1))))
+      (br_if $l (i32.eqz (ref.test (ref null $t2) (ref.null $t2))))
+      (br_if $l (i32.eqz (ref.test (ref null $t2) (ref.null $t3))))
+      (br_if $l (i32.eqz (ref.test (ref null $t2) (ref.null $t4))))
+      (br_if $l (i32.eqz (ref.test (ref null $t2) (table.get (i32.const 2)))))
 
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 1)) (global.get $t1))))
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 2)) (global.get $t1))))
+      (br_if $l (i32.eqz (ref.test (ref null $t3) (ref.null struct))))
+      (br_if $l (i32.eqz (ref.test (ref null $t3) (ref.null $t0))))
+      (br_if $l (i32.eqz (ref.test (ref null $t3) (ref.null $t1))))
+      (br_if $l (i32.eqz (ref.test (ref null $t3) (ref.null $t2))))
+      (br_if $l (i32.eqz (ref.test (ref null $t3) (ref.null $t3))))
+      (br_if $l (i32.eqz (ref.test (ref null $t3) (ref.null $t4))))
+      (br_if $l (i32.eqz (ref.test (ref null $t3) (table.get (i32.const 3)))))
 
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 2)) (global.get $t2))))
+      (br_if $l (i32.eqz (ref.test (ref null $t4) (ref.null struct))))
+      (br_if $l (i32.eqz (ref.test (ref null $t4) (ref.null $t0))))
+      (br_if $l (i32.eqz (ref.test (ref null $t4) (ref.null $t1))))
+      (br_if $l (i32.eqz (ref.test (ref null $t4) (ref.null $t2))))
+      (br_if $l (i32.eqz (ref.test (ref null $t4) (ref.null $t3))))
+      (br_if $l (i32.eqz (ref.test (ref null $t4) (ref.null $t4))))
+      (br_if $l (i32.eqz (ref.test (ref null $t4) (table.get (i32.const 4)))))
 
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 3)) (global.get $t3))))
+      (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 0)))))
+      (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 1)))))
+      (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 2)))))
+      (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 3)))))
+      (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 4)))))
 
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 4)) (global.get $t4))))
+      (br_if $l (i32.eqz (ref.test (ref $t1) (table.get (i32.const 1)))))
+      (br_if $l (i32.eqz (ref.test (ref $t1) (table.get (i32.const 2)))))
+
+      (br_if $l (i32.eqz (ref.test (ref $t2) (table.get (i32.const 2)))))
+
+      (br_if $l (i32.eqz (ref.test (ref $t3) (table.get (i32.const 3)))))
+
+      (br_if $l (i32.eqz (ref.test (ref $t4) (table.get (i32.const 4)))))
 
       ;; must not hold
-      (br_if $l (ref.test (ref.null data) (global.get $t0)))
-      (br_if $l (ref.test (ref.null data) (global.get $t1)))
-      (br_if $l (ref.test (ref.null data) (global.get $t2)))
-      (br_if $l (ref.test (ref.null data) (global.get $t3)))
-      (br_if $l (ref.test (ref.null data) (global.get $t4)))
-
-      (br_if $l (ref.test (table.get (i32.const 0)) (global.get $t1)))
-      (br_if $l (ref.test (table.get (i32.const 3)) (global.get $t1)))
-      (br_if $l (ref.test (table.get (i32.const 4)) (global.get $t1)))
-
-      (br_if $l (ref.test (table.get (i32.const 0)) (global.get $t2)))
-      (br_if $l (ref.test (table.get (i32.const 1)) (global.get $t2)))
-      (br_if $l (ref.test (table.get (i32.const 3)) (global.get $t2)))
-      (br_if $l (ref.test (table.get (i32.const 4)) (global.get $t2)))
-
-      (br_if $l (ref.test (table.get (i32.const 0)) (global.get $t3)))
-      (br_if $l (ref.test (table.get (i32.const 1)) (global.get $t3)))
-      (br_if $l (ref.test (table.get (i32.const 2)) (global.get $t3)))
-      (br_if $l (ref.test (table.get (i32.const 4)) (global.get $t3)))
-
-      (br_if $l (ref.test (table.get (i32.const 0)) (global.get $t4)))
-      (br_if $l (ref.test (table.get (i32.const 1)) (global.get $t4)))
-      (br_if $l (ref.test (table.get (i32.const 2)) (global.get $t4)))
-      (br_if $l (ref.test (table.get (i32.const 3)) (global.get $t4)))
+      (br_if $l (ref.test (ref $t0) (ref.null struct)))
+      (br_if $l (ref.test (ref $t1) (ref.null struct)))
+      (br_if $l (ref.test (ref $t2) (ref.null struct)))
+      (br_if $l (ref.test (ref $t3) (ref.null struct)))
+      (br_if $l (ref.test (ref $t4) (ref.null struct)))
+
+      (br_if $l (ref.test (ref $t1) (table.get (i32.const 0))))
+      (br_if $l (ref.test (ref $t1) (table.get (i32.const 3))))
+      (br_if $l (ref.test (ref $t1) (table.get (i32.const 4))))
+
+      (br_if $l (ref.test (ref $t2) (table.get (i32.const 0))))
+      (br_if $l (ref.test (ref $t2) (table.get (i32.const 1))))
+      (br_if $l (ref.test (ref $t2) (table.get (i32.const 3))))
+      (br_if $l (ref.test (ref $t2) (table.get (i32.const 4))))
+
+      (br_if $l (ref.test (ref $t3) (table.get (i32.const 0))))
+      (br_if $l (ref.test (ref $t3) (table.get (i32.const 1))))
+      (br_if $l (ref.test (ref $t3) (table.get (i32.const 2))))
+      (br_if $l (ref.test (ref $t3) (table.get (i32.const 4))))
+
+      (br_if $l (ref.test (ref $t4) (table.get (i32.const 0))))
+      (br_if $l (ref.test (ref $t4) (table.get (i32.const 1))))
+      (br_if $l (ref.test (ref $t4) (table.get (i32.const 2))))
+      (br_if $l (ref.test (ref $t4) (table.get (i32.const 3))))
 
       (return)
     )
@@ -81,25 +300,25 @@
   (func (export "test-canon")
     (call $init)
     (block $l
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 0)) (global.get $t0'))))
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 1)) (global.get $t0'))))
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 2)) (global.get $t0'))))
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 3)) (global.get $t0'))))
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 4)) (global.get $t0'))))
+      (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 0)))))
+      (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 1)))))
+      (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 2)))))
+      (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 3)))))
+      (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 4)))))
 
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 10)) (global.get $t0))))
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 11)) (global.get $t0))))
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 12)) (global.get $t0))))
+      (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 10)))))
+      (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 11)))))
+      (br_if $l (i32.eqz (ref.test (ref $t0) (table.get (i32.const 12)))))
 
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 1)) (global.get $t1'))))
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 2)) (global.get $t1'))))
+      (br_if $l (i32.eqz (ref.test (ref $t1') (table.get (i32.const 1)))))
+      (br_if $l (i32.eqz (ref.test (ref $t1') (table.get (i32.const 2)))))
 
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 11)) (global.get $t1))))
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 12)) (global.get $t1))))
+      (br_if $l (i32.eqz (ref.test (ref $t1) (table.get (i32.const 11)))))
+      (br_if $l (i32.eqz (ref.test (ref $t1) (table.get (i32.const 12)))))
 
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 2)) (global.get $t2'))))
+      (br_if $l (i32.eqz (ref.test (ref $t2') (table.get (i32.const 2)))))
 
-      (br_if $l (i32.eqz (ref.test (table.get (i32.const 12)) (global.get $t2))))
+      (br_if $l (i32.eqz (ref.test (ref $t2) (table.get (i32.const 12)))))
 
       (return)
     )
@@ -107,5 +326,5 @@
   )
 )
 
-(invoke "test-sub")
-(invoke "test-canon")
+(assert_return (invoke "test-sub"))
+(assert_return (invoke "test-canon"))
diff --git a/tests/wast/spec/proposals/gc/return_call.wast b/tests/wast/spec/proposals/gc/return_call.wast
new file mode 100644
index 0000000000..b9e8f8f010
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/return_call.wast
@@ -0,0 +1,210 @@
+;; Test `return_call` operator
+
+(module
+  ;; Auxiliary definitions
+  (func $const-i32 (result i32) (i32.const 0x132))
+  (func $const-i64 (result i64) (i64.const 0x164))
+  (func $const-f32 (result f32) (f32.const 0xf32))
+  (func $const-f64 (result f64) (f64.const 0xf64))
+
+  (func $id-i32 (param i32) (result i32) (local.get 0))
+  (func $id-i64 (param i64) (result i64) (local.get 0))
+  (func $id-f32 (param f32) (result f32) (local.get 0))
+  (func $id-f64 (param f64) (result f64) (local.get 0))
+
+  (func $f32-i32 (param f32 i32) (result i32) (local.get 1))
+  (func $i32-i64 (param i32 i64) (result i64) (local.get 1))
+  (func $f64-f32 (param f64 f32) (result f32) (local.get 1))
+  (func $i64-f64 (param i64 f64) (result f64) (local.get 1))
+
+  ;; Typing
+
+  (func (export "type-i32") (result i32) (return_call $const-i32))
+  (func (export "type-i64") (result i64) (return_call $const-i64))
+  (func (export "type-f32") (result f32) (return_call $const-f32))
+  (func (export "type-f64") (result f64) (return_call $const-f64))
+
+  (func (export "type-first-i32") (result i32) (return_call $id-i32 (i32.const 32)))
+  (func (export "type-first-i64") (result i64) (return_call $id-i64 (i64.const 64)))
+  (func (export "type-first-f32") (result f32) (return_call $id-f32 (f32.const 1.32)))
+  (func (export "type-first-f64") (result f64) (return_call $id-f64 (f64.const 1.64)))
+
+  (func (export "type-second-i32") (result i32)
+    (return_call $f32-i32 (f32.const 32.1) (i32.const 32))
+  )
+  (func (export "type-second-i64") (result i64)
+    (return_call $i32-i64 (i32.const 32) (i64.const 64))
+  )
+  (func (export "type-second-f32") (result f32)
+    (return_call $f64-f32 (f64.const 64) (f32.const 32))
+  )
+  (func (export "type-second-f64") (result f64)
+    (return_call $i64-f64 (i64.const 64) (f64.const 64.1))
+  )
+
+  ;; Recursion
+
+  (func $fac-acc (export "fac-acc") (param i64 i64) (result i64)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (local.get 1))
+      (else
+        (return_call $fac-acc
+          (i64.sub (local.get 0) (i64.const 1))
+          (i64.mul (local.get 0) (local.get 1))
+        )
+      )
+    )
+  )
+
+  (func $count (export "count") (param i64) (result i64)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (local.get 0))
+      (else (return_call $count (i64.sub (local.get 0) (i64.const 1))))
+    )
+  )
+
+  (func $even (export "even") (param i64) (result i32)
+    (if (result i32) (i64.eqz (local.get 0))
+      (then (i32.const 44))
+      (else (return_call $odd (i64.sub (local.get 0) (i64.const 1))))
+    )
+  )
+  (func $odd (export "odd") (param i64) (result i32)
+    (if (result i32) (i64.eqz (local.get 0))
+      (then (i32.const 99))
+      (else (return_call $even (i64.sub (local.get 0) (i64.const 1))))
+    )
+  )
+)
+
+(assert_return (invoke "type-i32") (i32.const 0x132))
+(assert_return (invoke "type-i64") (i64.const 0x164))
+(assert_return (invoke "type-f32") (f32.const 0xf32))
+(assert_return (invoke "type-f64") (f64.const 0xf64))
+
+(assert_return (invoke "type-first-i32") (i32.const 32))
+(assert_return (invoke "type-first-i64") (i64.const 64))
+(assert_return (invoke "type-first-f32") (f32.const 1.32))
+(assert_return (invoke "type-first-f64") (f64.const 1.64))
+
+(assert_return (invoke "type-second-i32") (i32.const 32))
+(assert_return (invoke "type-second-i64") (i64.const 64))
+(assert_return (invoke "type-second-f32") (f32.const 32))
+(assert_return (invoke "type-second-f64") (f64.const 64.1))
+
+(assert_return (invoke "fac-acc" (i64.const 0) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac-acc" (i64.const 1) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac-acc" (i64.const 5) (i64.const 1)) (i64.const 120))
+(assert_return
+  (invoke "fac-acc" (i64.const 25) (i64.const 1))
+  (i64.const 7034535277573963776)
+)
+
+(assert_return (invoke "count" (i64.const 0)) (i64.const 0))
+(assert_return (invoke "count" (i64.const 1000)) (i64.const 0))
+(assert_return (invoke "count" (i64.const 1_000_000)) (i64.const 0))
+
+(assert_return (invoke "even" (i64.const 0)) (i32.const 44))
+(assert_return (invoke "even" (i64.const 1)) (i32.const 99))
+(assert_return (invoke "even" (i64.const 100)) (i32.const 44))
+(assert_return (invoke "even" (i64.const 77)) (i32.const 99))
+(assert_return (invoke "even" (i64.const 1_000_000)) (i32.const 44))
+(assert_return (invoke "even" (i64.const 1_000_001)) (i32.const 99))
+(assert_return (invoke "odd" (i64.const 0)) (i32.const 99))
+(assert_return (invoke "odd" (i64.const 1)) (i32.const 44))
+(assert_return (invoke "odd" (i64.const 200)) (i32.const 99))
+(assert_return (invoke "odd" (i64.const 77)) (i32.const 44))
+(assert_return (invoke "odd" (i64.const 1_000_000)) (i32.const 99))
+(assert_return (invoke "odd" (i64.const 999_999)) (i32.const 44))
+
+
+;; Invalid typing
+
+(assert_invalid
+  (module
+    (func $type-void-vs-num (result i32) (return_call 1) (i32.const 0))
+    (func)
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-num-vs-num (result i32) (return_call 1) (i32.const 0))
+    (func (result i64) (i64.const 1))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $arity-0-vs-1 (return_call 1))
+    (func (param i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $arity-0-vs-2 (return_call 1))
+    (func (param f64 i32))
+  )
+  "type mismatch"
+)
+
+(module
+  (func $arity-1-vs-0 (i32.const 1) (return_call 1))
+  (func)
+)
+
+(module
+  (func $arity-2-vs-0 (f64.const 2) (i32.const 1) (return_call 1))
+  (func)
+)
+
+(assert_invalid
+  (module
+    (func $type-first-void-vs-num (return_call 1 (nop) (i32.const 1)))
+    (func (param i32 i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-second-void-vs-num (return_call 1 (i32.const 1) (nop)))
+    (func (param i32 i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-first-num-vs-num (return_call 1 (f64.const 1) (i32.const 1)))
+    (func (param i32 f64))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-second-num-vs-num (return_call 1 (i32.const 1) (f64.const 1)))
+    (func (param f64 i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (result i32 i32) unreachable)
+    (func (result i32)
+      return_call $f
+    )
+  )
+  "type mismatch"
+)
+
+;; Unbound function
+
+(assert_invalid
+  (module (func $unbound-func (return_call 1)))
+  "unknown function"
+)
+(assert_invalid
+  (module (func $large-func (return_call 1012321300)))
+  "unknown function"
+)
diff --git a/tests/wast/spec/proposals/gc/return_call_indirect.wast b/tests/wast/spec/proposals/gc/return_call_indirect.wast
new file mode 100644
index 0000000000..aa158be256
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/return_call_indirect.wast
@@ -0,0 +1,546 @@
+;; Test `return_call_indirect` operator
+
+(module
+  ;; Auxiliary definitions
+  (type $proc (func))
+  (type $out-i32 (func (result i32)))
+  (type $out-i64 (func (result i64)))
+  (type $out-f32 (func (result f32)))
+  (type $out-f64 (func (result f64)))
+  (type $over-i32 (func (param i32) (result i32)))
+  (type $over-i64 (func (param i64) (result i64)))
+  (type $over-f32 (func (param f32) (result f32)))
+  (type $over-f64 (func (param f64) (result f64)))
+  (type $f32-i32 (func (param f32 i32) (result i32)))
+  (type $i32-i64 (func (param i32 i64) (result i64)))
+  (type $f64-f32 (func (param f64 f32) (result f32)))
+  (type $i64-f64 (func (param i64 f64) (result f64)))
+  (type $over-i32-duplicate (func (param i32) (result i32)))
+  (type $over-i64-duplicate (func (param i64) (result i64)))
+  (type $over-f32-duplicate (func (param f32) (result f32)))
+  (type $over-f64-duplicate (func (param f64) (result f64)))
+
+  (func $const-i32 (type $out-i32) (i32.const 0x132))
+  (func $const-i64 (type $out-i64) (i64.const 0x164))
+  (func $const-f32 (type $out-f32) (f32.const 0xf32))
+  (func $const-f64 (type $out-f64) (f64.const 0xf64))
+
+  (func $id-i32 (type $over-i32) (local.get 0))
+  (func $id-i64 (type $over-i64) (local.get 0))
+  (func $id-f32 (type $over-f32) (local.get 0))
+  (func $id-f64 (type $over-f64) (local.get 0))
+
+  (func $i32-i64 (type $i32-i64) (local.get 1))
+  (func $i64-f64 (type $i64-f64) (local.get 1))
+  (func $f32-i32 (type $f32-i32) (local.get 1))
+  (func $f64-f32 (type $f64-f32) (local.get 1))
+
+  (func $over-i32-duplicate (type $over-i32-duplicate) (local.get 0))
+  (func $over-i64-duplicate (type $over-i64-duplicate) (local.get 0))
+  (func $over-f32-duplicate (type $over-f32-duplicate) (local.get 0))
+  (func $over-f64-duplicate (type $over-f64-duplicate) (local.get 0))
+
+  (table funcref
+    (elem
+      $const-i32 $const-i64 $const-f32 $const-f64
+      $id-i32 $id-i64 $id-f32 $id-f64
+      $f32-i32 $i32-i64 $f64-f32 $i64-f64
+      $fac $fac-acc $even $odd
+      $over-i32-duplicate $over-i64-duplicate
+      $over-f32-duplicate $over-f64-duplicate
+    )
+  )
+
+  ;; Syntax
+
+  (func
+    (return_call_indirect (i32.const 0))
+    (return_call_indirect (param i64) (i64.const 0) (i32.const 0))
+    (return_call_indirect (param i64) (param) (param f64 i32 i64)
+      (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0)
+    )
+    (return_call_indirect (result) (i32.const 0))
+  )
+
+  (func (result i32)
+    (return_call_indirect (result i32) (i32.const 0))
+    (return_call_indirect (result i32) (result) (i32.const 0))
+    (return_call_indirect (param i64) (result i32) (i64.const 0) (i32.const 0))
+    (return_call_indirect
+      (param) (param i64) (param) (param f64 i32 i64) (param) (param)
+      (result) (result i32) (result) (result)
+      (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0)
+    )
+  )
+
+  (func (result i64)
+    (return_call_indirect (type $over-i64) (param i64) (result i64)
+      (i64.const 0) (i32.const 0)
+    )
+  )
+
+  ;; Typing
+
+  (func (export "type-i32") (result i32)
+    (return_call_indirect (type $out-i32) (i32.const 0))
+  )
+  (func (export "type-i64") (result i64)
+    (return_call_indirect (type $out-i64) (i32.const 1))
+  )
+  (func (export "type-f32") (result f32)
+    (return_call_indirect (type $out-f32) (i32.const 2))
+  )
+  (func (export "type-f64") (result f64)
+    (return_call_indirect (type $out-f64) (i32.const 3))
+  )
+
+  (func (export "type-index") (result i64)
+    (return_call_indirect (type $over-i64) (i64.const 100) (i32.const 5))
+  )
+
+  (func (export "type-first-i32") (result i32)
+    (return_call_indirect (type $over-i32) (i32.const 32) (i32.const 4))
+  )
+  (func (export "type-first-i64") (result i64)
+    (return_call_indirect (type $over-i64) (i64.const 64) (i32.const 5))
+  )
+  (func (export "type-first-f32") (result f32)
+    (return_call_indirect (type $over-f32) (f32.const 1.32) (i32.const 6))
+  )
+  (func (export "type-first-f64") (result f64)
+    (return_call_indirect (type $over-f64) (f64.const 1.64) (i32.const 7))
+  )
+
+  (func (export "type-second-i32") (result i32)
+    (return_call_indirect (type $f32-i32)
+      (f32.const 32.1) (i32.const 32) (i32.const 8)
+    )
+  )
+  (func (export "type-second-i64") (result i64)
+    (return_call_indirect (type $i32-i64)
+      (i32.const 32) (i64.const 64) (i32.const 9)
+    )
+  )
+  (func (export "type-second-f32") (result f32)
+    (return_call_indirect (type $f64-f32)
+      (f64.const 64) (f32.const 32) (i32.const 10)
+    )
+  )
+  (func (export "type-second-f64") (result f64)
+    (return_call_indirect (type $i64-f64)
+      (i64.const 64) (f64.const 64.1) (i32.const 11)
+    )
+  )
+
+  ;; Dispatch
+
+  (func (export "dispatch") (param i32 i64) (result i64)
+    (return_call_indirect (type $over-i64) (local.get 1) (local.get 0))
+  )
+
+  (func (export "dispatch-structural") (param i32) (result i64)
+    (return_call_indirect (type $over-i64-duplicate)
+      (i64.const 9) (local.get 0)
+    )
+  )
+
+  ;; Multiple tables
+
+  (table $tab2 funcref (elem $tab-f1))
+  (table $tab3 funcref (elem $tab-f2))
+
+  (func $tab-f1 (result i32) (i32.const 0x133))
+  (func $tab-f2 (result i32) (i32.const 0x134))
+
+  (func (export "call-tab") (param $i i32) (result i32)
+    (if (i32.eq (local.get $i) (i32.const 0))
+      (then (return_call_indirect (type $out-i32) (i32.const 0)))
+    )
+    (if (i32.eq (local.get $i) (i32.const 1))
+      (then (return_call_indirect 1 (type $out-i32) (i32.const 0)))
+    )
+    (if (i32.eq (local.get $i) (i32.const 2))
+      (then (return_call_indirect $tab3 (type $out-i32) (i32.const 0)))
+    )
+    (i32.const 0)
+  )
+
+  ;; Recursion
+
+  (func $fac (export "fac") (type $over-i64)
+    (return_call_indirect (param i64 i64) (result i64)
+      (local.get 0) (i64.const 1) (i32.const 13)
+    )
+  )
+
+  (func $fac-acc (param i64 i64) (result i64)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (local.get 1))
+      (else
+        (return_call_indirect (param i64 i64) (result i64)
+          (i64.sub (local.get 0) (i64.const 1))
+          (i64.mul (local.get 0) (local.get 1))
+          (i32.const 13)
+        )
+      )
+    )
+  )
+
+  (func $even (export "even") (param i32) (result i32)
+    (if (result i32) (i32.eqz (local.get 0))
+      (then (i32.const 44))
+      (else
+        (return_call_indirect (type $over-i32)
+          (i32.sub (local.get 0) (i32.const 1))
+          (i32.const 15)
+        )
+      )
+    )
+  )
+  (func $odd (export "odd") (param i32) (result i32)
+    (if (result i32) (i32.eqz (local.get 0))
+      (then (i32.const 99))
+      (else
+        (return_call_indirect (type $over-i32)
+          (i32.sub (local.get 0) (i32.const 1))
+          (i32.const 14)
+        )
+      )
+    )
+  )
+)
+
+(assert_return (invoke "type-i32") (i32.const 0x132))
+(assert_return (invoke "type-i64") (i64.const 0x164))
+(assert_return (invoke "type-f32") (f32.const 0xf32))
+(assert_return (invoke "type-f64") (f64.const 0xf64))
+
+(assert_return (invoke "type-index") (i64.const 100))
+
+(assert_return (invoke "type-first-i32") (i32.const 32))
+(assert_return (invoke "type-first-i64") (i64.const 64))
+(assert_return (invoke "type-first-f32") (f32.const 1.32))
+(assert_return (invoke "type-first-f64") (f64.const 1.64))
+
+(assert_return (invoke "type-second-i32") (i32.const 32))
+(assert_return (invoke "type-second-i64") (i64.const 64))
+(assert_return (invoke "type-second-f32") (f32.const 32))
+(assert_return (invoke "type-second-f64") (f64.const 64.1))
+
+(assert_return (invoke "dispatch" (i32.const 5) (i64.const 2)) (i64.const 2))
+(assert_return (invoke "dispatch" (i32.const 5) (i64.const 5)) (i64.const 5))
+(assert_return (invoke "dispatch" (i32.const 12) (i64.const 5)) (i64.const 120))
+(assert_return (invoke "dispatch" (i32.const 17) (i64.const 2)) (i64.const 2))
+(assert_trap (invoke "dispatch" (i32.const 0) (i64.const 2)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch" (i32.const 15) (i64.const 2)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch" (i32.const 20) (i64.const 2)) "undefined element")
+(assert_trap (invoke "dispatch" (i32.const -1) (i64.const 2)) "undefined element")
+(assert_trap (invoke "dispatch" (i32.const 1213432423) (i64.const 2)) "undefined element")
+
+(assert_return (invoke "dispatch-structural" (i32.const 5)) (i64.const 9))
+(assert_return (invoke "dispatch-structural" (i32.const 5)) (i64.const 9))
+(assert_return (invoke "dispatch-structural" (i32.const 12)) (i64.const 362880))
+(assert_return (invoke "dispatch-structural" (i32.const 17)) (i64.const 9))
+(assert_trap (invoke "dispatch-structural" (i32.const 11)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch-structural" (i32.const 16)) "indirect call type mismatch")
+
+(assert_return (invoke "call-tab" (i32.const 0)) (i32.const 0x132))
+(assert_return (invoke "call-tab" (i32.const 1)) (i32.const 0x133))
+(assert_return (invoke "call-tab" (i32.const 2)) (i32.const 0x134))
+
+(assert_return (invoke "fac" (i64.const 0)) (i64.const 1))
+(assert_return (invoke "fac" (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac" (i64.const 5)) (i64.const 120))
+(assert_return (invoke "fac" (i64.const 25)) (i64.const 7034535277573963776))
+
+(assert_return (invoke "even" (i32.const 0)) (i32.const 44))
+(assert_return (invoke "even" (i32.const 1)) (i32.const 99))
+(assert_return (invoke "even" (i32.const 100)) (i32.const 44))
+(assert_return (invoke "even" (i32.const 77)) (i32.const 99))
+(assert_return (invoke "even" (i32.const 100_000)) (i32.const 44))
+(assert_return (invoke "even" (i32.const 111_111)) (i32.const 99))
+(assert_return (invoke "odd" (i32.const 0)) (i32.const 99))
+(assert_return (invoke "odd" (i32.const 1)) (i32.const 44))
+(assert_return (invoke "odd" (i32.const 200)) (i32.const 99))
+(assert_return (invoke "odd" (i32.const 77)) (i32.const 44))
+(assert_return (invoke "odd" (i32.const 200_002)) (i32.const 99))
+(assert_return (invoke "odd" (i32.const 300_003)) (i32.const 44))
+
+
+;; Invalid syntax
+
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (return_call_indirect (type $sig) (result i32) (param i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (return_call_indirect (param i32) (type $sig) (result i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (return_call_indirect (param i32) (result i32) (type $sig)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (return_call_indirect (result i32) (type $sig) (param i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (return_call_indirect (result i32) (param i32) (type $sig)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (return_call_indirect (result i32) (param i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote
+    "(table 0 funcref)"
+    "(func (return_call_indirect (param $x i32) (i32.const 0) (i32.const 0)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (return_call_indirect (type $sig) (result i32) (i32.const 0))"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (return_call_indirect (type $sig) (result i32) (i32.const 0))"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func"
+    "  (return_call_indirect (type $sig) (param i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32 i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (return_call_indirect (type $sig) (param i32) (result i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "inline function type"
+)
+
+;; Invalid typing
+
+(assert_invalid
+  (module
+    (type (func))
+    (func $no-table (return_call_indirect (type 0) (i32.const 0)))
+  )
+  "unknown table"
+)
+
+(assert_invalid
+  (module
+    (type (func))
+    (table 0 funcref)
+    (func $type-void-vs-num (i32.eqz (return_call_indirect (type 0) (i32.const 0))))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (result i64)))
+    (table 0 funcref)
+    (func $type-num-vs-num (i32.eqz (return_call_indirect (type 0) (i32.const 0))))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type (func (param i32)))
+    (table 0 funcref)
+    (func $arity-0-vs-1 (return_call_indirect (type 0) (i32.const 0)))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param f64 i32)))
+    (table 0 funcref)
+    (func $arity-0-vs-2 (return_call_indirect (type 0) (i32.const 0)))
+  )
+  "type mismatch"
+)
+
+(module
+  (type (func))
+  (table 0 funcref)
+  (func $arity-1-vs-0 (return_call_indirect (type 0) (i32.const 1) (i32.const 0)))
+)
+
+(module
+  (type (func))
+  (table 0 funcref)
+  (func $arity-2-vs-0
+    (return_call_indirect (type 0) (f64.const 2) (i32.const 1) (i32.const 0))
+  )
+)
+
+(assert_invalid
+  (module
+    (type (func (param i32)))
+    (table 0 funcref)
+    (func $type-func-void-vs-i32 (return_call_indirect (type 0) (i32.const 1) (nop)))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param i32)))
+    (table 0 funcref)
+    (func $type-func-num-vs-i32 (return_call_indirect (type 0) (i32.const 0) (i64.const 1)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type (func (param i32 i32)))
+    (table 0 funcref)
+    (func $type-first-void-vs-num
+      (return_call_indirect (type 0) (nop) (i32.const 1) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param i32 i32)))
+    (table 0 funcref)
+    (func $type-second-void-vs-num
+      (return_call_indirect (type 0) (i32.const 1) (nop) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param i32 f64)))
+    (table 0 funcref)
+    (func $type-first-num-vs-num
+      (return_call_indirect (type 0) (f64.const 1) (i32.const 1) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param f64 i32)))
+    (table 0 funcref)
+    (func $type-second-num-vs-num
+      (return_call_indirect (type 0) (i32.const 1) (f64.const 1) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type $ty (func (result i32 i32)))
+    (import "env" "table" (table $table 0 funcref))
+    (func (param i32) (result i32)
+      local.get 0
+      return_call_indirect $table (type $ty)
+    )
+  )
+  "type mismatch"
+)
+
+;; Unbound type
+
+(assert_invalid
+  (module
+    (table 0 funcref)
+    (func $unbound-type (return_call_indirect (type 1) (i32.const 0)))
+  )
+  "unknown type"
+)
+(assert_invalid
+  (module
+    (table 0 funcref)
+    (func $large-type (return_call_indirect (type 1012321300) (i32.const 0)))
+  )
+  "unknown type"
+)
+
+
+;; Unbound function in table
+
+(assert_invalid
+  (module (table funcref (elem 0 0)))
+  "unknown function 0"
+)
diff --git a/tests/wast/spec/proposals/gc/return_call_ref.wast b/tests/wast/spec/proposals/gc/return_call_ref.wast
index 8e7aac8211..5f5a7cba72 100644
--- a/tests/wast/spec/proposals/gc/return_call_ref.wast
+++ b/tests/wast/spec/proposals/gc/return_call_ref.wast
@@ -59,48 +59,48 @@
   ;; Typing
 
   (func (export "type-i32") (result i32)
-    (return_call_ref (global.get $const-i32))
+    (return_call_ref $-i32 (global.get $const-i32))
   )
   (func (export "type-i64") (result i64)
-    (return_call_ref (global.get $const-i64))
+    (return_call_ref $-i64 (global.get $const-i64))
   )
   (func (export "type-f32") (result f32)
-    (return_call_ref (global.get $const-f32))
+    (return_call_ref $-f32 (global.get $const-f32))
   )
   (func (export "type-f64") (result f64)
-    (return_call_ref (global.get $const-f64))
+    (return_call_ref $-f64 (global.get $const-f64))
   )
 
   (func (export "type-first-i32") (result i32)
-    (return_call_ref (i32.const 32) (global.get $id-i32))
+    (return_call_ref $i32-i32 (i32.const 32) (global.get $id-i32))
   )
   (func (export "type-first-i64") (result i64)
-    (return_call_ref (i64.const 64) (global.get $id-i64))
+    (return_call_ref $i64-i64 (i64.const 64) (global.get $id-i64))
   )
   (func (export "type-first-f32") (result f32)
-    (return_call_ref (f32.const 1.32) (global.get $id-f32))
+    (return_call_ref $f32-f32 (f32.const 1.32) (global.get $id-f32))
   )
   (func (export "type-first-f64") (result f64)
-    (return_call_ref (f64.const 1.64) (global.get $id-f64))
+    (return_call_ref $f64-f64 (f64.const 1.64) (global.get $id-f64))
   )
 
   (func (export "type-second-i32") (result i32)
-    (return_call_ref (f32.const 32.1) (i32.const 32) (global.get $f32-i32))
+    (return_call_ref $f32-i32 (f32.const 32.1) (i32.const 32) (global.get $f32-i32))
   )
   (func (export "type-second-i64") (result i64)
-    (return_call_ref (i32.const 32) (i64.const 64) (global.get $i32-i64))
+    (return_call_ref $i32-i64 (i32.const 32) (i64.const 64) (global.get $i32-i64))
   )
   (func (export "type-second-f32") (result f32)
-    (return_call_ref (f64.const 64) (f32.const 32) (global.get $f64-f32))
+    (return_call_ref $f64-f32 (f64.const 64) (f32.const 32) (global.get $f64-f32))
   )
   (func (export "type-second-f64") (result f64)
-    (return_call_ref (i64.const 64) (f64.const 64.1) (global.get $i64-f64))
+    (return_call_ref $i64-f64 (i64.const 64) (f64.const 64.1) (global.get $i64-f64))
   )
 
   ;; Null
 
   (func (export "null")
-    (return_call_ref (ref.null $proc))
+    (return_call_ref $proc (ref.null $proc))
   )
 
   ;; Recursion
@@ -112,7 +112,7 @@
     (if (result i64) (i64.eqz (local.get 0))
       (then (local.get 1))
       (else
-        (return_call_ref
+        (return_call_ref $i64i64-i64
           (i64.sub (local.get 0) (i64.const 1))
           (i64.mul (local.get 0) (local.get 1))
           (global.get $fac-acc)
@@ -128,7 +128,7 @@
     (if (result i64) (i64.eqz (local.get 0))
       (then (local.get 0))
       (else
-        (return_call_ref
+        (return_call_ref $i64-i64
           (i64.sub (local.get 0) (i64.const 1))
           (global.get $count)
         )
@@ -144,7 +144,7 @@
     (if (result i64) (i64.eqz (local.get 0))
       (then (i64.const 44))
       (else
-        (return_call_ref
+        (return_call_ref $i64-i64
           (i64.sub (local.get 0) (i64.const 1))
           (global.get $odd)
         )
@@ -156,7 +156,7 @@
     (if (result i64) (i64.eqz (local.get 0))
       (then (i64.const 99))
       (else
-        (return_call_ref
+        (return_call_ref $i64-i64
           (i64.sub (local.get 0) (i64.const 1))
           (global.get $even)
         )
@@ -180,7 +180,7 @@
 (assert_return (invoke "type-second-f32") (f32.const 32))
 (assert_return (invoke "type-second-f64") (f64.const 64.1))
 
-(assert_trap (invoke "null") "null function")
+(assert_trap (invoke "null") "null function reference")
 
 (assert_return (invoke "fac-acc" (i64.const 0) (i64.const 1)) (i64.const 1))
 (assert_return (invoke "fac-acc" (i64.const 1) (i64.const 1)) (i64.const 1))
@@ -212,24 +212,29 @@
 
 (module
   (type $t (func))
+  (type $t1 (func (result (ref $t))))
+  (type $t2 (func (result (ref null $t))))
+  (type $t3 (func (result (ref func))))
+  (type $t4 (func (result (ref null func))))
   (elem declare func $f11 $f22 $f33 $f44)
-  (func $f11 (result (ref $t)) (return_call_ref (ref.func $f11)))
-  (func $f21 (result (ref null $t)) (return_call_ref (ref.func $f11)))
-  (func $f22 (result (ref null $t)) (return_call_ref (ref.func $f22)))
-  (func $f31 (result (ref func)) (return_call_ref (ref.func $f11)))
-  (func $f33 (result (ref func)) (return_call_ref (ref.func $f33)))
-  (func $f41 (result (ref null func)) (return_call_ref (ref.func $f11)))
-  (func $f42 (result (ref null func)) (return_call_ref (ref.func $f22)))
-  (func $f43 (result (ref null func)) (return_call_ref (ref.func $f33)))
-  (func $f44 (result (ref null func)) (return_call_ref (ref.func $f44)))
+  (func $f11 (result (ref $t)) (return_call_ref $t1 (ref.func $f11)))
+  (func $f21 (result (ref null $t)) (return_call_ref $t1 (ref.func $f11)))
+  (func $f22 (result (ref null $t)) (return_call_ref $t2 (ref.func $f22)))
+  (func $f31 (result (ref func)) (return_call_ref $t1 (ref.func $f11)))
+  (func $f33 (result (ref func)) (return_call_ref $t3 (ref.func $f33)))
+  (func $f41 (result (ref null func)) (return_call_ref $t1 (ref.func $f11)))
+  (func $f42 (result (ref null func)) (return_call_ref $t2 (ref.func $f22)))
+  (func $f43 (result (ref null func)) (return_call_ref $t3 (ref.func $f33)))
+  (func $f44 (result (ref null func)) (return_call_ref $t4 (ref.func $f44)))
 )
 
 (assert_invalid
   (module
     (type $t (func))
+    (type $t2 (func (result (ref null $t))))
     (elem declare func $f22)
-    (func $f12 (result (ref $t)) (return_call_ref (ref.func $f22)))
-    (func $f22 (result (ref null $t)) (return_call_ref (ref.func $f22)))
+    (func $f12 (result (ref $t)) (return_call_ref $t2 (ref.func $f22)))
+    (func $f22 (result (ref null $t)) (return_call_ref $t2 (ref.func $f22)))
   )
   "type mismatch"
 )
@@ -237,9 +242,10 @@
 (assert_invalid
   (module
     (type $t (func))
+    (type $t3 (func (result (ref func))))
     (elem declare func $f33)
-    (func $f13 (result (ref $t)) (return_call_ref (ref.func $f33)))
-    (func $f33 (result (ref func)) (return_call_ref (ref.func $f33)))
+    (func $f13 (result (ref $t)) (return_call_ref $t3 (ref.func $f33)))
+    (func $f33 (result (ref func)) (return_call_ref $t3 (ref.func $f33)))
   )
   "type mismatch"
 )
@@ -247,9 +253,10 @@
 (assert_invalid
   (module
     (type $t (func))
+    (type $t4 (func (result (ref null func))))
     (elem declare func $f44)
-    (func $f14 (result (ref $t)) (return_call_ref (ref.func $f44)))
-    (func $f44 (result (ref null func)) (return_call_ref (ref.func $f44)))
+    (func $f14 (result (ref $t)) (return_call_ref $t4 (ref.func $f44)))
+    (func $f44 (result (ref null func)) (return_call_ref $t4 (ref.func $f44)))
   )
   "type mismatch"
 )
@@ -257,9 +264,10 @@
 (assert_invalid
   (module
     (type $t (func))
+    (type $t3 (func (result (ref func))))
     (elem declare func $f33)
-    (func $f23 (result (ref null $t)) (return_call_ref (ref.func $f33)))
-    (func $f33 (result (ref func)) (return_call_ref (ref.func $f33)))
+    (func $f23 (result (ref null $t)) (return_call_ref $t3 (ref.func $f33)))
+    (func $f33 (result (ref func)) (return_call_ref $t3 (ref.func $f33)))
   )
   "type mismatch"
 )
@@ -267,18 +275,20 @@
 (assert_invalid
   (module
     (type $t (func))
+    (type $t4 (func (result (ref null func))))
     (elem declare func $f44)
-    (func $f24 (result (ref null $t)) (return_call_ref (ref.func $f44)))
-    (func $f44 (result (ref null func)) (return_call_ref (ref.func $f44)))
+    (func $f24 (result (ref null $t)) (return_call_ref $t4 (ref.func $f44)))
+    (func $f44 (result (ref null func)) (return_call_ref $t4 (ref.func $f44)))
   )
   "type mismatch"
 )
 
 (assert_invalid
   (module
+    (type $t4 (func (result (ref null func))))
     (elem declare func $f44)
-    (func $f34 (result (ref func)) (return_call_ref (ref.func $f44)))
-    (func $f44 (result (ref null func)) (return_call_ref (ref.func $f44)))
+    (func $f34 (result (ref func)) (return_call_ref $t4 (ref.func $f44)))
+    (func $f44 (result (ref null func)) (return_call_ref $t4 (ref.func $f44)))
   )
   "type mismatch"
 )
@@ -287,34 +297,37 @@
 ;; Unreachable typing.
 
 (module
+  (type $t (func (result i32)))
   (func (export "unreachable") (result i32)
     (unreachable)
-    (return_call_ref)
+    (return_call_ref $t)
   )
 )
 (assert_trap (invoke "unreachable") "unreachable")
 
 (module
   (elem declare func $f)
+  (type $t (func (param i32) (result i32)))
   (func $f (param i32) (result i32) (local.get 0))
 
   (func (export "unreachable") (result i32)
     (unreachable)
     (ref.func $f)
-    (return_call_ref)
+    (return_call_ref $t)
   )
 )
 (assert_trap (invoke "unreachable") "unreachable")
 
 (module
   (elem declare func $f)
+  (type $t (func (param i32) (result i32)))
   (func $f (param i32) (result i32) (local.get 0))
 
   (func (export "unreachable") (result i32)
     (unreachable)
     (i32.const 0)
     (ref.func $f)
-    (return_call_ref)
+    (return_call_ref $t)
     (i32.const 0)
   )
 )
@@ -323,13 +336,14 @@
 (assert_invalid
   (module
     (elem declare func $f)
+    (type $t (func (param i32) (result i32)))
     (func $f (param i32) (result i32) (local.get 0))
 
     (func (export "unreachable") (result i32)
       (unreachable)
       (i64.const 0)
       (ref.func $f)
-      (return_call_ref)
+      (return_call_ref $t)
     )
   )
   "type mismatch"
@@ -338,12 +352,13 @@
 (assert_invalid
   (module
     (elem declare func $f)
+    (type $t (func (param i32) (result i32)))
     (func $f (param i32) (result i32) (local.get 0))
 
     (func (export "unreachable") (result i32)
       (unreachable)
       (ref.func $f)
-      (return_call_ref)
+      (return_call_ref $t)
       (i64.const 0)
     )
   )
@@ -352,8 +367,30 @@
 
 (assert_invalid
   (module
+    (type $t (func))
     (func $f (param $r externref)
-      (return_call_ref (local.get $r))
+      (return_call_ref $t (local.get $r))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $t (func))
+    (func $f (param $r funcref)
+      (return_call_ref $t (local.get $r))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $ty (func (result i32 i32)))
+    (func (param (ref $ty)) (result i32)
+      local.get 0
+      return_call_ref $ty
     )
   )
   "type mismatch"
diff --git a/tests/wast/spec/proposals/gc/select.wast b/tests/wast/spec/proposals/gc/select.wast
index e8130ba9b8..61e4dc22db 100644
--- a/tests/wast/spec/proposals/gc/select.wast
+++ b/tests/wast/spec/proposals/gc/select.wast
@@ -71,6 +71,7 @@
     (unreachable) (i64.add (select (i64.const 0) (i32.const 0)))
   )
 
+
   ;; As the argument of control constructs and instructions
 
   (func (export "as-select-first") (param i32) (result i32)
@@ -213,19 +214,6 @@
       (i32.wrap_i64 (select (i64.const 1) (i64.const 0) (local.get 0)))
     )
   )
-
-  (func (export "unreachable-num")
-    (unreachable)
-    (select)
-    (i32.eqz)
-    (drop)
-  )
-  (func (export "unreachable-ref")
-    (unreachable)
-    (select)
-    (ref.is_null)
-    (drop)
-  )
 )
 
 (assert_return (invoke "select-i32" (i32.const 1) (i32.const 2) (i32.const 1)) (i32.const 1))
@@ -328,7 +316,7 @@
 (assert_return (invoke "as-br_table-last" (i32.const 1)) (i32.const 2))
 
 (assert_return (invoke "as-call_indirect-first" (i32.const 0)) (i32.const 3))
-;;(assert_return (invoke "as-call_indirect-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-call_indirect-first" (i32.const 1)) (i32.const 2))
 (assert_return (invoke "as-call_indirect-mid" (i32.const 0)) (i32.const 1))
 (assert_return (invoke "as-call_indirect-mid" (i32.const 1)) (i32.const 1))
 (assert_trap (invoke "as-call_indirect-last" (i32.const 0)) "undefined element")
@@ -412,6 +400,9 @@
   ))
   "type mismatch"
 )
+(module (func $type-unreachable-ref-implicit
+  (drop (ref.is_null (select (unreachable) (i32.const 1))))
+))
 
 (assert_invalid
   (module (func $type-num-vs-num
@@ -582,44 +573,20 @@
   "type mismatch"
 )
 
-;; Validation after unreachable
-
-;; The first two operands should have the same type as each other
-(assert_invalid
-  (module (func (unreachable) (select (i32.const 1) (i64.const 1) (i32.const 1)) (drop)))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (func (unreachable) (select (i64.const 1) (i32.const 1) (i32.const 1)) (drop)))
-  "type mismatch"
-)
-
-;; Third operand must be i32
-(assert_invalid
-  (module (func (unreachable) (select (i32.const 1) (i32.const 1) (i64.const 1)) (drop)))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (func (unreachable) (select (i32.const 1) (i64.const 1)) (drop)))
-  "type mismatch"
-)
 
-(assert_invalid
-  (module (func (unreachable) (select (i64.const 1)) (drop)))
-  "type mismatch"
-)
+;; Flat syntax
 
-;; Result of select has type of first two operands (type of second operand when first one is omitted)
-(assert_invalid
-  (module (func (result i32) (unreachable) (select (i64.const 1) (i32.const 1))))
-  "type mismatch"
-)
-
-;; select always has non-empty result
-(assert_invalid
-  (module (func (unreachable) (select)))
-  "type mismatch"
+(module
+  (table 1 funcref)
+  (func (result i32) unreachable select)
+  (func (result i32) unreachable select nop)
+  (func (result i32) unreachable select (select))
+  (func (result i32) unreachable select select)
+  (func (result i32) unreachable select select select)
+  (func (result i32) unreachable select (result i32))
+  (func (result i32) unreachable select (result i32) (result))
+  (func (result i32) unreachable select (result i32) (result) select)
+  (func (result i32) unreachable select (result) (result i32) select (result i32))
+  (func (result i32) unreachable select call_indirect)
+  (func (result i32) unreachable select call_indirect select)
 )
-
diff --git a/tests/wast/spec/proposals/gc/simd_load.wast b/tests/wast/spec/proposals/gc/simd_load.wast
new file mode 100644
index 0000000000..4b2edc160b
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/simd_load.wast
@@ -0,0 +1,188 @@
+;; v128.load operater with normal argument (e.g. (i8x16, i16x8 i32x4))
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "v128.load") (result v128)
+    (v128.load (i32.const 0))
+  )
+)
+
+(assert_return (invoke "v128.load") (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f))
+(assert_return (invoke "v128.load") (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0b0a 0x0d0c 0x0f0e))
+(assert_return (invoke "v128.load") (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c))
+
+
+;; v128.load operater as the argument of other SIMD instructions
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "as-i8x16_extract_lane_s-value/0") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-i8x16_extract_lane_s-value/0") (i32.const 0x00))
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "as-i8x16.eq-operand") (result v128)
+    (i8x16.eq (v128.load offset=0 (i32.const 0)) (v128.load offset=16 (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-i8x16.eq-operand") (v128.const i32x4 0xffffffff 0x00000000 0x00000000 0x00000000))
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "as-v128.not-operand") (result v128)
+    (v128.not (v128.load (i32.const 0)))
+  )
+  (func (export "as-i8x16.all_true-operand") (result i32)
+    (i8x16.all_true (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-v128.not-operand") (v128.const i32x4 0xfcfdfeff 0xf8f9fafb 0xf4f5f6f7 0xf0f1f2f3))
+(assert_return (invoke "as-i8x16.all_true-operand") (i32.const 0))
+
+(module (memory 1)
+  (data (offset (i32.const 0))  "\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA")
+  (data (offset (i32.const 16)) "\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB")
+  (data (offset (i32.const 32)) "\F0\F0\F0\F0\FF\FF\FF\FF\00\00\00\00\FF\00\FF\00")
+  (func (export "as-v128.bitselect-operand") (result v128)
+    (v128.bitselect (v128.load (i32.const 0)) (v128.load (i32.const 16)) (v128.load (i32.const 32)))
+  )
+)
+(assert_return (invoke "as-v128.bitselect-operand") (v128.const i32x4 0xabababab 0xaaaaaaaa 0xbbbbbbbb 0xbbaabbaa))
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA")
+  (func (export "as-i8x16.shl-operand") (result v128)
+    (i8x16.shl (v128.load (i32.const 0)) (i32.const 1))
+  )
+)
+(assert_return (invoke "as-i8x16.shl-operand") (v128.const i32x4 0x54545454 0x54545454 0x54545454 0x54545454)) ;; 1010 1000 << 1010 1010
+
+(module (memory 1)
+  (data (offset (i32.const 0))  "\02\00\00\00\02\00\00\00\02\00\00\00\02\00\00\00")
+  (data (offset (i32.const 16)) "\03\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00")
+  (func (export "as-add/sub-operand") (result v128)
+    ;; 2 2 2 2 + 3 3 3 3 = 5 5 5 5
+    ;; 5 5 5 5 - 3 3 3 3 = 2 2 2 2
+    (i8x16.sub
+      (i8x16.add (v128.load (i32.const 0)) (v128.load (i32.const 16)))
+      (v128.load (i32.const 16))
+    )
+  )
+)
+(assert_return (invoke "as-add/sub-operand") (v128.const i32x4 2 2 2 2))
+
+(module (memory 1)
+  (data (offset (i32.const 0))  "\00\00\00\43\00\00\80\3f\66\66\e6\3f\00\00\80\bf")  ;; 128 1.0 1.8 -1
+  (data (offset (i32.const 16)) "\00\00\00\40\00\00\00\40\00\00\00\40\00\00\00\40")  ;; 2.0 2.0 2.0 2.0
+  (func (export "as-f32x4.mul-operand") (result v128)
+    (f32x4.mul (v128.load (i32.const 0)) (v128.load (i32.const 16)))
+  )
+)
+(assert_return (invoke "as-f32x4.mul-operand") (v128.const f32x4 256 2 3.6 -2))
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff")  ;; 1111 ...
+  (func (export "as-f32x4.abs-operand") (result v128)
+    (f32x4.abs (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-f32x4.abs-operand") (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)) ;; 1111 -> 0111
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA")
+  (data (offset (i32.const 16)) "\02\00\00\00\02\00\00\00\02\00\00\00\02\00\00\00")
+  (func (export "as-f32x4.min-operand") (result v128)
+    (f32x4.min (v128.load (i32.const 0)) (v128.load offset=16 (i32.const 1)))
+  )
+)
+(assert_return (invoke "as-f32x4.min-operand") (v128.const i32x4 0xaaaaaaaa 0xaaaaaaaa 0xaaaaaaaa 0xaaaaaaaa)) ;; signed 1010 < 0010
+
+(module (memory 1)
+  (data (offset (i32.const 0))  "\00\00\00\43\00\00\80\3f\66\66\e6\3f\00\00\80\bf")  ;; 128 1.0 1.8 -1
+  (func (export "as-i32x4.trunc_sat_f32x4_s-operand") (result v128)
+    (i32x4.trunc_sat_f32x4_s (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-i32x4.trunc_sat_f32x4_s-operand") (v128.const i32x4 128 1 1 -1)) ;; 128 1.0 1.8 -1 -> 128 1 1 -1
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\02\00\00\00\02\00\00\00\02\00\00\00\02\00\00\00")
+  (func (export "as-f32x4.convert_i32x4_u-operand") (result v128)
+    (f32x4.convert_i32x4_u (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-f32x4.convert_i32x4_u-operand") (v128.const f32x4 2 2 2 2))
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\64\65\66\67\68\69\6a\6b\6c\6d\6e\6f\70\71\72\73")  ;; 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
+  (data (offset (i32.const 16)) "\0f\0e\0d\0c\0b\0a\09\08\07\06\05\04\03\02\01\00")  ;;  15  14  13  12  11  10  09  08  07  06  05  04  03  02  01  00
+  (func (export "as-i8x16.swizzle-operand") (result v128)
+    (i8x16.swizzle (v128.load (i32.const 0)) (v128.load offset=15 (i32.const 1)))
+  )
+)
+(assert_return(invoke "as-i8x16.swizzle-operand") (v128.const i8x16 115 114 113 112 111 110 109 108 107 106 105 104 103 102 101 100))
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load (i32.const 0))))
+  )
+)
+(assert_return (invoke "as-br-value") (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c))
+
+
+;; Unknown operator(e.g. v128.load8, v128.load16, v128.load32)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (local v128) (drop (v128.load8 (i32.const 0))))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (local v128) (drop (v128.load16 (i32.const 0))))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (local v128) (drop (v128.load32 (i32.const 0))))"
+  )
+  "unknown operator"
+)
+
+
+;; Type mismatched (e.g. v128.load(f32.const 0), type address empty)
+
+(assert_invalid
+  (module (memory 1) (func (local v128) (drop (v128.load (f32.const 0)))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (local v128) (block (br_if 0 (v128.load (i32.const 0))))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (local v128) (v128.load (i32.const 0))))
+  "type mismatch"
+)
+
+
+;; Type address empty
+
+(assert_invalid
+  (module (memory 1) (func (drop (v128.load (local.get 2)))))
+  "unknown local 2"
+)
+(assert_invalid
+  (module (memory 1) (func (drop (v128.load))))
+  "type mismatch"
+)
\ No newline at end of file
diff --git a/tests/wast/spec/proposals/gc/simd_store.wast b/tests/wast/spec/proposals/gc/simd_store.wast
new file mode 100644
index 0000000000..50349c41bd
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/simd_store.wast
@@ -0,0 +1,166 @@
+;; v128.store operater with normal argument (e.g. (i8x16, i16x8, i32x4, f32x4))
+
+(module
+  (memory 1)
+  (func (export "v128.store_i8x16") (result v128)
+    (v128.store (i32.const 0) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i16x8") (result v128)
+    (v128.store (i32.const 0) (v128.const i16x8 0 1 2 3 4 5 6 7))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i16x8_2") (result v128)
+    (v128.store (i32.const 0) (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i16x8_3") (result v128)
+    (v128.store (i32.const 0) (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i32x4") (result v128)
+    (v128.store (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i32x4_2") (result v128)
+    (v128.store (i32.const 0) (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i32x4_3") (result v128)
+    (v128.store (i32.const 0) (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+    (v128.load (i32.const 0))
+  )
+
+  (func (export "v128.store_f32x4") (result v128)
+    (v128.store (i32.const 0) (v128.const f32x4 0 1 2 3))
+    (v128.load (i32.const 0))
+  )
+)
+
+(assert_return (invoke "v128.store_i8x16") (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "v128.store_i16x8") (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "v128.store_i16x8_2") (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+(assert_return (invoke "v128.store_i16x8_3") (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+(assert_return (invoke "v128.store_i32x4") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "v128.store_i32x4_2") (v128.const i32x4 123456789 123456789 123456789 123456789))
+(assert_return (invoke "v128.store_i32x4_3") (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+(assert_return (invoke "v128.store_f32x4") (v128.const f32x4 0 1 2 3))
+
+
+;; v128.store operator as the argument of control constructs and instructions
+
+(module
+  (memory 1)
+  (func (export "as-block-value")
+    (block (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+  )
+  (func (export "as-loop-value")
+    (loop (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+  )
+  (func (export "as-br-value")
+    (block (br 0 (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  )
+  (func (export "as-br_if-value")
+    (block
+      (br_if 0 (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)) (i32.const 1))
+    )
+  )
+  (func (export "as-br_if-value-cond")
+    (block
+      (br_if 0 (i32.const 6) (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+    )
+  )
+  (func (export "as-br_table-value")
+    (block
+      (br_table 0 (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)) (i32.const 1))
+    )
+  )
+  (func (export "as-return-value")
+    (return (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+  )
+  (func (export "as-if-then")
+    (if (i32.const 1) (then (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  )
+  (func (export "as-if-else")
+    (if (i32.const 0) (then) (else (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  )
+)
+
+(assert_return (invoke "as-block-value"))
+(assert_return (invoke "as-loop-value"))
+(assert_return (invoke "as-br-value"))
+(assert_return (invoke "as-br_if-value"))
+(assert_return (invoke "as-br_if-value-cond"))
+(assert_return (invoke "as-br_table-value"))
+(assert_return (invoke "as-return-value"))
+(assert_return (invoke "as-if-then"))
+(assert_return (invoke "as-if-else"))
+
+
+;; Unknown operator(e.g. v128.store8, v128.store16, v128.store32)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store8 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store16 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store32 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "unknown operator"
+)
+
+
+;; Type mismatched (e.g. v128.load(f32.const 0), type address empty)
+
+(assert_invalid
+  (module (memory 1) (func (v128.store (f32.const 0) (v128.const i32x4 0 0 0 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (local v128) (block (br_if 0 (v128.store)))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  "type mismatch"
+)
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module (memory 0)
+    (func $v128.store-1st-arg-empty
+      (v128.store (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.store-2nd-arg-empty
+      (v128.store (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.store-arg-empty
+      (v128.store)
+    )
+  )
+  "type mismatch"
+)
diff --git a/tests/wast/spec/proposals/gc/struct.wast b/tests/wast/spec/proposals/gc/struct.wast
index 50a0e1d5cf..6151fe100f 100644
--- a/tests/wast/spec/proposals/gc/struct.wast
+++ b/tests/wast/spec/proposals/gc/struct.wast
@@ -18,20 +18,15 @@
   )
   "duplicate field"
 )
-(assert_malformed
-  (module quote
-    "(type (struct (field $x i32)))"
-    "(type (struct (field $x i32)))"
-  )
-  "duplicate field"
-)
 
 
 ;; Binding structure
 
 (module
-  (type $s0 (struct (field (ref 0) (ref 1) (ref $s0) (ref $s1))))
-  (type $s1 (struct (field (ref 0) (ref 1) (ref $s0) (ref $s1))))
+  (rec
+    (type $s0 (struct (field (ref 0) (ref 1) (ref $s0) (ref $s1))))
+    (type $s1 (struct (field (ref 0) (ref 1) (ref $s0) (ref $s1))))
+  )
 
   (func (param (ref $forward)))
 
@@ -48,16 +43,63 @@
 )
 
 
+;; Field names
+
+(module
+  (type (struct (field $x i32)))
+  (type $t1 (struct (field i32) (field $x f32)))
+  (type $t2 (struct (field i32 i32) (field $x i64)))
+
+  (func (param (ref 0)) (result i32) (struct.get 0 $x (local.get 0)))
+  (func (param (ref $t1)) (result f32) (struct.get 1 $x (local.get 0)))
+  (func (param (ref $t2)) (result i64) (struct.get $t2 $x (local.get 0)))
+)
+
+(assert_invalid
+  (module
+    (type (struct (field $x i64)))
+    (type $t (struct (field $x i32)))
+    (func (param (ref 0)) (result i32) (struct.get 0 $x (local.get 0)))
+  )
+  "type mismatch"
+)
+
+
 ;; Basic instructions
 
 (module
   (type $vec (struct (field f32) (field $y (mut f32)) (field $z f32)))
 
-  (func $get_0 (param $v (ref $vec)) (result f32)
+  (global (ref $vec) (struct.new $vec (f32.const 1) (f32.const 2) (f32.const 3)))
+  (global (ref $vec) (struct.new_default $vec))
+
+  (func (export "new") (result anyref)
+    (struct.new_default $vec)
+  )
+
+  (func $get_0_0 (param $v (ref $vec)) (result f32)
+    (struct.get 0 0 (local.get $v))
+  )
+  (func (export "get_0_0") (result f32)
+    (call $get_0_0 (struct.new_default $vec))
+  )
+  (func $get_vec_0 (param $v (ref $vec)) (result f32)
     (struct.get $vec 0 (local.get $v))
   )
-  (func (export "get_0") (result f32)
-    (call $get_0 (struct.new_default $vec (rtt.canon $vec)))
+  (func (export "get_vec_0") (result f32)
+    (call $get_vec_0 (struct.new_default $vec))
+  )
+  (func $get_0_y (param $v (ref $vec)) (result f32)
+    (struct.get 0 $y (local.get $v))
+  )
+  (func (export "get_0_y") (result f32)
+    (call $get_0_y (struct.new_default $vec))
+  )
+  (func $get_vec_y (param $v (ref $vec)) (result f32)
+    (struct.get $vec $y (local.get $v))
+  )
+  (func (export "get_vec_y") (result f32)
+    (call $get_vec_y (struct.new_default $vec))
   )
 
   (func $set_get_y (param $v (ref $vec)) (param $y f32) (result f32)
@@ -65,7 +107,7 @@
     (struct.get $vec $y (local.get $v))
   )
   (func (export "set_get_y") (param $y f32) (result f32)
-    (call $set_get_y (struct.new_default $vec (rtt.canon $vec)) (local.get $y))
+    (call $set_get_y (struct.new_default $vec) (local.get $y))
   )
 
   (func $set_get_1 (param $v (ref $vec)) (param $y f32) (result f32)
@@ -73,11 +115,17 @@
     (struct.get $vec $y (local.get $v))
   )
   (func (export "set_get_1") (param $y f32) (result f32)
-    (call $set_get_1 (struct.new_default $vec (rtt.canon $vec)) (local.get $y))
+    (call $set_get_1 (struct.new_default $vec) (local.get $y))
   )
 )
 
-(assert_return (invoke "get_0") (f32.const 0))
+(assert_return (invoke "new") (ref.struct))
+
+(assert_return (invoke "get_0_0") (f32.const 0))
+(assert_return (invoke "get_vec_0") (f32.const 0))
+(assert_return (invoke "get_0_y") (f32.const 0))
+(assert_return (invoke "get_vec_y") (f32.const 0))
+
 (assert_return (invoke "set_get_y" (f32.const 7)) (f32.const 7))
 (assert_return (invoke "set_get_1" (f32.const 7)) (f32.const 7))
 
@@ -104,24 +152,78 @@
   )
 )
 
-(assert_trap (invoke "struct.get-null") "null structure")
-(assert_trap (invoke "struct.set-null") "null structure")
+(assert_trap (invoke "struct.get-null") "null structure reference")
+(assert_trap (invoke "struct.set-null") "null structure reference")
 
-(assert_invalid
-  (module
-    (type $t (struct (field i32 (mut i32))))
-    (func (export "struct.new-null")
-      (local (ref null (rtt $t))) (drop (struct.new $t (i32.const 1) (i32.const 2) (local.get 0)))
-    )
+;; Packed field instructions
+
+(module
+  (type $s (struct (field i8) (field (mut i8)) (field i16) (field (mut i16))))
+
+  (global (export "g0") (ref $s) (struct.new $s (i32.const 0) (i32.const 1) (i32.const 2) (i32.const 3)))
+  (global (export "g1") (ref $s) (struct.new $s (i32.const 254) (i32.const 255) (i32.const 65534) (i32.const 65535)))
+
+  (func (export "get_packed_g0_0") (result i32 i32)
+    (struct.get_s 0 0 (global.get 0))
+    (struct.get_u 0 0 (global.get 0))
   )
-  "type mismatch"
-)
-(assert_invalid
-  (module
-    (type $t (struct (field i32 (mut i32))))
-    (func (export "struct.new_default-null")
-      (local (ref null (rtt $t))) (drop (struct.new_default $t (local.get 0)))
-    )
+
+  (func (export "get_packed_g1_0") (result i32 i32)
+    (struct.get_s 0 0 (global.get 1))
+    (struct.get_u 0 0 (global.get 1))
+  )
+
+  (func (export "get_packed_g0_1") (result i32 i32)
+    (struct.get_s 0 1 (global.get 0))
+    (struct.get_u 0 1 (global.get 0))
+  )
+
+  (func (export "get_packed_g1_1") (result i32 i32)
+    (struct.get_s 0 1 (global.get 1))
+    (struct.get_u 0 1 (global.get 1))
+  )
+
+  (func (export "get_packed_g0_2") (result i32 i32)
+    (struct.get_s 0 2 (global.get 0))
+    (struct.get_u 0 2 (global.get 0))
+  )
+
+  (func (export "get_packed_g1_2") (result i32 i32)
+    (struct.get_s 0 2 (global.get 1))
+    (struct.get_u 0 2 (global.get 1))
+  )
+
+  (func (export "get_packed_g0_3") (result i32 i32)
+    (struct.get_s 0 3 (global.get 0))
+    (struct.get_u 0 3 (global.get 0))
+  )
+
+  (func (export "get_packed_g1_3") (result i32 i32)
+    (struct.get_s 0 3 (global.get 1))
+    (struct.get_u 0 3 (global.get 1))
+  )
+
+  (func (export "set_get_packed_g0_1") (param i32) (result i32 i32)
+    (struct.set 0 1 (global.get 0) (local.get 0))
+    (struct.get_s 0 1 (global.get 0))
+    (struct.get_u 0 1 (global.get 0))
+  )
+
+  (func (export "set_get_packed_g0_3") (param i32) (result i32 i32)
+    (struct.set 0 3 (global.get 0) (local.get 0))
+    (struct.get_s 0 3 (global.get 0))
+    (struct.get_u 0 3 (global.get 0))
   )
-  "type mismatch"
 )
+
+(assert_return (invoke "get_packed_g0_0") (i32.const 0) (i32.const 0))
+(assert_return (invoke "get_packed_g1_0") (i32.const -2) (i32.const 254))
+(assert_return (invoke "get_packed_g0_1") (i32.const 1) (i32.const 1))
+(assert_return (invoke "get_packed_g1_1") (i32.const -1) (i32.const 255))
+(assert_return (invoke "get_packed_g0_2") (i32.const 2) (i32.const 2))
+(assert_return (invoke "get_packed_g1_2") (i32.const -2) (i32.const 65534))
+(assert_return (invoke "get_packed_g0_3") (i32.const 3) (i32.const 3))
+(assert_return (invoke "get_packed_g1_3") (i32.const -1) (i32.const 65535))
+
+(assert_return (invoke "set_get_packed_g0_1" (i32.const 257)) (i32.const 1) (i32.const 1))
+(assert_return (invoke "set_get_packed_g0_3" (i32.const 257)) (i32.const 257) (i32.const 257))
diff --git a/tests/wast/spec/proposals/gc/table.wast b/tests/wast/spec/proposals/gc/table.wast
index 532c13d09a..a11dce56d7 100644
--- a/tests/wast/spec/proposals/gc/table.wast
+++ b/tests/wast/spec/proposals/gc/table.wast
@@ -15,6 +15,10 @@
 (module (table 0 funcref) (table 0 funcref))
 (module (table (import "spectest" "table") 0 funcref) (table 0 funcref))
 
+(module (table 0 funcref (ref.null func)))
+(module (table 1 funcref (ref.null func)))
+(module (table 1 (ref null func) (ref.null func)))
+
 (assert_invalid (module (elem (i32.const 0))) "unknown table")
 (assert_invalid (module (elem (i32.const 0) $f) (func $f)) "unknown table")
 
@@ -41,30 +45,116 @@
   "i32 constant out of range"
 )
 
+(assert_invalid
+  (module (table 1 (ref null func) (i32.const 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (table 1 (ref func) (ref.null extern)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (type $t (func)) (table 1 (ref $t) (ref.null func)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (table 1 (ref func) (ref.null func)))
+  "type mismatch"
+)
 (assert_invalid
   (module (table 0 (ref func)))
-  "non-defaultable element type"
+  "type mismatch"
 )
 (assert_invalid
   (module (table 0 (ref extern)))
-  "non-defaultable element type"
+  "type mismatch"
 )
 (assert_invalid
   (module (type $t (func)) (table 0 (ref $t)))
-  "non-defaultable element type"
+  "type mismatch"
+)
+
+
+;; Table initializer
+
+(module
+  (global (export "g") (ref $f) (ref.func $f))
+  (type $f (func))
+  (func $f)
+)
+(register "M")
+
+(module
+  (global $g (import "M" "g") (ref $dummy))
+
+  (type $dummy (func))
+  (func $dummy)
+
+  (table $t1 10 funcref)
+  (table $t2 10 funcref (ref.func $dummy))
+  (table $t3 10 (ref $dummy) (ref.func $dummy))
+  (table $t4 10 funcref (global.get $g))
+  (table $t5 10 (ref $dummy) (global.get $g))
+
+  (func (export "get1") (result funcref) (table.get $t1 (i32.const 1)))
+  (func (export "get2") (result funcref) (table.get $t2 (i32.const 4)))
+  (func (export "get3") (result funcref) (table.get $t3 (i32.const 7)))
+  (func (export "get4") (result funcref) (table.get $t4 (i32.const 8)))
+  (func (export "get5") (result funcref) (table.get $t5 (i32.const 9)))
 )
 
+(assert_return (invoke "get1") (ref.null))
+(assert_return (invoke "get2") (ref.func))
+(assert_return (invoke "get3") (ref.func))
+(assert_return (invoke "get4") (ref.func))
+(assert_return (invoke "get5") (ref.func))
+
+
+(assert_invalid
+  (module
+    (type $f (func))
+    (table 10 (ref $f))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $f (func))
+    (table 0 (ref $f))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $f (func))
+    (table 0 0 (ref $f))
+  )
+  "type mismatch"
+)
+
+
 ;; Duplicate table identifiers
 
-(assert_malformed (module quote
-  "(table $foo 1 funcref)"
-  "(table $foo 1 funcref)")
-  "duplicate table")
-(assert_malformed (module quote
-  "(import \"\" \"\" (table $foo 1 funcref))"
-  "(table $foo 1 funcref)")
-  "duplicate table")
-(assert_malformed (module quote
-  "(import \"\" \"\" (table $foo 1 funcref))"
-  "(import \"\" \"\" (table $foo 1 funcref))")
-  "duplicate table")
+(assert_malformed
+  (module quote
+    "(table $foo 1 funcref)"
+    "(table $foo 1 funcref)"
+  )
+  "duplicate table"
+)
+(assert_malformed
+  (module quote
+    "(import \"\" \"\" (table $foo 1 funcref))"
+    "(table $foo 1 funcref)"
+  )
+  "duplicate table"
+)
+(assert_malformed
+  (module quote
+    "(import \"\" \"\" (table $foo 1 funcref))"
+    "(import \"\" \"\" (table $foo 1 funcref))"
+  )
+  "duplicate table"
+)
diff --git a/tests/wast/spec/proposals/gc/table_grow.wast b/tests/wast/spec/proposals/gc/table_grow.wast
new file mode 100644
index 0000000000..9a931a7fa2
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/table_grow.wast
@@ -0,0 +1,176 @@
+(module
+  (table $t 0 externref)
+
+  (func (export "get") (param $i i32) (result externref) (table.get $t (local.get $i)))
+  (func (export "set") (param $i i32) (param $r externref) (table.set $t (local.get $i) (local.get $r)))
+
+  (func (export "grow") (param $sz i32) (param $init externref) (result i32)
+    (table.grow $t (local.get $init) (local.get $sz))
+  )
+  (func (export "grow-abbrev") (param $sz i32) (param $init externref) (result i32)
+    (table.grow (local.get $init) (local.get $sz))
+  )
+  (func (export "size") (result i32) (table.size $t))
+)
+
+(assert_return (invoke "size") (i32.const 0))
+(assert_trap (invoke "set" (i32.const 0) (ref.extern 2)) "out of bounds table access")
+(assert_trap (invoke "get" (i32.const 0)) "out of bounds table access")
+
+(assert_return (invoke "grow" (i32.const 1) (ref.null extern)) (i32.const 0))
+(assert_return (invoke "size") (i32.const 1))
+(assert_return (invoke "get" (i32.const 0)) (ref.null extern))
+(assert_return (invoke "set" (i32.const 0) (ref.extern 2)))
+(assert_return (invoke "get" (i32.const 0)) (ref.extern 2))
+(assert_trap (invoke "set" (i32.const 1) (ref.extern 2)) "out of bounds table access")
+(assert_trap (invoke "get" (i32.const 1)) "out of bounds table access")
+
+(assert_return (invoke "grow-abbrev" (i32.const 4) (ref.extern 3)) (i32.const 1))
+(assert_return (invoke "size") (i32.const 5))
+(assert_return (invoke "get" (i32.const 0)) (ref.extern 2))
+(assert_return (invoke "set" (i32.const 0) (ref.extern 2)))
+(assert_return (invoke "get" (i32.const 0)) (ref.extern 2))
+(assert_return (invoke "get" (i32.const 1)) (ref.extern 3))
+(assert_return (invoke "get" (i32.const 4)) (ref.extern 3))
+(assert_return (invoke "set" (i32.const 4) (ref.extern 4)))
+(assert_return (invoke "get" (i32.const 4)) (ref.extern 4))
+(assert_trap (invoke "set" (i32.const 5) (ref.extern 2)) "out of bounds table access")
+(assert_trap (invoke "get" (i32.const 5)) "out of bounds table access")
+
+
+;; Reject growing to size outside i32 value range
+(module
+  (table $t 0x10 funcref)
+  (elem declare func $f)
+  (func $f (export "grow") (result i32)
+    (table.grow $t (ref.func $f) (i32.const 0xffff_fff0))
+  )
+)
+
+(assert_return (invoke "grow") (i32.const -1))
+
+
+(module
+  (table $t 0 externref)
+  (func (export "grow") (param i32) (result i32)
+    (table.grow $t (ref.null extern) (local.get 0))
+  )
+)
+
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 2)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 800)) (i32.const 3))
+
+
+(module
+  (table $t 0 10 externref)
+  (func (export "grow") (param i32) (result i32)
+    (table.grow $t (ref.null extern) (local.get 0))
+  )
+)
+
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "grow" (i32.const 6)) (i32.const 4))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 10))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const -1))
+(assert_return (invoke "grow" (i32.const 0x10000)) (i32.const -1))
+
+
+(module
+  (table $t 10 funcref)
+  (func (export "grow") (param i32) (result i32)
+    (table.grow $t (ref.null func) (local.get 0))
+  )
+  (elem declare func 1)
+  (func (export "check-table-null") (param i32 i32) (result funcref)
+    (local funcref)
+    (local.set 2 (ref.func 1))
+    (block
+      (loop
+        (local.set 2 (table.get $t (local.get 0)))
+        (br_if 1 (i32.eqz (ref.is_null (local.get 2))))
+        (br_if 1 (i32.ge_u (local.get 0) (local.get 1)))
+        (local.set 0 (i32.add (local.get 0) (i32.const 1)))
+        (br_if 0 (i32.le_u (local.get 0) (local.get 1)))
+      )
+    )
+    (local.get 2)
+  )
+)
+
+(assert_return (invoke "check-table-null" (i32.const 0) (i32.const 9)) (ref.null func))
+(assert_return (invoke "grow" (i32.const 10)) (i32.const 10))
+(assert_return (invoke "check-table-null" (i32.const 0) (i32.const 19)) (ref.null func))
+
+
+;; Type errors
+
+(assert_invalid
+  (module
+    (table $t 0 externref)
+    (func $type-init-size-empty-vs-i32-externref (result i32)
+      (table.grow $t)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 0 externref)
+    (func $type-size-empty-vs-i32 (result i32)
+      (table.grow $t (ref.null extern))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 0 externref)
+    (func $type-init-empty-vs-externref (result i32)
+      (table.grow $t (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 0 externref)
+    (func $type-size-f32-vs-i32 (result i32)
+      (table.grow $t (ref.null extern) (f32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 0 funcref)
+    (func $type-init-externref-vs-funcref (param $r externref) (result i32)
+      (table.grow $t (local.get $r) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table $t 1 externref)
+    (func $type-result-i32-vs-empty
+      (table.grow $t (ref.null extern) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 1 externref)
+    (func $type-result-i32-vs-f32 (result f32)
+      (table.grow $t (ref.null extern) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
diff --git a/tests/wast/spec/proposals/gc/type-canon.wast b/tests/wast/spec/proposals/gc/type-canon.wast
new file mode 100644
index 0000000000..2c723aa392
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/type-canon.wast
@@ -0,0 +1,17 @@
+(module
+  (rec
+    (type $t1 (func (param i32 (ref $t3))))
+    (type $t2 (func (param i32 (ref $t1))))
+    (type $t3 (func (param i32 (ref $t2))))
+  )
+)
+
+(module
+  (rec
+    (type $t0 (func (param i32 (ref $t2) (ref $t3))))
+    (type $t1 (func (param i32 (ref $t0) i32 (ref $t4))))
+    (type $t2 (func (param i32 (ref $t2) (ref $t1))))
+    (type $t3 (func (param i32 (ref $t2) i32 (ref $t4))))
+    (type $t4 (func (param (ref $t0) (ref $t2))))
+  )
+)
diff --git a/tests/wast/spec/proposals/gc/type-equivalence.wast b/tests/wast/spec/proposals/gc/type-equivalence.wast
index e43871a366..b3d1151d22 100644
--- a/tests/wast/spec/proposals/gc/type-equivalence.wast
+++ b/tests/wast/spec/proposals/gc/type-equivalence.wast
@@ -27,6 +27,14 @@
 
 ;; Recursive types.
 
+(module
+  (rec (type $t1 (func (param i32 (ref $t1)))))
+  (rec (type $t2 (func (param i32 (ref $t2)))))
+
+  (func $f1 (param $r (ref $t1)) (call $f2 (local.get $r)))
+  (func $f2 (param $r (ref $t2)) (call $f1 (local.get $r)))
+)
+
 (module
   (type $t1 (func (param i32 (ref $t1))))
   (type $t2 (func (param i32 (ref $t2))))
@@ -39,64 +47,38 @@
 ;; Isomorphic recursive types.
 
 (module
-  (type $t1 (func (param i32 (ref $t1))))
-  (type $t2 (func (param i32 (ref $t3))))
-  (type $t3 (func (param i32 (ref $t2))))
-
-  (func $f1 (param $r (ref $t1))
-    (call $f2 (local.get $r))
-    (call $f3 (local.get $r))
+  (rec
+    (type $t0 (func (param i32 (ref $t1))))
+    (type $t1 (func (param i32 (ref $t0))))
   )
-  (func $f2 (param $r (ref $t2))
-    (call $f1 (local.get $r))
-    (call $f3 (local.get $r))
+  (rec
+    (type $t2 (func (param i32 (ref $t3))))
+    (type $t3 (func (param i32 (ref $t2))))
   )
-  (func $f3 (param $r (ref $t3))
-    (call $f1 (local.get $r))
+
+  (func $f0 (param $r (ref $t0))
     (call $f2 (local.get $r))
   )
-)
-
-(module
-  (type $t1 (func (param i32 (ref $t3))))
-  (type $t2 (func (param i32 (ref $t1))))
-  (type $t3 (func (param i32 (ref $t2))))
-
   (func $f1 (param $r (ref $t1))
-    (call $f2 (local.get $r))
     (call $f3 (local.get $r))
   )
   (func $f2 (param $r (ref $t2))
-    (call $f1 (local.get $r))
-    (call $f3 (local.get $r))
+    (call $f0 (local.get $r))
   )
   (func $f3 (param $r (ref $t3))
     (call $f1 (local.get $r))
-    (call $f2 (local.get $r))
   )
 )
 
-(module
-  (type $t1 (func (param i32 (ref $u1))))
-  (type $u1 (func (param f32 (ref $t1))))
 
-  (type $t2 (func (param i32 (ref $u3))))
-  (type $u2 (func (param f32 (ref $t3))))
-  (type $t3 (func (param i32 (ref $u2))))
-  (type $u3 (func (param f32 (ref $t2))))
+;; Invalid recursion.
 
-  (func $f1 (param $r (ref $t1))
-    (call $f2 (local.get $r))
-    (call $f3 (local.get $r))
-  )
-  (func $f2 (param $r (ref $t2))
-    (call $f1 (local.get $r))
-    (call $f3 (local.get $r))
-  )
-  (func $f3 (param $r (ref $t3))
-    (call $f1 (local.get $r))
-    (call $f2 (local.get $r))
+(assert_invalid
+  (module
+    (type $t1 (func (param (ref $t2))))
+    (type $t2 (func (param (ref $t1))))
   )
+  "unknown type"
 )
 
 
@@ -152,22 +134,23 @@
 ;; Recursive types.
 
 (module
-  (type $t1 (func (param i32 (ref $t1))))
-  (type $t2 (func (param i32 (ref $t2))))
+  (rec (type $t1 (func (result (ref null $t1)))))
+  (rec (type $t2 (func (result (ref null $t2)))))
 
-  (func $f1 (type $t1))
-  (func $f2 (type $t2))
+  (func $f1 (type $t1) (ref.null $t1))
+  (func $f2 (type $t2) (ref.null $t2))
   (table funcref (elem $f1 $f2))
 
   (func (export "run")
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 0))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 1))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 0))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 1))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 0))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 1))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 0))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 1))
+    (block (result (ref null $t1)) (call_indirect (type $t1) (i32.const 0)))
+    (block (result (ref null $t1)) (call_indirect (type $t2) (i32.const 0)))
+    (block (result (ref null $t2)) (call_indirect (type $t1) (i32.const 0)))
+    (block (result (ref null $t2)) (call_indirect (type $t2) (i32.const 0)))
+    (block (result (ref null $t1)) (call_indirect (type $t1) (i32.const 1)))
+    (block (result (ref null $t1)) (call_indirect (type $t2) (i32.const 1)))
+    (block (result (ref null $t2)) (call_indirect (type $t1) (i32.const 1)))
+    (block (result (ref null $t2)) (call_indirect (type $t2) (i32.const 1)))
+    (br 0)
   )
 )
 (assert_return (invoke "run"))
@@ -176,51 +159,17 @@
 ;; Isomorphic recursive types.
 
 (module
-  (type $t1 (func (param i32 (ref $t1))))
-  (type $t2 (func (param i32 (ref $t3))))
-  (type $t3 (func (param i32 (ref $t2))))
-
-  (func $f1 (type $t1))
-  (func $f2 (type $t2))
-  (func $f3 (type $t3))
-  (table funcref (elem $f1 $f2 $f3))
-
-  (func (export "run")
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 0))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 1))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 2))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 0))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 1))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 2))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 0))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 1))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 2))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 0))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 1))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 2))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 0))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 1))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 2))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 0))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 1))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 2))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 0))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 1))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 2))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 0))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 1))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 2))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 0))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 1))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 2))
+  (rec
+    (type $t1 (func (param i32 (ref $t1))))
+    (type $t2 (func (param i32 (ref $t3))))
+    (type $t3 (func (param i32 (ref $t2))))
   )
-)
-(assert_return (invoke "run"))
 
-(module
-  (type $t1 (func (param i32 (ref $t3))))
-  (type $t2 (func (param i32 (ref $t1))))
-  (type $t3 (func (param i32 (ref $t2))))
+  (rec
+    (type $u1 (func (param i32 (ref $u1))))
+    (type $u2 (func (param i32 (ref $u3))))
+    (type $u3 (func (param i32 (ref $u2))))
+  )
 
   (func $f1 (type $t1))
   (func $f2 (type $t2))
@@ -229,81 +178,11 @@
 
   (func (export "run")
     (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 0))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 1))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 2))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 0))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 1))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 2))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 0))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 1))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 2))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 0))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 1))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 2))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 0))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 1))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 2))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 0))
     (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 1))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 2))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 0))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 1))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 2))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 0))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 1))
     (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 2))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 0))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 1))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 2))
-  )
-)
-(assert_return (invoke "run"))
-
-(module
-  (type $t1 (func (param i32 (ref $u1))))
-  (type $u1 (func (param f32 (ref $t1))))
-
-  (type $t2 (func (param i32 (ref $u3))))
-  (type $u2 (func (param f32 (ref $t3))))
-  (type $t3 (func (param i32 (ref $u2))))
-  (type $u3 (func (param f32 (ref $t2))))
-
-  (func $f1 (type $t1))
-  (func $f2 (type $t2))
-  (func $f3 (type $t3))
-  (func $g1 (type $u1))
-  (func $g2 (type $u2))
-  (func $g3 (type $u3))
-  (table funcref (elem $f1 $f2 $f3 $g1 $g2 $g3))
-
-  (func (export "run")
-    (call_indirect (type $t1) (i32.const 1) (ref.func $g1) (i32.const 0))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $g1) (i32.const 1))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $g1) (i32.const 2))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $g2) (i32.const 0))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $g2) (i32.const 1))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $g2) (i32.const 2))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $g3) (i32.const 0))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $g3) (i32.const 1))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $g3) (i32.const 2))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $g1) (i32.const 0))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $g1) (i32.const 1))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $g1) (i32.const 2))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $g2) (i32.const 0))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $g2) (i32.const 1))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $g2) (i32.const 2))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $g3) (i32.const 0))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $g3) (i32.const 1))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $g3) (i32.const 2))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $g1) (i32.const 0))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $g1) (i32.const 1))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $g1) (i32.const 2))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $g2) (i32.const 0))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $g2) (i32.const 1))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $g2) (i32.const 2))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $g3) (i32.const 0))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $g3) (i32.const 1))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $g3) (i32.const 2))
+    (call_indirect (type $u1) (i32.const 1) (ref.func $f1) (i32.const 0))
+    (call_indirect (type $u2) (i32.const 1) (ref.func $f3) (i32.const 1))
+    (call_indirect (type $u3) (i32.const 1) (ref.func $f2) (i32.const 2))
   )
 )
 (assert_return (invoke "run"))
@@ -335,113 +214,111 @@
   (func (export "f1") (param (ref $t1)))
   (func (export "f2") (param (ref $t1)))
 )
-(register "M")
+(register "N")
 (module
   (type $s0 (func (param i32) (result f32)))
   (type $s1 (func (param i32 (ref $s0)) (result (ref $s0))))
   (type $s2 (func (param i32 (ref $s0)) (result (ref $s0))))
   (type $t1 (func (param (ref $s1)) (result (ref $s2))))
   (type $t2 (func (param (ref $s2)) (result (ref $s1))))
-  (func (import "M" "f1") (param (ref $t1)))
-  (func (import "M" "f1") (param (ref $t2)))
-  (func (import "M" "f2") (param (ref $t1)))
-  (func (import "M" "f2") (param (ref $t1)))
+  (func (import "N" "f1") (param (ref $t1)))
+  (func (import "N" "f1") (param (ref $t2)))
+  (func (import "N" "f2") (param (ref $t1)))
+  (func (import "N" "f2") (param (ref $t1)))
 )
 
 
 ;; Recursive types.
 
 (module
-  (type $t1 (func (param i32 (ref $t1))))
+  (rec (type $t1 (func (param i32 (ref $t1)))))
   (func (export "f") (param (ref $t1)))
 )
-(register "M")
+(register "Mr1")
 (module
-  (type $t2 (func (param i32 (ref $t2))))
-  (func (import "M" "f") (param (ref $t2)))
+  (rec (type $t2 (func (param i32 (ref $t2)))))
+  (func (import "Mr1" "f") (param (ref $t2)))
 )
 
 
 ;; Isomorphic recursive types.
 
 (module
-  (type $t1 (func (param i32 (ref $t1))))
-  (type $t2 (func (param i32 (ref $t3))))
-  (type $t3 (func (param i32 (ref $t2))))
+  (rec
+    (type $t1 (func (param i32 (ref $t1))))
+    (type $t2 (func (param i32 (ref $t3))))
+    (type $t3 (func (param i32 (ref $t2))))
+  )
   (func (export "f1") (param (ref $t1)))
   (func (export "f2") (param (ref $t2)))
   (func (export "f3") (param (ref $t3)))
 )
-(register "M")
+(register "Mr2")
 (module
-  (type $t1 (func (param i32 (ref $t1))))
-  (type $t2 (func (param i32 (ref $t3))))
-  (type $t3 (func (param i32 (ref $t2))))
-  (func (import "M" "f1") (param (ref $t1)))
-  (func (import "M" "f1") (param (ref $t2)))
-  (func (import "M" "f1") (param (ref $t3)))
-  (func (import "M" "f2") (param (ref $t1)))
-  (func (import "M" "f2") (param (ref $t2)))
-  (func (import "M" "f2") (param (ref $t3)))
-  (func (import "M" "f3") (param (ref $t1)))
-  (func (import "M" "f3") (param (ref $t2)))
-  (func (import "M" "f3") (param (ref $t3)))
+  (rec
+    (type $t1 (func (param i32 (ref $t1))))
+    (type $t2 (func (param i32 (ref $t3))))
+    (type $t3 (func (param i32 (ref $t2))))
+  )
+  (func (import "Mr2" "f1") (param (ref $t1)))
+  (func (import "Mr2" "f2") (param (ref $t2)))
+  (func (import "Mr2" "f3") (param (ref $t3)))
 )
 
 (module
-  (type $t1 (func (param i32 (ref $t3))))
-  (type $t2 (func (param i32 (ref $t1))))
-  (type $t3 (func (param i32 (ref $t2))))
+  (rec
+    (type $t1 (func (param i32 (ref $t3))))
+    (type $t2 (func (param i32 (ref $t1))))
+    (type $t3 (func (param i32 (ref $t2))))
+  )
   (func (export "f1") (param (ref $t1)))
   (func (export "f2") (param (ref $t2)))
   (func (export "f3") (param (ref $t3)))
 )
-(register "M")
+(register "Mr3")
 (module
-  (type $t1 (func (param i32 (ref $t3))))
-  (type $t2 (func (param i32 (ref $t1))))
-  (type $t3 (func (param i32 (ref $t2))))
-  (func (import "M" "f1") (param (ref $t1)))
-  (func (import "M" "f1") (param (ref $t2)))
-  (func (import "M" "f1") (param (ref $t3)))
-  (func (import "M" "f2") (param (ref $t1)))
-  (func (import "M" "f2") (param (ref $t2)))
-  (func (import "M" "f2") (param (ref $t3)))
-  (func (import "M" "f3") (param (ref $t1)))
-  (func (import "M" "f3") (param (ref $t2)))
-  (func (import "M" "f3") (param (ref $t3)))
+  (rec
+    (type $t1 (func (param i32 (ref $t3))))
+    (type $t2 (func (param i32 (ref $t1))))
+    (type $t3 (func (param i32 (ref $t2))))
+  )
+  (func (import "Mr3" "f1") (param (ref $t1)))
+  (func (import "Mr3" "f2") (param (ref $t2)))
+  (func (import "Mr3" "f3") (param (ref $t3)))
 )
 
 (module
-  (type $t1 (func (param i32 (ref $u1))))
-  (type $u1 (func (param f32 (ref $t1))))
+  (rec
+    (type $t1 (func (param i32 (ref $u1))))
+    (type $u1 (func (param f32 (ref $t1))))
+  )
 
-  (type $t2 (func (param i32 (ref $u3))))
-  (type $u2 (func (param f32 (ref $t3))))
-  (type $t3 (func (param i32 (ref $u2))))
-  (type $u3 (func (param f32 (ref $t2))))
+  (rec
+    (type $t2 (func (param i32 (ref $u3))))
+    (type $u2 (func (param f32 (ref $t3))))
+    (type $t3 (func (param i32 (ref $u2))))
+    (type $u3 (func (param f32 (ref $t2))))
+  )
 
   (func (export "f1") (param (ref $t1)))
   (func (export "f2") (param (ref $t2)))
   (func (export "f3") (param (ref $t3)))
 )
-(register "M")
+(register "Mr4")
 (module
-  (type $t1 (func (param i32 (ref $u1))))
-  (type $u1 (func (param f32 (ref $t1))))
-
-  (type $t2 (func (param i32 (ref $u3))))
-  (type $u2 (func (param f32 (ref $t3))))
-  (type $t3 (func (param i32 (ref $u2))))
-  (type $u3 (func (param f32 (ref $t2))))
-
-  (func (import "M" "f1") (param (ref $t1)))
-  (func (import "M" "f1") (param (ref $t2)))
-  (func (import "M" "f1") (param (ref $t3)))
-  (func (import "M" "f2") (param (ref $t1)))
-  (func (import "M" "f2") (param (ref $t2)))
-  (func (import "M" "f2") (param (ref $t3)))
-  (func (import "M" "f3") (param (ref $t1)))
-  (func (import "M" "f3") (param (ref $t2)))
-  (func (import "M" "f3") (param (ref $t3)))
+  (rec
+    (type $t1 (func (param i32 (ref $u1))))
+    (type $u1 (func (param f32 (ref $t1))))
+  )
+
+  (rec
+    (type $t2 (func (param i32 (ref $u3))))
+    (type $u2 (func (param f32 (ref $t3))))
+    (type $t3 (func (param i32 (ref $u2))))
+    (type $u3 (func (param f32 (ref $t2))))
+  )
+
+  (func (import "Mr4" "f1") (param (ref $t1)))
+  (func (import "Mr4" "f2") (param (ref $t2)))
+  (func (import "Mr4" "f3") (param (ref $t3)))
 )
diff --git a/tests/wast/spec/proposals/gc/type-rec.wast b/tests/wast/spec/proposals/gc/type-rec.wast
new file mode 100644
index 0000000000..5c4ba589da
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/type-rec.wast
@@ -0,0 +1,158 @@
+;; Static matching of recursive types
+
+(module
+  (rec (type $f1 (func)) (type (struct (field (ref $f1)))))
+  (rec (type $f2 (func)) (type (struct (field (ref $f2)))))
+  (func $f (type $f2))
+  (global (ref $f1) (ref.func $f))
+)
+
+(module
+  (rec (type $f1 (func)) (type (struct (field (ref $f1)))))
+  (rec (type $f2 (func)) (type (struct (field (ref $f2)))))
+  (rec
+    (type $g1 (func))
+    (type (struct (field (ref $f1) (ref $f1) (ref $f2) (ref $f2) (ref $g1))))
+  )
+  (rec
+    (type $g2 (func))
+    (type (struct (field (ref $f1) (ref $f2) (ref $f1) (ref $f2) (ref $g2))))
+  )
+  (func $g (type $g2))
+  (global (ref $g1) (ref.func $g))
+)
+
+(assert_invalid
+  (module
+    (rec (type $f1 (func)) (type (struct (field (ref $f1)))))
+    (rec (type $f2 (func)) (type (struct (field (ref $f1)))))
+    (func $f (type $f2))
+    (global (ref $f1) (ref.func $f))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (rec (type $f0 (func)) (type (struct (field (ref $f0)))))
+    (rec (type $f1 (func)) (type (struct (field (ref $f0)))))
+    (rec (type $f2 (func)) (type (struct (field (ref $f1)))))
+    (func $f (type $f2))
+    (global (ref $f1) (ref.func $f))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (rec (type $f1 (func)) (type (struct)))
+    (rec (type (struct)) (type $f2 (func)))
+    (global (ref $f1) (ref.func $f))
+    (func $f (type $f2))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (rec (type $f1 (func)) (type (struct)))
+    (rec (type $f2 (func)) (type (struct)) (type (func)))
+    (global (ref $f1) (ref.func $f))
+    (func $f (type $f2))
+  )
+  "type mismatch"
+)
+
+
+;; Link-time matching of recursive function types
+
+(module $M
+  (rec (type $f1 (func)) (type (struct)))
+  (func (export "f") (type $f1))
+)
+(register "M" $M)
+
+(module
+  (rec (type $f2 (func)) (type (struct)))
+  (func (import "M" "f") (type $f2))
+)
+
+(assert_unlinkable
+  (module
+    (rec (type (struct)) (type $f2 (func)))
+    (func (import "M" "f") (type $f2))
+  )
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module
+    (rec (type $f2 (func)))
+    (func (import "M" "f") (type $f2))
+  )
+  "incompatible import type"
+)
+
+
+;; Dynamic matching of recursive function types
+
+(module
+  (rec (type $f1 (func)) (type (struct)))
+  (rec (type $f2 (func)) (type (struct)))
+  (table funcref (elem $f1))
+  (func $f1 (type $f1))
+  (func (export "run") (call_indirect (type $f2) (i32.const 0)))
+)
+(assert_return (invoke "run"))
+
+(module
+  (rec (type $f1 (func)) (type (struct)))
+  (rec (type (struct)) (type $f2 (func)))
+  (table funcref (elem $f1))
+  (func $f1 (type $f1))
+  (func (export "run") (call_indirect (type $f2) (i32.const 0)))
+)
+(assert_trap (invoke "run") "indirect call type mismatch")
+
+(module
+  (rec (type $f1 (func)) (type (struct)))
+  (rec (type $f2 (func)))
+  (table funcref (elem $f1))
+  (func $f1 (type $f1))
+  (func (export "run") (call_indirect (type $f2) (i32.const 0)))
+)
+(assert_trap (invoke "run") "indirect call type mismatch")
+
+
+;; Implicit function types never pick up non-singleton recursive types
+
+(module
+  (rec (type $s (struct)))
+  (rec (type $t (func (param (ref $s)))))
+  (func $f (param (ref $s)))  ;; okay, type is equivalent to $t
+  (global (ref $t) (ref.func $f))
+)
+
+(assert_invalid
+  (module
+    (rec
+      (type $s (struct))
+      (type $t (func (param (ref $s))))
+    )
+    (func $f (param (ref $s)))  ;; type is not equivalent to $t
+    (global (ref $t) (ref.func $f))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (rec
+      (type (struct))
+      (type $t (func))
+    )
+    (func $f)  ;; type is not equivalent to $t
+    (global (ref $t) (ref.func $f))
+  )
+  "type mismatch"
+)
diff --git a/tests/wast/spec/proposals/gc/type-subtyping.wast b/tests/wast/spec/proposals/gc/type-subtyping.wast
new file mode 100644
index 0000000000..f2b33d7c49
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/type-subtyping.wast
@@ -0,0 +1,833 @@
+;; Definitions
+
+(module
+  (type $e0 (sub (array i32)))
+  (type $e1 (sub $e0 (array i32)))
+
+  (type $e2 (sub (array anyref)))
+  (type $e3 (sub (array (ref null $e0))))
+  (type $e4 (sub (array (ref $e1))))
+
+  (type $m1 (sub (array (mut i32))))
+  (type $m2 (sub $m1 (array (mut i32))))
+)
+
+(module
+  (type $e0 (sub (struct)))
+  (type $e1 (sub $e0 (struct)))
+  (type $e2 (sub $e1 (struct (field i32))))
+  (type $e3 (sub $e2 (struct (field i32 (ref null $e0)))))
+  (type $e4 (sub $e3 (struct (field i32 (ref $e0) (mut i64)))))
+  (type $e5 (sub $e4 (struct (field i32 (ref $e1) (mut i64)))))
+)
+
+(module
+  (type $s (sub (struct)))
+  (type $s' (sub $s (struct)))
+
+  (type $f1 (sub (func (param (ref $s')) (result anyref))))
+  (type $f2 (sub $f1 (func (param (ref $s)) (result (ref any)))))
+  (type $f3 (sub $f2 (func (param (ref null $s)) (result (ref $s)))))
+  (type $f4 (sub $f3 (func (param (ref null struct)) (result (ref $s')))))
+)
+
+
+;; Recursive definitions
+
+(module
+  (type $t (sub (struct (field anyref))))
+  (rec (type $r (sub $t (struct (field (ref $r))))))
+  (type $t' (sub $r (struct (field (ref $r) i32))))
+)
+
+(module
+  (rec
+    (type $r1 (sub (struct (field i32 (ref $r1)))))
+  )
+  (rec
+    (type $r2 (sub $r1 (struct (field i32 (ref $r3)))))
+    (type $r3 (sub $r1 (struct (field i32 (ref $r2)))))
+  )
+)
+
+(module
+  (rec
+    (type $a1 (sub (struct (field i32 (ref $a2)))))
+    (type $a2 (sub (struct (field i64 (ref $a1)))))
+  )
+  (rec
+    (type $b1 (sub $a2 (struct (field i64 (ref $a1) i32))))
+    (type $b2 (sub $a1 (struct (field i32 (ref $a2) i32))))
+    (type $b3 (sub $a2 (struct (field i64 (ref $b2) i32))))
+  )
+)
+
+
+;; Subsumption
+
+(module
+  (rec
+    (type $t1 (sub (func (param i32 (ref $t3)))))
+    (type $t2 (sub $t1 (func (param i32 (ref $t2)))))
+    (type $t3 (sub $t2 (func (param i32 (ref $t1)))))
+  )
+
+  (func $f1 (param $r (ref $t1))
+    (call $f1 (local.get $r))
+  )
+  (func $f2 (param $r (ref $t2))
+    (call $f1 (local.get $r))
+    (call $f2 (local.get $r))
+  )
+  (func $f3 (param $r (ref $t3))
+    (call $f1 (local.get $r))
+    (call $f2 (local.get $r))
+    (call $f3 (local.get $r))
+  )
+)
+
+(module
+  (rec
+    (type $t1 (sub (func (result i32 (ref $u1)))))
+    (type $u1 (sub (func (result f32 (ref $t1)))))
+  )
+
+  (rec
+    (type $t2 (sub $t1 (func (result i32 (ref $u3)))))
+    (type $u2 (sub $u1 (func (result f32 (ref $t3)))))
+    (type $t3 (sub $t1 (func (result i32 (ref $u2)))))
+    (type $u3 (sub $u1 (func (result f32 (ref $t2)))))
+  )
+
+  (func $f1 (param $r (ref $t1))
+    (call $f1 (local.get $r))
+  )
+  (func $f2 (param $r (ref $t2))
+    (call $f1 (local.get $r))
+    (call $f2 (local.get $r))
+  )
+  (func $f3 (param $r (ref $t3))
+    (call $f1 (local.get $r))
+    (call $f3 (local.get $r))
+  )
+)
+
+(module
+  (rec (type $f1 (sub (func))) (type (struct (field (ref $f1)))))
+  (rec (type $f2 (sub (func))) (type (struct (field (ref $f2)))))
+  (rec (type $g1 (sub $f1 (func))) (type (struct)))
+  (rec (type $g2 (sub $f2 (func))) (type (struct)))
+  (func $g (type $g2))
+  (global (ref $g1) (ref.func $g))
+)
+
+(module
+  (rec (type $f1 (sub (func))) (type $s1 (sub (struct (field (ref $f1))))))
+  (rec (type $f2 (sub (func))) (type $s2 (sub (struct (field (ref $f2))))))
+  (rec
+    (type $g1 (sub $f1 (func)))
+    (type (sub $s1 (struct (field (ref $f1) (ref $f1) (ref $f2) (ref $f2) (ref $g1)))))
+  )
+  (rec
+    (type $g2 (sub $f2 (func)))
+    (type (sub $s2 (struct (field (ref $f1) (ref $f2) (ref $f1) (ref $f2) (ref $g2)))))
+  )
+  (func $g (type $g2))
+  (global (ref $g1) (ref.func $g))
+)
+
+(assert_invalid
+  (module
+    (rec (type $f1 (sub (func))) (type (struct (field (ref $f1)))))
+    (rec (type $f2 (sub (func))) (type (struct (field (ref $f1)))))
+    (rec (type $g1 (sub $f1 (func))) (type (struct)))
+    (rec (type $g2 (sub $f2 (func))) (type (struct)))
+    (func $g (type $g2))
+    (global (ref $g1) (ref.func $g))
+  )
+  "type mismatch"
+)
+
+(module
+  (rec (type $f1 (sub (func))) (type (struct (field (ref $f1)))))
+  (rec (type $f2 (sub (func))) (type (struct (field (ref $f2)))))
+  (rec (type $g (sub $f1 (func))) (type (struct)))
+  (func $g (type $g))
+  (global (ref $f1) (ref.func $g))
+)
+
+(module
+  (rec (type $f1 (sub (func))) (type $s1 (sub (struct (field (ref $f1))))))
+  (rec (type $f2 (sub (func))) (type $s2 (sub (struct (field (ref $f2))))))
+  (rec
+    (type $g1 (sub $f1 (func)))
+    (type (sub $s1 (struct (field (ref $f1) (ref $f1) (ref $f2) (ref $f2) (ref $g1)))))
+  )
+  (rec
+    (type $g2 (sub $f2 (func)))
+    (type (sub $s2 (struct (field (ref $f1) (ref $f2) (ref $f1) (ref $f2) (ref $g2)))))
+  )
+  (rec (type $h (sub $g2 (func))) (type (struct)))
+  (func $h (type $h))
+  (global (ref $f1) (ref.func $h))
+  (global (ref $g1) (ref.func $h))
+)
+
+
+(module
+  (rec (type $f11 (sub (func (result (ref func))))) (type $f12 (sub $f11 (func (result (ref $f11))))))
+  (rec (type $f21 (sub (func (result (ref func))))) (type $f22 (sub $f21 (func (result (ref $f21))))))
+  (func $f11 (type $f11) (unreachable))
+  (func $f12 (type $f12) (unreachable))
+  (global (ref $f11) (ref.func $f11))
+  (global (ref $f21) (ref.func $f11))
+  (global (ref $f12) (ref.func $f12))
+  (global (ref $f22) (ref.func $f12))
+)
+
+(module
+  (rec (type $f11 (sub (func (result (ref func))))) (type $f12 (sub $f11 (func (result (ref $f11))))))
+  (rec (type $f21 (sub (func (result (ref func))))) (type $f22 (sub $f21 (func (result (ref $f21))))))
+  (rec (type $g11 (sub $f11 (func (result (ref func))))) (type $g12 (sub $g11 (func (result (ref $g11))))))
+  (rec (type $g21 (sub $f21 (func (result (ref func))))) (type $g22 (sub $g21 (func (result (ref $g21))))))
+  (func $g11 (type $g11) (unreachable))
+  (func $g12 (type $g12) (unreachable))
+  (global (ref $f11) (ref.func $g11))
+  (global (ref $f21) (ref.func $g11))
+  (global (ref $f11) (ref.func $g12))
+  (global (ref $f21) (ref.func $g12))
+  (global (ref $g11) (ref.func $g11))
+  (global (ref $g21) (ref.func $g11))
+  (global (ref $g12) (ref.func $g12))
+  (global (ref $g22) (ref.func $g12))
+)
+
+(assert_invalid
+  (module
+    (rec (type $f11 (sub (func))) (type $f12 (sub $f11 (func))))
+    (rec (type $f21 (sub (func))) (type $f22 (sub $f11 (func))))
+    (func $f (type $f21))
+    (global (ref $f11) (ref.func $f))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (rec (type $f01 (sub (func))) (type $f02 (sub $f01 (func))))
+    (rec (type $f11 (sub (func))) (type $f12 (sub $f01 (func))))
+    (rec (type $f21 (sub (func))) (type $f22 (sub $f11 (func))))
+    (func $f (type $f21))
+    (global (ref $f11) (ref.func $f))
+  )
+  "type mismatch"
+)
+
+
+;; Runtime types
+
+(module
+  (type $t0 (sub (func (result (ref null func)))))
+  (rec (type $t1 (sub $t0 (func (result (ref null $t1))))))
+  (rec (type $t2 (sub $t1 (func (result (ref null $t2))))))
+
+  (func $f0 (type $t0) (ref.null func))
+  (func $f1 (type $t1) (ref.null $t1))
+  (func $f2 (type $t2) (ref.null $t2))
+  (table funcref (elem $f0 $f1 $f2))
+
+  (func (export "run")
+    (block (result (ref null func)) (call_indirect (type $t0) (i32.const 0)))
+    (block (result (ref null func)) (call_indirect (type $t0) (i32.const 1)))
+    (block (result (ref null func)) (call_indirect (type $t0) (i32.const 2)))
+    (block (result (ref null $t1)) (call_indirect (type $t1) (i32.const 1)))
+    (block (result (ref null $t1)) (call_indirect (type $t1) (i32.const 2)))
+    (block (result (ref null $t2)) (call_indirect (type $t2) (i32.const 2)))
+
+    (block (result (ref null $t0)) (ref.cast (ref $t0) (table.get (i32.const 0))))
+    (block (result (ref null $t0)) (ref.cast (ref $t0) (table.get (i32.const 1))))
+    (block (result (ref null $t0)) (ref.cast (ref $t0) (table.get (i32.const 2))))
+    (block (result (ref null $t1)) (ref.cast (ref $t1) (table.get (i32.const 1))))
+    (block (result (ref null $t1)) (ref.cast (ref $t1) (table.get (i32.const 2))))
+    (block (result (ref null $t2)) (ref.cast (ref $t2) (table.get (i32.const 2))))
+    (br 0)
+  )
+
+  (func (export "fail1")
+    (block (result (ref null $t1)) (call_indirect (type $t1) (i32.const 0)))
+    (br 0)
+  )
+  (func (export "fail2")
+    (block (result (ref null $t1)) (call_indirect (type $t2) (i32.const 0)))
+    (br 0)
+  )
+  (func (export "fail3")
+    (block (result (ref null $t1)) (call_indirect (type $t2) (i32.const 1)))
+    (br 0)
+  )
+
+  (func (export "fail4")
+    (ref.cast (ref $t1) (table.get (i32.const 0)))
+    (br 0)
+  )
+  (func (export "fail5")
+    (ref.cast (ref $t2) (table.get (i32.const 0)))
+    (br 0)
+  )
+  (func (export "fail6")
+    (ref.cast (ref $t2) (table.get (i32.const 1)))
+    (br 0)
+  )
+)
+(assert_return (invoke "run"))
+(assert_trap (invoke "fail1") "indirect call")
+(assert_trap (invoke "fail2") "indirect call")
+(assert_trap (invoke "fail3") "indirect call")
+(assert_trap (invoke "fail4") "cast")
+(assert_trap (invoke "fail5") "cast")
+(assert_trap (invoke "fail6") "cast")
+
+(module
+  (type $t1 (sub (func)))
+  (type $t2 (sub final (func)))
+
+  (func $f1 (type $t1))
+  (func $f2 (type $t2))
+  (table funcref (elem $f1 $f2))
+
+  (func (export "fail1")
+    (block (call_indirect (type $t1) (i32.const 1)))
+  )
+  (func (export "fail2")
+    (block (call_indirect (type $t2) (i32.const 0)))
+  )
+
+  (func (export "fail3")
+    (ref.cast (ref $t1) (table.get (i32.const 1)))
+    (drop)
+  )
+  (func (export "fail4")
+    (ref.cast (ref $t2) (table.get (i32.const 0)))
+    (drop)
+  )
+)
+(assert_trap (invoke "fail1") "indirect call")
+(assert_trap (invoke "fail2") "indirect call")
+(assert_trap (invoke "fail3") "cast")
+(assert_trap (invoke "fail4") "cast")
+
+(module
+  (type $t1 (sub (func)))
+  (type $t2 (sub $t1 (func)))
+  (type $t3 (sub $t2 (func)))
+  (type $t4 (sub final (func)))
+
+  (func $f2 (type $t2))
+  (func $f3 (type $t3))
+  (table (ref null $t2) (elem $f2 $f3))
+
+  (func (export "run")
+    (call_indirect (type $t1) (i32.const 0))
+    (call_indirect (type $t1) (i32.const 1))
+    (call_indirect (type $t2) (i32.const 0))
+    (call_indirect (type $t2) (i32.const 1))
+    (call_indirect (type $t3) (i32.const 1))
+  )
+
+  (func (export "fail1")
+    (call_indirect (type $t3) (i32.const 0))
+  )
+  (func (export "fail2")
+    (call_indirect (type $t4) (i32.const 0))
+  )
+)
+(assert_return (invoke "run"))
+(assert_trap (invoke "fail1") "indirect call")
+(assert_trap (invoke "fail2") "indirect call")
+
+(module
+  (rec (type $f1 (sub (func))) (type (struct (field (ref $f1)))))
+  (rec (type $f2 (sub (func))) (type (struct (field (ref $f2)))))
+  (rec (type $g1 (sub $f1 (func))) (type (struct)))
+  (rec (type $g2 (sub $f2 (func))) (type (struct)))
+  (func $g (type $g2)) (elem declare func $g)
+  (func (export "run") (result i32)
+    (ref.test (ref $g1) (ref.func $g))
+  )
+)
+(assert_return (invoke "run") (i32.const 1))
+
+(module
+  (rec (type $f1 (sub (func))) (type $s1 (sub (struct (field (ref $f1))))))
+  (rec (type $f2 (sub (func))) (type $s2 (sub (struct (field (ref $f2))))))
+  (rec
+    (type $g1 (sub $f1 (func)))
+    (type (sub $s1 (struct (field (ref $f1) (ref $f1) (ref $f2) (ref $f2) (ref $g1)))))
+  )
+  (rec
+    (type $g2 (sub $f2 (func)))
+    (type (sub $s2 (struct (field (ref $f1) (ref $f2) (ref $f1) (ref $f2) (ref $g2)))))
+  )
+  (func $g (type $g2)) (elem declare func $g)
+  (func (export "run") (result i32)
+    (ref.test (ref $g1) (ref.func $g))
+  )
+)
+(assert_return (invoke "run") (i32.const 1))
+
+(module
+  (rec (type $f1 (sub (func))) (type (struct (field (ref $f1)))))
+  (rec (type $f2 (sub (func))) (type (struct (field (ref $f1)))))
+  (rec (type $g1 (sub $f1 (func))) (type (struct)))
+  (rec (type $g2 (sub $f2 (func))) (type (struct)))
+  (func $g (type $g2)) (elem declare func $g)
+  (func (export "run") (result i32)
+    (ref.test (ref $g1) (ref.func $g))
+  )
+)
+(assert_return (invoke "run") (i32.const 0))
+
+(module
+  (rec (type $f1 (sub (func))) (type (struct (field (ref $f1)))))
+  (rec (type $f2 (sub (func))) (type (struct (field (ref $f2)))))
+  (rec (type $g (sub $f1 (func))) (type (struct)))
+  (func $g (type $g)) (elem declare func $g)
+  (func (export "run") (result i32)
+    (ref.test (ref $f1) (ref.func $g))
+  )
+)
+(assert_return (invoke "run") (i32.const 1))
+
+(module
+  (rec (type $f1 (sub (func))) (type $s1 (sub (struct (field (ref $f1))))))
+  (rec (type $f2 (sub (func))) (type $s2 (sub (struct (field (ref $f2))))))
+  (rec
+    (type $g1 (sub $f1 (func)))
+    (type (sub $s1 (struct (field (ref $f1) (ref $f1) (ref $f2) (ref $f2) (ref $g1)))))
+  )
+  (rec
+    (type $g2 (sub $f2 (func)))
+    (type (sub $s2 (struct (field (ref $f1) (ref $f2) (ref $f1) (ref $f2) (ref $g2)))))
+  )
+  (rec (type $h (sub $g2 (func))) (type (struct)))
+  (func $h (type $h)) (elem declare func $h)
+  (func (export "run") (result i32 i32)
+    (ref.test (ref $f1) (ref.func $h))
+    (ref.test (ref $g1) (ref.func $h))
+  )
+)
+(assert_return (invoke "run") (i32.const 1) (i32.const 1))
+
+
+(module
+  (rec (type $f11 (sub (func (result (ref func))))) (type $f12 (sub $f11 (func (result (ref $f11))))))
+  (rec (type $f21 (sub (func (result (ref func))))) (type $f22 (sub $f21 (func (result (ref $f21))))))
+  (func $f11 (type $f11) (unreachable)) (elem declare func $f11)
+  (func $f12 (type $f12) (unreachable)) (elem declare func $f12)
+  (func (export "run") (result i32 i32 i32 i32)
+    (ref.test (ref $f11) (ref.func $f11))
+    (ref.test (ref $f21) (ref.func $f11))
+    (ref.test (ref $f12) (ref.func $f12))
+    (ref.test (ref $f22) (ref.func $f12))
+  )
+)
+(assert_return (invoke "run")
+  (i32.const 1) (i32.const 1) (i32.const 1) (i32.const 1)
+)
+
+(module
+  (rec (type $f11 (sub (func (result (ref func))))) (type $f12 (sub $f11 (func (result (ref $f11))))))
+  (rec (type $f21 (sub (func (result (ref func))))) (type $f22 (sub $f21 (func (result (ref $f21))))))
+  (rec (type $g11 (sub $f11 (func (result (ref func))))) (type $g12 (sub $g11 (func (result (ref $g11))))))
+  (rec (type $g21 (sub $f21 (func (result (ref func))))) (type $g22 (sub $g21 (func (result (ref $g21))))))
+  (func $g11 (type $g11) (unreachable)) (elem declare func $g11)
+  (func $g12 (type $g12) (unreachable)) (elem declare func $g12)
+  (func (export "run") (result i32 i32 i32 i32 i32 i32 i32 i32)
+    (ref.test (ref $f11) (ref.func $g11))
+    (ref.test (ref $f21) (ref.func $g11))
+    (ref.test (ref $f11) (ref.func $g12))
+    (ref.test (ref $f21) (ref.func $g12))
+    (ref.test (ref $g11) (ref.func $g11))
+    (ref.test (ref $g21) (ref.func $g11))
+    (ref.test (ref $g12) (ref.func $g12))
+    (ref.test (ref $g22) (ref.func $g12))
+  )
+)
+(assert_return (invoke "run")
+  (i32.const 1) (i32.const 1) (i32.const 1) (i32.const 1)
+  (i32.const 1) (i32.const 1) (i32.const 1) (i32.const 1)
+)
+
+(module
+  (rec (type $f11 (sub (func))) (type $f12 (sub $f11 (func))))
+  (rec (type $f21 (sub (func))) (type $f22 (sub $f11 (func))))
+  (func $f (type $f21)) (elem declare func $f)
+  (func (export "run") (result i32)
+    (ref.test (ref $f11) (ref.func $f))
+  )
+)
+(assert_return (invoke "run") (i32.const 0))
+
+(module
+  (rec (type $f01 (sub (func))) (type $f02 (sub $f01 (func))))
+  (rec (type $f11 (sub (func))) (type $f12 (sub $f01 (func))))
+  (rec (type $f21 (sub (func))) (type $f22 (sub $f11 (func))))
+  (func $f (type $f21)) (elem declare func $f)
+  (func (export "run") (result i32)
+    (ref.test (ref $f11) (ref.func $f))
+  )
+)
+(assert_return (invoke "run") (i32.const 0))
+
+
+
+;; Linking
+
+(module
+  (type $t0 (sub (func (result (ref null func)))))
+  (rec (type $t1 (sub $t0 (func (result (ref null $t1))))))
+  (rec (type $t2 (sub $t1 (func (result (ref null $t2))))))
+
+  (func (export "f0") (type $t0) (ref.null func))
+  (func (export "f1") (type $t1) (ref.null $t1))
+  (func (export "f2") (type $t2) (ref.null $t2))
+)
+(register "M")
+
+(module
+  (type $t0 (sub (func (result (ref null func)))))
+  (rec (type $t1 (sub $t0 (func (result (ref null $t1))))))
+  (rec (type $t2 (sub $t1 (func (result (ref null $t2))))))
+
+  (func (import "M" "f0") (type $t0))
+  (func (import "M" "f1") (type $t0))
+  (func (import "M" "f1") (type $t1))
+  (func (import "M" "f2") (type $t0))
+  (func (import "M" "f2") (type $t1))
+  (func (import "M" "f2") (type $t2))
+)
+
+(assert_unlinkable
+  (module
+    (type $t0 (sub (func (result (ref null func)))))
+    (rec (type $t1 (sub $t0 (func (result (ref null $t1))))))
+    (rec (type $t2 (sub $t1 (func (result (ref null $t2))))))
+    (func (import "M" "f0") (type $t1))
+  )
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module
+    (type $t0 (sub (func (result (ref null func)))))
+    (rec (type $t1 (sub $t0 (func (result (ref null $t1))))))
+    (rec (type $t2 (sub $t1 (func (result (ref null $t2))))))
+    (func (import "M" "f0") (type $t2))
+  )
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module
+    (type $t0 (sub (func (result (ref null func)))))
+    (rec (type $t1 (sub $t0 (func (result (ref null $t1))))))
+    (rec (type $t2 (sub $t1 (func (result (ref null $t2))))))
+    (func (import "M" "f1") (type $t2))
+  )
+  "incompatible import type"
+)
+
+(module
+  (type $t1 (sub (func)))
+  (type $t2 (sub final (func)))
+  (func (export "f1") (type $t1))
+  (func (export "f2") (type $t2))
+)
+(register "M2")
+
+(assert_unlinkable
+  (module
+    (type $t1 (sub (func)))
+    (type $t2 (sub final (func)))
+    (func (import "M2" "f1") (type $t2))
+  )
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module
+    (type $t1 (sub (func)))
+    (type $t2 (sub final (func)))
+    (func (import "M2" "f2") (type $t1))
+  )
+  "incompatible import type"
+)
+
+
+(module
+  (rec (type $f2 (sub (func))) (type (struct (field (ref $f2)))))
+  (rec (type $g2 (sub $f2 (func))) (type (struct)))
+  (func (export "g") (type $g2))
+)
+(register "M3")
+(module
+  (rec (type $f1 (sub (func))) (type (struct (field (ref $f1)))))
+  (rec (type $g1 (sub $f1 (func))) (type (struct)))
+  (func (import "M3" "g") (type $g1))
+)
+
+(module
+  (rec (type $f1 (sub (func))) (type $s1 (sub (struct (field (ref $f1))))))
+  (rec (type $f2 (sub (func))) (type $s2 (sub (struct (field (ref $f2))))))
+  (rec
+    (type $g2 (sub $f2 (func)))
+    (type (sub $s2 (struct (field (ref $f1) (ref $f2) (ref $f1) (ref $f2) (ref $g2)))))
+  )
+  (func (export "g") (type $g2))
+)
+(register "M4")
+(module
+  (rec (type $f1 (sub (func))) (type $s1 (sub (struct (field (ref $f1))))))
+  (rec (type $f2 (sub (func))) (type $s2 (sub (struct (field (ref $f2))))))
+  (rec
+    (type $g1 (sub $f1 (func)))
+    (type (sub $s1 (struct (field (ref $f1) (ref $f1) (ref $f2) (ref $f2) (ref $g1)))))
+  )
+  (func (import "M4" "g") (type $g1))
+)
+
+(module
+  (rec (type $f1 (sub (func))) (type (struct (field (ref $f1)))))
+  (rec (type $f2 (sub (func))) (type (struct (field (ref $f1)))))
+  (rec (type $g2 (sub $f2 (func))) (type (struct)))
+  (func (export "g") (type $g2))
+)
+(register "M5")
+(assert_unlinkable
+  (module
+    (rec (type $f1 (sub (func))) (type (struct (field (ref $f1)))))
+    (rec (type $g1 (sub $f1 (func))) (type (struct)))
+    (func (import "M5" "g") (type $g1))
+  )
+  "incompatible import"
+)
+
+(module
+  (rec (type $f1 (sub (func))) (type (struct (field (ref $f1)))))
+  (rec (type $f2 (sub (func))) (type (struct (field (ref $f2)))))
+  (rec (type $g (sub $f1 (func))) (type (struct)))
+  (func (export "g") (type $g))
+)
+(register "M6")
+(module
+  (rec (type $f1 (sub (func))) (type (struct (field (ref $f1)))))
+  (rec (type $f2 (sub (func))) (type (struct (field (ref $f2)))))
+  (rec (type $g (sub $f1 (func))) (type (struct)))
+  (func (import "M6" "g") (type $f1))
+)
+
+(module
+  (rec (type $f1 (sub (func))) (type $s1 (sub (struct (field (ref $f1))))))
+  (rec (type $f2 (sub (func))) (type $s2 (sub (struct (field (ref $f2))))))
+  (rec
+    (type $g2 (sub $f2 (func)))
+    (type (sub $s2 (struct (field (ref $f1) (ref $f2) (ref $f1) (ref $f2) (ref $g2)))))
+  )
+  (rec (type $h (sub $g2 (func))) (type (struct)))
+  (func (export "h") (type $h))
+)
+(register "M7")
+(module
+  (rec (type $f1 (sub (func))) (type $s1 (sub (struct (field (ref $f1))))))
+  (rec (type $f2 (sub (func))) (type $s2 (sub (struct (field (ref $f2))))))
+  (rec
+    (type $g1 (sub $f1 (func)))
+    (type (sub $s1 (struct (field (ref $f1) (ref $f1) (ref $f2) (ref $f2) (ref $g1)))))
+  )
+  (rec (type $h (sub $g1 (func))) (type (struct)))
+  (func (import "M7" "h") (type $f1))
+  (func (import "M7" "h") (type $g1))
+)
+
+
+(module
+  (rec (type $f11 (sub (func (result (ref func))))) (type $f12 (sub $f11 (func (result (ref $f11))))))
+  (rec (type $f21 (sub (func (result (ref func))))) (type $f22 (sub $f21 (func (result (ref $f21))))))
+  (func (export "f11") (type $f11) (unreachable))
+  (func (export "f12") (type $f12) (unreachable))
+)
+(register "M8")
+(module
+  (rec (type $f11 (sub (func (result (ref func))))) (type $f12 (sub $f11 (func (result (ref $f11))))))
+  (rec (type $f21 (sub (func (result (ref func))))) (type $f22 (sub $f21 (func (result (ref $f21))))))
+  (func (import "M8" "f11") (type $f11))
+  (func (import "M8" "f11") (type $f21))
+  (func (import "M8" "f12") (type $f12))
+  (func (import "M8" "f12") (type $f22))
+)
+
+(module
+  (rec (type $f11 (sub (func (result (ref func))))) (type $f12 (sub $f11 (func (result (ref $f11))))))
+  (rec (type $f21 (sub (func (result (ref func))))) (type $f22 (sub $f21 (func (result (ref $f21))))))
+  (rec (type $g11 (sub $f11 (func (result (ref func))))) (type $g12 (sub $g11 (func (result (ref $g11))))))
+  (rec (type $g21 (sub $f21 (func (result (ref func))))) (type $g22 (sub $g21 (func (result (ref $g21))))))
+  (func (export "g11") (type $g11) (unreachable))
+  (func (export "g12") (type $g12) (unreachable))
+)
+(register "M9")
+(module
+  (rec (type $f11 (sub (func (result (ref func))))) (type $f12 (sub $f11 (func (result (ref $f11))))))
+  (rec (type $f21 (sub (func (result (ref func))))) (type $f22 (sub $f21 (func (result (ref $f21))))))
+  (rec (type $g11 (sub $f11 (func (result (ref func))))) (type $g12 (sub $g11 (func (result (ref $g11))))))
+  (rec (type $g21 (sub $f21 (func (result (ref func))))) (type $g22 (sub $g21 (func (result (ref $g21))))))
+  (func (import "M9" "g11") (type $f11))
+  (func (import "M9" "g11") (type $f21))
+  (func (import "M9" "g12") (type $f11))
+  (func (import "M9" "g12") (type $f21))
+  (func (import "M9" "g11") (type $g11))
+  (func (import "M9" "g11") (type $g21))
+  (func (import "M9" "g12") (type $g12))
+  (func (import "M9" "g12") (type $g22))
+)
+
+(module
+  (rec (type $f11 (sub (func))) (type $f12 (sub $f11 (func))))
+  (rec (type $f21 (sub (func))) (type $f22 (sub $f11 (func))))
+  (func (export "f") (type $f21))
+)
+(register "M10")
+(assert_unlinkable
+  (module
+    (rec (type $f11 (sub (func))) (type $f12 (sub $f11 (func))))
+    (func (import "M10" "f") (type $f11))
+  )
+  "incompatible import"
+)
+
+(module
+  (rec (type $f01 (sub (func))) (type $f02 (sub $f01 (func))))
+  (rec (type $f11 (sub (func))) (type $f12 (sub $f01 (func))))
+  (rec (type $f21 (sub (func))) (type $f22 (sub $f11 (func))))
+  (func (export "f") (type $f21))
+)
+(register "M11")
+(assert_unlinkable
+  (module
+    (rec (type $f01 (sub (func))) (type $f02 (sub $f01 (func))))
+    (rec (type $f11 (sub (func))) (type $f12 (sub $f01 (func))))
+    (func (import "M11" "f") (type $f11))
+  )
+  "incompatible import"
+)
+
+
+
+;; Finality violation
+
+(assert_invalid
+  (module
+    (type $t (func))
+    (type $s (sub $t (func)))
+  )
+  "sub type"
+)
+
+(assert_invalid
+  (module
+    (type $t (struct))
+    (type $s (sub $t (struct)))
+  )
+  "sub type"
+)
+
+(assert_invalid
+  (module
+    (type $t (sub final (func)))
+    (type $s (sub $t (func)))
+  )
+  "sub type"
+)
+
+(assert_invalid
+  (module
+    (type $t (sub (func)))
+    (type $s (sub final $t (func)))
+    (type $u (sub $s (func)))
+  )
+  "sub type"
+)
+
+
+
+;; Invalid subtyping definitions
+
+(assert_invalid
+  (module
+    (type $a0 (sub (array i32)))
+    (type $s0 (sub $a0 (struct)))
+  )
+  "sub type"
+)
+
+(assert_invalid
+  (module
+    (type $f0 (sub (func (param i32) (result i32))))
+    (type $s0 (sub $f0 (struct)))
+  )
+  "sub type"
+)
+
+(assert_invalid
+  (module
+    (type $s0 (sub (struct)))
+    (type $a0 (sub $s0 (array i32)))
+  )
+  "sub type"
+)
+
+(assert_invalid
+  (module
+    (type $f0 (sub (func (param i32) (result i32))))
+    (type $a0 (sub $f0 (array i32)))
+  )
+  "sub type"
+)
+
+(assert_invalid
+  (module
+    (type $s0 (sub (struct)))
+    (type $f0 (sub $s0 (func (param i32) (result i32))))
+  )
+  "sub type"
+)
+
+(assert_invalid
+  (module
+    (type $a0 (sub (array i32)))
+    (type $f0 (sub $a0 (func (param i32) (result i32))))
+  )
+  "sub type"
+)
+
+(assert_invalid
+  (module
+    (type $a0 (sub (array i32)))
+    (type $a1 (sub $a0 (array i64)))
+  )
+  "sub type"
+)
+
+(assert_invalid
+  (module
+    (type $s0 (sub (struct (field i32))))
+    (type $s1 (sub $s0 (struct (field i64))))
+  )
+  "sub type"
+)
+
+(assert_invalid
+  (module
+    (type $f0 (sub (func)))
+    (type $f1 (sub $f0 (func (param i32))))
+  )
+  "sub type"
+)
diff --git a/tests/wast/spec/proposals/gc/unreached-invalid.wast b/tests/wast/spec/proposals/gc/unreached-invalid.wast
index 519656399f..1dfcf91f8c 100644
--- a/tests/wast/spec/proposals/gc/unreached-invalid.wast
+++ b/tests/wast/spec/proposals/gc/unreached-invalid.wast
@@ -704,3 +704,79 @@
   )
   "type mismatch"
 )
+
+;; The first two operands should have the same type as each other
+(assert_invalid
+  (module (func (unreachable) (select (i32.const 1) (i64.const 1) (i32.const 1)) (drop)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func (unreachable) (select (i64.const 1) (i32.const 1) (i32.const 1)) (drop)))
+  "type mismatch"
+)
+
+;; Third operand must be i32
+(assert_invalid
+  (module (func (unreachable) (select (i32.const 1) (i32.const 1) (i64.const 1)) (drop)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func (unreachable) (select (i32.const 1) (i64.const 1)) (drop)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func (unreachable) (select (i64.const 1)) (drop)))
+  "type mismatch"
+)
+
+;; Result of select has type of first two operands (type of second operand when first one is omitted)
+(assert_invalid
+  (module (func (result i32) (unreachable) (select (i64.const 1) (i32.const 1))))
+  "type mismatch"
+)
+
+
+;; select always has non-empty result
+(assert_invalid
+  (module (func (unreachable) (select)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $meet-bottom (param i32) (result externref)
+    (block $l1 (result externref)
+      (drop
+        (block $l2 (result i32)
+          (br_table $l2 $l1 $l2 (ref.null extern) (local.get 0))
+        )
+      )
+      (ref.null extern)
+    )
+  ))
+  "type mismatch"
+)
+
+
+(assert_invalid
+  (module
+    (type $t (func (param i32) (result i64)))
+    (func (result i32)
+      (unreachable)
+      (call_ref $t)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type $t (func (param i32) (result i32 i32)))
+    (func (result i32)
+      (unreachable)
+      (call_ref $t)
+    )
+  )
+  "type mismatch"
+)
diff --git a/tests/wast/spec/proposals/gc/unreached-valid.wast b/tests/wast/spec/proposals/gc/unreached-valid.wast
new file mode 100644
index 0000000000..f3feb0f35c
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/unreached-valid.wast
@@ -0,0 +1,108 @@
+(module
+
+  ;; Check that both sides of the select are evaluated
+  (func (export "select-trap-left") (param $cond i32) (result i32)
+    (select (unreachable) (i32.const 0) (local.get $cond))
+  )
+  (func (export "select-trap-right") (param $cond i32) (result i32)
+    (select (i32.const 0) (unreachable) (local.get $cond))
+  )
+
+  (func (export "select-unreached")
+    (unreachable) (select)
+    (unreachable) (i32.const 0) (select)
+    (unreachable) (i32.const 0) (i32.const 0) (select)
+    (unreachable) (i32.const 0) (i32.const 0) (i32.const 0) (select)
+    (unreachable) (f32.const 0) (i32.const 0) (select)
+    (unreachable)
+  )
+
+  (func (export "select-unreached-result1") (result i32)
+    (unreachable) (i32.add (select))
+  )
+
+  (func (export "select-unreached-result2") (result i64)
+    (unreachable) (i64.add (select (i64.const 0) (i32.const 0)))
+  )
+
+  (func (export "select-unreached-num")
+    (unreachable)
+    (select)
+    (i32.eqz)
+    (drop)
+  )
+  (func (export "select-unreached-ref")
+    (unreachable)
+    (select)
+    (ref.is_null)
+    (drop)
+  )
+
+  (type $t (func (param i32) (result i32)))
+  (func (export "call_ref-unreached") (result i32)
+    (unreachable)
+    (call_ref $t)
+  )
+)
+
+(assert_trap (invoke "select-trap-left" (i32.const 1)) "unreachable")
+(assert_trap (invoke "select-trap-left" (i32.const 0)) "unreachable")
+(assert_trap (invoke "select-trap-right" (i32.const 1)) "unreachable")
+(assert_trap (invoke "select-trap-right" (i32.const 0)) "unreachable")
+
+(assert_trap (invoke "select-unreached-result1") "unreachable")
+(assert_trap (invoke "select-unreached-result2") "unreachable")
+(assert_trap (invoke "select-unreached-num") "unreachable")
+(assert_trap (invoke "select-unreached-ref") "unreachable")
+
+(assert_trap (invoke "call_ref-unreached") "unreachable")
+
+
+;; Validation after unreachable
+
+(module
+  (func (export "meet-bottom")
+    (block (result f64)
+      (block (result f32)
+        (unreachable)
+        (br_table 0 1 1 (i32.const 1))
+      )
+      (drop)
+      (f64.const 0)
+    )
+    (drop)
+  )
+)
+
+(assert_trap (invoke "meet-bottom") "unreachable")
+
+
+;; Bottom heap type
+
+(module
+  (func (result (ref func))
+    (unreachable)
+    (ref.as_non_null)
+  )
+  (func (result (ref extern))
+    (unreachable)
+    (ref.as_non_null)
+  )
+
+  (func (result (ref func))
+    (block (result funcref)
+      (unreachable)
+      (br_on_null 0)
+      (return)
+    )
+    (unreachable)
+  )
+  (func (result (ref extern))
+    (block (result externref)
+      (unreachable)
+      (br_on_null 0)
+      (return)
+    )
+    (unreachable)
+  )
+)
diff --git a/tests/wast/spec/proposals/gc/utf8-custom-section-id.wast b/tests/wast/spec/proposals/gc/utf8-custom-section-id.wast
new file mode 100644
index 0000000000..ee5fd7ccb7
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/utf8-custom-section-id.wast
@@ -0,0 +1,1792 @@
+;;;;;; Invalid UTF-8 custom section names
+
+;;;; Continuation bytes not preceded by prefixes
+
+;; encoding starts with (first) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\80"                       ;; "\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0x8f) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\8f"                       ;; "\8f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0x90) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\90"                       ;; "\90"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0x9f) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\9f"                       ;; "\9f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0xa0) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\a0"                       ;; "\a0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (last) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\bf"                       ;; "\bf"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 2-byte sequences
+
+;; 2-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\c2\80\80"                 ;; "\c2\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 2-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\c2"                       ;; "\c2"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 2-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c2\2e"                    ;; "\c2."
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 2-byte sequence contents
+
+;; overlong encoding after 0xc0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c0\80"                    ;; "\c0\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c0\bf"                    ;; "\c0\bf"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc1 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c1\80"                    ;; "\c1\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc1 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c1\bf"                    ;; "\c1\bf"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a contination byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c2\00"                    ;; "\c2\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c2\7f"                    ;; "\c2\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c2\c0"                    ;; "\c2\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c2\fd"                    ;; "\c2\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\df\00"                    ;; "\df\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\df\7f"                    ;; "\df\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\df\c0"                    ;; "\df\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\df\fd"                    ;; "\df\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 3-byte sequences
+
+;; 3-byte sequence contains 4 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\e1\80\80\80"              ;; "\e1\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\e1\80"                    ;; "\e1\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\80\2e"                 ;; "\e1\80."
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\e1"                       ;; "\e1"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\e1\2e"                    ;; "\e1."
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 3-byte sequence contents
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\00\a0"                 ;; "\e0\00\a0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\7f\a0"                 ;; "\e0\7f\a0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\80\80"                 ;; "\e0\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\80\a0"                 ;; "\e0\80\a0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\9f\a0"                 ;; "\e0\9f\a0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\9f\bf"                 ;; "\e0\9f\bf"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\c0\a0"                 ;; "\e0\c0\a0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\fd\a0"                 ;; "\e0\fd\a0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\00\80"                 ;; "\e1\00\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\7f\80"                 ;; "\e1\7f\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\c0\80"                 ;; "\e1\c0\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\fd\80"                 ;; "\e1\fd\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\00\80"                 ;; "\ec\00\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\7f\80"                 ;; "\ec\7f\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\c0\80"                 ;; "\ec\c0\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\fd\80"                 ;; "\ec\fd\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\00\80"                 ;; "\ed\00\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\7f\80"                 ;; "\ed\7f\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\a0\80"                 ;; "\ed\a0\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\a0\bf"                 ;; "\ed\a0\bf"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\bf\80"                 ;; "\ed\bf\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\bf\bf"                 ;; "\ed\bf\bf"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\c0\80"                 ;; "\ed\c0\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\fd\80"                 ;; "\ed\fd\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\00\80"                 ;; "\ee\00\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\7f\80"                 ;; "\ee\7f\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\c0\80"                 ;; "\ee\c0\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\fd\80"                 ;; "\ee\fd\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\00\80"                 ;; "\ef\00\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\7f\80"                 ;; "\ef\7f\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\c0\80"                 ;; "\ef\c0\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\fd\80"                 ;; "\ef\fd\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 3-byte sequence contents (third byte)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\a0\00"                 ;; "\e0\a0\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\a0\7f"                 ;; "\e0\a0\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\a0\c0"                 ;; "\e0\a0\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\a0\fd"                 ;; "\e0\a0\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\80\00"                 ;; "\e1\80\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\80\7f"                 ;; "\e1\80\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\80\c0"                 ;; "\e1\80\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\80\fd"                 ;; "\e1\80\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\80\00"                 ;; "\ec\80\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\80\7f"                 ;; "\ec\80\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\80\c0"                 ;; "\ec\80\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\80\fd"                 ;; "\ec\80\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\80\00"                 ;; "\ed\80\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\80\7f"                 ;; "\ed\80\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\80\c0"                 ;; "\ed\80\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\80\fd"                 ;; "\ed\80\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\80\00"                 ;; "\ee\80\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\80\7f"                 ;; "\ee\80\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\80\c0"                 ;; "\ee\80\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\80\fd"                 ;; "\ee\80\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\80\00"                 ;; "\ef\80\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\80\7f"                 ;; "\ef\80\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\80\c0"                 ;; "\ef\80\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\80\fd"                 ;; "\ef\80\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequences
+
+;; 4-byte sequence contains 5 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\06"                       ;; custom section
+    "\05\f1\80\80\80\80"           ;; "\f1\80\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\f1\80\80"                 ;; "\f1\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\80\23"              ;; "\f1\80\80#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\f1\80"                    ;; "\f1\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\f1\80\23"                 ;; "\f1\80#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\f1"                       ;; "\f1"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\f1\23"                    ;; "\f1#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\00\90\90"              ;; "\f0\00\90\90"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\7f\90\90"              ;; "\f0\7f\90\90"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\80\80\80"              ;; "\f0\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\80\90\90"              ;; "\f0\80\90\90"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\8f\90\90"              ;; "\f0\8f\90\90"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\8f\bf\bf"              ;; "\f0\8f\bf\bf"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\c0\90\90"              ;; "\f0\c0\90\90"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\fd\90\90"              ;; "\f0\fd\90\90"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\00\80\80"              ;; "\f1\00\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\7f\80\80"              ;; "\f1\7f\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\c0\80\80"              ;; "\f1\c0\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\fd\80\80"              ;; "\f1\fd\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\00\80\80"              ;; "\f3\00\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\7f\80\80"              ;; "\f3\7f\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\c0\80\80"              ;; "\f3\c0\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\fd\80\80"              ;; "\f3\fd\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\00\80\80"              ;; "\f4\00\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\7f\80\80"              ;; "\f4\7f\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (first) malformed code point
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\90\80\80"              ;; "\f4\90\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; malformed code point
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\bf\80\80"              ;; "\f4\bf\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\c0\80\80"              ;; "\f4\c0\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\fd\80\80"              ;; "\f4\fd\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (first) malformed 4-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f5\80\80\80"              ;; "\f5\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 4-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f7\80\80\80"              ;; "\f7\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 4-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f7\bf\bf\bf"              ;; "\f7\bf\bf\bf"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents (third byte)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\00\90"              ;; "\f0\90\00\90"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\7f\90"              ;; "\f0\90\7f\90"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\c0\90"              ;; "\f0\90\c0\90"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\fd\90"              ;; "\f0\90\fd\90"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\00\80"              ;; "\f1\80\00\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\7f\80"              ;; "\f1\80\7f\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\c0\80"              ;; "\f1\80\c0\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\fd\80"              ;; "\f1\80\fd\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\00\80"              ;; "\f3\80\00\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\7f\80"              ;; "\f3\80\7f\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\c0\80"              ;; "\f3\80\c0\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\fd\80"              ;; "\f3\80\fd\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\00\80"              ;; "\f4\80\00\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\7f\80"              ;; "\f4\80\7f\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\c0\80"              ;; "\f4\80\c0\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\fd\80"              ;; "\f4\80\fd\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents (fourth byte)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\90\00"              ;; "\f0\90\90\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\90\7f"              ;; "\f0\90\90\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\90\c0"              ;; "\f0\90\90\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\90\fd"              ;; "\f0\90\90\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\80\00"              ;; "\f1\80\80\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\80\7f"              ;; "\f1\80\80\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\80\c0"              ;; "\f1\80\80\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\80\fd"              ;; "\f1\80\80\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\80\00"              ;; "\f3\80\80\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\80\7f"              ;; "\f3\80\80\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\80\c0"              ;; "\f3\80\80\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\80\fd"              ;; "\f3\80\80\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\80\00"              ;; "\f4\80\80\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\80\7f"              ;; "\f4\80\80\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\80\c0"              ;; "\f4\80\80\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\80\fd"              ;; "\f4\80\80\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 5-byte sequences
+
+;; 5-byte sequence contains 6 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\07"                       ;; custom section
+    "\06\f8\80\80\80\80\80"        ;; "\f8\80\80\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 4 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f8\80\80\80"              ;; "\f8\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 4 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\06"                       ;; custom section
+    "\05\f8\80\80\80\23"           ;; "\f8\80\80\80#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\f8\80\80"                 ;; "\f8\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f8\80\80\23"              ;; "\f8\80\80#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\f8\80"                    ;; "\f8\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\f8\80\23"                 ;; "\f8\80#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\f8"                       ;; "\f8"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\f8\23"                    ;; "\f8#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 5-byte sequence contents
+
+;; (first) malformed 5-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\06"                       ;; custom section
+    "\05\f8\80\80\80\80"           ;; "\f8\80\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 5-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\06"                       ;; custom section
+    "\05\fb\bf\bf\bf\bf"           ;; "\fb\bf\bf\bf\bf"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 6-byte sequences
+
+;; 6-byte sequence contains 7 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\08"                       ;; custom section
+    "\07\fc\80\80\80\80\80\80"     ;; "\fc\80\80\80\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 5 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\06"                       ;; custom section
+    "\05\fc\80\80\80\80"           ;; "\fc\80\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 5 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\07"                       ;; custom section
+    "\06\fc\80\80\80\80\23"        ;; "\fc\80\80\80\80#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 4 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\fc\80\80\80"              ;; "\fc\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 4 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\06"                       ;; custom section
+    "\05\fc\80\80\80\23"           ;; "\fc\80\80\80#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\fc\80\80"                 ;; "\fc\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\fc\80\80\23"              ;; "\fc\80\80#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\fc\80"                    ;; "\fc\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\fc\80\23"                 ;; "\fc\80#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\fc"                       ;; "\fc"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\fc\23"                    ;; "\fc#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 6-byte sequence contents
+
+;; (first) malformed 6-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\07"                       ;; custom section
+    "\06\fc\80\80\80\80\80"        ;; "\fc\80\80\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 6-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\07"                       ;; custom section
+    "\06\fd\bf\bf\bf\bf\bf"        ;; "\fd\bf\bf\bf\bf\bf"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; Miscellaneous malformed bytes
+
+;; malformed byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\fe"                       ;; "\fe"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; malformed byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\ff"                       ;; "\ff"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-16BE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\fe\ff"                    ;; "\fe\ff"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-32BE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\00\00\fe\ff"              ;; "\00\00\fe\ff"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-16LE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\ff\fe"                    ;; "\ff\fe"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-32LE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\ff\fe\00\00"              ;; "\ff\fe\00\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
diff --git a/tests/wast/spec/proposals/gc/utf8-import-field.wast b/tests/wast/spec/proposals/gc/utf8-import-field.wast
new file mode 100644
index 0000000000..0d030dabb1
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/utf8-import-field.wast
@@ -0,0 +1,2672 @@
+;;;;;; Invalid UTF-8 import field names
+
+;;;; Continuation bytes not preceded by prefixes
+
+;; encoding starts with (first) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\80"                       ;; "\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0x8f) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\8f"                       ;; "\8f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0x90) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\90"                       ;; "\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0x9f) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\9f"                       ;; "\9f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0xa0) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\a0"                       ;; "\a0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (last) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\bf"                       ;; "\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 2-byte sequences
+
+;; 2-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\c2\80\80"                 ;; "\c2\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 2-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\c2"                       ;; "\c2"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 2-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c2\2e"                    ;; "\c2."
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 2-byte sequence contents
+
+;; overlong encoding after 0xc0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c0\80"                    ;; "\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c0\bf"                    ;; "\c0\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc1 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c1\80"                    ;; "\c1\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc1 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c1\bf"                    ;; "\c1\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a contination byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c2\00"                    ;; "\c2\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c2\7f"                    ;; "\c2\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c2\c0"                    ;; "\c2\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c2\fd"                    ;; "\c2\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\df\00"                    ;; "\df\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\df\7f"                    ;; "\df\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\df\c0"                    ;; "\df\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\df\fd"                    ;; "\df\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 3-byte sequences
+
+;; 3-byte sequence contains 4 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\e1\80\80\80"              ;; "\e1\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\e1\80"                    ;; "\e1\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\80\2e"                 ;; "\e1\80."
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\e1"                       ;; "\e1"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\e1\2e"                    ;; "\e1."
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 3-byte sequence contents
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\00\a0"                 ;; "\e0\00\a0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\7f\a0"                 ;; "\e0\7f\a0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\80\80"                 ;; "\e0\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\80\a0"                 ;; "\e0\80\a0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\9f\a0"                 ;; "\e0\9f\a0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\9f\bf"                 ;; "\e0\9f\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\c0\a0"                 ;; "\e0\c0\a0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\fd\a0"                 ;; "\e0\fd\a0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\00\80"                 ;; "\e1\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\7f\80"                 ;; "\e1\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\c0\80"                 ;; "\e1\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\fd\80"                 ;; "\e1\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\00\80"                 ;; "\ec\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\7f\80"                 ;; "\ec\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\c0\80"                 ;; "\ec\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\fd\80"                 ;; "\ec\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\00\80"                 ;; "\ed\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\7f\80"                 ;; "\ed\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\a0\80"                 ;; "\ed\a0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\a0\bf"                 ;; "\ed\a0\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\bf\80"                 ;; "\ed\bf\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\bf\bf"                 ;; "\ed\bf\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\c0\80"                 ;; "\ed\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\fd\80"                 ;; "\ed\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\00\80"                 ;; "\ee\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\7f\80"                 ;; "\ee\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\c0\80"                 ;; "\ee\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\fd\80"                 ;; "\ee\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\00\80"                 ;; "\ef\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\7f\80"                 ;; "\ef\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\c0\80"                 ;; "\ef\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\fd\80"                 ;; "\ef\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 3-byte sequence contents (third byte)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\a0\00"                 ;; "\e0\a0\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\a0\7f"                 ;; "\e0\a0\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\a0\c0"                 ;; "\e0\a0\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\a0\fd"                 ;; "\e0\a0\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\80\00"                 ;; "\e1\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\80\7f"                 ;; "\e1\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\80\c0"                 ;; "\e1\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\80\fd"                 ;; "\e1\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\80\00"                 ;; "\ec\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\80\7f"                 ;; "\ec\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\80\c0"                 ;; "\ec\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\80\fd"                 ;; "\ec\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\80\00"                 ;; "\ed\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\80\7f"                 ;; "\ed\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\80\c0"                 ;; "\ed\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\80\fd"                 ;; "\ed\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\80\00"                 ;; "\ee\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\80\7f"                 ;; "\ee\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\80\c0"                 ;; "\ee\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\80\fd"                 ;; "\ee\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\80\00"                 ;; "\ef\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\80\7f"                 ;; "\ef\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\80\c0"                 ;; "\ef\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\80\fd"                 ;; "\ef\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequences
+
+;; 4-byte sequence contains 5 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\05\f1\80\80\80\80"           ;; "\f1\80\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\f1\80\80"                 ;; "\f1\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\80\23"              ;; "\f1\80\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\f1\80"                    ;; "\f1\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\f1\80\23"                 ;; "\f1\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\f1"                       ;; "\f1"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\f1\23"                    ;; "\f1#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\00\90\90"              ;; "\f0\00\90\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\7f\90\90"              ;; "\f0\7f\90\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\80\80\80"              ;; "\f0\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\80\90\90"              ;; "\f0\80\90\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\8f\90\90"              ;; "\f0\8f\90\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\8f\bf\bf"              ;; "\f0\8f\bf\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\c0\90\90"              ;; "\f0\c0\90\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\fd\90\90"              ;; "\f0\fd\90\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\00\80\80"              ;; "\f1\00\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\7f\80\80"              ;; "\f1\7f\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\c0\80\80"              ;; "\f1\c0\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\fd\80\80"              ;; "\f1\fd\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\00\80\80"              ;; "\f3\00\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\7f\80\80"              ;; "\f3\7f\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\c0\80\80"              ;; "\f3\c0\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\fd\80\80"              ;; "\f3\fd\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\00\80\80"              ;; "\f4\00\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\7f\80\80"              ;; "\f4\7f\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (first) malformed code point
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\90\80\80"              ;; "\f4\90\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; malformed code point
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\bf\80\80"              ;; "\f4\bf\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\c0\80\80"              ;; "\f4\c0\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\fd\80\80"              ;; "\f4\fd\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (first) malformed 4-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f5\80\80\80"              ;; "\f5\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 4-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f7\80\80\80"              ;; "\f7\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 4-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f7\bf\bf\bf"              ;; "\f7\bf\bf\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents (third byte)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\00\90"              ;; "\f0\90\00\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\7f\90"              ;; "\f0\90\7f\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\c0\90"              ;; "\f0\90\c0\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\fd\90"              ;; "\f0\90\fd\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\00\80"              ;; "\f1\80\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\7f\80"              ;; "\f1\80\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\c0\80"              ;; "\f1\80\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\fd\80"              ;; "\f1\80\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\00\80"              ;; "\f3\80\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\7f\80"              ;; "\f3\80\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\c0\80"              ;; "\f3\80\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\fd\80"              ;; "\f3\80\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\00\80"              ;; "\f4\80\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\7f\80"              ;; "\f4\80\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\c0\80"              ;; "\f4\80\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\fd\80"              ;; "\f4\80\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents (fourth byte)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\90\00"              ;; "\f0\90\90\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\90\7f"              ;; "\f0\90\90\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\90\c0"              ;; "\f0\90\90\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\90\fd"              ;; "\f0\90\90\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\80\00"              ;; "\f1\80\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\80\7f"              ;; "\f1\80\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\80\c0"              ;; "\f1\80\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\80\fd"              ;; "\f1\80\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\80\00"              ;; "\f3\80\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\80\7f"              ;; "\f3\80\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\80\c0"              ;; "\f3\80\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\80\fd"              ;; "\f3\80\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\80\00"              ;; "\f4\80\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\80\7f"              ;; "\f4\80\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\80\c0"              ;; "\f4\80\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\80\fd"              ;; "\f4\80\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 5-byte sequences
+
+;; 5-byte sequence contains 6 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\06\f8\80\80\80\80\80"        ;; "\f8\80\80\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 4 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f8\80\80\80"              ;; "\f8\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 4 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\05\f8\80\80\80\23"           ;; "\f8\80\80\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\f8\80\80"                 ;; "\f8\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f8\80\80\23"              ;; "\f8\80\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\f8\80"                    ;; "\f8\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\f8\80\23"                 ;; "\f8\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\f8"                       ;; "\f8"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\f8\23"                    ;; "\f8#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 5-byte sequence contents
+
+;; (first) malformed 5-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\05\f8\80\80\80\80"           ;; "\f8\80\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 5-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\05\fb\bf\bf\bf\bf"           ;; "\fb\bf\bf\bf\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 6-byte sequences
+
+;; 6-byte sequence contains 7 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\11"                       ;; import section
+    "\01"                          ;; length 1
+    "\07\fc\80\80\80\80\80\80"     ;; "\fc\80\80\80\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 5 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\05\fc\80\80\80\80"           ;; "\fc\80\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 5 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\06\fc\80\80\80\80\23"        ;; "\fc\80\80\80\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 4 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\fc\80\80\80"              ;; "\fc\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 4 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\05\fc\80\80\80\23"           ;; "\fc\80\80\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\fc\80\80"                 ;; "\fc\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\fc\80\80\23"              ;; "\fc\80\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\fc\80"                    ;; "\fc\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\fc\80\23"                 ;; "\fc\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\fc"                       ;; "\fc"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\fc\23"                    ;; "\fc#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 6-byte sequence contents
+
+;; (first) malformed 6-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\06\fc\80\80\80\80\80"        ;; "\fc\80\80\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 6-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\06\fd\bf\bf\bf\bf\bf"        ;; "\fd\bf\bf\bf\bf\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; Miscellaneous malformed bytes
+
+;; malformed byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\fe"                       ;; "\fe"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; malformed byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\ff"                       ;; "\ff"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-16BE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\fe\ff"                    ;; "\fe\ff"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-32BE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\00\00\fe\ff"              ;; "\00\00\fe\ff"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-16LE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\ff\fe"                    ;; "\ff\fe"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-32LE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\ff\fe\00\00"              ;; "\ff\fe\00\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
diff --git a/tests/wast/spec/proposals/gc/utf8-import-module.wast b/tests/wast/spec/proposals/gc/utf8-import-module.wast
new file mode 100644
index 0000000000..5a092da08a
--- /dev/null
+++ b/tests/wast/spec/proposals/gc/utf8-import-module.wast
@@ -0,0 +1,2672 @@
+;;;;;; Invalid UTF-8 import module names
+
+;;;; Continuation bytes not preceded by prefixes
+
+;; encoding starts with (first) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\80"                       ;; "\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0x8f) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\8f"                       ;; "\8f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0x90) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\90"                       ;; "\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0x9f) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\9f"                       ;; "\9f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0xa0) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\a0"                       ;; "\a0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (last) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\bf"                       ;; "\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 2-byte sequences
+
+;; 2-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\c2\80\80"                 ;; "\c2\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 2-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\c2"                       ;; "\c2"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 2-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c2\2e"                    ;; "\c2."
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 2-byte sequence contents
+
+;; overlong encoding after 0xc0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c0\80"                    ;; "\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c0\bf"                    ;; "\c0\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc1 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c1\80"                    ;; "\c1\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc1 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c1\bf"                    ;; "\c1\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a contination byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c2\00"                    ;; "\c2\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c2\7f"                    ;; "\c2\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c2\c0"                    ;; "\c2\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c2\fd"                    ;; "\c2\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\df\00"                    ;; "\df\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\df\7f"                    ;; "\df\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\df\c0"                    ;; "\df\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\df\fd"                    ;; "\df\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 3-byte sequences
+
+;; 3-byte sequence contains 4 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\e1\80\80\80"              ;; "\e1\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\e1\80"                    ;; "\e1\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\80\2e"                 ;; "\e1\80."
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\e1"                       ;; "\e1"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\e1\2e"                    ;; "\e1."
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 3-byte sequence contents
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\00\a0"                 ;; "\e0\00\a0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\7f\a0"                 ;; "\e0\7f\a0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\80\80"                 ;; "\e0\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\80\a0"                 ;; "\e0\80\a0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\9f\a0"                 ;; "\e0\9f\a0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\9f\bf"                 ;; "\e0\9f\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\c0\a0"                 ;; "\e0\c0\a0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\fd\a0"                 ;; "\e0\fd\a0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\00\80"                 ;; "\e1\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\7f\80"                 ;; "\e1\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\c0\80"                 ;; "\e1\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\fd\80"                 ;; "\e1\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\00\80"                 ;; "\ec\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\7f\80"                 ;; "\ec\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\c0\80"                 ;; "\ec\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\fd\80"                 ;; "\ec\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\00\80"                 ;; "\ed\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\7f\80"                 ;; "\ed\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\a0\80"                 ;; "\ed\a0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\a0\bf"                 ;; "\ed\a0\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\bf\80"                 ;; "\ed\bf\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\bf\bf"                 ;; "\ed\bf\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\c0\80"                 ;; "\ed\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\fd\80"                 ;; "\ed\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\00\80"                 ;; "\ee\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\7f\80"                 ;; "\ee\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\c0\80"                 ;; "\ee\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\fd\80"                 ;; "\ee\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\00\80"                 ;; "\ef\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\7f\80"                 ;; "\ef\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\c0\80"                 ;; "\ef\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\fd\80"                 ;; "\ef\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 3-byte sequence contents (third byte)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\a0\00"                 ;; "\e0\a0\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\a0\7f"                 ;; "\e0\a0\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\a0\c0"                 ;; "\e0\a0\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\a0\fd"                 ;; "\e0\a0\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\80\00"                 ;; "\e1\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\80\7f"                 ;; "\e1\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\80\c0"                 ;; "\e1\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\80\fd"                 ;; "\e1\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\80\00"                 ;; "\ec\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\80\7f"                 ;; "\ec\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\80\c0"                 ;; "\ec\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\80\fd"                 ;; "\ec\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\80\00"                 ;; "\ed\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\80\7f"                 ;; "\ed\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\80\c0"                 ;; "\ed\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\80\fd"                 ;; "\ed\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\80\00"                 ;; "\ee\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\80\7f"                 ;; "\ee\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\80\c0"                 ;; "\ee\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\80\fd"                 ;; "\ee\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\80\00"                 ;; "\ef\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\80\7f"                 ;; "\ef\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\80\c0"                 ;; "\ef\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\80\fd"                 ;; "\ef\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequences
+
+;; 4-byte sequence contains 5 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\05\f1\80\80\80\80"           ;; "\f1\80\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\f1\80\80"                 ;; "\f1\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\80\23"              ;; "\f1\80\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\f1\80"                    ;; "\f1\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\f1\80\23"                 ;; "\f1\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\f1"                       ;; "\f1"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\f1\23"                    ;; "\f1#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\00\90\90"              ;; "\f0\00\90\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\7f\90\90"              ;; "\f0\7f\90\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\80\80\80"              ;; "\f0\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\80\90\90"              ;; "\f0\80\90\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\8f\90\90"              ;; "\f0\8f\90\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\8f\bf\bf"              ;; "\f0\8f\bf\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\c0\90\90"              ;; "\f0\c0\90\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\fd\90\90"              ;; "\f0\fd\90\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\00\80\80"              ;; "\f1\00\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\7f\80\80"              ;; "\f1\7f\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\c0\80\80"              ;; "\f1\c0\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\fd\80\80"              ;; "\f1\fd\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\00\80\80"              ;; "\f3\00\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\7f\80\80"              ;; "\f3\7f\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\c0\80\80"              ;; "\f3\c0\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\fd\80\80"              ;; "\f3\fd\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\00\80\80"              ;; "\f4\00\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\7f\80\80"              ;; "\f4\7f\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (first) malformed code point
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\90\80\80"              ;; "\f4\90\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; malformed code point
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\bf\80\80"              ;; "\f4\bf\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\c0\80\80"              ;; "\f4\c0\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\fd\80\80"              ;; "\f4\fd\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (first) malformed 4-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f5\80\80\80"              ;; "\f5\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 4-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f7\80\80\80"              ;; "\f7\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 4-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f7\bf\bf\bf"              ;; "\f7\bf\bf\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents (third byte)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\00\90"              ;; "\f0\90\00\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\7f\90"              ;; "\f0\90\7f\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\c0\90"              ;; "\f0\90\c0\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\fd\90"              ;; "\f0\90\fd\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\00\80"              ;; "\f1\80\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\7f\80"              ;; "\f1\80\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\c0\80"              ;; "\f1\80\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\fd\80"              ;; "\f1\80\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\00\80"              ;; "\f3\80\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\7f\80"              ;; "\f3\80\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\c0\80"              ;; "\f3\80\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\fd\80"              ;; "\f3\80\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\00\80"              ;; "\f4\80\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\7f\80"              ;; "\f4\80\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\c0\80"              ;; "\f4\80\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\fd\80"              ;; "\f4\80\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents (fourth byte)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\90\00"              ;; "\f0\90\90\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\90\7f"              ;; "\f0\90\90\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\90\c0"              ;; "\f0\90\90\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\90\fd"              ;; "\f0\90\90\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\80\00"              ;; "\f1\80\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\80\7f"              ;; "\f1\80\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\80\c0"              ;; "\f1\80\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\80\fd"              ;; "\f1\80\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\80\00"              ;; "\f3\80\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\80\7f"              ;; "\f3\80\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\80\c0"              ;; "\f3\80\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\80\fd"              ;; "\f3\80\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\80\00"              ;; "\f4\80\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\80\7f"              ;; "\f4\80\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\80\c0"              ;; "\f4\80\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\80\fd"              ;; "\f4\80\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 5-byte sequences
+
+;; 5-byte sequence contains 6 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\06\f8\80\80\80\80\80"        ;; "\f8\80\80\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 4 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f8\80\80\80"              ;; "\f8\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 4 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\05\f8\80\80\80\23"           ;; "\f8\80\80\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\f8\80\80"                 ;; "\f8\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f8\80\80\23"              ;; "\f8\80\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\f8\80"                    ;; "\f8\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\f8\80\23"                 ;; "\f8\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\f8"                       ;; "\f8"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\f8\23"                    ;; "\f8#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 5-byte sequence contents
+
+;; (first) malformed 5-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\05\f8\80\80\80\80"           ;; "\f8\80\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 5-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\05\fb\bf\bf\bf\bf"           ;; "\fb\bf\bf\bf\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 6-byte sequences
+
+;; 6-byte sequence contains 7 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\11"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\07\fc\80\80\80\80\80\80"     ;; "\fc\80\80\80\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 5 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\05\fc\80\80\80\80"           ;; "\fc\80\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 5 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\06\fc\80\80\80\80\23"        ;; "\fc\80\80\80\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 4 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\fc\80\80\80"              ;; "\fc\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 4 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\05\fc\80\80\80\23"           ;; "\fc\80\80\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\fc\80\80"                 ;; "\fc\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\fc\80\80\23"              ;; "\fc\80\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\fc\80"                    ;; "\fc\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\fc\80\23"                 ;; "\fc\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\fc"                       ;; "\fc"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\fc\23"                    ;; "\fc#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 6-byte sequence contents
+
+;; (first) malformed 6-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\06\fc\80\80\80\80\80"        ;; "\fc\80\80\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 6-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\06\fd\bf\bf\bf\bf\bf"        ;; "\fd\bf\bf\bf\bf\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; Miscellaneous malformed bytes
+
+;; malformed byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\fe"                       ;; "\fe"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; malformed byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\ff"                       ;; "\ff"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-16BE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\fe\ff"                    ;; "\fe\ff"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-32BE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\00\00\fe\ff"              ;; "\00\00\fe\ff"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-16LE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\ff\fe"                    ;; "\ff\fe"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-32LE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\ff\fe\00\00"              ;; "\ff\fe\00\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
diff --git a/tests/wast/spec/proposals/mutable-global/globals.wast b/tests/wast/spec/proposals/mutable-global/globals.wast
index 175af36791..cc799fef5a 100644
--- a/tests/wast/spec/proposals/mutable-global/globals.wast
+++ b/tests/wast/spec/proposals/mutable-global/globals.wast
@@ -1,4 +1,5 @@
 ;; Test globals
+;; xdoardo (2024/09/06): These tests are not in the reference test suite anymore. We keep them for now, but adapt them to "new" keywords (e.g. local.get -> local.get)
 
 (module
   (global $a i32 (i32.const -2))
@@ -15,15 +16,15 @@
   (func (export "get-b") (result i64) (get_global $b))
   (func (export "get-x") (result i32) (get_global $x))
   (func (export "get-y") (result i64) (get_global $y))
-  (func (export "set-x") (param i32) (set_global $x (get_local 0)))
-  (func (export "set-y") (param i64) (set_global $y (get_local 0)))
+  (func (export "set-x") (param i32) (set_global $x (local.get 0)))
+  (func (export "set-y") (param i64) (set_global $y (local.get 0)))
 
   (func (export "get-1") (result f32) (get_global 1))
   (func (export "get-2") (result f64) (get_global 2))
   (func (export "get-5") (result f32) (get_global 5))
   (func (export "get-6") (result f64) (get_global 6))
-  (func (export "set-5") (param f32) (set_global 5 (get_local 0)))
-  (func (export "set-6") (param f64) (set_global 6 (get_local 0)))
+  (func (export "set-5") (param f32) (set_global 5 (local.get 0)))
+  (func (export "set-6") (param f64) (set_global 6 (local.get 0)))
 )
 
 (assert_return (invoke "get-a") (i32.const -2))
@@ -61,7 +62,7 @@
 )
 
 (assert_invalid
-  (module (global f32 (get_local 0)))
+  (module (global f32 (local.get 0)))
   "constant expression required"
 )
 
diff --git a/tests/wast/spec/proposals/mutable-global/linking.wast b/tests/wast/spec/proposals/mutable-global/linking.wast
index e2fc8b8f25..88691346e9 100644
--- a/tests/wast/spec/proposals/mutable-global/linking.wast
+++ b/tests/wast/spec/proposals/mutable-global/linking.wast
@@ -1,4 +1,5 @@
 ;; Functions
+;; xdoardo (2024/09/06): These tests are not in the reference test suite anymore. We keep them for now, but adapt them to "new" keywords (e.g. local.get -> local.get, etc..)
 
 (module $Mf
   (func (export "call") (result i32) (call $g))
@@ -43,7 +44,7 @@
   ;; export mutable globals
   (global $mut_glob (export "mut_glob") (mut i32) (i32.const 142))
   (func (export "get_mut") (result i32) (get_global $mut_glob))
-  (func (export "set_mut") (param i32) (set_global $mut_glob (get_local 0)))
+  (func (export "set_mut") (param i32) (set_global $mut_glob (local.get 0)))
 )
 (register "Mg" $Mg)
 
@@ -98,13 +99,13 @@
   (type (func (result i32)))
   (type (func))
 
-  (table (export "tab") 10 anyfunc)
+  (table (export "tab") 10 funcref)
   (elem (i32.const 2) $g $g $g $g)
   (func $g (result i32) (i32.const 4))
   (func (export "h") (result i32) (i32.const -4))
 
   (func (export "call") (param i32) (result i32)
-    (call_indirect (type 0) (get_local 0))
+    (call_indirect (type 0) (local.get 0))
   )
 )
 (register "Mt" $Mt)
@@ -116,15 +117,15 @@
   (func $f (import "Mt" "call") (param i32) (result i32))
   (func $h (import "Mt" "h") (result i32))
 
-  (table anyfunc (elem $g $g $g $h $f))
+  (table funcref (elem $g $g $g $h $f))
   (func $g (result i32) (i32.const 5))
 
   (export "Mt.call" (func $f))
   (func (export "call Mt.call") (param i32) (result i32)
-    (call $f (get_local 0))
+    (call $f (local.get 0))
   )
   (func (export "call") (param i32) (result i32)
-    (call_indirect (type 1) (get_local 0))
+    (call_indirect (type 1) (local.get 0))
   )
 )
 
@@ -155,12 +156,12 @@
   (type (func (result i32)))
 
   (func $h (import "Mt" "h") (result i32))
-  (table (import "Mt" "tab") 5 anyfunc)
+  (table (import "Mt" "tab") 5 funcref)
   (elem (i32.const 1) $i $h)
   (func $i (result i32) (i32.const 6))
 
   (func (export "call") (param i32) (result i32)
-    (call_indirect (type 0) (get_local 0))
+    (call_indirect (type 0) (local.get 0))
   )
 )
 
@@ -190,7 +191,7 @@
 (assert_trap (invoke $Ot "call" (i32.const 20)) "undefined")
 
 (module
-  (table (import "Mt" "tab") 0 anyfunc)
+  (table (import "Mt" "tab") 0 funcref)
   (elem (i32.const 9) $f)
   (func $f)
 )
@@ -205,7 +206,7 @@
 
 (assert_unlinkable
   (module
-    (table (import "Mt" "tab") 0 anyfunc)
+    (table (import "Mt" "tab") 0 funcref)
     (elem (i32.const 10) $f)
     (func $f)
   )
@@ -214,7 +215,7 @@
 
 (assert_unlinkable
   (module
-    (table (import "Mt" "tab") 10 anyfunc)
+    (table (import "Mt" "tab") 10 funcref)
     (memory (import "Mt" "mem") 1)  ;; does not exist
     (func $f (result i32) (i32.const 0))
     (elem (i32.const 7) $f)
@@ -226,7 +227,7 @@
 
 (assert_unlinkable
   (module
-    (table (import "Mt" "tab") 10 anyfunc)
+    (table (import "Mt" "tab") 10 funcref)
     (func $f (result i32) (i32.const 0))
     (elem (i32.const 7) $f)
     (elem (i32.const 12) $f)  ;; out of bounds
@@ -237,7 +238,7 @@
 
 (assert_unlinkable
   (module
-    (table (import "Mt" "tab") 10 anyfunc)
+    (table (import "Mt" "tab") 10 funcref)
     (func $f (result i32) (i32.const 0))
     (elem (i32.const 7) $f)
     (memory 1)
@@ -255,7 +256,7 @@
   (data (i32.const 10) "\00\01\02\03\04\05\06\07\08\09")
 
   (func (export "load") (param $a i32) (result i32)
-    (i32.load8_u (get_local 0))
+    (i32.load8_u (local.get 0))
   )
 )
 (register "Mm" $Mm)
@@ -268,7 +269,7 @@
 
   (export "Mm.load" (func $loadM))
   (func (export "load") (param $a i32) (result i32)
-    (i32.load8_u (get_local 0))
+    (i32.load8_u (local.get 0))
   )
 )
 
@@ -281,7 +282,7 @@
   (data (i32.const 5) "\a0\a1\a2\a3\a4\a5\a6\a7")
 
   (func (export "load") (param $a i32) (result i32)
-    (i32.load8_u (get_local 0))
+    (i32.load8_u (local.get 0))
   )
 )
 
@@ -307,7 +308,7 @@
   (memory (import "Mm" "mem") 1 8)
 
   (func (export "grow") (param $a i32) (result i32)
-    (memory.grow (get_local 0))
+    (memory.grow (local.get 0))
   )
 )
 
@@ -324,7 +325,7 @@
   (module
     (func $host (import "spectest" "print"))
     (memory (import "Mm" "mem") 1)
-    (table (import "Mm" "tab") 0 anyfunc)  ;; does not exist
+    (table (import "Mm" "tab") 0 funcref)  ;; does not exist
     (data (i32.const 0) "abc")
   )
   "unknown import"
@@ -345,7 +346,7 @@
   (module
     (memory (import "Mm" "mem") 1)
     (data (i32.const 0) "abc")
-    (table 0 anyfunc)
+    (table 0 funcref)
     (func)
     (elem (i32.const 0) 0) ;; out of bounds
   )
diff --git a/tests/wast/spec/select.wast b/tests/wast/spec/select.wast
index b343bf93cb..673dcf478d 100644
--- a/tests/wast/spec/select.wast
+++ b/tests/wast/spec/select.wast
@@ -36,31 +36,6 @@
     (select (result externref) (local.get 0) (local.get 1) (local.get 2))
   )
 
-  ;; Check that both sides of the select are evaluated
-  (func (export "select-trap-left") (param $cond i32) (result i32)
-    (select (unreachable) (i32.const 0) (local.get $cond))
-  )
-  (func (export "select-trap-right") (param $cond i32) (result i32)
-    (select (i32.const 0) (unreachable) (local.get $cond))
-  )
-
-  (func (export "select-unreached")
-    (unreachable) (select)
-    (unreachable) (i32.const 0) (select)
-    (unreachable) (i32.const 0) (i32.const 0) (select)
-    (unreachable) (i32.const 0) (i32.const 0) (i32.const 0) (select)
-    (unreachable) (f32.const 0) (i32.const 0) (select)
-    (unreachable)
-  )
-
-  (func (export "select_unreached_result_1") (result i32)
-    (unreachable) (i32.add (select))
-  )
-
-  (func (export "select_unreached_result_2") (result i64)
-    (unreachable) (i64.add (select (i64.const 0) (i32.const 0)))
-  )
-
   ;; As the argument of control constructs and instructions
 
   (func (export "as-select-first") (param i32) (result i32)
@@ -203,19 +178,6 @@
       (i32.wrap_i64 (select (i64.const 1) (i64.const 0) (local.get 0)))
     )
   )
-
-  (func (export "unreachable-num")
-    (unreachable)
-    (select)
-    (i32.eqz)
-    (drop)
-  )
-  (func (export "unreachable-ref")
-    (unreachable)
-    (select)
-    (ref.is_null)
-    (drop)
-  )
 )
 
 (assert_return (invoke "select-i32" (i32.const 1) (i32.const 2) (i32.const 1)) (i32.const 1))
@@ -278,11 +240,6 @@
 (assert_return (invoke "select-f64-t" (f64.const 2) (f64.const nan) (i32.const 0)) (f64.const nan))
 (assert_return (invoke "select-f64-t" (f64.const 2) (f64.const nan:0x20304) (i32.const 0)) (f64.const nan:0x20304))
 
-(assert_trap (invoke "select-trap-left" (i32.const 1)) "unreachable")
-(assert_trap (invoke "select-trap-left" (i32.const 0)) "unreachable")
-(assert_trap (invoke "select-trap-right" (i32.const 1)) "unreachable")
-(assert_trap (invoke "select-trap-right" (i32.const 0)) "unreachable")
-
 (assert_return (invoke "as-select-first" (i32.const 0)) (i32.const 1))
 (assert_return (invoke "as-select-first" (i32.const 1)) (i32.const 0))
 (assert_return (invoke "as-select-mid" (i32.const 0)) (i32.const 2))
@@ -315,7 +272,7 @@
 (assert_return (invoke "as-br_table-last" (i32.const 1)) (i32.const 2))
 
 (assert_return (invoke "as-call_indirect-first" (i32.const 0)) (i32.const 3))
-;;(assert_return (invoke "as-call_indirect-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-call_indirect-first" (i32.const 1)) (i32.const 2))
 (assert_return (invoke "as-call_indirect-mid" (i32.const 0)) (i32.const 1))
 (assert_return (invoke "as-call_indirect-mid" (i32.const 1)) (i32.const 1))
 (assert_trap (invoke "as-call_indirect-last" (i32.const 0)) "undefined element")
@@ -555,44 +512,20 @@
   "type mismatch"
 )
 
-;; Validation after unreachable
-
-;; The first two operands should have the same type as each other
-(assert_invalid
-  (module (func (unreachable) (select (i32.const 1) (i64.const 1) (i32.const 1)) (drop)))
-  "type mismatch"
-)
 
-(assert_invalid
-  (module (func (unreachable) (select (i64.const 1) (i32.const 1) (i32.const 1)) (drop)))
-  "type mismatch"
-)
+;; Flat syntax
 
-;; Third operand must be i32
-(assert_invalid
-  (module (func (unreachable) (select (i32.const 1) (i32.const 1) (i64.const 1)) (drop)))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (func (unreachable) (select (i32.const 1) (i64.const 1)) (drop)))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (func (unreachable) (select (i64.const 1)) (drop)))
-  "type mismatch"
-)
-
-;; Result of select has type of first two operands (type of second operand when first one is omitted)
-(assert_invalid
-  (module (func (result i32) (unreachable) (select (i64.const 1) (i32.const 1))))
-  "type mismatch"
-)
-
-;; select always has non-empty result
-(assert_invalid
-  (module (func (unreachable) (select)))
-  "type mismatch"
+(module
+  (table 1 funcref)
+  (func (result i32) unreachable select)
+  (func (result i32) unreachable select nop)
+  (func (result i32) unreachable select (select))
+  (func (result i32) unreachable select select)
+  (func (result i32) unreachable select select select)
+  (func (result i32) unreachable select (result i32))
+  (func (result i32) unreachable select (result i32) (result))
+  (func (result i32) unreachable select (result i32) (result) select)
+  (func (result i32) unreachable select (result) (result i32) select (result i32))
+  (func (result i32) unreachable select call_indirect)
+  (func (result i32) unreachable select call_indirect select)
 )
-
diff --git a/tests/wast/spec/simd_address.wast b/tests/wast/spec/simd_address.wast
new file mode 100644
index 0000000000..9e023008bb
--- /dev/null
+++ b/tests/wast/spec/simd_address.wast
@@ -0,0 +1,157 @@
+;; Load/Store v128 data with different valid offset/alignment
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\10\11\12\13\14\15")
+  (data (offset (i32.const 65505)) "\16\17\18\19\20\21\22\23\24\25\26\27\28\29\30\31")
+
+  (func (export "load_data_1") (param $i i32) (result v128)
+    (v128.load offset=0 (local.get $i))                   ;; 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15
+  )
+  (func (export "load_data_2") (param $i i32) (result v128)
+    (v128.load align=1 (local.get $i))                    ;; 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15
+  )
+  (func (export "load_data_3") (param $i i32) (result v128)
+    (v128.load offset=1 align=1 (local.get $i))           ;; 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00
+  )
+  (func (export "load_data_4") (param $i i32) (result v128)
+    (v128.load offset=2 align=1 (local.get $i))           ;; 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00 0x00
+  )
+  (func (export "load_data_5") (param $i i32) (result v128)
+    (v128.load offset=15 align=1 (local.get $i))          ;; 0x15 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
+  )
+
+  (func (export "store_data_0") (result v128)
+    (v128.store offset=0 (i32.const 0) (v128.const f32x4 0 1 2 3))
+    (v128.load offset=0 (i32.const 0))
+  )
+  (func (export "store_data_1") (result v128)
+    (v128.store align=1 (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load align=1 (i32.const 0))
+  )
+  (func (export "store_data_2") (result v128)
+    (v128.store offset=1 align=1 (i32.const 0) (v128.const i16x8 0 1 2 3 4 5 6 7))
+    (v128.load offset=1 align=1 (i32.const 0))
+  )
+  (func (export "store_data_3") (result v128)
+    (v128.store offset=2 align=1 (i32.const 0) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+    (v128.load offset=2 align=1 (i32.const 0))
+  )
+  (func (export "store_data_4") (result v128)
+    (v128.store offset=15 align=1 (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load offset=15 (i32.const 0))
+  )
+  (func (export "store_data_5") (result v128)
+    (v128.store offset=65520 align=1 (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load offset=65520 (i32.const 0))
+  )
+  (func (export "store_data_6") (param $i i32)
+    (v128.store offset=1 align=1 (local.get $i) (v128.const i32x4 0 1 2 3))
+  )
+)
+
+(assert_return (invoke "load_data_1" (i32.const 0)) (v128.const i32x4 0x03020100 0x07060504 0x11100908 0x15141312))
+(assert_return (invoke "load_data_2" (i32.const 0)) (v128.const i32x4 0x03020100 0x07060504 0x11100908 0x15141312))
+(assert_return (invoke "load_data_3" (i32.const 0)) (v128.const i32x4 0x04030201 0x08070605 0x12111009 0x00151413))
+(assert_return (invoke "load_data_4" (i32.const 0)) (v128.const i32x4 0x05040302 0x09080706 0x13121110 0x00001514))
+(assert_return (invoke "load_data_5" (i32.const 0)) (v128.const i32x4 0x00000015 0x00000000 0x00000000 0x00000000))
+
+(assert_return (invoke "load_data_1" (i32.const 0)) (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x1110 0x1312 0x1514))
+(assert_return (invoke "load_data_2" (i32.const 0)) (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x1110 0x1312 0x1514))
+(assert_return (invoke "load_data_3" (i32.const 0)) (v128.const i16x8 0x0201 0x0403 0x0605 0x0807 0x1009 0x1211 0x1413 0x0015))
+(assert_return (invoke "load_data_4" (i32.const 0)) (v128.const i16x8 0x0302 0x0504 0x0706 0x0908 0x1110 0x1312 0x1514 0x0000))
+(assert_return (invoke "load_data_5" (i32.const 0)) (v128.const i16x8 0x0015 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+
+(assert_return (invoke "load_data_1" (i32.const 0)) (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15))
+(assert_return (invoke "load_data_2" (i32.const 0)) (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15))
+(assert_return (invoke "load_data_3" (i32.const 0)) (v128.const i8x16 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00))
+(assert_return (invoke "load_data_4" (i32.const 0)) (v128.const i8x16 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00 0x00))
+(assert_return (invoke "load_data_5" (i32.const 0)) (v128.const i8x16 0x15 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+
+(assert_return (invoke "load_data_1" (i32.const 65505)) (v128.const i32x4 0x19181716 0x23222120 0x27262524 0x31302928))
+(assert_return (invoke "load_data_2" (i32.const 65505)) (v128.const i32x4 0x19181716 0x23222120 0x27262524 0x31302928))
+(assert_return (invoke "load_data_3" (i32.const 65505)) (v128.const i32x4 0x20191817 0x24232221 0x28272625 0x00313029))
+(assert_return (invoke "load_data_4" (i32.const 65505)) (v128.const i32x4 0x21201918 0x25242322 0x29282726 0x00003130))
+(assert_return (invoke "load_data_5" (i32.const 65505)) (v128.const i32x4 0x00000031 0x00000000 0x00000000 0x00000000))
+
+(assert_return (invoke "load_data_1" (i32.const 65505)) (v128.const i16x8 0x1716 0x1918 0x2120 0x2322 0x2524 0x2726 0x2928 0x3130))
+(assert_return (invoke "load_data_2" (i32.const 65505)) (v128.const i16x8 0x1716 0x1918 0x2120 0x2322 0x2524 0x2726 0x2928 0x3130))
+(assert_return (invoke "load_data_3" (i32.const 65505)) (v128.const i16x8 0x1817 0x2019 0x2221 0x2423 0x2625 0x2827 0x3029 0x0031))
+(assert_return (invoke "load_data_4" (i32.const 65505)) (v128.const i16x8 0x1918 0x2120 0x2322 0x2524 0x2726 0x2928 0x3130 0x0000))
+(assert_return (invoke "load_data_5" (i32.const 65505)) (v128.const i16x8 0x0031 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+
+(assert_return (invoke "load_data_1" (i32.const 65505)) (v128.const i8x16 0x16 0x17 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31))
+(assert_return (invoke "load_data_2" (i32.const 65505)) (v128.const i8x16 0x16 0x17 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31))
+(assert_return (invoke "load_data_3" (i32.const 65505)) (v128.const i8x16 0x17 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31 0x00))
+(assert_return (invoke "load_data_4" (i32.const 65505)) (v128.const i8x16 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31 0x00 0x00))
+(assert_return (invoke "load_data_5" (i32.const 65505)) (v128.const i8x16 0x31 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+
+(assert_trap (invoke "load_data_3" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "load_data_5" (i32.const 65506)) "out of bounds memory access")
+
+(assert_return (invoke "store_data_0") (v128.const f32x4 0 1 2 3))
+(assert_return (invoke "store_data_1") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "store_data_2") (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "store_data_3") (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "store_data_4") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "store_data_5") (v128.const i32x4 0 1 2 3))
+
+(assert_trap (invoke "store_data_6" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "store_data_6" (i32.const 65535)) "out of bounds memory access")
+
+;; Load/Store v128 data with invalid offset
+
+(module
+  (memory 1)
+  (func (export "v128.load_offset_65521")
+    (drop (v128.load offset=65521 (i32.const 0)))
+  )
+)
+(assert_trap (invoke "v128.load_offset_65521") "out of bounds memory access")
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func"
+    "  (drop (v128.load offset=-1 (i32.const 0)))"
+    ")"
+  )
+  "unknown operator"
+)
+
+(module
+  (memory 1)
+  (func (export "v128.store_offset_65521")
+    (v128.store offset=65521 (i32.const 0) (v128.const i32x4 0 0 0 0))
+  )
+)
+(assert_trap (invoke "v128.store_offset_65521") "out of bounds memory access")
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func"
+    "  (v128.store offset=-1 (i32.const 0) (v128.const i32x4 0 0 0 0))"
+    ")"
+  )
+  "unknown operator"
+)
+
+
+;; Offset constant out of range
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (drop (v128.load offset=4294967296 (i32.const 0))))"
+  )
+  "i32 constant"
+)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store offset=4294967296 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "i32 constant"
+)
diff --git a/tests/wast/spec/simd_align.wast b/tests/wast/spec/simd_align.wast
new file mode 100644
index 0000000000..ed91ed5c60
--- /dev/null
+++ b/tests/wast/spec/simd_align.wast
@@ -0,0 +1,355 @@
+;; Valid alignment
+
+(module (memory 1) (func (drop (v128.load align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load align=16 (i32.const 0)))))
+
+(module (memory 1) (func (v128.store align=1 (i32.const 0) (v128.const i32x4 0 1 2 3))))
+(module (memory 1) (func (v128.store align=2 (i32.const 0) (v128.const i32x4 0 1 2 3))))
+(module (memory 1) (func (v128.store align=4 (i32.const 0) (v128.const i32x4 0 1 2 3))))
+(module (memory 1) (func (v128.store align=8 (i32.const 0) (v128.const i32x4 0 1 2 3))))
+(module (memory 1) (func (v128.store align=16 (i32.const 0) (v128.const i32x4 0 1 2 3))))
+
+(module (memory 1) (func (drop (v128.load8x8_s align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_s align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_s align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_s align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_u align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_u align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_u align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_u align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_s align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_s align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_s align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_s align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_u align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_u align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_u align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_u align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_s align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_s align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_s align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_s align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_u align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_u align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_u align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_u align=8 (i32.const 0)))))
+
+(module (memory 1) (func (drop (v128.load8_splat align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16_splat align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16_splat align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32_splat align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32_splat align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32_splat align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load64_splat align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load64_splat align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load64_splat align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load64_splat align=8 (i32.const 0)))))
+
+;; Invalid alignment
+
+(assert_invalid
+  (module (memory 1) (func (drop (v128.load align=32 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func(v128.store align=32 (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load8x8_s align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load8x8_u align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load16x4_s align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load16x4_u align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load32x2_s align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load32x2_u align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load8_splat align=2 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load16_splat align=4 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load32_splat align=8 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load64_splat align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+
+;; Malformed alignment
+
+(assert_malformed
+  (module quote
+    "(memory 1) (func (drop (v128.load align=-1 (i32.const 0))))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (drop (v128.load align=0 (i32.const 0))))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (drop (v128.load align=7 (i32.const 0))))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (v128.store align=-1 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 0) (func (v128.store align=0 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 0) (func (v128.store align=7 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_s align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_s align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_s align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_u align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_u align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_u align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_s align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_s align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_s align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_u align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_u align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_u align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_s align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_s align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_s align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_u align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_u align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_u align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8_splat align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8_splat align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16_splat align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16_splat align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32_splat align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32_splat align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32_splat align=3 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load64_splat align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load64_splat align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load64_splat align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+
+;; Test that misaligned SIMD loads/stores don't trap
+
+(module
+  (memory 1 1)
+  (func (export "v128.load align=16") (param $address i32) (result v128)
+    (v128.load align=16 (local.get $address))
+  )
+  (func (export "v128.store align=16") (param $address i32) (param $value v128)
+    (v128.store align=16 (local.get $address) (local.get $value))
+  )
+)
+
+(assert_return (invoke "v128.load align=16" (i32.const 0)) (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "v128.load align=16" (i32.const 1)) (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "v128.store align=16" (i32.const 1) (v128.const i8x16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)))
+(assert_return (invoke "v128.load align=16" (i32.const 0)) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+
+;; Test aligned and unaligned read/write
+
+(module
+  (memory 1)
+  (func (export "v128_unaligned_read_and_write") (result v128)
+    (local v128)
+    (v128.store (i32.const 0) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128_aligned_read_and_write") (result v128)
+    (local v128)
+    (v128.store align=2 (i32.const 0) (v128.const i16x8 0 1 2 3 4 5 6 7))
+    (v128.load align=2  (i32.const 0))
+  )
+  (func (export "v128_aligned_read_and_unaligned_write") (result v128)
+    (local v128)
+    (v128.store (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load align=2 (i32.const 0))
+  )
+  (func (export "v128_unaligned_read_and_aligned_write") (result v128)
+    (local v128)
+    (v128.store align=2 (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load (i32.const 0))
+  )
+)
+
+(assert_return (invoke "v128_unaligned_read_and_write") (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "v128_aligned_read_and_write") (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "v128_aligned_read_and_unaligned_write") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "v128_unaligned_read_and_aligned_write") (v128.const i32x4 0 1 2 3))
diff --git a/tests/wast/spec/simd_bit_shift.wast b/tests/wast/spec/simd_bit_shift.wast
new file mode 100644
index 0000000000..98e155651e
--- /dev/null
+++ b/tests/wast/spec/simd_bit_shift.wast
@@ -0,0 +1,1104 @@
+;; Test all the bit shift operators on major boundary values and all special values.
+
+(module
+  (func (export "i8x16.shl") (param $0 v128) (param $1 i32) (result v128) (i8x16.shl (local.get $0) (local.get $1)))
+  (func (export "i8x16.shr_s") (param $0 v128) (param $1 i32) (result v128) (i8x16.shr_s (local.get $0) (local.get $1)))
+  (func (export "i8x16.shr_u") (param $0 v128) (param $1 i32) (result v128) (i8x16.shr_u (local.get $0) (local.get $1)))
+
+  (func (export "i16x8.shl") (param $0 v128) (param $1 i32) (result v128) (i16x8.shl (local.get $0) (local.get $1)))
+  (func (export "i16x8.shr_s") (param $0 v128) (param $1 i32) (result v128) (i16x8.shr_s (local.get $0) (local.get $1)))
+  (func (export "i16x8.shr_u") (param $0 v128) (param $1 i32) (result v128) (i16x8.shr_u (local.get $0) (local.get $1)))
+
+  (func (export "i32x4.shl") (param $0 v128) (param $1 i32) (result v128) (i32x4.shl (local.get $0) (local.get $1)))
+  (func (export "i32x4.shr_s") (param $0 v128) (param $1 i32) (result v128) (i32x4.shr_s (local.get $0) (local.get $1)))
+  (func (export "i32x4.shr_u") (param $0 v128) (param $1 i32) (result v128) (i32x4.shr_u (local.get $0) (local.get $1)))
+
+  (func (export "i64x2.shl") (param $0 v128) (param $1 i32) (result v128) (i64x2.shl (local.get $0) (local.get $1)))
+  (func (export "i64x2.shr_s") (param $0 v128) (param $1 i32) (result v128) (i64x2.shr_s (local.get $0) (local.get $1)))
+  (func (export "i64x2.shr_u") (param $0 v128) (param $1 i32) (result v128) (i64x2.shr_u (local.get $0) (local.get $1)))
+
+  ;; shifting by a constant amount
+  ;; i8x16
+  (func (export "i8x16.shl_1") (param $0 v128) (result v128) (i8x16.shl (local.get $0) (i32.const 1)))
+  (func (export "i8x16.shr_u_8") (param $0 v128) (result v128) (i8x16.shr_u (local.get $0) (i32.const 8)))
+  (func (export "i8x16.shr_s_9") (param $0 v128) (result v128) (i8x16.shr_s (local.get $0) (i32.const 9)))
+
+  ;; i16x8
+  (func (export "i16x8.shl_1") (param $0 v128) (result v128) (i16x8.shl (local.get $0) (i32.const 1)))
+  (func (export "i16x8.shr_u_16") (param $0 v128) (result v128) (i16x8.shr_u (local.get $0) (i32.const 16)))
+  (func (export "i16x8.shr_s_17") (param $0 v128) (result v128) (i16x8.shr_s (local.get $0) (i32.const 17)))
+
+  ;; i32x4
+  (func (export "i32x4.shl_1") (param $0 v128) (result v128) (i32x4.shl (local.get $0) (i32.const 1)))
+  (func (export "i32x4.shr_u_32") (param $0 v128) (result v128) (i32x4.shr_u (local.get $0) (i32.const 32)))
+  (func (export "i32x4.shr_s_33") (param $0 v128) (result v128) (i32x4.shr_s (local.get $0) (i32.const 33)))
+
+  ;; i64x2
+  (func (export "i64x2.shl_1") (param $0 v128) (result v128) (i64x2.shl (local.get $0) (i32.const 1)))
+  (func (export "i64x2.shr_u_64") (param $0 v128) (result v128) (i64x2.shr_u (local.get $0) (i32.const 64)))
+  (func (export "i64x2.shr_s_65") (param $0 v128) (result v128) (i64x2.shr_s (local.get $0) (i32.const 65)))
+)
+
+;; i8x16 shl
+;; amount less than lane width
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                   (i32.const 1))
+                                   (v128.const i8x16 0 -128 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0xAA 0xBB 0xCC 0xDD 0xEE 0xFF 0xA0 0xB0 0xC0 0xD0 0xE0 0xF0 0x0A 0x0B 0x0C 0x0D)
+                                   (i32.const 4))
+                                   (v128.const i8x16 0xA0 0xB0 0xC0 0xD0 0xE0 0xF0 0x00 0x00 0x00 0x00 0x00 0x00 0xA0 0xB0 0xC0 0xD0))
+;; amount is multiple of lane width
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 8))
+                                   (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 32))
+                                   (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 128))
+                                   (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 256))
+                                   (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                   (i32.const 9))
+                                   (v128.const i8x16 0 -128 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 9))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 17))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 33))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 129))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 257))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 513))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 514))
+                                   (v128.const i8x16 0 4 8 12 16 20 24 28 32 36 0x28 0x2C 0x30 0x34 0x38 0x3C))
+;; i8x16 shr_u
+;; amount less than lane width
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 1))
+                                     (v128.const i8x16 64 96 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0xAA 0xBB 0xCC 0xDD 0xEE 0xFF 0xA0 0xB0 0xC0 0xD0 0xE0 0xF0 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 4))
+                                     (v128.const i8x16 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F 0x00 0x00 0x00 0x00))
+;; amount is multiple of lane width
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 8))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 9))
+                                     (v128.const i8x16 64 96 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 9))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 17))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 33))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 0x02 0x02 0x03 0x03 0x03 0x03))
+;; i8x16 shr_s
+;; amount less than lane width
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 1))
+                                     (v128.const i8x16 192 224 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0xAA 0xBB 0xCC 0xDD 0xEE 0xFF 0xA0 0xB0 0xC0 0xD0 0xE0 0xF0 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 4))
+                                     (v128.const i8x16 0xFA 0xFB 0xFC 0xFD 0xFE 0xFF 0xFA 0xFB 0xFC 0xFD 0xFE 0xFF 0x00 0x00 0x00 0x00))
+;; amount is multiple of lane width
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 8))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 9))
+                                     (v128.const i8x16 192 224 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 9))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 17))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 33))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 0x02 0x02 0x03 0x03 0x03 0x03))
+;; shifting by a constant amount
+(assert_return (invoke "i8x16.shl_1" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+                                     (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shr_u_8" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+                                       (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_s_9" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+                                       (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+
+;; i16x8 shl
+;; amount less than lane width
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                   (i32.const 1))
+                                   (v128.const i16x8 65280 65408 0 2 4 6 8 10))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                   (i32.const 2))
+                                   (v128.const i16x8 49380 49380 49380 49380 49380 49380 49380 49380))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                   (i32.const 2))
+                                   (v128.const i16x8 0x48d0 0x48d0 0x48d0 0x48d0 0x48d0 0x48d0 0x48d0 0x48d0))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0xAABB 0xCCDD 0xEEFF 0xA0B0 0xC0D0 0xE0F0 0x0A0B 0x0C0D)
+                                   (i32.const 4))
+                                   (v128.const i16x8 0xABB0 0xCDD0 0xEFF0 0xB00 0xD00 0xF00 0xA0B0 0xC0D0))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 8))
+                                   (v128.const i16x8 0 256 512 768 1024 1280 1536 1792))
+;; amount is multiple of lane width
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 32))
+                                   (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 128))
+                                   (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 256))
+                                   (v128.const i16x8 0 1 2 3 4 5 6 7))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                   (i32.const 17))
+                                   (v128.const i16x8 65280 65408 0 2 4 6 8 10))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 17))
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 33))
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 129))
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 257))
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 513))
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 514))
+                                   (v128.const i16x8 0 4 8 12 16 20 24 28))
+
+;; i16x8 shr_u
+;; amount less than lane width
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                     (i32.const 1))
+                                     (v128.const i16x8 32704 32736 0 0 1 1 2 2))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                     (i32.const 2))
+                                     (v128.const i16x8 3086 3086 3086 3086 3086 3086 3086 3086))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                     (i32.const 2))
+                                     (v128.const i16x8 0x242a 0x242a 0x242a 0x242a 0x242a 0x242a 0x242a 0x242a))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0xAABB 0xCCDD 0xEEFF 0xA0B0 0xC0D0 0xE0F0 0x0A0B 0x0C0D)
+                                     (i32.const 4))
+                                     (v128.const i16x8 0xAAB 0xCCD 0xEEF 0xA0B 0xC0D 0xE0F 0x0A0 0x0C0))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 8))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+;; amount is multiple of lane width
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 32))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 128))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 256))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                     (i32.const 17))
+                                     (v128.const i16x8 32704 32736 0 0 1 1 2 2))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 17))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 33))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 129))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 257))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 513))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 514))
+                                     (v128.const i16x8 0 0 0 0 1 1 1 1))
+
+;; i16x8 shr_s
+;; amount less than lane width
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                     (i32.const 1))
+                                     (v128.const i16x8 65472 65504 0 0 1 1 2 2))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                     (i32.const 2))
+                                     (v128.const i16x8 3086 3086 3086 3086 3086 3086 3086 3086))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                     (i32.const 2))
+                                     (v128.const i16x8 0xe42a 0xe42a 0xe42a 0xe42a 0xe42a 0xe42a 0xe42a 0xe42a))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0xAABB 0xCCDD 0xEEFF 0xA0B0 0xC0D0 0xE0F0 0x0A0B 0x0C0D)
+                                     (i32.const 4))
+                                     (v128.const i16x8 0xFAAB 0xFCCD 0xFEEF 0xFA0B 0xFC0D 0xFE0F 0x00A0 0x00C0))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 8))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+;; amount is multiple of lane width
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 32))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 128))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 256))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                     (i32.const 17))
+                                     (v128.const i16x8 65472 65504 0 0 1 1 2 2))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 17))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 33))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 129))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 257))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 513))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 514))
+                                     (v128.const i16x8 0 0 0 0 1 1 1 1))
+
+;; shifting by a constant amount
+(assert_return (invoke "i16x8.shl_1" (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                     (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shr_u_16" (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                        (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shr_s_17" (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                        (v128.const i16x8 0 0 1 1 2 2 3 3))
+
+;; i32x4 shl
+;; amount less than lane width
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 -2147483648 -32768 0 0x0A0B0C0D)
+                                   (i32.const 1))
+                                   (v128.const i32x4 0 4294901760 0 0x1416181A))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                   (i32.const 2))
+                                   (v128.const i32x4 643304264 643304264 643304264 643304264))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                                   (i32.const 2))
+                                   (v128.const i32x4 0x48d159e0 0x48d159e0 0x48d159e0 0x48d159e0))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0xAABBCCDD 0xEEFFA0B0 0xC0D0E0F0 0x0A0B0C0D)
+                                   (i32.const 4))
+                                   (v128.const i32x4 0xABBCCDD0 0xEFFA0B00 0x0D0E0F00 0xA0B0C0D0))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 8))
+                                   (v128.const i32x4 0 256 0x00000E00 0x00000F00))
+;; amount is multiple of lane width
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 32))
+                                   (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 128))
+                                   (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 256))
+                                   (v128.const i32x4 0 1 0x0E 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 -2147483648 -32768 0 0x0A0B0C0D)
+                                   (i32.const 33))
+                                   (v128.const i32x4 0 4294901760 0 0x1416181A))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 33))
+                                   (v128.const i32x4 0 2 0x1C 0x1E))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 65))
+                                   (v128.const i32x4 0 2 0x1C 0x1E))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 129))
+                                   (v128.const i32x4 0 2 0x1C 0x1E))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 257))
+                                   (v128.const i32x4 0 2 0x1C 0x1E))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 513))
+                                   (v128.const i32x4 0 2 0x1C 0x1E))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 514))
+                                   (v128.const i32x4 0 4 0x38 0x3C))
+
+;; i32x4 shr_u
+;; amount less than lane width
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 -2147483648 -32768 0x0000000C 0x0000000D)
+                                     (i32.const 1))
+                                     (v128.const i32x4 1073741824 2147467264 0x00000006 0x00000006))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                     (i32.const 2))
+                                     (v128.const i32x4 308641972 308641972 308641972 308641972))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                     (i32.const 2))
+                                     (v128.const i32x4 0x242af37b 0x242af37b 0x242af37b 0x242af37b))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0xAABBCCDD 0xEEFFA0B0 0xC0D0E0F0 0x0A0B0C0D)
+                                     (i32.const 4))
+                                     (v128.const i32x4 0x0AABBCCD 0x0EEFFA0B 0x0C0D0E0F 0x00A0B0C0))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 8))
+                                     (v128.const i32x4 0 0 0x00000000 0x00000000))
+;; amount is multiple of lane width
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 -2147483648 -32768 0x0000000C 0x0000000D)
+                                     (i32.const 33))
+                                     (v128.const i32x4 1073741824 2147467264 0x00000006 0x00000006))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 33))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 65))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i32x4 0 0 0x03 0x03))
+
+;; i32x4 shr_s
+;; amount less than lane width
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 -2147483648 -32768 0x0C 0x0D)
+                                     (i32.const 1))
+                                     (v128.const i32x4 3221225472 4294950912 0x06 0x06))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                     (i32.const 2))
+                                     (v128.const i32x4 308641972 308641972 308641972 308641972))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                     (i32.const 2))
+                                     (v128.const i32x4 0xe42af37b 0xe42af37b 0xe42af37b 0xe42af37b))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0xAABBCCDD 0xEEFFA0B0 0xC0D0E0F0 0x0A0B0C0D)
+                                     (i32.const 4))
+                                     (v128.const i32x4 0xfaabbccd 0xFEEFFA0B 0xFC0D0E0F 0x00A0B0C0))
+;; amount is multiple of lane width
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 8))
+                                     (v128.const i32x4 0 0 0x00000000 0x00000000))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 -2147483648 -32768 0x0C 0x0D)
+                                     (i32.const 33))
+                                     (v128.const i32x4 3221225472 4294950912 0x06 0x06))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 33))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 65))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i32x4 0 0 0x03 0x03))
+
+;; shifting by a constant amount
+(assert_return (invoke "i32x4.shl_1" (v128.const i32x4 0 1 0x0E 0x0F))
+                                     (v128.const i32x4 0 2 28 30))
+(assert_return (invoke "i32x4.shr_u_32" (v128.const i32x4 0 1 0x0E 0x0F))
+                                        (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shr_s_33" (v128.const i32x4 0 1 0x0E 0x0F))
+                                        (v128.const i32x4 0 0 7 7))
+
+;; i64x2 shl
+;; amount less than lane width
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 -9223372036854775808 -2147483648)
+                                   (i32.const 1))
+                                   (v128.const i64x2 0 18446744069414584320))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)
+                                   (i32.const 2))
+                                   (v128.const i64x2 4938271560493827156 4938271560493827156))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef)
+                                   (i32.const 2))
+                                   (v128.const i64x2 0x48d159e242af37bc 0x48d159e242af37bc))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D)
+                                   (i32.const 4))
+                                   (v128.const i64x2 0xABBCCDDEEFFA0B00 0xD0E0F00A0B0C0D0))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D)
+                                   (i32.const 8))
+                                   (v128.const i64x2 0xBBCCDDEEFFA0B000 0xD0E0F00A0B0C0D00))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 16))
+                                   (v128.const i64x2 65536 0xF0000))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 32))
+                                   (v128.const i64x2 4294967296 0xF00000000))
+;; amount is multiple of lane width
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 128))
+                                   (v128.const i64x2 1 0x0F))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 256))
+                                   (v128.const i64x2 1 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 65))
+                                   (v128.const i64x2 2 0x1E))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 129))
+                                   (v128.const i64x2 2 0x1E))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 257))
+                                   (v128.const i64x2 2 0x1E))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 513))
+                                   (v128.const i64x2 2 0x1E))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 514))
+                                   (v128.const i64x2 4 0x3C))
+
+;; i64x2 shr_u
+;; amount less than lane width
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 -9223372036854775808 -2147483648)
+                                     (i32.const 1))
+                                     (v128.const i64x2 4611686018427387904 9223372035781033984))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)
+                                     (i32.const 2))
+                                     (v128.const i64x2 308641972530864197 308641972530864197))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 0x0_90AB_cdef_8765_4321 0x0_90AB_cdef_8765_4321)
+                                     (i32.const 2))
+                                     (v128.const i64x2 0x242af37be1d950c8 0x242af37be1d950c8))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D)
+                                     (i32.const 4))
+                                     (v128.const i64x2 0xAABBCCDDEEFFA0B 0xC0D0E0F00A0B0C0))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D)
+                                     (i32.const 8))
+                                     (v128.const i64x2 0xAABBCCDDEEFFA0 0xC0D0E0F00A0B0C))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 16))
+                                     (v128.const i64x2 0 0x00))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i64x2 0 0x00))
+;; amount is multiple of lane width
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i64x2 1 0x0F))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i64x2 1 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 65))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 0 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i64x2 0 0x03))
+
+;; i64x2 shr_s
+;; amount less than lane width
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 -9223372036854775808 -2147483648)
+                                     (i32.const 1))
+                                     (v128.const i64x2 13835058055282163712 18446744072635809792))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)
+                                     (i32.const 2))
+                                     (v128.const i64x2 308641972530864197 308641972530864197))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 0x0_90AB_cdef_8765_4321 0x0_90AB_cdef_8765_4321)
+                                     (i32.const 2))
+                                     (v128.const i64x2 0xe42af37be1d950c8 0xe42af37be1d950c8))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D)
+                                     (i32.const 4))
+                                     (v128.const i64x2 0xFAABBCCDDEEFFA0B 0xFC0D0E0F00A0B0C0))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 0xFFAABBCCDDEEFFA0 0xC0D0E0F00A0B0C0D)
+                                     (i32.const 8))
+                                     (v128.const i64x2 0xFFFFAABBCCDDEEFF 0xFFC0D0E0F00A0B0C))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 16))
+                                     (v128.const i64x2 0 0x00))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i64x2 0 0x00))
+;; amount is multiple of lane width
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i64x2 1 0x0F))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i64x2 1 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 -9223372036854775808 -2147483648)
+                                     (i32.const 65))
+                                     (v128.const i64x2 13835058055282163712 18446744072635809792))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 0x0C 0x0D)
+                                     (i32.const 65))
+                                     (v128.const i64x2 0x06 0x06))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i64x2 0 0x03))
+
+;; shifting by a constant amount
+(assert_return (invoke "i64x2.shl_1" (v128.const i64x2 1 0x0F))
+                                     (v128.const i64x2 2 0x1E))
+(assert_return (invoke "i64x2.shr_u_64" (v128.const i64x2 1 0x0F))
+                                        (v128.const i64x2 1 0x0F))
+(assert_return (invoke "i64x2.shr_s_65" (v128.const i64x2 1 0x0F))
+                                        (v128.const i64x2 0 0x07))
+
+;; Combination
+
+(module (memory 1)
+  (func (export "i8x16.shl-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.shl
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i8x16.shr_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.shr_s
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i8x16.shr_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.shr_u
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i16x8.shl-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.shl
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i16x8.shr_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.shr_s
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i16x8.shr_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.shr_u
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i32x4.shl-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.shl
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i32x4.shr_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.shr_s
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i32x4.shr_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.shr_u
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i64x2.shl-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i64x2.shl
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i64x2.shr_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i64x2.shr_s
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i64x2.shr_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i64x2.shr_u
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-i8x16.shl")
+    (drop
+      (i8x16.shl
+        (i8x16.shl
+          (i8x16.shl
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i8x16.shr_s")
+    (drop
+      (i8x16.shr_s
+        (i8x16.shr_s
+          (i8x16.shr_s
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i8x16.shr_u")
+    (drop
+      (i8x16.shr_u
+        (i8x16.shr_u
+          (i8x16.shr_u
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i16x8.shl")
+    (drop
+      (i16x8.shl
+        (i16x8.shl
+          (i16x8.shl
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i16x8.shr_s")
+    (drop
+      (i16x8.shr_s
+        (i16x8.shr_s
+          (i16x8.shr_s
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i16x8.shr_u")
+    (drop
+      (i16x8.shr_u
+        (i16x8.shr_u
+          (i16x8.shr_u
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i32x4.shl")
+    (drop
+      (i32x4.shl
+        (i32x4.shl
+          (i32x4.shl
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i32x4.shr_s")
+    (drop
+      (i32x4.shr_s
+        (i32x4.shr_s
+          (i32x4.shr_s
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i32x4.shr_u")
+    (drop
+      (i32x4.shr_u
+        (i32x4.shr_u
+          (i32x4.shr_u
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i64x2.shl")
+    (drop
+      (i64x2.shl
+        (i64x2.shl
+          (i64x2.shl
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i64x2.shr_s")
+    (drop
+      (i64x2.shr_s
+        (i64x2.shr_s
+          (i64x2.shr_s
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i64x2.shr_u")
+    (drop
+      (i64x2.shr_u
+        (i64x2.shr_u
+          (i64x2.shr_u
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+)
+
+(assert_return (invoke "i8x16.shl-in-block"))
+(assert_return (invoke "i8x16.shr_s-in-block"))
+(assert_return (invoke "i8x16.shr_u-in-block"))
+(assert_return (invoke "i16x8.shl-in-block"))
+(assert_return (invoke "i16x8.shr_s-in-block"))
+(assert_return (invoke "i16x8.shr_u-in-block"))
+(assert_return (invoke "i32x4.shl-in-block"))
+(assert_return (invoke "i32x4.shr_s-in-block"))
+(assert_return (invoke "i32x4.shr_u-in-block"))
+(assert_return (invoke "i64x2.shl-in-block"))
+(assert_return (invoke "i64x2.shr_s-in-block"))
+(assert_return (invoke "i64x2.shr_u-in-block"))
+(assert_return (invoke "nested-i8x16.shl"))
+(assert_return (invoke "nested-i8x16.shr_s"))
+(assert_return (invoke "nested-i8x16.shr_u"))
+(assert_return (invoke "nested-i16x8.shl"))
+(assert_return (invoke "nested-i16x8.shr_s"))
+(assert_return (invoke "nested-i16x8.shr_u"))
+(assert_return (invoke "nested-i32x4.shl"))
+(assert_return (invoke "nested-i32x4.shr_s"))
+(assert_return (invoke "nested-i32x4.shr_u"))
+(assert_return (invoke "nested-i64x2.shl"))
+(assert_return (invoke "nested-i64x2.shr_s"))
+(assert_return (invoke "nested-i64x2.shr_u"))
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (i8x16.shl   (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.shr_s (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.shr_u (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.shl   (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.shr_s (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.shr_u (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.shl   (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.shr_s (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.shr_u (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.shl   (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.shr_s (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.shr_u (i32.const 0) (i32.const 0)))) "type mismatch")
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.shl_s (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.shl_r (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.shr   (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.shl_s (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.shl_r (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.shr   (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.shl_s (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.shl_r (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.shr   (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.shl_s (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.shl_r (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.shr   (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.shl   (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.shr_s (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.shr_u (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.shl-1st-arg-empty (result v128)
+      (i8x16.shl (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.shl-last-arg-empty (result v128)
+      (i8x16.shl (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.shl-arg-empty (result v128)
+      (i8x16.shl)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.shr_u-1st-arg-empty (result v128)
+      (i16x8.shr_u (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.shr_u-last-arg-empty (result v128)
+      (i16x8.shr_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.shr_u-arg-empty (result v128)
+      (i16x8.shr_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.shr_s-1st-arg-empty (result v128)
+      (i32x4.shr_s (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.shr_s-last-arg-empty (result v128)
+      (i32x4.shr_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.shr_s-arg-empty (result v128)
+      (i32x4.shr_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.shl-1st-arg-empty (result v128)
+      (i64x2.shl (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.shr_u-last-arg-empty (result v128)
+      (i64x2.shr_u (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.shr_s-arg-empty (result v128)
+      (i64x2.shr_s)
+    )
+  )
+  "type mismatch"
+)
diff --git a/tests/wast/spec/simd_bitwise.wast b/tests/wast/spec/simd_bitwise.wast
new file mode 100644
index 0000000000..f646bf61d4
--- /dev/null
+++ b/tests/wast/spec/simd_bitwise.wast
@@ -0,0 +1,812 @@
+;; Test all the bitwise operators on major boundary values and all special values.
+
+(module
+  (func (export "not") (param $0 v128) (result v128) (v128.not (local.get $0)))
+  (func (export "and") (param $0 v128) (param $1 v128) (result v128) (v128.and (local.get $0) (local.get $1)))
+  (func (export "or") (param $0 v128) (param $1 v128) (result v128) (v128.or (local.get $0) (local.get $1)))
+  (func (export "xor") (param $0 v128) (param $1 v128) (result v128) (v128.xor (local.get $0) (local.get $1)))
+  (func (export "bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+    (v128.bitselect (local.get $0) (local.get $1) (local.get $2))
+  )
+  (func (export "andnot") (param $0 v128) (param $1 v128) (result v128) (v128.andnot (local.get $0) (local.get $1)))
+)
+
+;; i32x4
+(assert_return (invoke "not" (v128.const i32x4 0 0 0 0))
+                             (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "not" (v128.const i32x4 -1 -1 -1 -1))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "not" (v128.const i32x4 -1 0 -1 0))
+                             (v128.const i32x4 0 -1 0 -1))
+(assert_return (invoke "not" (v128.const i32x4 0 -1 0 -1))
+                             (v128.const i32x4 -1 0 -1 0))
+(assert_return (invoke "not" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+                             (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+(assert_return (invoke "not" (v128.const i32x4 3435973836 3435973836 3435973836 3435973836))
+                             (v128.const i32x4 858993459 858993459 858993459 858993459))
+(assert_return (invoke "not" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                             (v128.const i32x4 3060399405 3060399405 3060399405 3060399405))
+(assert_return (invoke "not" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                             (v128.const i32x4 0xedcba987 0xedcba987 0xedcba987 0xedcba987))
+(assert_return (invoke "and" (v128.const i32x4 0 0 -1 -1)
+                             (v128.const i32x4 0 -1 0 -1))
+                             (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "and" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 0 0 0 0))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "and" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 -1 -1 -1 -1))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "and" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "and" (v128.const i32x4 1 1 1 1)
+                             (v128.const i32x4 1 1 1 1))
+                             (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "and" (v128.const i32x4 255 255 255 255)
+                             (v128.const i32x4 85 85 85 85))
+                             (v128.const i32x4 85 85 85 85))
+(assert_return (invoke "and" (v128.const i32x4 255 255 255 255)
+                             (v128.const i32x4 128 128 128 128))
+                             (v128.const i32x4 128 128 128 128))
+(assert_return (invoke "and" (v128.const i32x4 2863311530 2863311530 2863311530 2863311530)
+                             (v128.const i32x4 10 128 5 165))
+                             (v128.const i32x4 10 128 0 160))
+(assert_return (invoke "and" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+                             (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+(assert_return (invoke "and" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                             (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+(assert_return (invoke "and" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0x0 0x0 0x0 0x0))
+                             (v128.const i32x4 0x0 0x0 0x0 0x0))
+(assert_return (invoke "and" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                             (v128.const i32x4 0x5555 0xFFFF 0x55FF 0x5FFF))
+                             (v128.const i32x4 0x5555 0x5555 0x5555 0x5555))
+(assert_return (invoke "and" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                             (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                             (v128.const i32x4 1234567890 1234567890 1234567890 1234567890))
+(assert_return (invoke "and" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                             (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                             (v128.const i32x4 0x10204468 0x10204468 0x10204468 0x10204468))
+(assert_return (invoke "or" (v128.const i32x4 0 0 -1 -1)
+                            (v128.const i32x4 0 -1 0 -1))
+                            (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "or" (v128.const i32x4 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "or" (v128.const i32x4 0 0 0 0)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "or" (v128.const i32x4 0 0 0 0)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "or" (v128.const i32x4 1 1 1 1)
+                            (v128.const i32x4 1 1 1 1))
+                            (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "or" (v128.const i32x4 255 255 255 255)
+                            (v128.const i32x4 85 85 85 85))
+                            (v128.const i32x4 255 255 255 255))
+(assert_return (invoke "or" (v128.const i32x4 255 255 255 255)
+                            (v128.const i32x4 128 128 128 128))
+                            (v128.const i32x4 255 255 255 255))
+(assert_return (invoke "or" (v128.const i32x4 2863311530 2863311530 2863311530 2863311530)
+                            (v128.const i32x4 10 128 5 165))
+                            (v128.const i32x4 2863311530 2863311530 2863311535 2863311535))
+(assert_return (invoke "or" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "or" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "or" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0x0 0x0 0x0 0x0))
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "or" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                            (v128.const i32x4 0x5555 0xFFFF 0x55FF 0x5FFF))
+                            (v128.const i32x4 0x55555555 0x5555ffff 0x555555ff 0x55555fff))
+(assert_return (invoke "or" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                            (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                            (v128.const i32x4 1234567890 1234567890 1234567890 1234567890))
+(assert_return (invoke "or" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                            (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                            (v128.const i32x4 0x92bfdfff 0x92bfdfff 0x92bfdfff 0x92bfdfff))
+(assert_return (invoke "xor" (v128.const i32x4 0 0 -1 -1)
+                             (v128.const i32x4 0 -1 0 -1))
+                             (v128.const i32x4 0 -1 -1 0))
+(assert_return (invoke "xor" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 0 0 0 0))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 -1 -1 -1 -1))
+                             (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "xor" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                             (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "xor" (v128.const i32x4 1 1 1 1)
+                             (v128.const i32x4 1 1 1 1))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const i32x4 255 255 255 255)
+                             (v128.const i32x4 85 85 85 85))
+                             (v128.const i32x4 170 170 170 170))
+(assert_return (invoke "xor" (v128.const i32x4 255 255 255 255)
+                             (v128.const i32x4 128 128 128 128))
+                             (v128.const i32x4 127 127 127 127))
+(assert_return (invoke "xor" (v128.const i32x4 2863311530 2863311530 2863311530 2863311530)
+                             (v128.const i32x4 10 128 5 165))
+                             (v128.const i32x4 2863311520 2863311402 2863311535 2863311375))
+(assert_return (invoke "xor" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+                             (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+(assert_return (invoke "xor" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                             (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+(assert_return (invoke "xor" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0x0 0x0 0x0 0x0))
+                             (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "xor" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                             (v128.const i32x4 0x5555 0xFFFF 0x55FF 0x5FFF))
+                             (v128.const i32x4 0x55550000 0x5555AAAA 0x555500AA 0x55550AAA))
+(assert_return (invoke "xor" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                             (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                             (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                             (v128.const i32x4 0x829f9b97 0x829f9b97 0x829f9b97 0x829f9b97))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB)
+                                   (v128.const i32x4 0x00112345 0xF00FFFFF 0x10112021 0xBBAABBAA))
+                                   (v128.const i32x4 0xBBAABABA 0xABBAAAAA 0xABAABBBA 0xAABBAABB))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB)
+                                   (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                                   (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB)
+                                   (v128.const i32x4 0x11111111 0x11111111 0x11111111 0x11111111))
+                                   (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB)
+                                   (v128.const i32x4 0x01234567 0x89ABCDEF 0xFEDCBA98 0x76543210))
+                                   (v128.const i32x4 0xBABABABA 0xBABABABA 0xABABABAB 0xABABABAB))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                                   (v128.const i32x4 0x01234567 0x89ABCDEF 0xFEDCBA98 0x76543210))
+                                   (v128.const i32x4 0x54761032 0xDCFE98BA 0xAB89EFCD 0x23016745))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                                   (v128.const i32x4 0x55555555 0xAAAAAAAA 0x00000000 0xFFFFFFFF))
+                                   (v128.const i32x4 0x00000000 0xFFFFFFFF 0x55555555 0xAAAAAAAA))
+(assert_return (invoke "bitselect" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                   (v128.const i32x4 03_060_399_406 03_060_399_406 03_060_399_406 03_060_399_406)
+                                   (v128.const i32x4 0xcdefcdef 0xcdefcdef 0xcdefcdef 0xcdefcdef))
+                                   (v128.const i32x4 2072391874 2072391874 2072391874 2072391874))
+(assert_return (invoke "bitselect" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                                   (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                   (v128.const i32x4 0xcdefcdef 0xcdefcdef 0xcdefcdef 0xcdefcdef))
+                                   (v128.const i32x4 0x10244468 0x10244468 0x10244468 0x10244468))
+(assert_return (invoke "andnot" (v128.const i32x4 0 0 -1 -1)
+                                (v128.const i32x4 0 -1 0 -1))
+                                (v128.const i32x4 0 0 -1 0))
+(assert_return (invoke "andnot" (v128.const i32x4 0 0 0 0)
+                                (v128.const i32x4 0 0 0 0))
+                                (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "andnot" (v128.const i32x4 0 0 0 0)
+                                (v128.const i32x4 -1 -1 -1 -1))
+                                (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "andnot" (v128.const i32x4 0 0 0 0)
+                                (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                                (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "andnot" (v128.const i32x4 1 1 1 1)
+                                (v128.const i32x4 1 1 1 1))
+                                (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "andnot" (v128.const i32x4 255 255 255 255)
+                                (v128.const i32x4 85 85 85 85))
+                                (v128.const i32x4 170 170 170 170))
+(assert_return (invoke "andnot" (v128.const i32x4 255 255 255 255)
+                                (v128.const i32x4 128 128 128 128))
+                                (v128.const i32x4 127 127 127 127))
+(assert_return (invoke "andnot" (v128.const i32x4 2863311530 2863311530 2863311530 2863311530)
+                                (v128.const i32x4 10 128 5 165))
+                                (v128.const i32x4 2863311520 2863311402 2863311530 2863311370))
+(assert_return (invoke "andnot" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                                (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+                                (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+(assert_return (invoke "andnot" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                                (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                                (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+(assert_return (invoke "andnot" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                                (v128.const i32x4 0x0 0x0 0x0 0x0))
+                                (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "andnot" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                                (v128.const i32x4 0x5555 0xFFFF 0x55FF 0x5FFF))
+                                (v128.const i32x4 0x55550000 0x55550000 0x55550000 0x55550000))
+(assert_return (invoke "andnot" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "andnot" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                                (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                                (v128.const i32x4 0x02141210 0x02141210 0x02141210 0x02141210))
+
+;; for float special data [e.g. -nan nan -inf inf]
+(assert_return (invoke "not" (v128.const f32x4 -nan -nan -nan -nan))
+                             (v128.const f32x4 5.87747e-39 5.87747e-39 5.87747e-39 5.87747e-39))
+(assert_return (invoke "not" (v128.const f32x4 nan nan nan nan))
+                             (v128.const f32x4 -5.87747e-39 -5.87747e-39 -5.87747e-39 -5.87747e-39))
+(assert_return (invoke "not" (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const i32x4 0x007fffff 0x007fffff 0x007fffff 0x007fffff))
+(assert_return (invoke "not" (v128.const f32x4 inf inf inf inf))
+                             (v128.const i32x4 0x807fffff 0x807fffff 0x807fffff 0x807fffff))
+(assert_return (invoke "and" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 -nan -nan -nan -nan))
+                             (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "and" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 nan nan nan nan))
+                             (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "and" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "and" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "and" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 nan nan nan nan))
+                             (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "and" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "and" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "and" (v128.const f32x4 -inf -inf -inf -inf)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "and" (v128.const f32x4 -inf -inf -inf -inf)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "and" (v128.const f32x4 inf inf inf inf)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "or" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "or" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "or" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "or" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "or" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "or" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "or" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "or" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "or" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "or" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "xor" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 -nan -nan -nan -nan))
+                             (v128.const f32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 nan nan nan nan))
+                             (v128.const f32x4 -0 -0 -0 -0))
+(assert_return (invoke "xor" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000))
+(assert_return (invoke "xor" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const i32x4 0x80400000 0x80400000 0x80400000 0x80400000))
+(assert_return (invoke "xor" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 nan nan nan nan))
+                             (v128.const f32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const i32x4 0x80400000 0x80400000 0x80400000 0x80400000))
+(assert_return (invoke "xor" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000))
+(assert_return (invoke "xor" (v128.const f32x4 -inf -inf -inf -inf)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const f32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const f32x4 -inf -inf -inf -inf)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "xor" (v128.const f32x4 inf inf inf inf)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const f32x4 0 0 0 0))
+(assert_return (invoke "bitselect" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "bitselect" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "bitselect" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "bitselect" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "andnot" (v128.const f32x4 -nan -nan -nan -nan)
+                                (v128.const f32x4 -nan -nan -nan -nan))
+                                (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "andnot" (v128.const f32x4 -nan -nan -nan -nan)
+                                (v128.const f32x4 nan nan nan nan))
+                                (v128.const f32x4 -0 -0 -0 -0))
+(assert_return (invoke "andnot" (v128.const f32x4 -nan -nan -nan -nan)
+                                (v128.const f32x4 -inf -inf -inf -inf))
+                                (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000))
+(assert_return (invoke "andnot" (v128.const f32x4 -nan -nan -nan -nan)
+                                (v128.const f32x4 inf inf inf inf))
+                                (v128.const i32x4 0x80400000 0x80400000 0x80400000 0x80400000))
+(assert_return (invoke "andnot" (v128.const f32x4 nan nan nan nan)
+                                (v128.const f32x4 nan nan nan nan))
+                                (v128.const f32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "andnot" (v128.const f32x4 nan nan nan nan)
+                                (v128.const f32x4 -inf -inf -inf -inf))
+                                (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000))
+(assert_return (invoke "andnot" (v128.const f32x4 nan nan nan nan)
+                                (v128.const f32x4 inf inf inf inf))
+                                (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000))
+(assert_return (invoke "andnot" (v128.const f32x4 -inf -inf -inf -inf)
+                                (v128.const f32x4 -inf -inf -inf -inf))
+                                (v128.const f32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "andnot" (v128.const f32x4 -inf -inf -inf -inf)
+                                (v128.const f32x4 inf inf inf inf))
+                                (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "andnot" (v128.const f32x4 inf inf inf inf)
+                                (v128.const f32x4 inf inf inf inf))
+                                (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+
+;; Type check
+
+;; not
+(assert_invalid (module (func (result v128) (v128.not (i32.const 0)))) "type mismatch")
+;; and
+(assert_invalid (module (func (result v128) (v128.and (i32.const 0) (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.and (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.and (i32.const 0) (i32.const 0)))) "type mismatch")
+;; or
+(assert_invalid (module (func (result v128) (v128.or (i32.const 0) (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.or (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.or (i32.const 0) (i32.const 0)))) "type mismatch")
+;; xor
+(assert_invalid (module (func (result v128) (v128.xor (i32.const 0) (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.xor (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.xor (i32.const 0) (i32.const 0)))) "type mismatch")
+;; bitselect
+(assert_invalid (module (func (result v128) (v128.bitselect (i32.const 0) (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.bitselect (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.bitselect (i32.const 0) (i32.const 0) (i32.const 0)))) "type mismatch")
+;; andnot
+(assert_invalid (module (func (result v128) (v128.andnot (i32.const 0) (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.andnot (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.andnot (i32.const 0) (i32.const 0)))) "type mismatch")
+
+;; Combination
+
+(module (memory 1)
+  (func (export "v128.not-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.not
+            (block (result v128) (v128.load (i32.const 0)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "v128.and-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.and
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "v128.or-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.or
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "v128.xor-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.xor
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "v128.bitselect-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.bitselect
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+            (block (result v128) (v128.load (i32.const 2)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "v128.andnot-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.andnot
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.not")
+    (drop
+      (v128.not
+        (v128.not
+          (v128.not
+            (v128.load (i32.const 0))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.and")
+    (drop
+      (v128.and
+        (v128.and
+          (v128.and
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.and
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+        (v128.and
+          (v128.and
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.and
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.or")
+    (drop
+      (v128.or
+        (v128.or
+          (v128.or
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.or
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+        (v128.or
+          (v128.or
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.or
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.xor")
+    (drop
+      (v128.xor
+        (v128.xor
+          (v128.xor
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.xor
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+        (v128.xor
+          (v128.xor
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.xor
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.bitselect")
+    (drop
+      (v128.bitselect
+        (v128.bitselect
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+        )
+        (v128.bitselect
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+        )
+        (v128.bitselect
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.andnot")
+    (drop
+      (v128.andnot
+        (v128.andnot
+          (v128.andnot
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.andnot
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+        (v128.andnot
+          (v128.andnot
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.andnot
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (v128.or
+        (v128.and
+          (v128.not
+            (v128.load (i32.const 0))
+          )
+          (v128.not
+            (v128.load (i32.const 1))
+          )
+        )
+        (v128.xor
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.andnot
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+      )
+    )
+  )
+)
+(assert_return (invoke "v128.not-in-block"))
+(assert_return (invoke "v128.and-in-block"))
+(assert_return (invoke "v128.or-in-block"))
+(assert_return (invoke "v128.xor-in-block"))
+(assert_return (invoke "v128.bitselect-in-block"))
+(assert_return (invoke "v128.andnot-in-block"))
+(assert_return (invoke "nested-v128.not"))
+(assert_return (invoke "nested-v128.and"))
+(assert_return (invoke "nested-v128.or"))
+(assert_return (invoke "nested-v128.xor"))
+(assert_return (invoke "nested-v128.bitselect"))
+(assert_return (invoke "nested-v128.andnot"))
+(assert_return (invoke "as-param"))
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $v128.not-arg-empty (result v128)
+      (v128.not)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.and-1st-arg-empty (result v128)
+      (v128.and (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.and-arg-empty (result v128)
+      (v128.and)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.or-1st-arg-empty (result v128)
+      (v128.or (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.or-arg-empty (result v128)
+      (v128.or)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.xor-1st-arg-empty (result v128)
+      (v128.xor (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.xor-arg-empty (result v128)
+      (v128.xor)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.andnot-1st-arg-empty (result v128)
+      (v128.andnot (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.andnot-arg-empty (result v128)
+      (v128.andnot)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.bitselect-1st-arg-empty (result v128)
+      (v128.bitselect (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.bitselect-two-args-empty (result v128)
+      (v128.bitselect (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.bitselect-arg-empty (result v128)
+      (v128.bitselect)
+    )
+  )
+  "type mismatch"
+)
diff --git a/tests/wast/spec/simd_boolean.wast b/tests/wast/spec/simd_boolean.wast
new file mode 100644
index 0000000000..6ab330fe50
--- /dev/null
+++ b/tests/wast/spec/simd_boolean.wast
@@ -0,0 +1,1058 @@
+;; Test all the boolean operators on major boundary values and all special values.
+
+(module
+  (func (export "i8x16.any_true") (param $0 v128) (result i32) (v128.any_true (local.get $0)))
+  (func (export "i8x16.all_true") (param $0 v128) (result i32) (i8x16.all_true (local.get $0)))
+  (func (export "i8x16.bitmask") (param $0 v128) (result i32) (i8x16.bitmask (local.get $0)))
+
+  (func (export "i16x8.any_true") (param $0 v128) (result i32) (v128.any_true (local.get $0)))
+  (func (export "i16x8.all_true") (param $0 v128) (result i32) (i16x8.all_true (local.get $0)))
+  (func (export "i16x8.bitmask") (param $0 v128) (result i32) (i16x8.bitmask (local.get $0)))
+
+  (func (export "i32x4.any_true") (param $0 v128) (result i32) (v128.any_true (local.get $0)))
+  (func (export "i32x4.all_true") (param $0 v128) (result i32) (i32x4.all_true (local.get $0)))
+  (func (export "i32x4.bitmask") (param $0 v128) (result i32) (i32x4.bitmask (local.get $0)))
+
+  (func (export "i64x2.all_true") (param $0 v128) (result i32) (i64x2.all_true (local.get $0)))
+  (func (export "i64x2.bitmask") (param $0 v128) (result i32) (i64x2.bitmask (local.get $0)))
+)
+
+;; i8x16
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 -1 0 1 2 3 4 5 6 7 8 9 0xA 0xB 0xC 0xD 0xF))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 -1 0 1 2 3 4 5 6 7 8 9 0xA 0xB 0xC 0xD 0xF))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.bitmask" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 0x0000FFFF))
+(assert_return (invoke "i8x16.bitmask" (v128.const i8x16 -1 0 1 2 3 4 5 6 7 8 9 0xA 0xB 0xC 0xD 0xF))
+                                        (i32.const 0x00000001))
+
+;; i16x8
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 -1 0 1 2 0xB 0xC 0xD 0xF))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 -1 0 1 2 0xB 0xC 0xD 0xF))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.bitmask" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                                        (i32.const 0x000000FF))
+(assert_return (invoke "i16x8.bitmask" (v128.const i16x8 -1 0 1 2 0xB 0xC 0xD 0xF))
+                                        (i32.const 0x00000001))
+
+;; i32x4
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0 0 1 0))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 1 1 0 1))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 -1 0 1 0xF))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0 0 1 0))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 1 1 0 1))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 -1 0 1 0xF))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.bitmask" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                                        (i32.const 0x0000000F))
+(assert_return (invoke "i32x4.bitmask" (v128.const i32x4 -1 0 1 0xF))
+                                        (i32.const 0x00000001))
+
+;; i64x2
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0 1))
+                                        (i32.const 0))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 1 0))
+                                        (i32.const 0))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 -1 0))
+                                        (i32.const 0))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i64x2.bitmask" (v128.const i64x2 0xFFFFFFFF_FFFFFFFF 0xFFFFFFFF_FFFFFFFF))
+                                        (i32.const 0x00000003))
+(assert_return (invoke "i64x2.bitmask" (v128.const i64x2 -1 0xF))
+                                        (i32.const 0x00000001))
+
+;; Combination
+
+(module (memory 1)
+    ;; as if condition
+    (func (export "i8x16_any_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (v128.any_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    (func (export "i16x8_any_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (v128.any_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    (func (export "i32x4_any_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (v128.any_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    (func (export "i8x16_all_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (i8x16.all_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    (func (export "i16x8_all_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (i16x8.all_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    (func (export "i32x4_all_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (i32x4.all_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    ;; any_true as select condition
+    (func (export "i8x16_any_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (v128.any_true (local.get 0)))
+    )
+    (func (export "i16x8_any_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (v128.any_true (local.get 0)))
+    )
+    (func (export "i32x4_any_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (v128.any_true (local.get 0)))
+    )
+    ;; all_true as select condition
+    (func (export "i8x16_all_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (i8x16.all_true (local.get 0)))
+    )
+    (func (export "i16x8_all_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (i16x8.all_true (local.get 0)))
+    )
+    (func (export "i32x4_all_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (i32x4.all_true (local.get 0)))
+    )
+    ;; any_true as br_if condition
+    (func (export "i8x16_any_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (v128.any_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    (func (export "i16x8_any_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (v128.any_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    (func (export "i32x4_any_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (v128.any_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    ;; all_true as br_if condition
+    (func (export "i8x16_all_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (i8x16.all_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    (func (export "i16x8_all_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (i16x8.all_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    (func (export "i32x4_all_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (i32x4.all_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    ;; any_true as i32.and operand
+    (func (export "i8x16_any_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i16x8_any_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i32x4_any_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+     ;; any_true as i32.or operand
+    (func (export "i8x16_any_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i16x8_any_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i32x4_any_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+     ;; any_true as i32.xor operand
+    (func (export "i8x16_any_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i16x8_any_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i32x4_any_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+     ;; all_true as i32.and operand
+    (func (export "i8x16_all_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (i8x16.all_true (local.get $0)) (i8x16.all_true (local.get $1)))
+    )
+    (func (export "i16x8_all_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (i16x8.all_true (local.get $0)) (i16x8.all_true (local.get $1)))
+    )
+    (func (export "i32x4_all_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (i32x4.all_true (local.get $0)) (i32x4.all_true (local.get $1)))
+    )
+     ;; all_true as i32.or operand
+    (func (export "i8x16_all_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (i8x16.all_true (local.get $0)) (i8x16.all_true (local.get $1)))
+    )
+    (func (export "i16x8_all_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (i16x8.all_true (local.get $0)) (i16x8.all_true (local.get $1)))
+    )
+    (func (export "i32x4_all_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (i32x4.all_true (local.get $0)) (i32x4.all_true (local.get $1)))
+    )
+     ;; all_true as i32.xor operand
+    (func (export "i8x16_all_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (i8x16.all_true (local.get $0)) (i8x16.all_true (local.get $1)))
+    )
+    (func (export "i16x8_all_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (i16x8.all_true (local.get $0)) (i16x8.all_true (local.get $1)))
+    )
+    (func (export "i32x4_all_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (i32x4.all_true (local.get $0)) (i32x4.all_true (local.get $1)))
+    )
+    ;; any_true with v128.not
+    (func (export "i8x16_any_true_with_v128.not") (param $0 v128) (result i32)
+       (v128.any_true (v128.not (local.get $0)))
+    )
+    (func (export "i16x8_any_true_with_v128.not") (param $0 v128) (result i32)
+       (v128.any_true (v128.not (local.get $0)))
+    )
+    (func (export "i32x4_any_true_with_v128.not") (param $0 v128) (result i32)
+       (v128.any_true (v128.not (local.get $0)))
+    )
+    ;; any_true with v128.and
+    (func (export "i8x16_any_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.and (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_any_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.and (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_any_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.and (local.get $0) (local.get $1)))
+    )
+    ;; any_true with v128.or
+    (func (export "i8x16_any_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.or (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_any_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.or (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_any_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.or (local.get $0) (local.get $1)))
+    )
+    ;; any_true with v128.xor
+    (func (export "i8x16_any_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_any_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_any_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    ;; any_true with v128.bitselect
+    (func (export "i8x16_any_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (v128.any_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+    (func (export "i16x8_any_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (v128.any_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+    (func (export "i32x4_any_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (v128.any_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+    ;; all_true with v128.not
+    (func (export "i8x16_all_true_with_v128.not") (param $0 v128) (result i32)
+       (i8x16.all_true (v128.not (local.get $0)))
+    )
+    (func (export "i16x8_all_true_with_v128.not") (param $0 v128) (result i32)
+       (i16x8.all_true (v128.not (local.get $0)))
+    )
+    (func (export "i32x4_all_true_with_v128.not") (param $0 v128) (result i32)
+       (i32x4.all_true (v128.not (local.get $0)))
+    )
+    ;; all_true with v128.and
+    (func (export "i8x16_all_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (i8x16.all_true (v128.and (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_all_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (i16x8.all_true (v128.and (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_all_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (i32x4.all_true (v128.and (local.get $0) (local.get $1)))
+    )
+    ;; all_true with v128.or
+    (func (export "i8x16_all_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (i8x16.all_true (v128.or (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_all_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (i16x8.all_true (v128.or (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_all_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (i32x4.all_true (v128.or (local.get $0) (local.get $1)))
+    )
+    ;; all_true with v128.xor
+    (func (export "i8x16_all_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (i8x16.all_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_all_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (i16x8.all_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_all_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (i32x4.all_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    ;; all_true with v128.bitselect
+    (func (export "i8x16_all_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (i8x16.all_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+    (func (export "i16x8_all_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (i16x8.all_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+    (func (export "i32x4_all_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (i32x4.all_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+)
+
+;; 'any_true' as 'if' condition
+;; i8x16
+(assert_return (invoke "i8x16_any_true_as_if_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_if_cond" (v128.const i8x16 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0))
+                                                   (i32.const 1))
+(assert_return (invoke "i8x16_any_true_as_if_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (i32.const 1))
+;; i16x8
+(assert_return (invoke "i16x8_any_true_as_if_cond" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_if_cond" (v128.const i16x8 0 0 1 0 0 0 1 0))
+                                                   (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_if_cond" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (i32.const 1))
+;; i32x4
+(assert_return (invoke "i32x4_any_true_as_if_cond" (v128.const i32x4 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_if_cond" (v128.const i32x4 0 0 1 0))
+                                                   (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_if_cond" (v128.const i32x4 1 1 1 1))
+                                                   (i32.const 1))
+
+;; 'all_true' as 'if' condition
+;; i8x16
+(assert_return (invoke "i8x16_all_true_as_if_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i8x16_all_true_as_if_cond" (v128.const i8x16 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i8x16_all_true_as_if_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (i32.const 1))
+;; i16x8
+(assert_return (invoke "i16x8_all_true_as_if_cond" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_if_cond" (v128.const i16x8 1 1 1 0 1 1 1 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_if_cond" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (i32.const 1))
+;; i32x4
+(assert_return (invoke "i32x4_all_true_as_if_cond" (v128.const i32x4 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_if_cond" (v128.const i32x4 1 1 1 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_if_cond" (v128.const i32x4 1 1 1 1))
+                                                   (i32.const 1))
+
+;; any_true as select condition
+(assert_return (invoke "i8x16_any_true_as_select_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                       (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_select_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                       (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_select_cond" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                       (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_select_cond" (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                       (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_select_cond" (v128.const i32x4 0 0 0 0))
+                                                       (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_select_cond" (v128.const i32x4 0 0 1 0))
+                                                       (i32.const 1))
+;; all_true as select condition
+(assert_return (invoke "i8x16_all_true_as_select_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                       (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_select_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                                       (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_select_cond" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                       (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_select_cond" (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                                       (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_select_cond" (v128.const i32x4 1 1 1 1))
+                                                       (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_select_cond" (v128.const i32x4 1 1 0 1))
+                                                       (i32.const 0))
+;; any_true as br_if condition
+(assert_return (invoke "i8x16_any_true_as_br_if_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_br_if_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_br_if_cond" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_br_if_cond" (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_br_if_cond" (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_br_if_cond" (v128.const i32x4 0 0 1 0))
+                                                      (i32.const 1))
+;; all_true as br_if condition
+(assert_return (invoke "i8x16_all_true_as_br_if_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                      (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_br_if_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_br_if_cond" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_br_if_cond" (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_br_if_cond" (v128.const i32x4 1 1 1 1))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_br_if_cond" (v128.const i32x4 1 1 0 1))
+                                                      (i32.const 0))
+;; any_true as and operand
+(assert_return (invoke "i8x16_any_true_as_i32.and_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_i32.and_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_i32.and_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                           (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_i32.and_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_i32.and_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_i32.and_operand" (v128.const i16x8 0 0 0 0 0 0 1 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                           (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_i32.and_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_i32.and_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_i32.and_operand" (v128.const i32x4 0 0 1 0)
+                                                           (v128.const i32x4 0 0 1 0))
+                                                           (i32.const 1))
+;; any_true as or operand
+(assert_return (invoke "i8x16_any_true_as_i32.or_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                          (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                          (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_i32.or_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                          (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                          (i32.const 1))
+(assert_return (invoke "i8x16_any_true_as_i32.or_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)
+                                                          (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                          (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_i32.or_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                          (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                          (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_i32.or_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                          (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                          (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_i32.or_operand" (v128.const i16x8 0 0 0 0 0 0 1 0)
+                                                          (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                          (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_i32.or_operand" (v128.const i32x4 0 0 0 0)
+                                                          (v128.const i32x4 0 0 0 0))
+                                                          (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_i32.or_operand" (v128.const i32x4 0 0 0 0)
+                                                          (v128.const i32x4 0 0 1 0))
+                                                          (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_i32.or_operand" (v128.const i32x4 0 0 1 0)
+                                                          (v128.const i32x4 0 0 1 0))
+                                                          (i32.const 1))
+;; any_true as xor operand
+(assert_return (invoke "i8x16_any_true_as_i32.xor_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_i32.xor_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                           (i32.const 1))
+(assert_return (invoke "i8x16_any_true_as_i32.xor_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_i32.xor_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_i32.xor_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                           (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_i32.xor_operand" (v128.const i16x8 0 0 0 0 0 0 1 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_i32.xor_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_i32.xor_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 1 0))
+                                                           (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_i32.xor_operand" (v128.const i32x4 0 0 1 0)
+                                                           (v128.const i32x4 0 0 1 0))
+                                                           (i32.const 0))
+;; all_true as and operand
+(assert_return (invoke "i8x16_all_true_as_i32.and_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                           (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_i32.and_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                           (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i8x16_all_true_as_i32.and_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_i32.and_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_i32.and_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                           (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_i32.and_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_i32.and_operand" (v128.const i32x4 1 1 1 1)
+                                                           (v128.const i32x4 1 1 1 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_i32.and_operand" (v128.const i32x4 1 1 1 1)
+                                                           (v128.const i32x4 1 1 0 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_i32.and_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 1 0))
+                                                           (i32.const 0))
+;; all_true as or operand
+(assert_return (invoke "i8x16_all_true_as_i32.or_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                          (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_i32.or_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                          (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_i32.or_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                          (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                          (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_i32.or_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                          (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_i32.or_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                          (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_i32.or_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                          (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                          (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_i32.or_operand" (v128.const i32x4 1 1 1 1)
+                                                          (v128.const i32x4 1 1 1 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_i32.or_operand" (v128.const i32x4 1 1 1 1)
+                                                          (v128.const i32x4 1 1 0 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_i32.or_operand" (v128.const i32x4 0 0 0 0)
+                                                          (v128.const i32x4 0 0 0 0))
+                                                          (i32.const 0))
+;; all_true as xor operand
+(assert_return (invoke "i8x16_all_true_as_i32.xor_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                           (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i8x16_all_true_as_i32.xor_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                           (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_i32.xor_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_i32.xor_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_i32.xor_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                           (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_i32.xor_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_i32.xor_operand" (v128.const i32x4 1 1 1 1)
+                                                           (v128.const i32x4 1 1 1 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_i32.xor_operand" (v128.const i32x4 1 1 1 1)
+                                                           (v128.const i32x4 1 1 0 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_i32.xor_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 0 0))
+                                                           (i32.const 0))
+;; any_true with v128.not
+(assert_return (invoke "i8x16_any_true_with_v128.not" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i8x16_any_true_with_v128.not" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.not" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.not" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.not" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.not" (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.not" (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.not" (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.not" (v128.const i32x4 0 0 -1 0))
+                                                      (i32.const 1))
+;; any_true with v128.and
+(assert_return (invoke "i8x16_any_true_with_v128.and" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.and" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i8x16_any_true_with_v128.and" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.and" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.and" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.and" (v128.const i16x8 0 0 0 0 0 0 -1 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.and" (v128.const i32x4 0 0 0 0)
+                                                      (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.and" (v128.const i32x4 -1 -1 -1 -1)
+                                                      (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.and" (v128.const i32x4 0 0 -1 0)
+                                                      (v128.const i32x4 0 0 -1 0))
+                                                      (i32.const 1))
+;; any_true with v128.or
+(assert_return (invoke "i8x16_any_true_with_v128.or" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.or" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i8x16_any_true_with_v128.or" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                     (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.or" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.or" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.or" (v128.const i16x8 0 0 0 0 0 0 -1 0)
+                                                     (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                     (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.or" (v128.const i32x4 0 0 0 0)
+                                                     (v128.const i32x4 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.or" (v128.const i32x4 -1 -1 -1 -1)
+                                                     (v128.const i32x4 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.or" (v128.const i32x4 0 0 -1 0)
+                                                     (v128.const i32x4 0 0 -1 0))
+                                                     (i32.const 1))
+;; any_true with v128.xor
+(assert_return (invoke "i8x16_any_true_with_v128.xor" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.xor" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.xor" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.xor" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.xor" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.xor" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.xor" (v128.const i32x4 0 0 0 0)
+                                                      (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.xor" (v128.const i32x4 -1 -1 -1 -1)
+                                                      (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.xor" (v128.const i32x4 0 0 0 0)
+                                                      (v128.const i32x4 0 0 -1 0))
+                                                      (i32.const 1))
+;; any_true with v128.bitselect
+(assert_return (invoke "i8x16_any_true_with_v128.bitselect" (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.bitselect" (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0xFF 0x55))
+                                                            (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.bitselect" (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.bitselect" (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0xFF 0x55))
+                                                            (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.bitselect" (v128.const i32x4 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.bitselect" (v128.const i32x4 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55)
+                                                            (v128.const i32x4 0x55 0x55 0xFF 0x55))
+                                                            (i32.const 1))
+;; all_true with v128.not
+(assert_return (invoke "i8x16_all_true_with_v128.not" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i8x16_all_true_with_v128.not" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.not" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.not" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_all_true_with_v128.not" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.not" (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.not" (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_all_true_with_v128.not" (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.not" (v128.const i32x4 0 0 -1 0))
+                                                      (i32.const 0))
+;; all_true with v128.and
+(assert_return (invoke "i8x16_all_true_with_v128.and" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.and" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i8x16_all_true_with_v128.and" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.and" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.and" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_all_true_with_v128.and" (v128.const i16x8 0 0 0 0 0 0 -1 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.and" (v128.const i32x4 0 0 0 0)
+                                                      (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.and" (v128.const i32x4 -1 -1 -1 -1)
+                                                      (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_all_true_with_v128.and" (v128.const i32x4 0 0 -1 0)
+                                                      (v128.const i32x4 0 0 -1 0))
+                                                      (i32.const 0))
+;; all_true with v128.or
+(assert_return (invoke "i8x16_all_true_with_v128.or" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.or" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i8x16_all_true_with_v128.or" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.or" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.or" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i16x8_all_true_with_v128.or" (v128.const i16x8 0 0 0 0 0 0 -1 0)
+                                                     (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.or" (v128.const i32x4 0 0 0 0)
+                                                     (v128.const i32x4 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.or" (v128.const i32x4 -1 -1 -1 -1)
+                                                     (v128.const i32x4 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i32x4_all_true_with_v128.or" (v128.const i32x4 0 0 -1 0)
+                                                     (v128.const i32x4 0 0 -1 0))
+                                                     (i32.const 0))
+;; all_true with v128.xor
+(assert_return (invoke "i8x16_all_true_with_v128.xor" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.xor" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.xor" (v128.const i8x16 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1)
+                                                      (v128.const i8x16 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_all_true_with_v128.xor" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.xor" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.xor" (v128.const i16x8 0 -1 0 -1 0 -1 0 -1)
+                                                      (v128.const i16x8 -1 0 -1 0 -1 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_all_true_with_v128.xor" (v128.const i32x4 0 0 0 0)
+                                                      (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.xor" (v128.const i32x4 -1 -1 -1 -1)
+                                                      (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.xor" (v128.const i32x4 0 -1 0 -1)
+                                                      (v128.const i32x4 -1 0 -1 0))
+                                                      (i32.const 1))
+;; all_true with v128.bitselect
+(assert_return (invoke "i8x16_all_true_with_v128.bitselect" (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.bitselect" (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                                                            (i32.const 1))
+(assert_return (invoke "i16x8_all_true_with_v128.bitselect" (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.bitselect" (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                                                            (i32.const 1))
+(assert_return (invoke "i32x4_all_true_with_v128.bitselect" (v128.const i32x4 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.bitselect" (v128.const i32x4 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55)
+                                                            (v128.const i32x4 0xAA 0xAA 0xAA 0xAA))
+                                                            (i32.const 1))
+
+;; Type check
+
+(assert_invalid (module (func (result i32) (v128.any_true (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i8x16.all_true (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (v128.any_true (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i16x8.all_true (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (v128.any_true (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32x4.all_true (i32.const 0)))) "type mismatch")
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result i32) (f32x4.any_true (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result i32) (f32x4.all_true (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result i32) (f64x2.any_true (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result i32) (f64x2.all_true (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $v128.any_true-arg-empty (result v128)
+      (v128.any_true)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.all_true-arg-empty (result v128)
+      (i8x16.all_true)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.any_true-arg-empty (result v128)
+      (v128.any_true)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.all_true-arg-empty (result v128)
+      (i16x8.all_true)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.any_true-arg-empty (result v128)
+      (v128.any_true)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.all_true-arg-empty (result v128)
+      (i32x4.all_true)
+    )
+  )
+  "type mismatch"
+)
diff --git a/tests/wast/spec/simd_const.wast b/tests/wast/spec/simd_const.wast
new file mode 100644
index 0000000000..8080cfb0f9
--- /dev/null
+++ b/tests/wast/spec/simd_const.wast
@@ -0,0 +1,1664 @@
+;; v128.const normal parameter (e.g. (i8x16, i16x8 i32x4, f32x4))
+
+(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF) drop))
+(module (func (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) drop))
+(module (func (v128.const i8x16  255  255  255  255  255  255  255  255  255  255  255  255  255  255  255  255) drop))
+(module (func (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) drop))
+(module (func (v128.const i16x8  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF) drop))
+(module (func (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000) drop))
+(module (func (v128.const i16x8  65535  65535  65535  65535  65535  65535  65535  65535) drop))
+(module (func (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) drop))
+(module (func (v128.const i16x8  65_535  65_535  65_535  65_535  65_535  65_535  65_535  65_535) drop))
+(module (func (v128.const i16x8 -32_768 -32_768 -32_768 -32_768 -32_768 -32_768 -32_768 -32_768) drop))
+(module (func (v128.const i16x8  0_123_45 0_123_45 0_123_45 0_123_45 0_123_45 0_123_45 0_123_45 0_123_45) drop))
+(module (func (v128.const i16x8  0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) drop))
+(module (func (v128.const i32x4  0xffffffff  0xffffffff  0xffffffff  0xffffffff) drop))
+(module (func (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000) drop))
+(module (func (v128.const i32x4  4294967295  4294967295  4294967295  4294967295) drop))
+(module (func (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) drop))
+(module (func (v128.const i32x4  0xffff_ffff  0xffff_ffff  0xffff_ffff  0xffff_ffff) drop))
+(module (func (v128.const i32x4 -0x8000_0000 -0x8000_0000 -0x8000_0000 -0x8000_0000) drop))
+(module (func (v128.const i32x4 4_294_967_295  4_294_967_295  4_294_967_295  4_294_967_295) drop))
+(module (func (v128.const i32x4 -2_147_483_648 -2_147_483_648 -2_147_483_648 -2_147_483_648) drop))
+(module (func (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789) drop))
+(module (func (v128.const i32x4 0x0_9acf_fBDF 0x0_9acf_fBDF 0x0_9acf_fBDF 0x0_9acf_fBDF) drop))
+(module (func (v128.const i64x2  0xffffffffffffffff  0xffffffffffffffff) drop))
+(module (func (v128.const i64x2 -0x8000000000000000 -0x8000000000000000) drop))
+(module (func (v128.const i64x2  18446744073709551615 18446744073709551615) drop))
+(module (func (v128.const i64x2 -9223372036854775808 -9223372036854775808) drop))
+(module (func (v128.const i64x2  0xffff_ffff_ffff_ffff  0xffff_ffff_ffff_ffff) drop))
+(module (func (v128.const i64x2 -0x8000_0000_0000_0000 -0x8000_0000_0000_0000) drop))
+(module (func (v128.const i64x2  18_446_744_073_709_551_615 18_446_744_073_709_551_615) drop))
+(module (func (v128.const i64x2 -9_223_372_036_854_775_808 -9_223_372_036_854_775_808) drop))
+(module (func (v128.const i64x2  0_123_456_789 0_123_456_789) drop))
+(module (func (v128.const i64x2  0x0125_6789_ADEF_bcef 0x0125_6789_ADEF_bcef) drop))
+(module (func (v128.const f32x4  0x1p127  0x1p127  0x1p127  0x1p127) drop))
+(module (func (v128.const f32x4 -0x1p127 -0x1p127 -0x1p127 -0x1p127) drop))
+(module (func (v128.const f32x4  1e38  1e38  1e38  1e38) drop))
+(module (func (v128.const f32x4 -1e38 -1e38 -1e38 -1e38) drop))
+(module (func (v128.const f32x4  340282356779733623858607532500980858880 340282356779733623858607532500980858880
+                                 340282356779733623858607532500980858880 340282356779733623858607532500980858880) drop))
+(module (func (v128.const f32x4 -340282356779733623858607532500980858880 -340282356779733623858607532500980858880
+                                -340282356779733623858607532500980858880 -340282356779733623858607532500980858880) drop))
+(module (func (v128.const f32x4 nan:0x1 nan:0x1 nan:0x1 nan:0x1) drop))
+(module (func (v128.const f32x4 nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff) drop))
+(module (func (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) drop))
+(module (func (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) drop))
+(module (func (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) drop))
+(module (func (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) drop))
+(module (func (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) drop))
+(module (func (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) drop))
+(module (func (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) drop))
+(module (func (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) drop))
+(module (func (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) drop))
+(module (func (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) drop))
+(module (func (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) drop))
+(module (func (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) drop))
+(module (func (v128.const f64x2  0x1p1023  0x1p1023) drop))
+(module (func (v128.const f64x2 -0x1p1023 -0x1p1023) drop))
+(module (func (v128.const f64x2  1e308  1e308) drop))
+(module (func (v128.const f64x2 -1e308 -1e308) drop))
+(module (func (v128.const f64x2  179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368
+                                 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop))
+(module (func (v128.const f64x2 -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368
+                                -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop))
+(module (func (v128.const f64x2 nan:0x1 nan:0x1) drop))
+(module (func (v128.const f64x2 nan:0xf_ffff_ffff_ffff nan:0xf_ffff_ffff_ffff) drop))
+(module (func (v128.const f64x2 0123456789 0123456789) drop))
+(module (func (v128.const f64x2 0123456789e019 0123456789e019) drop))
+(module (func (v128.const f64x2 0123456789e+019 0123456789e+019) drop))
+(module (func (v128.const f64x2 0123456789e-019 0123456789e-019) drop))
+(module (func (v128.const f64x2 0123456789. 0123456789.) drop))
+(module (func (v128.const f64x2 0123456789.e019 0123456789.e019) drop))
+(module (func (v128.const f64x2 0123456789.e+019 0123456789.e+019) drop))
+(module (func (v128.const f64x2 0123456789.e-019 0123456789.e-019) drop))
+(module (func (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) drop))
+(module (func (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) drop))
+(module (func (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) drop))
+(module (func (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) drop))
+
+;; Non-splat cases
+
+(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF
+                                -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) drop))
+(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF   255   255   255   255
+                                -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) drop))
+(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF   255   255   255   255
+                                -0x80 -0x80 -0x80 -0x80  -128  -128  -128  -128) drop))
+(module (func (v128.const i16x8 0xFF 0xFF  0xFF  0xFF -0x8000 -0x8000 -0x8000 -0x8000) drop))
+(module (func (v128.const i16x8 0xFF 0xFF 65535 65535 -0x8000 -0x8000 -0x8000 -0x8000) drop))
+(module (func (v128.const i16x8 0xFF 0xFF 65535 65535 -0x8000 -0x8000  -32768  -32768) drop))
+(module (func (v128.const i32x4 0xffffffff 0xffffffff -0x80000000 -0x80000000) drop))
+(module (func (v128.const i32x4 0xffffffff 4294967295 -0x80000000 -0x80000000) drop))
+(module (func (v128.const i32x4 0xffffffff 4294967295 -0x80000000 -2147483648) drop))
+(module (func (v128.const f32x4 0x1p127 0x1p127 -0x1p127 -1e38) drop))
+(module (func (v128.const f32x4 0x1p127 340282356779733623858607532500980858880 -1e38 -340282356779733623858607532500980858880) drop))
+(module (func (v128.const f32x4 nan -nan inf -inf) drop))
+(module (func (v128.const i64x2 0xffffffffffffffff 0x8000000000000000) drop))
+(module (func (v128.const i64x2 0xffffffffffffffff -9223372036854775808) drop))
+(module (func (v128.const f64x2 0x1p1023 -1e308) drop))
+(module (func (v128.const f64x2 nan -inf) drop))
+
+;; Constant out of range (int literal is too large)
+
+(module (memory 1))
+(assert_malformed
+  (module quote "(func (v128.const i8x16 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 0x10000 0x10000 0x10000 0x10000 0x10000 0x10000 0x10000 0x10000) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 65536 65536 65536 65536 65536 65536 65536 65536) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 -32769 -32769 -32769 -32769 -32769 -32769 -32769 -32769) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4  0x100000000  0x100000000  0x100000000  0x100000000) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 -0x80000001 -0x80000001 -0x80000001 -0x80000001) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4  4294967296  4294967296  4294967296  4294967296) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 -2147483649 -2147483649 -2147483649 -2147483649) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4  0x1p128  0x1p128  0x1p128  0x1p128) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 -0x1p128 -0x1p128 -0x1p128 -0x1p128) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4  1e39  1e39  1e39  1e39) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 -1e39 -1e39 -1e39 -1e39) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4  340282356779733661637539395458142568448 340282356779733661637539395458142568448"
+                "                         340282356779733661637539395458142568448 340282356779733661637539395458142568448) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 -340282356779733661637539395458142568448 -340282356779733661637539395458142568448"
+                "                        -340282356779733661637539395458142568448 -340282356779733661637539395458142568448) drop)")
+  "constant out of range"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f32x4 nan:0x80_0000 nan:0x80_0000 nan:0x80_0000 nan:0x80_0000) drop)")
+  "constant out of range"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f64x2  269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552"
+                "                         269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 -269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552"
+                "                        -269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop)")
+  "constant out of range"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f64x2 nan:0x10_0000_0000_0000 nan:0x10_0000_0000_0000) drop)")
+  "constant out of range"
+)
+
+;; More malformed v128.const forms
+(assert_malformed
+  (module quote "(func (v128.const) drop)")
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const 0 0 0 0) drop)")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg) drop)")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const i16x8) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 0x 0x 0x 0x 0x 0x 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 1x 1x 1x 1x 1x 1x 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg) drop)")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const i32x4) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 0x 0x 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 1x 1x 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 0xg 0xg 0xg 0xg) drop)")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const i64x2) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const i64x2 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0xg 0xg) drop)")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f32x4) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 .0 .0 .0 .0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 .0e0 .0e0 .0e0 .0e0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0e 0e 0e 0e) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0e+ 0e+ 0e+ 0e+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0.0e 0.0e 0.0e 0.0e) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0.0e- 0.0e- 0.0e- 0.0e-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x 0x 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 1x 1x 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0xg 0xg 0xg 0xg) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x. 0x. 0x. 0x.) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0.g 0x0.g 0x0.g 0x0.g) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0p 0x0p 0x0p 0x0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0p+ 0x0p+ 0x0p+ 0x0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0p- 0x0p- 0x0p- 0x0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0.0p 0x0.0p 0x0.0p 0x0.0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0.0p+ 0x0.0p+ 0x0.0p+ 0x0.0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0.0p- 0x0.0p- 0x0.0p- 0x0.0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0pA 0x0pA 0x0pA 0x0pA) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 nan:1 nan:1 nan:1 nan:1) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 nan:0x0 nan:0x0 nan:0x0 nan:0x0) drop)")
+  "constant out of range"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f64x2) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 .0 .0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 .0e0 .0e0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0e 0e) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0e+ 0e+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0.0e+ 0.0e+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0.0e- 0.0e-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0xg 0xg) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x. 0x.) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0.g 0x0.g) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0p 0x0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0p+ 0x0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0p- 0x0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0.0p 0x0.0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0.0p+ 0x0.0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0.0p- 0x0.0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0pA 0x0pA) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 nan:1 nan:1) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 nan:0x0 nan:0x0) drop)")
+  "constant out of range"
+)
+
+;; too little arguments
+
+(assert_malformed
+  (module quote "(func (v128.const i32x4 0x10000000000000000 0x10000000000000000) drop)")
+  "wrong number of lane literals"
+)
+
+;; too many arguments
+(assert_malformed
+  (module quote "(func (v128.const i32x4 0x1 0x1 0x1 0x1 0x1) drop)")
+  "wrong number of lane literals"
+)
+
+;; Rounding behaviour
+
+;; f32x4, small exponent
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000100000000000p-50 +0x1.00000100000000000p-50 +0x1.00000100000000000p-50 +0x1.00000100000000000p-50)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000100000000000p-50 -0x1.00000100000000000p-50 -0x1.00000100000000000p-50 -0x1.00000100000000000p-50)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000500000000001p-50 +0x1.00000500000000001p-50 +0x1.00000500000000001p-50 +0x1.00000500000000001p-50)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000500000000001p-50 -0x1.00000500000000001p-50 -0x1.00000500000000001p-50 -0x1.00000500000000001p-50)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50))
+
+(module (func (export "f") (result v128) (v128.const f32x4 +0x4000.004000000p-64 +0x4000.004000000p-64 +0x4000.004000000p-64 +0x4000.004000000p-64)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x4000.004000000p-64 -0x4000.004000000p-64 -0x4000.004000000p-64 -0x4000.004000000p-64)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x4000.014000001p-64 +0x4000.014000001p-64 +0x4000.014000001p-64 +0x4000.014000001p-64)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x4000.014000001p-64 -0x4000.014000001p-64 -0x4000.014000001p-64 -0x4000.014000001p-64)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50))
+
+(module (func (export "f") (result v128) (v128.const f32x4 +8.8817847263968443573e-16 +8.8817847263968443573e-16 +8.8817847263968443573e-16 +8.8817847263968443573e-16)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -8.8817847263968443573e-16 -8.8817847263968443573e-16 -8.8817847263968443573e-16 -8.8817847263968443573e-16)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 +8.8817857851880284253e-16 +8.8817857851880284253e-16 +8.8817857851880284253e-16 +8.8817857851880284253e-16)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000004p-50 +0x1.000004p-50 +0x1.000004p-50 +0x1.000004p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -8.8817857851880284253e-16 -8.8817857851880284253e-16 -8.8817857851880284253e-16 -8.8817857851880284253e-16)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000004p-50 -0x1.000004p-50 -0x1.000004p-50 -0x1.000004p-50))
+
+;; f32x4, large exponent
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000100000000000p+50 +0x1.00000100000000000p+50 +0x1.00000100000000000p+50 +0x1.00000100000000000p+50)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000100000000000p+50 -0x1.00000100000000000p+50 -0x1.00000100000000000p+50 -0x1.00000100000000000p+50)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000500000000001p+50 +0x1.00000500000000001p+50 +0x1.00000500000000001p+50 +0x1.00000500000000001p+50)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000006p+50 +0x1.000006p+50 +0x1.000006p+50 +0x1.000006p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000500000000001p+50 -0x1.00000500000000001p+50 -0x1.00000500000000001p+50 -0x1.00000500000000001p+50)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000006p+50 -0x1.000006p+50 -0x1.000006p+50 -0x1.000006p+50))
+
+(module (func (export "f") (result v128) (v128.const f32x4 +0x4000004000000 +0x4000004000000 +0x4000004000000 +0x4000004000000)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x4000004000000 -0x4000004000000 -0x4000004000000 -0x4000004000000)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x400000c000000 +0x400000c000000 +0x400000c000000 +0x400000c000000)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x400000c000000 -0x400000c000000 -0x400000c000000 -0x400000c000000)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50))
+
+(module (func (export "f") (result v128) (v128.const f32x4 +1125899973951488 +1125899973951488 +1125899973951488 +1125899973951488)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -1125899973951488 -1125899973951488 -1125899973951488 -1125899973951488)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 +1125900108169216 +1125900108169216 +1125900108169216 +1125900108169216)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -1125900108169216 -1125900108169216 -1125900108169216 -1125900108169216)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50))
+
+;; f32x4, subnormal
+(module (func (export "f") (result v128) (v128.const f32x4 +0x0.00000100000000000p-126 +0x0.00000100000000000p-126 +0x0.00000100000000000p-126 +0x0.00000100000000000p-126)))
+(assert_return (invoke "f") (v128.const f32x4 +0x0.000000p-126 +0x0.000000p-126 +0x0.000000p-126 +0x0.000000p-126))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126)))
+(assert_return (invoke "f") (v128.const f32x4 -0x0.000000p-126 -0x0.000000p-126 -0x0.000000p-126 -0x0.000000p-126))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126)))
+(assert_return (invoke "f") (v128.const f32x4 +0x0.000006p-126 +0x0.000006p-126 +0x0.000006p-126 +0x0.000006p-126))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x0.00000500000000001p-126 -0x0.00000500000000001p-126 -0x0.00000500000000001p-126 -0x0.00000500000000001p-126)))
+(assert_return (invoke "f") (v128.const f32x4 -0x0.000006p-126 -0x0.000006p-126 -0x0.000006p-126 -0x0.000006p-126))
+
+;; f32x4, round down at limit to infinity
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.fffffe8p127 +0x1.fffffe8p127 +0x1.fffffe8p127 +0x1.fffffe8p127)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.fffffe8p127 -0x1.fffffe8p127 -0x1.fffffe8p127 -0x1.fffffe8p127)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.fffffefffffffffffp127 +0x1.fffffefffffffffffp127 +0x1.fffffefffffffffffp127 +0x1.fffffefffffffffffp127)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.fffffefffffffffffp127 -0x1.fffffefffffffffffp127 -0x1.fffffefffffffffffp127 -0x1.fffffefffffffffffp127)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127))
+
+;; f64x2, small exponent
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.0000000000000fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.0000000000000fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.00000000000017ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.00000000000017ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.0000000000001fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.0000000000001fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.00000000000027ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.00000000000027ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000003p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000003p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000400000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000400000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000400000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000400000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.0000007fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.0000007fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000800000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000800000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000800000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000800000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000bfffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000bfffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000c00000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000c00000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000c00000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000c00000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000ffffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000ffffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000001000000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000001000000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000001000000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000001000000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.0000013fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.0000013fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000001400000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000003p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000001400000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000003p-600))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313371995e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000000p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313371995e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000000p+999))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313371996e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313371996e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313383891e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313383891e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313383892e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313383892e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p+999))
+
+;; f64, large exponent
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000080000000000p+600 +0x1.000000000000080000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000000p+600 +0x1.0000000000000p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000080000000000p+600 -0x1.000000000000080000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000000p+600 -0x1.0000000000000p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000080000000001p+600 +0x1.000000000000080000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000080000000001p+600 -0x1.000000000000080000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.0000000000000fffffffffffp+600 +0x1.0000000000000fffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.0000000000000fffffffffffp+600 -0x1.0000000000000fffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000100000000000p+600 +0x1.000000000000100000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000100000000000p+600 -0x1.000000000000100000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000100000000001p+600 +0x1.000000000000100000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000100000000001p+600 -0x1.000000000000100000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.00000000000017ffffffffffp+600 +0x1.00000000000017ffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.00000000000017ffffffffffp+600 -0x1.00000000000017ffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000180000000000p+600 +0x1.000000000000180000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000180000000000p+600 -0x1.000000000000180000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000180000000001p+600 +0x1.000000000000180000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000180000000001p+600 -0x1.000000000000180000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.0000000000001fffffffffffp+600 +0x1.0000000000001fffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.0000000000001fffffffffffp+600 -0x1.0000000000001fffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000200000000000p+600 +0x1.000000000000200000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000200000000000p+600 -0x1.000000000000200000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000200000000001p+600 +0x1.000000000000200000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000200000000001p+600 -0x1.000000000000200000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.00000000000027ffffffffffp+600 +0x1.00000000000027ffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.00000000000027ffffffffffp+600 -0x1.00000000000027ffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000280000000000p+600 +0x1.000000000000280000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000280000000000p+600 -0x1.000000000000280000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000280000000001p+600 +0x1.000000000000280000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000003p+600 +0x1.0000000000003p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000280000000001p+600 -0x1.000000000000280000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000003p+600 -0x1.0000000000003p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000100000000000 +0x2000000000000100000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000000p+97 +0x1.0000000000000p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000100000000000 -0x2000000000000100000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000000p+97 -0x1.0000000000000p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000100000000001 +0x2000000000000100000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000100000000001 -0x2000000000000100000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000001fffffffffff +0x20000000000001fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000001fffffffffff -0x20000000000001fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000200000000000 +0x2000000000000200000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000200000000000 -0x2000000000000200000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000200000000001 +0x2000000000000200000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000200000000001 -0x2000000000000200000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000002fffffffffff +0x20000000000002fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000002fffffffffff -0x20000000000002fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000300000000000 +0x2000000000000300000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000300000000000 -0x2000000000000300000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000300000000001 +0x2000000000000300000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000300000000001 -0x2000000000000300000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000003fffffffffff +0x20000000000003fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000003fffffffffff -0x20000000000003fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000400000000000 +0x2000000000000400000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000400000000000 -0x2000000000000400000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000400000000001 +0x2000000000000400000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000400000000001 -0x2000000000000400000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000004fffffffffff +0x20000000000004fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000004fffffffffff -0x20000000000004fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000500000000000 +0x2000000000000500000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000500000000000 -0x2000000000000500000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000500000000001 +0x2000000000000500000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000003p+97 +0x1.0000000000003p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000500000000001 -0x2000000000000500000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000003p+97 -0x1.0000000000003p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847104 +1152921504606847104)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000000p+60 +0x1.0000000000000p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847104 -1152921504606847104)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000000p+60 -0x1.0000000000000p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847105 +1152921504606847105)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+60 +0x1.0000000000001p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847105 -1152921504606847105)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+60 -0x1.0000000000001p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847359 +1152921504606847359)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+60 +0x1.0000000000001p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847359 -1152921504606847359)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+60 -0x1.0000000000001p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847360 +1152921504606847360)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+60 +0x1.0000000000002p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847360 -1152921504606847360)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+60 -0x1.0000000000002p+60))
+
+;; f64x2, subnormal
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000080000000000p-1022 +0x0.000000000000080000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000000p-1022 +0x0.0000000000000p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000080000000000p-1022 -0x0.000000000000080000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000000p-1022 -0x0.0000000000000p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000080000000001p-1022 +0x0.000000000000080000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000080000000001p-1022 -0x0.000000000000080000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.0000000000000fffffffffffp-1022 +0x0.0000000000000fffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.0000000000000fffffffffffp-1022 -0x0.0000000000000fffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000100000000000p-1022 +0x0.000000000000100000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000100000000000p-1022 -0x0.000000000000100000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000100000000001p-1022 +0x0.000000000000100000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000100000000001p-1022 -0x0.000000000000100000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.00000000000017ffffffffffp-1022 +0x0.00000000000017ffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.00000000000017ffffffffffp-1022 -0x0.00000000000017ffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000180000000000p-1022 +0x0.000000000000180000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000180000000000p-1022 -0x0.000000000000180000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000180000000001p-1022 +0x0.000000000000180000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000180000000001p-1022 -0x0.000000000000180000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.0000000000001fffffffffffp-1022 +0x0.0000000000001fffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.0000000000001fffffffffffp-1022 -0x0.0000000000001fffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000200000000000p-1022 +0x0.000000000000200000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000200000000000p-1022 -0x0.000000000000200000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000200000000001p-1022 +0x0.000000000000200000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000200000000001p-1022 -0x0.000000000000200000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.00000000000027ffffffffffp-1022 +0x0.00000000000027ffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.00000000000027ffffffffffp-1022 -0x0.00000000000027ffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000280000000000p-1022 +0x0.000000000000280000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000280000000000p-1022 -0x0.000000000000280000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000280000000001p-1022 +0x1.000000000000280000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000003p-1022 +0x1.0000000000003p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000280000000001p-1022 -0x1.000000000000280000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000003p-1022 -0x1.0000000000003p-1022))
+
+;; f64x2, round down at limit to infinity
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.fffffffffffff4p1023 +0x1.fffffffffffff4p1023)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.fffffffffffffp1023 +0x1.fffffffffffffp1023))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.fffffffffffff4p1023 -0x1.fffffffffffff4p1023)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.fffffffffffffp1023 -0x1.fffffffffffffp1023))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.fffffffffffff7ffffffp1023 +0x1.fffffffffffff7ffffffp1023)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.fffffffffffffp1023 +0x1.fffffffffffffp1023))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.fffffffffffff7ffffffp1023 -0x1.fffffffffffff7ffffffp1023)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.fffffffffffffp1023 -0x1.fffffffffffffp1023))
+
+;; As parameters of control constructs
+
+(module (memory 1)
+  (func (export "as-br-retval") (result v128)
+    (block (result v128) (br 0 (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c)))
+  )
+  (func (export "as-br_if-retval") (result v128)
+    (block (result v128)
+      (br_if 0 (v128.const i32x4 0 1 2 3) (i32.const 1))
+    )
+  )
+  (func (export "as-return-retval") (result v128)
+    (return (v128.const i32x4 0 1 2 3))
+  )
+  (func (export "as-if-then-retval") (result v128)
+    (if (result v128) (i32.const 1)
+      (then (v128.const i32x4 0 1 2 3)) (else (v128.const i32x4 3 2 1 0))
+    )
+  )
+  (func (export "as-if-else-retval") (result v128)
+    (if (result v128) (i32.const 0)
+      (then (v128.const i32x4 0 1 2 3)) (else (v128.const i32x4 3 2 1 0))
+    )
+  )
+  (func $f (param v128 v128 v128) (result v128) (v128.const i32x4 0 1 2 3))
+  (func (export "as-call-param") (result v128)
+    (call $f (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3))
+  )
+  (func (export "as-block-retval") (result v128)
+    (block (result v128) (v128.const i32x4 0 1 2 3))
+  )
+  (func (export "as-loop-retval") (result v128)
+    (loop (result v128) (v128.const i32x4 0 1 2 3))
+  )
+  (func (export "as-drop-operand")
+    (drop (v128.const i32x4 0 1 2 3))
+  )
+
+  (func (export "as-br-retval2") (result v128)
+    (block (result v128) (br 0 (v128.const i64x2 0x0302010007060504 0x0b0a09080f0e0d0c)))
+  )
+  (func (export "as-br_if-retval2") (result v128)
+    (block (result v128)
+      (br_if 0 (v128.const i64x2 0 1) (i32.const 1))
+    )
+  )
+  (func (export "as-return-retval2") (result v128)
+    (return (v128.const i64x2 0 1))
+  )
+  (func (export "as-if-then-retval2") (result v128)
+    (if (result v128) (i32.const 1)
+      (then (v128.const i64x2 0 1)) (else (v128.const i64x2 1 0))
+    )
+  )
+  (func (export "as-if-else-retval2") (result v128)
+    (if (result v128) (i32.const 0)
+      (then (v128.const i64x2 0 1)) (else (v128.const i64x2 1 0))
+    )
+  )
+  (func $f2 (param v128 v128 v128) (result v128) (v128.const i64x2 0 1))
+  (func (export "as-call-param2") (result v128)
+    (call $f2 (v128.const i64x2 0 1) (v128.const i64x2 0 1) (v128.const i64x2 0 1))
+  )
+
+  (type $sig (func (param v128 v128 v128) (result v128)))
+  (table funcref (elem $f $f2))
+  (func (export "as-call_indirect-param") (result v128)
+    (call_indirect (type $sig)
+      (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-param2") (result v128)
+    (call_indirect (type $sig)
+      (v128.const i64x2 0 1) (v128.const i64x2 0 1) (v128.const i64x2 0 1) (i32.const 1)
+    )
+  )
+  (func (export "as-block-retval2") (result v128)
+    (block (result v128) (v128.const i64x2 0 1))
+  )
+  (func (export "as-loop-retval2") (result v128)
+    (loop (result v128) (v128.const i64x2 0 1))
+  )
+  (func (export "as-drop-operand2")
+    (drop (v128.const i64x2 0 1))
+  )
+)
+
+(assert_return (invoke "as-br-retval") (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c))
+(assert_return (invoke "as-br_if-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-return-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-if-then-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-if-else-retval") (v128.const i32x4 3 2 1 0))
+(assert_return (invoke "as-call-param") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-call_indirect-param") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-block-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-loop-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-drop-operand"))
+
+(assert_return (invoke "as-br-retval2") (v128.const i64x2 0x0302010007060504 0x0b0a09080f0e0d0c))
+(assert_return (invoke "as-br_if-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-return-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-if-then-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-if-else-retval2") (v128.const i64x2 1 0))
+(assert_return (invoke "as-call-param2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-call_indirect-param2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-block-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-loop-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-drop-operand2"))
+
+;; v128 locals
+
+(module (memory 1)
+  (func (export "as-local.set/get-value_0_0") (param $0 v128) (result v128)
+    (local v128 v128 v128 v128)
+    (local.set 0 (local.get $0))
+    (local.get 0)
+  )
+  (func (export "as-local.set/get-value_0_1") (param $0 v128) (result v128)
+    (local v128 v128 v128 v128)
+    (local.set 0 (local.get $0))
+    (local.set 1 (local.get 0))
+    (local.set 2 (local.get 1))
+    (local.set 3 (local.get 2))
+    (local.get 0)
+  )
+  (func (export "as-local.set/get-value_3_0") (param $0 v128) (result v128)
+    (local v128 v128 v128 v128)
+    (local.set 0 (local.get $0))
+    (local.set 1 (local.get 0))
+    (local.set 2 (local.get 1))
+    (local.set 3 (local.get 2))
+    (local.get 3)
+  )
+  (func (export "as-local.tee-value") (result v128)
+    (local v128)
+    (local.tee 0 (v128.const i32x4 0 1 2 3))
+  )
+)
+
+(assert_return (invoke "as-local.set/get-value_0_0" (v128.const i32x4 0 0 0 0)) (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "as-local.set/get-value_0_1" (v128.const i32x4 1 1 1 1)) (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "as-local.set/get-value_3_0" (v128.const i32x4 2 2 2 2)) (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "as-local.tee-value") (v128.const i32x4 0 1 2 3))
+
+
+;; v128 globals
+
+(module (memory 1)
+  (global $g0 (mut v128) (v128.const i32x4 0 1 2 3))
+  (global $g1 (mut v128) (v128.const i32x4 4 5 6 7))
+  (global $g2 (mut v128) (v128.const i32x4 8 9 10 11))
+  (global $g3 (mut v128) (v128.const i32x4 12 13 14 15))
+  (global $g4 (mut v128) (v128.const i32x4 16 17 18 19))
+
+  (func $set_g0 (export "as-global.set_value_$g0") (param $0 v128)
+    (global.set $g0 (local.get $0))
+  )
+  (func $set_g1_g2 (export "as-global.set_value_$g1_$g2") (param $0 v128) (param $1 v128)
+    (global.set $g1 (local.get $0))
+    (global.set $g2 (local.get $1))
+  )
+  (func $set_g0_g1_g2_g3 (export "as-global.set_value_$g0_$g1_$g2_$g3") (param $0 v128) (param $1 v128) (param $2 v128) (param $3 v128)
+    (call $set_g0 (local.get $0))
+    (call $set_g1_g2 (local.get $1) (local.get $2))
+    (global.set $g3 (local.get $3))
+  )
+  (func (export "global.get_g0") (result v128)
+    (global.get $g0)
+  )
+  (func (export "global.get_g1") (result v128)
+    (global.get $g1)
+  )
+  (func (export "global.get_g2") (result v128)
+    (global.get $g2)
+  )
+  (func (export "global.get_g3") (result v128)
+    (global.get $g3)
+  )
+)
+
+(assert_return (invoke "as-global.set_value_$g0_$g1_$g2_$g3" (v128.const i32x4 1 1 1 1)
+                                                             (v128.const i32x4 2 2 2 2)
+                                                             (v128.const i32x4 3 3 3 3)
+                                                             (v128.const i32x4 4 4 4 4)))
+(assert_return (invoke "global.get_g0") (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "global.get_g1") (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "global.get_g2") (v128.const i32x4 3 3 3 3))
+(assert_return (invoke "global.get_g3") (v128.const i32x4 4 4 4 4))
+
+
+;; Test integer literal parsing.
+
+(module
+  (func (export "i32x4.test") (result v128) (return (v128.const i32x4 0x0bAdD00D 0x0bAdD00D 0x0bAdD00D 0x0bAdD00D)))
+  (func (export "i32x4.smax") (result v128) (return (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)))
+  (func (export "i32x4.neg_smax") (result v128) (return (v128.const i32x4 -0x7fffffff -0x7fffffff -0x7fffffff -0x7fffffff)))
+  (func (export "i32x4.inc_smin") (result v128) (return (i32x4.add (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000) (v128.const i32x4 1 1 1 1))))
+  (func (export "i32x4.neg_zero") (result v128) (return (v128.const i32x4 -0x0 -0x0 -0x0 -0x0)))
+  (func (export "i32x4.not_octal") (result v128) (return (v128.const i32x4 010 010 010 010)))
+  (func (export "i32x4.plus_sign") (result v128) (return (v128.const i32x4 +42 +42 +42 +42)))
+
+  (func (export "i32x4-dec-sep1") (result v128) (v128.const i32x4 1_000_000 1_000_000 1_000_000 1_000_000))
+  (func (export "i32x4-dec-sep2") (result v128) (v128.const i32x4 1_0_0_0 1_0_0_0 1_0_0_0 1_0_0_0))
+  (func (export "i32x4-hex-sep1") (result v128) (v128.const i32x4 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99))
+  (func (export "i32x4-hex-sep2") (result v128) (v128.const i32x4 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f))
+
+  (func (export "i64x2.test") (result v128) (return (v128.const i64x2 0x0bAdD00D0bAdD00D 0x0bAdD00D0bAdD00D)))
+  (func (export "i64x2.smax") (result v128) (return (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)))
+  (func (export "i64x2.neg_smax") (result v128) (return (v128.const i64x2 -0x7fffffffffffffff -0x7fffffffffffffff)))
+  (func (export "i64x2.inc_smin") (result v128) (return (i64x2.add (v128.const i64x2 -0x8000000000000000 -0x8000000000000000) (v128.const i64x2 1 1))))
+  (func (export "i64x2.neg_zero") (result v128) (return (v128.const i64x2 -0x0 -0x0)))
+  (func (export "i64x2.not_octal") (result v128) (return (v128.const i64x2 010010 010010)))
+  (func (export "i64x2.plus_sign") (result v128) (return (v128.const i64x2 +42 +42)))
+
+  (func (export "i64x2-dec-sep1") (result v128) (v128.const i64x2 10_000_000_000_000 10_000_000_000_000))
+  (func (export "i64x2-dec-sep2") (result v128) (v128.const i64x2 1_0_0_0_0_0_0_0 1_0_0_0_0_0_0_0))
+  (func (export "i64x2-hex-sep1") (result v128) (v128.const i64x2 0xa_0f_00_99_0a_0f_00_99 0xa_0f_00_99_0a_0f_00_99))
+  (func (export "i64x2-hex-sep2") (result v128) (v128.const i64x2 0x1_a_A_0_f_1_a_A_0_f 0x1_a_A_0_f_1_a_A_0_f))
+)
+
+(assert_return (invoke "i32x4.test") (v128.const i32x4 195940365 195940365 195940365 195940365))
+(assert_return (invoke "i32x4.smax") (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.neg_smax") (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.inc_smin") (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.neg_zero") (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.not_octal") (v128.const i32x4 10 10 10 10))
+(assert_return (invoke "i32x4.plus_sign") (v128.const i32x4 42 42 42 42))
+
+(assert_return (invoke "i32x4-dec-sep1") (v128.const i32x4 1000000 1000000 1000000 1000000))
+(assert_return (invoke "i32x4-dec-sep2") (v128.const i32x4 1000 1000 1000 1000))
+(assert_return (invoke "i32x4-hex-sep1") (v128.const i32x4 0xa0f0099 0xa0f0099 0xa0f0099 0xa0f0099))
+(assert_return (invoke "i32x4-hex-sep2") (v128.const i32x4 0x1aa0f 0x1aa0f 0x1aa0f 0x1aa0f))
+
+(assert_return (invoke "i64x2.test") (v128.const i64x2 841557459837243405 841557459837243405))
+(assert_return (invoke "i64x2.smax") (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.neg_smax") (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.inc_smin") (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.neg_zero") (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.not_octal") (v128.const i64x2 10010 10010))
+(assert_return (invoke "i64x2.plus_sign") (v128.const i64x2 42 42))
+
+(assert_return (invoke "i64x2-dec-sep1") (v128.const i64x2 10000000000000 10000000000000))
+(assert_return (invoke "i64x2-dec-sep2") (v128.const i64x2 10000000 10000000))
+(assert_return (invoke "i64x2-hex-sep1") (v128.const i64x2 0xa0f00990a0f0099 0xa0f00990a0f0099))
+(assert_return (invoke "i64x2-hex-sep2") (v128.const i64x2 0x1aa0f1aa0f 0x1aa0f1aa0f))
+
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 _100 _100 _100 _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 +_100 +_100 +_100 +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 -_100 -_100 -_100 -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 99_ 99_ 99_ 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 1__000 1__000 1__000 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 _0x100 _0x100 _0x100 _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 0_x100 0_x100 0_x100 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 0x_100 0x_100 0x_100 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 0x00_ 0x00_ 0x00_ 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 0xff__ffff 0xff__ffff 0xff__ffff 0xff__ffff))")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 _100_100 _100_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 +_100_100 +_100_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 -_100_100 -_100_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 99_99_ 99_99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 1__000_000 1__000_000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 _0x100000 _0x100000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 0_x100000 0_x100000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 0x_100000 0x_100000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 0x00_ 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 0xff__ffff_ffff_ffff 0xff__ffff_ffff_ffff))")
+  "unknown operator"
+)
+
+;; Test floating-point literal parsing.
+
+(module
+  (func (export "f32-dec-sep1") (result v128) (v128.const f32x4 1_000_000 1_000_000 1_000_000 1_000_000))
+  (func (export "f32-dec-sep2") (result v128) (v128.const f32x4 1_0_0_0 1_0_0_0 1_0_0_0 1_0_0_0))
+  (func (export "f32-dec-sep3") (result v128) (v128.const f32x4 100_3.141_592 100_3.141_592 100_3.141_592 100_3.141_592))
+  (func (export "f32-dec-sep4") (result v128) (v128.const f32x4 99e+1_3 99e+1_3 99e+1_3 99e+1_3))
+  (func (export "f32-dec-sep5") (result v128) (v128.const f32x4 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3))
+  (func (export "f32-hex-sep1") (result v128) (v128.const f32x4 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99))
+  (func (export "f32-hex-sep2") (result v128) (v128.const f32x4 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f))
+  (func (export "f32-hex-sep3") (result v128) (v128.const f32x4 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a))
+  (func (export "f32-hex-sep4") (result v128) (v128.const f32x4 0xf0P+1_3 0xf0P+1_3 0xf0P+1_3 0xf0P+1_3))
+  (func (export "f32-hex-sep5") (result v128) (v128.const f32x4 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3))
+  (func (export "f64-dec-sep1") (result v128) (v128.const f64x2 1_000_000 1_000_000))
+  (func (export "f64-dec-sep2") (result v128) (v128.const f64x2 1_0_0_0 1_0_0_0))
+  (func (export "f64-dec-sep3") (result v128) (v128.const f64x2 100_3.141_592 100_3.141_592))
+  (func (export "f64-dec-sep4") (result v128) (v128.const f64x2 99e+1_3 99e+1_3))
+  (func (export "f64-dec-sep5") (result v128) (v128.const f64x2 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3))
+  (func (export "f64-hex-sep1") (result v128) (v128.const f64x2 0xa_0f_00_99 0xa_0f_00_99))
+  (func (export "f64-hex-sep2") (result v128) (v128.const f64x2 0x1_a_A_0_f 0x1_a_A_0_f))
+  (func (export "f64-hex-sep3") (result v128) (v128.const f64x2 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a))
+  (func (export "f64-hex-sep4") (result v128) (v128.const f64x2 0xf0P+1_3 0xf0P+1_3))
+  (func (export "f64-hex-sep5") (result v128) (v128.const f64x2 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3))
+)
+
+(assert_return (invoke "f32-dec-sep1") (v128.const f32x4 1000000 1000000 1000000 1000000))
+(assert_return (invoke "f32-dec-sep2") (v128.const f32x4 1000 1000 1000 1000))
+(assert_return (invoke "f32-dec-sep3") (v128.const f32x4 1003.141592 1003.141592 1003.141592 1003.141592))
+(assert_return (invoke "f32-dec-sep4") (v128.const f32x4 99e+13 99e+13 99e+13 99e+13))
+(assert_return (invoke "f32-dec-sep5") (v128.const f32x4 122000.11354e23 122000.11354e23 122000.11354e23 122000.11354e23))
+(assert_return (invoke "f32-hex-sep1") (v128.const f32x4 0xa0f0099 0xa0f0099 0xa0f0099 0xa0f0099))
+(assert_return (invoke "f32-hex-sep2") (v128.const f32x4 0x1aa0f 0x1aa0f 0x1aa0f 0x1aa0f))
+(assert_return (invoke "f32-hex-sep3") (v128.const f32x4 0xa0ff.f141a59a 0xa0ff.f141a59a 0xa0ff.f141a59a 0xa0ff.f141a59a))
+(assert_return (invoke "f32-hex-sep4") (v128.const f32x4 0xf0P+13 0xf0P+13 0xf0P+13 0xf0P+13))
+(assert_return (invoke "f32-hex-sep5") (v128.const f32x4 0x2af00a.1f3eep23 0x2af00a.1f3eep23 0x2af00a.1f3eep23 0x2af00a.1f3eep23))
+(assert_return (invoke "f64-dec-sep1") (v128.const f64x2 1000000 1000000))
+(assert_return (invoke "f64-dec-sep2") (v128.const f64x2 1000 1000))
+(assert_return (invoke "f64-dec-sep3") (v128.const f64x2 1003.141592 1003.141592))
+(assert_return (invoke "f64-dec-sep4") (v128.const f64x2 99e+13 99e+13))
+(assert_return (invoke "f64-dec-sep5") (v128.const f64x2 122000.11354e23 122000.11354e23))
+(assert_return (invoke "f64-hex-sep1") (v128.const f64x2 0xa0f0099 0xa0f0099))
+(assert_return (invoke "f64-hex-sep2") (v128.const f64x2 0x1aa0f 0x1aa0f))
+(assert_return (invoke "f64-hex-sep3") (v128.const f64x2 0xa0ff.f141a59a 0xa0ff.f141a59a))
+(assert_return (invoke "f64-hex-sep4") (v128.const f64x2 0xf0P+13 0xf0P+13))
+(assert_return (invoke "f64-hex-sep5") (v128.const f64x2 0x2af00a.1f3eep23 0x2af00a.1f3eep23))
+
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _100 _100 _100 _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 +_100 +_100 +_100 +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 -_100 -_100 -_100 -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 99_ 99_ 99_ 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1__000 1__000 1__000 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _1.0 _1.0 _1.0 _1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0_ 1.0_ 1.0_ 1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1_.0 1_.0 1_.0 1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1._0 1._0 1._0 1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _1e1 _1e1 _1e1 _1e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1e1_ 1e1_ 1e1_ 1e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1_e1 1_e1 1_e1 1_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1e_1 1e_1 1e_1 1e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _1.0e1 _1.0e1 _1.0e1 _1.0e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0e1_ 1.0e1_ 1.0e1_ 1.0e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0_e1 1.0_e1 1.0_e1 1.0_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0e_1 1.0e_1 1.0e_1 1.0e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0e+_1 1.0e+_1 1.0e+_1 1.0e+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0e_+1 1.0e_+1 1.0e_+1 1.0e_+1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _0x100 _0x100 _0x100 _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0_x100 0_x100 0_x100 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x_100 0x_100 0x_100 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x00_ 0x00_ 0x00_ 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0xff__ffff 0xff__ffff 0xff__ffff 0xff__ffff))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x_1.0 0x_1.0 0x_1.0 0x_1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0_ 0x1.0_ 0x1.0_ 0x1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1_.0 0x1_.0 0x1_.0 0x1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1._0 0x1._0 0x1._0 0x1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x_1p1 0x_1p1 0x_1p1 0x_1p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1p1_ 0x1p1_ 0x1p1_ 0x1p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1_p1 0x1_p1 0x1_p1 0x1_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1p_1 0x1p_1 0x1p_1 0x1p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x_1.0p1 0x_1.0p1 0x_1.0p1 0x_1.0p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0p1_ 0x1.0p1_ 0x1.0p1_ 0x1.0p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0_p1 0x1.0_p1 0x1.0_p1 0x1.0_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0p_1 0x1.0p_1 0x1.0p_1 0x1.0p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0p+_1 0x1.0p+_1 0x1.0p+_1 0x1.0p+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0p_+1 0x1.0p_+1 0x1.0p_+1 0x1.0p_+1))")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _100 _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 +_100 +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 -_100 -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 99_ 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1__000 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _1.0 _1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0_ 1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1_.0 1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1._0 1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _1e1 _1e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1e1_ 1e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1_e1 1_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1e_1 1e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _1.0e1 _1.0e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0e1_ 1.0e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0_e1 1.0_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0e_1 1.0e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0e+_1 1.0e+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0e_+1 1.0e_+1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _0x100 _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0_x100 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x_100 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x00_ 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0xff__ffff 0xff__ffff))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x_1.0 0x_1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0_ 0x1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1_.0 0x1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1._0 0x1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x_1p1 0x_1p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1p1_ 0x1p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1_p1 0x1_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1p_1 0x1p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x_1.0p1 0x_1.0p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0p1_ 0x1.0p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0_p1 0x1.0_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0p_1 0x1.0p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0p+_1 0x1.0p+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0p_+1 0x1.0p_+1))")
+  "unknown operator"
+)
+
+;; Test parsing an integer from binary
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\69\38\78\31\36\00\00"  ;; export name (parse_i8x16)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\00\00\00\00"                             ;; data lane 0~3   (0,    0,    0,    0)
+  "\80\80\80\80"                             ;; data lane 4~7   (-128, -128, -128, -128)
+  "\ff\ff\ff\ff"                             ;; data lane 8~11  (0xff, 0xff, 0xff, 0xff)
+  "\ff\ff\ff\ff"                             ;; data lane 12~15 (255,  255,  255,  255)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_i8x16") (v128.const i8x16 0 0 0 0 -128 -128 -128 -128 0xff 0xff 0xff 0xff 255 255 255 255))
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\69\31\36\78\38\00\00"  ;; export name (parse_i16x8)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\00\00\00\00"                             ;; data lane 0, 1 (0,      0)
+  "\00\80\00\80"                             ;; data lane 2, 3 (-32768, -32768)
+  "\ff\ff\ff\ff"                             ;; data lane 4, 5 (65535,  65535)
+  "\ff\ff\ff\ff"                             ;; data lane 6, 7 (0xffff, 0xffff)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_i16x8") (v128.const i16x8 0 0 -32768 -32768 65535 65535 0xffff 0xffff))
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\69\33\32\78\34\00\00"  ;; export name (parse_i32x4)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\d1\ff\ff\ff"                             ;; data lane 0 (4294967249)
+  "\d1\ff\ff\ff"                             ;; data lane 1 (4294967249)
+  "\d1\ff\ff\ff"                             ;; data lane 2 (4294967249)
+  "\d1\ff\ff\ff"                             ;; data lane 3 (4294967249)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_i32x4") (v128.const i32x4 4294967249 4294967249 4294967249 4294967249))
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\69\36\34\78\32\00\00"  ;; export name (parse_i64x2)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\ff\ff\ff\ff\ff\ff\ff\7f"                 ;; data lane 0 (9223372036854775807)
+  "\ff\ff\ff\ff\ff\ff\ff\7f"                 ;; data lane 1 (9223372036854775807)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_i64x2") (v128.const i64x2 9223372036854775807 9223372036854775807))
+
+;; Test parsing a float from binary
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\66\33\32\78\34\00\00"  ;; export name (parse_f32x4)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\00\00\80\4f"                             ;; data lane 0 (4294967249)
+  "\00\00\80\4f"                             ;; data lane 1 (4294967249)
+  "\00\00\80\4f"                             ;; data lane 2 (4294967249)
+  "\00\00\80\4f"                             ;; data lane 3 (4294967249)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_f32x4") (v128.const f32x4 4294967249 4294967249 4294967249 4294967249))
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\66\36\34\78\32\00\00"  ;; export name (parse_f64x2)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\ff\ff\ff\ff\ff\ff\ef\7f"                 ;; data lane 0 (0x1.fffffffffffffp+1023)
+  "\ff\ff\ff\ff\ff\ff\ef\7f"                 ;; data lane 1 (0x1.fffffffffffffp+1023)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_f64x2") (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
diff --git a/tests/wast/spec/simd_conversions.wast b/tests/wast/spec/simd_conversions.wast
new file mode 100644
index 0000000000..552e943612
--- /dev/null
+++ b/tests/wast/spec/simd_conversions.wast
@@ -0,0 +1,899 @@
+;; Web Assembly SIMD-related type conversion tests
+
+(module
+  ;; Integer to floating point
+  (func (export "f32x4.convert_i32x4_s") (param v128) (result v128)
+    (f32x4.convert_i32x4_s (local.get 0)))
+  (func (export "f32x4.convert_i32x4_u") (param v128) (result v128)
+    (f32x4.convert_i32x4_u (local.get 0)))
+
+  (func (export "f64x2.convert_low_i32x4_s") (param v128) (result v128)
+    (f64x2.convert_low_i32x4_s (local.get 0)))
+  (func (export "f64x2.convert_low_i32x4_u") (param v128) (result v128)
+    (f64x2.convert_low_i32x4_u (local.get 0)))
+
+  ;; Integer to integer narrowing
+  (func (export "i8x16.narrow_i16x8_s") (param v128 v128) (result v128)
+    (i8x16.narrow_i16x8_s (local.get 0) (local.get 1)))
+  (func (export "i8x16.narrow_i16x8_u") (param v128 v128) (result v128)
+    (i8x16.narrow_i16x8_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.narrow_i32x4_s") (param v128 v128) (result v128)
+    (i16x8.narrow_i32x4_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.narrow_i32x4_u") (param v128 v128) (result v128)
+    (i16x8.narrow_i32x4_u (local.get 0)(local.get 1)))
+
+  ;; Float to float promote/demote
+  (func (export "f64x2.promote_low_f32x4") (param v128) (result v128)
+    (f64x2.promote_low_f32x4 (local.get 0)))
+  (func (export "f32x4.demote_f64x2_zero") (param v128) (result v128)
+    (f32x4.demote_f64x2_zero (local.get 0)))
+)
+
+;; f64x2.promote_low_f32x4
+;; Float constants copied from test/core/conversions.wast.
+
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0.0 0.0 0.0 0.0))
+                                                 (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                                 (v128.const f64x2 -0.0 -0.0))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                                 (v128.const f64x2 0x1p-149 0x1p-149))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                                 (v128.const f64x2 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                                 (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                                 (v128.const f64x2 -1.0 -1.0))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+;; Generated randomly by picking a random int and reinterpret it to float.
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0x1p-119 0x1p-119 0x1p-119 0x1p-119))
+                                                 (v128.const f64x2 0x1p-119 0x1p-119))
+;; Generated randomly by picking a random float.
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0x1.8f867ep+125 0x1.8f867ep+125 0x1.8f867ep+125 0x1.8f867ep+125))
+                                                 (v128.const f64x2 6.6382536710104395e+37 6.6382536710104395e+37))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 inf inf inf inf))
+                                                 (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -inf -inf -inf -inf))
+                                                 (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 nan nan nan nan))
+                                                 (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                                 (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -nan -nan -nan -nan))
+                                                 (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                                 (v128.const f64x2 nan:arithmetic nan:arithmetic))
+
+;; f32x4.demote_f64x2_zero
+;; Float constants copied from test/core/conversions.wast.
+
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0.0 0.0))
+                                                 (v128.const f32x4 0.0 0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0.0 -0.0))
+                                                 (v128.const f32x4 -0.0 -0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                                 (v128.const f32x4 0.0 0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+                                                 (v128.const f32x4 -0.0 -0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 1.0 1.0))
+                                                 (v128.const f32x4 1.0 1.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -1.0 -1.0))
+                                                 (v128.const f32x4 -1.0 -1.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffe0000000p-127 0x1.fffffe0000000p-127))
+                                                 (v128.const f32x4 0x1p-126 0x1p-126 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffe0000000p-127 -0x1.fffffe0000000p-127))
+                                                 (v128.const f32x4 -0x1p-126 -0x1p-126 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffdfffffffp-127 0x1.fffffdfffffffp-127))
+                                                 (v128.const f32x4 0x1.fffffcp-127 0x1.fffffcp-127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffdfffffffp-127 -0x1.fffffdfffffffp-127))
+                                                 (v128.const f32x4 -0x1.fffffcp-127 -0x1.fffffcp-127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1p-149 0x1p-149))
+                                                 (v128.const f32x4 0x1p-149 0x1p-149 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1p-149 -0x1p-149))
+                                                 (v128.const f32x4 -0x1p-149 -0x1p-149 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffd0000000p+127 0x1.fffffd0000000p+127))
+                                                 (v128.const f32x4 0x1.fffffcp+127 0x1.fffffcp+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffd0000000p+127 -0x1.fffffd0000000p+127))
+                                                 (v128.const f32x4 -0x1.fffffcp+127 -0x1.fffffcp+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffd0000001p+127 0x1.fffffd0000001p+127))
+                                                 (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffd0000001p+127 -0x1.fffffd0000001p+127))
+                                                 (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffefffffffp+127 0x1.fffffefffffffp+127))
+                                                 (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffefffffffp+127 -0x1.fffffefffffffp+127))
+                                                 (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.ffffffp+127 0x1.ffffffp+127))
+                                                 (v128.const f32x4 inf inf 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.ffffffp+127 -0x1.ffffffp+127))
+                                                 (v128.const f32x4 -inf -inf 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1p-119 0x1p-119))
+                                                 (v128.const f32x4 0x1p-119 0x1p-119 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.8f867ep+125 0x1.8f867ep+125))
+                                                 (v128.const f32x4 0x1.8f867ep+125 0x1.8f867ep+125 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 inf inf))
+                                                 (v128.const f32x4 inf inf 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -inf -inf))
+                                                 (v128.const f32x4 -inf -inf 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000000000001p+0 0x1.0000000000001p+0))
+                                                 (v128.const f32x4 1.0 1.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffffffffffp-1 0x1.fffffffffffffp-1))
+                                                 (v128.const f32x4 1.0 1.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000010000000p+0 0x1.0000010000000p+0))
+                                                 (v128.const f32x4 0x1.000000p+0 0x1.000000p+0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000010000001p+0 0x1.0000010000001p+0))
+                                                 (v128.const f32x4 0x1.000002p+0 0x1.000002p+0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.000002fffffffp+0 0x1.000002fffffffp+0))
+                                                 (v128.const f32x4 0x1.000002p+0 0x1.000002p+0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000030000000p+0 0x1.0000030000000p+0))
+                                                 (v128.const f32x4 0x1.000004p+0 0x1.000004p+0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000050000000p+0 0x1.0000050000000p+0))
+                                                 (v128.const f32x4 0x1.000004p+0 0x1.000004p+0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000010000000p+24 0x1.0000010000000p+24))
+                                                 (v128.const f32x4 0x1.0p+24 0x1.0p+24 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000010000001p+24 0x1.0000010000001p+24))
+                                                 (v128.const f32x4 0x1.000002p+24 0x1.000002p+24 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.000002fffffffp+24 0x1.000002fffffffp+24))
+                                                 (v128.const f32x4 0x1.000002p+24 0x1.000002p+24 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000030000000p+24 0x1.0000030000000p+24))
+                                                 (v128.const f32x4 0x1.000004p+24 0x1.000004p+24 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.4eae4f7024c7p+108 0x1.4eae4f7024c7p+108))
+                                                 (v128.const f32x4 0x1.4eae5p+108 0x1.4eae5p+108 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.a12e71e358685p-113 0x1.a12e71e358685p-113))
+                                                 (v128.const f32x4 0x1.a12e72p-113 0x1.a12e72p-113 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.cb98354d521ffp-127 0x1.cb98354d521ffp-127))
+                                                 (v128.const f32x4 0x1.cb9834p-127 0x1.cb9834p-127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.6972b30cfb562p+1 -0x1.6972b30cfb562p+1))
+                                                 (v128.const f32x4 -0x1.6972b4p+1 -0x1.6972b4p+1 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.bedbe4819d4c4p+112 -0x1.bedbe4819d4c4p+112))
+                                                 (v128.const f32x4 -0x1.bedbe4p+112 -0x1.bedbe4p+112 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 nan nan))
+                                                 (v128.const f32x4 nan:canonical nan:canonical 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                                 (v128.const f32x4 nan:arithmetic nan:arithmetic 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -nan -nan))
+                                                 (v128.const f32x4 nan:canonical nan:canonical 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                                 (v128.const f32x4 nan:arithmetic nan:arithmetic 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                                 (v128.const f32x4 0.0 0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                                 (v128.const f32x4 -0.0 -0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0p-150 0x1.0p-150))
+                                                 (v128.const f32x4 0.0 0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.0p-150 -0x1.0p-150))
+                                                 (v128.const f32x4 -0.0 -0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000000000001p-150 0x1.0000000000001p-150))
+                                                 (v128.const f32x4 0x1p-149 0x1p-149 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.0000000000001p-150 -0x1.0000000000001p-150))
+                                                 (v128.const f32x4 -0x1p-149 -0x1p-149 0 0))
+
+
+;; Integer to floating point
+;; f32x4.convert_i32x4_s
+
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 0 0 0 0))
+                                               (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 1 1 1 1))
+                                               (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                               (v128.const f32x4 2147483647.0 2147483647.0 2147483647.0 2147483647.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                               (v128.const f32x4 -2147483648.0 -2147483648.0 -2147483648.0 -2147483648.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 1234567890 1234567890 1234567890 1234567890))
+                                               (v128.const f32x4 0x1.26580cp+30 0x1.26580cp+30 0x1.26580cp+30 0x1.26580cp+30))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 0_123_456_792 0_123_456_792 0_123_456_792 0_123_456_792))
+                                               (v128.const f32x4 123456792.0 123456792.0 123456792.0 123456792.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 0x0_1234_5680 0x0_1234_5680 0x0_1234_5680 0x0_1234_5680))
+                                               (v128.const f32x4 305419904.0 305419904.0 305419904.0 305419904.0))
+;; Test rounding directions.
+
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 16777217 16777217 16777217 16777217))
+                                               (v128.const f32x4 16777216.0 16777216.0 16777216.0 16777216.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 -16777217 -16777217 -16777217 -16777217))
+                                               (v128.const f32x4 -16777216.0 -16777216.0 -16777216.0 -16777216.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 16777219 16777219 16777219 16777219))
+                                               (v128.const f32x4 16777220.0 16777220.0 16777220.0 16777220.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 -16777219 -16777219 -16777219 -16777219))
+                                               (v128.const f32x4 -16777220.0 -16777220.0 -16777220.0 -16777220.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 0 -1 0x7fffffff 0x80000000))
+                                               (v128.const f32x4 0.0 -1.0 2147483647.0 -2147483648.0))
+
+;; f32x4.convert_i32x4_u
+
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0 0 0 0))
+                                               (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 1 1 1 1))
+                                               (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const f32x4 4294967295.0 4294967295.0 4294967295.0 4294967295.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                               (v128.const f32x4 2147483648.0 2147483648.0 2147483648.0 2147483648.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                               (v128.const f32x4 2147483648.0 2147483648.0 2147483648.0 2147483648.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                                               (v128.const f32x4 0x1.234568p+28 0x1.234568p+28 0x1.234568p+28 0x1.234568p+28))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x80000080 0x80000080 0x80000080 0x80000080))
+                                               (v128.const f32x4 0x1.000000p+31 0x1.000000p+31 0x1.000000p+31 0x1.000000p+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x80000081 0x80000081 0x80000081 0x80000081))
+                                               (v128.const f32x4 0x1.000002p+31 0x1.000002p+31 0x1.000002p+31 0x1.000002p+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x80000082 0x80000082 0x80000082 0x80000082))
+                                               (v128.const f32x4 0x1.000002p+31 0x1.000002p+31 0x1.000002p+31 0x1.000002p+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0xfffffe80 0xfffffe80 0xfffffe80 0xfffffe80))
+                                               (v128.const f32x4 0x1.fffffcp+31 0x1.fffffcp+31 0x1.fffffcp+31 0x1.fffffcp+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0xfffffe81 0xfffffe81 0xfffffe81 0xfffffe81))
+                                               (v128.const f32x4 0x1.fffffep+31 0x1.fffffep+31 0x1.fffffep+31 0x1.fffffep+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0xfffffe82 0xfffffe82 0xfffffe82 0xfffffe82))
+                                               (v128.const f32x4 0x1.fffffep+31 0x1.fffffep+31 0x1.fffffep+31 0x1.fffffep+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0_123_456_792 0_123_456_792 0_123_456_792 0_123_456_792))
+                                               (v128.const f32x4 123456792.0 123456792.0 123456792.0 123456792.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                                               (v128.const f32x4 2427178496.0 2427178496.0 2427178496.0 2427178496.0))
+;; Test rounding directions.
+
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 16777217 16777217 16777217 16777217))
+                                               (v128.const f32x4 16777216.0 16777216.0 16777216.0 16777216.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 16777219 16777219 16777219 16777219))
+                                               (v128.const f32x4 16777220.0 16777220.0 16777220.0 16777220.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0 -1 0x7fffffff 0x80000000))
+                                               (v128.const f32x4 0.0 4294967295.0 2147483647.0 2147483648.0))
+
+;; f64x2.convert_i32x4_s
+;; constants copied from test/core/conversions.wast.
+
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 1 1 0 0))
+                                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 -1 -1 0 0))
+                                                   (v128.const f64x2 -1.0 -1.0))
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 0 0 0 0))
+                                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 0 0))
+                                                   (v128.const f64x2 2147483647 2147483647))
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 0 0))
+                                                   (v128.const f64x2 -2147483648 -2147483648))
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 987654321 987654321 0 0))
+                                                   (v128.const f64x2 987654321 987654321))
+
+;; f64x2.convert_i32x4_u
+;; constants copied from test/core/conversions.wast.
+
+(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 1 1 0 0))
+                                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 0 0 0 0))
+                                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 0 0))
+                                                   (v128.const f64x2 2147483647 2147483647))
+(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 0 0))
+                                                   (v128.const f64x2 2147483648 2147483648))
+(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 0xffffffff 0xffffffff 0 0))
+                                                   (v128.const f64x2 4294967295.0 4294967295.0))
+
+;; Integer to integer narrowing
+;; i8x16.narrow_i16x8_s
+
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                              (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                              (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f)
+                                              (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                              (v128.const i8x16 0x81 0x81 0x81 0x81 0x81 0x81 0x81 0x81 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x81 0x81 0x81 0x81 0x81 0x81 0x81 0x81))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81)
+                                              (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81)
+                                              (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81)
+                                              (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                              (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                              (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+;; i8x16.narrow_i16x8_u
+
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                              (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                              (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                              (v128.const i16x8 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe))
+                                              (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100)
+                                              (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+                                              (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                              (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+                                              (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789)
+                                              (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                              (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+;; i16x8.narrow_i32x4_s
+
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 1 1 1 1))
+                                              (v128.const i16x8 0 0 0 0 1 1 1 1))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 -1 -1 -1 -1))
+                                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                              (v128.const i32x4 -1 -1 -1 -1))
+                                              (v128.const i16x8 1 1 1 1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 1 1 1 1))
+                                              (v128.const i16x8 -1 -1 -1 -1 1 1 1 1))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7ffe 0x7ffe 0x7ffe 0x7ffe)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x7ffe 0x7ffe 0x7ffe 0x7ffe 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff)
+                                              (v128.const i32x4 0x7ffe 0x7ffe 0x7ffe 0x7ffe))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7ffe 0x7ffe 0x7ffe 0x7ffe))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                              (v128.const i32x4 0x8000 0x8000 0x8000 0x8000))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff)
+                                              (v128.const i32x4 0x8000 0x8000 0x8000 0x8000))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x7fff -0x7fff -0x7fff -0x7fff)
+                                              (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000))
+                                              (v128.const i16x8 0x8001 0x8001 0x8001 0x8001 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 -0x7fff -0x7fff -0x7fff -0x7fff))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8001 0x8001 0x8001 0x8001))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001)
+                                              (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001)
+                                              (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 0x8000 0x8000 0x8000 0x8000))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001)
+                                              (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000000 -0x8000000 -0x8000000 -0x8000000)
+                                              (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                                              (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                              (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+;; i16x8.narrow_i32x4_u
+
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 1 1 1 1))
+                                              (v128.const i16x8 0 0 0 0 1 1 1 1))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 -1 -1 -1 -1))
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                              (v128.const i32x4 -1 -1 -1 -1))
+                                              (v128.const i16x8 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 1 1 1 1))
+                                              (v128.const i16x8 0 0 0 0 1 1 1 1))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0xfffe 0xfffe 0xfffe 0xfffe)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0xfffe 0xfffe 0xfffe 0xfffe 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)
+                                              (v128.const i32x4 0xfffe 0xfffe 0xfffe 0xfffe))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xfffe 0xfffe 0xfffe 0xfffe))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0x10000 0x10000 0x10000 0x10000)
+                                              (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)
+                                              (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0x10000 0x10000 0x10000 0x10000)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+                                              (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+                                              (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000)
+                                              (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                                              (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                              (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                                              (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff))
+
+
+;; Unknown operator
+
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.trunc_sat_f32x4 (v128.const f32x4 0.0 0.0 0.0 0.0)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.trunc_s_sat_f32x4 (v128.const f32x4 -2.0 -1.0 1.0 2.0)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.trunc_u_sat_f32x4 (v128.const f32x4 -2.0 -1.0 1.0 2.0)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.convert_f32x4 (v128.const f32x4 -1 0 1 2)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.convert_s_f32x4 (v128.const f32x4 -1 0 1 2)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.convert_u_f32x4 (v128.const f32x4 -1 0 1 2)))")
+  "unknown operator")
+
+(assert_malformed (module quote
+  "(func (result v128) (i64x2.trunc_sat_f64x2_s (v128.const f64x2 0.0 0.0)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i64x2.trunc_sat_f64x2_u (v128.const f64x2 -2.0 -1.0)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (f64x2.convert_i64x2_s (v128.const i64x2 1 2)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (f64x2.convert_i64x2_u (v128.const i64x2 1 2)))")
+  "unknown operator")
+
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.narrow_i16x8 (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.narrow_i8x16 (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.narrow_i8x16_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.narrow_i8x16_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.narrow_i32x4 (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.narrow_i16x8 (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.narrow_i16x8_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.narrow_i16x8_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_low_i8x16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.extend_low_i16x8_s (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.extend_low_i16x8_u (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_high_i8x16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.extend_high_i16x8_s (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.extend_high_i16x8_u (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.extend_low_i16x8 (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_low_i32x4_s (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_low_i32x4_u (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.extend_high_i16x8 (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_high_i32x4_s (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_high_i32x4_u (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+
+
+;; Type mismatch
+
+(assert_invalid (module (func (result v128) (f32x4.convert_i32x4_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.convert_i32x4_s (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.convert_i32x4_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.convert_i32x4_u (i64.const 0)))) "type mismatch")
+
+(assert_invalid (module (func (result v128) (i8x16.narrow_i16x8_s (i32.const 0) (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.narrow_i16x8_u (i32.const 0) (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.narrow_i32x4_s (f32.const 0.0) (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.narrow_i32x4_s (f32.const 0.0) (f64.const 0.0)))) "type mismatch")
+
+
+;; Combinations
+
+(module
+  (func (export "f32x4_convert_i32x4_s_add") (param v128 v128) (result v128)
+    (f32x4.convert_i32x4_s (i32x4.add (local.get 0) (local.get 1))))
+  (func (export "f32x4_convert_i32x4_s_sub") (param  v128 v128) (result v128)
+    (f32x4.convert_i32x4_s (i32x4.sub (local.get 0) (local.get 1))))
+  (func (export "f32x4_convert_i32x4_u_mul") (param  v128 v128) (result v128)
+    (f32x4.convert_i32x4_u (i32x4.mul (local.get 0) (local.get 1))))
+
+  (func (export "i16x8_low_extend_narrow_ss") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_s (i8x16.narrow_i16x8_s (local.get 0) (local.get 1))))
+  (func (export "i16x8_low_extend_narrow_su") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_s (i8x16.narrow_i16x8_u (local.get 0) (local.get 1))))
+  (func (export "i16x8_high_extend_narrow_ss") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_s (i8x16.narrow_i16x8_s (local.get 0) (local.get 1))))
+  (func (export "i16x8_high_extend_narrow_su") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_s (i8x16.narrow_i16x8_u (local.get 0) (local.get 1))))
+  (func (export "i16x8_low_extend_narrow_uu") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_u (i8x16.narrow_i16x8_u (local.get 0) (local.get 1))))
+  (func (export "i16x8_low_extend_narrow_us") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_u (i8x16.narrow_i16x8_s (local.get 0) (local.get 1))))
+  (func (export "i16x8_high_extend_narrow_uu") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_u (i8x16.narrow_i16x8_u (local.get 0) (local.get 1))))
+  (func (export "i16x8_high_extend_narrow_us") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_u (i8x16.narrow_i16x8_s (local.get 0) (local.get 1))))
+
+  (func (export "i32x4_low_extend_narrow_ss") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_s (i16x8.narrow_i32x4_s (local.get 0) (local.get 1))))
+  (func (export "i32x4_low_extend_narrow_su") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_s (i16x8.narrow_i32x4_u (local.get 0) (local.get 1))))
+  (func (export "i32x4_high_extend_narrow_ss") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_s (i16x8.narrow_i32x4_s (local.get 0) (local.get 1))))
+  (func (export "i32x4_high_extend_narrow_su") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_s (i16x8.narrow_i32x4_u (local.get 0) (local.get 1))))
+  (func (export "i32x4_low_extend_narrow_uu") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_u (i16x8.narrow_i32x4_u (local.get 0) (local.get 1))))
+  (func (export "i32x4_low_extend_narrow_us") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_u (i16x8.narrow_i32x4_s (local.get 0) (local.get 1))))
+  (func (export "i32x4_high_extend_narrow_uu") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_u (i16x8.narrow_i32x4_u (local.get 0) (local.get 1))))
+  (func (export "i32x4_high_extend_narrow_us") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_u (i16x8.narrow_i32x4_s (local.get 0) (local.get 1))))
+)
+
+(assert_return (invoke "f32x4_convert_i32x4_s_add" (v128.const i32x4 1 2 3 4)
+                                                   (v128.const i32x4 2 3 4 5))
+                                                   (v128.const f32x4 3.0 5.0 7.0 9.0))
+(assert_return (invoke "f32x4_convert_i32x4_s_sub" (v128.const i32x4 0 1 2 3)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const f32x4 -1.0 0.0 1.0 2.0))
+(assert_return (invoke "f32x4_convert_i32x4_u_mul" (v128.const i32x4 1 2 3 4)
+                                                   (v128.const i32x4 1 2 3 4))
+                                                   (v128.const f32x4 1.0 4.0 9.0 16.0))
+
+(assert_return (invoke "i16x8_low_extend_narrow_ss" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000)
+                                                    (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000))
+                                                    (v128.const i16x8 0xff80 0xff80 0x7f 0xff80 0xff80 0xff80 0x7f 0xff80))
+(assert_return (invoke "i16x8_low_extend_narrow_su" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff)
+                                                    (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff))
+                                                    (v128.const i16x8 0 0 0xffff 0 0 0 0xffff 0))
+(assert_return (invoke "i16x8_high_extend_narrow_ss" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000)
+                                                     (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000))
+                                                     (v128.const i16x8 0xff80 0xff80 0x7f 0xff80 0xff80 0xff80 0x7f 0xff80))
+(assert_return (invoke "i16x8_high_extend_narrow_su" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff)
+                                                     (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff))
+                                                     (v128.const i16x8 0 0 0xffff 0 0 0 0xffff 0))
+(assert_return (invoke "i16x8_low_extend_narrow_uu" (v128.const i16x8 -0x8000 -0x7fff 0x8000 0xffff -0x8000 -0x7fff 0x8000 0xffff)
+                                                    (v128.const i16x8 -0x8000 -0x7fff 0x8000 0xffff -0x8000 -0x7fff 0x8000 0xffff))
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_low_extend_narrow_us" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000)
+                                                    (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000))
+                                                    (v128.const i16x8 0x80 0x80 0x7f 0x80 0x80 0x80 0x7f 0x80))
+(assert_return (invoke "i16x8_high_extend_narrow_uu" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff)
+                                                     (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff))
+                                                     (v128.const i16x8 0 0 0xff 0 0 0 0xff 0))
+(assert_return (invoke "i16x8_high_extend_narrow_us" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000)
+                                                     (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000))
+                                                     (v128.const i16x8 0x80 0x80 0x7f 0x80 0x80 0x80 0x7f 0x80))
+
+(assert_return (invoke "i32x4_low_extend_narrow_ss" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000)
+                                                    (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000))
+                                                    (v128.const i32x4 0xffff8000 0xffff8000 0x7fff 0x7fff))
+(assert_return (invoke "i32x4_low_extend_narrow_su" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff)
+                                                    (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff))
+                                                    (v128.const i32x4 0 0 0xffffffff 0))
+(assert_return (invoke "i32x4_high_extend_narrow_ss" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000)
+                                                     (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000))
+                                                     (v128.const i32x4 0xffff8000 0xffff8000 0x7fff 0x7fff))
+(assert_return (invoke "i32x4_high_extend_narrow_su" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff)
+                                                     (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff))
+                                                     (v128.const i32x4 0 0 0xffffffff 0))
+(assert_return (invoke "i32x4_low_extend_narrow_uu" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff)
+                                                    (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff))
+                                                    (v128.const i32x4 0 0 0xffff 0))
+(assert_return (invoke "i32x4_low_extend_narrow_us" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000)
+                                                    (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000))
+                                                    (v128.const i32x4 0x8000 0x8000 0x7fff 0x7fff))
+(assert_return (invoke "i32x4_high_extend_narrow_uu" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff)
+                                                     (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff))
+                                                     (v128.const i32x4 0 0 0xffff 0))
+(assert_return (invoke "i32x4_high_extend_narrow_us" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000)
+                                                     (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000))
+                                                     (v128.const i32x4 0x8000 0x8000 0x7fff 0x7fff))
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.convert_i32x4_s-arg-empty (result v128)
+      (f32x4.convert_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.convert_i32x4_u-arg-empty (result v128)
+      (f32x4.convert_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.narrow_i16x8_s-1st-arg-empty (result v128)
+      (i8x16.narrow_i16x8_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.narrow_i16x8_s-arg-empty (result v128)
+      (i8x16.narrow_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.narrow_i16x8_u-1st-arg-empty (result v128)
+      (i8x16.narrow_i16x8_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.narrow_i16x8_u-arg-empty (result v128)
+      (i8x16.narrow_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.narrow_i32x4_s-1st-arg-empty (result v128)
+      (i16x8.narrow_i32x4_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.narrow_i32x4_s-arg-empty (result v128)
+      (i16x8.narrow_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.narrow_i32x4_u-1st-arg-empty (result v128)
+      (i16x8.narrow_i32x4_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.narrow_i32x4_u-arg-empty (result v128)
+      (i16x8.narrow_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
diff --git a/tests/wast/spec/simd_f32x4.wast b/tests/wast/spec/simd_f32x4.wast
new file mode 100644
index 0000000000..819db8cfd1
--- /dev/null
+++ b/tests/wast/spec/simd_f32x4.wast
@@ -0,0 +1,2407 @@
+;; Tests for f32x4 [abs, min, max] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f32x4.min") (param v128 v128) (result v128) (f32x4.min (local.get 0) (local.get 1)))
+  (func (export "f32x4.max") (param v128 v128) (result v128) (f32x4.max (local.get 0) (local.get 1)))
+  (func (export "f32x4.abs") (param v128) (result v128) (f32x4.abs (local.get 0)))
+  ;; f32x4.min const vs const
+  (func (export "f32x4.min_with_const_0") (result v128) (f32x4.min (v128.const f32x4 0 1 2 -3) (v128.const f32x4 0 2 1 3)))
+  (func (export "f32x4.min_with_const_1") (result v128) (f32x4.min (v128.const f32x4 0 1 2 3) (v128.const f32x4 0 1 2 3)))
+  (func (export "f32x4.min_with_const_2") (result v128) (f32x4.min (v128.const f32x4 0x00 0x01 0x02 0x80000000) (v128.const f32x4 0x00 0x02 0x01 2147483648)))
+  (func (export "f32x4.min_with_const_3") (result v128) (f32x4.min (v128.const f32x4 0x00 0x01 0x02 0x80000000) (v128.const f32x4 0x00 0x01 0x02 0x80000000)))
+  ;; f32x4.min param vs const
+  (func (export "f32x4.min_with_const_5")(param v128) (result v128) (f32x4.min (local.get 0) (v128.const f32x4 0 1 2 -3)))
+  (func (export "f32x4.min_with_const_6")(param v128) (result v128) (f32x4.min (v128.const f32x4 0 1 2 3) (local.get 0)))
+  (func (export "f32x4.min_with_const_7")(param v128) (result v128) (f32x4.min (v128.const f32x4 0x00 0x01 0x02 0x80000000) (local.get 0)))
+  (func (export "f32x4.min_with_const_8")(param v128) (result v128) (f32x4.min (local.get 0) (v128.const f32x4 0x00 0x01 0x02 0x80000000)))
+  ;; f32x4.max const vs const
+  (func (export "f32x4.max_with_const_10") (result v128) (f32x4.max (v128.const f32x4 0 1 2 -3) (v128.const f32x4 0 2 1 3)))
+  (func (export "f32x4.max_with_const_11") (result v128) (f32x4.max (v128.const f32x4 0 1 2 3) (v128.const f32x4 0 1 2 3)))
+  (func (export "f32x4.max_with_const_12") (result v128) (f32x4.max (v128.const f32x4 0x00 0x01 0x02 0x80000000) (v128.const f32x4 0x00 0x02 0x01 2147483648)))
+  (func (export "f32x4.max_with_const_13") (result v128) (f32x4.max (v128.const f32x4 0x00 0x01 0x02 0x80000000) (v128.const f32x4 0x00 0x01 0x02 0x80000000)))
+  ;; f32x4.max param vs const
+  (func (export "f32x4.max_with_const_15")(param v128) (result v128) (f32x4.max (local.get 0) (v128.const f32x4 0 1 2 -3)))
+  (func (export "f32x4.max_with_const_16")(param v128) (result v128) (f32x4.max (v128.const f32x4 0 1 2 3) (local.get 0)))
+  (func (export "f32x4.max_with_const_17")(param v128) (result v128) (f32x4.max (v128.const f32x4 0x00 0x01 0x02 0x80000000) (local.get 0)))
+  (func (export "f32x4.max_with_const_18")(param v128) (result v128) (f32x4.max (local.get 0) (v128.const f32x4 0x00 0x01 0x02 0x80000000)))
+
+  (func (export "f32x4.abs_with_const") (result v128) (f32x4.abs (v128.const f32x4 -0 -1 -2 -3)))
+)
+
+;; f32x4.min const vs const
+(assert_return (invoke "f32x4.min_with_const_0") (v128.const f32x4 0 1 1 -3))
+(assert_return (invoke "f32x4.min_with_const_1") (v128.const f32x4 0 1 2 3))
+(assert_return (invoke "f32x4.min_with_const_2") (v128.const f32x4 0x00 0x01 0x01 0x80000000))
+(assert_return (invoke "f32x4.min_with_const_3") (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+;; f32x4.min param vs const
+(assert_return (invoke "f32x4.min_with_const_5" (v128.const f32x4 0 2 1 3))
+                                                (v128.const f32x4 0 1 1 -3))
+(assert_return (invoke "f32x4.min_with_const_6" (v128.const f32x4 0 1 2 3))
+                                                (v128.const f32x4 0 1 2 3))
+(assert_return (invoke "f32x4.min_with_const_7" (v128.const f32x4 0x00 0x02 0x01 2147483648))
+                                                (v128.const f32x4 0x00 0x01 0x01 0x80000000))
+(assert_return (invoke "f32x4.min_with_const_8" (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+                                                (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+;; f32x4.max const vs const
+(assert_return (invoke "f32x4.max_with_const_10") (v128.const f32x4 0 2 2 3))
+(assert_return (invoke "f32x4.max_with_const_11") (v128.const f32x4 0 1 2 3))
+(assert_return (invoke "f32x4.max_with_const_12") (v128.const f32x4 0x00 0x02 0x02 2147483648))
+(assert_return (invoke "f32x4.max_with_const_13") (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+;; f32x4.max param vs const
+(assert_return (invoke "f32x4.max_with_const_15" (v128.const f32x4 0 2 1 3))
+                                                 (v128.const f32x4 0 2 2 3))
+(assert_return (invoke "f32x4.max_with_const_16" (v128.const f32x4 0 1 2 3))
+                                                 (v128.const f32x4 0 1 2 3))
+(assert_return (invoke "f32x4.max_with_const_17" (v128.const f32x4 0x00 0x02 0x01 2147483648))
+                                                 (v128.const f32x4 0x00 0x02 0x02 2147483648))
+(assert_return (invoke "f32x4.max_with_const_18" (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+                                                 (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+
+(assert_return (invoke "f32x4.abs_with_const") (v128.const f32x4 0 1 2 3))
+
+;; Test different lanes go through different if-then clauses
+;; f32x4.min
+(assert_return
+  (invoke "f32x4.min"
+    (v128.const f32x4 nan 0 0 1)
+    (v128.const f32x4 0 -nan 1 0)
+  )
+  (v128.const f32x4 nan:canonical nan:canonical 0 0)
+)
+;; f32x4.min
+(assert_return
+  (invoke "f32x4.min"
+    (v128.const f32x4 nan 0 0 0)
+    (v128.const f32x4 0 -nan 1 0)
+  )
+  (v128.const f32x4 nan:canonical nan:canonical 0 0)
+)
+;; f32x4.max
+(assert_return
+  (invoke "f32x4.max"
+    (v128.const f32x4 nan 0 0 1)
+    (v128.const f32x4 0 -nan 1 0)
+  )
+  (v128.const f32x4 nan:canonical nan:canonical 1 1)
+)
+;; f32x4.max
+(assert_return
+  (invoke "f32x4.max"
+    (v128.const f32x4 nan 0 0 0)
+    (v128.const f32x4 0 -nan 1 0)
+  )
+  (v128.const f32x4 nan:canonical nan:canonical 1 0)
+)
+
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+
+;; Test opposite signs of zero
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0 0 -0 +0)
+                                   (v128.const f32x4 +0 -0 +0 -0))
+                                   (v128.const f32x4 0 -0 -0 -0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0 -0 -0 -0)
+                                   (v128.const f32x4 +0 +0 +0 +0))
+                                   (v128.const f32x4 -0 -0 -0 -0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0 0 -0 +0)
+                                   (v128.const f32x4 +0 -0 +0 -0))
+                                   (v128.const f32x4 0 0 0 0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0 -0 -0 -0)
+                                   (v128.const f32x4 +0 +0 +0 +0))
+                                   (v128.const f32x4 +0 +0 +0 +0))
+
+
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f32x4.abs (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.min (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.max (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.abs-arg-empty (result v128)
+      (f32x4.abs)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.min-1st-arg-empty (result v128)
+      (f32x4.min (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.min-arg-empty (result v128)
+      (f32x4.min)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.max-1st-arg-empty (result v128)
+      (f32x4.max (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.max-arg-empty (result v128)
+      (f32x4.max)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "max-min") (param v128 v128 v128) (result v128)
+    (f32x4.max (f32x4.min (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "min-max") (param v128 v128 v128) (result v128)
+    (f32x4.min (f32x4.max (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "max-abs") (param v128 v128) (result v128)
+    (f32x4.max (f32x4.abs (local.get 0)) (local.get 1)))
+  (func (export "min-abs") (param v128 v128) (result v128)
+    (f32x4.min (f32x4.abs (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "max-min" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+(assert_return (invoke "min-max" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+(assert_return (invoke "max-abs" (v128.const f32x4 -1.125 -1.125 -1.125 -1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 1.125 1.125 1.125 1.125))
+(assert_return (invoke "min-abs" (v128.const f32x4 -1.125 -1.125 -1.125 -1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
\ No newline at end of file
diff --git a/tests/wast/spec/simd_f32x4_arith.wast b/tests/wast/spec/simd_f32x4_arith.wast
new file mode 100644
index 0000000000..56f80f547b
--- /dev/null
+++ b/tests/wast/spec/simd_f32x4_arith.wast
@@ -0,0 +1,5476 @@
+;; Tests for f32x4 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f32x4.add") (param v128 v128) (result v128) (f32x4.add (local.get 0) (local.get 1)))
+  (func (export "f32x4.sub") (param v128 v128) (result v128) (f32x4.sub (local.get 0) (local.get 1)))
+  (func (export "f32x4.mul") (param v128 v128) (result v128) (f32x4.mul (local.get 0) (local.get 1)))
+  (func (export "f32x4.div") (param v128 v128) (result v128) (f32x4.div (local.get 0) (local.get 1)))
+  (func (export "f32x4.neg") (param v128) (result v128) (f32x4.neg (local.get 0)))
+  (func (export "f32x4.sqrt") (param v128) (result v128) (f32x4.sqrt (local.get 0)))
+)
+
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                   (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                   (v128.const f32x4 246913578.0 246913578.0 246913578.0 246913578.0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 2.46913578e+27 2.46913578e+27 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                   (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                   (v128.const f32x4 2.46913578e+27 2.46913578e+27 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 2.46913578e-11 2.46913578e-11 2.46913578e-11 2.46913578e-11))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                   (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                   (v128.const f32x4 246913578.0 246913578.0 246913578.0 246913578.0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 2.46913578e+27 2.46913578e+27 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 2.46913578e+27 2.46913578e+27 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f32x4 2.46913578e-11 2.46913578e-11 2.46913578e-11 2.46913578e-11))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f32x4 246913578.02469134 246913578.02469134 246913578.02469134 246913578.02469134))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f32x4 2.4691357802469137e+27 2.4691357802469137e+27 2.4691357802469137e+27 2.4691357802469137e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f32x4 2.4691357802469137e+27 2.4691357802469137e+27 2.4691357802469137e+27 2.4691357802469137e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f32x4 2.4691357802469137e-11 2.4691357802469137e-11 2.4691357802469137e-11 2.4691357802469137e-11))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                   (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                   (v128.const f32x4 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                   (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                   (v128.const f32x4 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                   (v128.const f32x4 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                   (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                   (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                   (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                   (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                   (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-298 0x1.0000000000000p-298 0x1.0000000000000p-298 0x1.0000000000000p-298))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-298 -0x1.0000000000000p-298 -0x1.0000000000000p-298 -0x1.0000000000000p-298))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-298 -0x1.0000000000000p-298 -0x1.0000000000000p-298 -0x1.0000000000000p-298))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-298 0x1.0000000000000p-298 0x1.0000000000000p-298 0x1.0000000000000p-298))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-252 0x1.0000000000000p-252 0x1.0000000000000p-252 0x1.0000000000000p-252))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-252 -0x1.0000000000000p-252 -0x1.0000000000000p-252 -0x1.0000000000000p-252))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-252 -0x1.0000000000000p-252 -0x1.0000000000000p-252 -0x1.0000000000000p-252))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-252 0x1.0000000000000p-252 0x1.0000000000000p-252 0x1.0000000000000p-252))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-2 0x1.0000000000000p-2 0x1.0000000000000p-2 0x1.0000000000000p-2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-2 -0x1.0000000000000p-2 -0x1.0000000000000p-2 -0x1.0000000000000p-2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-2 -0x1.0000000000000p-2 -0x1.0000000000000p-2 -0x1.0000000000000p-2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-2 0x1.0000000000000p-2 0x1.0000000000000p-2 0x1.0000000000000p-2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                   (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                   (v128.const f32x4 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                   (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                   (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                   (v128.const f32x4 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f32x4 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f32x4 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f32x4 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                   (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                   (v128.const f32x4 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                   (v128.const f32x4 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                   (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                   (v128.const f32x4 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                   (v128.const f32x4 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                   (v128.const f32x4 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                   (v128.const f32x4 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-23 0x1.0000000000000p-23 0x1.0000000000000p-23 0x1.0000000000000p-23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-23 -0x1.0000000000000p-23 -0x1.0000000000000p-23 -0x1.0000000000000p-23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-277 0x1.0000010000010p-277 0x1.0000010000010p-277 0x1.0000010000010p-277))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-277 -0x1.0000010000010p-277 -0x1.0000010000010p-277 -0x1.0000010000010p-277))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-23 -0x1.0000000000000p-23 -0x1.0000000000000p-23 -0x1.0000000000000p-23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-23 0x1.0000000000000p-23 0x1.0000000000000p-23 0x1.0000000000000p-23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-277 -0x1.0000010000010p-277 -0x1.0000010000010p-277 -0x1.0000010000010p-277))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-277 0x1.0000010000010p-277 0x1.0000010000010p-277 0x1.0000010000010p-277))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+23 0x1.0000000000000p+23 0x1.0000000000000p+23 0x1.0000000000000p+23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+23 -0x1.0000000000000p+23 -0x1.0000000000000p+23 -0x1.0000000000000p+23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-254 0x1.0000010000010p-254 0x1.0000010000010p-254 0x1.0000010000010p-254))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-254 -0x1.0000010000010p-254 -0x1.0000010000010p-254 -0x1.0000010000010p-254))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+23 -0x1.0000000000000p+23 -0x1.0000000000000p+23 -0x1.0000000000000p+23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+23 0x1.0000000000000p+23 0x1.0000000000000p+23 0x1.0000000000000p+23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-254 -0x1.0000010000010p-254 -0x1.0000010000010p-254 -0x1.0000010000010p-254))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-254 0x1.0000010000010p-254 0x1.0000010000010p-254 0x1.0000010000010p-254))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+125 0x1.0000000000000p+125 0x1.0000000000000p+125 0x1.0000000000000p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+125 -0x1.0000000000000p+125 -0x1.0000000000000p+125 -0x1.0000000000000p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-129 0x1.0000010000010p-129 0x1.0000010000010p-129 0x1.0000010000010p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-129 -0x1.0000010000010p-129 -0x1.0000010000010p-129 -0x1.0000010000010p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+125 -0x1.0000000000000p+125 -0x1.0000000000000p+125 -0x1.0000000000000p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+125 0x1.0000000000000p+125 0x1.0000000000000p+125 0x1.0000000000000p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-129 -0x1.0000010000010p-129 -0x1.0000010000010p-129 -0x1.0000010000010p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-129 0x1.0000010000010p-129 0x1.0000010000010p-129 0x1.0000010000010p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+126 0x1.0000000000000p+126 0x1.0000000000000p+126 0x1.0000000000000p+126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+126 -0x1.0000000000000p+126 -0x1.0000000000000p+126 -0x1.0000000000000p+126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-128 0x1.0000010000010p-128 0x1.0000010000010p-128 0x1.0000010000010p-128))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-128 -0x1.0000010000010p-128 -0x1.0000010000010p-128 -0x1.0000010000010p-128))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+126 -0x1.0000000000000p+126 -0x1.0000000000000p+126 -0x1.0000000000000p+126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+126 0x1.0000000000000p+126 0x1.0000000000000p+126 0x1.0000000000000p+126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-128 -0x1.0000010000010p-128 -0x1.0000010000010p-128 -0x1.0000010000010p-128))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-128 0x1.0000010000010p-128 0x1.0000010000010p-128 0x1.0000010000010p-128))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                   (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                   (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                   (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                   (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                   (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.6a09e667f3bcdp-75 0x1.6a09e667f3bcdp-75 0x1.6a09e667f3bcdp-75 0x1.6a09e667f3bcdp-75))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-63 0x1.0000000000000p-63 0x1.0000000000000p-63 0x1.0000000000000p-63))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.6a09e667f3bcdp-1 0x1.6a09e667f3bcdp-1 0x1.6a09e667f3bcdp-1 0x1.6a09e667f3bcdp-1))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.40d9324a48138p+1 0x1.40d9324a48138p+1 0x1.40d9324a48138p+1 0x1.40d9324a48138p+1))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffeffffffcp+63 0x1.fffffeffffffcp+63 0x1.fffffeffffffcp+63 0x1.fffffeffffffcp+63))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 11111.111060555555 11111.111060555555 11111.111060555555 11111.111060555555))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 35136418286444.62 35136418286444.62 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 35136418286444.62 35136418286444.62 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 3.5136418286444623e-06 3.5136418286444623e-06 3.5136418286444623e-06 3.5136418286444623e-06))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 11111.111060555555 11111.111060555555 11111.111060555555 11111.111060555555))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 35136418286444.62 35136418286444.62 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 35136418286444.62 35136418286444.62 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 3.5136418286444623e-06 3.5136418286444623e-06 3.5136418286444623e-06 3.5136418286444623e-06))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 11111.11106111111 11111.11106111111 11111.11106111111 11111.11106111111))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 35136418288201.445 35136418288201.445 35136418288201.445 35136418288201.445))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 35136418288201.445 35136418288201.445 35136418288201.445 35136418288201.445))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 3.513641828820144e-06 3.513641828820144e-06 3.513641828820144e-06 3.513641828820144e-06))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                   (v128.const f32x4 -123456789.0 -123456789.0 -123456789.0 -123456789.0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                   (v128.const f32x4 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 -1.23456789e-11 -1.23456789e-11 -1.23456789e-11 -1.23456789e-11))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                   (v128.const f32x4 -123456789.0 -123456789.0 -123456789.0 -123456789.0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f32x4 -1.23456789e-11 -1.23456789e-11 -1.23456789e-11 -1.23456789e-11))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f32x4 -123456789.01234567 -123456789.01234567 -123456789.01234567 -123456789.01234567))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f32x4 -1.2345678901234569e+27 -1.2345678901234569e+27 -1.2345678901234569e+27 -1.2345678901234569e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f32x4 -1.2345678901234569e+27 -1.2345678901234569e+27 -1.2345678901234569e+27 -1.2345678901234569e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f32x4 -1.2345678901234568e-11 -1.2345678901234568e-11 -1.2345678901234568e-11 -1.2345678901234568e-11))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37))
+
+
+;; Mixed f32x4 tests when some lanes are NaNs
+(module
+
+  (func (export "f32x4_sqrt_arith") (result v128)
+    (f32x4.sqrt (v128.const f32x4 nan:0x200000 -nan:0x200000 16.0 25.0)))
+  (func (export "f32x4_sqrt_canon") (result v128)
+    (f32x4.sqrt (v128.const f32x4 -1.0 nan 4.0 9.0)))
+  (func (export "f32x4_sqrt_mixed") (result v128)
+    (f32x4.sqrt (v128.const f32x4 -inf nan:0x200000 36.0 49.0)))
+)
+
+(assert_return (invoke "f32x4_sqrt_arith") (v128.const f32x4 nan:arithmetic nan:arithmetic 4.0 5.0))
+(assert_return (invoke "f32x4_sqrt_canon") (v128.const f32x4 nan:canonical nan:canonical 2.0 3.0))
+(assert_return (invoke "f32x4_sqrt_mixed") (v128.const f32x4 nan:canonical nan:arithmetic 6.0 7.0))
+
+;; type check
+(assert_invalid (module (func (result v128) (f32x4.neg (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.sqrt (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.add (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.sub (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.mul (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.div (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.neg-arg-empty (result v128)
+      (f32x4.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.sqrt-arg-empty (result v128)
+      (f32x4.sqrt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.add-1st-arg-empty (result v128)
+      (f32x4.add (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.add-arg-empty (result v128)
+      (f32x4.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.sub-1st-arg-empty (result v128)
+      (f32x4.sub (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.sub-arg-empty (result v128)
+      (f32x4.sub)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.mul-1st-arg-empty (result v128)
+      (f32x4.mul (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.mul-arg-empty (result v128)
+      (f32x4.mul)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.div-1st-arg-empty (result v128)
+      (f32x4.div (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.div-arg-empty (result v128)
+      (f32x4.div)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (f32x4.add (f32x4.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-add") (param v128 v128 v128) (result v128)
+    (f32x4.div (f32x4.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-mul") (param v128 v128 v128) (result v128)
+    (f32x4.div (f32x4.mul (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-sub") (param v128 v128 v128) (result v128)
+    (f32x4.div (f32x4.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-add") (param v128 v128 v128) (result v128)
+    (f32x4.mul (f32x4.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-div") (param v128 v128 v128) (result v128)
+    (f32x4.mul (f32x4.div (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-sub") (param v128 v128 v128) (result v128)
+    (f32x4.mul (f32x4.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (f32x4.sub (f32x4.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (f32x4.add (f32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "add-sqrt") (param v128 v128) (result v128)
+    (f32x4.add (f32x4.sqrt (local.get 0)) (local.get 1)))
+  (func (export "div-neg") (param v128 v128) (result v128)
+    (f32x4.div (f32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "div-sqrt") (param v128 v128) (result v128)
+    (f32x4.div (f32x4.sqrt (local.get 0)) (local.get 1)))
+  (func (export "mul-neg") (param v128 v128) (result v128)
+    (f32x4.mul (f32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "mul-sqrt") (param v128 v128) (result v128)
+    (f32x4.mul (f32x4.sqrt (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (f32x4.sub (f32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-sqrt") (param v128 v128) (result v128)
+    (f32x4.sub (f32x4.sqrt (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "div-add" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 5.0 5.0 5.0 5.0))
+(assert_return (invoke "div-mul" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 4 4 4 4)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 18.0 18.0 18.0 18.0))
+(assert_return (invoke "div-sub" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 4.0 4.0 4.0 4.0))
+(assert_return (invoke "mul-add" (v128.const f32x4 1.25 1.25 1.25 1.25)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 0.375 0.375 0.375 0.375))
+(assert_return (invoke "mul-div" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 2.25 2.25 2.25 2.25))
+(assert_return (invoke "mul-sub" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+(assert_return (invoke "sub-add" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 1.25 1.25 1.25 1.25))
+(assert_return (invoke "add-neg" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+(assert_return (invoke "add-sqrt" (v128.const f32x4 2.25 2.25 2.25 2.25)
+                                  (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                  (v128.const f32x4 1.75 1.75 1.75 1.75))
+(assert_return (invoke "div-neg" (v128.const f32x4 1.5 1.5 1.5 1.5)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 -6 -6 -6 -6))
+(assert_return (invoke "div-sqrt" (v128.const f32x4 2.25 2.25 2.25 2.25)
+                                  (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                  (v128.const f32x4 6 6 6 6))
+(assert_return (invoke "mul-neg" (v128.const f32x4 1.5 1.5 1.5 1.5)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 -0.375 -0.375 -0.375 -0.375))
+(assert_return (invoke "mul-sqrt" (v128.const f32x4 2.25 2.25 2.25 2.25)
+                                  (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                  (v128.const f32x4 0.375 0.375 0.375 0.375))
+(assert_return (invoke "sub-neg" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 -1.25 -1.25 -1.25 -1.25))
+(assert_return (invoke "sub-sqrt" (v128.const f32x4 2.25 2.25 2.25 2.25)
+                                  (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                  (v128.const f32x4 1.25 1.25 1.25 1.25))
\ No newline at end of file
diff --git a/tests/wast/spec/simd_f32x4_cmp.wast b/tests/wast/spec/simd_f32x4_cmp.wast
new file mode 100644
index 0000000000..9e9a8735bf
--- /dev/null
+++ b/tests/wast/spec/simd_f32x4_cmp.wast
@@ -0,0 +1,8167 @@
+;; Test all the f32x4 comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) (f32x4.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) (f32x4.ne (local.get $x) (local.get $y)))
+  (func (export "lt") (param $x v128) (param $y v128) (result v128) (f32x4.lt (local.get $x) (local.get $y)))
+  (func (export "le") (param $x v128) (param $y v128) (result v128) (f32x4.le (local.get $x) (local.get $y)))
+  (func (export "gt") (param $x v128) (param $y v128) (result v128) (f32x4.gt (local.get $x) (local.get $y)))
+  (func (export "ge") (param $x v128) (param $y v128) (result v128) (f32x4.ge (local.get $x) (local.get $y)))
+)
+
+;; eq
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; ne
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+
+;; lt
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+
+;; le
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; gt
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+
+;; ge
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; eq
+
+;; f32x4.eq  (f32x4) (i8x16)
+(assert_return (invoke "eq" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 0 -1 0 0))
+
+;; f32x4.eq  (f32x4) (i16x8)
+(assert_return (invoke "eq" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 0 -1 0 0))
+
+;; f32x4.eq  (f32x4) (i32x4)
+(assert_return (invoke "eq" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 -1 -1 0 0 ))
+
+;; ne
+
+;; f32x4.ne  (f32x4) (i8x16)
+(assert_return (invoke "ne" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 -1 0 -1 -1))
+
+;; f32x4.ne  (f32x4) (i16x8)
+(assert_return (invoke "ne" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 -1 0 -1 -1))
+
+;; f32x4.ne  (f32x4) (i32x4)
+(assert_return (invoke "ne" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 0 0 -1 -1))
+
+;; lt
+
+;; f32x4.lt  (f32x4) (i8x16)
+(assert_return (invoke "lt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 0 0 0 0))
+
+;; f32x4.lt  (f32x4) (i16x8)
+(assert_return (invoke "lt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 0 0 0 0))
+
+;; f32x4.lt  (f32x4) (i32x4)
+(assert_return (invoke "lt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 0 0 0 0))
+
+;; le
+
+;; f32x4.le  (f32x4) (i8x16)
+(assert_return (invoke "le" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 0 -1 0 0))
+
+;; f32x4.le  (f32x4) (i16x8)
+(assert_return (invoke "le" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 0 -1 0 0))
+
+;; f32x4.le  (f32x4) (i32x4)
+(assert_return (invoke "le" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 -1 -1 0 0))
+
+;; gt
+
+;; f32x4.gt  (f32x4) (i8x16)
+(assert_return (invoke "gt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 0 0 -1 -1))
+
+;; f32x4.gt  (f32x4) (i16x8)
+(assert_return (invoke "gt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 0 0 -1 -1))
+
+;; f32x4.gt  (f32x4) (i32x4)
+(assert_return (invoke "gt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 0 0 -1 -1))
+
+;; ge
+
+;; f32x4.ge  (f32x4) (i8x16)
+(assert_return (invoke "ge" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 0 -1 -1 -1))
+
+;; f32x4.ge  (f32x4) (i16x8)
+(assert_return (invoke "ge" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 0 -1 -1 -1))
+
+;; f32x4.ge  (f32x4) (i32x4)
+(assert_return (invoke "ge" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (f32x4.eq (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.ge (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.gt (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.le (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.lt (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.ne (i64.const 0) (f64.const 0)))) "type mismatch")
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.eq (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.ge (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.gt (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.le (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.lt (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.ne (local.get $x) (local.get $y)))") "unknown operator")
+
+
+;; Combination
+
+(module (memory 1)
+  (func (export "eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "lt-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.lt
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "le-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.le
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "gt-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.gt
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ge-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.ge
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-eq")
+    (drop
+      (f32x4.eq
+        (f32x4.eq
+          (f32x4.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.eq
+          (f32x4.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ne")
+    (drop
+      (f32x4.ne
+        (f32x4.ne
+          (f32x4.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.ne
+          (f32x4.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-lt")
+    (drop
+      (f32x4.lt
+        (f32x4.lt
+          (f32x4.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.lt
+          (f32x4.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-le")
+    (drop
+      (f32x4.le
+        (f32x4.le
+          (f32x4.le
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.le
+          (f32x4.le
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-gt")
+    (drop
+      (f32x4.gt
+        (f32x4.gt
+          (f32x4.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.gt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.gt
+          (f32x4.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.gt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ge")
+    (drop
+      (f32x4.ge
+        (f32x4.ge
+          (f32x4.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ge
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.ge
+          (f32x4.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ge
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (f32x4.ge
+        (f32x4.eq
+          (f32x4.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.ne
+          (f32x4.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+
+(assert_return (invoke "eq-in-block"))
+(assert_return (invoke "ne-in-block"))
+(assert_return (invoke "lt-in-block"))
+(assert_return (invoke "le-in-block"))
+(assert_return (invoke "gt-in-block"))
+(assert_return (invoke "ge-in-block"))
+(assert_return (invoke "nested-eq"))
+(assert_return (invoke "nested-ne"))
+(assert_return (invoke "nested-lt"))
+(assert_return (invoke "nested-le"))
+(assert_return (invoke "nested-gt"))
+(assert_return (invoke "nested-ge"))
+(assert_return (invoke "as-param"))
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.eq-1st-arg-empty (result v128)
+      (f32x4.eq (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.eq-arg-empty (result v128)
+      (f32x4.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.ne-1st-arg-empty (result v128)
+      (f32x4.ne (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.ne-arg-empty (result v128)
+      (f32x4.ne)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.lt-1st-arg-empty (result v128)
+      (f32x4.lt (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.lt-arg-empty (result v128)
+      (f32x4.lt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.le-1st-arg-empty (result v128)
+      (f32x4.le (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.le-arg-empty (result v128)
+      (f32x4.le)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.gt-1st-arg-empty (result v128)
+      (f32x4.gt (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.gt-arg-empty (result v128)
+      (f32x4.gt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.ge-1st-arg-empty (result v128)
+      (f32x4.ge (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.ge-arg-empty (result v128)
+      (f32x4.ge)
+    )
+  )
+  "type mismatch"
+)
\ No newline at end of file
diff --git a/tests/wast/spec/simd_f32x4_pmin_pmax.wast b/tests/wast/spec/simd_f32x4_pmin_pmax.wast
new file mode 100644
index 0000000000..b0f47b380c
--- /dev/null
+++ b/tests/wast/spec/simd_f32x4_pmin_pmax.wast
@@ -0,0 +1,11676 @@
+;; Tests for f32x4 [pmin, pmax] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f32x4.pmin") (param v128 v128) (result v128) (f32x4.pmin (local.get 0) (local.get 1)))
+  (func (export "f32x4.pmax") (param v128 v128) (result v128) (f32x4.pmax (local.get 0) (local.get 1)))
+)
+
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f32x4.pmin (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.pmax (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.pmin-1st-arg-empty (result v128)
+      (f32x4.pmin (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.pmin-arg-empty (result v128)
+      (f32x4.pmin)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.pmax-1st-arg-empty (result v128)
+      (f32x4.pmax (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.pmax-arg-empty (result v128)
+      (f32x4.pmax)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/tests/wast/spec/simd_f32x4_rounding.wast b/tests/wast/spec/simd_f32x4_rounding.wast
new file mode 100644
index 0000000000..e59f99a77b
--- /dev/null
+++ b/tests/wast/spec/simd_f32x4_rounding.wast
@@ -0,0 +1,424 @@
+;; Tests for f32x4 [ceil, floor, trunc, nearest] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f32x4.ceil") (param v128) (result v128) (f32x4.ceil (local.get 0)))
+  (func (export "f32x4.floor") (param v128) (result v128) (f32x4.floor (local.get 0)))
+  (func (export "f32x4.trunc") (param v128) (result v128) (f32x4.trunc (local.get 0)))
+  (func (export "f32x4.nearest") (param v128) (result v128) (f32x4.nearest (local.get 0)))
+)
+
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.c000000000000p+2 0x1.c000000000000p+2 0x1.c000000000000p+2 0x1.c000000000000p+2))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 123456790.0 123456790.0 123456790.0 123456790.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 156374987062.0 156374987062.0 156374987062.0 156374987062.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 156374987062.0 156374987062.0 156374987062.0 156374987062.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 156374987062.0 156374987062.0 156374987062.0 156374987062.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                     (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                     (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                     (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                     (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                     (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                     (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                     (v128.const f32x4 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                     (v128.const f32x4 -0x1.c000000000000p+2 -0x1.c000000000000p+2 -0x1.c000000000000p+2 -0x1.c000000000000p+2))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                     (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                     (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 inf inf inf inf))
+                                     (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -inf -inf -inf -inf))
+                                     (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                     (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                     (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 nan nan nan nan))
+                                     (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -nan -nan -nan -nan))
+                                     (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                     (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                     (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                     (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                     (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                     (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                     (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                     (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                     (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                     (v128.const f32x4 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                     (v128.const f32x4 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                     (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                     (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 inf inf inf inf))
+                                     (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -inf -inf -inf -inf))
+                                     (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                     (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                     (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 nan nan nan nan))
+                                     (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -nan -nan -nan -nan))
+                                     (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                     (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                     (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                       (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                       (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                       (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                       (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                       (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                       (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                       (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                       (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                       (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                       (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                       (v128.const f32x4 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                       (v128.const f32x4 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                       (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                       (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 inf inf inf inf))
+                                       (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -inf -inf -inf -inf))
+                                       (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                       (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                       (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                       (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                       (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                       (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                       (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                       (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                       (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                       (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                       (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                       (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                       (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                       (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                       (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                       (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                       (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                       (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                       (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 nan nan nan nan))
+                                       (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -nan -nan -nan -nan))
+                                       (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                       (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                       (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f32x4.ceil (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.floor (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.trunc (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.nearest (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.ceil-arg-empty (result v128)
+      (f32x4.ceil)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.floor-arg-empty (result v128)
+      (f32x4.floor)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.trunc-arg-empty (result v128)
+      (f32x4.trunc)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.nearest-arg-empty (result v128)
+      (f32x4.nearest)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/tests/wast/spec/simd_f64x2.wast b/tests/wast/spec/simd_f64x2.wast
new file mode 100644
index 0000000000..8ebd33b368
--- /dev/null
+++ b/tests/wast/spec/simd_f64x2.wast
@@ -0,0 +1,2459 @@
+;; Tests for f64x2 [abs, min, max] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f64x2.min") (param v128 v128) (result v128) (f64x2.min (local.get 0) (local.get 1)))
+  (func (export "f64x2.max") (param v128 v128) (result v128) (f64x2.max (local.get 0) (local.get 1)))
+  (func (export "f64x2.abs") (param v128) (result v128) (f64x2.abs (local.get 0)))
+  ;; f64x2.min const vs const
+  (func (export "f64x2.min_with_const_0") (result v128) (f64x2.min (v128.const f64x2 0 1) (v128.const f64x2 0 2)))
+  (func (export "f64x2.min_with_const_1") (result v128) (f64x2.min (v128.const f64x2 2 -3) (v128.const f64x2 1 3)))
+  (func (export "f64x2.min_with_const_2") (result v128) (f64x2.min (v128.const f64x2 0 1) (v128.const f64x2 0 1)))
+  (func (export "f64x2.min_with_const_3") (result v128) (f64x2.min (v128.const f64x2 2 3) (v128.const f64x2 2 3)))
+  (func (export "f64x2.min_with_const_4") (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x02)))
+  (func (export "f64x2.min_with_const_5") (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x01 2147483648)))
+  (func (export "f64x2.min_with_const_6") (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x01)))
+  (func (export "f64x2.min_with_const_7") (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x02 0x80000000)))
+  ;; f64x2.min param vs const
+  (func (export "f64x2.min_with_const_9") (param v128) (result v128) (f64x2.min (local.get 0) (v128.const f64x2 0 1)))
+  (func (export "f64x2.min_with_const_10") (param v128) (result v128) (f64x2.min (v128.const f64x2 2 -3) (local.get 0)))
+  (func (export "f64x2.min_with_const_11") (param v128) (result v128) (f64x2.min (v128.const f64x2 0 1) (local.get 0)))
+  (func (export "f64x2.min_with_const_12") (param v128) (result v128) (f64x2.min (local.get 0) (v128.const f64x2 2 3)))
+  (func (export "f64x2.min_with_const_13") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.min_with_const_14") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+  (func (export "f64x2.min_with_const_15") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.min_with_const_16") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+  ;; f64x2.max const vs const
+  (func (export "f64x2.max_with_const_18") (result v128) (f64x2.max (v128.const f64x2 0 1) (v128.const f64x2 0 2)))
+  (func (export "f64x2.max_with_const_19") (result v128) (f64x2.max (v128.const f64x2 2 -3) (v128.const f64x2 1 3)))
+  (func (export "f64x2.max_with_const_20") (result v128) (f64x2.max (v128.const f64x2 0 1) (v128.const f64x2 0 1)))
+  (func (export "f64x2.max_with_const_21") (result v128) (f64x2.max (v128.const f64x2 2 3) (v128.const f64x2 2 3)))
+  (func (export "f64x2.max_with_const_22") (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x02)))
+  (func (export "f64x2.max_with_const_23") (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x01 2147483648)))
+  (func (export "f64x2.max_with_const_24") (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x01)))
+  (func (export "f64x2.max_with_const_25") (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x02 0x80000000)))
+  ;; f64x2.max param vs const
+  (func (export "f64x2.max_with_const_27") (param v128) (result v128) (f64x2.max (local.get 0) (v128.const f64x2 0 1)))
+  (func (export "f64x2.max_with_const_28") (param v128) (result v128) (f64x2.max (v128.const f64x2 2 -3) (local.get 0)))
+  (func (export "f64x2.max_with_const_29") (param v128) (result v128) (f64x2.max (v128.const f64x2 0 1) (local.get 0)))
+  (func (export "f64x2.max_with_const_30") (param v128) (result v128) (f64x2.max (local.get 0) (v128.const f64x2 2 3)))
+  (func (export "f64x2.max_with_const_31") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.max_with_const_32") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+  (func (export "f64x2.max_with_const_33") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.max_with_const_34") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+
+  (func (export "f64x2.abs_with_const_35") (result v128) (f64x2.abs (v128.const f64x2 -0 -1)))
+  (func (export "f64x2.abs_with_const_36") (result v128) (f64x2.abs (v128.const f64x2 -2 -3)))
+)
+
+;; f64x2.min const vs const
+(assert_return (invoke "f64x2.min_with_const_0") (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.min_with_const_1") (v128.const f64x2 1 -3))
+(assert_return (invoke "f64x2.min_with_const_2") (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.min_with_const_3") (v128.const f64x2 2 3))
+;; f64x2.min param vs const
+(assert_return (invoke "f64x2.min_with_const_4") (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.min_with_const_5") (v128.const f64x2 0x01 0x80000000))
+(assert_return (invoke "f64x2.min_with_const_6") (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.min_with_const_7") (v128.const f64x2 0x02 0x80000000))
+(assert_return (invoke "f64x2.min_with_const_9" (v128.const f64x2 0 2))
+                                                (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.min_with_const_10" (v128.const f64x2 1 3))
+                                                 (v128.const f64x2 1 -3))
+(assert_return (invoke "f64x2.min_with_const_11" (v128.const f64x2 0 1))
+                                                 (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.min_with_const_12" (v128.const f64x2 2 3))
+                                                 (v128.const f64x2 2 3))
+(assert_return (invoke "f64x2.min_with_const_13" (v128.const f64x2 0x00 0x02))
+                                                 (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.min_with_const_14" (v128.const f64x2 0x01 2147483648))
+                                                 (v128.const f64x2 0x01 0x80000000))
+(assert_return (invoke "f64x2.min_with_const_15" (v128.const f64x2 0x00 0x01))
+                                                 (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.min_with_const_16" (v128.const f64x2 0x02 0x80000000))
+                                                 (v128.const f64x2 0x02 0x80000000))
+;; f64x2.max const vs const
+(assert_return (invoke "f64x2.max_with_const_18") (v128.const f64x2 0 2))
+(assert_return (invoke "f64x2.max_with_const_19") (v128.const f64x2 2 3))
+(assert_return (invoke "f64x2.max_with_const_20") (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.max_with_const_21") (v128.const f64x2 2 3))
+;; f64x2.max param vs const
+(assert_return (invoke "f64x2.max_with_const_22") (v128.const f64x2 0x00 0x02))
+(assert_return (invoke "f64x2.max_with_const_23") (v128.const f64x2 0x02 2147483648))
+(assert_return (invoke "f64x2.max_with_const_24") (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.max_with_const_25") (v128.const f64x2 0x02 0x80000000))
+(assert_return (invoke "f64x2.max_with_const_27" (v128.const f64x2 0 2))
+                                                 (v128.const f64x2 0 2))
+(assert_return (invoke "f64x2.max_with_const_28" (v128.const f64x2 1 3))
+                                                 (v128.const f64x2 2 3))
+(assert_return (invoke "f64x2.max_with_const_29" (v128.const f64x2 0 1))
+                                                 (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.max_with_const_30" (v128.const f64x2 2 3))
+                                                 (v128.const f64x2 2 3))
+(assert_return (invoke "f64x2.max_with_const_31" (v128.const f64x2 0x00 0x02))
+                                                 (v128.const f64x2 0x00 0x02))
+(assert_return (invoke "f64x2.max_with_const_32" (v128.const f64x2 0x01 2147483648))
+                                                 (v128.const f64x2 0x02 2147483648))
+(assert_return (invoke "f64x2.max_with_const_33" (v128.const f64x2 0x00 0x01))
+                                                 (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.max_with_const_34" (v128.const f64x2 0x02 0x80000000))
+                                                 (v128.const f64x2 0x02 0x80000000))
+
+(assert_return (invoke "f64x2.abs_with_const_35") (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.abs_with_const_36") (v128.const f64x2 2 3))
+
+;; Test different lanes go through different if-then clauses
+;; f64x2.min
+(assert_return
+  (invoke "f64x2.min"
+    (v128.const f64x2 nan 0)
+    (v128.const f64x2 0 1)
+  )
+  (v128.const f64x2 nan:canonical 0)
+)
+;; f64x2.min
+(assert_return
+  (invoke "f64x2.min"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 0)
+  )
+  (v128.const f64x2 nan:canonical 0)
+)
+;; f64x2.min
+(assert_return
+  (invoke "f64x2.min"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 1)
+  )
+  (v128.const f64x2 nan:canonical 1)
+)
+;; f64x2.max
+(assert_return
+  (invoke "f64x2.max"
+    (v128.const f64x2 nan 0)
+    (v128.const f64x2 0 1)
+  )
+  (v128.const f64x2 nan:canonical 1)
+)
+;; f64x2.max
+(assert_return
+  (invoke "f64x2.max"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 0)
+  )
+  (v128.const f64x2 nan:canonical 1)
+)
+;; f64x2.max
+(assert_return
+  (invoke "f64x2.max"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 1)
+  )
+  (v128.const f64x2 nan:canonical 1)
+)
+
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+
+;; Test opposite signs of zero
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0 0)
+                                   (v128.const f64x2 +0 -0))
+                                   (v128.const f64x2 0 -0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0 +0)
+                                   (v128.const f64x2 +0 -0))
+                                   (v128.const f64x2 -0 -0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0 -0)
+                                   (v128.const f64x2 +0 +0))
+                                   (v128.const f64x2 -0 -0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0 0)
+                                   (v128.const f64x2 +0 -0))
+                                   (v128.const f64x2 0 0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0 +0)
+                                   (v128.const f64x2 +0 -0))
+                                   (v128.const f64x2 0 0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0 -0)
+                                   (v128.const f64x2 +0 +0))
+                                   (v128.const f64x2 +0 +0))
+
+
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+
+;; type check
+(assert_invalid (module (func (result v128) (f64x2.abs (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.min (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.max (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f64x2.abs-arg-empty (result v128)
+      (f64x2.abs)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.min-1st-arg-empty (result v128)
+      (f64x2.min (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.min-arg-empty (result v128)
+      (f64x2.min)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.max-1st-arg-empty (result v128)
+      (f64x2.max (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.max-arg-empty (result v128)
+      (f64x2.max)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "max-min") (param v128 v128 v128) (result v128)
+    (f64x2.max (f64x2.min (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "min-max") (param v128 v128 v128) (result v128)
+    (f64x2.min (f64x2.max (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "max-abs") (param v128 v128) (result v128)
+    (f64x2.max (f64x2.abs (local.get 0)) (local.get 1)))
+  (func (export "min-abs") (param v128 v128) (result v128)
+    (f64x2.min (f64x2.abs (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "max-min" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.25 0.25)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 0.25 0.25))
+(assert_return (invoke "min-max" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.25 0.25)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 0.125 0.125))
+(assert_return (invoke "max-abs" (v128.const f64x2 -1.125 -1.125)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 1.125 1.125))
+(assert_return (invoke "min-abs" (v128.const f64x2 -1.125 -1.125)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 0.125 0.125))
\ No newline at end of file
diff --git a/tests/wast/spec/simd_f64x2_arith.wast b/tests/wast/spec/simd_f64x2_arith.wast
new file mode 100644
index 0000000000..4ab3b01e96
--- /dev/null
+++ b/tests/wast/spec/simd_f64x2_arith.wast
@@ -0,0 +1,5483 @@
+;; Tests for f64x2 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f64x2.add") (param v128 v128) (result v128) (f64x2.add (local.get 0) (local.get 1)))
+  (func (export "f64x2.sub") (param v128 v128) (result v128) (f64x2.sub (local.get 0) (local.get 1)))
+  (func (export "f64x2.mul") (param v128 v128) (result v128) (f64x2.mul (local.get 0) (local.get 1)))
+  (func (export "f64x2.div") (param v128 v128) (result v128) (f64x2.div (local.get 0) (local.get 1)))
+  (func (export "f64x2.neg") (param v128) (result v128) (f64x2.neg (local.get 0)))
+  (func (export "f64x2.sqrt") (param v128) (result v128) (f64x2.sqrt (local.get 0)))
+)
+
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1021 0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1021 -0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.b21fb54442d18p+2 0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.721fb54442d18p+2 -0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.721fb54442d18p+2 0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.b21fb54442d18p+2 -0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.d21fb54442d18p+2 0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.521fb54442d18p+2 -0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.521fb54442d18p+2 0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.d21fb54442d18p+2 -0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.b21fb54442d18p+2 0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.721fb54442d18p+2 0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.d21fb54442d18p+2 0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.521fb54442d18p+2 0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+3 0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.721fb54442d18p+2 -0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.b21fb54442d18p+2 -0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.521fb54442d18p+2 -0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.d21fb54442d18p+2 -0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+3 -0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789 0123456789)
+                                   (v128.const f64x2 0123456789 0123456789))
+                                   (v128.const f64x2 246913578.0 246913578.0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789e019 0123456789e019)
+                                   (v128.const f64x2 0123456789e019 0123456789e019))
+                                   (v128.const f64x2 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                   (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                   (v128.const f64x2 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                   (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                   (v128.const f64x2 2.46913578e-11 2.46913578e-11))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789. 0123456789.)
+                                   (v128.const f64x2 0123456789. 0123456789.))
+                                   (v128.const f64x2 246913578.0 246913578.0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                   (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                   (v128.const f64x2 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f64x2 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f64x2 2.46913578e-11 2.46913578e-11))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f64x2 246913578.02469134 246913578.02469134))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f64x2 2.4691357802469137e+27 2.4691357802469137e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f64x2 2.4691357802469137e+27 2.4691357802469137e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f64x2 2.4691357802469137e-11 2.4691357802469137e-11))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.23456789abcdfp+81 0x1.23456789abcdfp+81))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+62 0x1.23456789abcdfp+62))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                   (v128.const f64x2 0x1.23456789abcdfp+81 0x1.23456789abcdfp+81))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+62 0x1.23456789abcdfp+62))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.23456789abcdfp+81 0x1.23456789abcdfp+81))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+62 0x1.23456789abcdfp+62))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1021 0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.fffffffffffffp-1022 0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.fffffffffffffp-1022 0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1021 -0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000001p-1022 -0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000001p-1022 -0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.721fb54442d18p+2 -0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.b21fb54442d18p+2 0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.b21fb54442d18p+2 -0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.721fb54442d18p+2 0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.521fb54442d18p+2 -0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.d21fb54442d18p+2 0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.d21fb54442d18p+2 -0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.521fb54442d18p+2 0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.721fb54442d18p+2 0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.b21fb54442d18p+2 0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.521fb54442d18p+2 0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.d21fb54442d18p+2 0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+3 0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.b21fb54442d18p+2 -0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.721fb54442d18p+2 -0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.d21fb54442d18p+2 -0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.521fb54442d18p+2 -0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+3 -0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789 0123456789)
+                                   (v128.const f64x2 0123456789 0123456789))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789e019 0123456789e019)
+                                   (v128.const f64x2 0123456789e019 0123456789e019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                   (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                   (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789. 0123456789.)
+                                   (v128.const f64x2 0123456789. 0123456789.))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                   (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.8000000000000p-1022 0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.8000000000000p-1022 -0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p-1020 0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p-1020 -0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1 0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1 -0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x0.8000000000000p-1022 -0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.8000000000000p-1022 0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p-1020 -0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p-1020 0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1 -0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1 0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.8000000000000p-1022 0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.8000000000000p-1022 -0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-2 0x1.0000000000000p-2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-2 -0x1.0000000000000p-2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+1 0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+1 -0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1022 0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1022 -0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.8000000000000p-1022 -0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.8000000000000p-1022 0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-2 -0x1.0000000000000p-2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-2 0x1.0000000000000p-2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+1 -0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+1 0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1022 -0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1022 0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p-1020 0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p-1020 -0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+1 0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+1 -0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.3bd3cc9be45dep+5 0x1.3bd3cc9be45dep+5))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.3bd3cc9be45dep+5 -0x1.3bd3cc9be45dep+5))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000006p-1022 0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000006p-1022 0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p-1020 -0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p-1020 0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+1 -0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+1 0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.3bd3cc9be45dep+5 -0x1.3bd3cc9be45dep+5))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.3bd3cc9be45dep+5 0x1.3bd3cc9be45dep+5))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000006p-1022 -0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000006p-1022 -0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1 0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1 -0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1022 0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1022 -0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp-51 0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp-51 0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1 -0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1 0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1022 -0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1022 0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp-51 -0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp-51 -0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0000000000006p-1022 0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0000000000006p-1022 -0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp-51 0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp-51 -0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0000000000006p-1022 0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0000000000006p-1022 -0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp-51 0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp-51 -0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789 0123456789)
+                                   (v128.const f64x2 0123456789 0123456789))
+                                   (v128.const f64x2 1.524157875019052e+16 1.524157875019052e+16))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789e019 0123456789e019)
+                                   (v128.const f64x2 0123456789e019 0123456789e019))
+                                   (v128.const f64x2 1.524157875019052e+54 1.524157875019052e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                   (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                   (v128.const f64x2 1.524157875019052e+54 1.524157875019052e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                   (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                   (v128.const f64x2 1.524157875019052e-22 1.524157875019052e-22))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789. 0123456789.)
+                                   (v128.const f64x2 0123456789. 0123456789.))
+                                   (v128.const f64x2 1.524157875019052e+16 1.524157875019052e+16))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                   (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                   (v128.const f64x2 1.524157875019052e+54 1.524157875019052e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f64x2 1.524157875019052e+54 1.524157875019052e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f64x2 1.524157875019052e-22 1.524157875019052e-22))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f64x2 1.5241578753238834e+16 1.5241578753238834e+16))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f64x2 1.5241578753238838e+54 1.5241578753238838e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f64x2 1.5241578753238838e+54 1.5241578753238838e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f64x2 1.524157875323884e-22 1.524157875323884e-22))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+160 0x1.4b66dc33f6acep+160))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+122 0x1.4b66dc33f6acep+122))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+160 0x1.4b66dc33f6acep+160))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+122 0x1.4b66dc33f6acep+122))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+160 0x1.4b66dc33f6acep+160))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+122 0x1.4b66dc33f6acep+122))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1021 0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1021 -0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.28be60db93910p-1022 0x0.28be60db93910p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.28be60db93910p-1022 -0x0.28be60db93910p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+52 0x1.0000000000000p+52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+52 0x1.0000000000000p+52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1021 -0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1021 0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.28be60db93910p-1022 -0x0.28be60db93910p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.28be60db93910p-1022 0x0.28be60db93910p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+52 -0x1.0000000000000p+52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+52 -0x1.0000000000000p+52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+1021 0x1.0000000000000p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+1021 -0x1.0000000000000p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c883p-4 0x1.45f306dc9c883p-4))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c883p-4 -0x1.45f306dc9c883p-4))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.2000000000000p-1022 0x0.2000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.2000000000000p-1022 -0x0.2000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+1021 -0x1.0000000000000p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+1021 0x1.0000000000000p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c883p-4 -0x1.45f306dc9c883p-4))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c883p-4 0x1.45f306dc9c883p-4))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.2000000000000p-1022 -0x0.2000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.2000000000000p-1022 0x0.2000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+1022 0x1.0000000000000p+1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+1022 -0x1.0000000000000p+1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c883p-3 0x1.45f306dc9c883p-3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c883p-3 -0x1.45f306dc9c883p-3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.4000000000000p-1022 0x0.4000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.4000000000000p-1022 -0x0.4000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+1022 -0x1.0000000000000p+1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+1022 0x1.0000000000000p+1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c883p-3 -0x1.45f306dc9c883p-3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c883p-3 0x1.45f306dc9c883p-3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.4000000000000p-1022 -0x0.4000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.4000000000000p-1022 0x0.4000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+3 0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+3 -0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.921fb54442d19p-1022 0x1.921fb54442d19p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.921fb54442d19p-1022 -0x1.921fb54442d19p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+3 -0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+3 0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.921fb54442d19p-1022 -0x1.921fb54442d19p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.921fb54442d19p-1022 0x1.921fb54442d19p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c882p+1021 0x1.45f306dc9c882p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c882p+1021 -0x1.45f306dc9c882p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c882p+1021 -0x1.45f306dc9c882p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c882p+1021 0x1.45f306dc9c882p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-52 0x1.0000000000000p-52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-52 -0x1.0000000000000p-52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-52 0x1.0000000000000p-52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-52 -0x1.0000000000000p-52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789 0123456789)
+                                   (v128.const f64x2 0123456789 0123456789))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789e019 0123456789e019)
+                                   (v128.const f64x2 0123456789e019 0123456789e019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                   (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                   (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789. 0123456789.)
+                                   (v128.const f64x2 0123456789. 0123456789.))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                   (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-511 0x1.0000000000000p-511))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.6a09e667f3bcdp-1 0x1.6a09e667f3bcdp-1))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.40d931ff62705p+1 0x1.40d931ff62705p+1))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+511 0x1.fffffffffffffp+511))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-537 0x1.0000000000000p-537))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-537 0x1.0000000000000p-537))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 11111.111060555555 11111.111060555555))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 3.5136418286444623e-06 3.5136418286444623e-06))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 11111.111060555555 11111.111060555555))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 3.5136418286444623e-06 3.5136418286444623e-06))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 11111.11106111111 11111.11106111111))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 35136418288201.445 35136418288201.445))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 35136418288201.445 35136418288201.445))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 3.513641828820144e-06 3.513641828820144e-06))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.1111111111111p+40 0x1.1111111111111p+40))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+30 0x1.822cb17ff2eb8p+30))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.1111111111111p+40 0x1.1111111111111p+40))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+30 0x1.822cb17ff2eb8p+30))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.1111111111111p+40 0x1.1111111111111p+40))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+30 0x1.822cb17ff2eb8p+30))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789 0123456789))
+                                   (v128.const f64x2 -123456789.0 -123456789.0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789e019 0123456789e019))
+                                   (v128.const f64x2 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                   (v128.const f64x2 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                   (v128.const f64x2 -1.23456789e-11 -1.23456789e-11))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789. 0123456789.))
+                                   (v128.const f64x2 -123456789.0 -123456789.0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                   (v128.const f64x2 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f64x2 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f64x2 -1.23456789e-11 -1.23456789e-11))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f64x2 -123456789.01234567 -123456789.01234567))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f64x2 -1.2345678901234569e+27 -1.2345678901234569e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f64x2 -1.2345678901234569e+27 -1.2345678901234569e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f64x2 -1.2345678901234568e-11 -1.2345678901234568e-11))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+80 -0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+61 -0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+80 -0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+61 -0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+80 -0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+61 -0x1.23456789abcdfp+61))
+
+;; Mixed f64x2 tests when some lanes are NaNs
+(module
+  (func (export "f64x2_add_arith") (result v128)
+    (f64x2.add (v128.const f64x2 nan:0x8000000000000 1.0) (v128.const f64x2 nan 1.0)))
+  (func (export "f64x2_div_mixed") (result v128)
+    (f64x2.div (v128.const f64x2 nan 1.0) (v128.const f64x2 2.0 -nan:0x8000000000000)))
+  (func (export "f64x2_mul_mixed") (result v128)
+    (f64x2.mul (v128.const f64x2 nan:0x8000000000000 1.0) (v128.const f64x2 2.0 nan)))
+  (func (export "f64x2_neg_canon") (result v128)
+    (f64x2.neg (v128.const f64x2 nan 1.0)))
+  (func (export "f64x2_sqrt_canon") (result v128)
+    (f64x2.sqrt (v128.const f64x2 4.0 -nan)))
+  (func (export "f64x2_sub_arith") (result v128)
+    (f64x2.sub (v128.const f64x2 1.0 -1.0) (v128.const f64x2 -nan 1.0)))
+)
+
+(assert_return (invoke "f64x2_add_arith") (v128.const f64x2 nan:arithmetic 2.0))
+(assert_return (invoke "f64x2_div_mixed") (v128.const f64x2 nan:canonical nan:arithmetic))
+(assert_return (invoke "f64x2_mul_mixed") (v128.const f64x2 nan:arithmetic nan:canonical))
+(assert_return (invoke "f64x2_neg_canon") (v128.const f64x2 nan:canonical -1.0))
+(assert_return (invoke "f64x2_sqrt_canon") (v128.const f64x2 2.0 nan:canonical))
+(assert_return (invoke "f64x2_sub_arith") (v128.const f64x2 nan:canonical -2.0))
+
+;; type check
+(assert_invalid (module (func (result v128) (f64x2.neg (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.sqrt (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.add (i64.const 0) (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.sub (i64.const 0) (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.mul (i64.const 0) (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.div (i64.const 0) (f64.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f64x2.neg-arg-empty (result v128)
+      (f64x2.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.sqrt-arg-empty (result v128)
+      (f64x2.sqrt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.add-1st-arg-empty (result v128)
+      (f64x2.add (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.add-arg-empty (result v128)
+      (f64x2.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.sub-1st-arg-empty (result v128)
+      (f64x2.sub (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.sub-arg-empty (result v128)
+      (f64x2.sub)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.mul-1st-arg-empty (result v128)
+      (f64x2.mul (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.mul-arg-empty (result v128)
+      (f64x2.mul)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.div-1st-arg-empty (result v128)
+      (f64x2.div (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.div-arg-empty (result v128)
+      (f64x2.div)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (f64x2.add (f64x2.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-add") (param v128 v128 v128) (result v128)
+    (f64x2.div (f64x2.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-mul") (param v128 v128 v128) (result v128)
+    (f64x2.div (f64x2.mul (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-sub") (param v128 v128 v128) (result v128)
+    (f64x2.div (f64x2.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-add") (param v128 v128 v128) (result v128)
+    (f64x2.mul (f64x2.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-div") (param v128 v128 v128) (result v128)
+    (f64x2.mul (f64x2.div (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-sub") (param v128 v128 v128) (result v128)
+    (f64x2.mul (f64x2.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (f64x2.sub (f64x2.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (f64x2.add (f64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "add-sqrt") (param v128 v128) (result v128)
+    (f64x2.add (f64x2.sqrt (local.get 0)) (local.get 1)))
+  (func (export "div-neg") (param v128 v128) (result v128)
+    (f64x2.div (f64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "div-sqrt") (param v128 v128) (result v128)
+    (f64x2.div (f64x2.sqrt (local.get 0)) (local.get 1)))
+  (func (export "mul-neg") (param v128 v128) (result v128)
+    (f64x2.mul (f64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "mul-sqrt") (param v128 v128) (result v128)
+    (f64x2.mul (f64x2.sqrt (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (f64x2.sub (f64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-sqrt") (param v128 v128) (result v128)
+    (f64x2.sub (f64x2.sqrt (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.25 0.25)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "div-add" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 5.0 5.0))
+(assert_return (invoke "div-mul" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 4 4)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 18.0 18.0))
+(assert_return (invoke "div-sub" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 4.0 4.0))
+(assert_return (invoke "mul-add" (v128.const f64x2 1.25 1.25)
+                                 (v128.const f64x2 0.25 0.25)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 0.375 0.375))
+(assert_return (invoke "mul-div" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 2.25 2.25))
+(assert_return (invoke "mul-sub" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 0.25 0.25))
+(assert_return (invoke "sub-add" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.25 0.25)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 1.25 1.25))
+(assert_return (invoke "add-neg" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 -1.0 -1.0))
+(assert_return (invoke "add-sqrt" (v128.const f64x2 2.25 2.25)
+                                  (v128.const f64x2 0.25 0.25))
+                                  (v128.const f64x2 1.75 1.75))
+(assert_return (invoke "div-neg" (v128.const f64x2 1.5 1.5)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 -6 -6))
+(assert_return (invoke "div-sqrt" (v128.const f64x2 2.25 2.25)
+                                  (v128.const f64x2 0.25 0.25))
+                                  (v128.const f64x2 6 6))
+(assert_return (invoke "mul-neg" (v128.const f64x2 1.5 1.5)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 -0.375 -0.375))
+(assert_return (invoke "mul-sqrt" (v128.const f64x2 2.25 2.25)
+                                  (v128.const f64x2 0.25 0.25))
+                                  (v128.const f64x2 0.375 0.375))
+(assert_return (invoke "sub-neg" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 -1.25 -1.25))
+(assert_return (invoke "sub-sqrt" (v128.const f64x2 2.25 2.25)
+                                  (v128.const f64x2 0.25 0.25))
+                                  (v128.const f64x2 1.25 1.25))
\ No newline at end of file
diff --git a/tests/wast/spec/simd_f64x2_cmp.wast b/tests/wast/spec/simd_f64x2_cmp.wast
new file mode 100644
index 0000000000..cab815ea56
--- /dev/null
+++ b/tests/wast/spec/simd_f64x2_cmp.wast
@@ -0,0 +1,8337 @@
+;; Tests for f64x2 comparison operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f64x2.eq") (param v128 v128) (result v128) (f64x2.eq (local.get 0) (local.get 1)))
+  (func (export "f64x2.ne") (param v128 v128) (result v128) (f64x2.ne (local.get 0) (local.get 1)))
+  (func (export "f64x2.lt") (param v128 v128) (result v128) (f64x2.lt (local.get 0) (local.get 1)))
+  (func (export "f64x2.le") (param v128 v128) (result v128) (f64x2.le (local.get 0) (local.get 1)))
+  (func (export "f64x2.gt") (param v128 v128) (result v128) (f64x2.gt (local.get 0) (local.get 1)))
+  (func (export "f64x2.ge") (param v128 v128) (result v128) (f64x2.ge (local.get 0) (local.get 1)))
+)
+
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+
+
+;; unknown operators
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.eq (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.ne (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.lt (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.le (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.gt (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.ge (local.get $x) (local.get $y)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f64x2.eq (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.ne (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.lt (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.le (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.gt (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.ge (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f64x2.eq-1st-arg-empty (result v128)
+      (f64x2.eq (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.eq-arg-empty (result v128)
+      (f64x2.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.ne-1st-arg-empty (result v128)
+      (f64x2.ne (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.ne-arg-empty (result v128)
+      (f64x2.ne)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.lt-1st-arg-empty (result v128)
+      (f64x2.lt (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.lt-arg-empty (result v128)
+      (f64x2.lt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.le-1st-arg-empty (result v128)
+      (f64x2.le (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.le-arg-empty (result v128)
+      (f64x2.le)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.gt-1st-arg-empty (result v128)
+      (f64x2.gt (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.gt-arg-empty (result v128)
+      (f64x2.gt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.ge-1st-arg-empty (result v128)
+      (f64x2.ge (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.ge-arg-empty (result v128)
+      (f64x2.ge)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module (memory 1)
+  (func (export "f64x2.eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "f64x2.ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "f64x2.lt-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.lt
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "f64x2.le-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.le
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "f64x2.gt-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.gt
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "f64x2.ge-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.ge
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.eq")
+    (drop
+      (f64x2.eq
+        (f64x2.eq
+          (f64x2.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.eq
+          (f64x2.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.ne")
+    (drop
+      (f64x2.ne
+        (f64x2.ne
+          (f64x2.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.ne
+          (f64x2.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.lt")
+    (drop
+      (f64x2.lt
+        (f64x2.lt
+          (f64x2.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.lt
+          (f64x2.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.le")
+    (drop
+      (f64x2.le
+        (f64x2.le
+          (f64x2.le
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.le
+          (f64x2.le
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.gt")
+    (drop
+      (f64x2.gt
+        (f64x2.gt
+          (f64x2.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.gt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.gt
+          (f64x2.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.gt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.ge")
+    (drop
+      (f64x2.ge
+        (f64x2.ge
+          (f64x2.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.ge
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.ge
+          (f64x2.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.ge
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (f64x2.eq
+        (f64x2.ne
+          (f64x2.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.gt
+          (f64x2.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+(assert_return (invoke "f64x2.eq-in-block"))
+(assert_return (invoke "f64x2.ne-in-block"))
+(assert_return (invoke "f64x2.lt-in-block"))
+(assert_return (invoke "f64x2.le-in-block"))
+(assert_return (invoke "f64x2.gt-in-block"))
+(assert_return (invoke "f64x2.ge-in-block"))
+(assert_return (invoke "nested-f64x2.eq"))
+(assert_return (invoke "nested-f64x2.ne"))
+(assert_return (invoke "nested-f64x2.lt"))
+(assert_return (invoke "nested-f64x2.le"))
+(assert_return (invoke "nested-f64x2.gt"))
+(assert_return (invoke "nested-f64x2.ge"))
+(assert_return (invoke "as-param"))
diff --git a/tests/wast/spec/simd_f64x2_pmin_pmax.wast b/tests/wast/spec/simd_f64x2_pmin_pmax.wast
new file mode 100644
index 0000000000..e8167b0e54
--- /dev/null
+++ b/tests/wast/spec/simd_f64x2_pmin_pmax.wast
@@ -0,0 +1,11676 @@
+;; Tests for f64x2 [pmin, pmax] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f64x2.pmin") (param v128 v128) (result v128) (f64x2.pmin (local.get 0) (local.get 1)))
+  (func (export "f64x2.pmax") (param v128 v128) (result v128) (f64x2.pmax (local.get 0) (local.get 1)))
+)
+
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f64x2.pmin (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.pmax (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f64x2.pmin-1st-arg-empty (result v128)
+      (f64x2.pmin (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.pmin-arg-empty (result v128)
+      (f64x2.pmin)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.pmax-1st-arg-empty (result v128)
+      (f64x2.pmax (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.pmax-arg-empty (result v128)
+      (f64x2.pmax)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/tests/wast/spec/simd_f64x2_rounding.wast b/tests/wast/spec/simd_f64x2_rounding.wast
new file mode 100644
index 0000000000..f82c6d2941
--- /dev/null
+++ b/tests/wast/spec/simd_f64x2_rounding.wast
@@ -0,0 +1,424 @@
+;; Tests for f64x2 [ceil, floor, trunc, nearest] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f64x2.ceil") (param v128) (result v128) (f64x2.ceil (local.get 0)))
+  (func (export "f64x2.floor") (param v128) (result v128) (f64x2.floor (local.get 0)))
+  (func (export "f64x2.trunc") (param v128) (result v128) (f64x2.trunc (local.get 0)))
+  (func (export "f64x2.nearest") (param v128) (result v128) (f64x2.nearest (local.get 0)))
+)
+
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.c000000000000p+2 0x1.c000000000000p+2))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 123456790.0 123456790.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0p+0 0x0p+0))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                     (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                     (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1p-1 0x1p-1))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                     (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1p+0 0x1p+0))
+                                     (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                     (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                     (v128.const f64x2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                     (v128.const f64x2 -0x1.c000000000000p+2 -0x1.c000000000000p+2))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                     (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                     (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 inf inf))
+                                     (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -inf -inf))
+                                     (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789 0123456789))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789e019 0123456789e019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789. 0123456789.))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                     (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                     (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 nan nan))
+                                     (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -nan -nan))
+                                     (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                     (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                     (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0p+0 0x0p+0))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                     (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                     (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1p-1 0x1p-1))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                     (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1p+0 0x1p+0))
+                                     (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                     (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                     (v128.const f64x2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                     (v128.const f64x2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                     (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                     (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 inf inf))
+                                     (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -inf -inf))
+                                     (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789 0123456789))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789e019 0123456789e019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789. 0123456789.))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                     (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                     (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 nan nan))
+                                     (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -nan -nan))
+                                     (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                     (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                     (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0p+0 0x0p+0))
+                                       (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                       (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                       (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                       (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1p-1 0x1p-1))
+                                       (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                       (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1p+0 0x1p+0))
+                                       (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                       (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                       (v128.const f64x2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                       (v128.const f64x2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                       (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                       (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                       (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                       (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 inf inf))
+                                       (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -inf -inf))
+                                       (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789 0123456789))
+                                       (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789e019 0123456789e019))
+                                       (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                       (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                       (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789. 0123456789.))
+                                       (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                       (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                       (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                       (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                       (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                       (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                       (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                       (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                       (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                       (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                       (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                       (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                       (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                       (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 nan nan))
+                                       (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -nan -nan))
+                                       (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                       (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                       (v128.const f64x2 nan:arithmetic nan:arithmetic))
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f64x2.ceil (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.floor (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.trunc (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.nearest (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f64x2.ceil-arg-empty (result v128)
+      (f64x2.ceil)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.floor-arg-empty (result v128)
+      (f64x2.floor)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.trunc-arg-empty (result v128)
+      (f64x2.trunc)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.nearest-arg-empty (result v128)
+      (f64x2.nearest)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/tests/wast/spec/simd_i16x8_arith.wast b/tests/wast/spec/simd_i16x8_arith.wast
new file mode 100644
index 0000000000..3dc4d5ed73
--- /dev/null
+++ b/tests/wast/spec/simd_i16x8_arith.wast
@@ -0,0 +1,634 @@
+;; Tests for i16x8 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i16x8.add") (param v128 v128) (result v128) (i16x8.add (local.get 0) (local.get 1)))
+  (func (export "i16x8.sub") (param v128 v128) (result v128) (i16x8.sub (local.get 0) (local.get 1)))
+  (func (export "i16x8.mul") (param v128 v128) (result v128) (i16x8.mul (local.get 0) (local.get 1)))
+  (func (export "i16x8.neg") (param v128) (result v128) (i16x8.neg (local.get 0)))
+)
+
+
+;; i16x8.add
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i8x16 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i32x4 0x80008000 0x80008000 0x80008000 0x80008000))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i16x8 0x8000 0 0x8000 0 0x8000 0 0x8000 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i16x8 0x8000 0xbf80 0x8000 0xbf80 0x8000 0xbf80 0x8000 0xbf80))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i16x8 0x8000 0x3f80 0x8000 0x3f80 0x8000 0x3f80 0x8000 0x3f80))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i16x8 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i16x8 0x01 0xff81 0x01 0xff81 0x01 0xff81 0x01 0xff81))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i16x8 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                   (v128.const i16x8 0 3 6 9 12 15 18 21))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                   (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                   (v128.const i16x8 03_598 03_598 03_598 03_598 03_598 03_598 03_598 03_598))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                   (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678))
+                                   (v128.const i16x8 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac))
+
+;; i16x8.sub
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32764 32764 32764 32764 32764 32764 32764 32764))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32765 -32765 -32765 -32765 -32765 -32765 -32765 -32765))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i8x16 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i16x8 0x02 0x02 0x02 0x02 0x02 0x02 0x02 0x02))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i32x4 0x80008000 0x80008000 0x80008000 0x80008000))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i16x8 0x02 0x02 0x02 0x02 0x02 0x02 0x02 0x02))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i16x8 0x8000 0 0x8000 0 0x8000 0 0x8000 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i16x8 0x8000 0x4080 0x8000 0x4080 0x8000 0x4080 0x8000 0x4080))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i16x8 0x8000 0xc080 0x8000 0xc080 0x8000 0xc080 0x8000 0xc080))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i16x8 0x01 0x8081 0x01 0x8081 0x01 0x8081 0x01 0x8081))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i16x8 0x01 0x81 0x01 0x81 0x01 0x81 0x01 0x81))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i16x8 0x01 0x8041 0x01 0x8041 0x01 0x8041 0x01 0x8041))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                   (v128.const i16x8 0 0x02 0x04 0x06 0x08 0x0a 0x0c 0x0e))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                   (v128.const i16x8 0 -1 -2 -3 -4 -5 -6 -7))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789)
+                                   (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+                                   (v128.const i16x8 044_444 044_444 044_444 044_444 044_444 044_444 044_444 044_444))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678)
+                                   (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+                                   (v128.const i16x8 0x0_4444 0x0_4444 0x0_4444 0x0_4444 0x0_4444 0x0_4444 0x0_4444 0x0_4444))
+
+;; i16x8.mul
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x1000 0x1000 0x1000 0x1000 0x1000 0x1000 0x1000 0x1000)
+                                   (v128.const i8x16 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i32x4 0x00020002 0x00020002 0x00020002 0x00020002))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i16x8 0 0x7f80 0 0x7f80 0 0x7f80 0 0x7f80))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i16x8 0 0xff80 0 0xff80 0 0xff80 0 0xff80))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i16x8 0 0x7fc0 0 0x7fc0 0 0x7fc0 0 0x7fc0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                   (v128.const i16x8 0 0xffff 0xfffc 0xfff7 0xfff0 0xffe7 0xffdc 0xffcf))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                   (v128.const i16x8 0 0x02 0x08 0x12 0x20 0x32 0x48 0x62))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                   (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                   (v128.const i16x8 021_613 021_613 021_613 021_613 021_613 021_613 021_613 021_613))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                   (v128.const i16x8 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef))
+                                   (v128.const i16x8 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c))
+
+;; i16x8.neg
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+                                   (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -0x7fff -0x7fff -0x7fff -0x7fff -0x7fff -0x7fff -0x7fff -0x7fff))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.neg (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.add (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.sub (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.mul (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.neg-arg-empty (result v128)
+      (i16x8.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.add-1st-arg-empty (result v128)
+      (i16x8.add (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.add-arg-empty (result v128)
+      (i16x8.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub-1st-arg-empty (result v128)
+      (i16x8.sub (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub-arg-empty (result v128)
+      (i16x8.sub)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.mul-1st-arg-empty (result v128)
+      (i16x8.mul (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.mul-arg-empty (result v128)
+      (i16x8.mul)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (i16x8.add (i16x8.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-add") (param v128 v128 v128) (result v128)
+    (i16x8.mul (i16x8.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-sub") (param v128 v128 v128) (result v128)
+    (i16x8.mul (i16x8.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (i16x8.sub (i16x8.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (i16x8.add (i16x8.neg (local.get 0)) (local.get 1)))
+  (func (export "mul-neg") (param v128 v128) (result v128)
+    (i16x8.mul (i16x8.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (i16x8.sub (i16x8.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 2 4 6 8 10 12 14)
+                                 (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "mul-add" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                 (v128.const i16x8 0 4 8 12 16 20 24 28))
+(assert_return (invoke "mul-sub" (v128.const i16x8 0 2 4 6 8 10 12 14)
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                 (v128.const i16x8 0 1 4 9 16 25 36 49))
+(assert_return (invoke "sub-add" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 2 4 6 8 10 12 14)
+                                 (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "add-neg" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                 (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "mul-neg" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                 (v128.const i16x8 0 -2 -4 -6 -8 -10 -12 -14))
+(assert_return (invoke "sub-neg" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                 (v128.const i16x8 0 -2 -4 -6 -8 -10 -12 -14))
\ No newline at end of file
diff --git a/tests/wast/spec/simd_i16x8_arith2.wast b/tests/wast/spec/simd_i16x8_arith2.wast
new file mode 100644
index 0000000000..454f598df4
--- /dev/null
+++ b/tests/wast/spec/simd_i16x8_arith2.wast
@@ -0,0 +1,610 @@
+;; Tests for i16x8 [min_s, min_u, max_s, max_u, avgr_u, abs] operations.
+
+(module
+  (func (export "i16x8.min_s") (param v128 v128) (result v128) (i16x8.min_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.min_u") (param v128 v128) (result v128) (i16x8.min_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.max_s") (param v128 v128) (result v128) (i16x8.max_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.max_u") (param v128 v128) (result v128) (i16x8.max_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.avgr_u") (param v128 v128) (result v128) (i16x8.avgr_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.abs") (param v128) (result v128) (i16x8.abs (local.get 0)))
+  (func (export "i16x8.min_s_with_const_0") (result v128) (i16x8.min_s (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)))
+  (func (export "i16x8.min_s_with_const_1") (result v128) (i16x8.min_s (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0)))
+  (func (export "i16x8.min_u_with_const_2") (result v128) (i16x8.min_u (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)))
+  (func (export "i16x8.min_u_with_const_3") (result v128) (i16x8.min_u (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0)))
+  (func (export "i16x8.max_s_with_const_4") (result v128) (i16x8.max_s (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)))
+  (func (export "i16x8.max_s_with_const_5") (result v128) (i16x8.max_s (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0)))
+  (func (export "i16x8.max_u_with_const_6") (result v128) (i16x8.max_u (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)))
+  (func (export "i16x8.max_u_with_const_7") (result v128) (i16x8.max_u (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0)))
+  (func (export "i16x8.avgr_u_with_const_8") (result v128) (i16x8.avgr_u (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)))
+  (func (export "i16x8.avgr_u_with_const_9") (result v128) (i16x8.avgr_u (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0)))
+  (func (export "i16x8.abs_with_const_10") (result v128) (i16x8.abs (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.min_s_with_const_11") (param v128) (result v128) (i16x8.min_s (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.min_s_with_const_12") (param v128) (result v128) (i16x8.min_s (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3)))
+  (func (export "i16x8.min_u_with_const_13") (param v128) (result v128) (i16x8.min_u (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.min_u_with_const_14") (param v128) (result v128) (i16x8.min_u (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3)))
+  (func (export "i16x8.max_s_with_const_15") (param v128) (result v128) (i16x8.max_s (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.max_s_with_const_16") (param v128) (result v128) (i16x8.max_s (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3)))
+  (func (export "i16x8.max_u_with_const_17") (param v128) (result v128) (i16x8.max_u (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.max_u_with_const_18") (param v128) (result v128) (i16x8.max_u (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3)))
+  (func (export "i16x8.avgr_u_with_const_19") (param v128) (result v128) (i16x8.avgr_u (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.avgr_u_with_const_20") (param v128) (result v128) (i16x8.avgr_u (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3)))
+)
+
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)
+                                     (v128.const i16x8 0 0 -1 -1 0 0 -1 -1))
+                                     (v128.const i16x8 0 0 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+                                     (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 123 123 123 123 123 123 123 123)
+                                     (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)
+                                     (v128.const i16x8 0 0 -1 -1 0 0 -1 -1))
+                                     (v128.const i16x8 0 0 0 0 0 0 -1 -1))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 123 123 123 123 123 123 123 123)
+                                     (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)
+                                     (v128.const i16x8 0 0 -1 -1 0 0 -1 -1))
+                                     (v128.const i16x8 0 0 0 0 0 0 -1 -1))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 123 123 123 123 123 123 123 123)
+                                     (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)
+                                     (v128.const i16x8 0 0 -1 -1 0 0 -1 -1))
+                                     (v128.const i16x8 0 0 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+                                     (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 123 123 123 123 123 123 123 123)
+                                     (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                      (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                      (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)
+                                      (v128.const i16x8 0 0 -1 -1 0 0 -1 -1))
+                                      (v128.const i16x8 0 0 32768 32768 32768 32768 65535 65535))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                      (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                      (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                      (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                      (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                      (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                      (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                      (v128.const i16x8 128 128 128 128 128 128 128 128))
+                                      (v128.const i16x8 32832 32832 32832 32832 32832 32832 32832 32832))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                      (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                      (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                      (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                      (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 123 123 123 123 123 123 123 123)
+                                      (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                      (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                      (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                      (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i16x8 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+                                   (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000))
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                   (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3))
+                                   (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                   (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                   (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0))
+                                   (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+
+;; Const vs const
+(assert_return (invoke "i16x8.min_s_with_const_0") (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_s_with_const_1") (v128.const i16x8 0 0 1 1 1 1 0 0))
+(assert_return (invoke "i16x8.min_u_with_const_2") (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_u_with_const_3") (v128.const i16x8 0 0 1 1 1 1 0 0))
+(assert_return (invoke "i16x8.max_s_with_const_4") (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_s_with_const_5") (v128.const i16x8 3 3 2 2 2 2 3 3))
+(assert_return (invoke "i16x8.max_u_with_const_6") (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_u_with_const_7") (v128.const i16x8 3 3 2 2 2 2 3 3))
+(assert_return (invoke "i16x8.avgr_u_with_const_8") (v128.const i16x8 49152 49152 24576 24576 24576 24576 49152 49152))
+(assert_return (invoke "i16x8.avgr_u_with_const_9") (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.abs_with_const_10") (v128.const i16x8 32768 32768 32767 32767 16384 16384 1 1))
+
+;; Param vs const
+(assert_return (invoke "i16x8.min_s_with_const_11" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                                   (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_s_with_const_12" (v128.const i16x8 3 3 2 2 1 1 0 0))
+                                                   (v128.const i16x8 0 0 1 1 1 1 0 0))
+(assert_return (invoke "i16x8.min_u_with_const_13" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                                   (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_u_with_const_14" (v128.const i16x8 3 3 2 2 1 1 0 0))
+                                                   (v128.const i16x8 0 0 1 1 1 1 0 0))
+(assert_return (invoke "i16x8.max_s_with_const_15" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                                   (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_s_with_const_16" (v128.const i16x8 3 3 2 2 1 1 0 0))
+                                                   (v128.const i16x8 3 3 2 2 2 2 3 3))
+(assert_return (invoke "i16x8.max_u_with_const_17" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                                   (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_u_with_const_18" (v128.const i16x8 3 3 2 2 1 1 0 0))
+                                                   (v128.const i16x8 3 3 2 2 2 2 3 3))
+(assert_return (invoke "i16x8.avgr_u_with_const_19" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                                    (v128.const i16x8 49152 49152 24576 24576 24576 24576 49152 49152))
+(assert_return (invoke "i16x8.avgr_u_with_const_20" (v128.const i16x8 3 3 2 2 1 1 0 0))
+                                                    (v128.const i16x8 2 2 2 2 2 2 2 2))
+
+;; Test different lanes go through different if-then clauses
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)
+                                     (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                     (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 1 1 2 2 128 128)
+                                     (v128.const i16x8 0 0 2 2 1 1 128 128))
+                                     (v128.const i16x8 0 0 1 1 1 1 128 128))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)
+                                     (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                     (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 1 1 2 2 128 128)
+                                     (v128.const i16x8 0 0 2 2 1 1 128 128))
+                                     (v128.const i16x8 0 0 1 1 1 1 128 128))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)
+                                     (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                     (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 1 1 2 2 128 128)
+                                     (v128.const i16x8 0 0 2 2 1 1 128 128))
+                                     (v128.const i16x8 0 0 2 2 2 2 128 128))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)
+                                     (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                     (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 1 1 2 2 128 128)
+                                     (v128.const i16x8 0 0 2 2 1 1 128 128))
+                                     (v128.const i16x8 0 0 2 2 2 2 128 128))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)
+                                      (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                      (v128.const i16x8 49152 49152 24576 24576 24576 24576 49152 49152))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 1 1 2 2 128 128)
+                                      (v128.const i16x8 0 0 2 2 1 1 128 128))
+                                      (v128.const i16x8 0 0 2 2 2 2 128 128))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535))
+                                   (v128.const i16x8 32768 32768 32767 32767 16384 16384 1 1))
+
+;; Test opposite signs of zero
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)
+                                     (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                     (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)
+                                     (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                     (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)
+                                     (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                     (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)
+                                     (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                     (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)
+                                      (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)
+                                      (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+                                   (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                   (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+                                   (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                   (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+
+;; Unknown operators
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.avgr (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.avgr_s (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 1 1 1 1 1 1 1 1)))") "unknown operator")
+
+;; Type check
+(assert_invalid (module (func (result v128) (i16x8.min_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.min_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.max_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.max_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.avgr_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.abs (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.min_s-1st-arg-empty (result v128)
+      (i16x8.min_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.min_s-arg-empty (result v128)
+      (i16x8.min_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.min_u-1st-arg-empty (result v128)
+      (i16x8.min_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.min_u-arg-empty (result v128)
+      (i16x8.min_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.max_s-1st-arg-empty (result v128)
+      (i16x8.max_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.max_s-arg-empty (result v128)
+      (i16x8.max_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.max_u-1st-arg-empty (result v128)
+      (i16x8.max_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.max_u-arg-empty (result v128)
+      (i16x8.max_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.avgr_u-1st-arg-empty (result v128)
+      (i16x8.avgr_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.avgr_u-arg-empty (result v128)
+      (i16x8.avgr_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.abs-arg-empty (result v128)
+      (i16x8.abs)
+    )
+  )
+  "type mismatch"
+)
+
+;; Combination
+(module
+  (func (export "i16x8.min_s-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_s-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_s-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_s-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_s-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_s-i16x8.abs") (param v128 v128) (result v128) (i16x8.min_s (i16x8.abs (local.get 0))(local.get 1)))
+  (func (export "i16x8.abs-i16x8.min_s") (param v128 v128) (result v128) (i16x8.abs (i16x8.min_s (local.get 0) (local.get 1))))
+  (func (export "i16x8.min_u-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_u-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_u-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_u-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_u-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_u-i16x8.abs") (param v128 v128) (result v128) (i16x8.min_u (i16x8.abs (local.get 0))(local.get 1)))
+  (func (export "i16x8.abs-i16x8.min_u") (param v128 v128) (result v128) (i16x8.abs (i16x8.min_u (local.get 0) (local.get 1))))
+  (func (export "i16x8.max_s-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_s-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_s-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_s-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_s-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_s-i16x8.abs") (param v128 v128) (result v128) (i16x8.max_s (i16x8.abs (local.get 0))(local.get 1)))
+  (func (export "i16x8.abs-i16x8.max_s") (param v128 v128) (result v128) (i16x8.abs (i16x8.max_s (local.get 0) (local.get 1))))
+  (func (export "i16x8.max_u-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_u-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_u-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_u-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_u-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_u-i16x8.abs") (param v128 v128) (result v128) (i16x8.max_u (i16x8.abs (local.get 0))(local.get 1)))
+  (func (export "i16x8.abs-i16x8.max_u") (param v128 v128) (result v128) (i16x8.abs (i16x8.max_u (local.get 0) (local.get 1))))
+  (func (export "i16x8.avgr_u-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.avgr_u-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.avgr_u-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.avgr_u-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.avgr_u-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.avgr_u-i16x8.abs") (param v128 v128) (result v128) (i16x8.avgr_u (i16x8.abs (local.get 0))(local.get 1)))
+  (func (export "i16x8.abs-i16x8.avgr_u") (param v128 v128) (result v128) (i16x8.abs (i16x8.avgr_u (local.get 0) (local.get 1))))
+  (func (export "i16x8.abs-i16x8.abs") (param v128) (result v128) (i16x8.abs (i16x8.abs (local.get 0))))
+)
+
+(assert_return (invoke "i16x8.min_s-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_s-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_s-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_s-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_s-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_s-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.abs-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                               (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_u-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_u-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.abs-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                               (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_s-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_s-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_s-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_s-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_s-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_s-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                               (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                               (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_u-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_u-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_u-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_u-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_u-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_u-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                               (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                               (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.avgr_u-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                   (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                   (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.avgr_u-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.avgr_u-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.avgr_u-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.avgr_u-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.avgr_u-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.abs-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
diff --git a/tests/wast/spec/simd_i16x8_cmp.wast b/tests/wast/spec/simd_i16x8_cmp.wast
new file mode 100644
index 0000000000..24068ce321
--- /dev/null
+++ b/tests/wast/spec/simd_i16x8_cmp.wast
@@ -0,0 +1,1901 @@
+
+;; Test all the i16x8 comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) (i16x8.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) (i16x8.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x v128) (param $y v128) (result v128) (i16x8.lt_s (local.get $x) (local.get $y)))
+  (func (export "lt_u") (param $x v128) (param $y v128) (result v128) (i16x8.lt_u (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x v128) (param $y v128) (result v128) (i16x8.le_s (local.get $x) (local.get $y)))
+  (func (export "le_u") (param $x v128) (param $y v128) (result v128) (i16x8.le_u (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x v128) (param $y v128) (result v128) (i16x8.gt_s (local.get $x) (local.get $y)))
+  (func (export "gt_u") (param $x v128) (param $y v128) (result v128) (i16x8.gt_u (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x v128) (param $y v128) (result v128) (i16x8.ge_s (local.get $x) (local.get $y)))
+  (func (export "ge_u") (param $x v128) (param $y v128) (result v128) (i16x8.ge_u (local.get $x) (local.get $y)))
+)
+
+
+;; eq
+
+;; i16x8.eq  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                            (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                            (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                            (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                            (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                            (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                            (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "eq" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                            (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                            (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                            (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "eq" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "eq" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                            (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                            (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                            (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                            (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                            (v128.const i16x8 -1 -1 0 0 0 0 -1 -1))
+
+;; i16x8.eq  (i16x8) (i8x16)
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                            (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                            (v128.const i16x8 0 0 -1 -1 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                            (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; i16x8.eq  (i16x8) (i32x4)
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                            (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 0 0 1 1 32768 32768)
+                            (v128.const i32x4 65535 0 1 32768))
+                            (v128.const i16x8 -1 0 -1 -1 -1 0 -1 0))
+(assert_return (invoke "eq" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                            (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                            (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                            (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; ne
+
+;; i16x8.ne  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                            (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                            (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                            (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                            (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                            (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                            (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "ne" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 255 255 255 255 255 255 255 255)
+                            (v128.const i16x8 255 255 255 255 255 255 255 255))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 255 255 255 255 0 0 0 0)
+                            (v128.const i16x8 255 255 255 255 0 0 0 0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0 0 0 0 255 255 255 255)
+                            (v128.const i16x8 0 0 0 0 255 255 255 255))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 255 32767 -0 0 1 2 65534 65535)
+                            (v128.const i16x8 255 32767 0 0 1 2 -2 -1))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "ne" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "ne" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                            (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                            (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 0x8081 0x8283 0xFDFE 0xFF00 0x0001 0x027F 0x80FD 0xFEFF)
+                            (v128.const i16x8 65279 33021 639 1 65280 65022 33411 32897))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 128 129 130 131 -0 255 32766 32767)
+                            (v128.const i16x8 32767 32766 255 -0 131 130 129 28))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.ne  (i16x8) (i8x16)
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                            (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                            (v128.const i16x8 -1 -1 0 0 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                            (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.ne  (i16x8) (i32x4)
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                            (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                            (v128.const i32x4 -128 0 1 255))
+                            (v128.const i16x8 0 -1 0 0 0 -1 0 -1))
+(assert_return (invoke "ne" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                            (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                            (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                            (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; lt_s
+
+;; i16x8.lt_s  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 255 255 255 255 0 0 0 0)
+                              (v128.const i16x8 255 255 255 255 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0 0 0 0 255 255 255 255)
+                              (v128.const i16x8 0 0 0 0 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 255 32767 -0 0 1 2 65534 65535)
+                              (v128.const i16x8 255 32767 0 0 1 2 -2 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 0 0 -1 0 0 0 0 -1))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x8081 0x8283 0xFDFE 0xFF00 0x0001 0x027F 0x80FD 0xFEFF)
+                              (v128.const i16x8 65279 33021 639 1 65280 65022 33411 32897))
+                              (v128.const i16x8 -1 0 -1 -1 0 0 -1 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 128 129 130 131 -0 255 32766 32767)
+                              (v128.const i16x8 32767 32766 255 -0 131 130 129 28))
+                              (v128.const i16x8 -1 -1 -1 0 -1 0 0 0))
+
+;; i16x8.lt_s  (i16x8) (i8x16)
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 -1 -1 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; i16x8.lt_s  (i16x8) (i32x4)
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 0 -1 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; lt_u
+
+;; i16x8.lt_u  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 255 255 255 255 0 0 0 0)
+                              (v128.const i16x8 255 255 255 255 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0 0 0 0 255 255 255 255)
+                              (v128.const i16x8 0 0 0 0 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 255 32767 -0 0 1 2 65534 65535)
+                              (v128.const i16x8 255 32767 0 0 1 2 -2 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 -1 -1 -1 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x8081 0x8283 0xFDFE 0xFF00 0x0001 0x027F 0x80FD 0xFEFF)
+                              (v128.const i16x8 65279 33021 639 1 65280 65022 33411 32897))
+                              (v128.const i16x8 -1 0 0 0 -1 -1 -1 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 128 129 130 131 -0 255 32766 32767)
+                              (v128.const i16x8 32767 32766 255 -0 131 130 129 28))
+                              (v128.const i16x8 -1 -1 -1 0 -1 0 0 0))
+
+;; i16x8.lt_u  (i16x8) (i8x16)
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.lt_u  (i16x8) (i32x4)
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 0 -1 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; le_s
+
+;; i16x8.le_s  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                              (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                              (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                              (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 0 0 -1 0 0 0 0 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "le_s" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 -1 -1))
+
+;; i16x8.le_s  (i16x8) (i8x16)
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 0 0 -1 -1 -1 -1 0 0))
+(assert_return (invoke "le_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; i16x8.le_s  (i16x8) (i32x4)
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 0 -1 0))
+(assert_return (invoke "le_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "le_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; le_u
+
+;; i16x8.le_u  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                              (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                              (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                              (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 -1 -1 -1 0 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 -1 -1 -1 0 -1 0 -1 -1))
+
+;; i16x8.le_u  (i16x8) (i8x16)
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 0 0 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.le_u  (i16x8) (i32x4)
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 0 -1 0))
+(assert_return (invoke "le_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb)
+                              (v128.const i16x8 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; gt_s
+
+;; i16x8.gt_s  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                              (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                              (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                              (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 -1 -1 0 -1 -1 -1 -1 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 0 0 0 0 -1 -1 0 0))
+
+;; i16x8.gt_s  (i16x8) (i8x16)
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 -1 -1 0 0 0 0 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.gt_s  (i16x8) (i32x4)
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 0 0 1 1 32768 32768)
+                              (v128.const i32x4 65535 0 1 32768))
+                              (v128.const i16x8 0 0 0 0 0 -1 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; gt_u
+
+;; i16x8.gt_u  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "eq" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                            (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                            (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                            (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 0 0 0 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 0 0 0 -1 0 -1 0 0))
+
+;; i16x8.gt_u  (i16x8) (i8x16)
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 -1 -1 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; i16x8.gt_u  (i16x8) (i32x4)
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 0 0 0 0 0 -1 0 -1))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; ge_s
+
+;; i16x8.ge_s  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                              (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                              (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                              (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 -1 -1 0 -1 -1 -1 -1 0))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 -1 -1 0 0 -1 -1 -1 -1))
+
+;; i16x8.ge_s  (i16x8) (i8x16)
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA)
+                              (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; i16x8.ge_s  (i16x8) (i32x4)
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 0 0 1 1 32768 32768)
+                              (v128.const i32x4 65535 0 1 32768))
+                              (v128.const i16x8 -1 0 -1 -1 -1 -1 -1 0))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; ge_u
+
+;; i16x8.ge_u  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                              (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                              (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                              (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 0 0 0 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 -1 -1 0 -1 0 -1 -1 -1))
+
+;; i16x8.ge_u  (i16x8) (i8x16)
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "ge_u" (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA)
+                              (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.ge_u  (i16x8) (i32x4)
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 0 0 1 1 32768 32768)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ge_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (i16x8.eq (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.ge_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.ge_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.gt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.gt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.le_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.le_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.lt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+
+
+;; combination
+
+(module (memory 1)
+  (func (export "eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "lt_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.lt_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "le_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.le_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "gt_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.gt_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ge_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.ge_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-eq")
+    (drop
+      (i16x8.eq
+        (i16x8.eq
+          (i16x8.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.eq
+          (i16x8.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ne")
+    (drop
+      (i16x8.ne
+        (i16x8.ne
+          (i16x8.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.ne
+          (i16x8.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-lt_s")
+    (drop
+      (i16x8.lt_s
+        (i16x8.lt_s
+          (i16x8.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.lt_s
+          (i16x8.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-le_u")
+    (drop
+      (i16x8.le_u
+        (i16x8.le_u
+          (i16x8.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.le_u
+          (i16x8.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-gt_u")
+    (drop
+      (i16x8.gt_u
+        (i16x8.gt_u
+          (i16x8.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.gt_u
+          (i16x8.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ge_s")
+    (drop
+      (i16x8.ge_s
+        (i16x8.ge_s
+          (i16x8.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.ge_s
+          (i16x8.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (i16x8.ge_u
+        (i16x8.eq
+          (i16x8.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.ne
+          (i16x8.gt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.lt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+(assert_return (invoke "eq-in-block"))
+(assert_return (invoke "ne-in-block"))
+(assert_return (invoke "lt_s-in-block"))
+(assert_return (invoke "le_u-in-block"))
+(assert_return (invoke "gt_u-in-block"))
+(assert_return (invoke "ge_s-in-block"))
+(assert_return (invoke "nested-eq"))
+(assert_return (invoke "nested-ne"))
+(assert_return (invoke "nested-lt_s"))
+(assert_return (invoke "nested-le_u"))
+(assert_return (invoke "nested-gt_u"))
+(assert_return (invoke "nested-ge_s"))
+(assert_return (invoke "as-param"))
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.eq-1st-arg-empty (result v128)
+      (i16x8.eq (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.eq-arg-empty (result v128)
+      (i16x8.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ne-1st-arg-empty (result v128)
+      (i16x8.ne (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ne-arg-empty (result v128)
+      (i16x8.ne)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.lt_s-1st-arg-empty (result v128)
+      (i16x8.lt_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.lt_s-arg-empty (result v128)
+      (i16x8.lt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.lt_u-1st-arg-empty (result v128)
+      (i16x8.lt_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.lt_u-arg-empty (result v128)
+      (i16x8.lt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.le_s-1st-arg-empty (result v128)
+      (i16x8.le_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.le_s-arg-empty (result v128)
+      (i16x8.le_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.le_u-1st-arg-empty (result v128)
+      (i16x8.le_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.le_u-arg-empty (result v128)
+      (i16x8.le_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.gt_s-1st-arg-empty (result v128)
+      (i16x8.gt_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.gt_s-arg-empty (result v128)
+      (i16x8.gt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.gt_u-1st-arg-empty (result v128)
+      (i16x8.gt_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.gt_u-arg-empty (result v128)
+      (i16x8.gt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ge_s-1st-arg-empty (result v128)
+      (i16x8.ge_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ge_s-arg-empty (result v128)
+      (i16x8.ge_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ge_u-1st-arg-empty (result v128)
+      (i16x8.ge_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ge_u-arg-empty (result v128)
+      (i16x8.ge_u)
+    )
+  )
+  "type mismatch"
+)
\ No newline at end of file
diff --git a/tests/wast/spec/simd_i16x8_extadd_pairwise_i8x16.wast b/tests/wast/spec/simd_i16x8_extadd_pairwise_i8x16.wast
new file mode 100644
index 0000000000..c2267de9c3
--- /dev/null
+++ b/tests/wast/spec/simd_i16x8_extadd_pairwise_i8x16.wast
@@ -0,0 +1,68 @@
+;; Tests for i16x8 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i16x8.extadd_pairwise_i8x16_s") (param v128) (result v128) (i16x8.extadd_pairwise_i8x16_s (local.get 0)))
+  (func (export "i16x8.extadd_pairwise_i8x16_u") (param v128) (result v128) (i16x8.extadd_pairwise_i8x16_u (local.get 0)))
+)
+
+
+;; i16x8.extadd_pairwise_i8x16_s
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                       (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                       (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                       (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+                                                       (v128.const i16x8 252 252 252 252 252 252 252 252))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                       (v128.const i16x8 -254 -254 -254 -254 -254 -254 -254 -254))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                       (v128.const i16x8 -256 -256 -256 -256 -256 -256 -256 -256))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                       (v128.const i16x8 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                       (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+
+;; i16x8.extadd_pairwise_i8x16_u
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                       (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                       (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                       (v128.const i16x8 510 510 510 510 510 510 510 510))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+                                                       (v128.const i16x8 252 252 252 252 252 252 252 252))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                       (v128.const i16x8 258 258 258 258 258 258 258 258))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                       (v128.const i16x8 256 256 256 256 256 256 256 256))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                       (v128.const i16x8 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                       (v128.const i16x8 510 510 510 510 510 510 510 510))
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.extadd_pairwise_i8x16_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extadd_pairwise_i8x16_u (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.extadd_pairwise_i8x16_s-arg-empty (result v128)
+      (i16x8.extadd_pairwise_i8x16_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extadd_pairwise_i8x16_u-arg-empty (result v128)
+      (i16x8.extadd_pairwise_i8x16_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/tests/wast/spec/simd_i16x8_extmul_i8x16.wast b/tests/wast/spec/simd_i16x8_extmul_i8x16.wast
new file mode 100644
index 0000000000..cc8cf8f402
--- /dev/null
+++ b/tests/wast/spec/simd_i16x8_extmul_i8x16.wast
@@ -0,0 +1,404 @@
+;; Tests for i16x8 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i16x8.extmul_low_i8x16_s") (param v128 v128) (result v128) (i16x8.extmul_low_i8x16_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.extmul_high_i8x16_s") (param v128 v128) (result v128) (i16x8.extmul_high_i8x16_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.extmul_low_i8x16_u") (param v128 v128) (result v128) (i16x8.extmul_low_i8x16_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.extmul_high_i8x16_u") (param v128 v128) (result v128) (i16x8.extmul_high_i8x16_u (local.get 0) (local.get 1)))
+)
+
+
+;; i16x8.extmul_low_i8x16_s
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                                  (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                  (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                                  (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                  (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 4160 4160 4160 4160 4160 4160 4160 4160))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                                  (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 16129 16129 16129 16129 16129 16129 16129 16129))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                  (v128.const i16x8 16256 16256 16256 16256 16256 16256 16256 16256))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+
+;; i16x8.extmul_high_i8x16_s
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                   (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                   (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 4160 4160 4160 4160 4160 4160 4160 4160))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 16129 16129 16129 16129 16129 16129 16129 16129))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                   (v128.const i16x8 16256 16256 16256 16256 16256 16256 16256 16256))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+
+;; i16x8.extmul_low_i8x16_u
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                                  (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                  (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                                  (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                  (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 -28480 -28480 -28480 -28480 -28480 -28480 -28480 -28480))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 -28672 -28672 -28672 -28672 -28672 -28672 -28672 -28672))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 -28864 -28864 -28864 -28864 -28864 -28864 -28864 -28864))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -32386 -32386 -32386 -32386 -32386 -32386 -32386 -32386))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -32641 -32641 -32641 -32641 -32641 -32641 -32641 -32641))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 32640 32640 32640 32640 32640 32640 32640 32640))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                                  (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 16129 16129 16129 16129 16129 16129 16129 16129))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                  (v128.const i16x8 16512 16512 16512 16512 16512 16512 16512 16512))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 32385 32385 32385 32385 32385 32385 32385 32385))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 32640 32640 32640 32640 32640 32640 32640 32640))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                  (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+
+;; i16x8.extmul_high_i8x16_u
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                   (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                   (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 -28480 -28480 -28480 -28480 -28480 -28480 -28480 -28480))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 -28672 -28672 -28672 -28672 -28672 -28672 -28672 -28672))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 -28864 -28864 -28864 -28864 -28864 -28864 -28864 -28864))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -32386 -32386 -32386 -32386 -32386 -32386 -32386 -32386))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -32641 -32641 -32641 -32641 -32641 -32641 -32641 -32641))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 32640 32640 32640 32640 32640 32640 32640 32640))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 16129 16129 16129 16129 16129 16129 16129 16129))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                   (v128.const i16x8 16512 16512 16512 16512 16512 16512 16512 16512))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 32385 32385 32385 32385 32385 32385 32385 32385))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 32640 32640 32640 32640 32640 32640 32640 32640))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                   (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.extmul_low_i8x16_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extmul_high_i8x16_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extmul_low_i8x16_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extmul_high_i8x16_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.extmul_low_i8x16_s-1st-arg-empty (result v128)
+      (i16x8.extmul_low_i8x16_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_low_i8x16_s-arg-empty (result v128)
+      (i16x8.extmul_low_i8x16_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_high_i8x16_s-1st-arg-empty (result v128)
+      (i16x8.extmul_high_i8x16_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_high_i8x16_s-arg-empty (result v128)
+      (i16x8.extmul_high_i8x16_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_low_i8x16_u-1st-arg-empty (result v128)
+      (i16x8.extmul_low_i8x16_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_low_i8x16_u-arg-empty (result v128)
+      (i16x8.extmul_low_i8x16_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_high_i8x16_u-1st-arg-empty (result v128)
+      (i16x8.extmul_high_i8x16_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_high_i8x16_u-arg-empty (result v128)
+      (i16x8.extmul_high_i8x16_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/tests/wast/spec/simd_i16x8_q15mulr_sat_s.wast b/tests/wast/spec/simd_i16x8_q15mulr_sat_s.wast
new file mode 100644
index 0000000000..2cea8cc748
--- /dev/null
+++ b/tests/wast/spec/simd_i16x8_q15mulr_sat_s.wast
@@ -0,0 +1,110 @@
+;; Tests for i16x8 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i16x8.q15mulr_sat_s") (param v128 v128) (result v128) (i16x8.q15mulr_sat_s (local.get 0) (local.get 1)))
+)
+
+
+;; i16x8.q15mulr_sat_s
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                             (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                             (v128.const i16x8 8192 8192 8192 8192 8192 8192 8192 8192))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                             (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                             (v128.const i16x8 8192 8192 8192 8192 8192 8192 8192 8192))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                             (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                             (v128.const i16x8 8192 8192 8192 8192 8192 8192 8192 8192))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                             (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                             (v128.const i16x8 8192 8192 8192 8192 8192 8192 8192 8192))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                             (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                             (v128.const i16x8 8193 8193 8193 8193 8193 8193 8193 8193))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                             (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                             (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                             (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                             (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                             (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                             (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.q15mulr_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.q15mulr_sat_s-1st-arg-empty (result v128)
+      (i16x8.q15mulr_sat_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.q15mulr_sat_s-arg-empty (result v128)
+      (i16x8.q15mulr_sat_s)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/tests/wast/spec/simd_i16x8_sat_arith.wast b/tests/wast/spec/simd_i16x8_sat_arith.wast
new file mode 100644
index 0000000000..cea4ebbc7f
--- /dev/null
+++ b/tests/wast/spec/simd_i16x8_sat_arith.wast
@@ -0,0 +1,742 @@
+;; Tests for i16x8 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i16x8.add_sat_s") (param v128 v128) (result v128) (i16x8.add_sat_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.add_sat_u") (param v128 v128) (result v128) (i16x8.add_sat_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.sub_sat_s") (param v128 v128) (result v128) (i16x8.sub_sat_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.sub_sat_u") (param v128 v128) (result v128) (i16x8.sub_sat_u (local.get 0) (local.get 1)))
+)
+
+
+;; i16x8.add_sat_s
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i16x8 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i16x8 0x01 0xff81 0x01 0xff81 0x01 0xff81 0x01 0xff81))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i16x8 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i16x8 0x01 0xffc1 0x01 0xffc1 0x01 0xffc1 0x01 0xffc1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                         (v128.const i16x8 0 3 6 9 12 15 18 21))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 032_123 032_123 032_123 032_123 032_123 032_123 032_123 032_123))
+                                         (v128.const i16x8 032_767 032_767 032_767 032_767 032_767 032_767 032_767 032_767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                         (v128.const i16x8 03_598 03_598 03_598 03_598 03_598 03_598 03_598 03_598))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                         (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678))
+                                         (v128.const i16x8 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                         (v128.const i16x8 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef))
+                                         (v128.const i16x8 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000))
+
+;; i16x8.add_sat_u
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32769 32769 32769 32769 32769 32769 32769 32769))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                         (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i16x8 0x8000 0xffff 0x8000 0xffff 0x8000 0xffff 0x8000 0xffff))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i16x8 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i16x8 0x01 0xff81 0x01 0xff81 0x01 0xff81 0x01 0xff81))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i16x8 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i16x8 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                         (v128.const i16x8 0 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                         (v128.const i16x8 0 3 6 9 12 15 18 21))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                         (v128.const i16x8 065_535 065_535 065_535 065_535 065_535 065_535 065_535 065_535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345))
+                                         (v128.const i16x8 065_535 065_535 065_535 065_535 065_535 065_535 065_535 065_535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                         (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678))
+                                         (v128.const i16x8 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                         (v128.const i16x8 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef))
+                                         (v128.const i16x8 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff))
+
+;; i16x8.sub_sat_s
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32764 32764 32764 32764 32764 32764 32764 32764))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32765 -32765 -32765 -32765 -32765 -32765 -32765 -32765))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i16x8 0x8000 0 0x8000 0 0x8000 0 0x8000 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i16x8 0x01 0x8081 0x01 0x8081 0x01 0x8081 0x01 0x8081))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i16x8 0x01 0x81 0x01 0x81 0x01 0x81 0x01 0x81))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i16x8 0x01 0x8041 0x01 0x8041 0x01 0x8041 0x01 0x8041))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i16x8 0x01 0x41 0x01 0x41 0x01 0x41 0x01 0x41))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                         (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                         (v128.const i16x8 0 -1 -2 -3 -4 -5 -6 -7))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                         (v128.const i16x8 021_092 021_092 021_092 021_092 021_092 021_092 021_092 021_092))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345))
+                                         (v128.const i16x8 024_690 024_690 024_690 024_690 024_690 024_690 024_690 024_690))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                         (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678))
+                                         (v128.const i16x8 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                         (v128.const i16x8 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234))
+                                         (v128.const i16x8 0xa2df 0xa2df 0xa2df 0xa2df 0xa2df 0xa2df 0xa2df 0xa2df))
+
+;; i16x8.sub_sat_u
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32764 32764 32764 32764 32764 32764 32764 32764))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i16x8 0x8000 0 0x8000 0 0x8000 0 0x8000 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i16x8 0x01 0 0x01 0 0x01 0 0x01 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i16x8 0x01 0 0x01 0 0x01 0 0x01 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i16x8 0x01 0 0x01 0 0x01 0 0x01 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i16x8 0x01 0 0x01 0 0x01 0 0x01 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789)
+                                         (v128.const i16x8 -12_345 -12_345 -12_345 -12_345 -12_345 -12_345 -12_345 -12_345))
+                                         (v128.const i16x8 03_598 03_598 03_598 03_598 03_598 03_598 03_598 03_598))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                         (v128.const i16x8 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef)
+                                         (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB))
+                                         (v128.const i16x8 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44))
+
+;; Malformed cases: non-existent op names
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.add_sat (v128.const i16x8 1 1 1 1 1 1 1 1) (v128.const i16x8 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.sub_sat (v128.const i16x8 1 1 1 1 1 1 1 1) (v128.const i16x8 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.mul_sat (v128.const i16x8 1 1 1 1 1 1 1 1) (v128.const i16x8 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.div_sat (v128.const i16x8 1 1 1 1 1 1 1 1) (v128.const i16x8 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.add_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.add_sat_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.sub_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.sub_sat_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.add_sat_s-1st-arg-empty (result v128)
+      (i16x8.add_sat_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.add_sat_s-arg-empty (result v128)
+      (i16x8.add_sat_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.add_sat_u-1st-arg-empty (result v128)
+      (i16x8.add_sat_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.add_sat_u-arg-empty (result v128)
+      (i16x8.add_sat_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub_sat_s-1st-arg-empty (result v128)
+      (i16x8.sub_sat_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub_sat_s-arg-empty (result v128)
+      (i16x8.sub_sat_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub_sat_u-1st-arg-empty (result v128)
+      (i16x8.sub_sat_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub_sat_u-arg-empty (result v128)
+      (i16x8.sub_sat_u)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "sat-add_s-sub_s") (param v128 v128 v128) (result v128)
+    (i16x8.add_sat_s (i16x8.sub_sat_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_s-sub_u") (param v128 v128 v128) (result v128)
+    (i16x8.add_sat_s (i16x8.sub_sat_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_u-sub_s") (param v128 v128 v128) (result v128)
+    (i16x8.add_sat_u (i16x8.sub_sat_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_u-sub_u") (param v128 v128 v128) (result v128)
+    (i16x8.add_sat_u (i16x8.sub_sat_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_s-neg") (param v128 v128) (result v128)
+    (i16x8.add_sat_s (i16x8.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-add_u-neg") (param v128 v128) (result v128)
+    (i16x8.add_sat_u (i16x8.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-sub_s-neg") (param v128 v128) (result v128)
+    (i16x8.sub_sat_s (i16x8.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-sub_u-neg") (param v128 v128) (result v128)
+    (i16x8.sub_sat_u (i16x8.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "sat-add_s-sub_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "sat-add_s-sub_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "sat-add_u-sub_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534))
+(assert_return (invoke "sat-add_u-sub_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "sat-add_s-neg" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                       (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                       (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "sat-add_u-neg" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                       (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                       (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "sat-sub_s-neg" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                       (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                       (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "sat-sub_u-neg" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                       (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                       (v128.const i16x8 1 1 1 1 1 1 1 1))
\ No newline at end of file
diff --git a/tests/wast/spec/simd_i32x4_arith.wast b/tests/wast/spec/simd_i32x4_arith.wast
new file mode 100644
index 0000000000..f0e09b8bf7
--- /dev/null
+++ b/tests/wast/spec/simd_i32x4_arith.wast
@@ -0,0 +1,634 @@
+;; Tests for i32x4 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i32x4.add") (param v128 v128) (result v128) (i32x4.add (local.get 0) (local.get 1)))
+  (func (export "i32x4.sub") (param v128 v128) (result v128) (i32x4.sub (local.get 0) (local.get 1)))
+  (func (export "i32x4.mul") (param v128 v128) (result v128) (i32x4.mul (local.get 0) (local.get 1)))
+  (func (export "i32x4.neg") (param v128) (result v128) (i32x4.neg (local.get 0)))
+)
+
+
+;; i32x4.add
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -1 -1 -1 -1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x3fffffff 0x3fffffff 0x3fffffff 0x3fffffff)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -0x3fffffff -0x3fffffff -0x3fffffff -0x3fffffff)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000001 -0x40000001 -0x40000001 -0x40000001))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i8x16 0 0 0 0x80 0 0 0 0x80 0 0 0 0x80 0 0 0 0x80))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i16x8 0 0x8000 0 0x8000 0 0x8000 0 0x8000))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i32x4 0xbf800000 0xbf800000 0xbf800000 0xbf800000))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i32x4 0x3f800000 0x3f800000 0x3f800000 0x3f800000))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i32x4 0x7f800001 0x7f800001 0x7f800001 0x7f800001))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i32x4 0xff800001 0xff800001 0xff800001 0xff800001))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i32x4 0x7fc00001 0x7fc00001 0x7fc00001 0x7fc00001))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 0xffffffff 0xfffffffe 0xfffffffd))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 2 4 6))
+                                   (v128.const i32x4 0 3 6 9))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                   (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                   (v128.const i32x4 02_469_135_780 02_469_135_780 02_469_135_780 02_469_135_780))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                                   (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                                   (v128.const i32x4 0x0_a2e0_2467 0x0_a2e0_2467 0x0_a2e0_2467 0x0_a2e0_2467))
+
+;; i32x4.sub
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -1 -1 -1 -1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483644 2147483644 2147483644 2147483644))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483645 2147483645 2147483645 2147483645))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483645 -2147483645 -2147483645 -2147483645))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x3fffffff 0x3fffffff 0x3fffffff 0x3fffffff)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -0x3fffffff -0x3fffffff -0x3fffffff -0x3fffffff)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000001 -0x40000001 -0x40000001 -0x40000001))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i8x16 0 0 0 0x80 0 0 0 0x80 0 0 0 0x80 0 0 0 0x80))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i16x8 0 0x8000 0 0x8000 0 0x8000 0 0x8000))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i32x4 0x02 0x02 0x02 0x02))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i32x4 0x40800000 0x40800000 0x40800000 0x40800000))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i32x4 0xc0800000 0xc0800000 0xc0800000 0xc0800000))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i32x4 0x80800001 0x80800001 0x80800001 0x80800001))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i32x4 0x00800001 0x00800001 0x00800001 0x00800001))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i32x4 0x80400001 0x80400001 0x80400001 0x80400001))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 0xffffffff 0xfffffffe 0xfffffffd))
+                                   (v128.const i32x4 0 0x02 0x04 0x06))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 2 4 6))
+                                   (v128.const i32x4 0 -1 -2 -3))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 03_214_567_890  03_214_567_890  03_214_567_890  03_214_567_890 )
+                                   (v128.const i32x4 01_234_567_890  01_234_567_890  01_234_567_890  01_234_567_890 ))
+                                   (v128.const i32x4 01_980_000_000 01_980_000_000 01_980_000_000 01_980_000_000))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                   (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                                   (v128.const i32x4 0x0_7e77_7777 0x0_7e77_7777 0x0_7e77_7777 0x0_7e77_7777))
+
+;; i32x4.mul
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -1 -1 -1 -1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483645 2147483645 2147483645 2147483645))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x3fffffff 0x3fffffff 0x3fffffff 0x3fffffff)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -0x3fffffff -0x3fffffff -0x3fffffff -0x3fffffff)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000001 -0x40000001 -0x40000001 -0x40000001))
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x10000000 0x10000000 0x10000000 0x10000000)
+                                   (v128.const i8x16 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i16x8 0 0x02 0 0x02 0 0x02 0 0x02))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i32x4 0x7f800000 0x7f800000 0x7f800000 0x7f800000))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i32x4 0xff800000 0xff800000 0xff800000 0xff800000))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i32x4 0x7fc00000 0x7fc00000 0x7fc00000 0x7fc00000))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 0xffffffff 0xfffffffe 0xfffffffd))
+                                   (v128.const i32x4 0 0xffffffff 0xfffffffc 0xfffffff7))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 2 4 6))
+                                   (v128.const i32x4 0 0x02 0x08 0x12))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                                   (v128.const i32x4 0_987_654_321 0_987_654_321 0_987_654_321 0_987_654_321))
+                                   (v128.const i32x4 04_227_814_277 04_227_814_277 04_227_814_277 04_227_814_277))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                                   (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                                   (v128.const i32x4 0x0_2a42_d208 0x0_2a42_d208 0x0_2a42_d208 0x0_2a42_d208))
+
+;; i32x4.neg
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+                                   (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -0x7fffffff -0x7fffffff -0x7fffffff -0x7fffffff))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i32x4 1 1 1 1))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.neg (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.add (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.sub (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.mul (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.neg-arg-empty (result v128)
+      (i32x4.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.add-1st-arg-empty (result v128)
+      (i32x4.add (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.add-arg-empty (result v128)
+      (i32x4.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.sub-1st-arg-empty (result v128)
+      (i32x4.sub (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.sub-arg-empty (result v128)
+      (i32x4.sub)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.mul-1st-arg-empty (result v128)
+      (i32x4.mul (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.mul-arg-empty (result v128)
+      (i32x4.mul)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (i32x4.add (i32x4.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-add") (param v128 v128 v128) (result v128)
+    (i32x4.mul (i32x4.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-sub") (param v128 v128 v128) (result v128)
+    (i32x4.mul (i32x4.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (i32x4.sub (i32x4.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (i32x4.add (i32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "mul-neg") (param v128 v128) (result v128)
+    (i32x4.mul (i32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (i32x4.sub (i32x4.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 2 4 6)
+                                 (v128.const i32x4 0 2 4 6))
+                                 (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "mul-add" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 2 2 2 2))
+                                 (v128.const i32x4 0 4 8 12))
+(assert_return (invoke "mul-sub" (v128.const i32x4 0 2 4 6)
+                                 (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 1 2 3))
+                                 (v128.const i32x4 0 1 4 9))
+(assert_return (invoke "sub-add" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 2 4 6)
+                                 (v128.const i32x4 0 2 4 6))
+                                 (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "add-neg" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 1 2 3))
+                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "mul-neg" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 2 2 2 2))
+                                 (v128.const i32x4 0 -2 -4 -6))
+(assert_return (invoke "sub-neg" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 1 2 3))
+                                 (v128.const i32x4 0 -2 -4 -6))
\ No newline at end of file
diff --git a/tests/wast/spec/simd_i32x4_arith2.wast b/tests/wast/spec/simd_i32x4_arith2.wast
new file mode 100644
index 0000000000..63c3f4a42c
--- /dev/null
+++ b/tests/wast/spec/simd_i32x4_arith2.wast
@@ -0,0 +1,494 @@
+;; Tests for i32x4 [min_s, min_u, max_s, max_u, abs] operations.
+
+(module
+  (func (export "i32x4.min_s") (param v128 v128) (result v128) (i32x4.min_s (local.get 0) (local.get 1)))
+  (func (export "i32x4.min_u") (param v128 v128) (result v128) (i32x4.min_u (local.get 0) (local.get 1)))
+  (func (export "i32x4.max_s") (param v128 v128) (result v128) (i32x4.max_s (local.get 0) (local.get 1)))
+  (func (export "i32x4.max_u") (param v128 v128) (result v128) (i32x4.max_u (local.get 0) (local.get 1)))
+  (func (export "i32x4.abs") (param v128) (result v128) (i32x4.abs (local.get 0)))
+  (func (export "i32x4.min_s_with_const_0") (result v128) (i32x4.min_s (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)))
+  (func (export "i32x4.min_s_with_const_1") (result v128) (i32x4.min_s (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0)))
+  (func (export "i32x4.min_u_with_const_2") (result v128) (i32x4.min_u (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)))
+  (func (export "i32x4.min_u_with_const_3") (result v128) (i32x4.min_u (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0)))
+  (func (export "i32x4.max_s_with_const_4") (result v128) (i32x4.max_s (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)))
+  (func (export "i32x4.max_s_with_const_5") (result v128) (i32x4.max_s (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0)))
+  (func (export "i32x4.max_u_with_const_6") (result v128) (i32x4.max_u (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)))
+  (func (export "i32x4.max_u_with_const_7") (result v128) (i32x4.max_u (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0)))
+  (func (export "i32x4.abs_with_const_8") (result v128) (i32x4.abs (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)))
+  (func (export "i32x4.min_s_with_const_9") (param v128) (result v128) (i32x4.min_s (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)))
+  (func (export "i32x4.min_s_with_const_10") (param v128) (result v128) (i32x4.min_s (local.get 0) (v128.const i32x4 0 1 2 3)))
+  (func (export "i32x4.min_u_with_const_11") (param v128) (result v128) (i32x4.min_u (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)))
+  (func (export "i32x4.min_u_with_const_12") (param v128) (result v128) (i32x4.min_u (local.get 0) (v128.const i32x4 0 1 2 3)))
+  (func (export "i32x4.max_s_with_const_13") (param v128) (result v128) (i32x4.max_s (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)))
+  (func (export "i32x4.max_s_with_const_14") (param v128) (result v128) (i32x4.max_s (local.get 0) (v128.const i32x4 0 1 2 3)))
+  (func (export "i32x4.max_u_with_const_15") (param v128) (result v128) (i32x4.max_u (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)))
+  (func (export "i32x4.max_u_with_const_16") (param v128) (result v128) (i32x4.max_u (local.get 0) (v128.const i32x4 0 1 2 3)))
+)
+
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0 0 0 0))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 -1 -1 -1 -1))
+                                     (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 -1 -1)
+                                     (v128.const i32x4 0 -1 0 -1))
+                                     (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 1 1 1 1)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 128 128 128 128))
+                                     (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 123 123 123 123)
+                                     (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i32x4 123 123 123 123))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0x80 0x80 0x80 0x80)
+                                     (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0 0 0 0))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 -1 -1 -1 -1))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 -1 -1)
+                                     (v128.const i32x4 0 -1 0 -1))
+                                     (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 1 1 1 1)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 128 128 128 128))
+                                     (v128.const i32x4 128 128 128 128))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 123 123 123 123)
+                                     (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i32x4 123 123 123 123))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0x80 0x80 0x80 0x80)
+                                     (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0 0 0 0))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 -1 -1 -1 -1))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 -1 -1)
+                                     (v128.const i32x4 0 -1 0 -1))
+                                     (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 1 1 1 1)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 128 128 128 128))
+                                     (v128.const i32x4 128 128 128 128))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 123 123 123 123)
+                                     (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i32x4 123 123 123 123))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0x80 0x80 0x80 0x80)
+                                     (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0 0 0 0))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 -1 -1 -1 -1))
+                                     (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 -1 -1)
+                                     (v128.const i32x4 0 -1 0 -1))
+                                     (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 1 1 1 1)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 128 128 128 128))
+                                     (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 123 123 123 123)
+                                     (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i32x4 123 123 123 123))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0x80 0x80 0x80 0x80)
+                                     (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i32x4 0x1 0x1 0x1 0x1))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+                                   (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000))
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+                                   (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -01_2_3 -01_2_3 -01_2_3 -01_2_3))
+                                   (v128.const i32x4 123 123 123 123))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 0x80 0x80 0x80 0x80))
+                                   (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0x80 -0x80 -0x80 -0x80))
+                                   (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                   (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0))
+                                   (v128.const i32x4 0x80 0x80 0x80 0x80))
+
+;; Const vs const
+(assert_return (invoke "i32x4.min_s_with_const_0") (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_s_with_const_1") (v128.const i32x4 0 1 1 0))
+(assert_return (invoke "i32x4.min_u_with_const_2") (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_u_with_const_3") (v128.const i32x4 0 1 1 0))
+(assert_return (invoke "i32x4.max_s_with_const_4") (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_s_with_const_5") (v128.const i32x4 3 2 2 3))
+(assert_return (invoke "i32x4.max_u_with_const_6") (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_u_with_const_7") (v128.const i32x4 3 2 2 3))
+(assert_return (invoke "i32x4.abs_with_const_8") (v128.const i32x4 2147483648 2147483647 1073741824 1))
+
+;; Param vs const
+(assert_return (invoke "i32x4.min_s_with_const_9" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                                  (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_s_with_const_10" (v128.const i32x4 3 2 1 0))
+                                                   (v128.const i32x4 0 1 1 0))
+(assert_return (invoke "i32x4.min_u_with_const_11" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                                   (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_u_with_const_12" (v128.const i32x4 3 2 1 0))
+                                                   (v128.const i32x4 0 1 1 0))
+(assert_return (invoke "i32x4.max_s_with_const_13" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                                   (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_s_with_const_14" (v128.const i32x4 3 2 1 0))
+                                                   (v128.const i32x4 3 2 2 3))
+(assert_return (invoke "i32x4.max_u_with_const_15" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                                   (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_u_with_const_16" (v128.const i32x4 3 2 1 0))
+                                                   (v128.const i32x4 3 2 2 3))
+
+;; Test different lanes go through different if-then clauses
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)
+                                     (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                     (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 1 2 128)
+                                     (v128.const i32x4 0 2 1 128))
+                                     (v128.const i32x4 0 1 1 128))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)
+                                     (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                     (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 1 2 128)
+                                     (v128.const i32x4 0 2 1 128))
+                                     (v128.const i32x4 0 1 1 128))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)
+                                     (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                     (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 1 2 128)
+                                     (v128.const i32x4 0 2 1 128))
+                                     (v128.const i32x4 0 2 2 128))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)
+                                     (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                     (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 1 2 128)
+                                     (v128.const i32x4 0 2 1 128))
+                                     (v128.const i32x4 0 2 2 128))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295))
+                                   (v128.const i32x4 2147483648 2147483647 1073741824 1))
+
+;; Test opposite signs of zero
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 -0 -0 +0 +0)
+                                     (v128.const i32x4 +0 0 -0 0))
+                                     (v128.const i32x4 -0 -0 +0 +0))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 -0 -0 -0 -0)
+                                     (v128.const i32x4 +0 +0 +0 +0))
+                                     (v128.const i32x4 -0 -0 -0 -0))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 -0 -0 +0 +0)
+                                     (v128.const i32x4 +0 0 -0 0))
+                                     (v128.const i32x4 -0 -0 +0 +0))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 -0 -0 -0 -0)
+                                     (v128.const i32x4 +0 +0 +0 +0))
+                                     (v128.const i32x4 -0 -0 -0 -0))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 -0 -0 +0 +0)
+                                     (v128.const i32x4 +0 0 -0 0))
+                                     (v128.const i32x4 -0 -0 +0 +0))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 -0 -0 -0 -0)
+                                     (v128.const i32x4 +0 +0 +0 +0))
+                                     (v128.const i32x4 -0 -0 -0 -0))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 -0 -0 +0 +0)
+                                     (v128.const i32x4 +0 0 -0 0))
+                                     (v128.const i32x4 -0 -0 +0 +0))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 -0 -0 -0 -0)
+                                     (v128.const i32x4 +0 +0 +0 +0))
+                                     (v128.const i32x4 -0 -0 -0 -0))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0 -0 +0 +0))
+                                   (v128.const i32x4 -0 -0 +0 +0))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 +0 0 -0 0))
+                                   (v128.const i32x4 +0 0 -0 0))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0 -0 -0 -0))
+                                   (v128.const i32x4 -0 -0 -0 -0))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 +0 +0 +0 +0))
+                                   (v128.const i32x4 +0 +0 +0 +0))
+
+;; Unknown operators
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.min_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.min_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.max_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.max_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.min_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.min_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.max_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.max_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.min_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.min_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.max_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.max_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+
+;; Type check
+(assert_invalid (module (func (result v128) (i32x4.min_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.min_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.max_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.max_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.abs (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.min_s-1st-arg-empty (result v128)
+      (i32x4.min_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.min_s-arg-empty (result v128)
+      (i32x4.min_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.min_u-1st-arg-empty (result v128)
+      (i32x4.min_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.min_u-arg-empty (result v128)
+      (i32x4.min_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.max_s-1st-arg-empty (result v128)
+      (i32x4.max_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.max_s-arg-empty (result v128)
+      (i32x4.max_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.max_u-1st-arg-empty (result v128)
+      (i32x4.max_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.max_u-arg-empty (result v128)
+      (i32x4.max_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.abs-arg-empty (result v128)
+      (i32x4.abs)
+    )
+  )
+  "type mismatch"
+)
+
+;; Combination
+(module
+  (func (export "i32x4.min_s-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_s-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_s-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_s-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_s-i32x4.abs") (param v128 v128) (result v128) (i32x4.min_s (i32x4.abs (local.get 0))(local.get 1)))
+  (func (export "i32x4.abs-i32x4.min_s") (param v128 v128) (result v128) (i32x4.abs (i32x4.min_s (local.get 0) (local.get 1))))
+  (func (export "i32x4.min_u-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_u-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_u-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_u-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_u-i32x4.abs") (param v128 v128) (result v128) (i32x4.min_u (i32x4.abs (local.get 0))(local.get 1)))
+  (func (export "i32x4.abs-i32x4.min_u") (param v128 v128) (result v128) (i32x4.abs (i32x4.min_u (local.get 0) (local.get 1))))
+  (func (export "i32x4.max_s-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_s-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_s-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_s-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_s-i32x4.abs") (param v128 v128) (result v128) (i32x4.max_s (i32x4.abs (local.get 0))(local.get 1)))
+  (func (export "i32x4.abs-i32x4.max_s") (param v128 v128) (result v128) (i32x4.abs (i32x4.max_s (local.get 0) (local.get 1))))
+  (func (export "i32x4.max_u-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_u-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_u-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_u-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_u-i32x4.abs") (param v128 v128) (result v128) (i32x4.max_u (i32x4.abs (local.get 0))(local.get 1)))
+  (func (export "i32x4.abs-i32x4.max_u") (param v128 v128) (result v128) (i32x4.abs (i32x4.max_u (local.get 0) (local.get 1))))
+  (func (export "i32x4.abs-i32x4.abs") (param v128) (result v128) (i32x4.abs (i32x4.abs (local.get 0))))
+)
+
+(assert_return (invoke "i32x4.min_s-i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_s-i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_s-i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_s-i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_s-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1)
+                                               (v128.const i32x4 0 0 0 0))
+                                               (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.abs-i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                               (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_u-i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_u-i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_u-i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_u-i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_u-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1)
+                                               (v128.const i32x4 0 0 0 0))
+                                               (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.abs-i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                               (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_s-i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_s-i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_s-i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_s-i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_s-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1)
+                                               (v128.const i32x4 0 0 0 0))
+                                               (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs-i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                               (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_u-i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_u-i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_u-i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_u-i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_u-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1)
+                                               (v128.const i32x4 0 0 0 0))
+                                               (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs-i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                               (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1))
+                                             (v128.const i32x4 1 1 1 1))
diff --git a/tests/wast/spec/simd_i32x4_cmp.wast b/tests/wast/spec/simd_i32x4_cmp.wast
new file mode 100644
index 0000000000..fca45ab96b
--- /dev/null
+++ b/tests/wast/spec/simd_i32x4_cmp.wast
@@ -0,0 +1,1920 @@
+
+;; Test all the i32x4 comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) (i32x4.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) (i32x4.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x v128) (param $y v128) (result v128) (i32x4.lt_s (local.get $x) (local.get $y)))
+  (func (export "lt_u") (param $x v128) (param $y v128) (result v128) (i32x4.lt_u (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x v128) (param $y v128) (result v128) (i32x4.le_s (local.get $x) (local.get $y)))
+  (func (export "le_u") (param $x v128) (param $y v128) (result v128) (i32x4.le_u (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x v128) (param $y v128) (result v128) (i32x4.gt_s (local.get $x) (local.get $y)))
+  (func (export "gt_u") (param $x v128) (param $y v128) (result v128) (i32x4.gt_u (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x v128) (param $y v128) (result v128) (i32x4.ge_s (local.get $x) (local.get $y)))
+  (func (export "ge_u") (param $x v128) (param $y v128) (result v128) (i32x4.ge_u (local.get $x) (local.get $y)))
+)
+
+
+;; eq
+
+;; i32x4.eq  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                            (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                            (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                            (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                            (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                            (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                            (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "eq" (v128.const i32x4 -1 -1 -1 -1)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 0 0)
+                            (v128.const i32x4 4294967295 4294967295 0 0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0 0 4294967295 4294967295)
+                            (v128.const i32x4 0 0 4294967295 4294967295))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                            (v128.const i32x4 2147483649 -1 0 -1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "eq" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "eq" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                            (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                            (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                            (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i32x4 2147483648 2147483647 0 -1)
+                            (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                            (v128.const i32x4 -1 0 0 0))
+
+;; i32x4.eq  (i32x4) (i8x16)
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 -8323200 0 1 4294967295)
+                            (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                            (v128.const i32x4 0 -1 0 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                            (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                            (v128.const i32x4 0 0 0 0))
+
+;; i32x4.eq  (i32x4) (i16x8)
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                            (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 0 1 65535)
+                            (v128.const i16x8 65535 65535 0 0 1 0 65535 65535))
+                            (v128.const i32x4 -1 -1 -1 0))
+(assert_return (invoke "eq" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                            (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                            (v128.const i32x4 123456789 123456789 123456789 123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                            (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; ne
+
+;; i32x4.ne  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                            (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                            (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                            (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                            (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                            (v128.const i32x4 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                            (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                            (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i32x4 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "ne" (v128.const i32x4 -1 -1 -1 -1)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 0 0)
+                            (v128.const i32x4 4294967295 4294967295 0 0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0 0 4294967295 4294967295)
+                            (v128.const i32x4 0 0 4294967295 4294967295))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                            (v128.const i32x4 2147483649 -1 0 -1))
+                            (v128.const i32x4 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "ne" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i32x4 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "ne" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                            (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                            (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                            (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 2147483648 2147483647 0 -1)
+                            (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                            (v128.const i32x4 0 -1 -1 -1))
+
+;; i32x4.ne  (i32x4) (i8x16)
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 -8323200 0 1 4294967295)
+                            (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                            (v128.const i32x4 -1 0 -1 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                            (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.ne  (i32x4) (i16x8)
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                            (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 -128 0 1 255)
+                            (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                            (v128.const i32x4 -1 0 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                            (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                            (v128.const i32x4 123456789 123456789 123456789 123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                            (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                            (v128.const i32x4 0 0 0 0))
+
+;; lt_s
+
+;; i32x4.lt_s  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_s" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_s" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 0 0 0 -1))
+
+;; i32x4.lt_s  (i32x4) (i8x16)
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 0 0 -1 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 0 0 0 0))
+
+;; i32x4.lt_s  (i32x4) (i16x8)
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                              (v128.const i32x4 -0x6f543210 -0x6f543210 -0x6f543210 -0x6f543210))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; lt_u
+
+;; i32x4.lt_u  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_u" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_u" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 0 -1 -1 0))
+
+;; i32x4.lt_u  (i32x4) (i8x16)
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 0 0 -1 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.lt_u  (i32x4) (i16x8)
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                              (v128.const i32x4 -0x6f543210 -0x6f543210 -0x6f543210 -0x6f543210))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; le_s
+
+;; i32x4.le_s  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_s" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_s" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "le_s" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 -1 0 0 -1))
+
+;; i32x4.le_s  (i32x4)(i8x16)
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 0 0 0 0))
+
+;; i32x4.le_s  (i32x4) (i16x8)
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                              (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; le_u
+
+;; i32x4.le_u  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_u" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_u" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "le_u" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "le_u" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "le_u" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 -1 -1 -1 0))
+
+;; i32x4.le_u  (i32x4) (i8x16)
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.le_u  (i32x4) (i16x8)
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                              (v128.const i32x4 0x90ABcdef 0x90ABcdef 0x90ABcdef 0x90ABcdef))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; gt_s
+
+;; i32x4.gt_s  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_s" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_s" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 -1 -1 -1 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 0 -1 -1 0))
+
+;; i32x4.gt_s  (i32x4) (i8x16)
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.gt_s  (i32x4) (i16x8)
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 65535 0 1 32768)
+                              (v128.const i16x8 65535 65535 0 0 1 1 32768 32768))
+                              (v128.const i32x4 -1 0 0 -1))
+(assert_return (invoke "gt_s" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                              (v128.const i32x4 -0x6f543211 -0x6f543211 -0x6f543211 -0x6f543211))
+                              (v128.const i32x4 0 0 0 0))
+
+;; gt_u
+
+;; i32x4.gt_u  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_u" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_u" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 0 0 0 -1))
+
+;; i32x4.gt_u  (i32x4) (i8x16)
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 0 0 0 0))
+
+;; i32x4.gt_u  (i32x4) (i16x8)
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                              (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                              (v128.const i32x4 0 0 0 0))
+
+;; ge_s
+
+;; i32x4.ge_s  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_s" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_s" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 -1 -1 -1 0))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 -1 -1 -1 0))
+
+;; i32x4.ge_s  (i32x4) (i8x16)
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 -1 -1 0 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.ge_s  (i32x4) (i16x8)
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 65535 0 1 32768)
+                              (v128.const i16x8 65535 65535 0 0 1 1 32768 32768))
+                              (v128.const i32x4 -1 -1 0 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                              (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; ge_u
+
+;; i32x4.ge_u  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_u" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_u" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 -1 0 0 -1))
+
+;; i32x4.ge_u  (i32x4) (i8x16)
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 -1 -1 0 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.ge_u  (i32x4) (i16x8)
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 65535 65535 0 0 1 1 32768 32768))
+                              (v128.const i32x4 0 -1 0 0))
+(assert_return (invoke "ge_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                              (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (i32x4.eq (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.ge_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.ge_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.gt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.gt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.le_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.le_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.lt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+
+
+;; combination
+
+(module (memory 1)
+  (func (export "eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "lt_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.lt_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "le_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.le_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "gt_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.gt_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ge_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.ge_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-eq")
+    (drop
+      (i32x4.eq
+        (i32x4.eq
+          (i32x4.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.eq
+          (i32x4.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ne")
+    (drop
+      (i32x4.ne
+        (i32x4.ne
+          (i32x4.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.ne
+          (i32x4.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-lt_s")
+    (drop
+      (i32x4.lt_s
+        (i32x4.lt_s
+          (i32x4.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.lt_s
+          (i32x4.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-le_u")
+    (drop
+      (i32x4.le_u
+        (i32x4.le_u
+          (i32x4.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.le_u
+          (i32x4.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-gt_u")
+    (drop
+      (i32x4.gt_u
+        (i32x4.gt_u
+          (i32x4.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.gt_u
+          (i32x4.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ge_s")
+    (drop
+      (i32x4.ge_s
+        (i32x4.ge_s
+          (i32x4.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.ge_s
+          (i32x4.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (i32x4.ge_u
+        (i32x4.eq
+          (i32x4.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.ne
+          (i32x4.gt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.lt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+(assert_return (invoke "eq-in-block"))
+(assert_return (invoke "ne-in-block"))
+(assert_return (invoke "lt_s-in-block"))
+(assert_return (invoke "le_u-in-block"))
+(assert_return (invoke "gt_u-in-block"))
+(assert_return (invoke "ge_s-in-block"))
+(assert_return (invoke "nested-eq"))
+(assert_return (invoke "nested-ne"))
+(assert_return (invoke "nested-lt_s"))
+(assert_return (invoke "nested-le_u"))
+(assert_return (invoke "nested-gt_u"))
+(assert_return (invoke "nested-ge_s"))
+(assert_return (invoke "as-param"))
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.eq-1st-arg-empty (result v128)
+      (i32x4.eq (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.eq-arg-empty (result v128)
+      (i32x4.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ne-1st-arg-empty (result v128)
+      (i32x4.ne (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ne-arg-empty (result v128)
+      (i32x4.ne)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.lt_s-1st-arg-empty (result v128)
+      (i32x4.lt_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.lt_s-arg-empty (result v128)
+      (i32x4.lt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.lt_u-1st-arg-empty (result v128)
+      (i32x4.lt_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.lt_u-arg-empty (result v128)
+      (i32x4.lt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.le_s-1st-arg-empty (result v128)
+      (i32x4.le_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.le_s-arg-empty (result v128)
+      (i32x4.le_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.le_u-1st-arg-empty (result v128)
+      (i32x4.le_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.le_u-arg-empty (result v128)
+      (i32x4.le_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.gt_s-1st-arg-empty (result v128)
+      (i32x4.gt_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.gt_s-arg-empty (result v128)
+      (i32x4.gt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.gt_u-1st-arg-empty (result v128)
+      (i32x4.gt_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.gt_u-arg-empty (result v128)
+      (i32x4.gt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ge_s-1st-arg-empty (result v128)
+      (i32x4.ge_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ge_s-arg-empty (result v128)
+      (i32x4.ge_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ge_u-1st-arg-empty (result v128)
+      (i32x4.ge_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ge_u-arg-empty (result v128)
+      (i32x4.ge_u)
+    )
+  )
+  "type mismatch"
+)
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.eq (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ne (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.lt_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.lt_u (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.le_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.le_u (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.gt_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.gt_u (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ge_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ge_u (local.get $x) (local.get $y)))") "unknown operator")
+
diff --git a/tests/wast/spec/simd_i32x4_dot_i16x8.wast b/tests/wast/spec/simd_i32x4_dot_i16x8.wast
new file mode 100644
index 0000000000..b41de74d00
--- /dev/null
+++ b/tests/wast/spec/simd_i32x4_dot_i16x8.wast
@@ -0,0 +1,110 @@
+;; Tests for i32x4 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i32x4.dot_i16x8_s") (param v128 v128) (result v128) (i32x4.dot_i16x8_s (local.get 0) (local.get 1)))
+)
+
+
+;; i32x4.dot_i16x8_s
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                           (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                           (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                           (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                           (v128.const i32x4 536838144 536838144 536838144 536838144))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                           (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                           (v128.const i32x4 536870912 536870912 536870912 536870912))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                           (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                           (v128.const i32x4 536838144 536838144 536838144 536838144))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                           (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                           (v128.const i32x4 536870912 536870912 536870912 536870912))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                           (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                           (v128.const i32x4 536903680 536903680 536903680 536903680))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 65530 65530 65530 65530))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 65532 65532 65532 65532))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 -65536 -65536 -65536 -65536))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 65532 65532 65532 65532))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 65534 65534 65534 65534))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 65536 65536 65536 65536))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                           (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                           (v128.const i32x4 2147352578 2147352578 2147352578 2147352578))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                           (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                           (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                           (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                           (v128.const i32x4 2147418112 2147418112 2147418112 2147418112))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                           (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                           (v128.const i32x4 -65534 -65534 -65534 -65534))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                           (v128.const i32x4 65536 65536 65536 65536))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                           (v128.const i32x4 2 2 2 2))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.dot_i16x8_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.dot_i16x8_s-1st-arg-empty (result v128)
+      (i32x4.dot_i16x8_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.dot_i16x8_s-arg-empty (result v128)
+      (i32x4.dot_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/tests/wast/spec/simd_i32x4_extadd_pairwise_i16x8.wast b/tests/wast/spec/simd_i32x4_extadd_pairwise_i16x8.wast
new file mode 100644
index 0000000000..2d1682d40e
--- /dev/null
+++ b/tests/wast/spec/simd_i32x4_extadd_pairwise_i16x8.wast
@@ -0,0 +1,68 @@
+;; Tests for i32x4 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i32x4.extadd_pairwise_i16x8_s") (param v128) (result v128) (i32x4.extadd_pairwise_i16x8_s (local.get 0)))
+  (func (export "i32x4.extadd_pairwise_i16x8_u") (param v128) (result v128) (i32x4.extadd_pairwise_i16x8_u (local.get 0)))
+)
+
+
+;; i32x4.extadd_pairwise_i16x8_s
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                       (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                       (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                       (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+                                                       (v128.const i32x4 65532 65532 65532 65532))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                       (v128.const i32x4 -65534 -65534 -65534 -65534))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                       (v128.const i32x4 -65536 -65536 -65536 -65536))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                       (v128.const i32x4 65534 65534 65534 65534))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                       (v128.const i32x4 -2 -2 -2 -2))
+
+;; i32x4.extadd_pairwise_i16x8_u
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                       (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                       (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                       (v128.const i32x4 131070 131070 131070 131070))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+                                                       (v128.const i32x4 65532 65532 65532 65532))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                       (v128.const i32x4 65538 65538 65538 65538))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                       (v128.const i32x4 65536 65536 65536 65536))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                       (v128.const i32x4 65534 65534 65534 65534))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                       (v128.const i32x4 131070 131070 131070 131070))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.extadd_pairwise_i16x8_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extadd_pairwise_i16x8_u (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.extadd_pairwise_i16x8_s-arg-empty (result v128)
+      (i32x4.extadd_pairwise_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extadd_pairwise_i16x8_u-arg-empty (result v128)
+      (i32x4.extadd_pairwise_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/tests/wast/spec/simd_i32x4_extmul_i16x8.wast b/tests/wast/spec/simd_i32x4_extmul_i16x8.wast
new file mode 100644
index 0000000000..f04db6770f
--- /dev/null
+++ b/tests/wast/spec/simd_i32x4_extmul_i16x8.wast
@@ -0,0 +1,404 @@
+;; Tests for i32x4 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i32x4.extmul_low_i16x8_s") (param v128 v128) (result v128) (i32x4.extmul_low_i16x8_s (local.get 0) (local.get 1)))
+  (func (export "i32x4.extmul_high_i16x8_s") (param v128 v128) (result v128) (i32x4.extmul_high_i16x8_s (local.get 0) (local.get 1)))
+  (func (export "i32x4.extmul_low_i16x8_u") (param v128 v128) (result v128) (i32x4.extmul_low_i16x8_u (local.get 0) (local.get 1)))
+  (func (export "i32x4.extmul_high_i16x8_u") (param v128 v128) (result v128) (i32x4.extmul_high_i16x8_u (local.get 0) (local.get 1)))
+)
+
+
+;; i32x4.extmul_low_i16x8_s
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                  (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                  (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 268451840 268451840 268451840 268451840))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 32765 32765 32765 32765))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                                  (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 1073676289 1073676289 1073676289 1073676289))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                  (v128.const i32x4 1073709056 1073709056 1073709056 1073709056))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                  (v128.const i32x4 1 1 1 1))
+
+;; i32x4.extmul_high_i16x8_s
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                   (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                   (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 268451840 268451840 268451840 268451840))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 32765 32765 32765 32765))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 1073676289 1073676289 1073676289 1073676289))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                   (v128.const i32x4 1073709056 1073709056 1073709056 1073709056))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                   (v128.const i32x4 1 1 1 1))
+
+;; i32x4.extmul_low_i16x8_u
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -131071 -131071 -131071 -131071))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                  (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                  (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 -1878999040 -1878999040 -1878999040 -1878999040))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 -1879048192 -1879048192 -1879048192 -1879048192))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 -1879097344 -1879097344 -1879097344 -1879097344))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 32765 32765 32765 32765))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -2147385346 -2147385346 -2147385346 -2147385346))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -2147450881 -2147450881 -2147450881 -2147450881))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 2147450880 2147450880 2147450880 2147450880))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                                  (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 1073676289 1073676289 1073676289 1073676289))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                  (v128.const i32x4 1073774592 1073774592 1073774592 1073774592))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -131071 -131071 -131071 -131071))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 2147385345 2147385345 2147385345 2147385345))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 2147450880 2147450880 2147450880 2147450880))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                  (v128.const i32x4 -131071 -131071 -131071 -131071))
+
+;; i32x4.extmul_high_i16x8_u
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -131071 -131071 -131071 -131071))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                   (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                   (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 -1878999040 -1878999040 -1878999040 -1878999040))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 -1879048192 -1879048192 -1879048192 -1879048192))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 -1879097344 -1879097344 -1879097344 -1879097344))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 32765 32765 32765 32765))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -2147385346 -2147385346 -2147385346 -2147385346))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -2147450881 -2147450881 -2147450881 -2147450881))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 2147450880 2147450880 2147450880 2147450880))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 1073676289 1073676289 1073676289 1073676289))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                   (v128.const i32x4 1073774592 1073774592 1073774592 1073774592))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -131071 -131071 -131071 -131071))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 2147385345 2147385345 2147385345 2147385345))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 2147450880 2147450880 2147450880 2147450880))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                   (v128.const i32x4 -131071 -131071 -131071 -131071))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.extmul_low_i16x8_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extmul_high_i16x8_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extmul_low_i16x8_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extmul_high_i16x8_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.extmul_low_i16x8_s-1st-arg-empty (result v128)
+      (i32x4.extmul_low_i16x8_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_low_i16x8_s-arg-empty (result v128)
+      (i32x4.extmul_low_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_high_i16x8_s-1st-arg-empty (result v128)
+      (i32x4.extmul_high_i16x8_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_high_i16x8_s-arg-empty (result v128)
+      (i32x4.extmul_high_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_low_i16x8_u-1st-arg-empty (result v128)
+      (i32x4.extmul_low_i16x8_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_low_i16x8_u-arg-empty (result v128)
+      (i32x4.extmul_low_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_high_i16x8_u-1st-arg-empty (result v128)
+      (i32x4.extmul_high_i16x8_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_high_i16x8_u-arg-empty (result v128)
+      (i32x4.extmul_high_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/tests/wast/spec/simd_i32x4_trunc_sat_f32x4.wast b/tests/wast/spec/simd_i32x4_trunc_sat_f32x4.wast
new file mode 100644
index 0000000000..40af590f52
--- /dev/null
+++ b/tests/wast/spec/simd_i32x4_trunc_sat_f32x4.wast
@@ -0,0 +1,239 @@
+;; Tests for i32x4 trunc sat conversions from float.
+
+(module
+  (func (export "i32x4.trunc_sat_f32x4_s") (param v128) (result v128) (i32x4.trunc_sat_f32x4_s (local.get 0)))
+  (func (export "i32x4.trunc_sat_f32x4_u") (param v128) (result v128) (i32x4.trunc_sat_f32x4_u (local.get 0)))
+)
+
+
+;; i32x4.trunc_sat_f32x4_s
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0.0 0.0 0.0 0.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 1.5 1.5 1.5 1.5))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -1.5 -1.5 -1.5 -1.5))
+                                                 (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 1.9 1.9 1.9 1.9))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 2.0 2.0 2.0 2.0))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -1.9 -1.9 -1.9 -1.9))
+                                                 (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -2.0 -2.0 -2.0 -2.0))
+                                                 (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 2147483520.0 2147483520.0 2147483520.0 2147483520.0))
+                                                 (v128.const i32x4 2147483520 2147483520 2147483520 2147483520))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -2147483520.0 -2147483520.0 -2147483520.0 -2147483520.0))
+                                                 (v128.const i32x4 -2147483520 -2147483520 -2147483520 -2147483520))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 2147483648.0 2147483648.0 2147483648.0 2147483648.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -2147483648.0 -2147483648.0 -2147483648.0 -2147483648.0))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 4294967294.0 4294967294.0 4294967294.0 4294967294.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -4294967294.0 -4294967294.0 -4294967294.0 -4294967294.0))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 2147483647.0 2147483647.0 2147483647.0 2147483647.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -2147483647.0 -2147483647.0 -2147483647.0 -2147483647.0))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 4294967294.0 4294967294.0 4294967294.0 4294967294.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 4294967295.0 4294967295.0 4294967295.0 4294967295.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 4294967296.0 4294967296.0 4294967296.0 4294967296.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                                 (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.19999ap+0 0x1.19999ap+0 0x1.19999ap+0 0x1.19999ap+0))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.19999ap+0 -0x1.19999ap+0 -0x1.19999ap+0 -0x1.19999ap+0))
+                                                 (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                 (v128.const i32x4 6 6 6 6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                 (v128.const i32x4 -6 -6 -6 -6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.ccccccp-1 0x1.ccccccp-1 0x1.ccccccp-1 0x1.ccccccp-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.ccccccp-1 -0x1.ccccccp-1 -0x1.ccccccp-1 -0x1.ccccccp-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.fffffep-1 0x1.fffffep-1 0x1.fffffep-1 0x1.fffffep-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.fffffep-1 -0x1.fffffep-1 -0x1.fffffep-1 -0x1.fffffep-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                 (v128.const i32x4 6 6 6 6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                 (v128.const i32x4 -6 -6 -6 -6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 +inf +inf +inf +inf))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -inf -inf -inf -inf))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 +nan +nan +nan +nan))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -nan -nan -nan -nan))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 nan:0x444444 nan:0x444444 nan:0x444444 nan:0x444444))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -nan:0x444444 -nan:0x444444 -nan:0x444444 -nan:0x444444))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 42 42 42 42))
+                                                 (v128.const i32x4 42 42 42 42))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -42 -42 -42 -42))
+                                                 (v128.const i32x4 -42 -42 -42 -42))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0123456792.0 0123456792.0 0123456792.0 0123456792.0))
+                                                 (v128.const i32x4 123456792 123456792 123456792 123456792))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 01234567890.0 01234567890.0 01234567890.0 01234567890.0))
+                                                 (v128.const i32x4 1234567936 1234567936 1234567936 1234567936))
+
+;; i32x4.trunc_sat_f32x4_u
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0.0 0.0 0.0 0.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 1.5 1.5 1.5 1.5))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -1.5 -1.5 -1.5 -1.5))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 1.9 1.9 1.9 1.9))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 2.0 2.0 2.0 2.0))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -1.9 -1.9 -1.9 -1.9))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -2.0 -2.0 -2.0 -2.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 2147483520.0 2147483520.0 2147483520.0 2147483520.0))
+                                                 (v128.const i32x4 2147483520 2147483520 2147483520 2147483520))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -2147483520.0 -2147483520.0 -2147483520.0 -2147483520.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 2147483648.0 2147483648.0 2147483648.0 2147483648.0))
+                                                 (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -2147483648.0 -2147483648.0 -2147483648.0 -2147483648.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 4294967294.0 4294967294.0 4294967294.0 4294967294.0))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -4294967294.0 -4294967294.0 -4294967294.0 -4294967294.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 2147483647.0 2147483647.0 2147483647.0 2147483647.0))
+                                                 (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -2147483647.0 -2147483647.0 -2147483647.0 -2147483647.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 4294967294.0 4294967294.0 4294967294.0 4294967294.0))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 4294967295.0 4294967295.0 4294967295.0 4294967295.0))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 4294967296.0 4294967296.0 4294967296.0 4294967296.0))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.19999ap+0 0x1.19999ap+0 0x1.19999ap+0 0x1.19999ap+0))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.19999ap+0 -0x1.19999ap+0 -0x1.19999ap+0 -0x1.19999ap+0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                 (v128.const i32x4 6 6 6 6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.ccccccp-1 0x1.ccccccp-1 0x1.ccccccp-1 0x1.ccccccp-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.ccccccp-1 -0x1.ccccccp-1 -0x1.ccccccp-1 -0x1.ccccccp-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.fffffep-1 0x1.fffffep-1 0x1.fffffep-1 0x1.fffffep-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.fffffep-1 -0x1.fffffep-1 -0x1.fffffep-1 -0x1.fffffep-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                 (v128.const i32x4 6 6 6 6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 +inf +inf +inf +inf))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -inf -inf -inf -inf))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 +nan +nan +nan +nan))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -nan -nan -nan -nan))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 nan:0x444444 nan:0x444444 nan:0x444444 nan:0x444444))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -nan:0x444444 -nan:0x444444 -nan:0x444444 -nan:0x444444))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 42 42 42 42))
+                                                 (v128.const i32x4 42 42 42 42))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -42 -42 -42 -42))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0123456792.0 0123456792.0 0123456792.0 0123456792.0))
+                                                 (v128.const i32x4 123456792 123456792 123456792 123456792))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 01234567890.0 01234567890.0 01234567890.0 01234567890.0))
+                                                 (v128.const i32x4 1234567936 1234567936 1234567936 1234567936))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.trunc_sat_f32x4_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.trunc_sat_f32x4_u (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.trunc_sat_f32x4_s-arg-empty (result v128)
+      (i32x4.trunc_sat_f32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.trunc_sat_f32x4_u-arg-empty (result v128)
+      (i32x4.trunc_sat_f32x4_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/tests/wast/spec/simd_i32x4_trunc_sat_f64x2.wast b/tests/wast/spec/simd_i32x4_trunc_sat_f64x2.wast
new file mode 100644
index 0000000000..9bf507d77f
--- /dev/null
+++ b/tests/wast/spec/simd_i32x4_trunc_sat_f64x2.wast
@@ -0,0 +1,239 @@
+;; Tests for i32x4 trunc sat conversions from float.
+
+(module
+  (func (export "i32x4.trunc_sat_f64x2_s_zero") (param v128) (result v128) (i32x4.trunc_sat_f64x2_s_zero (local.get 0)))
+  (func (export "i32x4.trunc_sat_f64x2_u_zero") (param v128) (result v128) (i32x4.trunc_sat_f64x2_u_zero (local.get 0)))
+)
+
+
+;; i32x4.trunc_sat_f64x2_s_zero
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0.0 0.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0.0 -0.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 1.5 1.5))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -1.5 -1.5))
+                                                      (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 1.9 1.9))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 2.0 2.0))
+                                                      (v128.const i32x4 2 2 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -1.9 -1.9))
+                                                      (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -2.0 -2.0))
+                                                      (v128.const i32x4 -2 -2 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 2147483520.0 2147483520.0))
+                                                      (v128.const i32x4 2147483520 2147483520 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -2147483520.0 -2147483520.0))
+                                                      (v128.const i32x4 -2147483520 -2147483520 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 2147483648.0 2147483648.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -2147483648.0 -2147483648.0))
+                                                      (v128.const i32x4 -2147483648 -2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 4294967294.0 4294967294.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -4294967294.0 -4294967294.0))
+                                                      (v128.const i32x4 -2147483648 -2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 2147483647.0 2147483647.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -2147483647.0 -2147483647.0))
+                                                      (v128.const i32x4 -2147483647 -2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 4294967294.0 4294967294.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 4294967295.0 4294967295.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 4294967296.0 4294967296.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1p-149 0x1p-149))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1p-149 -0x1p-149))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1p-126 0x1p-126))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1p-126 -0x1p-126))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1p-1 0x1p-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1p+0 0x1p+0))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                                      (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.19999ap+0 0x1.19999ap+0))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.19999ap+0 -0x1.19999ap+0))
+                                                      (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                      (v128.const i32x4 6 6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                      (v128.const i32x4 -6 -6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                      (v128.const i32x4 -2147483648 -2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.ccccccp-1 0x1.ccccccp-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.ccccccp-1 -0x1.ccccccp-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.fffffep-1 0x1.fffffep-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.fffffep-1 -0x1.fffffep-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                      (v128.const i32x4 6 6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                      (v128.const i32x4 -6 -6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                      (v128.const i32x4 -2147483648 -2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 +inf +inf))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -inf -inf))
+                                                      (v128.const i32x4 -2147483648 -2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 +nan +nan))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -nan -nan))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 nan:0x444444 nan:0x444444))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -nan:0x444444 -nan:0x444444))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 42 42))
+                                                      (v128.const i32x4 42 42 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -42 -42))
+                                                      (v128.const i32x4 -42 -42 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0123456792.0 0123456792.0))
+                                                      (v128.const i32x4 123456792 123456792 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 01234567890.0 01234567890.0))
+                                                      (v128.const i32x4 1234567890 1234567890 0 0))
+
+;; i32x4.trunc_sat_f64x2_u_zero
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0.0 0.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0.0 -0.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 1.5 1.5))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -1.5 -1.5))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 1.9 1.9))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 2.0 2.0))
+                                                      (v128.const i32x4 2 2 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -1.9 -1.9))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -2.0 -2.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 2147483520.0 2147483520.0))
+                                                      (v128.const i32x4 2147483520 2147483520 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -2147483520.0 -2147483520.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 2147483648.0 2147483648.0))
+                                                      (v128.const i32x4 2147483648 2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -2147483648.0 -2147483648.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 4294967294.0 4294967294.0))
+                                                      (v128.const i32x4 4294967294 4294967294 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -4294967294.0 -4294967294.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 2147483647.0 2147483647.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -2147483647.0 -2147483647.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 4294967294.0 4294967294.0))
+                                                      (v128.const i32x4 4294967294 4294967294 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 4294967295.0 4294967295.0))
+                                                      (v128.const i32x4 4294967295 4294967295 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 4294967296.0 4294967296.0))
+                                                      (v128.const i32x4 4294967295 4294967295 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1p-149 0x1p-149))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1p-149 -0x1p-149))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1p-126 0x1p-126))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1p-126 -0x1p-126))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1p-1 0x1p-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1p+0 0x1p+0))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.19999ap+0 0x1.19999ap+0))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.19999ap+0 -0x1.19999ap+0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                      (v128.const i32x4 6 6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+                                                      (v128.const i32x4 4294967295 4294967295 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.ccccccp-1 0x1.ccccccp-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.ccccccp-1 -0x1.ccccccp-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.fffffep-1 0x1.fffffep-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.fffffep-1 -0x1.fffffep-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                      (v128.const i32x4 6 6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+                                                      (v128.const i32x4 4294967295 4294967295 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 +inf +inf))
+                                                      (v128.const i32x4 4294967295 4294967295 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -inf -inf))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 +nan +nan))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -nan -nan))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 nan:0x444444 nan:0x444444))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -nan:0x444444 -nan:0x444444))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 42 42))
+                                                      (v128.const i32x4 42 42 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -42 -42))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0123456792.0 0123456792.0))
+                                                      (v128.const i32x4 123456792 123456792 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 01234567890.0 01234567890.0))
+                                                      (v128.const i32x4 1234567890 1234567890 0 0))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.trunc_sat_f64x2_s_zero (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.trunc_sat_f64x2_u_zero (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.trunc_sat_f64x2_s_zero-arg-empty (result v128)
+      (i32x4.trunc_sat_f64x2_s_zero)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.trunc_sat_f64x2_u_zero-arg-empty (result v128)
+      (i32x4.trunc_sat_f64x2_u_zero)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/tests/wast/spec/simd_i64x2_arith.wast b/tests/wast/spec/simd_i64x2_arith.wast
new file mode 100644
index 0000000000..00963a0d03
--- /dev/null
+++ b/tests/wast/spec/simd_i64x2_arith.wast
@@ -0,0 +1,652 @@
+;; Tests for i64x2 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i64x2.add") (param v128 v128) (result v128) (i64x2.add (local.get 0) (local.get 1)))
+  (func (export "i64x2.sub") (param v128 v128) (result v128) (i64x2.sub (local.get 0) (local.get 1)))
+  (func (export "i64x2.mul") (param v128 v128) (result v128) (i64x2.mul (local.get 0) (local.get 1)))
+  (func (export "i64x2.neg") (param v128) (result v128) (i64x2.neg (local.get 0)))
+)
+
+
+;; i64x2.add
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 2 2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -1 -1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 4611686018427387903 4611686018427387903)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 4611686018427387904 4611686018427387904)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -4611686018427387903 -4611686018427387903)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -4611686018427387904 -4611686018427387904)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -4611686018427387905 -4611686018427387905)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 9223372036854775805 9223372036854775805)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775806 9223372036854775806))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 9223372036854775806 9223372036854775806)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 9223372036854775808 9223372036854775808)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775806 -9223372036854775806)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775807 -9223372036854775807)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 9223372036854775807 9223372036854775807)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 9223372036854775806 9223372036854775806))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 18446744073709551615 18446744073709551615))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x3fffffffffffffff 0x3fffffffffffffff)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x4000000000000000 0x4000000000000000)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -0x3fffffffffffffff -0x3fffffffffffffff)
+                                   (v128.const i64x2 -0x40000000fffffff -0x40000000fffffff))
+                                   (v128.const i64x2 -4899916394847535102 -4899916394847535102))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000000 -0x400000000000000))
+                                   (v128.const i64x2 -4899916394579099648 -4899916394579099648))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000001 -0x400000000000001))
+                                   (v128.const i64x2 -4899916394579099649 -4899916394579099649))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x7ffffffffffffff 0x7ffffffffffffff))
+                                   (v128.const i64x2 -8646911284551352322 -8646911284551352322))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 -0x01 -0x01))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0x80 0 0 0 0 0 0 0 0x80))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i16x8 0 0 0 0x8000 0 0 0 0x8000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i32x4 0 0x80000000 0 0x80000000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 +0.0 +0.0))
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 -0.0 -0.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 1.0 1.0))
+                                   (v128.const i64x2 0xbff0000000000000 0xbff0000000000000))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 -1.0 -1.0))
+                                   (v128.const i64x2 0x3ff0000000000000 0x3ff0000000000000))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const f64x2 +inf +inf))
+                                   (v128.const i64x2 0x7ff0000000000001 0x7ff0000000000001))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const i64x2 0xfff0000000000001 0xfff0000000000001))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const i64x2 0x7ff8000000000001 0x7ff8000000000001))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 0xffffffffffffffff))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 2))
+                                   (v128.const i64x2 0 3))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)
+                                   (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789))
+                                   (v128.const i64x2 02_469_135_780_246_913_578 02_469_135_780_246_913_578))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef)
+                                   (v128.const i64x2 0x0_90AB_cdef_1234_5678 0x0_90AB_cdef_1234_5678))
+                                   (v128.const i64x2 0x0_a2e0_2467_a2e0_2467 0x0_a2e0_2467_a2e0_2467))
+
+;; i64x2.sub
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 2 2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -1 -1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 4611686018427387903 4611686018427387903)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 4611686018427387904 4611686018427387904)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -4611686018427387903 -4611686018427387903)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -4611686018427387904 -4611686018427387904)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -4611686018427387905 -4611686018427387905)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 9223372036854775805 9223372036854775805)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775804 9223372036854775804))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 9223372036854775806 9223372036854775806)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775805 9223372036854775805))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 9223372036854775808 9223372036854775808)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775806 -9223372036854775806)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775805 -9223372036854775805))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775807 -9223372036854775807)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775806 -9223372036854775806))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 9223372036854775807 9223372036854775807)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 18446744073709551615 18446744073709551615))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x3fffffffffffffff 0x3fffffffffffffff)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x4000000000000000 0x4000000000000000)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -0x3fffffffffffffff -0x3fffffffffffffff)
+                                   (v128.const i64x2 -0x40000000fffffff -0x40000000fffffff))
+                                   (v128.const i64x2 -4323455642007240704 -4323455642007240704))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000000 -0x400000000000000))
+                                   (v128.const i64x2 -4323455642275676160 -4323455642275676160))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000001 -0x400000000000001))
+                                   (v128.const i64x2 -4323455642275676159 -4323455642275676159))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x7ffffffffffffff 0x7ffffffffffffff))
+                                   (v128.const i64x2 8646911284551352320 8646911284551352320))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 9223372036854775806 9223372036854775806))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 -0x01 -0x01))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0x80 0 0 0 0 0 0 0 0x80))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i64x2 2 2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i16x8 0 0 0 0x8000 0 0 0 0x8000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i64x2 2 2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i32x4 0 0x80000000 0 0x80000000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i64x2 2 2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 +0.0 +0.0))
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 -0.0 -0.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 1.0 1.0))
+                                   (v128.const i64x2 0x4010000000000000 0x4010000000000000))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 -1.0 -1.0))
+                                   (v128.const i64x2 0xc010000000000000 0xc010000000000000))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 +inf +inf))
+                                   (v128.const i64x2 0x8010000000000001 0x8010000000000001))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const i64x2 0x0010000000000001 0x0010000000000001))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const i64x2 0x8008000000000001 0x8008000000000001))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 0xffffffffffffffff))
+                                   (v128.const i64x2 0 0x02))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 2))
+                                   (v128.const i64x2 0 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 03_214_567_890_123_456_789 03_214_567_890_123_456_789)
+                                   (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789))
+                                   (v128.const i64x2 01_980_000_000_000_000_000 01_980_000_000_000_000_000))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x0_90AB_cdef_8765_4321 0x0_90AB_cdef_8765_4321)
+                                   (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef))
+                                   (v128.const i64x2 0x0_7e77_7776_f6b9_7532 0x0_7e77_7776_f6b9_7532))
+
+;; i64x2.mul
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -1 -1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 4611686018427387903 4611686018427387903)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 4611686018427387904 4611686018427387904)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -4611686018427387903 -4611686018427387903)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -4611686018427387904 -4611686018427387904)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -4611686018427387905 -4611686018427387905)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 9223372036854775805 9223372036854775805)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775805 9223372036854775805))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 9223372036854775806 9223372036854775806)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775806 9223372036854775806))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 9223372036854775808 9223372036854775808)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775806 -9223372036854775806)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 9223372036854775806 9223372036854775806))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775807 -9223372036854775807)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 9223372036854775807 9223372036854775807)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 18446744073709551615 18446744073709551615))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x3fffffffffffffff 0x3fffffffffffffff)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x4000000000000000 0x4000000000000000)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -0x3fffffffffffffff -0x3fffffffffffffff)
+                                   (v128.const i64x2 -0x40000000fffffff -0x40000000fffffff))
+                                   (v128.const i64x2 -4899916394847535103 -4899916394847535103))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000000 -0x400000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000001 -0x400000000000001))
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x7ffffffffffffff 0x7ffffffffffffff))
+                                   (v128.const i64x2 8646911284551352321 8646911284551352321))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 -0x01 -0x01))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i8x16 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i16x8 0 0 0 0x02 0 0 0 0x02))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i32x4 0 0x02 0 0x02))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x80000000 0x80000000)
+                                   (v128.const f64x2 +0.0 +0.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x80000000 0x80000000)
+                                   (v128.const f64x2 -0.0 -0.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x80000000 0x80000000)
+                                   (v128.const f64x2 1.0 1.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x80000000 0x80000000)
+                                   (v128.const f64x2 -1.0 -1.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 +inf +inf))
+                                   (v128.const i64x2 0x7ff0000000000000 0x7ff0000000000000))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const i64x2 0xfff0000000000000 0xfff0000000000000))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const i64x2 0x7ff8000000000000 0x7ff8000000000000))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 0xffffffffffffffff))
+                                   (v128.const i64x2 0 0xffffffffffffffff))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 2))
+                                   (v128.const i64x2 0 0x02))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)
+                                   (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789))
+                                   (v128.const i64x2 09_710_478_858_155_731_897 09_710_478_858_155_731_897))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef)
+                                   (v128.const i64x2 0x0_90AB_cdef_8765_4321 0x0_90AB_cdef_8765_4321))
+                                   (v128.const i64x2 0x0_602f_05e9_e556_18cf 0x0_602f_05e9_e556_18cf))
+
+;; i64x2.neg
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 0 0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 9223372036854775806 9223372036854775806))
+                                   (v128.const i64x2 -9223372036854775806 -9223372036854775806))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 18446744073709551615 18446744073709551615))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -0x01 -0x01))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -0x8000000000000000 -0x8000000000000000))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -0x7fffffffffffffff -0x7fffffffffffffff))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff))
+                                   (v128.const i64x2 1 1))
+
+;; type check
+(assert_invalid (module (func (result v128) (i64x2.neg (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.add (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.sub (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.mul (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i64x2.neg-arg-empty (result v128)
+      (i64x2.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.add-1st-arg-empty (result v128)
+      (i64x2.add (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.add-arg-empty (result v128)
+      (i64x2.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.sub-1st-arg-empty (result v128)
+      (i64x2.sub (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.sub-arg-empty (result v128)
+      (i64x2.sub)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.mul-1st-arg-empty (result v128)
+      (i64x2.mul (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.mul-arg-empty (result v128)
+      (i64x2.mul)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (i64x2.add (i64x2.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-add") (param v128 v128 v128) (result v128)
+    (i64x2.mul (i64x2.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-sub") (param v128 v128 v128) (result v128)
+    (i64x2.mul (i64x2.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (i64x2.sub (i64x2.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (i64x2.add (i64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "mul-neg") (param v128 v128) (result v128)
+    (i64x2.mul (i64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (i64x2.sub (i64x2.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 2)
+                                 (v128.const i64x2 0 2))
+                                 (v128.const i64x2 0 1))
+(assert_return (invoke "mul-add" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 1)
+                                 (v128.const i64x2 2 2))
+                                 (v128.const i64x2 0 4))
+(assert_return (invoke "mul-sub" (v128.const i64x2 0 2)
+                                 (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 1))
+                                 (v128.const i64x2 0 1))
+(assert_return (invoke "sub-add" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 2)
+                                 (v128.const i64x2 0 2))
+                                 (v128.const i64x2 0 1))
+(assert_return (invoke "add-neg" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 1))
+                                 (v128.const i64x2 0 0))
+(assert_return (invoke "mul-neg" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 2 2))
+                                 (v128.const i64x2 0 -2))
+(assert_return (invoke "sub-neg" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 1))
+                                 (v128.const i64x2 0 -2))
\ No newline at end of file
diff --git a/tests/wast/spec/simd_i64x2_arith2.wast b/tests/wast/spec/simd_i64x2_arith2.wast
new file mode 100644
index 0000000000..14398d8a46
--- /dev/null
+++ b/tests/wast/spec/simd_i64x2_arith2.wast
@@ -0,0 +1,78 @@
+;; Tests for i64x2 [abs] operations.
+
+(module
+  (func (export "i64x2.abs") (param v128) (result v128) (i64x2.abs (local.get 0)))
+  (func (export "i64x2.abs_with_const_0") (result v128) (i64x2.abs (v128.const i64x2 -9223372036854775808 9223372036854775807)))
+)
+
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 1 1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 18446744073709551615 18446744073709551615))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff))
+                                   (v128.const i64x2 0x1 0x1))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 9223372036854775808 9223372036854775808))
+                                   (v128.const i64x2 9223372036854775808 9223372036854775808))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 9223372036854775808 9223372036854775808))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0x8000000000000000 -0x8000000000000000))
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 01_2_3 01_2_3))
+                                   (v128.const i64x2 01_2_3 01_2_3))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -01_2_3 -01_2_3))
+                                   (v128.const i64x2 123 123))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 0x80 0x80))
+                                   (v128.const i64x2 0x80 0x80))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0x80 -0x80))
+                                   (v128.const i64x2 0x80 0x80))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 0x0_8_0 0x0_8_0))
+                                   (v128.const i64x2 0x0_8_0 0x0_8_0))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0x0_8_0 -0x0_8_0))
+                                   (v128.const i64x2 0x80 0x80))
+
+;; Const vs const
+(assert_return (invoke "i64x2.abs_with_const_0") (v128.const i64x2 9223372036854775808 9223372036854775807))
+
+;; Param vs const
+
+;; Test different lanes go through different if-then clauses
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -9223372036854775808 9223372036854775807))
+                                   (v128.const i64x2 9223372036854775808 9223372036854775807))
+
+;; Test opposite signs of zero
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0 -0))
+                                   (v128.const i64x2 -0 -0))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 +0 0))
+                                   (v128.const i64x2 +0 0))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0 -0))
+                                   (v128.const i64x2 -0 -0))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 +0 +0))
+                                   (v128.const i64x2 +0 +0))
+
+;; Unknown operators
+
+;; Type check
+(assert_invalid (module (func (result v128) (i64x2.abs (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i64x2.abs-arg-empty (result v128)
+      (i64x2.abs)
+    )
+  )
+  "type mismatch"
+)
+
+;; Combination
+(module
+  (func (export "i64x2.abs-i64x2.abs") (param v128) (result v128) (i64x2.abs (i64x2.abs (local.get 0))))
+)
+
+(assert_return (invoke "i64x2.abs-i64x2.abs" (v128.const i64x2 -1 -1))
+                                             (v128.const i64x2 1 1))
diff --git a/tests/wast/spec/simd_i64x2_cmp.wast b/tests/wast/spec/simd_i64x2_cmp.wast
new file mode 100644
index 0000000000..50e58b64b1
--- /dev/null
+++ b/tests/wast/spec/simd_i64x2_cmp.wast
@@ -0,0 +1,420 @@
+
+;; Test all the i64x2 comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) (i64x2.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) (i64x2.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x v128) (param $y v128) (result v128) (i64x2.lt_s (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x v128) (param $y v128) (result v128) (i64x2.le_s (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x v128) (param $y v128) (result v128) (i64x2.gt_s (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x v128) (param $y v128) (result v128) (i64x2.ge_s (local.get $x) (local.get $y)))
+)
+
+
+;; eq
+
+;; i64x2.eq  (i64x2) (i64x2)
+(assert_return (invoke "eq" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                            (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                            (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                            (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                            (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                            (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                            (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0x03020100 0x11100904)
+                            (v128.const i64x2 0x03020100 0x11100904))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                            (v128.const i64x2 0x0FFFFFFFFFFFFFFF 0x0FFFFFFFFFFFFFFF))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "eq" (v128.const i64x2 0x1 0x1)
+                            (v128.const i64x2 0x2 0x2))
+                            (v128.const i64x2 0 0))
+
+;; ne
+
+;; i64x2.ne  (i64x2) (i64x2)
+
+;; hex vs hex
+(assert_return (invoke "ne" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                            (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                            (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                            (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                            (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                            (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                            (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0x03020100 0x11100904)
+                            (v128.const i64x2 0x03020100 0x11100904))
+                            (v128.const i64x2 0 0))
+
+;; lt_s
+
+;; i64x2.lt_s  (i64x2) (i64x2)
+
+;; hex vs hex
+(assert_return (invoke "lt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                              (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                              (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                              (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B)
+                              (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B))
+                              (v128.const i64x2 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 9259542123273814144 9259542123273814144))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 -9187201950435737472 -9187201950435737472))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x8382818000FFFEFD 0x7F020100FFFEFD80)
+                              (v128.const i64x2 -8970465120996032771 9151878496576798080))
+                              (v128.const i64x2 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_s" (v128.const i64x2 -1 -1)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0 0)
+                              (v128.const i64x2 0 0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 18446744073709551615 0)
+                              (v128.const i64x2 18446744073709551615 0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0 18446744073709551615)
+                              (v128.const i64x2 0 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 -9223372036854775807 18446744073709551615)
+                              (v128.const i64x2 9223372036854775809 -1))
+                              (v128.const i64x2 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_s" (v128.const i64x2 0xc060000000000000 0xc05fc00000000000)
+                              (v128.const f64x2 -128.0 -127.0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x3ff0000000000000 0x405fc00000000000)
+                              (v128.const f64x2 1.0 127.0))
+                              (v128.const i64x2 0 0))
+
+;; le_s
+
+;; i64x2.le_s  (i64x2) (i64x2)
+
+;; hex vs hex
+(assert_return (invoke "le_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                              (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                              (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                              (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B)
+                              (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B))
+                              (v128.const i64x2 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 9259542123273814144 9259542123273814144))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 -9187201950435737472 -9187201950435737472))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x8382818000FFFEFD 0x7F020100FFFEFD80)
+                              (v128.const i64x2 -8970465120996032771 9151878496576798080))
+                              (v128.const i64x2 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_s" (v128.const i64x2 -1 -1)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0 0)
+                              (v128.const i64x2 0 -1))
+                              (v128.const i64x2 -1 0))
+(assert_return (invoke "le_s" (v128.const i64x2 0 0)
+                              (v128.const i64x2 0 0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 18446744073709551615 0)
+                              (v128.const i64x2 18446744073709551615 0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0 18446744073709551615)
+                              (v128.const i64x2 0 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 -9223372036854775807 18446744073709551615)
+                              (v128.const i64x2 9223372036854775809 -1))
+                              (v128.const i64x2 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_s" (v128.const i64x2 0xc060000000000000 0xc05fc00000000000)
+                              (v128.const f64x2 -128.0 -127.0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x3ff0000000000000 0x405fc00000000000)
+                              (v128.const f64x2 1.0 127.0))
+                              (v128.const i64x2 -1 -1))
+
+;; gt_s
+
+;; i64x2.gt_s  (i64x2) (i64x2)
+
+;; hex vs hex
+(assert_return (invoke "gt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                              (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                              (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                              (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B)
+                              (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B))
+                              (v128.const i64x2 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 9259542123273814144 9259542123273814144))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 -9187201950435737472 -9187201950435737472))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x8382818000FFFEFD 0x7F020100FFFEFD80)
+                              (v128.const i64x2 -8970465120996032771 9151878496576798080))
+                              (v128.const i64x2 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_s" (v128.const i64x2 -1 -1)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0 0)
+                              (v128.const i64x2 0 0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 18446744073709551615 0)
+                              (v128.const i64x2 18446744073709551615 0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0 18446744073709551615)
+                              (v128.const i64x2 0 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 -9223372036854775807 18446744073709551615)
+                              (v128.const i64x2 9223372036854775809 -1))
+                              (v128.const i64x2 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_s" (v128.const i64x2 0xc060000000000000 0xc05fc00000000000)
+                              (v128.const f64x2 -128.0 -127.0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x3ff0000000000000 0x405fc00000000000)
+                              (v128.const f64x2 1.0 127.0))
+                              (v128.const i64x2 0 0))
+
+;; ge_s
+
+;; i64x2.ge_s  (i64x2) (i64x2)
+
+;; hex vs hex
+(assert_return (invoke "ge_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                              (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                              (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                              (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B)
+                              (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B))
+                              (v128.const i64x2 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 9259542123273814144 9259542123273814144))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 -9187201950435737472 -9187201950435737472))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x8382818000FFFEFD 0x7F020100FFFEFD80)
+                              (v128.const i64x2 -8970465120996032771 9151878496576798080))
+                              (v128.const i64x2 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_s" (v128.const i64x2 -1 -1)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 -1 -1)
+                              (v128.const i64x2 0 -1))
+                              (v128.const i64x2 0 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0 0)
+                              (v128.const i64x2 0 0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 18446744073709551615 0)
+                              (v128.const i64x2 18446744073709551615 0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0 18446744073709551615)
+                              (v128.const i64x2 0 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 -9223372036854775807 18446744073709551615)
+                              (v128.const i64x2 9223372036854775809 -1))
+                              (v128.const i64x2 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_s" (v128.const i64x2 0xc060000000000000 0xc05fc00000000000)
+                              (v128.const f64x2 -128.0 -127.0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x3ff0000000000000 0x405fc00000000000)
+                              (v128.const f64x2 1.0 127.0))
+                              (v128.const i64x2 -1 -1))
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (i64x2.eq (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.ge_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.gt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.le_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i64x2.eq-1st-arg-empty (result v128)
+      (i64x2.eq (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.eq-arg-empty (result v128)
+      (i64x2.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.ne-1st-arg-empty (result v128)
+      (i64x2.ne (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.ne-arg-empty (result v128)
+      (i64x2.ne)
+    )
+  )
+  "type mismatch"
+)
\ No newline at end of file
diff --git a/tests/wast/spec/simd_i64x2_extmul_i32x4.wast b/tests/wast/spec/simd_i64x2_extmul_i32x4.wast
new file mode 100644
index 0000000000..9259279c92
--- /dev/null
+++ b/tests/wast/spec/simd_i64x2_extmul_i32x4.wast
@@ -0,0 +1,404 @@
+;; Tests for i64x2 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i64x2.extmul_low_i32x4_s") (param v128 v128) (result v128) (i64x2.extmul_low_i32x4_s (local.get 0) (local.get 1)))
+  (func (export "i64x2.extmul_high_i32x4_s") (param v128 v128) (result v128) (i64x2.extmul_high_i32x4_s (local.get 0) (local.get 1)))
+  (func (export "i64x2.extmul_low_i32x4_u") (param v128 v128) (result v128) (i64x2.extmul_low_i32x4_u (local.get 0) (local.get 1)))
+  (func (export "i64x2.extmul_high_i32x4_u") (param v128 v128) (result v128) (i64x2.extmul_high_i32x4_u (local.get 0) (local.get 1)))
+)
+
+
+;; i64x2.extmul_low_i32x4_s
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -1 -1 -1 -1)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                  (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                  (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 1152921505680588800 1152921505680588800))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 2147483645 2147483645))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                                  (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 4611686014132420609 4611686014132420609))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                                  (v128.const i64x2 4611686016279904256 4611686016279904256))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 -2147483647 -2147483647))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                                  (v128.const i64x2 1 1))
+
+;; i64x2.extmul_high_i32x4_s
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -1 -1 -1 -1)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                   (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                   (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 1152921505680588800 1152921505680588800))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 2147483645 2147483645))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 4611686014132420609 4611686014132420609))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                                   (v128.const i64x2 4611686016279904256 4611686016279904256))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 -2147483647 -2147483647))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                                   (v128.const i64x2 1 1))
+
+;; i64x2.extmul_low_i32x4_u
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 -8589934591 -8589934591))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                  (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                  (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 -8070450529026703360 -8070450529026703360))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 -8070450532247928832 -8070450532247928832))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 -8070450535469154304 -8070450535469154304))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 2147483645 2147483645))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 -9223372030412324866 -9223372030412324866))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 -9223372034707292161 -9223372034707292161))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 9223372034707292160 9223372034707292160))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                                  (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 4611686014132420609 4611686014132420609))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                                  (v128.const i64x2 4611686020574871552 4611686020574871552))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 -8589934591 -8589934591))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 9223372030412324865 9223372030412324865))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 9223372034707292160 9223372034707292160))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                                  (v128.const i64x2 -8589934591 -8589934591))
+
+;; i64x2.extmul_high_i32x4_u
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 -8589934591 -8589934591))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                   (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                   (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 -8070450529026703360 -8070450529026703360))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 -8070450532247928832 -8070450532247928832))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 -8070450535469154304 -8070450535469154304))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 2147483645 2147483645))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 -9223372030412324866 -9223372030412324866))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 -9223372034707292161 -9223372034707292161))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 9223372034707292160 9223372034707292160))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 4611686014132420609 4611686014132420609))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                                   (v128.const i64x2 4611686020574871552 4611686020574871552))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 -8589934591 -8589934591))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 9223372030412324865 9223372030412324865))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 9223372034707292160 9223372034707292160))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                                   (v128.const i64x2 -8589934591 -8589934591))
+
+;; type check
+(assert_invalid (module (func (result v128) (i64x2.extmul_low_i32x4_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extmul_high_i32x4_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extmul_low_i32x4_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extmul_high_i32x4_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i64x2.extmul_low_i32x4_s-1st-arg-empty (result v128)
+      (i64x2.extmul_low_i32x4_s (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_low_i32x4_s-arg-empty (result v128)
+      (i64x2.extmul_low_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_high_i32x4_s-1st-arg-empty (result v128)
+      (i64x2.extmul_high_i32x4_s (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_high_i32x4_s-arg-empty (result v128)
+      (i64x2.extmul_high_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_low_i32x4_u-1st-arg-empty (result v128)
+      (i64x2.extmul_low_i32x4_u (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_low_i32x4_u-arg-empty (result v128)
+      (i64x2.extmul_low_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_high_i32x4_u-1st-arg-empty (result v128)
+      (i64x2.extmul_high_i32x4_u (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_high_i32x4_u-arg-empty (result v128)
+      (i64x2.extmul_high_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/tests/wast/spec/simd_i8x16_arith.wast b/tests/wast/spec/simd_i8x16_arith.wast
new file mode 100644
index 0000000000..1e56b4c00f
--- /dev/null
+++ b/tests/wast/spec/simd_i8x16_arith.wast
@@ -0,0 +1,426 @@
+;; Tests for i8x16 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i8x16.add") (param v128 v128) (result v128) (i8x16.add (local.get 0) (local.get 1)))
+  (func (export "i8x16.sub") (param v128 v128) (result v128) (i8x16.sub (local.get 0) (local.get 1)))
+  (func (export "i8x16.neg") (param v128) (result v128) (i8x16.neg (local.get 0)))
+)
+
+
+;; i8x16.add
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                   (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                   (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                   (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                   (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                   (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                   (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                   (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                   (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i8x16 0x80 0x80 0 0xbf 0x80 0x80 0 0xbf 0x80 0x80 0 0xbf 0x80 0x80 0 0xbf))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i8x16 0x80 0x80 0 0x3f 0x80 0x80 0 0x3f 0x80 0x80 0 0x3f 0x80 0x80 0 0x3f))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i8x16 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i8x16 0x01 0x01 0x81 0 0x01 0x01 0x81 0 0x01 0x01 0x81 0 0x01 0x01 0x81 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i8x16 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                   (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                   (v128.const i8x16 0 3 6 9 12 15 18 21 24 27 30 33 36 39 42 45))
+
+;; i8x16.sub
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                   (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                   (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                   (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                   (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                   (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                   (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                   (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i8x16 0x80 0x80 0 0x41 0x80 0x80 0 0x41 0x80 0x80 0 0x41 0x80 0x80 0 0x41))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i8x16 0x80 0x80 0 0xc1 0x80 0x80 0 0xc1 0x80 0x80 0 0xc1 0x80 0x80 0 0xc1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i8x16 0x01 0x01 0x81 0x82 0x01 0x01 0x81 0x82 0x01 0x01 0x81 0x82 0x01 0x01 0x81 0x82))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i8x16 0x01 0x01 0x81 0x02 0x01 0x01 0x81 0x02 0x01 0x01 0x81 0x02 0x01 0x01 0x81 0x02))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i8x16 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                   (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                   (v128.const i8x16 0 0x02 0x04 0x06 0x08 0x0a 0x0c 0x0e 0x10 0x12 0x14 0x16 0x18 0x1a 0x1c 0x1e))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                   (v128.const i8x16 0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15))
+
+;; i8x16.neg
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+                                   (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+
+;; type check
+(assert_invalid (module (func (result v128) (i8x16.neg (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.add (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.sub (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.neg-arg-empty (result v128)
+      (i8x16.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.add-1st-arg-empty (result v128)
+      (i8x16.add (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.add-arg-empty (result v128)
+      (i8x16.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub-1st-arg-empty (result v128)
+      (i8x16.sub (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub-arg-empty (result v128)
+      (i8x16.sub)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (i8x16.add (i8x16.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (i8x16.sub (i8x16.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (i8x16.add (i8x16.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (i8x16.sub (i8x16.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                 (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30)
+                                 (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "sub-add" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                 (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30)
+                                 (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "add-neg" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+                                 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "sub-neg" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+                                 (v128.const i8x16 0 -2 -4 -6 -8 -10 -12 -14 -16 -18 -20 -22 -24 -26 -28 -30))
\ No newline at end of file
diff --git a/tests/wast/spec/simd_i8x16_arith2.wast b/tests/wast/spec/simd_i8x16_arith2.wast
new file mode 100644
index 0000000000..991ec14bb8
--- /dev/null
+++ b/tests/wast/spec/simd_i8x16_arith2.wast
@@ -0,0 +1,713 @@
+;; Tests for i8x16 [min_s, min_u, max_s, max_u, avgr_u, abs] operations.
+
+(module
+  (func (export "i8x16.min_s") (param v128 v128) (result v128) (i8x16.min_s (local.get 0) (local.get 1)))
+  (func (export "i8x16.min_u") (param v128 v128) (result v128) (i8x16.min_u (local.get 0) (local.get 1)))
+  (func (export "i8x16.max_s") (param v128 v128) (result v128) (i8x16.max_s (local.get 0) (local.get 1)))
+  (func (export "i8x16.max_u") (param v128 v128) (result v128) (i8x16.max_u (local.get 0) (local.get 1)))
+  (func (export "i8x16.avgr_u") (param v128 v128) (result v128) (i8x16.avgr_u (local.get 0) (local.get 1)))
+  (func (export "i8x16.abs") (param v128) (result v128) (i8x16.abs (local.get 0)))
+  (func (export "i8x16.popcnt") (param v128) (result v128) (i8x16.popcnt (local.get 0)))
+  (func (export "i8x16.min_s_with_const_0") (result v128) (i8x16.min_s (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)))
+  (func (export "i8x16.min_s_with_const_1") (result v128) (i8x16.min_s (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)))
+  (func (export "i8x16.min_u_with_const_2") (result v128) (i8x16.min_u (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)))
+  (func (export "i8x16.min_u_with_const_3") (result v128) (i8x16.min_u (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)))
+  (func (export "i8x16.max_s_with_const_4") (result v128) (i8x16.max_s (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)))
+  (func (export "i8x16.max_s_with_const_5") (result v128) (i8x16.max_s (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)))
+  (func (export "i8x16.max_u_with_const_6") (result v128) (i8x16.max_u (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)))
+  (func (export "i8x16.max_u_with_const_7") (result v128) (i8x16.max_u (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)))
+  (func (export "i8x16.avgr_u_with_const_8") (result v128) (i8x16.avgr_u (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)))
+  (func (export "i8x16.avgr_u_with_const_9") (result v128) (i8x16.avgr_u (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)))
+  (func (export "i8x16.abs_with_const_10") (result v128) (i8x16.abs (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.popcnt_with_const_11") (result v128) (i8x16.popcnt (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.min_s_with_const_12") (param v128) (result v128) (i8x16.min_s (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.min_s_with_const_13") (param v128) (result v128) (i8x16.min_s (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3)))
+  (func (export "i8x16.min_u_with_const_14") (param v128) (result v128) (i8x16.min_u (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.min_u_with_const_15") (param v128) (result v128) (i8x16.min_u (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3)))
+  (func (export "i8x16.max_s_with_const_16") (param v128) (result v128) (i8x16.max_s (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.max_s_with_const_17") (param v128) (result v128) (i8x16.max_s (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3)))
+  (func (export "i8x16.max_u_with_const_18") (param v128) (result v128) (i8x16.max_u (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.max_u_with_const_19") (param v128) (result v128) (i8x16.max_u (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3)))
+  (func (export "i8x16.avgr_u_with_const_20") (param v128) (result v128) (i8x16.avgr_u (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.avgr_u_with_const_21") (param v128) (result v128) (i8x16.avgr_u (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3)))
+)
+
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)
+                                     (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)
+                                     (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                     (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)
+                                     (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                     (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)
+                                     (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                      (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                      (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)
+                                      (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1))
+                                      (v128.const i8x16 0 0 0 0 128 128 128 128 128 128 128 128 255 255 255 255))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                      (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                      (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                      (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                      (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                      (v128.const i8x16 192 192 192 192 192 192 192 192 192 192 192 192 192 192 192 192))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                      (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                      (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                      (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                      (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)
+                                      (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                      (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                      (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                      (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                   (v128.const i8x16 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                   (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                   (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3))
+                                   (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                      (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                      (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                      (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                      (v128.const i8x16 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3))
+                                      (v128.const i8x16 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+
+;; Const vs const
+(assert_return (invoke "i8x16.min_s_with_const_0") (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_s_with_const_1") (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i8x16.min_u_with_const_2") (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_u_with_const_3") (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i8x16.max_s_with_const_4") (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_s_with_const_5") (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3))
+(assert_return (invoke "i8x16.max_u_with_const_6") (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_u_with_const_7") (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3))
+(assert_return (invoke "i8x16.avgr_u_with_const_8") (v128.const i8x16 192 192 192 192 96 96 96 96 96 96 96 96 192 192 192 192))
+(assert_return (invoke "i8x16.avgr_u_with_const_9") (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.abs_with_const_10") (v128.const i8x16 128 128 128 128 127 127 127 127 64 64 64 64 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt_with_const_11") (v128.const i8x16 1 1 1 1 7 7 7 7 1 1 1 1 8 8 8 8))
+
+;; Param vs const
+(assert_return (invoke "i8x16.min_s_with_const_12" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                                   (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_s_with_const_13" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i8x16.min_u_with_const_14" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                                   (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_u_with_const_15" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i8x16.max_s_with_const_16" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                                   (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_s_with_const_17" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))
+                                                   (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3))
+(assert_return (invoke "i8x16.max_u_with_const_18" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                                   (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_u_with_const_19" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))
+                                                   (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3))
+(assert_return (invoke "i8x16.avgr_u_with_const_20" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                                    (v128.const i8x16 192 192 192 192 96 96 96 96 96 96 96 96 192 192 192 192))
+(assert_return (invoke "i8x16.avgr_u_with_const_21" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))
+                                                    (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+
+;; Test different lanes go through different if-then clauses
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)
+                                     (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                     (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128)
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128))
+                                     (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 128 128 128 128))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)
+                                     (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                     (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128)
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128))
+                                     (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 128 128 128 128))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)
+                                     (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                     (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128)
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128))
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 2 2 2 2 128 128 128 128))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)
+                                     (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                     (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128)
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128))
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 2 2 2 2 128 128 128 128))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)
+                                      (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                      (v128.const i8x16 192 192 192 192 96 96 96 96 96 96 96 96 192 192 192 192))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128)
+                                      (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128))
+                                      (v128.const i8x16 0 0 0 0 2 2 2 2 2 2 2 2 128 128 128 128))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255))
+                                   (v128.const i8x16 128 128 128 128 127 127 127 127 64 64 64 64 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255))
+                                      (v128.const i8x16 1 1 1 1 7 7 7 7 1 1 1 1 8 8 8 8))
+
+;; Test opposite signs of zero
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)
+                                     (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)
+                                     (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)
+                                     (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)
+                                     (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)
+                                      (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)
+                                      (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                   (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                   (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+                                   (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                   (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; Unknown operators
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.avgr (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.avgr_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+
+;; Type check
+(assert_invalid (module (func (result v128) (i8x16.min_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.min_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.max_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.max_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.avgr_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.abs (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.popcnt (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.min_s-1st-arg-empty (result v128)
+      (i8x16.min_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.min_s-arg-empty (result v128)
+      (i8x16.min_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.min_u-1st-arg-empty (result v128)
+      (i8x16.min_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.min_u-arg-empty (result v128)
+      (i8x16.min_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.max_s-1st-arg-empty (result v128)
+      (i8x16.max_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.max_s-arg-empty (result v128)
+      (i8x16.max_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.max_u-1st-arg-empty (result v128)
+      (i8x16.max_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.max_u-arg-empty (result v128)
+      (i8x16.max_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.avgr_u-1st-arg-empty (result v128)
+      (i8x16.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.avgr_u-arg-empty (result v128)
+      (i8x16.avgr_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.abs-arg-empty (result v128)
+      (i8x16.abs)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.popcnt-arg-empty (result v128)
+      (i8x16.popcnt)
+    )
+  )
+  "type mismatch"
+)
+
+;; Combination
+(module
+  (func (export "i8x16.min_s-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_s-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_s-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_s-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_s-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_s-i8x16.abs") (param v128 v128) (result v128) (i8x16.min_s (i8x16.abs (local.get 0))(local.get 1)))
+  (func (export "i8x16.abs-i8x16.min_s") (param v128 v128) (result v128) (i8x16.abs (i8x16.min_s (local.get 0) (local.get 1))))
+  (func (export "i8x16.min_s-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.min_s (i8x16.popcnt (local.get 0))(local.get 1)))
+  (func (export "i8x16.popcnt-i8x16.min_s") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.min_s (local.get 0) (local.get 1))))
+  (func (export "i8x16.min_u-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_u-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_u-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_u-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_u-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_u-i8x16.abs") (param v128 v128) (result v128) (i8x16.min_u (i8x16.abs (local.get 0))(local.get 1)))
+  (func (export "i8x16.abs-i8x16.min_u") (param v128 v128) (result v128) (i8x16.abs (i8x16.min_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.min_u-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.min_u (i8x16.popcnt (local.get 0))(local.get 1)))
+  (func (export "i8x16.popcnt-i8x16.min_u") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.min_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.max_s-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_s-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_s-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_s-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_s-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_s-i8x16.abs") (param v128 v128) (result v128) (i8x16.max_s (i8x16.abs (local.get 0))(local.get 1)))
+  (func (export "i8x16.abs-i8x16.max_s") (param v128 v128) (result v128) (i8x16.abs (i8x16.max_s (local.get 0) (local.get 1))))
+  (func (export "i8x16.max_s-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.max_s (i8x16.popcnt (local.get 0))(local.get 1)))
+  (func (export "i8x16.popcnt-i8x16.max_s") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.max_s (local.get 0) (local.get 1))))
+  (func (export "i8x16.max_u-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_u-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_u-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_u-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_u-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_u-i8x16.abs") (param v128 v128) (result v128) (i8x16.max_u (i8x16.abs (local.get 0))(local.get 1)))
+  (func (export "i8x16.abs-i8x16.max_u") (param v128 v128) (result v128) (i8x16.abs (i8x16.max_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.max_u-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.max_u (i8x16.popcnt (local.get 0))(local.get 1)))
+  (func (export "i8x16.popcnt-i8x16.max_u") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.max_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.avgr_u-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.avgr_u-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.avgr_u-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.avgr_u-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.avgr_u-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.avgr_u-i8x16.abs") (param v128 v128) (result v128) (i8x16.avgr_u (i8x16.abs (local.get 0))(local.get 1)))
+  (func (export "i8x16.abs-i8x16.avgr_u") (param v128 v128) (result v128) (i8x16.abs (i8x16.avgr_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.avgr_u-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.avgr_u (i8x16.popcnt (local.get 0))(local.get 1)))
+  (func (export "i8x16.popcnt-i8x16.avgr_u") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.avgr_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.abs-i8x16.popcnt") (param v128) (result v128) (i8x16.abs (i8x16.popcnt (local.get 0))))
+  (func (export "i8x16.abs-i8x16.abs") (param v128) (result v128) (i8x16.abs (i8x16.abs (local.get 0))))
+  (func (export "i8x16.popcnt-i8x16.popcnt") (param v128) (result v128) (i8x16.popcnt (i8x16.popcnt (local.get 0))))
+  (func (export "i8x16.popcnt-i8x16.abs") (param v128) (result v128) (i8x16.popcnt (i8x16.abs (local.get 0))))
+)
+
+(assert_return (invoke "i8x16.min_s-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_s-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_s-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_s-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_s-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_s-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.abs-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                               (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_s-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.popcnt-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.min_u-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_u-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_u-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_u-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.abs-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                               (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.popcnt-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_s-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_s-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_s-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_s-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_s-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_s-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                               (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                               (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_s-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.popcnt-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_u-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_u-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_u-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_u-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_u-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_u-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                               (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                               (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.max_u-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.popcnt-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.avgr_u-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.avgr_u-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.avgr_u-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.avgr_u-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.avgr_u-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.avgr_u-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.avgr_u-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4))
+(assert_return (invoke "i8x16.popcnt-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.abs-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
diff --git a/tests/wast/spec/simd_i8x16_cmp.wast b/tests/wast/spec/simd_i8x16_cmp.wast
new file mode 100644
index 0000000000..8683accea4
--- /dev/null
+++ b/tests/wast/spec/simd_i8x16_cmp.wast
@@ -0,0 +1,1847 @@
+
+;; Test all the i8x16 comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) (i8x16.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) (i8x16.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x v128) (param $y v128) (result v128) (i8x16.lt_s (local.get $x) (local.get $y)))
+  (func (export "lt_u") (param $x v128) (param $y v128) (result v128) (i8x16.lt_u (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x v128) (param $y v128) (result v128) (i8x16.le_s (local.get $x) (local.get $y)))
+  (func (export "le_u") (param $x v128) (param $y v128) (result v128) (i8x16.le_u (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x v128) (param $y v128) (result v128) (i8x16.gt_s (local.get $x) (local.get $y)))
+  (func (export "gt_u") (param $x v128) (param $y v128) (result v128) (i8x16.gt_u (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x v128) (param $y v128) (result v128) (i8x16.ge_s (local.get $x) (local.get $y)))
+  (func (export "ge_u") (param $x v128) (param $y v128) (result v128) (i8x16.ge_u (local.get $x) (local.get $y)))
+)
+
+
+;; eq
+
+;; i8x16.eq  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                            (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                            (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                            (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                            (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                            (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "eq" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "eq" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                            (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                            (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                            (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                            (v128.const i8x16 0 0 0 0 0 0 0 -1 -1 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                            (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                            (v128.const i8x16 0 0 0 0 0 0 0 -1 -1 0 0 0 0 0 0 0))
+
+;; i8x16.eq  (i8x16) (i16x8)
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                            (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                            (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                            (v128.const i8x16 -1 0 -1 0 -1 -1 -1 -1 -1 0 -1 0 -1 0 -1 0))
+(assert_return (invoke "eq" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                            (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; i8x16.eq  (i8x16) (i32x4)
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                            (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                            (v128.const i32x4 -128 0 1 255))
+                            (v128.const i8x16 -1 0 0 0 -1 -1 -1 -1 -1 0 0 0 -1 0 0 0))
+(assert_return (invoke "eq" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                            (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; ne
+
+;; i8x16.ne  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                            (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                            (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                            (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                            (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                            (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "ne" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "ne" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                            (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                            (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                            (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 0 0 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                            (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 0 0 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.ne (i8x16) (i16x8)
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                            (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                            (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                            (v128.const i8x16 0 -1 0 -1 0 0 0 0 0 -1 0 -1 0 -1 0 -1))
+(assert_return (invoke "ne" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                            (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.ne  (i8x16) (i32x4)
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                            (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                            (v128.const i32x4 -128 0 1 255))
+                            (v128.const i8x16 0 -1 -1 -1 0 0 0 0 0 -1 -1 -1 0 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                            (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; lt_s
+
+;; i8x16.lt_s  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 0 -1 0 -1 0 0 0 -1 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 -1 -1 -1 0 0 0 0 0 -1 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 -1 -1 -1 0 0 0 0 0 -1 0 0 0))
+
+;; i8x16.lt_s  (i8x16) (i16x8)
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 0 -1 0 -1 0 0 0 0 0 0 0 0 0 -1 0 -1))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; i8x16.lt_s  (i8x16) (i32x4)
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 0 -1 -1 -1 0 0 0 0 0 0 0 0 0 -1 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; lt_u
+
+;; i8x16.lt_u  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 0 -1 0 -1 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 0 0 0 -1 -1 -1 -1 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 0 0 0 -1 -1 -1 -1 0 0 0))
+
+;; i8x16.lt_u  (i8x16) (i16x8)
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 0 -1 0 -1 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.lt_u  (i8x16) (i32x4)
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 0 -1 -1 -1 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; le_s
+
+;; i8x16.le_s  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 0 -1 0 -1 0 0 0 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 -1 -1 -1 -1 -1 0 0 0 -1 0 0 0))
+(assert_return (invoke "le_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 -1 -1 -1 -1 -1 0 0 0 -1 0 0 0))
+
+;; i8x16.le_s  (i8x16) (i16x8)
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 -1 0 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; i8x16.le_s  (i8x16) (i32x4)
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; le_u
+
+;; i8x16.le_u  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 0 -1 0 -1 0 0 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 0 -1 -1 -1 -1 -1 -1 0 0 0))
+(assert_return (invoke "le_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 0 -1 -1 -1 -1 -1 -1 0 0 0))
+
+;; i8x16.le_u  (i8x16) (i16x8)
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 -1 0 -1 0 -1 0))
+(assert_return (invoke "le_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.le_u  (i8x16) (i32x4)
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 -1 0 0 0))
+(assert_return (invoke "le_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; gt_s
+
+;; i8x16.gt_s  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 -1 0 -1 0 -1 -1 -1 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 0 0 0 0 0 -1 -1 -1 0 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 0 0 0 0 0 -1 -1 -1 0 -1 -1 -1))
+
+;; i8x16.gt_s  (i8x16) (i16x8)
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 -1 0 -1 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.gt_s  (i8x16) (i32x4)
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; gt_u
+
+;; i8x16.gt_u  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 -1 0 -1 0 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 -1 0 0 0 0 0 0 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 -1 0 0 0 0 0 0 -1 -1 -1))
+
+;; i8x16.gt_u  (i8x16) (i16x8)
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 -1 0 -1 0 -1 0 -1))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; i8x16.gt_u  (i8x16) (i32x4)
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 -1 -1 -1 0 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; ge_s
+
+;; i8x16.ge_s  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 -1 0 -1 0 -1 -1 -1 0 0 0))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 0 0 0 -1 -1 -1 -1 -1 0 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 0 0 0 -1 -1 -1 -1 -1 0 -1 -1 -1))
+
+;; i8x16.ge_s  (i8x16) (i16x8)
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 -1 0 -1 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 -1 0))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.ge_s  (i8x16) (i32x4)
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 -1 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; ge_u
+
+;; i8x16.ge_u  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 -1 0 -1 0 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 -1 -1 -1 0 0 0 0 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 -1 -1 -1 0 0 0 0 -1 -1 -1))
+
+;; i8x16.ge_u (i8x16) (i16x8)
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 -1 0 -1 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; i8x16.ge_u (i8x16) (i32x4)
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 -1 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (i8x16.eq (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.ge_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.ge_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.gt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.gt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.le_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.le_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.lt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+
+
+;; combination
+
+(module (memory 1)
+  (func (export "eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "lt_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.lt_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "le_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.le_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "gt_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.gt_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ge_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.ge_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-eq")
+    (drop
+      (i8x16.eq
+        (i8x16.eq
+          (i8x16.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.eq
+          (i8x16.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ne")
+    (drop
+      (i8x16.ne
+        (i8x16.ne
+          (i8x16.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.ne
+          (i8x16.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-lt_s")
+    (drop
+      (i8x16.lt_s
+        (i8x16.lt_s
+          (i8x16.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.lt_s
+          (i8x16.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-le_u")
+    (drop
+      (i8x16.le_u
+        (i8x16.le_u
+          (i8x16.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.le_u
+          (i8x16.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-gt_u")
+    (drop
+      (i8x16.gt_u
+        (i8x16.gt_u
+          (i8x16.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.gt_u
+          (i8x16.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ge_s")
+    (drop
+      (i8x16.ge_s
+        (i8x16.ge_s
+          (i8x16.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.ge_s
+          (i8x16.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (i8x16.ge_u
+        (i8x16.eq
+          (i8x16.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.ne
+          (i8x16.gt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.lt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+(assert_return (invoke "eq-in-block"))
+(assert_return (invoke "ne-in-block"))
+(assert_return (invoke "lt_s-in-block"))
+(assert_return (invoke "le_u-in-block"))
+(assert_return (invoke "gt_u-in-block"))
+(assert_return (invoke "ge_s-in-block"))
+(assert_return (invoke "nested-eq"))
+(assert_return (invoke "nested-ne"))
+(assert_return (invoke "nested-lt_s"))
+(assert_return (invoke "nested-le_u"))
+(assert_return (invoke "nested-gt_u"))
+(assert_return (invoke "nested-ge_s"))
+(assert_return (invoke "as-param"))
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.eq-1st-arg-empty (result v128)
+      (i8x16.eq (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.eq-arg-empty (result v128)
+      (i8x16.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ne-1st-arg-empty (result v128)
+      (i8x16.ne (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ne-arg-empty (result v128)
+      (i8x16.ne)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.lt_s-1st-arg-empty (result v128)
+      (i8x16.lt_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.lt_s-arg-empty (result v128)
+      (i8x16.lt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.lt_u-1st-arg-empty (result v128)
+      (i8x16.lt_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.lt_u-arg-empty (result v128)
+      (i8x16.lt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.le_s-1st-arg-empty (result v128)
+      (i8x16.le_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.le_s-arg-empty (result v128)
+      (i8x16.le_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.le_u-1st-arg-empty (result v128)
+      (i8x16.le_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.le_u-arg-empty (result v128)
+      (i8x16.le_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.gt_s-1st-arg-empty (result v128)
+      (i8x16.gt_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.gt_s-arg-empty (result v128)
+      (i8x16.gt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.gt_u-1st-arg-empty (result v128)
+      (i8x16.gt_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.gt_u-arg-empty (result v128)
+      (i8x16.gt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ge_s-1st-arg-empty (result v128)
+      (i8x16.ge_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ge_s-arg-empty (result v128)
+      (i8x16.ge_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ge_u-1st-arg-empty (result v128)
+      (i8x16.ge_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ge_u-arg-empty (result v128)
+      (i8x16.ge_u)
+    )
+  )
+  "type mismatch"
+)
\ No newline at end of file
diff --git a/tests/wast/spec/simd_i8x16_sat_arith.wast b/tests/wast/spec/simd_i8x16_sat_arith.wast
new file mode 100644
index 0000000000..a799a8b739
--- /dev/null
+++ b/tests/wast/spec/simd_i8x16_sat_arith.wast
@@ -0,0 +1,718 @@
+;; Tests for i8x16 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i8x16.add_sat_s") (param v128 v128) (result v128) (i8x16.add_sat_s (local.get 0) (local.get 1)))
+  (func (export "i8x16.add_sat_u") (param v128 v128) (result v128) (i8x16.add_sat_u (local.get 0) (local.get 1)))
+  (func (export "i8x16.sub_sat_s") (param v128 v128) (result v128) (i8x16.sub_sat_s (local.get 0) (local.get 1)))
+  (func (export "i8x16.sub_sat_u") (param v128 v128) (result v128) (i8x16.sub_sat_u (local.get 0) (local.get 1)))
+)
+
+
+;; i8x16.add_sat_s
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i8x16 0x01 0x01 0x81 0x7f 0x01 0x01 0x81 0x7f 0x01 0x01 0x81 0x7f 0x01 0x01 0x81 0x7f))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i8x16 0x01 0x01 0x81 0 0x01 0x01 0x81 0 0x01 0x01 0x81 0 0x01 0x01 0x81 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i8x16 0x01 0x01 0xc1 0x7f 0x01 0x01 0xc1 0x7f 0x01 0x01 0xc1 0x7f 0x01 0x01 0xc1 0x7f))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i8x16 0x01 0x01 0xc1 0 0x01 0x01 0xc1 0 0x01 0x01 0xc1 0 0x01 0x01 0xc1 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                         (v128.const i8x16 0 3 6 9 12 15 18 21 24 27 30 33 36 39 42 45))
+
+;; i8x16.add_sat_u
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 129 129 129 129 129 129 129 129 129 129 129 129 129 129 129 129))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                         (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i8x16 0x80 0x80 0x80 0xff 0x80 0x80 0x80 0xff 0x80 0x80 0x80 0xff 0x80 0x80 0x80 0xff))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i8x16 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i8x16 0x01 0x01 0x81 0xff 0x01 0x01 0x81 0xff 0x01 0x01 0x81 0xff 0x01 0x01 0x81 0xff))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i8x16 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i8x16 0x01 0x01 0xc1 0xff 0x01 0x01 0xc1 0xff 0x01 0x01 0xc1 0xff 0x01 0x01 0xc1 0xff))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                         (v128.const i8x16 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                         (v128.const i8x16 0 3 6 9 12 15 18 21 24 27 30 33 36 39 42 45))
+
+;; i8x16.sub_sat_s
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i8x16 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i8x16 0x01 0x01 0x7f 0x82 0x01 0x01 0x7f 0x82 0x01 0x01 0x7f 0x82 0x01 0x01 0x7f 0x82))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i8x16 0x01 0x01 0x7f 0x02 0x01 0x01 0x7f 0x02 0x01 0x01 0x7f 0x02 0x01 0x01 0x7f 0x02))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i8x16 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i8x16 0x01 0x01 0x41 0x02 0x01 0x01 0x41 0x02 0x01 0x01 0x41 0x02 0x01 0x01 0x41 0x02))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                         (v128.const i8x16 0 0x02 0x04 0x06 0x08 0x0a 0x0c 0x0e 0x10 0x12 0x14 0x16 0x18 0x1a 0x1c 0x1e))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                         (v128.const i8x16 0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15))
+
+;; i8x16.sub_sat_u
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i8x16 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i8x16 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i8x16 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i8x16 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i8x16 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; Malformed cases: non-existent op names
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.add_sat (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.sub_sat (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.mul_sat (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.div_sat (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.add_sat_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.add_sat_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.sub_sat_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.sub_sat_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (f32x4.add_sat_s (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (f32x4.add_sat_u (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (f32x4.sub_sat_s (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (f32x4.sub_sat_u (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0)))")
+    "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (i8x16.add_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.add_sat_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.sub_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.sub_sat_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.add_sat_s-1st-arg-empty (result v128)
+      (i8x16.add_sat_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.add_sat_s-arg-empty (result v128)
+      (i8x16.add_sat_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.add_sat_u-1st-arg-empty (result v128)
+      (i8x16.add_sat_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.add_sat_u-arg-empty (result v128)
+      (i8x16.add_sat_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub_sat_s-1st-arg-empty (result v128)
+      (i8x16.sub_sat_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub_sat_s-arg-empty (result v128)
+      (i8x16.sub_sat_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub_sat_u-1st-arg-empty (result v128)
+      (i8x16.sub_sat_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub_sat_u-arg-empty (result v128)
+      (i8x16.sub_sat_u)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "sat-add_s-sub_s") (param v128 v128 v128) (result v128)
+    (i8x16.add_sat_s (i8x16.sub_sat_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_s-sub_u") (param v128 v128 v128) (result v128)
+    (i8x16.add_sat_s (i8x16.sub_sat_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_u-sub_s") (param v128 v128 v128) (result v128)
+    (i8x16.add_sat_u (i8x16.sub_sat_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_u-sub_u") (param v128 v128 v128) (result v128)
+    (i8x16.add_sat_u (i8x16.sub_sat_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_s-neg") (param v128 v128) (result v128)
+    (i8x16.add_sat_s (i8x16.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-add_u-neg") (param v128 v128) (result v128)
+    (i8x16.add_sat_u (i8x16.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-sub_s-neg") (param v128 v128) (result v128)
+    (i8x16.sub_sat_s (i8x16.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-sub_u-neg") (param v128 v128) (result v128)
+    (i8x16.sub_sat_u (i8x16.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "sat-add_s-sub_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "sat-add_s-sub_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "sat-add_u-sub_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254))
+(assert_return (invoke "sat-add_u-sub_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "sat-add_s-neg" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                       (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                       (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "sat-add_u-neg" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                       (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                       (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "sat-sub_s-neg" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                       (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                       (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "sat-sub_u-neg" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                       (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                       (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
\ No newline at end of file
diff --git a/tests/wast/spec/simd_int_to_int_extend.wast b/tests/wast/spec/simd_int_to_int_extend.wast
new file mode 100644
index 0000000000..be8d554ca5
--- /dev/null
+++ b/tests/wast/spec/simd_int_to_int_extend.wast
@@ -0,0 +1,599 @@
+;; Tests for int-to-int extension operations.
+
+(module
+  (func (export "i16x8.extend_high_i8x16_s") (param v128) (result v128) (i16x8.extend_high_i8x16_s (local.get 0)))
+  (func (export "i16x8.extend_high_i8x16_u") (param v128) (result v128) (i16x8.extend_high_i8x16_u (local.get 0)))
+  (func (export "i16x8.extend_low_i8x16_s") (param v128) (result v128) (i16x8.extend_low_i8x16_s (local.get 0)))
+  (func (export "i16x8.extend_low_i8x16_u") (param v128) (result v128) (i16x8.extend_low_i8x16_u (local.get 0)))
+  (func (export "i32x4.extend_high_i16x8_s") (param v128) (result v128) (i32x4.extend_high_i16x8_s (local.get 0)))
+  (func (export "i32x4.extend_high_i16x8_u") (param v128) (result v128) (i32x4.extend_high_i16x8_u (local.get 0)))
+  (func (export "i32x4.extend_low_i16x8_s") (param v128) (result v128) (i32x4.extend_low_i16x8_s (local.get 0)))
+  (func (export "i32x4.extend_low_i16x8_u") (param v128) (result v128) (i32x4.extend_low_i16x8_u (local.get 0)))
+  (func (export "i64x2.extend_high_i32x4_s") (param v128) (result v128) (i64x2.extend_high_i32x4_s (local.get 0)))
+  (func (export "i64x2.extend_high_i32x4_u") (param v128) (result v128) (i64x2.extend_high_i32x4_u (local.get 0)))
+  (func (export "i64x2.extend_low_i32x4_s") (param v128) (result v128) (i64x2.extend_low_i32x4_s (local.get 0)))
+  (func (export "i64x2.extend_low_i32x4_u") (param v128) (result v128) (i64x2.extend_low_i32x4_u (local.get 0)))
+)
+
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 126 126 126 126 126 126 126 126))
+                                                   (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                   (v128.const i16x8 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 126 126 126 126 126 126 126 126))
+                                                   (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                   (v128.const i16x8 129 129 129 129 129 129 129 129))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 126 126 126 126 126 126 126 126))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                  (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 126 126 126 126 126 126 126 126))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 129 129 129 129 129 129 129 129))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 0 0 0 0 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 1 1 1 1 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 1 1 1 1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32766 32766 32766 32766))
+                                                   (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32767 -32767 -32767 -32767))
+                                                   (v128.const i32x4 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 -32768 -32768 -32768 -32768))
+
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 0 0 0 0 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 1 1 1 1 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 1 1 1 1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32766 32766 32766 32766))
+                                                   (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 -1 -1 -1 -1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32767 -32767 -32767 -32767))
+                                                   (v128.const i32x4 32769 32769 32769 32769))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -1 -1 -1 -1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 0 0 0 0 1 1 1 1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 1 1 1 1 0 0 0 0))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 1 1 1 1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 1 1 1 1))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32767 32767 32767 32767))
+                                                  (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32766 32766 32766 32766))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 32767 32767 32767 32767))
+                                                  (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 32767 32767 32767 32767))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32767 -32767 -32767 -32767))
+                                                  (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 0 0 0 0 1 1 1 1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 1 1 1 1 0 0 0 0))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 1 1 1 1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 1 1 1 1))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32767 32767 32767 32767))
+                                                  (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32766 32766 32766 32766))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 32767 32767 32767 32767))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 32767 32767 32767 32767))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 32769 32769 32769 32769))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32767 -32767 -32767 -32767))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 0 0 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 0 0 -1 -1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 1 1 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -1 -1 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 1 1 -1 -1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -1 -1 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483646 2147483646 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483646 2147483646))
+                                                   (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 -2147483648 -2147483648))
+                                                   (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 -1 -1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -1 -1 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483647 -2147483647 -2147483648 -2147483648))
+                                                   (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483647 -2147483647))
+                                                   (v128.const i64x2 -2147483647 -2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -1 -1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -1 -1 -2147483648 -2147483648))
+                                                   (v128.const i64x2 -2147483648 -2147483648))
+
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 0 0 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 0 0 -1 -1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 1 1 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -1 -1 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 1 1 -1 -1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -1 -1 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483646 2147483646 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483646 2147483646))
+                                                   (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 -2147483648 -2147483648))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 -1 -1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -1 -1 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483647 -2147483647 -2147483648 -2147483648))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483647 -2147483647))
+                                                   (v128.const i64x2 2147483649 2147483649))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -1 -1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -1 -1 -2147483648 -2147483648))
+                                                   (v128.const i64x2 2147483648 2147483648))
+
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 0 0 1 1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 0 0 -1 -1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 1 1 0 0))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -1 -1 0 0))
+                                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 1 1 -1 -1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -1 -1 1 1))
+                                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483646 2147483646 2147483647 2147483647))
+                                                  (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483646 2147483646))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 -2147483648 -2147483648))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 2147483647 2147483647))
+                                                  (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 -1 -1))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -1 -1 2147483647 2147483647))
+                                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483647 -2147483647 -2147483648 -2147483648))
+                                                  (v128.const i64x2 -2147483647 -2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483647 -2147483647))
+                                                  (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -1 -1))
+                                                  (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -1 -1 -2147483648 -2147483648))
+                                                  (v128.const i64x2 -1 -1))
+
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 0 0 1 1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 0 0 -1 -1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 1 1 0 0))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -1 -1 0 0))
+                                                  (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 1 1 -1 -1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -1 -1 1 1))
+                                                  (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483646 2147483646 2147483647 2147483647))
+                                                  (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483646 2147483646))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 -2147483648 -2147483648))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 2147483647 2147483647))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 -1 -1))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -1 -1 2147483647 2147483647))
+                                                  (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483647 -2147483647 -2147483648 -2147483648))
+                                                  (v128.const i64x2 2147483649 2147483649))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483647 -2147483647))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -1 -1))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -1 -1 -2147483648 -2147483648))
+                                                  (v128.const i64x2 4294967295 4294967295))
+
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.extend_high_i8x16_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extend_high_i8x16_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extend_low_i8x16_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extend_low_i8x16_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extend_high_i16x8_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extend_high_i16x8_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extend_low_i16x8_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extend_low_i16x8_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extend_high_i32x4_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extend_high_i32x4_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extend_low_i32x4_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extend_low_i32x4_u (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.extend_high_i8x16_s-arg-empty (result v128)
+      (i16x8.extend_high_i8x16_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extend_high_i8x16_u-arg-empty (result v128)
+      (i16x8.extend_high_i8x16_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extend_low_i8x16_s-arg-empty (result v128)
+      (i16x8.extend_low_i8x16_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extend_low_i8x16_u-arg-empty (result v128)
+      (i16x8.extend_low_i8x16_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extend_high_i16x8_s-arg-empty (result v128)
+      (i32x4.extend_high_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extend_high_i16x8_u-arg-empty (result v128)
+      (i32x4.extend_high_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extend_low_i16x8_s-arg-empty (result v128)
+      (i32x4.extend_low_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extend_low_i16x8_u-arg-empty (result v128)
+      (i32x4.extend_low_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extend_high_i32x4_s-arg-empty (result v128)
+      (i64x2.extend_high_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extend_high_i32x4_u-arg-empty (result v128)
+      (i64x2.extend_high_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extend_low_i32x4_s-arg-empty (result v128)
+      (i64x2.extend_low_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extend_low_i32x4_u-arg-empty (result v128)
+      (i64x2.extend_low_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/tests/wast/spec/simd_lane.wast b/tests/wast/spec/simd_lane.wast
new file mode 100644
index 0000000000..9b66f53b1a
--- /dev/null
+++ b/tests/wast/spec/simd_lane.wast
@@ -0,0 +1,1265 @@
+;; Tests for the extract_lane, replace_lane, swizzle and shuffle group instructions
+
+
+(module
+  (func (export "i8x16_extract_lane_s-first") (param v128) (result i32)
+    (i8x16.extract_lane_s 0 (local.get 0)))
+  (func (export "i8x16_extract_lane_s-last") (param v128) (result i32)
+    (i8x16.extract_lane_s 15 (local.get 0)))
+  (func (export "i8x16_extract_lane_u-first") (param v128) (result i32)
+    (i8x16.extract_lane_u 0 (local.get 0)))
+  (func (export "i8x16_extract_lane_u-last") (param v128) (result i32)
+    (i8x16.extract_lane_u 15 (local.get 0)))
+  (func (export "i16x8_extract_lane_s-first") (param v128) (result i32)
+    (i16x8.extract_lane_s 0 (local.get 0)))
+  (func (export "i16x8_extract_lane_s-last") (param v128) (result i32)
+    (i16x8.extract_lane_s 7 (local.get 0)))
+  (func (export "i16x8_extract_lane_u-first") (param v128) (result i32)
+    (i16x8.extract_lane_u 0 (local.get 0)))
+  (func (export "i16x8_extract_lane_u-last") (param v128) (result i32)
+    (i16x8.extract_lane_u 7 (local.get 0)))
+  (func (export "i32x4_extract_lane-first") (param v128) (result i32)
+    (i32x4.extract_lane 0 (local.get 0)))
+  (func (export "i32x4_extract_lane-last") (param v128) (result i32)
+    (i32x4.extract_lane 3 (local.get 0)))
+  (func (export "f32x4_extract_lane-first") (param v128) (result f32)
+    (f32x4.extract_lane 0 (local.get 0)))
+  (func (export "f32x4_extract_lane-last") (param v128) (result f32)
+    (f32x4.extract_lane 3 (local.get 0)))
+  (func (export "i8x16_replace_lane-first") (param v128 i32) (result v128)
+    (i8x16.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "i8x16_replace_lane-last") (param v128 i32) (result v128)
+    (i8x16.replace_lane 15 (local.get 0) (local.get 1)))
+  (func (export "i16x8_replace_lane-first") (param v128 i32) (result v128)
+    (i16x8.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "i16x8_replace_lane-last") (param v128 i32) (result v128)
+    (i16x8.replace_lane 7 (local.get 0) (local.get 1)))
+  (func (export "i32x4_replace_lane-first") (param v128 i32) (result v128)
+    (i32x4.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "i32x4_replace_lane-last") (param v128 i32) (result v128)
+    (i32x4.replace_lane 3 (local.get 0) (local.get 1)))
+  (func (export "f32x4_replace_lane-first") (param v128 f32) (result v128)
+    (f32x4.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "f32x4_replace_lane-last") (param v128 f32) (result v128)
+    (f32x4.replace_lane 3 (local.get 0) (local.get 1)))
+  (func (export "i64x2_extract_lane-first") (param v128) (result i64)
+    (i64x2.extract_lane 0 (local.get 0)))
+  (func (export "i64x2_extract_lane-last") (param v128) (result i64)
+    (i64x2.extract_lane 1 (local.get 0)))
+  (func (export "f64x2_extract_lane-first") (param v128) (result f64)
+    (f64x2.extract_lane 0 (local.get 0)))
+  (func (export "f64x2_extract_lane-last") (param v128) (result f64)
+    (f64x2.extract_lane 1 (local.get 0)))
+  (func (export "i64x2_replace_lane-first") (param v128 i64) (result v128)
+    (i64x2.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "i64x2_replace_lane-last") (param v128 i64) (result v128)
+    (i64x2.replace_lane 1 (local.get 0) (local.get 1)))
+  (func (export "f64x2_replace_lane-first") (param v128 f64) (result v128)
+    (f64x2.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "f64x2_replace_lane-last") (param v128 f64) (result v128)
+    (f64x2.replace_lane 1 (local.get 0) (local.get 1)))
+
+  ;; Swizzle and shuffle
+  (func (export "v8x16_swizzle") (param v128 v128) (result v128)
+    (i8x16.swizzle (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-1") (param v128 v128) (result v128)
+    (i8x16.shuffle  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-2") (param v128 v128) (result v128)
+    (i8x16.shuffle 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-3") (param v128 v128) (result v128)
+    (i8x16.shuffle 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-4") (param v128 v128) (result v128)
+    (i8x16.shuffle 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-5") (param v128 v128) (result v128)
+    (i8x16.shuffle  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-6") (param v128 v128) (result v128)
+    (i8x16.shuffle 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-7") (param v128 v128) (result v128)
+    (i8x16.shuffle  0  0  0  0  0  0  0  0 16 16 16 16 16 16 16 16 (local.get 0) (local.get 1)))
+)
+
+(assert_return (invoke "i8x16_extract_lane_s-first" (v128.const i8x16 127 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 127))
+(assert_return (invoke "i8x16_extract_lane_s-first" (v128.const i8x16 0x7f 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 127))
+(assert_return (invoke "i8x16_extract_lane_s-first" (v128.const i8x16 255 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const -1))
+(assert_return (invoke "i8x16_extract_lane_s-first" (v128.const i8x16 0xff 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const -1))
+(assert_return (invoke "i8x16_extract_lane_u-first" (v128.const i8x16 255 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 255))
+(assert_return (invoke "i8x16_extract_lane_u-first" (v128.const i8x16 0xff 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 255))
+(assert_return (invoke "i8x16_extract_lane_s-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -128)) (i32.const -128))
+(assert_return (invoke "i8x16_extract_lane_s-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0x80)) (i32.const -128))
+(assert_return (invoke "i8x16_extract_lane_u-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1)) (i32.const 255))
+(assert_return (invoke "i8x16_extract_lane_u-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0xff)) (i32.const 255))
+(assert_return (invoke "i8x16_extract_lane_u-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -128)) (i32.const 128))
+(assert_return (invoke "i8x16_extract_lane_u-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0x80)) (i32.const 128))
+
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 32767 0 0 0 0 0 0 0)) (i32.const 32767))
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 0x7fff 0 0 0 0 0 0 0)) (i32.const 32767))
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 65535 0 0 0 0 0 0 0)) (i32.const -1))
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 0xffff 0 0 0 0 0 0 0)) (i32.const -1))
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 012_345 0 0 0 0 0 0 0)) (i32.const 12345))
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 -0x0_1234 0 0 0 0 0 0 0)) (i32.const -0x1234))
+(assert_return (invoke "i16x8_extract_lane_u-first" (v128.const i16x8 65535 0 0 0 0 0 0 0)) (i32.const 65535))
+(assert_return (invoke "i16x8_extract_lane_u-first" (v128.const i16x8 0xffff 0 0 0 0 0 0 0)) (i32.const 65535))
+(assert_return (invoke "i16x8_extract_lane_u-first" (v128.const i16x8 012_345 0 0 0 0 0 0 0)) (i32.const 12345))
+(assert_return (invoke "i16x8_extract_lane_u-first" (v128.const i16x8 -0x0_1234 0 0 0 0 0 0 0)) (i32.const 60876))
+(assert_return (invoke "i16x8_extract_lane_s-last" (v128.const i16x8 0 0 0 0 0 0 0 -32768)) (i32.const -32768))
+(assert_return (invoke "i16x8_extract_lane_s-last" (v128.const i16x8 0 0 0 0 0 0 0 0x8000)) (i32.const -32768))
+(assert_return (invoke "i16x8_extract_lane_s-last" (v128.const i16x8 0 0 0 0 0 0 0 06_789)) (i32.const 6789))
+(assert_return (invoke "i16x8_extract_lane_s-last" (v128.const i16x8 0 0 0 0 0 0 0 -0x0_6789)) (i32.const -0x6789))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 -1)) (i32.const 65535))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 0xffff)) (i32.const 65535))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 -32768)) (i32.const 32768))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 0x8000)) (i32.const 32768))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 06_789)) (i32.const 6789))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 -0x0_6789)) (i32.const 39031))
+
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 2147483647 0 0 0)) (i32.const 2147483647))
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 0x7fffffff 0 0 0)) (i32.const 2147483647))
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 4294967295 0 0 0)) (i32.const -1))
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 0xffffffff 0 0 0)) (i32.const -1))
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 01_234_567_890 0 0 0)) (i32.const 1234567890))
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 -0x0_1234_5678 0 0 0)) (i32.const -0x12345678))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 -2147483648)) (i32.const -2147483648))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 0x80000000)) (i32.const -2147483648))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 -1)) (i32.const -1))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 0xffffffff)) (i32.const -1))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 0_987_654_321)) (i32.const 987654321))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 -0x0_1234_5678)) (i32.const -0x12345678))
+
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 9223372036854775807 0)) (i64.const 9223372036854775807))
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 0x7ffffffffffffffe 0)) (i64.const 0x7ffffffffffffffe))
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 18446744073709551615 0)) (i64.const -1))
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 0xffffffffffffffff 0)) (i64.const -1))
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 01_234_567_890_123_456_789 0)) (i64.const 1234567890123456789))
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 0x0_1234_5678_90AB_cdef 0)) (i64.const 0x1234567890abcdef))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 9223372036854775808)) (i64.const -9223372036854775808))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 0x8000000000000000)) (i64.const -0x8000000000000000))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 0x8000000000000000)) (i64.const 0x8000000000000000))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0x7f)) (i64.const 9223372036854775807))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0x8000)) (i64.const -9223372036854775808))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i32x4 0 0 0xffffffff 0x7fffffff)) (i64.const 9223372036854775807))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const f64x2 -inf +inf)) (i64.const 0x7ff0000000000000))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 01_234_567_890_123_456_789)) (i64.const 1234567890123456789))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 0x0_1234_5678_90AB_cdef)) (i64.const 0x1234567890abcdef))
+
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 -5.0 0.0 0.0 0.0)) (f32.const -5.0))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 1e38 0.0 0.0 0.0)) (f32.const 1e38))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 0x1.fffffep127 0.0 0.0 0.0)) (f32.const 0x1.fffffep127))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 0x1p127 0.0 0.0 0.0)) (f32.const 0x1p127))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 inf 0.0 0.0 0.0)) (f32.const inf))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 nan inf 0.0 0.0)) (f32.const nan))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 0123456789.0123456789e+019 0.0 0.0 0.0)) (f32.const 123456789.0123456789e+019))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0.0 0.0 0.0)) (f32.const 0x123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 -1e38)) (f32.const -1e38))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 -0x1.fffffep127)) (f32.const -0x1.fffffep127))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 -0x1p127)) (f32.const -0x1p127))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 -inf)) (f32.const -inf))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 -inf nan)) (f32.const nan))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 0123456789.)) (f32.const 123456789.0))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 0x0123456789ABCDEF.)) (f32.const 0x123456789ABCDEF.0p0))
+
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -1.5 0.0)) (f64.const -1.5))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 1.5 0.0)) (f64.const 1.5))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -1.7976931348623157e-308 0x0p+0)) (f64.const -1.7976931348623157e-308))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 1.7976931348623157e-308 0x0p-0)) (f64.const 1.7976931348623157e-308))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -0x1.fffffffffffffp-1023 0x0p+0)) (f64.const -0x1.fffffffffffffp-1023))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 0x1.fffffffffffffp-1023 0x0p-0)) (f64.const 0x1.fffffffffffffp-1023))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -inf 0.0)) (f64.const -inf))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 inf 0.0)) (f64.const inf))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -nan -0.0)) (f64.const -nan))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 nan 0.0)) (f64.const nan))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 0123456789.0123456789e+019 0.0)) (f64.const 123456789.0123456789e+019))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0.0)) (f64.const 0x123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 2.25)) (f64.const 2.25))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 -2.25)) (f64.const -2.25))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0x0p-0 -1.7976931348623157e+308)) (f64.const -1.7976931348623157e+308))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0x0p+0 1.7976931348623157e+308)) (f64.const 1.7976931348623157e+308))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0x0p-0 -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0x0p+0 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 -0.0 -inf)) (f64.const -inf))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 inf)) (f64.const inf))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 -0.0 -nan)) (f64.const -nan))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 nan)) (f64.const nan))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 0123456789.)) (f64.const 123456789.0))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 0x0123456789ABCDEFabcdef.)) (f64.const 0x123456789ABCDEFabcdef.0))
+
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (f64.const 0.0))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0x80)) (f64.const -0.0))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0x4000)) (f64.const 2.0))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0xc000)) (f64.const -2.0))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i32x4 0 0 0xffffffff 0x7fefffff)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i32x4 0 0 0 0x00100000)) (f64.const 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i32x4 0 0 0xffffffff 0x000fffff)) (f64.const 0x1.ffffffffffffep-1023))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i32x4 0 0 1 0)) (f64.const 0x0.0000000000002p-1023))
+
+(assert_return (invoke "i8x16_replace_lane-first" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 127)) (v128.const i8x16 127 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16_replace_lane-first" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 128)) (v128.const i8x16 -128 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16_replace_lane-first" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 255)) (v128.const i8x16 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16_replace_lane-first" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 256)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16_replace_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const -128)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -128))
+(assert_return (invoke "i8x16_replace_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const -129)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127))
+(assert_return (invoke "i8x16_replace_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 32767)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0xff))
+(assert_return (invoke "i8x16_replace_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const -32768)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 32767)) (v128.const i16x8 32767 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 32768)) (v128.const i16x8 -32768 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 65535)) (v128.const i16x8 -1 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 65536)) (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 012345)) (v128.const i16x8 012_345 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const -0x01234)) (v128.const i16x8 -0x0_1234 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const -32768)) (v128.const i16x8 0 0 0 0 0 0 0 -32768))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const -32769)) (v128.const i16x8 0 0 0 0 0 0 0 32767))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 0x7fffffff)) (v128.const i16x8 0 0 0 0 0 0 0 0xffff))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 0x80000000)) (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 054321)) (v128.const i16x8 0 0 0 0 0 0 0 054_321))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const -0x04321)) (v128.const i16x8 0 0 0 0 0 0 0 -0x0_4321))
+
+(assert_return (invoke "i32x4_replace_lane-first" (v128.const i32x4 0 0 0 0) (i32.const 2147483647)) (v128.const i32x4 2147483647 0 0 0))
+(assert_return (invoke "i32x4_replace_lane-first" (v128.const i32x4 0 0 0 0) (i32.const 4294967295)) (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "i32x4_replace_lane-first" (v128.const i32x4 0 0 0 0) (i32.const 01234567890)) (v128.const i32x4 01_234_567_890 0 0 0))
+(assert_return (invoke "i32x4_replace_lane-first" (v128.const i32x4 0 0 0 0) (i32.const -0x012345678)) (v128.const i32x4 -0x0_1234_5678 0 0 0))
+(assert_return (invoke "i32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (i32.const 2147483648)) (v128.const i32x4 0 0 0 2147483648))
+(assert_return (invoke "i32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (i32.const -2147483648)) (v128.const i32x4 0 0 0 -2147483648))
+(assert_return (invoke "i32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (i32.const 01234567890)) (v128.const i32x4 0 0 0 01_234_567_890))
+(assert_return (invoke "i32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (i32.const -0x012345678)) (v128.const i32x4 0 0 0 -0x0_1234_5678))
+
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 53.0)) (v128.const f32x4 53.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const i32x4 0 0 0 0 ) (f32.const 53.0)) (v128.const f32x4 53.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const nan)) (v128.const f32x4 nan 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const inf)) (v128.const f32x4 inf 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 nan 0.0 0.0 0.0) (f32.const 3.14)) (v128.const f32x4 3.14 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 inf 0.0 0.0 0.0) (f32.const 1e38)) (v128.const f32x4 1e38 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 inf 0.0 0.0 0.0) (f32.const 0x1.fffffep127)) (v128.const f32x4 0x1.fffffep127 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 inf 0.0 0.0 0.0) (f32.const 0x1p127)) (v128.const f32x4 0x1p127 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0123456789)) (v128.const f32x4 0123456789 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0123456789.)) (v128.const f32x4 0123456789. 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0x0123456789ABCDEF)) (v128.const f32x4 0x0123456789ABCDEF 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0x0123456789ABCDEF.)) (v128.const f32x4 0x0123456789ABCDEF. 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const -53.0)) (v128.const f32x4 0.0 0.0 0.0 -53.0))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (f32.const -53.0)) (v128.const f32x4 0.0 0.0 0.0 -53.0))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const nan)) (v128.const f32x4 0.0 0.0 0.0 nan))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const -inf)) (v128.const f32x4 0.0 0.0 0.0 -inf))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 nan) (f32.const 3.14)) (v128.const f32x4 0.0 0.0 0.0 3.14))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 -inf) (f32.const -1e38)) (v128.const f32x4 0.0 0.0 0.0 -1e38))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 -inf) (f32.const -0x1.fffffep127)) (v128.const f32x4 0.0 0.0 0.0 -0x1.fffffep127))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 -inf) (f32.const -0x1p127)) (v128.const f32x4 0.0 0.0 0.0 -0x1p127))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0123456789e019)) (v128.const f32x4 0.0 0.0 0.0 0123456789e019))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0123456789.e+019)) (v128.const f32x4 0.0 0.0 0.0 0123456789.e+019))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0x0123456789ABCDEFp019)) (v128.const f32x4 0.0 0.0 0.0 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0x0123456789ABCDEF.p-019)) (v128.const f32x4 0.0 0.0 0.0 0x0123456789ABCDEF.p-019))
+
+(assert_return (invoke "i64x2_replace_lane-first" (v128.const i64x2 0 0) (i64.const 9223372036854775807)) (v128.const i64x2 9223372036854775807 0))
+(assert_return (invoke "i64x2_replace_lane-first" (v128.const i64x2 0 0) (i64.const 18446744073709551615)) (v128.const i64x2 -1 0))
+(assert_return (invoke "i64x2_replace_lane-first" (v128.const i64x2 0 0) (i64.const 01234567890123456789)) (v128.const i64x2 01_234_567_890_123_456_789 0))
+(assert_return (invoke "i64x2_replace_lane-first" (v128.const i64x2 0 0) (i64.const 0x01234567890abcdef)) (v128.const i64x2 0x0_1234_5678_90AB_cdef 0))
+(assert_return (invoke "i64x2_replace_lane-last" (v128.const i64x2 0 0) (i64.const 9223372036854775808)) (v128.const i64x2 0 9223372036854775808))
+(assert_return (invoke "i64x2_replace_lane-last" (v128.const i64x2 0 0) (i64.const 9223372036854775808)) (v128.const i64x2 0 -9223372036854775808))
+(assert_return (invoke "i64x2_replace_lane-last" (v128.const i64x2 0 0) (i64.const 01234567890123456789)) (v128.const i64x2 0 01_234_567_890_123_456_789))
+(assert_return (invoke "i64x2_replace_lane-last" (v128.const i64x2 0 0) (i64.const 0x01234567890abcdef)) (v128.const i64x2 0 0x0_1234_5678_90AB_cdef))
+
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 1.0 1.0) (f64.const 0x0p+0)) (v128.const f64x2 0.0 1.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 -1.0 -1.0) (f64.const -0x0p-0)) (v128.const f64x2 -0.0 -1.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 1.25)) (v128.const f64x2 1.25 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const -1.25)) (v128.const f64x2 -1.25 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 -nan 0.0) (f64.const -1.7976931348623157e+308)) (v128.const f64x2 -1.7976931348623157e+308 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 nan 0.0) (f64.const 1.7976931348623157e+308)) (v128.const f64x2 1.7976931348623157e+308 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 -inf 0.0) (f64.const -0x1.fffffffffffffp-1023)) (v128.const f64x2 -0x1.fffffffffffffp-1023 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 inf 0.0) (f64.const 0x1.fffffffffffffp-1023)) (v128.const f64x2 0x1.fffffffffffffp-1023 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const -nan)) (v128.const f64x2 -nan 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const nan)) (v128.const f64x2 nan 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const -inf)) (v128.const f64x2 -inf 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const inf)) (v128.const f64x2 inf 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 0123456789)) (v128.const f64x2 0123456789 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 0123456789.)) (v128.const f64x2 0123456789. 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 0x0123456789ABCDEFabcdef)) (v128.const f64x2 0x0123456789ABCDEFabcdef 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 0x0123456789ABCDEFabcdef.)) (v128.const f64x2 0x0123456789ABCDEFabcdef. 0.0))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 2.0 2.0) (f64.const 0.0)) (v128.const f64x2 2.0 0.0))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 -2.0 -2.0) (f64.const -0.0)) (v128.const f64x2 -2.0 -0.0))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 2.25)) (v128.const f64x2 0.0 2.25))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const -2.25)) (v128.const f64x2 0.0 -2.25))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 -nan) (f64.const -1.7976931348623157e+308)) (v128.const f64x2 0.0 -1.7976931348623157e+308))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 nan) (f64.const 1.7976931348623157e+308)) (v128.const f64x2 0.0 1.7976931348623157e+308))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 -inf) (f64.const -0x1.fffffffffffffp-1023)) (v128.const f64x2 0.0 -0x1.fffffffffffffp-1023))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 inf) (f64.const 0x1.fffffffffffffp-1023)) (v128.const f64x2 0.0 0x1.fffffffffffffp-1023))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const -nan)) (v128.const f64x2 0.0 -nan))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const nan)) (v128.const f64x2 0.0 nan))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const -inf)) (v128.const f64x2 0.0 -inf))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const inf)) (v128.const f64x2 0.0 inf))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 0123456789e019)) (v128.const f64x2 0.0 0123456789e019))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 0123456789e+019)) (v128.const f64x2 0.0 0123456789e+019))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 0123456789.e019)) (v128.const f64x2 0.0 0123456789.e019))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 0123456789.e-019)) (v128.const f64x2 0.0 0123456789.e-019))
+
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+  (v128.const i8x16  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15))
+  (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16  -8  -7  -6  -5  -4  -3  -2 -1 16 17 18 19 20 21 22 23))
+  (v128.const i8x16   0   0   0   0   0   0   0  0  0  0  0  0  0  0  0  0))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115)
+  (v128.const i8x16  15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0))
+  (v128.const i8x16 115 114 113 112 111 110 109 108 107 106 105 104 103 102 101 100))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115)
+  (v128.const i8x16  -1   1  -2   2  -3   3  -4   4  -5   5  -6   6  -7   7  -8   8))
+  (v128.const i8x16   0 101   0 102   0 103   0 104   0 105   0 106   0 107   0 108))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115)
+  (v128.const i8x16   9  16  10  17  11  18  12  19  13  20  14  21  15  22  16  23))
+  (v128.const i8x16 109   0 110   0 111   0 112   0 113   0 114   0 115   0   0   0))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 0x64 0x65 0x66 0x67 0x68 0x69 0x6a 0x6b 0x6c 0x6d 0x6e 0x6f 0x70 0x71 0x72 0x73)
+  (v128.const i8x16    9   16   10   17  11    18   12   19  13    20   14   21   15   22   16   23))
+  (v128.const i8x16 0x6d    0 0x6e    0 0x6f    0 0x70    0 0x71    0 0x72    0 0x73    0    0    0))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i16x8 0x6465 0x6667 0x6869 0x6a6b 0x6c6d 0x6e6f 0x7071 0x7273)
+  (v128.const i8x16 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15))
+  (v128.const i16x8 0x6465 0x6667 0x6869 0x6a6b 0x6c6d 0x6e6f 0x7071 0x7273))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i32x4 0x64656667 0x68696a6b 0x6c6d6e6f 0x70717273)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0))
+  (v128.const i32x4 0x73727170 0x6f6e6d6c 0x6b6a6968 0x67666564))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const f32x4 nan -nan inf -inf)
+  (v128.const i8x16 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15))
+  (v128.const i32x4 0x7fc00000 0xffc00000 0x7f800000 0xff800000))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i32x4 0x67666564 0x6b6a6968 0x6f6e6d5c 0x73727170)
+  (v128.const f32x4 0.0 -0.0 inf -inf))
+  (v128.const i32x4 0x64646464 0x00646464 0x00006464 0x00006464))
+
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+  (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31))
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "v8x16_shuffle-2"
+  (v128.const i8x16   0   1   2   3   4   5   6  7  8  9 10 11 12 13 14 15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1))
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1))
+(assert_return (invoke "v8x16_shuffle-3"
+  (v128.const i8x16   0   1   2   3   4   5   6  7  8   9  10  11  12  13  14  15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8  -7  -6  -5  -4  -3  -2  -1))
+  (v128.const i8x16  -1  -2  -3  -4  -5  -6  -7 -8 -9 -10 -11 -12 -13 -14 -15 -16))
+(assert_return (invoke "v8x16_shuffle-4"
+  (v128.const i8x16   0   1   2   3   4   5   6  7  8  9 10 11 12 13 14 15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1))
+  (v128.const i8x16  15  14  13  12  11  10   9  8  7  6  5  4  3  2  1  0))
+(assert_return (invoke "v8x16_shuffle-5"
+  (v128.const i8x16   0   1   2   3   4   5   6  7  8  9 10 11 12 13 14 15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1))
+  (v128.const i8x16   0   0   0   0   0   0   0  0  0  0  0  0  0  0  0  0))
+(assert_return (invoke "v8x16_shuffle-6"
+  (v128.const i8x16   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10  -9  -8  -7  -6  -5  -4  -3  -2  -1))
+  (v128.const i8x16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16))
+(assert_return (invoke "v8x16_shuffle-7"
+  (v128.const i8x16   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10  -9  -8  -7  -6  -5  -4  -3  -2  -1))
+  (v128.const i8x16   0   0   0   0   0   0   0   0 -16 -16 -16 -16 -16 -16 -16 -16))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i8x16 0x64 0x65 0x66 0x67 0x68 0x69 0x6a 0x6b 0x6c 0x6d 0x6e 0x6f 0x70 0x71 0x72 0x73)
+  (v128.const i8x16 0xf0 0xf1 0xf2 0xf3 0xf4 0xf5 0xf6 0xf7 0xf8 0xf9 0xfa 0xfb 0xfc 0xfd 0xfe 0xff))
+  (v128.const i8x16 0x64 0x65 0x66 0x67 0x68 0x69 0x6a 0x6b 0x6c 0x6d 0x6e 0x6f 0x70 0x71 0x72 0x73))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0b0a 0x0d0c 0x0f0e)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10  -9  -8  -7  -6  -5  -4  -3  -2  -1))
+  (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0b0a 0x0d0c 0x0f0e))
+(assert_return (invoke "v8x16_shuffle-2"
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+  (v128.const i32x4 0xf3f2f1f0 0xf7f6f5f4 0xfbfaf9f8 0xfffefdfc))
+  (v128.const i32x4 0xf3f2f1f0 0xf7f6f5f4 0xfbfaf9f8 0xfffefdfc))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i32x4 0x10203 0x4050607 0x8090a0b 0xc0d0e0f)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+  (v128.const i32x4 0x10203 0x4050607 0x8090a0b 0xc0d0e0f))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const f32x4 1.0 nan inf -inf)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+  (v128.const i32x4 0x3f800000 0x7fc00000 0x7f800000 0xff800000))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i32x4 0x10203 0x4050607 0x8090a0b 0xc0d0e0f)
+  (v128.const f32x4 -0.0 nan inf -inf))
+  (v128.const i32x4 0x10203 0x4050607 0x8090a0b 0xc0d0e0f))
+
+;; More literals
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i32x4 1_234_567_890 0x1234_5678 01_234_567_890 0x0_1234_5678)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+  (v128.const i32x4 0x4996_02d2 0x1234_5678 0x4996_02d2 0x1234_5678))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i64x2 1_234_567_890_123_456_789_0 0x1234_5678_90AB_cdef)
+  (v128.const i64x2 01_234_567_890_123_456_789_0 0x0_1234_5678_90AB_cdef))
+  (v128.const i32x4 0xeb1f_0ad2 0xab54_a98c 0x90ab_cdef 0x1234_5678))
+
+;; Syntax errors for negative values
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_s  -1 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_u  -1 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_s  -1 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_u  -1 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane  -1 (v128.const i32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result f32) (f32x4.extract_lane  -1 (v128.const f32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i8x16.replace_lane  -1 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i16x8.replace_lane  -1 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i32x4.replace_lane  -1 (v128.const i32x4 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (f32x4.replace_lane  -1 (v128.const f32x4 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result i64) (i64x2.extract_lane  -1 (v128.const i64x2 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result f64) (f64x2.extract_lane  -1 (v128.const f64x2 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i64x2.replace_lane  -1 (v128.const i64x2 0 0) (i64.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (f64x2.replace_lane  -1 (v128.const f64x2 0 0) (f64.const 1)))") "unexpected token")
+
+;; Malformed lane index value
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_s 256 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_u 256 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_s 256 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_u 256 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane 256 (v128.const i32x4 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result f32) (f32x4.extract_lane 256 (v128.const f32x4 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (i8x16.replace_lane 256 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (i16x8.replace_lane 256 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (i32x4.replace_lane 256 (v128.const i32x4 0 0 0 0) (i32.const 1)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (f32x4.replace_lane 256 (v128.const f32x4 0 0 0 0) (i32.const 1)))") "malformed lane index")
+(assert_malformed (module quote "(func (result i64) (i64x2.extract_lane 256 (v128.const i64x2 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result f64) (f64x2.extract_lane 256 (v128.const f64x2 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (i64x2.replace_lane 256 (v128.const i64x2 0 0) (i64.const 1)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (f64x2.replace_lane 256 (v128.const f64x2 0 0) (f64.const 1)))") "malformed lane index")
+
+;; Invalid lane index value
+
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_s 16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_s 255 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_u 16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_u 255 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_s 8 (v128.const i16x8 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_s 255 (v128.const i16x8 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_u 8 (v128.const i16x8 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_u 255 (v128.const i16x8 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i32x4.extract_lane 4 (v128.const i32x4 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i32x4.extract_lane 255 (v128.const i32x4 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result f32) (f32x4.extract_lane 4 (v128.const f32x4 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result f32) (f32x4.extract_lane 255 (v128.const f32x4 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i8x16.replace_lane 16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i8x16.replace_lane 255 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i16x8.replace_lane 16 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i16x8.replace_lane 255 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 4 (v128.const i32x4 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 255 (v128.const i32x4 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 4 (v128.const f32x4 0 0 0 0) (f32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 255 (v128.const f32x4 0 0 0 0) (f32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result i64) (i64x2.extract_lane 2 (v128.const i64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i64) (i64x2.extract_lane 255 (v128.const i64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result f64) (f64x2.extract_lane 2 (v128.const f64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result f64) (f64x2.extract_lane 255 (v128.const f64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i64x2.replace_lane 2 (v128.const i64x2 0 0) (i64.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i64x2.replace_lane 255 (v128.const i64x2 0 0) (i64.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f64x2.replace_lane 2 (v128.const f64x2 0 0) (f64.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f64x2.replace_lane 255 (v128.const f64x2 0 0) (f64.const 1.0)))) "invalid lane index")
+
+;; Lane index is determined by the instruction's interpretation only.
+
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_s 8 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_u 8 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i32x4.extract_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (f32x4.extract_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i16x8.replace_lane 8 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (f32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result i64) (i64x2.extract_lane 2 (v128.const i64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result f64) (f64x2.extract_lane 2 (v128.const f64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i64x2.replace_lane 2 (v128.const i64x2 0 0) (i64.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f64x2.replace_lane 2 (v128.const f64x2 0 0) (f64.const 1.0)))) "invalid lane index")
+
+;; Invalid parameters: required v128 but pass other types
+
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_s 0 (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_u 0 (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_s 0 (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_u 0 (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32x4.extract_lane 0 (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32x4.extract_lane 0 (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.replace_lane 0 (i32.const 0) (i32.const 1)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.replace_lane 0 (i64.const 0) (i32.const 1)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 0 (i32.const 0) (i32.const 1)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 0 (f32.const 0.0) (i32.const 1)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64x2.extract_lane 0 (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64x2.extract_lane 0 (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 0 (i32.const 0) (i32.const 1)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 0 (f32.const 0.0) (i32.const 1)))) "type mismatch")
+
+;; Invalid types for the replaced value
+
+(assert_invalid (module (func (result v128) (i8x16.replace_lane 0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (f32.const 1.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.replace_lane 0 (v128.const i16x8 0 0 0 0 0 0 0 0) (f64.const 1.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 0 (v128.const i32x4 0 0 0 0) (f32.const 1.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 0 (v128.const f32x4 0 0 0 0) (i32.const 1)))) "type mismatch")
+
+(assert_invalid (module (func (result v128) (i64x2.replace_lane 0 (v128.const i64x2 0 0) (f64.const 1.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.replace_lane 0 (v128.const f64x2 0 0) (i64.const 1)))) "type mismatch")
+
+;; Invalid types for swizzle and shuffle values
+(assert_invalid (module (func (result v128)
+  (i8x16.swizzle (i32.const 1) (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)))) "type mismatch")
+(assert_invalid (module (func (result v128)
+  (i8x16.swizzle (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) (i32.const 2)))) "type mismatch")
+(assert_invalid (module (func (result v128)
+  (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (f32.const 3.0)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)))) "type mismatch")
+(assert_invalid (module (func (result v128)
+  (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) (f32.const 4.0)))) "type mismatch")
+
+;; i8x16.shuffle: the 1st argument must be 16-byte literals in 0..32
+(assert_malformed (module quote "(func (param v128) (result v128)"
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 (local.get 0) (local.get 0)))")
+  "invalid lane length")
+(assert_malformed (module quote "(func (param v128) (result v128)"
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 (local.get 0) (local.get 0)))")
+  "invalid lane length")
+(assert_malformed (module quote "(func (result v128)"
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 -1"
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)"
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128)"
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 256"
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)"
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_invalid (module (func (result v128)
+  (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 255
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))) "invalid lane index")
+
+;; Possible wrong instruction names that'd be used
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane 0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane 0 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane_s 0 (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane_u 0 (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(func (result i32) (i64x2.extract_lane_s 0 (v128.const i64x2 0 0)))") "unknown operator")
+(assert_malformed (module quote "(func (result i32) (i64x2.extract_lane_u 0 (v128.const i64x2 0 0)))") "unknown operator")
+
+
+;; Old shuffle instruction names will not work
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle1 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)))")
+  "unknown operator")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle2_imm  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)))")
+  "unknown operator")
+;; i8x16 not v8x16
+(assert_malformed (module quote "(func (result v128) "
+  "(v8x16.swizzle (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)))")
+  "unknown operator")
+(assert_malformed (module quote "(func (result v128) "
+  "(v8x16.shuffle  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)))")
+  "unknown operator")
+
+
+;; Malformed lane index
+
+;; Pass params as the lane index
+
+(assert_malformed (module quote "(func (param i32) (result i32) (i8x16.extract_lane_s (local.get 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result i32) (i8x16.extract_lane_u (local.get 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result i32) (i16x8.extract_lane_s (local.get 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result i32) (i16x8.extract_lane_u (local.get 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result i32) (i32x4.extract_lane (local.get 0) (v128.const i32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result f32) (f32x4.extract_lane (local.get 0) (v128.const f32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (i8x16.replace_lane (local.get 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (i16x8.replace_lane (local.get 0) (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (i32x4.replace_lane (local.get 0) (v128.const i32x4 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (f32x4.replace_lane (local.get 0) (v128.const f32x4 0 0 0 0) (f32.const 1.0)))") "unexpected token")
+
+(assert_malformed (module quote "(func (param i32) (result i64) (i64x2.extract_lane (local.get 0) (v128.const i64x2 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result f64) (f64x2.extract_lane (local.get 0) (v128.const f64x2 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (i64x2.replace_lane (local.get 0) (v128.const i64x2 0 0) (i64.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (f64x2.replace_lane (local.get 0) (v128.const f64x2 0 0) (f64.const 1.0)))") "unexpected token")
+
+;; Pass non-literal as the lane index
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_s 1.5 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_u nan (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_s inf (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_u -inf (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane nan (v128.const i32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result f32) (f32x4.extract_lane nan (v128.const f32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i8x16.replace_lane -2.5 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i16x8.replace_lane nan (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i32x4.replace_lane inf (v128.const i32x4 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (f32x4.replace_lane -inf (v128.const f32x4 0 0 0 0) (f32.const 1.1)))") "unexpected token")
+
+;; i8x16.shuffle expects a 16-byte literals as first argument
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "invalid lane length")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15.0) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle 0.5 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle -inf 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 inf) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle nan 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+
+
+;; Combination with each other
+
+(module
+  ;; as *.replace_lane's operand
+  (func (export "i8x16_extract_lane_s") (param v128 v128) (result v128)
+    (i8x16.replace_lane 0 (local.get 0) (i8x16.extract_lane_s 0 (local.get 1))))
+  (func (export "i8x16_extract_lane_u") (param v128 v128) (result v128)
+    (i8x16.replace_lane 0 (local.get 0) (i8x16.extract_lane_u 0 (local.get 1))))
+  (func (export "i16x8_extract_lane_s") (param v128 v128) (result v128)
+    (i16x8.replace_lane 0 (local.get 0) (i16x8.extract_lane_s 0 (local.get 1))))
+  (func (export "i16x8_extract_lane_u") (param v128 v128) (result v128)
+    (i16x8.replace_lane 0 (local.get 0) (i16x8.extract_lane_u 0 (local.get 1))))
+  (func (export "i32x4_extract_lane") (param v128 v128) (result v128)
+    (i32x4.replace_lane 0 (local.get 0) (i32x4.extract_lane 0 (local.get 1))))
+  (func (export "f32x4_extract_lane") (param v128 v128) (result v128)
+    (i32x4.replace_lane 0 (local.get 0) (i32x4.extract_lane 0 (local.get 1))))
+  (func (export "i64x2_extract_lane") (param v128 v128) (result v128)
+    (i64x2.replace_lane 0 (local.get 0) (i64x2.extract_lane 0 (local.get 1))))
+  (func (export "f64x2_extract_lane") (param v128 v128) (result v128)
+    (f64x2.replace_lane 0 (local.get 0) (f64x2.extract_lane 0 (local.get 1))))
+
+  ;; as *.extract_lane's operand
+  (func (export "i8x16_replace_lane-s") (param v128 i32) (result i32)
+    (i8x16.extract_lane_s 15 (i8x16.replace_lane 15 (local.get 0) (local.get 1))))
+  (func (export "i8x16_replace_lane-u") (param v128 i32) (result i32)
+    (i8x16.extract_lane_u 15 (i8x16.replace_lane 15 (local.get 0) (local.get 1))))
+  (func (export "i16x8_replace_lane-s") (param v128 i32) (result i32)
+    (i16x8.extract_lane_s 7 (i16x8.replace_lane 7 (local.get 0) (local.get 1))))
+  (func (export "i16x8_replace_lane-u") (param v128 i32) (result i32)
+    (i16x8.extract_lane_u 7 (i16x8.replace_lane 7 (local.get 0) (local.get 1))))
+  (func (export "i32x4_replace_lane") (param v128 i32) (result i32)
+    (i32x4.extract_lane 3 (i32x4.replace_lane 3 (local.get 0) (local.get 1))))
+  (func (export "f32x4_replace_lane") (param v128 f32) (result f32)
+    (f32x4.extract_lane 3 (f32x4.replace_lane 3 (local.get 0) (local.get 1))))
+  (func (export "i64x2_replace_lane") (param v128 i64) (result i64)
+    (i64x2.extract_lane 1 (i64x2.replace_lane 1 (local.get 0) (local.get 1))))
+  (func (export "f64x2_replace_lane") (param v128 f64) (result f64)
+    (f64x2.extract_lane 1 (f64x2.replace_lane 1 (local.get 0) (local.get 1))))
+
+  ;; i8x16.replace outputs as shuffle operand
+  (func (export "as-v8x16_swizzle-operand") (param v128 i32 v128) (result v128)
+    (i8x16.swizzle (i8x16.replace_lane 0 (local.get 0) (local.get 1)) (local.get 2)))
+  (func (export "as-v8x16_shuffle-operands") (param v128 i32 v128 i32) (result v128)
+    (i8x16.shuffle 16 1 18 3 20 5 22 7 24 9 26 11 28 13 30 15
+      (i8x16.replace_lane 0 (local.get 0) (local.get 1))
+      (i8x16.replace_lane 15 (local.get 2) (local.get 3))))
+)
+
+(assert_return (invoke "i8x16_extract_lane_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) (v128.const i8x16 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16_extract_lane_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) (v128.const i8x16 255 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_extract_lane_s" (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) (v128.const i16x8 -1 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_extract_lane_u" (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) (v128.const i16x8 65535 0 0 0 0 0 0 0))
+(assert_return (invoke "i32x4_extract_lane" (v128.const i32x4 0 0 0 0) (v128.const i32x4 0x10000 -1 -1 -1)) (v128.const i32x4 65536 0 0 0))
+(assert_return (invoke "f32x4_extract_lane" (v128.const f32x4 0 0 0 0) (v128.const f32x4 1e38 nan nan nan)) (v128.const f32x4 1e38 0 0 0))
+(assert_return (invoke "i8x16_replace_lane-s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 255)) (i32.const -1))
+(assert_return (invoke "i8x16_replace_lane-u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 255)) (i32.const 255))
+(assert_return (invoke "i16x8_replace_lane-s" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 65535)) (i32.const -1))
+(assert_return (invoke "i16x8_replace_lane-u" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 65535)) (i32.const 65535))
+(assert_return (invoke "i32x4_replace_lane" (v128.const i32x4 0 0 0 0) (i32.const -1)) (i32.const -1))
+(assert_return (invoke "f32x4_replace_lane" (v128.const f32x4 0 0 0 0) (f32.const 1.25)) (f32.const 1.25))
+
+(assert_return (invoke "i64x2_extract_lane" (v128.const i64x2 0 0) (v128.const i64x2 0xffffffffffffffff -1)) (v128.const i64x2 0xffffffffffffffff 0))
+(assert_return (invoke "f64x2_extract_lane" (v128.const f64x2 0 0) (v128.const f64x2 1e308 nan)) (v128.const f64x2 1e308 0))
+(assert_return (invoke "i64x2_replace_lane" (v128.const i64x2 0 0) (i64.const -1)) (i64.const -1))
+(assert_return (invoke "f64x2_replace_lane" (v128.const f64x2 0 0) (f64.const 2.5)) (f64.const 2.5))
+
+(assert_return (invoke "as-v8x16_swizzle-operand"
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) (i32.const 255)
+  (v128.const i8x16 -1 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1))
+  (v128.const i8x16 0 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1))
+(assert_return (invoke "as-v8x16_shuffle-operands"
+  (v128.const i8x16 0 255 0 255 15 255 0 255 255 255 0 255 127 255 0 255) (i32.const 1)
+  (v128.const i8x16 0x55 0 0x55 0 0x55 0 0x55 0 0x55 0 0x55 0 0x55 1 0x55 -1) (i32.const 0))
+  (v128.const i8x16 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff))
+
+;; Combination with other SIMD instructions
+
+(module
+  ;; Constructing SIMD values
+  (func (export "as-i8x16_splat-operand") (param v128) (result v128)
+    (i8x16.splat (i8x16.extract_lane_s 0 (local.get 0))))
+  (func (export "as-i16x8_splat-operand") (param v128) (result v128)
+    (i16x8.splat (i16x8.extract_lane_u 0 (local.get 0))))
+  (func (export "as-i32x4_splat-operand") (param v128) (result v128)
+    (i32x4.splat (i32x4.extract_lane 0 (local.get 0))))
+  (func (export "as-f32x4_splat-operand") (param v128) (result v128)
+    (f32x4.splat (f32x4.extract_lane 0 (local.get 0))))
+  (func (export "as-i64x2_splat-operand") (param v128) (result v128)
+    (i64x2.splat (i64x2.extract_lane 0 (local.get 0))))
+  (func (export "as-f64x2_splat-operand") (param v128) (result v128)
+    (f64x2.splat (f64x2.extract_lane 0 (local.get 0))))
+
+  ;; Integer arithmetic
+  (func (export "as-i8x16_add-operands") (param v128 i32 v128 i32) (result v128)
+    (i8x16.add (i8x16.replace_lane 0 (local.get 0) (local.get 1)) (i8x16.replace_lane 15 (local.get 2) (local.get 3))))
+  (func (export "as-i16x8_add-operands") (param v128 i32 v128 i32) (result v128)
+    (i16x8.add (i16x8.replace_lane 0 (local.get 0) (local.get 1)) (i16x8.replace_lane 7 (local.get 2) (local.get 3))))
+  (func (export "as-i32x4_add-operands") (param v128 i32 v128 i32) (result v128)
+    (i32x4.add (i32x4.replace_lane 0 (local.get 0) (local.get 1)) (i32x4.replace_lane 3 (local.get 2) (local.get 3))))
+  (func (export "as-i64x2_add-operands") (param v128 i64 v128 i64) (result v128)
+    (i64x2.add (i64x2.replace_lane 0 (local.get 0) (local.get 1)) (i64x2.replace_lane 1 (local.get 2) (local.get 3))))
+
+  (func (export "swizzle-as-i8x16_add-operands") (param v128 v128 v128 v128) (result v128)
+    (i8x16.add (i8x16.swizzle (local.get 0) (local.get 1)) (i8x16.swizzle (local.get 2) (local.get 3))))
+  (func (export "shuffle-as-i8x16_sub-operands") (param v128 v128 v128 v128) (result v128)
+    (i8x16.sub (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (local.get 0) (local.get 1))
+      (i8x16.shuffle 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 (local.get 2) (local.get 3))))
+
+  ;; Boolean horizontal reductions
+  (func (export "as-i8x16_any_true-operand") (param v128 i32) (result i32)
+    (v128.any_true (i8x16.replace_lane 0 (local.get 0) (local.get 1))))
+  (func (export "as-i16x8_any_true-operand") (param v128 i32) (result i32)
+    (v128.any_true (i16x8.replace_lane 0 (local.get 0) (local.get 1))))
+  (func (export "as-i32x4_any_true-operand1") (param v128 i32) (result i32)
+    (v128.any_true (i32x4.replace_lane 0 (local.get 0) (local.get 1))))
+  (func (export "as-i32x4_any_true-operand2") (param v128 i64) (result i32)
+    (v128.any_true (i64x2.replace_lane 0 (local.get 0) (local.get 1))))
+
+  (func (export "swizzle-as-i8x16_all_true-operands") (param v128 v128) (result i32)
+    (i8x16.all_true (i8x16.swizzle (local.get 0) (local.get 1))))
+  (func (export "shuffle-as-i8x16_any_true-operands") (param v128 v128) (result i32)
+    (v128.any_true (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (local.get 0) (local.get 1))))
+)
+
+(assert_return (invoke "as-i8x16_splat-operand" (v128.const i8x16 0xff 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "as-i16x8_splat-operand" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0)) (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "as-i32x4_splat-operand" (v128.const i32x4 0x10000 0 0 0)) (v128.const i32x4 65536 65536 65536 65536))
+(assert_return (invoke "as-f32x4_splat-operand" (v128.const f32x4 3.14 nan nan nan)) (v128.const f32x4 3.14 3.14 3.14 3.14))
+(assert_return (invoke "as-i64x2_splat-operand" (v128.const i64x2 -1 0)) (v128.const i64x2 -1 -1))
+(assert_return (invoke "as-f64x2_splat-operand" (v128.const f64x2 inf nan)) (v128.const f64x2 inf inf))
+(assert_return (invoke "as-i8x16_add-operands"
+  (v128.const i8x16 0xff 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16) (i32.const 1)
+  (v128.const i8x16 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 0xff) (i32.const 1))
+  (v128.const i8x16 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17))
+(assert_return (invoke "as-i16x8_add-operands"
+  (v128.const i16x8 -1 4 9 16 25 36 49 64) (i32.const 1)
+  (v128.const i16x8 64 49 36 25 16 9 4 -1) (i32.const 1))
+  (v128.const i16x8 65 53 45 41 41 45 53 65))
+(assert_return (invoke "as-i32x4_add-operands"
+  (v128.const i32x4 -1 8 27 64) (i32.const 1) (v128.const i32x4 64 27 8 -1) (i32.const 1)) (v128.const i32x4 65 35 35 65))
+(assert_return (invoke "as-i64x2_add-operands"
+  (v128.const i64x2 -1 8) (i64.const 1) (v128.const i64x2 64 27) (i64.const 1)) (v128.const i64x2 65 9))
+
+(assert_return (invoke "swizzle-as-i8x16_add-operands"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0))
+  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "shuffle-as-i8x16_sub-operands"
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0))
+  (v128.const i8x16 -15 -13 -11 -9 -7 -5 -3 -1 1 3 5 7 9 11 13 15))
+
+(assert_return (invoke "as-i8x16_any_true-operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-i16x8_any_true-operand" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-i32x4_any_true-operand1" (v128.const i32x4 1 0 0 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-i32x4_any_true-operand2" (v128.const i64x2 1 0) (i64.const 0)) (i32.const 0))
+
+(assert_return (invoke "swizzle-as-i8x16_all_true-operands"
+  (v128.const i8x16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) (i32.const 1))
+(assert_return (invoke "swizzle-as-i8x16_all_true-operands"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 16)) (i32.const 0))
+(assert_return (invoke "shuffle-as-i8x16_any_true-operands"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) (i32.const 1))
+
+;; Load and store
+
+(module
+  (memory 1)
+  (func (export "as-v128_store-operand-1") (param v128 i32) (result v128)
+    (v128.store (i32.const 0) (i8x16.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-2") (param v128 i32) (result v128)
+    (v128.store (i32.const 0) (i16x8.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-3") (param v128 i32) (result v128)
+    (v128.store (i32.const 0) (i32x4.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-4") (param v128 f32) (result v128)
+    (v128.store (i32.const 0) (f32x4.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-5") (param v128 i64) (result v128)
+    (v128.store (i32.const 0) (i64x2.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-6") (param v128 f64) (result v128)
+    (v128.store (i32.const 0) (f64x2.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+)
+
+(assert_return (invoke "as-v128_store-operand-1" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)) (v128.const i8x16 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "as-v128_store-operand-2" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 256)) (v128.const i16x8 0x100 0 0 0 0 0 0 0))
+(assert_return (invoke "as-v128_store-operand-3" (v128.const i32x4 0 0 0 0) (i32.const 0xffffffff)) (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "as-v128_store-operand-4" (v128.const f32x4 0 0 0 0) (f32.const 3.14)) (v128.const f32x4 3.14 0 0 0))
+(assert_return (invoke "as-v128_store-operand-5" (v128.const i64x2 0 0) (i64.const 0xffffffffffffffff)) (v128.const i64x2 -1 0))
+(assert_return (invoke "as-v128_store-operand-6" (v128.const f64x2 0 0) (f64.const 3.14)) (v128.const f64x2 3.14 0))
+
+;; As the argument of wasm core ops
+
+(module
+  (global $g (mut v128) (v128.const f32x4 0.0 0.0 0.0 0.0))
+  (global $h (mut v128) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+  (func (export "as-if-condition-value") (param v128) (result i32)
+    (if (result i32) (i8x16.extract_lane_s 0 (local.get 0)) (then (i32.const 0xff)) (else (i32.const 0))))
+  (func (export "as-return-value-1") (param v128 i32) (result v128)
+    (return (i16x8.replace_lane 0 (local.get 0) (local.get 1))))
+  (func (export "as-local_set-value") (param v128) (result i32) (local i32)
+    (local.set 1 (i32x4.extract_lane 0 (local.get 0)))
+    (return (local.get 1)))
+  (func (export "as-global_set-value-1") (param v128 f32) (result v128)
+    (global.set $g (f32x4.replace_lane 0 (local.get 0) (local.get 1)))
+    (return (global.get $g)))
+
+   (func (export "as-return-value-2") (param v128 v128) (result v128)
+    (return (i8x16.swizzle (local.get 0) (local.get 1))))
+  (func (export "as-global_set-value-2") (param v128 v128) (result v128)
+    (global.set $h (i8x16.shuffle 0 1 2 3 4 5 6 7 24 25 26 27 28 29 30 31 (local.get 0) (local.get 1)))
+    (return (global.get $h)))
+
+  (func (export "as-local_set-value-1") (param v128) (result i64) (local i64)
+    (local.set 1 (i64x2.extract_lane 0 (local.get 0)))
+    (return (local.get 1)))
+  (func (export "as-global_set-value-3") (param v128 f64) (result v128)
+    (global.set $g (f64x2.replace_lane 0 (local.get 0) (local.get 1)))
+    (return (global.get $g)))
+)
+
+(assert_return (invoke "as-if-condition-value" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 0))
+(assert_return (invoke "as-return-value-1" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)) (v128.const i16x8 1 0 0 0 0 0 0 0))
+(assert_return (invoke "as-local_set-value" (v128.const i32x4 -1 -1 -1 -1)) (i32.const -1))
+(assert_return (invoke "as-global_set-value-1" (v128.const f32x4 0 0 0 0)(f32.const 3.14)) (v128.const f32x4 3.14 0 0 0))
+
+(assert_return (invoke "as-return-value-2"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0))
+  (v128.const i8x16 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15 -16))
+(assert_return (invoke "as-global_set-value-2"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1))
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 8 7 6 5 4 3 2 1))
+
+(assert_return (invoke "as-local_set-value-1" (v128.const i64x2 -1 -1)) (i64.const -1))
+(assert_return (invoke "as-global_set-value-3" (v128.const f64x2 0 0)(f64.const 3.14)) (v128.const f64x2 3.14 0))
+
+;; Non-nat lane index
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_u +0x0f (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result f32) (f32x4.extract_lane +03 (v128.const f32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i64) (i64x2.extract_lane +1 (v128.const i64x2 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i8x16.replace_lane +015 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i16x8.replace_lane +0x7 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i32x4.replace_lane +3 (v128.const i32x4 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (f64x2.replace_lane +0x01 (v128.const f64x2 0 0) (f64.const 1.0)))") "unexpected token")
+
+;; Lane index literal
+
+(module (func (result i32) (i8x16.extract_lane_s 0x0f (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))))
+(module (func (result i32) (i16x8.extract_lane_s 0x07 (v128.const i16x8 0 0 0 0 0 0 0 0))))
+(module (func (result i32) (i16x8.extract_lane_u 0x0_7 (v128.const i16x8 0 0 0 0 0 0 0 0))))
+(module (func (result i32) (i32x4.extract_lane 03 (v128.const i32x4 0 0 0 0))))
+(module (func (result f64) (f64x2.extract_lane 0x1 (v128.const f64x2 0 0))))
+(module (func (result v128) (f32x4.replace_lane 0x3 (v128.const f32x4 0 0 0 0) (f32.const 1.0))))
+(module (func (result v128) (i64x2.replace_lane 01 (v128.const i64x2 0 0) (i64.const 1))))
+
+;; 1.0 is malformed lane index
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_s 1.0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+
+;; Test operation with empty argument
+
+(assert_malformed
+  (module quote
+    "(func $i8x16.extract_lane_s-1st-arg-empty (result i32)"
+    "  (i8x16.extract_lane_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i8x16.extract_lane_s-2nd-arg-empty (result i32)
+      (i8x16.extract_lane_s 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i8x16.extract_lane_s-arg-empty (result i32)"
+    "  (i8x16.extract_lane_s)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i16x8.extract_lane_u-1st-arg-empty (result i32)"
+    "  (i16x8.extract_lane_u (v128.const i16x8 0 0 0 0 0 0 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extract_lane_u-2nd-arg-empty (result i32)
+      (i16x8.extract_lane_u 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i16x8.extract_lane_u-arg-empty (result i32)"
+    "  (i16x8.extract_lane_u)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i32x4.extract_lane-1st-arg-empty (result i32)"
+    "  (i32x4.extract_lane (v128.const i32x4 0 0 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extract_lane-2nd-arg-empty (result i32)
+      (i32x4.extract_lane 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i32x4.extract_lane-arg-empty (result i32)"
+    "  (i32x4.extract_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i64x2.extract_lane-1st-arg-empty (result i64)"
+    "  (i64x2.extract_lane (v128.const i64x2 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extract_lane-2nd-arg-empty (result i64)
+      (i64x2.extract_lane 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i64x2.extract_lane-arg-empty (result i64)"
+    "  (i64x2.extract_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $f32x4.extract_lane-1st-arg-empty (result f32)"
+    "  (f32x4.extract_lane (v128.const f32x4 0 0 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $f32x4.extract_lane-2nd-arg-empty (result f32)
+      (f32x4.extract_lane 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $f32x4.extract_lane-arg-empty (result f32)"
+    "  (f32x4.extract_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $f64x2.extract_lane-1st-arg-empty (result f64)"
+    "  (f64x2.extract_lane (v128.const f64x2 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $f64x2.extract_lane-2nd-arg-empty (result f64)
+      (f64x2.extract_lane 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $f64x2.extract_lane-arg-empty (result f64)"
+    "  (f64x2.extract_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i8x16.replace_lane-1st-arg-empty (result v128)"
+    "  (i8x16.replace_lane (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i8x16.replace_lane-2nd-arg-empty (result v128)
+      (i8x16.replace_lane 0 (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.replace_lane-3rd-arg-empty (result v128)
+      (i8x16.replace_lane 0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i8x16.replace_lane-arg-empty (result v128)"
+    "  (i8x16.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i16x8.replace_lane-1st-arg-empty (result v128)"
+    "  (i16x8.replace_lane (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i16x8.replace_lane-2nd-arg-empty (result v128)
+      (i16x8.replace_lane 0 (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.replace_lane-3rd-arg-empty (result v128)
+      (i16x8.replace_lane 0 (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i16x8.replace_lane-arg-empty (result v128)"
+    "  (i16x8.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i32x4.replace_lane-1st-arg-empty (result v128)"
+    "  (i32x4.replace_lane (v128.const i32x4 0 0 0 0) (i32.const 1))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i32x4.replace_lane-2nd-arg-empty (result v128)
+      (i32x4.replace_lane 0 (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.replace_lane-3rd-arg-empty (result v128)
+      (i32x4.replace_lane 0 (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i32x4.replace_lane-arg-empty (result v128)"
+    "  (i32x4.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $f32x4.replace_lane-1st-arg-empty (result v128)"
+    "  (f32x4.replace_lane (v128.const f32x4 0 0 0 0) (f32.const 1.0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $f32x4.replace_lane-2nd-arg-empty (result v128)
+      (f32x4.replace_lane 0 (f32.const 1.0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.replace_lane-3rd-arg-empty (result v128)
+      (f32x4.replace_lane 0 (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $f32x4.replace_lane-arg-empty (result v128)"
+    "  (f32x4.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i64x2.replace_lane-1st-arg-empty (result v128)"
+    "  (i64x2.replace_lane (v128.const i64x2 0 0) (i64.const 1))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i64x2.replace_lane-2nd-arg-empty (result v128)
+      (i64x2.replace_lane 0 (i64.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.replace_lane-3rd-arg-empty (result v128)
+      (i64x2.replace_lane 0 (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i64x2.replace_lane-arg-empty (result v128)"
+    "  (i64x2.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $f64x2.replace_lane-1st-arg-empty (result v128)"
+    "  (f64x2.replace_lane (v128.const f64x2 0 0) (f64.const 1.0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $f64x2.replace_lane-2nd-arg-empty (result v128)
+      (f64x2.replace_lane 0 (f64.const 1.0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.replace_lane-3rd-arg-empty (result v128)
+      (f64x2.replace_lane 0 (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $f64x2.replace_lane-arg-empty (result v128)"
+    "  (f64x2.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i8x16.shuffle-1st-arg-empty (result v128)"
+    "  (i8x16.shuffle"
+    "    (v128.const i8x16 0 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15)"
+    "    (v128.const i8x16 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15 16)"
+    "  )"
+    ")"
+  )
+  "invalid lane length"
+)
+(assert_invalid
+  (module
+    (func $i8x16.shuffle-2nd-arg-empty (result v128)
+      (i8x16.shuffle 0 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15
+        (v128.const i8x16 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15 16)
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i8x16.shuffle-arg-empty (result v128)"
+    "  (i8x16.shuffle)"
+    ")"
+  )
+  "invalid lane length"
+)
diff --git a/tests/wast/spec/simd_linking.wast b/tests/wast/spec/simd_linking.wast
new file mode 100644
index 0000000000..1a1d16355e
--- /dev/null
+++ b/tests/wast/spec/simd_linking.wast
@@ -0,0 +1,12 @@
+(module
+  (global (export "g-v128") v128 (v128.const i64x2 0 0))
+  (global (export "mg-v128") (mut v128) (v128.const i64x2 0 0))
+)
+(register "Mv128")
+
+(module
+  ;; TODO: Reactivate once the fix for https://bugs.chromium.org/p/v8/issues/detail?id=13732
+  ;; has made it to the downstream node.js that we use on CI.
+  ;; (import "Mv128" "g-v128" (global v128))
+  (import "Mv128" "mg-v128" (global (mut v128)))
+)
diff --git a/tests/wast/spec/simd_load.wast b/tests/wast/spec/simd_load.wast
new file mode 100644
index 0000000000..2fddd3019e
--- /dev/null
+++ b/tests/wast/spec/simd_load.wast
@@ -0,0 +1,188 @@
+;; v128.load operator with normal argument (e.g. (i8x16, i16x8 i32x4))
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "v128.load") (result v128)
+    (v128.load (i32.const 0))
+  )
+)
+
+(assert_return (invoke "v128.load") (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f))
+(assert_return (invoke "v128.load") (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0b0a 0x0d0c 0x0f0e))
+(assert_return (invoke "v128.load") (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c))
+
+
+;; v128.load operator as the argument of other SIMD instructions
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "as-i8x16_extract_lane_s-value/0") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-i8x16_extract_lane_s-value/0") (i32.const 0x00))
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "as-i8x16.eq-operand") (result v128)
+    (i8x16.eq (v128.load offset=0 (i32.const 0)) (v128.load offset=16 (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-i8x16.eq-operand") (v128.const i32x4 0xffffffff 0x00000000 0x00000000 0x00000000))
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "as-v128.not-operand") (result v128)
+    (v128.not (v128.load (i32.const 0)))
+  )
+  (func (export "as-i8x16.all_true-operand") (result i32)
+    (i8x16.all_true (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-v128.not-operand") (v128.const i32x4 0xfcfdfeff 0xf8f9fafb 0xf4f5f6f7 0xf0f1f2f3))
+(assert_return (invoke "as-i8x16.all_true-operand") (i32.const 0))
+
+(module (memory 1)
+  (data (offset (i32.const 0))  "\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA")
+  (data (offset (i32.const 16)) "\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB")
+  (data (offset (i32.const 32)) "\F0\F0\F0\F0\FF\FF\FF\FF\00\00\00\00\FF\00\FF\00")
+  (func (export "as-v128.bitselect-operand") (result v128)
+    (v128.bitselect (v128.load (i32.const 0)) (v128.load (i32.const 16)) (v128.load (i32.const 32)))
+  )
+)
+(assert_return (invoke "as-v128.bitselect-operand") (v128.const i32x4 0xabababab 0xaaaaaaaa 0xbbbbbbbb 0xbbaabbaa))
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA")
+  (func (export "as-i8x16.shl-operand") (result v128)
+    (i8x16.shl (v128.load (i32.const 0)) (i32.const 1))
+  )
+)
+(assert_return (invoke "as-i8x16.shl-operand") (v128.const i32x4 0x54545454 0x54545454 0x54545454 0x54545454)) ;; 1010 1000 << 1010 1010
+
+(module (memory 1)
+  (data (offset (i32.const 0))  "\02\00\00\00\02\00\00\00\02\00\00\00\02\00\00\00")
+  (data (offset (i32.const 16)) "\03\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00")
+  (func (export "as-add/sub-operand") (result v128)
+    ;; 2 2 2 2 + 3 3 3 3 = 5 5 5 5
+    ;; 5 5 5 5 - 3 3 3 3 = 2 2 2 2
+    (i8x16.sub
+      (i8x16.add (v128.load (i32.const 0)) (v128.load (i32.const 16)))
+      (v128.load (i32.const 16))
+    )
+  )
+)
+(assert_return (invoke "as-add/sub-operand") (v128.const i32x4 2 2 2 2))
+
+(module (memory 1)
+  (data (offset (i32.const 0))  "\00\00\00\43\00\00\80\3f\66\66\e6\3f\00\00\80\bf")  ;; 128 1.0 1.8 -1
+  (data (offset (i32.const 16)) "\00\00\00\40\00\00\00\40\00\00\00\40\00\00\00\40")  ;; 2.0 2.0 2.0 2.0
+  (func (export "as-f32x4.mul-operand") (result v128)
+    (f32x4.mul (v128.load (i32.const 0)) (v128.load (i32.const 16)))
+  )
+)
+(assert_return (invoke "as-f32x4.mul-operand") (v128.const f32x4 256 2 3.6 -2))
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff")  ;; 1111 ...
+  (func (export "as-f32x4.abs-operand") (result v128)
+    (f32x4.abs (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-f32x4.abs-operand") (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)) ;; 1111 -> 0111
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA")
+  (data (offset (i32.const 16)) "\02\00\00\00\02\00\00\00\02\00\00\00\02\00\00\00")
+  (func (export "as-f32x4.min-operand") (result v128)
+    (f32x4.min (v128.load (i32.const 0)) (v128.load offset=16 (i32.const 1)))
+  )
+)
+(assert_return (invoke "as-f32x4.min-operand") (v128.const i32x4 0xaaaaaaaa 0xaaaaaaaa 0xaaaaaaaa 0xaaaaaaaa)) ;; signed 1010 < 0010
+
+(module (memory 1)
+  (data (offset (i32.const 0))  "\00\00\00\43\00\00\80\3f\66\66\e6\3f\00\00\80\bf")  ;; 128 1.0 1.8 -1
+  (func (export "as-i32x4.trunc_sat_f32x4_s-operand") (result v128)
+    (i32x4.trunc_sat_f32x4_s (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-i32x4.trunc_sat_f32x4_s-operand") (v128.const i32x4 128 1 1 -1)) ;; 128 1.0 1.8 -1 -> 128 1 1 -1
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\02\00\00\00\02\00\00\00\02\00\00\00\02\00\00\00")
+  (func (export "as-f32x4.convert_i32x4_u-operand") (result v128)
+    (f32x4.convert_i32x4_u (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-f32x4.convert_i32x4_u-operand") (v128.const f32x4 2 2 2 2))
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\64\65\66\67\68\69\6a\6b\6c\6d\6e\6f\70\71\72\73")  ;; 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
+  (data (offset (i32.const 16)) "\0f\0e\0d\0c\0b\0a\09\08\07\06\05\04\03\02\01\00")  ;;  15  14  13  12  11  10  09  08  07  06  05  04  03  02  01  00
+  (func (export "as-i8x16.swizzle-operand") (result v128)
+    (i8x16.swizzle (v128.load (i32.const 0)) (v128.load offset=15 (i32.const 1)))
+  )
+)
+(assert_return(invoke "as-i8x16.swizzle-operand") (v128.const i8x16 115 114 113 112 111 110 109 108 107 106 105 104 103 102 101 100))
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load (i32.const 0))))
+  )
+)
+(assert_return (invoke "as-br-value") (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c))
+
+
+;; Unknown operator(e.g. v128.load8, v128.load16, v128.load32)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (local v128) (drop (v128.load8 (i32.const 0))))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (local v128) (drop (v128.load16 (i32.const 0))))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (local v128) (drop (v128.load32 (i32.const 0))))"
+  )
+  "unknown operator"
+)
+
+
+;; Type mismatched (e.g. v128.load(f32.const 0), type address empty)
+
+(assert_invalid
+  (module (memory 1) (func (local v128) (drop (v128.load (f32.const 0)))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (local v128) (block (br_if 0 (v128.load (i32.const 0))))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (local v128) (v128.load (i32.const 0))))
+  "type mismatch"
+)
+
+
+;; Type address empty
+
+(assert_invalid
+  (module (memory 1) (func (drop (v128.load (local.get 2)))))
+  "unknown local 2"
+)
+(assert_invalid
+  (module (memory 1) (func (drop (v128.load))))
+  "type mismatch"
+)
diff --git a/tests/wast/spec/simd_load16_lane.wast b/tests/wast/spec/simd_load16_lane.wast
new file mode 100644
index 0000000000..8c72a57335
--- /dev/null
+++ b/tests/wast/spec/simd_load16_lane.wast
@@ -0,0 +1,211 @@
+;; Tests for load lane operations.
+
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F")
+  (func (export "v128.load16_lane_0")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_3")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 4 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_5")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 5 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_6")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 6 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_7")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 7 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_0_offset_0")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=0 0 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_1_offset_1")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=1 1 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_2_offset_2")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=2 2 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_3_offset_3")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=3 3 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_4_offset_4")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=4 4 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_5_offset_5")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=5 5 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_6_offset_6")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=6 6 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_7_offset_7")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=7 7 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_0_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_0_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_1_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_1_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_2_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_2_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_3_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_3_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_4_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 4 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_4_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 4 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_5_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 5 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_5_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 5 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_6_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 6 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_6_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 6 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_7_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 7 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_7_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 7 (local.get $address) (local.get $x)))
+)
+
+(assert_return (invoke "v128.load16_lane_0" (i32.const 0)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 256 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_1" (i32.const 1)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 513 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_2" (i32.const 2)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 770 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_3" (i32.const 3)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 0 1027 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_4" (i32.const 4)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 0 0 1284 0 0 0))
+(assert_return (invoke "v128.load16_lane_5" (i32.const 5)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 0 0 0 1541 0 0))
+(assert_return (invoke "v128.load16_lane_6" (i32.const 6)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 0 0 0 0 1798 0))
+(assert_return (invoke "v128.load16_lane_7" (i32.const 7)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 0 0 0 0 0 2055))
+(assert_return (invoke "v128.load16_lane_0_offset_0" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 256 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_1_offset_1" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 513 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_2_offset_2" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 770 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_3_offset_3" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 0 1027 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_4_offset_4" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 0 0 1284 0 0 0))
+(assert_return (invoke "v128.load16_lane_5_offset_5" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 0 0 0 1541 0 0))
+(assert_return (invoke "v128.load16_lane_6_offset_6" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 0 0 0 0 1798 0))
+(assert_return (invoke "v128.load16_lane_7_offset_7" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 0 0 0 0 0 2055))
+(assert_return (invoke "v128.load16_lane_0_align_1" (i32.const 0)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 256 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_0_align_2" (i32.const 0)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 256 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_1_align_1" (i32.const 1)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 513 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_1_align_2" (i32.const 1)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 513 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_2_align_1" (i32.const 2)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 770 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_2_align_2" (i32.const 2)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 770 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_3_align_1" (i32.const 3)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 1027 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_3_align_2" (i32.const 3)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 1027 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_4_align_1" (i32.const 4)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 1284 0 0 0))
+(assert_return (invoke "v128.load16_lane_4_align_2" (i32.const 4)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 1284 0 0 0))
+(assert_return (invoke "v128.load16_lane_5_align_1" (i32.const 5)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 1541 0 0))
+(assert_return (invoke "v128.load16_lane_5_align_2" (i32.const 5)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 1541 0 0))
+(assert_return (invoke "v128.load16_lane_6_align_1" (i32.const 6)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 0 1798 0))
+(assert_return (invoke "v128.load16_lane_6_align_2" (i32.const 6)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 0 1798 0))
+(assert_return (invoke "v128.load16_lane_7_align_1" (i32.const 7)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 2055))
+(assert_return (invoke "v128.load16_lane_7_align_2" (i32.const 7)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 2055))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load16_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load16_lane 8 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.load16_lane align=4 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/tests/wast/spec/simd_load32_lane.wast b/tests/wast/spec/simd_load32_lane.wast
new file mode 100644
index 0000000000..e67690ff98
--- /dev/null
+++ b/tests/wast/spec/simd_load32_lane.wast
@@ -0,0 +1,143 @@
+;; Tests for load lane operations.
+
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F")
+  (func (export "v128.load32_lane_0")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_3")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_0_offset_0")
+    (param $x v128) (result v128)
+    (v128.load32_lane offset=0 0 (i32.const 0) (local.get $x)))
+  (func (export "v128.load32_lane_1_offset_1")
+    (param $x v128) (result v128)
+    (v128.load32_lane offset=1 1 (i32.const 0) (local.get $x)))
+  (func (export "v128.load32_lane_2_offset_2")
+    (param $x v128) (result v128)
+    (v128.load32_lane offset=2 2 (i32.const 0) (local.get $x)))
+  (func (export "v128.load32_lane_3_offset_3")
+    (param $x v128) (result v128)
+    (v128.load32_lane offset=3 3 (i32.const 0) (local.get $x)))
+  (func (export "v128.load32_lane_0_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=1 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_0_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=2 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_0_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=4 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_1_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=1 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_1_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=2 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_1_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=4 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_2_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=1 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_2_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=2 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_2_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=4 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_3_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=1 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_3_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=2 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_3_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=4 3 (local.get $address) (local.get $x)))
+)
+
+(assert_return (invoke "v128.load32_lane_0" (i32.const 0)
+                                            (v128.const i32x4 0 0 0 0))
+                                            (v128.const i32x4 50462976 0 0 0))
+(assert_return (invoke "v128.load32_lane_1" (i32.const 1)
+                                            (v128.const i32x4 0 0 0 0))
+                                            (v128.const i32x4 0 67305985 0 0))
+(assert_return (invoke "v128.load32_lane_2" (i32.const 2)
+                                            (v128.const i32x4 0 0 0 0))
+                                            (v128.const i32x4 0 0 84148994 0))
+(assert_return (invoke "v128.load32_lane_3" (i32.const 3)
+                                            (v128.const i32x4 0 0 0 0))
+                                            (v128.const i32x4 0 0 0 100992003))
+(assert_return (invoke "v128.load32_lane_0_offset_0" (v128.const i32x4 0 0 0 0))
+                                                     (v128.const i32x4 50462976 0 0 0))
+(assert_return (invoke "v128.load32_lane_1_offset_1" (v128.const i32x4 0 0 0 0))
+                                                     (v128.const i32x4 0 67305985 0 0))
+(assert_return (invoke "v128.load32_lane_2_offset_2" (v128.const i32x4 0 0 0 0))
+                                                     (v128.const i32x4 0 0 84148994 0))
+(assert_return (invoke "v128.load32_lane_3_offset_3" (v128.const i32x4 0 0 0 0))
+                                                     (v128.const i32x4 0 0 0 100992003))
+(assert_return (invoke "v128.load32_lane_0_align_1" (i32.const 0)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 50462976 0 0 0))
+(assert_return (invoke "v128.load32_lane_0_align_2" (i32.const 0)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 50462976 0 0 0))
+(assert_return (invoke "v128.load32_lane_0_align_4" (i32.const 0)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 50462976 0 0 0))
+(assert_return (invoke "v128.load32_lane_1_align_1" (i32.const 1)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 67305985 0 0))
+(assert_return (invoke "v128.load32_lane_1_align_2" (i32.const 1)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 67305985 0 0))
+(assert_return (invoke "v128.load32_lane_1_align_4" (i32.const 1)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 67305985 0 0))
+(assert_return (invoke "v128.load32_lane_2_align_1" (i32.const 2)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 84148994 0))
+(assert_return (invoke "v128.load32_lane_2_align_2" (i32.const 2)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 84148994 0))
+(assert_return (invoke "v128.load32_lane_2_align_4" (i32.const 2)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 84148994 0))
+(assert_return (invoke "v128.load32_lane_3_align_1" (i32.const 3)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 0 100992003))
+(assert_return (invoke "v128.load32_lane_3_align_2" (i32.const 3)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 0 100992003))
+(assert_return (invoke "v128.load32_lane_3_align_4" (i32.const 3)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 0 100992003))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load32_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load32_lane 4 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.load32_lane align=8 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/tests/wast/spec/simd_load64_lane.wast b/tests/wast/spec/simd_load64_lane.wast
new file mode 100644
index 0000000000..5883a6eaeb
--- /dev/null
+++ b/tests/wast/spec/simd_load64_lane.wast
@@ -0,0 +1,97 @@
+;; Tests for load lane operations.
+
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F")
+  (func (export "v128.load64_lane_0")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_0_offset_0")
+    (param $x v128) (result v128)
+    (v128.load64_lane offset=0 0 (i32.const 0) (local.get $x)))
+  (func (export "v128.load64_lane_1_offset_1")
+    (param $x v128) (result v128)
+    (v128.load64_lane offset=1 1 (i32.const 0) (local.get $x)))
+  (func (export "v128.load64_lane_0_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=1 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_0_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=2 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_0_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=4 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_0_align_8")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=8 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_1_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=1 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_1_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=2 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_1_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=4 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_1_align_8")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=8 1 (local.get $address) (local.get $x)))
+)
+
+(assert_return (invoke "v128.load64_lane_0" (i32.const 0)
+                                            (v128.const i64x2 0 0))
+                                            (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_1" (i32.const 1)
+                                            (v128.const i64x2 0 0))
+                                            (v128.const i64x2 0 578437695752307201))
+(assert_return (invoke "v128.load64_lane_0_offset_0" (v128.const i64x2 0 0))
+                                                     (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_1_offset_1" (v128.const i64x2 0 0))
+                                                     (v128.const i64x2 0 578437695752307201))
+(assert_return (invoke "v128.load64_lane_0_align_1" (i32.const 0)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_0_align_2" (i32.const 0)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_0_align_4" (i32.const 0)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_0_align_8" (i32.const 0)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_1_align_1" (i32.const 1)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 0 578437695752307201))
+(assert_return (invoke "v128.load64_lane_1_align_2" (i32.const 1)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 0 578437695752307201))
+(assert_return (invoke "v128.load64_lane_1_align_4" (i32.const 1)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 0 578437695752307201))
+(assert_return (invoke "v128.load64_lane_1_align_8" (i32.const 1)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 0 578437695752307201))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load64_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load64_lane 2 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.load64_lane align=16 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/tests/wast/spec/simd_load8_lane.wast b/tests/wast/spec/simd_load8_lane.wast
new file mode 100644
index 0000000000..d0706f5351
--- /dev/null
+++ b/tests/wast/spec/simd_load8_lane.wast
@@ -0,0 +1,299 @@
+;; Tests for load lane operations.
+
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F")
+  (func (export "v128.load8_lane_0")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_3")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 4 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_5")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 5 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_6")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 6 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_7")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 7 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_8")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 8 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_9")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 9 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_10")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 10 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_11")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 11 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_12")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 12 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_13")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 13 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_14")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 14 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_15")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 15 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_0_offset_0")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=0 0 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_1_offset_1")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=1 1 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_2_offset_2")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=2 2 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_3_offset_3")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=3 3 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_4_offset_4")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=4 4 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_5_offset_5")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=5 5 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_6_offset_6")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=6 6 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_7_offset_7")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=7 7 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_8_offset_8")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=8 8 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_9_offset_9")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=9 9 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_10_offset_10")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=10 10 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_11_offset_11")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=11 11 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_12_offset_12")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=12 12 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_13_offset_13")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=13 13 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_14_offset_14")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=14 14 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_15_offset_15")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=15 15 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_0_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_1_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_2_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_3_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_4_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 4 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_5_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 5 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_6_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 6 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_7_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 7 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_8_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 8 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_9_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 9 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_10_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 10 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_11_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 11 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_12_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 12 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_13_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 13 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_14_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 14 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_15_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 15 (local.get $address) (local.get $x)))
+)
+
+(assert_return (invoke "v128.load8_lane_0" (i32.const 0)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_1" (i32.const 1)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_2" (i32.const 2)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_3" (i32.const 3)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_4" (i32.const 4)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_5" (i32.const 5)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_6" (i32.const 6)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_7" (i32.const 7)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_8" (i32.const 8)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_9" (i32.const 9)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_10" (i32.const 10)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_11" (i32.const 11)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_12" (i32.const 12)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+(assert_return (invoke "v128.load8_lane_13" (i32.const 13)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+(assert_return (invoke "v128.load8_lane_14" (i32.const 14)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+(assert_return (invoke "v128.load8_lane_15" (i32.const 15)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+(assert_return (invoke "v128.load8_lane_0_offset_0" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_1_offset_1" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_2_offset_2" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_3_offset_3" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_4_offset_4" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_5_offset_5" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_6_offset_6" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_7_offset_7" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_8_offset_8" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_9_offset_9" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_10_offset_10" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_11_offset_11" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_12_offset_12" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+(assert_return (invoke "v128.load8_lane_13_offset_13" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+(assert_return (invoke "v128.load8_lane_14_offset_14" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+(assert_return (invoke "v128.load8_lane_15_offset_15" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+(assert_return (invoke "v128.load8_lane_0_align_1" (i32.const 0)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_1_align_1" (i32.const 1)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_2_align_1" (i32.const 2)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_3_align_1" (i32.const 3)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_4_align_1" (i32.const 4)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_5_align_1" (i32.const 5)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_6_align_1" (i32.const 6)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_7_align_1" (i32.const 7)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_8_align_1" (i32.const 8)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_9_align_1" (i32.const 9)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_10_align_1" (i32.const 10)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_11_align_1" (i32.const 11)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_12_align_1" (i32.const 12)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+(assert_return (invoke "v128.load8_lane_13_align_1" (i32.const 13)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+(assert_return (invoke "v128.load8_lane_14_align_1" (i32.const 14)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+(assert_return (invoke "v128.load8_lane_15_align_1" (i32.const 15)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load8_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load8_lane 16 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.load8_lane align=2 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/tests/wast/spec/simd_load_extend.wast b/tests/wast/spec/simd_load_extend.wast
new file mode 100644
index 0000000000..b9982bbfd0
--- /dev/null
+++ b/tests/wast/spec/simd_load_extend.wast
@@ -0,0 +1,384 @@
+;; Load and Extend test cases
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+  (data (i32.const 65520) "\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+
+  (func (export "v128.load8x8_s") (param $0 i32) (result v128)
+    (v128.load8x8_s (local.get $0))
+  )
+  (func (export "v128.load8x8_u") (param $0 i32) (result v128)
+    (v128.load8x8_u (local.get $0))
+  )
+  (func (export "v128.load16x4_s") (param $0 i32) (result v128)
+    (v128.load16x4_s (local.get $0))
+  )
+  (func (export "v128.load16x4_u") (param $0 i32) (result v128)
+    (v128.load16x4_u (local.get $0))
+  )
+  (func (export "v128.load32x2_s") (param $0 i32) (result v128)
+    (v128.load32x2_s (local.get $0))
+  )
+  (func (export "v128.load32x2_u") (param $0 i32) (result v128)
+    (v128.load32x2_u (local.get $0))
+  )
+
+  ;; load by a constant amount
+  (func (export "v128.load8x8_s_const0") (result v128)
+    (v128.load8x8_s (i32.const 0))
+  )
+  (func (export "v128.load8x8_u_const8") (result v128)
+    (v128.load8x8_u (i32.const 8))
+  )
+  (func (export "v128.load16x4_s_const10") (result v128)
+    (v128.load16x4_s (i32.const 10))
+  )
+  (func (export "v128.load16x4_u_const20") (result v128)
+    (v128.load16x4_u (i32.const 20))
+  )
+  (func (export "v128.load32x2_s_const65520") (result v128)
+    (v128.load32x2_s (i32.const 65520))
+  )
+  (func (export "v128.load32x2_u_const65526") (result v128)
+    (v128.load32x2_u (i32.const 65526))
+  )
+
+  ;; load data with different offset/align arguments
+  ;; i16x8
+  (func (export "v128.load8x8_s_offset0") (param $0 i32) (result v128)
+    (v128.load8x8_s offset=0 (local.get $0))
+  )
+  (func (export "v128.load8x8_s_align1") (param $0 i32) (result v128)
+    (v128.load8x8_s align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_s_offset0_align1") (param $0 i32) (result v128)
+    (v128.load8x8_s offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_s_offset1_align1") (param $0 i32) (result v128)
+    (v128.load8x8_s offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_s_offset10_align4") (param $0 i32) (result v128)
+    (v128.load8x8_s offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load8x8_s_offset20_align8") (param $0 i32) (result v128)
+    (v128.load8x8_s offset=20 align=8 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_offset0") (param $0 i32) (result v128)
+    (v128.load8x8_u offset=0 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_align1") (param $0 i32) (result v128)
+    (v128.load8x8_u align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_offset0_align1") (param $0 i32) (result v128)
+    (v128.load8x8_u offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_offset1_align1") (param $0 i32) (result v128)
+    (v128.load8x8_u offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_offset10_align4") (param $0 i32) (result v128)
+    (v128.load8x8_u offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_offset20_align8") (param $0 i32) (result v128)
+    (v128.load8x8_u offset=20 align=8 (local.get $0))
+  )
+  ;; i32x4
+  (func (export "v128.load16x4_s_offset0") (param $0 i32) (result v128)
+    (v128.load16x4_s offset=0 (local.get $0))
+  )
+  (func (export "v128.load16x4_s_align1") (param $0 i32) (result v128)
+    (v128.load16x4_s align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_s_offset0_align1") (param $0 i32) (result v128)
+    (v128.load16x4_s offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_s_offset1_align1") (param $0 i32) (result v128)
+    (v128.load16x4_s offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_s_offset10_align4") (param $0 i32) (result v128)
+    (v128.load16x4_s offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load16x4_s_offset20_align8") (param $0 i32) (result v128)
+    (v128.load16x4_s offset=20 align=8 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_offset0") (param $0 i32) (result v128)
+    (v128.load16x4_u offset=0 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_align1") (param $0 i32) (result v128)
+    (v128.load16x4_u align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_offset0_align1") (param $0 i32) (result v128)
+    (v128.load16x4_u offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_offset1_align1") (param $0 i32) (result v128)
+    (v128.load16x4_u offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_offset10_align4") (param $0 i32) (result v128)
+    (v128.load16x4_u offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_offset20_align8") (param $0 i32) (result v128)
+    (v128.load16x4_u offset=20 align=8 (local.get $0))
+  )
+  ;; i64x2
+  (func (export "v128.load32x2_s_offset0") (param $0 i32) (result v128)
+    (v128.load32x2_s offset=0 (local.get $0))
+  )
+  (func (export "v128.load32x2_s_align1") (param $0 i32) (result v128)
+    (v128.load32x2_s align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_s_offset0_align1") (param $0 i32) (result v128)
+    (v128.load32x2_s offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_s_offset1_align1") (param $0 i32) (result v128)
+    (v128.load32x2_s offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_s_offset10_align4") (param $0 i32) (result v128)
+    (v128.load32x2_s offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load32x2_s_offset20_align8") (param $0 i32) (result v128)
+    (v128.load32x2_s offset=20 align=8 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_offset0") (param $0 i32) (result v128)
+    (v128.load32x2_u offset=0 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_align1") (param $0 i32) (result v128)
+    (v128.load32x2_u align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_offset0_align1") (param $0 i32) (result v128)
+    (v128.load32x2_u offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_offset1_align1") (param $0 i32) (result v128)
+    (v128.load32x2_u offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_offset10_align4") (param $0 i32) (result v128)
+    (v128.load32x2_u offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_offset20_align8") (param $0 i32) (result v128)
+    (v128.load32x2_u offset=20 align=8 (local.get $0))
+  )
+)
+
+
+;; normal
+(assert_return (invoke "v128.load8x8_s" (i32.const 0)) (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load8x8_u" (i32.const 0)) (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load16x4_s" (i32.const 0)) (v128.const i32x4 0x00000100 0x00000302 0x00000504 0x00000706))
+(assert_return (invoke "v128.load16x4_u" (i32.const 0)) (v128.const i32x4 0x00000100 0x00000302 0x00000504 0x00000706))
+(assert_return (invoke "v128.load32x2_s" (i32.const 0)) (v128.const i64x2 0x0000000003020100 0x0000000007060504))
+(assert_return (invoke "v128.load32x2_u" (i32.const 0)) (v128.const i64x2 0x0000000003020100 0x0000000007060504))
+(assert_return (invoke "v128.load8x8_s" (i32.const 10)) (v128.const i16x8 0x000A 0x000B 0x000C 0x000D 0x000E 0x000F 0xFF80 0xFF81))
+(assert_return (invoke "v128.load8x8_u" (i32.const 10)) (v128.const i16x8 0x000A 0x000B 0x000C 0x000D 0x000E 0x000F 0x0080 0x0081))
+(assert_return (invoke "v128.load16x4_s" (i32.const 10)) (v128.const i32x4 0x00000B0A 0x00000D0C 0x00000F0E 0xFFFF8180))
+(assert_return (invoke "v128.load16x4_u" (i32.const 10)) (v128.const i32x4 0x00000B0A 0x00000D0C 0x00000F0E 0x00008180))
+(assert_return (invoke "v128.load32x2_s" (i32.const 10)) (v128.const i64x2 0x000000000D0C0B0A 0xFFFFFFFF81800F0E))
+(assert_return (invoke "v128.load32x2_u" (i32.const 10)) (v128.const i64x2 0x000000000D0C0B0A 0x0000000081800F0E))
+(assert_return (invoke "v128.load8x8_s" (i32.const 20)) (v128.const i16x8 0xff84 0xff85 0xff86 0xff87 0xff88 0xff89 0x0000 0x0000))
+(assert_return (invoke "v128.load8x8_u" (i32.const 20)) (v128.const i16x8 0x0084 0x0085 0x0086 0x0087 0x0088 0x0089 0x0000 0x0000))
+(assert_return (invoke "v128.load16x4_s" (i32.const 20)) (v128.const i32x4 0xffff8584 0xffff8786 0xffff8988 0x00000000))
+(assert_return (invoke "v128.load16x4_u" (i32.const 20)) (v128.const i32x4 0x00008584 0x00008786 0x00008988 0x00000000))
+(assert_return (invoke "v128.load32x2_s" (i32.const 20)) (v128.const i64x2 0xFFFFFFFF87868584 0x0000000000008988))
+(assert_return (invoke "v128.load32x2_u" (i32.const 20)) (v128.const i64x2 0x0000000087868584 0x0000000000008988))
+
+;; load by a constant amount
+(assert_return (invoke "v128.load8x8_s_const0") (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load8x8_u_const8") (v128.const i16x8 0x0008 0x0009 0x000A 0x000B 0x000C 0x000D 0x000E 0x000F))
+(assert_return (invoke "v128.load16x4_s_const10") (v128.const i32x4 0x00000B0A 0x00000D0C 0x00000F0E 0xFFFF8180))
+(assert_return (invoke "v128.load16x4_u_const20") (v128.const i32x4 0x00008584 0x00008786 0x00008988 0x00000000))
+(assert_return (invoke "v128.load32x2_s_const65520") (v128.const i64x2 0x000000000D0C0B0A 0xFFFFFFFF81800F0E))
+(assert_return (invoke "v128.load32x2_u_const65526") (v128.const i64x2 0x0000000083828180 0x0000000087868584))
+
+;; load data with different offset/align arguments
+;; i16x8
+(assert_return (invoke "v128.load8x8_s_offset0" (i32.const 0)) (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load8x8_s_align1" (i32.const 1)) (v128.const i16x8 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008))
+(assert_return (invoke "v128.load8x8_s_offset0_align1" (i32.const 2)) (v128.const i16x8 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008 0x0009))
+(assert_return (invoke "v128.load8x8_s_offset10_align4" (i32.const 3)) (v128.const i16x8 0x000D 0x000E 0x000F 0xFF80 0xFF81 0xFF82 0xFF83 0xFF84))
+(assert_return (invoke "v128.load8x8_s_offset20_align8" (i32.const 4)) (v128.const i16x8 0xFF88 0xFF89 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+(assert_return (invoke "v128.load8x8_u_offset0" (i32.const 0)) (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load8x8_u_align1" (i32.const 1)) (v128.const i16x8 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008))
+(assert_return (invoke "v128.load8x8_u_offset0_align1" (i32.const 2)) (v128.const i16x8 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008 0x0009))
+(assert_return (invoke "v128.load8x8_u_offset10_align4" (i32.const 3)) (v128.const i16x8 0x000D 0x000E 0x000F 0x0080 0x0081 0x0082 0x0083 0x0084))
+(assert_return (invoke "v128.load8x8_u_offset20_align8" (i32.const 4)) (v128.const i16x8 0x0088 0x0089 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+;; i32x4
+(assert_return (invoke "v128.load16x4_s_offset0" (i32.const 0)) (v128.const i32x4 0x00000100 0x00000302 0x00000504 0x00000706))
+(assert_return (invoke "v128.load16x4_s_align1" (i32.const 1)) (v128.const i32x4 0x00000201 0x00000403 0x00000605 0x00000807))
+(assert_return (invoke "v128.load16x4_s_offset0_align1" (i32.const 2)) (v128.const i32x4 0x00000302 0x00000504 0x00000706 0x00000908))
+(assert_return (invoke "v128.load16x4_s_offset10_align4" (i32.const 3)) (v128.const i32x4 0x00000E0D 0xFFFF800F 0xFFFF8281 0xFFFF8483))
+(assert_return (invoke "v128.load16x4_s_offset20_align8" (i32.const 4)) (v128.const i32x4 0xFFFF8988 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load16x4_u_offset0" (i32.const 0)) (v128.const i32x4 0x00000100 0x00000302 0x00000504 0x00000706))
+(assert_return (invoke "v128.load16x4_u_align1" (i32.const 1)) (v128.const i32x4 0x00000201 0x00000403 0x00000605 0x00000807))
+(assert_return (invoke "v128.load16x4_u_offset0_align1" (i32.const 2)) (v128.const i32x4 0x00000302 0x00000504 0x00000706 0x00000908))
+(assert_return (invoke "v128.load16x4_u_offset10_align4" (i32.const 3)) (v128.const i32x4 0x00000E0D 0x0000800F 0x00008281 0x00008483))
+(assert_return (invoke "v128.load16x4_u_offset20_align8" (i32.const 4)) (v128.const i32x4 0x00008988 0x00000000 0x00000000 0x00000000))
+;; i64x2
+(assert_return (invoke "v128.load32x2_s_offset0" (i32.const 0)) (v128.const i64x2 0x0000000003020100 0x0000000007060504))
+(assert_return (invoke "v128.load32x2_s_align1" (i32.const 1)) (v128.const i64x2 0x0000000004030201 0x0000000008070605))
+(assert_return (invoke "v128.load32x2_s_offset0_align1" (i32.const 2)) (v128.const i64x2 0x0000000005040302 0x0000000009080706))
+(assert_return (invoke "v128.load32x2_s_offset10_align4" (i32.const 3)) (v128.const i64x2 0xFFFFFFFF800F0E0D 0xFFFFFFFF84838281))
+(assert_return (invoke "v128.load32x2_s_offset20_align8" (i32.const 4)) (v128.const i64x2 0x0000000000008988 0x0000000000000000))
+(assert_return (invoke "v128.load32x2_u_offset0" (i32.const 0)) (v128.const i64x2 0x0000000003020100 0x0000000007060504))
+(assert_return (invoke "v128.load32x2_u_align1" (i32.const 1)) (v128.const i64x2 0x0000000004030201 0x0000000008070605))
+(assert_return (invoke "v128.load32x2_u_offset0_align1" (i32.const 2)) (v128.const i64x2 0x0000000005040302 0x0000000009080706))
+(assert_return (invoke "v128.load32x2_u_offset10_align4" (i32.const 3)) (v128.const i64x2 0x00000000800F0E0D 0x0000000084838281))
+(assert_return (invoke "v128.load32x2_u_offset20_align8" (i32.const 4)) (v128.const i64x2 0x0000000000008988 0x0000000000000000))
+
+;; out of bounds memory access
+(assert_trap (invoke "v128.load8x8_s" (i32.const -1))  "out of bounds memory access")
+(assert_trap (invoke "v128.load8x8_u" (i32.const -1))  "out of bounds memory access")
+(assert_trap (invoke "v128.load16x4_s" (i32.const 65536))  "out of bounds memory access")
+(assert_trap (invoke "v128.load16x4_u" (i32.const 65536))  "out of bounds memory access")
+(assert_trap (invoke "v128.load32x2_s" (i32.const 65529))  "out of bounds memory access")
+(assert_trap (invoke "v128.load32x2_u" (i32.const 65529))  "out of bounds memory access")
+
+(assert_trap (invoke "v128.load8x8_s_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load8x8_u_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load16x4_s_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load16x4_u_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load32x2_s_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load32x2_u_offset1_align1" (i32.const -1)) "out of bounds memory access")
+
+;; type check
+(assert_invalid (module (memory 0) (func (result v128) (v128.load8x8_s (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load8x8_u (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load16x4_s (f64.const 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load16x4_u (f64.const 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load32x2_s (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load32x2_u (v128.const i32x4 0 0 0 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load8x8_s-arg-empty (result v128)
+      (v128.load8x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load8x8_u-arg-empty (result v128)
+      (v128.load8x8_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load16x4_s-arg-empty (result v128)
+      (v128.load16x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load16x4_u-arg-empty (result v128)
+      (v128.load16x4_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load32x2_s-arg-empty (result v128)
+      (v128.load32x2_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load32x2_u-arg-empty (result v128)
+      (v128.load32x2_u)
+    )
+  )
+  "type mismatch"
+)
+
+;; Unknown operator
+
+(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load16x4_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load16x4_u (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load32x2_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load32x2_u (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load64x1_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load64x1_u (i32.const 0))))") "unknown operator")
+
+;; combination
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+  (func (export "v128.load8x8_s-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load8x8_s (i32.const 0))))
+  )
+  (func (export "v128.load8x8_u-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load8x8_u (i32.const 1))))
+  )
+  (func (export "v128.load16x4_s-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load16x4_s (i32.const 2))))
+  )
+  (func (export "v128.load16x4_u-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load16x4_u (i32.const 3))))
+  )
+  (func (export "v128.load32x2_s-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load32x2_s (i32.const 4))))
+  )
+  (func (export "v128.load32x2_u-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load32x2_u (i32.const 5))))
+  )
+  (func (export "v128.load8x8_s-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load8x8_s (i32.const 6))))
+  )
+  (func (export "v128.load8x8_u-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load8x8_u (i32.const 7))))
+  )
+  (func (export "v128.load16x4_s-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load16x4_s (i32.const 8))))
+  )
+  (func (export "v128.load16x4_u-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load16x4_u (i32.const 9))))
+  )
+  (func (export "v128.load32x2_s-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load32x2_s (i32.const 10))))
+  )
+  (func (export "v128.load32x2_u-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load32x2_u (i32.const 11))))
+  )
+  (func (export "v128.load8x8_s-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load8x8_s (i32.const 12)))
+  )
+  (func (export "v128.load8x8_u-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load8x8_u (i32.const 13)))
+  )
+  (func (export "v128.load16x4_s-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load16x4_s (i32.const 14)))
+  )
+  (func (export "v128.load16x4_u-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load16x4_u (i32.const 15)))
+  )
+  (func (export "v128.load32x2_s-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load32x2_s (i32.const 16)))
+  )
+  (func (export "v128.load32x2_u-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load32x2_u (i32.const 17)))
+  )
+)
+(assert_return (invoke "v128.load8x8_s-in-block") (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load8x8_u-in-block") (v128.const i16x8 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008))
+(assert_return (invoke "v128.load16x4_s-in-block") (v128.const i32x4 0x00000302 0x00000504 0x00000706 0x00000908))
+(assert_return (invoke "v128.load16x4_u-in-block") (v128.const i32x4 0x00000403 0x00000605 0x00000807 0x00000A09))
+(assert_return (invoke "v128.load32x2_s-in-block") (v128.const i64x2 0x0000000007060504 0x000000000B0A0908))
+(assert_return (invoke "v128.load32x2_u-in-block") (v128.const i64x2 0x0000000008070605 0x000000000C0B0A09))
+(assert_return (invoke "v128.load8x8_s-as-br-value") (v128.const i16x8 0x0006 0x0007 0x0008 0x0009 0x000A 0x000B 0x000C 0x000D))
+(assert_return (invoke "v128.load8x8_u-as-br-value") (v128.const i16x8 0x0007 0x0008 0x0009 0x000A 0x000B 0x000C 0x000D 0x000E))
+(assert_return (invoke "v128.load16x4_s-as-br-value") (v128.const i32x4 0x00000908 0x00000B0A 0x00000D0C 0x00000F0E))
+(assert_return (invoke "v128.load16x4_u-as-br-value") (v128.const i32x4 0x00000A09 0x00000C0B 0x00000E0D 0x0000800F))
+(assert_return (invoke "v128.load32x2_s-as-br-value") (v128.const i64x2 0x000000000D0C0B0A 0xFFFFFFFF81800F0E))
+(assert_return (invoke "v128.load32x2_u-as-br-value") (v128.const i64x2 0x000000000E0D0C0B 0x000000008281800F))
+(assert_return (invoke "v128.load8x8_s-extract_lane_s-operand") (i32.const 12))
+(assert_return (invoke "v128.load8x8_u-extract_lane_s-operand") (i32.const 13))
+(assert_return (invoke "v128.load16x4_s-extract_lane_s-operand") (i32.const 14))
+(assert_return (invoke "v128.load16x4_u-extract_lane_s-operand") (i32.const 15))
+(assert_return (invoke "v128.load32x2_s-extract_lane_s-operand") (i32.const -128))
+(assert_return (invoke "v128.load32x2_u-extract_lane_s-operand") (i32.const -127))
diff --git a/tests/wast/spec/simd_load_splat.wast b/tests/wast/spec/simd_load_splat.wast
new file mode 100644
index 0000000000..d9642f8bd6
--- /dev/null
+++ b/tests/wast/spec/simd_load_splat.wast
@@ -0,0 +1,261 @@
+;; Tests for the load_splat instructions
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F")
+  (data (i32.const 65520) "\10\11\12\13\14\15\16\17\18\19\1A\1B\1C\1D\1E\1F")
+
+  (func (export "v128.load8_splat") (param $address i32) (result v128) (v128.load8_splat (local.get $address)))
+  (func (export "v128.load16_splat") (param $address i32) (result v128) (v128.load16_splat (local.get $address)))
+  (func (export "v128.load32_splat") (param $address i32) (result v128) (v128.load32_splat (local.get $address)))
+  (func (export "v128.load64_splat") (param $address i32) (result v128) (v128.load64_splat (local.get $address)))
+
+  ;; Load data with different offset/align arguments
+  (func (export "v8x16.offset0") (param $address i32) (result v128) (v128.load8_splat offset=0 (local.get $address)))
+  (func (export "v8x16.align1") (param $address i32) (result v128) (v128.load8_splat align=1 (local.get $address)))
+  (func (export "v8x16.offset1_align1") (param $address i32) (result v128) (v128.load8_splat offset=1 align=1 (local.get $address)))
+  (func (export "v8x16.offset2_align1") (param $address i32) (result v128) (v128.load8_splat offset=2 align=1 (local.get $address)))
+  (func (export "v8x16.offset15_align1") (param $address i32) (result v128) (v128.load8_splat offset=15 align=1 (local.get $address)))
+
+  (func (export "v16x8.offset0") (param $address i32) (result v128) (v128.load16_splat offset=0 (local.get $address)))
+  (func (export "v16x8.align1") (param $address i32) (result v128) (v128.load16_splat align=1 (local.get $address)))
+  (func (export "v16x8.offset1_align1") (param $address i32) (result v128) (v128.load16_splat offset=1 align=1 (local.get $address)))
+  (func (export "v16x8.offset2_align1") (param $address i32) (result v128) (v128.load16_splat offset=2 align=1 (local.get $address)))
+  (func (export "v16x8.offset15_align2") (param $address i32) (result v128) (v128.load16_splat offset=15 align=2 (local.get $address)))
+
+  (func (export "v32x4.offset0") (param $address i32) (result v128) (v128.load32_splat offset=0 (local.get $address)))
+  (func (export "v32x4.align1") (param $address i32) (result v128) (v128.load32_splat align=1 (local.get $address)))
+  (func (export "v32x4.offset1_align1") (param $address i32) (result v128) (v128.load32_splat offset=1 align=1 (local.get $address)))
+  (func (export "v32x4.offset2_align2") (param $address i32) (result v128) (v128.load32_splat offset=2 align=2 (local.get $address)))
+  (func (export "v32x4.offset15_align4") (param $address i32) (result v128) (v128.load32_splat offset=15 align=4 (local.get $address)))
+
+  (func (export "v64x2.offset0") (param $address i32) (result v128) (v128.load64_splat offset=0 (local.get $address)))
+  (func (export "v64x2.align1") (param $address i32) (result v128) (v128.load64_splat align=1 (local.get $address)))
+  (func (export "v64x2.offset1_align2") (param $address i32) (result v128) (v128.load64_splat offset=1 align=2 (local.get $address)))
+  (func (export "v64x2.offset2_align4") (param $address i32) (result v128) (v128.load64_splat offset=2 align=4 (local.get $address)))
+  (func (export "v64x2.offset15_align8") (param $address i32) (result v128) (v128.load64_splat offset=15 align=8 (local.get $address)))
+
+  (func (export "v8x16.offset65536") (param $address i32) (result v128) (v128.load8_splat offset=65536 (local.get $address)))
+  (func (export "v16x8.offset65535") (param $address i32) (result v128) (v128.load16_splat offset=65535 (local.get $address)))
+  (func (export "v32x4.offset65533") (param $address i32) (result v128) (v128.load32_splat offset=65533 (local.get $address)))
+  (func (export "v64x2.offset65529") (param $address i32) (result v128) (v128.load64_splat offset=65529 (local.get $address)))
+)
+(assert_return (invoke "v128.load8_splat" (i32.const 0)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_splat" (i32.const 1)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "v128.load8_splat" (i32.const 2)) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "v128.load8_splat" (i32.const 3)) (v128.const i8x16 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3))
+(assert_return (invoke "v128.load8_splat" (i32.const 65535)) (v128.const i8x16 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31))
+(assert_return (invoke "v128.load16_splat" (i32.const 4)) (v128.const i16x8 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504))
+(assert_return (invoke "v128.load16_splat" (i32.const 5)) (v128.const i16x8 0x0605 0x0605 0x0605 0x0605 0x0605 0x0605 0x0605 0x0605))
+(assert_return (invoke "v128.load16_splat" (i32.const 6)) (v128.const i16x8 0x0706 0x0706 0x0706 0x0706 0x0706 0x0706 0x0706 0x0706))
+(assert_return (invoke "v128.load16_splat" (i32.const 7)) (v128.const i16x8 0x0807 0x0807 0x0807 0x0807 0x0807 0x0807 0x0807 0x0807))
+(assert_return (invoke "v128.load16_splat" (i32.const 65534)) (v128.const i16x8 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E))
+(assert_return (invoke "v128.load32_splat" (i32.const 8)) (v128.const i32x4 0x0B0A0908 0x0B0A0908 0x0B0A0908 0x0B0A0908))
+(assert_return (invoke "v128.load32_splat" (i32.const 9)) (v128.const i32x4 0x0C0B0A09 0x0C0B0A09 0x0C0B0A09 0x0C0B0A09))
+(assert_return (invoke "v128.load32_splat" (i32.const 10)) (v128.const i32x4 0x0D0C0B0A 0x0D0C0B0A 0x0D0C0B0A 0x0D0C0B0A))
+(assert_return (invoke "v128.load32_splat" (i32.const 11)) (v128.const i32x4 0x0E0D0C0B 0x0E0D0C0B 0x0E0D0C0B 0x0E0D0C0B))
+(assert_return (invoke "v128.load32_splat" (i32.const 65532)) (v128.const i32x4 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C))
+(assert_return (invoke "v128.load64_splat" (i32.const 12)) (v128.const i64x2 0x000000000F0E0D0C 0x000000000F0E0D0C))
+(assert_return (invoke "v128.load64_splat" (i32.const 13)) (v128.const i64x2 0x00000000000F0E0D 0x00000000000F0E0D))
+(assert_return (invoke "v128.load64_splat" (i32.const 14)) (v128.const i64x2 0x0000000000000F0E 0x0000000000000F0E))
+(assert_return (invoke "v128.load64_splat" (i32.const 15)) (v128.const i64x2 0x000000000000000F 0x000000000000000F))
+(assert_return (invoke "v128.load64_splat" (i32.const 65528)) (v128.const i64x2 0x1F1E1D1C1B1A1918 0x1F1E1D1C1B1A1918))
+
+;; v8x16
+(assert_return (invoke "v8x16.offset0" (i32.const 0)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v8x16.align1" (i32.const 0)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v8x16.offset1_align1" (i32.const 0)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "v8x16.offset2_align1" (i32.const 0)) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "v8x16.offset15_align1" (i32.const 0)) (v128.const i8x16 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15))
+(assert_return (invoke "v8x16.offset0" (i32.const 1)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "v8x16.align1" (i32.const 1)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "v8x16.offset1_align1" (i32.const 1)) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "v8x16.offset2_align1" (i32.const 1)) (v128.const i8x16 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3))
+(assert_return (invoke "v8x16.offset15_align1" (i32.const 1)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v8x16.offset0" (i32.const 65535)) (v128.const i8x16 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31))
+(assert_return (invoke "v8x16.align1" (i32.const 65535)) (v128.const i8x16 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31))
+;; v16x8
+(assert_return (invoke "v16x8.offset0" (i32.const 0)) (v128.const i16x8 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100))
+(assert_return (invoke "v16x8.align1" (i32.const 0)) (v128.const i16x8 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100))
+(assert_return (invoke "v16x8.offset1_align1" (i32.const 0)) (v128.const i16x8 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201))
+(assert_return (invoke "v16x8.offset2_align1" (i32.const 0)) (v128.const i16x8 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302))
+(assert_return (invoke "v16x8.offset15_align2" (i32.const 0)) (v128.const i16x8 0x000F 0x000F 0x000F 0x000F 0x000F 0x000F 0x000F 0x000F))
+(assert_return (invoke "v16x8.offset0" (i32.const 1)) (v128.const i16x8 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201))
+(assert_return (invoke "v16x8.align1" (i32.const 1)) (v128.const i16x8 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201))
+(assert_return (invoke "v16x8.offset1_align1" (i32.const 1)) (v128.const i16x8 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302))
+(assert_return (invoke "v16x8.offset2_align1" (i32.const 1)) (v128.const i16x8 0x0403 0x0403 0x0403 0x0403 0x0403 0x0403 0x0403 0x0403))
+(assert_return (invoke "v16x8.offset15_align2" (i32.const 1)) (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+(assert_return (invoke "v16x8.offset0" (i32.const 65534)) (v128.const i16x8 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E))
+(assert_return (invoke "v16x8.align1" (i32.const 65534)) (v128.const i16x8 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E))
+;; v32x4
+(assert_return (invoke "v32x4.offset0" (i32.const 0)) (v128.const i32x4 0x03020100 0x03020100 0x03020100 0x03020100))
+(assert_return (invoke "v32x4.align1" (i32.const 0)) (v128.const i32x4 0x03020100 0x03020100 0x03020100 0x03020100))
+(assert_return (invoke "v32x4.offset1_align1" (i32.const 0)) (v128.const i32x4 0x04030201 0x04030201 0x04030201 0x04030201))
+(assert_return (invoke "v32x4.offset2_align2" (i32.const 0)) (v128.const i32x4 0x05040302 0x05040302 0x05040302 0x05040302))
+(assert_return (invoke "v32x4.offset15_align4" (i32.const 0)) (v128.const i32x4 0x0000000F 0x0000000F 0x0000000F 0x0000000F))
+(assert_return (invoke "v32x4.offset0" (i32.const 1)) (v128.const i32x4 0x04030201 0x04030201 0x04030201 0x04030201))
+(assert_return (invoke "v32x4.align1" (i32.const 1)) (v128.const i32x4 0x04030201 0x04030201 0x04030201 0x04030201))
+(assert_return (invoke "v32x4.offset1_align1" (i32.const 1)) (v128.const i32x4 0x05040302 0x05040302 0x05040302 0x05040302))
+(assert_return (invoke "v32x4.offset2_align2" (i32.const 1)) (v128.const i32x4 0x06050403 0x06050403 0x06050403 0x06050403))
+(assert_return (invoke "v32x4.offset15_align4" (i32.const 1)) (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v32x4.offset0" (i32.const 65532)) (v128.const i32x4 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C))
+(assert_return (invoke "v32x4.align1" (i32.const 65532)) (v128.const i32x4 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C))
+;; v64x2
+(assert_return (invoke "v64x2.offset0" (i32.const 0)) (v128.const i64x2 0x0706050403020100 0x0706050403020100))
+(assert_return (invoke "v64x2.align1" (i32.const 0)) (v128.const i64x2 0x0706050403020100 0x0706050403020100))
+(assert_return (invoke "v64x2.offset1_align2" (i32.const 0)) (v128.const i64x2 0x0807060504030201 0x0807060504030201))
+(assert_return (invoke "v64x2.offset2_align4" (i32.const 0)) (v128.const i64x2 0x0908070605040302 0x0908070605040302))
+(assert_return (invoke "v64x2.offset15_align8" (i32.const 0)) (v128.const i64x2 0x000000000000000F 0x000000000000000F))
+(assert_return (invoke "v64x2.offset0" (i32.const 1)) (v128.const i64x2 0x0807060504030201 0x0807060504030201))
+(assert_return (invoke "v64x2.align1" (i32.const 1)) (v128.const i64x2 0x0807060504030201 0x0807060504030201))
+(assert_return (invoke "v64x2.offset1_align2" (i32.const 1)) (v128.const i64x2 0x0908070605040302 0x0908070605040302))
+(assert_return (invoke "v64x2.offset2_align4" (i32.const 1)) (v128.const i64x2 0x0A09080706050403 0x0A09080706050403))
+(assert_return (invoke "v64x2.offset15_align8" (i32.const 1)) (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+(assert_return (invoke "v64x2.offset0" (i32.const 65528)) (v128.const i64x2 0x1F1E1D1C1B1A1918 0x1F1E1D1C1B1A1918))
+(assert_return (invoke "v64x2.align1" (i32.const 65528)) (v128.const i64x2 0x1F1E1D1C1B1A1918 0x1F1E1D1C1B1A1918))
+
+
+;; Out of bounds memory access
+(assert_trap (invoke "v128.load8_splat" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load16_splat" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load32_splat" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load64_splat" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load8_splat" (i32.const 65536)) "out of bounds memory access")
+(assert_trap (invoke "v128.load16_splat" (i32.const 65535)) "out of bounds memory access")
+(assert_trap (invoke "v128.load32_splat" (i32.const 65533)) "out of bounds memory access")
+(assert_trap (invoke "v128.load64_splat" (i32.const 65529)) "out of bounds memory access")
+
+(assert_trap (invoke "v8x16.offset1_align1" (i32.const 65535)) "out of bounds memory access")
+(assert_trap (invoke "v8x16.offset2_align1" (i32.const 65535)) "out of bounds memory access")
+(assert_trap (invoke "v8x16.offset15_align1" (i32.const 65535)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset1_align1" (i32.const 65534)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset2_align1" (i32.const 65534)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset15_align2" (i32.const 65534)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset1_align1" (i32.const 65532)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset2_align2" (i32.const 65532)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset15_align4" (i32.const 65532)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset1_align2" (i32.const 65528)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset2_align4" (i32.const 65528)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset15_align8" (i32.const 65528)) "out of bounds memory access")
+
+(assert_trap (invoke "v8x16.offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset1_align2" (i32.const -1)) "out of bounds memory access")
+
+(assert_trap (invoke "v8x16.offset65536" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset65535" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset65533" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset65529" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "v8x16.offset65536" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset65535" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset65533" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset65529" (i32.const 1)) "out of bounds memory access")
+
+
+;; Combination
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A")
+
+  (func (export "v128.load8_splat-in-block") (result v128)
+      (block (result v128) (block (result v128) (v128.load8_splat (i32.const 0))))
+  )
+  (func (export "v128.load16_splat-in-block") (result v128)
+      (block (result v128) (block (result v128) (v128.load16_splat (i32.const 1))))
+  )
+  (func (export "v128.load32_splat-in-block") (result v128)
+      (block (result v128) (block (result v128) (v128.load32_splat (i32.const 2))))
+  )
+  (func (export "v128.load64_splat-in-block") (result v128)
+      (block (result v128) (block (result v128) (v128.load64_splat (i32.const 9))))
+  )
+  (func (export "v128.load8_splat-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load8_splat (i32.const 3))))
+  )
+  (func (export "v128.load16_splat-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load16_splat (i32.const 4))))
+  )
+  (func (export "v128.load32_splat-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load32_splat (i32.const 5))))
+  )
+  (func (export "v128.load64_splat-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load64_splat (i32.const 10))))
+  )
+  (func (export "v128.load8_splat-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load8_splat (i32.const 6)))
+  )
+  (func (export "v128.load16_splat-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load16_splat (i32.const 7)))
+  )
+  (func (export "v128.load32_splat-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load32_splat (i32.const 8)))
+  )
+  (func (export "v128.load64_splat-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load64_splat (i32.const 11)))
+  )
+)
+(assert_return (invoke "v128.load8_splat-in-block") (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_splat-in-block") (v128.const i16x8 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201))
+(assert_return (invoke "v128.load32_splat-in-block") (v128.const i32x4 0x05040302 0x05040302 0x05040302 0x05040302))
+(assert_return (invoke "v128.load64_splat-in-block") (v128.const i64x2 0x0000000000000A09 0x0000000000000A09))
+(assert_return (invoke "v128.load8_splat-as-br-value") (v128.const i8x16 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3))
+(assert_return (invoke "v128.load16_splat-as-br-value") (v128.const i16x8 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504))
+(assert_return (invoke "v128.load32_splat-as-br-value") (v128.const i32x4 0x08070605 0x08070605 0x08070605 0x08070605))
+(assert_return (invoke "v128.load64_splat-as-br-value") (v128.const i64x2 0x000000000000000A 0x000000000000000A))
+(assert_return (invoke "v128.load8_splat-extract_lane_s-operand") (i32.const 6))
+(assert_return (invoke "v128.load16_splat-extract_lane_s-operand") (i32.const 7))
+(assert_return (invoke "v128.load32_splat-extract_lane_s-operand") (i32.const 8))
+(assert_return (invoke "v128.load64_splat-extract_lane_s-operand") (i32.const 0))
+
+
+;; Type check
+
+(assert_invalid (module (memory 0) (func (result v128) (v128.load8_splat (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load16_splat (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load32_splat (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load64_splat (v128.const i32x4 0 0 0 0)))) "type mismatch")
+
+
+;; Unknown operator
+
+(assert_malformed (module quote "(memory 1) (func (drop (i8x16.load_splat (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load_splat (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load_splat (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load_splat (i32.const 0))))") "unknown operator")
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load8_splat-arg-empty (result v128)
+      (v128.load8_splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load16_splat-arg-empty (result v128)
+      (v128.load16_splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load32_splat-arg-empty (result v128)
+      (v128.load32_splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load64_splat-arg-empty (result v128)
+      (v128.load64_splat)
+    )
+  )
+  "type mismatch"
+)
diff --git a/tests/wast/spec/simd_load_zero.wast b/tests/wast/spec/simd_load_zero.wast
new file mode 100644
index 0000000000..6276a68637
--- /dev/null
+++ b/tests/wast/spec/simd_load_zero.wast
@@ -0,0 +1,154 @@
+;; Load and Zero extend test cases
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+  (data (i32.const 65520) "\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+
+  (func (export "v128.load32_zero") (param $0 i32) (result v128)
+    (v128.load32_zero (local.get $0))
+  )
+  (func (export "v128.load64_zero") (param $0 i32) (result v128)
+    (v128.load64_zero (local.get $0))
+  )
+
+  ;; load by a constant amount
+  (func (export "v128.load32_zero_const0") (result v128)
+    (v128.load32_zero (i32.const 0))
+  )
+  (func (export "v128.load64_zero_const8") (result v128)
+    (v128.load64_zero (i32.const 8))
+  )
+
+  ;; load data with different offset/align arguments
+  ;; i16x8
+  (func (export "v128.load32_zero_offset0") (param $0 i32) (result v128)
+    (v128.load32_zero offset=0 (local.get $0))
+  )
+  (func (export "v128.load32_zero_align1") (param $0 i32) (result v128)
+    (v128.load32_zero align=1 (local.get $0))
+  )
+  (func (export "v128.load32_zero_offset0_align1") (param $0 i32) (result v128)
+    (v128.load32_zero offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load32_zero_offset1_align1") (param $0 i32) (result v128)
+    (v128.load32_zero offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load32_zero_offset10_align4") (param $0 i32) (result v128)
+    (v128.load32_zero offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load64_zero_offset0") (param $0 i32) (result v128)
+    (v128.load64_zero offset=0 (local.get $0))
+  )
+  (func (export "v128.load64_zero_align1") (param $0 i32) (result v128)
+    (v128.load64_zero align=1 (local.get $0))
+  )
+  (func (export "v128.load64_zero_offset0_align1") (param $0 i32) (result v128)
+    (v128.load64_zero offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load64_zero_offset1_align1") (param $0 i32) (result v128)
+    (v128.load64_zero offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load64_zero_offset10_align4") (param $0 i32) (result v128)
+    (v128.load64_zero offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load64_zero_offset20_align8") (param $0 i32) (result v128)
+    (v128.load64_zero offset=20 align=8 (local.get $0))
+  )
+)
+
+
+;; normal
+(assert_return (invoke "v128.load32_zero" (i32.const 0)) (v128.const i32x4 0x03020100 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero" (i32.const 0)) (v128.const i64x2 0x0706050403020100 0x0000000000000000))
+(assert_return (invoke "v128.load32_zero" (i32.const 10)) (v128.const i32x4 0x0D0C0B0A 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero" (i32.const 10)) (v128.const i64x2 0x81800F0E0D0C0B0A 0x0000000000000000))
+(assert_return (invoke "v128.load32_zero" (i32.const 20)) (v128.const i32x4 0x87868584 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero" (i32.const 20)) (v128.const i64x2 0x0000898887868584 0x0000000000000000))
+
+;; load by a constant amount
+(assert_return (invoke "v128.load32_zero_const0") (v128.const i32x4 0x03020100 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero_const8") (v128.const i64x2 0x0F0E0D0C0B0A0908 0x0000000000000000))
+
+;; load data with different offset/align arguments
+;; load32_zero
+(assert_return (invoke "v128.load32_zero_offset0" (i32.const 0)) (v128.const i32x4 0x03020100 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load32_zero_align1" (i32.const 1)) (v128.const i32x4 0x04030201 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load32_zero_offset0_align1" (i32.const 2)) (v128.const i32x4 0x05040302 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load32_zero_offset10_align4" (i32.const 3)) (v128.const i32x4 0x800F0E0D 0x00000000 0x00000000 0x00000000))
+
+;; load64_zero
+(assert_return (invoke "v128.load64_zero_offset0" (i32.const 0)) (v128.const i64x2 0x0706050403020100 0x0000000000000000))
+(assert_return (invoke "v128.load64_zero_align1" (i32.const 1)) (v128.const i64x2 0x0807060504030201 0x0000000000000000))
+(assert_return (invoke "v128.load64_zero_offset0_align1" (i32.const 2)) (v128.const i64x2 0x0908070605040302 0x0000000000000000))
+(assert_return (invoke "v128.load64_zero_offset10_align4" (i32.const 3)) (v128.const i64x2 0x84838281800F0E0D 0x0000000000000000))
+(assert_return (invoke "v128.load64_zero_offset20_align8" (i32.const 4)) (v128.const i64x2 0x0000000000008988 0x0000000000000000))
+
+;; out of bounds memory access
+(assert_trap (invoke "v128.load32_zero" (i32.const -1))  "out of bounds memory access")
+(assert_trap (invoke "v128.load64_zero" (i32.const -1))  "out of bounds memory access")
+
+(assert_trap (invoke "v128.load32_zero_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load64_zero_offset1_align1" (i32.const -1)) "out of bounds memory access")
+
+;; type check
+(assert_invalid (module (memory 0) (func (result v128) (v128.load32_zero (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load64_zero (f32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load32_zero-arg-empty (result v128)
+      (v128.load32_zero)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load64_zero-arg-empty (result v128)
+      (v128.load64_zero)
+    )
+  )
+  "type mismatch"
+)
+
+;; Unknown operator
+
+(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load16x4_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load16x4_u (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load32x2_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load32x2_u (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load64x1_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load64x1_u (i32.const 0))))") "unknown operator")
+
+;; combination
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+  (func (export "v128.load32_zero-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load32_zero (i32.const 0))))
+  )
+  (func (export "v128.load64_zero-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load64_zero (i32.const 1))))
+  )
+  (func (export "v128.load32_zero-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load32_zero (i32.const 6))))
+  )
+  (func (export "v128.load64_zero-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load64_zero (i32.const 7))))
+  )
+  (func (export "v128.load32_zero-extract_lane_s-operand") (result i32)
+    (i32x4.extract_lane 0 (v128.load32_zero (i32.const 12)))
+  )
+  (func (export "v128.load64_zero-extract_lane_s-operand") (result i64)
+    (i64x2.extract_lane 0 (v128.load64_zero (i32.const 13)))
+  )
+)
+(assert_return (invoke "v128.load32_zero-in-block") (v128.const i32x4 0x03020100 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero-in-block") (v128.const i64x2 0x0807060504030201 0x0000000000000000))
+(assert_return (invoke "v128.load32_zero-as-br-value") (v128.const i32x4 0x09080706 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero-as-br-value") (v128.const i64x2 0x0E0D0C0B0A090807 0x0000000000000000))
+(assert_return (invoke "v128.load32_zero-extract_lane_s-operand") (i32.const 0x0F0E0D0C))
+(assert_return (invoke "v128.load64_zero-extract_lane_s-operand") (i64.const 0x84838281800F0E0D))
diff --git a/tests/wast/spec/simd_splat.wast b/tests/wast/spec/simd_splat.wast
new file mode 100644
index 0000000000..4be04ef177
--- /dev/null
+++ b/tests/wast/spec/simd_splat.wast
@@ -0,0 +1,430 @@
+;; Tests for the *_splat instructions
+
+(module
+  (func (export "i8x16.splat") (param i32) (result v128) (i8x16.splat (local.get 0)))
+  (func (export "i16x8.splat") (param i32) (result v128) (i16x8.splat (local.get 0)))
+  (func (export "i32x4.splat") (param i32) (result v128) (i32x4.splat (local.get 0)))
+  (func (export "f32x4.splat") (param f32) (result v128) (f32x4.splat (local.get 0)))
+  (func (export "i64x2.splat") (param i64) (result v128) (i64x2.splat (local.get 0)))
+  (func (export "f64x2.splat") (param f64) (result v128) (f64x2.splat (local.get 0)))
+)
+
+(assert_return (invoke "i8x16.splat" (i32.const 0)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.splat" (i32.const 5)) (v128.const i8x16 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5))
+(assert_return (invoke "i8x16.splat" (i32.const -5)) (v128.const i8x16 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5))
+(assert_return (invoke "i8x16.splat" (i32.const 257)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.splat" (i32.const 0xff)) (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.splat" (i32.const -128)) (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.splat" (i32.const 127)) (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.splat" (i32.const -129)) (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.splat" (i32.const 128)) (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.splat" (i32.const 0xff7f)) (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.splat" (i32.const 0x80)) (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.splat" (i32.const 0xAB)) (v128.const i32x4 0xABABABAB 0xABABABAB 0xABABABAB 0xABABABAB))
+
+(assert_return (invoke "i16x8.splat" (i32.const 0)) (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.splat" (i32.const 5)) (v128.const i16x8 5 5 5 5 5 5 5 5))
+(assert_return (invoke "i16x8.splat" (i32.const -5)) (v128.const i16x8 -5 -5 -5 -5 -5 -5 -5 -5))
+(assert_return (invoke "i16x8.splat" (i32.const 65537)) (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.splat" (i32.const 0xffff)) (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.splat" (i32.const -32768)) (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.splat" (i32.const 32767)) (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.splat" (i32.const -32769)) (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.splat" (i32.const 32768)) (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.splat" (i32.const 0xffff7fff)) (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.splat" (i32.const 0x8000)) (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.splat" (i32.const 0xABCD)) (v128.const i32x4 0xABCDABCD 0xABCDABCD 0xABCDABCD 0xABCDABCD))
+(assert_return (invoke "i16x8.splat" (i32.const 012345)) (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+(assert_return (invoke "i16x8.splat" (i32.const 0x01234)) (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+
+(assert_return (invoke "i32x4.splat" (i32.const 0)) (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.splat" (i32.const 5)) (v128.const i32x4 5 5 5 5))
+(assert_return (invoke "i32x4.splat" (i32.const -5)) (v128.const i32x4 -5 -5 -5 -5))
+(assert_return (invoke "i32x4.splat" (i32.const 0xffffffff)) (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.splat" (i32.const 4294967295)) (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.splat" (i32.const -2147483648)) (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.splat" (i32.const 2147483647)) (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff))
+(assert_return (invoke "i32x4.splat" (i32.const 2147483648)) (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.splat" (i32.const 01234567890)) (v128.const i32x4 012_3456_7890 012_3456_7890 012_3456_7890 012_3456_7890))
+(assert_return (invoke "i32x4.splat" (i32.const 0x012345678)) (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+
+(assert_return (invoke "f32x4.splat" (f32.const 0.0)) (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.splat" (f32.const 1.1)) (v128.const f32x4 1.1 1.1 1.1 1.1))
+(assert_return (invoke "f32x4.splat" (f32.const -1.1)) (v128.const f32x4 -1.1 -1.1 -1.1 -1.1))
+(assert_return (invoke "f32x4.splat" (f32.const 1e38)) (v128.const f32x4 1e38 1e38 1e38 1e38))
+(assert_return (invoke "f32x4.splat" (f32.const -1e38)) (v128.const f32x4 -1e38 -1e38 -1e38 -1e38))
+(assert_return (invoke "f32x4.splat" (f32.const 0x1.fffffep127)) (v128.const f32x4 0x1.fffffep127 0x1.fffffep127 0x1.fffffep127 0x1.fffffep127))
+(assert_return (invoke "f32x4.splat" (f32.const -0x1.fffffep127)) (v128.const f32x4 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127))
+(assert_return (invoke "f32x4.splat" (f32.const 0x1p127)) (v128.const f32x4 0x1p127 0x1p127 0x1p127 0x1p127))
+(assert_return (invoke "f32x4.splat" (f32.const -0x1p127)) (v128.const f32x4 -0x1p127 -0x1p127 -0x1p127 -0x1p127))
+(assert_return (invoke "f32x4.splat" (f32.const inf)) (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.splat" (f32.const -inf)) (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.splat" (f32.const nan)) (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.splat" (f32.const nan:0x1)) (v128.const f32x4 nan:0x1 nan:0x1 nan:0x1 nan:0x1))
+(assert_return (invoke "f32x4.splat" (f32.const nan:0x7f_ffff)) (v128.const f32x4 nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff))
+(assert_return (invoke "f32x4.splat" (f32.const 0123456789)) (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.splat" (f32.const 0123456789.)) (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.splat" (f32.const 0x0123456789ABCDEF)) (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.splat" (f32.const 0x0123456789ABCDEF.)) (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.splat" (f32.const 0123456789e019)) (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.splat" (f32.const 0123456789.e+019)) (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.splat" (f32.const 0x0123456789ABCDEFp019)) (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.splat" (f32.const 0x0123456789ABCDEF.p-019)) (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+
+(assert_return (invoke "i64x2.splat" (i64.const 0)) (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.splat" (i64.const -0)) (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.splat" (i64.const 1)) (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.splat" (i64.const -1)) (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.splat" (i64.const -9223372036854775808)) (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.splat" (i64.const -9223372036854775808)) (v128.const i64x2 9223372036854775808 9223372036854775808))
+(assert_return (invoke "i64x2.splat" (i64.const 9223372036854775807)) (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.splat" (i64.const 18446744073709551615)) (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.splat" (i64.const 0x7fffffffffffffff)) (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff))
+(assert_return (invoke "i64x2.splat" (i64.const 0xffffffffffffffff)) (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.splat" (i64.const -0x8000000000000000)) (v128.const i64x2 -0x8000000000000000 -0x8000000000000000))
+(assert_return (invoke "i64x2.splat" (i64.const -0x8000000000000000)) (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+(assert_return (invoke "i64x2.splat" (i64.const 01234567890123456789)) (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789))
+(assert_return (invoke "i64x2.splat" (i64.const 0x01234567890ABcdef)) (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef))
+
+(assert_return (invoke "f64x2.splat" (f64.const 0.0)) (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.splat" (f64.const -0.0)) (v128.const f64x2 -0.0 -0.0))
+(assert_return (invoke "f64x2.splat" (f64.const 1.1)) (v128.const f64x2 1.1 1.1))
+(assert_return (invoke "f64x2.splat" (f64.const -1.1)) (v128.const f64x2 -1.1 -1.1))
+(assert_return (invoke "f64x2.splat" (f64.const 0x0.0000000000001p-1022)) (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.splat" (f64.const -0x0.0000000000001p-1022)) (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.splat" (f64.const 0x1p-1022)) (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.splat" (f64.const -0x1p-1022)) (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.splat" (f64.const 0x1p-1)) (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.splat" (f64.const -0x1p-1)) (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.splat" (f64.const 0x1p+0)) (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.splat" (f64.const -0x1p+0)) (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.splat" (f64.const 0x1.921fb54442d18p+2)) (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.splat" (f64.const -0x1.921fb54442d18p+2)) (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.splat" (f64.const 0x1.fffffffffffffp+1023)) (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.splat" (f64.const -0x1.fffffffffffffp+1023)) (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.splat" (f64.const inf)) (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.splat" (f64.const -inf)) (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.splat" (f64.const nan)) (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.splat" (f64.const -nan)) (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.splat" (f64.const nan:0x4000000000000)) (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.splat" (f64.const -nan:0x4000000000000)) (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.splat" (f64.const 0123456789)) (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.splat" (f64.const 0123456789.)) (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.splat" (f64.const 0x0123456789ABCDEFabcdef)) (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.splat" (f64.const 0x0123456789ABCDEFabcdef.)) (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.splat" (f64.const 0123456789e019)) (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.splat" (f64.const 0123456789e+019)) (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.splat" (f64.const 0x0123456789ABCDEFabcdef.p019)) (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.splat" (f64.const 0x0123456789ABCDEFabcdef.p-019)) (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+
+;; Unknown operator
+
+(assert_malformed (module quote "(func (result v128) (v128.splat (i32.const 0)))") "unknown operator")
+
+
+;; Type mismatched
+
+(assert_invalid (module (func (result v128) i8x16.splat (i64.const 0))) "type mismatch")
+(assert_invalid (module (func (result v128) i8x16.splat (f32.const 0.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i8x16.splat (f64.const 0.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i16x8.splat (i64.const 1))) "type mismatch")
+(assert_invalid (module (func (result v128) i16x8.splat (f32.const 1.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i16x8.splat (f64.const 1.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i32x4.splat (i64.const 2))) "type mismatch")
+(assert_invalid (module (func (result v128) i32x4.splat (f32.const 2.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i32x4.splat (f64.const 2.0))) "type mismatch")
+(assert_invalid (module (func (result v128) f32x4.splat (i32.const 4))) "type mismatch")
+(assert_invalid (module (func (result v128) f32x4.splat (i64.const 4))) "type mismatch")
+(assert_invalid (module (func (result v128) f32x4.splat (f64.const 4.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i64x2.splat (i32.const 0))) "type mismatch")
+(assert_invalid (module (func (result v128) i64x2.splat (f64.const 0.0))) "type mismatch")
+(assert_invalid (module (func (result v128) f64x2.splat (i32.const 0))) "type mismatch")
+(assert_invalid (module (func (result v128) f64x2.splat (f32.const 0.0))) "type mismatch")
+
+
+;; V128 splat operators as the argument of other SIMD instructions
+
+;; v128.store and v128.load
+(module (memory 1)
+  (func (export "as-v128_store-operand-1") (param i32) (result v128)
+    (v128.store (i32.const 0) (i8x16.splat (local.get 0)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-2") (param i32) (result v128)
+    (v128.store (i32.const 0) (i16x8.splat (local.get 0)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-3") (param i32) (result v128)
+    (v128.store (i32.const 0) (i32x4.splat (local.get 0)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-4") (param i64) (result v128)
+    (v128.store (i32.const 0) (i64x2.splat (local.get 0)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-5") (param f64) (result v128)
+    (v128.store (i32.const 0) (f64x2.splat (local.get 0)))
+    (v128.load (i32.const 0)))
+)
+
+(assert_return (invoke "as-v128_store-operand-1" (i32.const 1)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "as-v128_store-operand-2" (i32.const 256)) (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+(assert_return (invoke "as-v128_store-operand-3" (i32.const 0xffffffff)) (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "as-v128_store-operand-4" (i64.const 1)) (v128.const i64x2 1 1))
+(assert_return (invoke "as-v128_store-operand-5" (f64.const -0x1p+0)) (v128.const f64x2 -0x1p+0 -0x1p+0))
+
+(module
+  ;; Accessing lane
+  (func (export "as-i8x16_extract_lane_s-operand-first") (param i32) (result i32)
+    (i8x16.extract_lane_s 0 (i8x16.splat (local.get 0))))
+  (func (export "as-i8x16_extract_lane_s-operand-last") (param i32) (result i32)
+    (i8x16.extract_lane_s 15 (i8x16.splat (local.get 0))))
+  (func (export "as-i16x8_extract_lane_s-operand-first") (param i32) (result i32)
+    (i16x8.extract_lane_s 0 (i16x8.splat (local.get 0))))
+  (func (export "as-i16x8_extract_lane_s-operand-last") (param i32) (result i32)
+    (i16x8.extract_lane_s 7 (i16x8.splat (local.get 0))))
+  (func (export "as-i32x4_extract_lane_s-operand-first") (param i32) (result i32)
+    (i32x4.extract_lane 0 (i32x4.splat (local.get 0))))
+  (func (export "as-i32x4_extract_lane_s-operand-last") (param i32) (result i32)
+    (i32x4.extract_lane 3 (i32x4.splat (local.get 0))))
+  (func (export "as-f32x4_extract_lane_s-operand-first") (param f32) (result f32)
+    (f32x4.extract_lane 0 (f32x4.splat (local.get 0))))
+  (func (export "as-f32x4_extract_lane_s-operand-last") (param f32) (result f32)
+    (f32x4.extract_lane 3 (f32x4.splat (local.get 0))))
+  (func (export "as-v8x16_swizzle-operands") (param i32) (param i32) (result v128)
+    (i8x16.swizzle (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1))))
+  (func (export "as-i64x2_extract_lane-operand-first") (param i64) (result i64)
+    (i64x2.extract_lane 0 (i64x2.splat (local.get 0))))
+  (func (export "as-i64x2_extract_lane-operand-last") (param i64) (result i64)
+    (i64x2.extract_lane 1 (i64x2.splat (local.get 0))))
+  (func (export "as-f64x2_extract_lane-operand-first") (param f64) (result f64)
+    (f64x2.extract_lane 0 (f64x2.splat (local.get 0))))
+  (func (export "as-f64x2_extract_lane-operand-last") (param f64) (result f64)
+    (f64x2.extract_lane 1 (f64x2.splat (local.get 0))))
+
+  ;; Integer arithmetic
+  (func (export "as-i8x16_add_sub-operands") (param i32 i32 i32) (result v128)
+    (i8x16.add (i8x16.splat (local.get 0))
+      (i8x16.sub (i8x16.splat (local.get 1)) (i8x16.splat (local.get 2)))))
+  (func (export "as-i16x8_add_sub_mul-operands") (param i32 i32 i32 i32) (result v128)
+    (i16x8.add (i16x8.splat (local.get 0))
+      (i16x8.sub (i16x8.splat (local.get 1))
+        (i16x8.mul (i16x8.splat (local.get 2)) (i16x8.splat (local.get 3))))))
+  (func (export "as-i32x4_add_sub_mul-operands") (param i32 i32 i32 i32) (result v128)
+    (i32x4.add (i32x4.splat (local.get 0))
+      (i32x4.sub (i32x4.splat (local.get 1))
+        (i32x4.mul (i32x4.splat (local.get 2)) (i32x4.splat (local.get 3))))))
+
+  (func (export "as-i64x2_add_sub_mul-operands") (param i64 i64 i64 i64) (result v128)
+    (i64x2.add (i64x2.splat (local.get 0))
+      (i64x2.sub (i64x2.splat (local.get 1))
+        (i64x2.mul (i64x2.splat (local.get 2)) (i64x2.splat (local.get 3))))))
+  (func (export "as-f64x2_add_sub_mul-operands") (param f64 f64 f64 f64) (result v128)
+    (f64x2.add (f64x2.splat (local.get 0))
+      (f64x2.sub (f64x2.splat (local.get 1))
+        (f64x2.mul (f64x2.splat (local.get 2)) (f64x2.splat (local.get 3))))))
+
+  ;; Saturating integer arithmetic
+  (func (export "as-i8x16_add_sat_s-operands") (param i32 i32) (result v128)
+    (i8x16.add_sat_s (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1))))
+  (func (export "as-i16x8_add_sat_s-operands") (param i32 i32) (result v128)
+    (i16x8.add_sat_s (i16x8.splat (local.get 0)) (i16x8.splat (local.get 1))))
+  (func (export "as-i8x16_sub_sat_u-operands") (param i32 i32) (result v128)
+    (i8x16.sub_sat_u (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1))))
+  (func (export "as-i16x8_sub_sat_u-operands") (param i32 i32) (result v128)
+    (i16x8.sub_sat_u (i16x8.splat (local.get 0)) (i16x8.splat (local.get 1))))
+
+  ;; Bit shifts
+  (func (export "as-i8x16_shr_s-operand") (param i32 i32) (result v128)
+    (i8x16.shr_s (i8x16.splat (local.get 0)) (local.get 1)))
+  (func (export "as-i16x8_shr_s-operand") (param i32 i32) (result v128)
+    (i16x8.shr_s (i16x8.splat (local.get 0)) (local.get 1)))
+  (func (export "as-i32x4_shr_s-operand") (param i32 i32) (result v128)
+    (i32x4.shr_s (i32x4.splat (local.get 0)) (local.get 1)))
+
+  ;; Bitwise operantions
+  (func (export "as-v128_and-operands") (param i32 i32) (result v128)
+    (v128.and (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1))))
+  (func (export "as-v128_or-operands") (param i32 i32) (result v128)
+    (v128.or (i16x8.splat (local.get 0)) (i16x8.splat (local.get 1))))
+  (func (export "as-v128_xor-operands") (param i32 i32) (result v128)
+    (v128.xor (i32x4.splat (local.get 0)) (i32x4.splat (local.get 1))))
+
+  ;; Boolean horizontal reductions
+  (func (export "as-i8x16_all_true-operand") (param i32) (result i32)
+    (i8x16.all_true (i8x16.splat (local.get 0))))
+  (func (export "as-i16x8_all_true-operand") (param i32) (result i32)
+    (i16x8.all_true (i16x8.splat (local.get 0))))
+  (func (export "as-i32x4_all_true-operand1") (param i32) (result i32)
+    (i32x4.all_true (i32x4.splat (local.get 0))))
+  (func (export "as-i32x4_all_true-operand2") (param i64) (result i32)
+    (i32x4.all_true (i64x2.splat (local.get 0))))
+
+  ;; Comparisons
+  (func (export "as-i8x16_eq-operands") (param i32 i32) (result v128)
+    (i8x16.eq (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1))))
+  (func (export "as-i16x8_eq-operands") (param i32 i32) (result v128)
+    (i16x8.eq (i16x8.splat (local.get 0)) (i16x8.splat (local.get 1))))
+  (func (export "as-i32x4_eq-operands1") (param i32 i32) (result v128)
+    (i32x4.eq (i32x4.splat (local.get 0)) (i32x4.splat (local.get 1))))
+  (func (export "as-i32x4_eq-operands2") (param i64 i64) (result v128)
+    (i32x4.eq (i64x2.splat (local.get 0)) (i64x2.splat (local.get 1))))
+  (func (export "as-f32x4_eq-operands") (param f32 f32) (result v128)
+    (f32x4.eq (f32x4.splat (local.get 0)) (f32x4.splat (local.get 1))))
+  (func (export "as-f64x2_eq-operands") (param f64 f64) (result v128)
+    (f64x2.eq (f64x2.splat (local.get 0)) (f64x2.splat (local.get 1))))
+
+  ;; Floating-point sign bit operations
+  (func (export "as-f32x4_abs-operand") (param f32) (result v128)
+    (f32x4.abs (f32x4.splat (local.get 0))))
+
+  ;; Floating-point min
+  (func (export "as-f32x4_min-operands") (param f32 f32) (result v128)
+    (f32x4.min (f32x4.splat (local.get 0)) (f32x4.splat (local.get 1))))
+
+  ;; Floating-point arithmetic
+  (func (export "as-f32x4_div-operands") (param f32 f32) (result v128)
+    (f32x4.div (f32x4.splat (local.get 0)) (f32x4.splat (local.get 1))))
+
+  ;; Conversions
+  (func (export "as-f32x4_convert_s_i32x4-operand") (param i32) (result v128)
+    (f32x4.convert_i32x4_s (i32x4.splat (local.get 0))))
+  (func (export "as-i32x4_trunc_s_f32x4_sat-operand") (param f32) (result v128)
+    (i32x4.trunc_sat_f32x4_s (f32x4.splat (local.get 0))))
+)
+
+(assert_return (invoke "as-i8x16_extract_lane_s-operand-first" (i32.const 42)) (i32.const 42))
+(assert_return (invoke "as-i8x16_extract_lane_s-operand-last" (i32.const -42)) (i32.const -42))
+(assert_return (invoke "as-i16x8_extract_lane_s-operand-first" (i32.const 0xffff7fff)) (i32.const 32767))
+(assert_return (invoke "as-i16x8_extract_lane_s-operand-last" (i32.const 0x8000)) (i32.const -32768))
+(assert_return (invoke "as-i32x4_extract_lane_s-operand-first" (i32.const 0x7fffffff)) (i32.const 2147483647))
+(assert_return (invoke "as-i32x4_extract_lane_s-operand-last" (i32.const 0x80000000)) (i32.const -2147483648))
+(assert_return (invoke "as-f32x4_extract_lane_s-operand-first" (f32.const 1.5)) (f32.const 1.5))
+(assert_return (invoke "as-f32x4_extract_lane_s-operand-last" (f32.const -0.25)) (f32.const -0.25))
+(assert_return (invoke "as-v8x16_swizzle-operands" (i32.const 1) (i32.const -1)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "as-i64x2_extract_lane-operand-last" (i64.const -42)) (i64.const -42))
+(assert_return (invoke "as-i64x2_extract_lane-operand-first" (i64.const 42)) (i64.const 42))
+(assert_return (invoke "as-f64x2_extract_lane-operand-first" (f64.const 1.5)) (f64.const 1.5))
+(assert_return (invoke "as-f64x2_extract_lane-operand-last" (f64.const -0x1p+0)) (f64.const -0x1p+0))
+
+(assert_return (invoke "as-i8x16_add_sub-operands" (i32.const 3) (i32.const 2) (i32.const 1)) (v128.const i8x16 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4))
+(assert_return (invoke "as-i16x8_add_sub_mul-operands" (i32.const 257) (i32.const 128) (i32.const 16) (i32.const 16)) (v128.const i16x8 129 129 129 129 129 129 129 129))
+(assert_return (invoke "as-i32x4_add_sub_mul-operands" (i32.const 65535) (i32.const 65537) (i32.const 256) (i32.const 256)) (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+(assert_return (invoke "as-i64x2_add_sub_mul-operands" (i64.const 0x7fffffff) (i64.const 0x1_0000_0001) (i64.const 65536) (i64.const 65536)) (v128.const i64x2 0x8000_0000 0x8000_0000))
+(assert_return (invoke "as-f64x2_add_sub_mul-operands" (f64.const 0x1p-1) (f64.const 0.75) (f64.const 0x1p-1) (f64.const 0.5)) (v128.const f64x2 0x1p+0 0x1p+0))
+
+(assert_return (invoke "as-i8x16_add_sat_s-operands" (i32.const 0x7f) (i32.const 1)) (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "as-i16x8_add_sat_s-operands" (i32.const 0x7fff) (i32.const 1)) (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "as-i8x16_sub_sat_u-operands" (i32.const 0x7f) (i32.const 0xff)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "as-i16x8_sub_sat_u-operands" (i32.const 0x7fff) (i32.const 0xffff)) (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+(assert_return (invoke "as-i8x16_shr_s-operand" (i32.const 0xf0) (i32.const 3)) (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "as-i16x8_shr_s-operand" (i32.const 0x100) (i32.const 4)) (v128.const i16x8 16 16 16 16 16 16 16 16))
+(assert_return (invoke "as-i32x4_shr_s-operand" (i32.const -1) (i32.const 16)) (v128.const i32x4 -1 -1 -1 -1))
+
+(assert_return (invoke "as-v128_and-operands" (i32.const 0x11) (i32.const 0xff)) (v128.const i8x16 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17))
+(assert_return (invoke "as-v128_or-operands" (i32.const 0) (i32.const 0xffff)) (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "as-v128_xor-operands" (i32.const 0xf0f0f0f0) (i32.const 0xffffffff)) (v128.const i32x4 0xf0f0f0f 0xf0f0f0f 0xf0f0f0f 0xf0f0f0f))
+
+(assert_return (invoke "as-i8x16_all_true-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-i16x8_all_true-operand" (i32.const 0xffff)) (i32.const 1))
+(assert_return (invoke "as-i32x4_all_true-operand1" (i32.const 0xf0f0f0f0)) (i32.const 1))
+(assert_return (invoke "as-i32x4_all_true-operand2" (i64.const -1)) (i32.const 1))
+
+(assert_return (invoke "as-i8x16_eq-operands" (i32.const 1) (i32.const 2)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "as-i16x8_eq-operands" (i32.const -1) (i32.const 65535)) (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "as-i32x4_eq-operands1" (i32.const -1) (i32.const 0xffffffff)) (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+(assert_return (invoke "as-f32x4_eq-operands" (f32.const +0.0) (f32.const -0.0)) (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+(assert_return (invoke "as-i32x4_eq-operands2" (i64.const 1) (i64.const 2)) (v128.const i64x2 0xffffffff00000000 0xffffffff00000000))
+(assert_return (invoke "as-f64x2_eq-operands" (f64.const +0.0) (f64.const -0.0)) (v128.const i64x2 -1 -1))
+
+(assert_return (invoke "as-f32x4_abs-operand" (f32.const -1.125)) (v128.const f32x4 1.125 1.125 1.125 1.125))
+(assert_return (invoke "as-f32x4_min-operands" (f32.const 0.25) (f32.const 1e-38)) (v128.const f32x4 1e-38 1e-38 1e-38 1e-38))
+(assert_return (invoke "as-f32x4_div-operands" (f32.const 1.0) (f32.const 8.0)) (v128.const f32x4 0.125 0.125 0.125 0.125))
+
+(assert_return (invoke "as-f32x4_convert_s_i32x4-operand" (i32.const 12345)) (v128.const f32x4 12345.0 12345.0 12345.0 12345.0))
+(assert_return (invoke "as-i32x4_trunc_s_f32x4_sat-operand" (f32.const 1.1)) (v128.const i32x4 1 1 1 1))
+
+
+;; As the argument of control constructs and WASM instructions
+
+(module
+  (global $g (mut v128) (v128.const f32x4 0.0 0.0 0.0 0.0))
+  (func (export "as-br-value1") (param i32) (result v128)
+    (block (result v128) (br 0 (i8x16.splat (local.get 0)))))
+  (func (export "as-return-value1") (param i32) (result v128)
+    (return (i16x8.splat (local.get 0))))
+  (func (export "as-local_set-value1") (param i32) (result v128) (local v128)
+    (local.set 1 (i32x4.splat (local.get 0)))
+    (return (local.get 1)))
+  (func (export "as-global_set-value1") (param f32) (result v128)
+    (global.set $g (f32x4.splat (local.get 0)))
+    (return (global.get $g)))
+  (func (export "as-br-value2") (param i64) (result v128)
+    (block (result v128) (br 0 (i64x2.splat (local.get 0)))))
+  (func (export "as-return-value2") (param i64) (result v128)
+    (return (i64x2.splat (local.get 0))))
+  (func (export "as-local_set-value2") (param i64) (result v128) (local v128)
+    (local.set 1 (i64x2.splat (local.get 0)))
+    (return (local.get 1)))
+  (func (export "as-global_set-value2") (param f64) (result v128)
+    (global.set $g (f64x2.splat (local.get 0)))
+    (return (global.get $g)))
+)
+
+(assert_return (invoke "as-br-value1" (i32.const 0xAB)) (v128.const i8x16 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB))
+(assert_return (invoke "as-return-value1" (i32.const 0xABCD)) (v128.const i16x8 0xABCD 0xABCD 0xABCD 0xABCD 0xABCD 0xABCD 0xABCD 0xABCD))
+(assert_return (invoke "as-local_set-value1" (i32.const 0x10000)) (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+(assert_return (invoke "as-global_set-value1" (f32.const 1.0)) (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "as-br-value2" (i64.const 0xABCD)) (v128.const i64x2 0xABCD 0xABCD))
+(assert_return (invoke "as-return-value2" (i64.const 0xABCD)) (v128.const i64x2 0xABCD 0xABCD))
+(assert_return (invoke "as-local_set-value2" (i64.const 0x10000)) (v128.const i64x2 0x10000 0x10000))
+(assert_return (invoke "as-global_set-value2" (f64.const 1.0)) (v128.const f64x2 1.0 1.0))
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.splat-arg-empty (result v128)
+      (i8x16.splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.splat-arg-empty (result v128)
+      (i16x8.splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.splat-arg-empty (result v128)
+      (i32x4.splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.splat-arg-empty (result v128)
+      (f32x4.splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.splat-arg-empty (result v128)
+      (i64x2.splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.splat-arg-empty (result v128)
+      (f64x2.splat)
+    )
+  )
+  "type mismatch"
+)
diff --git a/tests/wast/spec/simd_store.wast b/tests/wast/spec/simd_store.wast
new file mode 100644
index 0000000000..7bba053d8e
--- /dev/null
+++ b/tests/wast/spec/simd_store.wast
@@ -0,0 +1,166 @@
+;; v128.store operator with normal argument (e.g. (i8x16, i16x8, i32x4, f32x4))
+
+(module
+  (memory 1)
+  (func (export "v128.store_i8x16") (result v128)
+    (v128.store (i32.const 0) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i16x8") (result v128)
+    (v128.store (i32.const 0) (v128.const i16x8 0 1 2 3 4 5 6 7))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i16x8_2") (result v128)
+    (v128.store (i32.const 0) (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i16x8_3") (result v128)
+    (v128.store (i32.const 0) (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i32x4") (result v128)
+    (v128.store (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i32x4_2") (result v128)
+    (v128.store (i32.const 0) (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i32x4_3") (result v128)
+    (v128.store (i32.const 0) (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+    (v128.load (i32.const 0))
+  )
+
+  (func (export "v128.store_f32x4") (result v128)
+    (v128.store (i32.const 0) (v128.const f32x4 0 1 2 3))
+    (v128.load (i32.const 0))
+  )
+)
+
+(assert_return (invoke "v128.store_i8x16") (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "v128.store_i16x8") (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "v128.store_i16x8_2") (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+(assert_return (invoke "v128.store_i16x8_3") (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+(assert_return (invoke "v128.store_i32x4") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "v128.store_i32x4_2") (v128.const i32x4 123456789 123456789 123456789 123456789))
+(assert_return (invoke "v128.store_i32x4_3") (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+(assert_return (invoke "v128.store_f32x4") (v128.const f32x4 0 1 2 3))
+
+
+;; v128.store operator as the argument of control constructs and instructions
+
+(module
+  (memory 1)
+  (func (export "as-block-value")
+    (block (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+  )
+  (func (export "as-loop-value")
+    (loop (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+  )
+  (func (export "as-br-value")
+    (block (br 0 (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  )
+  (func (export "as-br_if-value")
+    (block
+      (br_if 0 (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)) (i32.const 1))
+    )
+  )
+  (func (export "as-br_if-value-cond")
+    (block
+      (br_if 0 (i32.const 6) (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+    )
+  )
+  (func (export "as-br_table-value")
+    (block
+      (br_table 0 (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)) (i32.const 1))
+    )
+  )
+  (func (export "as-return-value")
+    (return (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+  )
+  (func (export "as-if-then")
+    (if (i32.const 1) (then (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  )
+  (func (export "as-if-else")
+    (if (i32.const 0) (then) (else (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  )
+)
+
+(assert_return (invoke "as-block-value"))
+(assert_return (invoke "as-loop-value"))
+(assert_return (invoke "as-br-value"))
+(assert_return (invoke "as-br_if-value"))
+(assert_return (invoke "as-br_if-value-cond"))
+(assert_return (invoke "as-br_table-value"))
+(assert_return (invoke "as-return-value"))
+(assert_return (invoke "as-if-then"))
+(assert_return (invoke "as-if-else"))
+
+
+;; Unknown operator(e.g. v128.store8, v128.store16, v128.store32)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store8 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store16 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store32 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "unknown operator"
+)
+
+
+;; Type mismatched (e.g. v128.load(f32.const 0), type address empty)
+
+(assert_invalid
+  (module (memory 1) (func (v128.store (f32.const 0) (v128.const i32x4 0 0 0 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (local v128) (block (br_if 0 (v128.store)))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  "type mismatch"
+)
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module (memory 0)
+    (func $v128.store-1st-arg-empty
+      (v128.store (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.store-2nd-arg-empty
+      (v128.store (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.store-arg-empty
+      (v128.store)
+    )
+  )
+  "type mismatch"
+)
diff --git a/tests/wast/spec/simd_store16_lane.wast b/tests/wast/spec/simd_store16_lane.wast
new file mode 100644
index 0000000000..d8ea35c3fa
--- /dev/null
+++ b/tests/wast/spec/simd_store16_lane.wast
@@ -0,0 +1,299 @@
+;; Tests for store lane operations.
+
+
+(module
+  (memory 1)
+  (global $zero (mut v128) (v128.const i32x4 0 0 0 0))
+  (func (export "v128.store16_lane_0")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_3")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 4 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_5")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 5 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_6")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 6 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_7")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 7 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_0_offset_0")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=0 0 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=0 (i32.const 0)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_1_offset_1")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=1 1 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=1 (i32.const 0)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_2_offset_2")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=2 2 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=2 (i32.const 0)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_3_offset_3")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=3 3 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=3 (i32.const 0)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_4_offset_4")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=4 4 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=4 (i32.const 0)))
+    (v128.store offset=4 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_5_offset_5")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=5 5 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=5 (i32.const 0)))
+    (v128.store offset=5 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_6_offset_6")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=6 6 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=6 (i32.const 0)))
+    (v128.store offset=6 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_7_offset_7")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=7 7 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=7 (i32.const 0)))
+    (v128.store offset=7 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_0_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_0_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_1_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_1_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_2_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_2_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_3_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_3_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_4_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 4 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=4 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_4_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 4 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=4 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_5_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 5 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=5 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_5_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 5 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=5 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_6_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 6 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=6 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_6_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 6 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=6 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_7_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 7 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=7 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_7_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 7 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=7 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+)
+
+(assert_return (invoke "v128.store16_lane_0" (i32.const 0)
+                                             (v128.const i16x8 256 0 0 0 0 0 0 0))
+                                             (i64.const 256))
+(assert_return (invoke "v128.store16_lane_1" (i32.const 1)
+                                             (v128.const i16x8 0 513 0 0 0 0 0 0))
+                                             (i64.const 513))
+(assert_return (invoke "v128.store16_lane_2" (i32.const 2)
+                                             (v128.const i16x8 0 0 770 0 0 0 0 0))
+                                             (i64.const 770))
+(assert_return (invoke "v128.store16_lane_3" (i32.const 3)
+                                             (v128.const i16x8 0 0 0 1027 0 0 0 0))
+                                             (i64.const 1027))
+(assert_return (invoke "v128.store16_lane_4" (i32.const 4)
+                                             (v128.const i16x8 0 0 0 0 1284 0 0 0))
+                                             (i64.const 1284))
+(assert_return (invoke "v128.store16_lane_5" (i32.const 5)
+                                             (v128.const i16x8 0 0 0 0 0 1541 0 0))
+                                             (i64.const 1541))
+(assert_return (invoke "v128.store16_lane_6" (i32.const 6)
+                                             (v128.const i16x8 0 0 0 0 0 0 1798 0))
+                                             (i64.const 1798))
+(assert_return (invoke "v128.store16_lane_7" (i32.const 7)
+                                             (v128.const i16x8 0 0 0 0 0 0 0 2055))
+                                             (i64.const 2055))
+(assert_return (invoke "v128.store16_lane_0_offset_0" (v128.const i16x8 256 0 0 0 0 0 0 0))
+                                                      (i64.const 256))
+(assert_return (invoke "v128.store16_lane_1_offset_1" (v128.const i16x8 0 513 0 0 0 0 0 0))
+                                                      (i64.const 513))
+(assert_return (invoke "v128.store16_lane_2_offset_2" (v128.const i16x8 0 0 770 0 0 0 0 0))
+                                                      (i64.const 770))
+(assert_return (invoke "v128.store16_lane_3_offset_3" (v128.const i16x8 0 0 0 1027 0 0 0 0))
+                                                      (i64.const 1027))
+(assert_return (invoke "v128.store16_lane_4_offset_4" (v128.const i16x8 0 0 0 0 1284 0 0 0))
+                                                      (i64.const 1284))
+(assert_return (invoke "v128.store16_lane_5_offset_5" (v128.const i16x8 0 0 0 0 0 1541 0 0))
+                                                      (i64.const 1541))
+(assert_return (invoke "v128.store16_lane_6_offset_6" (v128.const i16x8 0 0 0 0 0 0 1798 0))
+                                                      (i64.const 1798))
+(assert_return (invoke "v128.store16_lane_7_offset_7" (v128.const i16x8 0 0 0 0 0 0 0 2055))
+                                                      (i64.const 2055))
+(assert_return (invoke "v128.store16_lane_0_align_1" (i32.const 0)
+                                                     (v128.const i16x8 256 0 0 0 0 0 0 0))
+                                                     (i64.const 256))
+(assert_return (invoke "v128.store16_lane_0_align_2" (i32.const 0)
+                                                     (v128.const i16x8 256 0 0 0 0 0 0 0))
+                                                     (i64.const 256))
+(assert_return (invoke "v128.store16_lane_1_align_1" (i32.const 1)
+                                                     (v128.const i16x8 0 513 0 0 0 0 0 0))
+                                                     (i64.const 513))
+(assert_return (invoke "v128.store16_lane_1_align_2" (i32.const 1)
+                                                     (v128.const i16x8 0 513 0 0 0 0 0 0))
+                                                     (i64.const 513))
+(assert_return (invoke "v128.store16_lane_2_align_1" (i32.const 2)
+                                                     (v128.const i16x8 0 0 770 0 0 0 0 0))
+                                                     (i64.const 770))
+(assert_return (invoke "v128.store16_lane_2_align_2" (i32.const 2)
+                                                     (v128.const i16x8 0 0 770 0 0 0 0 0))
+                                                     (i64.const 770))
+(assert_return (invoke "v128.store16_lane_3_align_1" (i32.const 3)
+                                                     (v128.const i16x8 0 0 0 1027 0 0 0 0))
+                                                     (i64.const 1027))
+(assert_return (invoke "v128.store16_lane_3_align_2" (i32.const 3)
+                                                     (v128.const i16x8 0 0 0 1027 0 0 0 0))
+                                                     (i64.const 1027))
+(assert_return (invoke "v128.store16_lane_4_align_1" (i32.const 4)
+                                                     (v128.const i16x8 0 0 0 0 1284 0 0 0))
+                                                     (i64.const 1284))
+(assert_return (invoke "v128.store16_lane_4_align_2" (i32.const 4)
+                                                     (v128.const i16x8 0 0 0 0 1284 0 0 0))
+                                                     (i64.const 1284))
+(assert_return (invoke "v128.store16_lane_5_align_1" (i32.const 5)
+                                                     (v128.const i16x8 0 0 0 0 0 1541 0 0))
+                                                     (i64.const 1541))
+(assert_return (invoke "v128.store16_lane_5_align_2" (i32.const 5)
+                                                     (v128.const i16x8 0 0 0 0 0 1541 0 0))
+                                                     (i64.const 1541))
+(assert_return (invoke "v128.store16_lane_6_align_1" (i32.const 6)
+                                                     (v128.const i16x8 0 0 0 0 0 0 1798 0))
+                                                     (i64.const 1798))
+(assert_return (invoke "v128.store16_lane_6_align_2" (i32.const 6)
+                                                     (v128.const i16x8 0 0 0 0 0 0 1798 0))
+                                                     (i64.const 1798))
+(assert_return (invoke "v128.store16_lane_7_align_1" (i32.const 7)
+                                                     (v128.const i16x8 0 0 0 0 0 0 0 2055))
+                                                     (i64.const 2055))
+(assert_return (invoke "v128.store16_lane_7_align_2" (i32.const 7)
+                                                     (v128.const i16x8 0 0 0 0 0 0 0 2055))
+                                                     (i64.const 2055))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store16_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store16_lane 8 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.store16_lane align=4 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/tests/wast/spec/simd_store32_lane.wast b/tests/wast/spec/simd_store32_lane.wast
new file mode 100644
index 0000000000..847bab9e6f
--- /dev/null
+++ b/tests/wast/spec/simd_store32_lane.wast
@@ -0,0 +1,199 @@
+;; Tests for store lane operations.
+
+
+(module
+  (memory 1)
+  (global $zero (mut v128) (v128.const i32x4 0 0 0 0))
+  (func (export "v128.store32_lane_0")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store32_lane_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store32_lane_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store32_lane_3")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store32_lane_0_offset_0")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane offset=0 0 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=0 (i32.const 0)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_1_offset_1")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane offset=1 1 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=1 (i32.const 0)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_2_offset_2")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane offset=2 2 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=2 (i32.const 0)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_3_offset_3")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane offset=3 3 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=3 (i32.const 0)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_0_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=1 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_0_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=2 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_0_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=4 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_1_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=1 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_1_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=2 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_1_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=4 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_2_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=1 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_2_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=2 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_2_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=4 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_3_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=1 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_3_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=2 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_3_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=4 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+)
+
+(assert_return (invoke "v128.store32_lane_0" (i32.const 0)
+                                             (v128.const i32x4 50462976 0 0 0))
+                                             (i64.const 50462976))
+(assert_return (invoke "v128.store32_lane_1" (i32.const 1)
+                                             (v128.const i32x4 0 67305985 0 0))
+                                             (i64.const 67305985))
+(assert_return (invoke "v128.store32_lane_2" (i32.const 2)
+                                             (v128.const i32x4 0 0 84148994 0))
+                                             (i64.const 84148994))
+(assert_return (invoke "v128.store32_lane_3" (i32.const 3)
+                                             (v128.const i32x4 0 0 0 100992003))
+                                             (i64.const 100992003))
+(assert_return (invoke "v128.store32_lane_0_offset_0" (v128.const i32x4 50462976 0 0 0))
+                                                      (i64.const 50462976))
+(assert_return (invoke "v128.store32_lane_1_offset_1" (v128.const i32x4 0 67305985 0 0))
+                                                      (i64.const 67305985))
+(assert_return (invoke "v128.store32_lane_2_offset_2" (v128.const i32x4 0 0 84148994 0))
+                                                      (i64.const 84148994))
+(assert_return (invoke "v128.store32_lane_3_offset_3" (v128.const i32x4 0 0 0 100992003))
+                                                      (i64.const 100992003))
+(assert_return (invoke "v128.store32_lane_0_align_1" (i32.const 0)
+                                                     (v128.const i32x4 50462976 0 0 0))
+                                                     (i64.const 50462976))
+(assert_return (invoke "v128.store32_lane_0_align_2" (i32.const 0)
+                                                     (v128.const i32x4 50462976 0 0 0))
+                                                     (i64.const 50462976))
+(assert_return (invoke "v128.store32_lane_0_align_4" (i32.const 0)
+                                                     (v128.const i32x4 50462976 0 0 0))
+                                                     (i64.const 50462976))
+(assert_return (invoke "v128.store32_lane_1_align_1" (i32.const 1)
+                                                     (v128.const i32x4 0 67305985 0 0))
+                                                     (i64.const 67305985))
+(assert_return (invoke "v128.store32_lane_1_align_2" (i32.const 1)
+                                                     (v128.const i32x4 0 67305985 0 0))
+                                                     (i64.const 67305985))
+(assert_return (invoke "v128.store32_lane_1_align_4" (i32.const 1)
+                                                     (v128.const i32x4 0 67305985 0 0))
+                                                     (i64.const 67305985))
+(assert_return (invoke "v128.store32_lane_2_align_1" (i32.const 2)
+                                                     (v128.const i32x4 0 0 84148994 0))
+                                                     (i64.const 84148994))
+(assert_return (invoke "v128.store32_lane_2_align_2" (i32.const 2)
+                                                     (v128.const i32x4 0 0 84148994 0))
+                                                     (i64.const 84148994))
+(assert_return (invoke "v128.store32_lane_2_align_4" (i32.const 2)
+                                                     (v128.const i32x4 0 0 84148994 0))
+                                                     (i64.const 84148994))
+(assert_return (invoke "v128.store32_lane_3_align_1" (i32.const 3)
+                                                     (v128.const i32x4 0 0 0 100992003))
+                                                     (i64.const 100992003))
+(assert_return (invoke "v128.store32_lane_3_align_2" (i32.const 3)
+                                                     (v128.const i32x4 0 0 0 100992003))
+                                                     (i64.const 100992003))
+(assert_return (invoke "v128.store32_lane_3_align_4" (i32.const 3)
+                                                     (v128.const i32x4 0 0 0 100992003))
+                                                     (i64.const 100992003))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store32_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store32_lane 4 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.store32_lane align=8 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/tests/wast/spec/simd_store64_lane.wast b/tests/wast/spec/simd_store64_lane.wast
new file mode 100644
index 0000000000..2ed1dcd689
--- /dev/null
+++ b/tests/wast/spec/simd_store64_lane.wast
@@ -0,0 +1,131 @@
+;; Tests for store lane operations.
+
+
+(module
+  (memory 1)
+  (global $zero (mut v128) (v128.const i32x4 0 0 0 0))
+  (func (export "v128.store64_lane_0")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store64_lane_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store64_lane_0_offset_0")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane offset=0 0 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=0 (i32.const 0)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_1_offset_1")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane offset=1 1 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=1 (i32.const 0)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_0_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=1 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_0_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=2 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_0_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=4 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_0_align_8")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=8 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_1_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=1 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_1_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=2 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_1_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=4 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_1_align_8")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=8 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+)
+
+(assert_return (invoke "v128.store64_lane_0" (i32.const 0)
+                                             (v128.const i64x2 506097522914230528 0))
+                                             (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_1" (i32.const 1)
+                                             (v128.const i64x2 0 578437695752307201))
+                                             (i64.const 578437695752307201))
+(assert_return (invoke "v128.store64_lane_0_offset_0" (v128.const i64x2 506097522914230528 0))
+                                                      (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_1_offset_1" (v128.const i64x2 0 578437695752307201))
+                                                      (i64.const 578437695752307201))
+(assert_return (invoke "v128.store64_lane_0_align_1" (i32.const 0)
+                                                     (v128.const i64x2 506097522914230528 0))
+                                                     (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_0_align_2" (i32.const 0)
+                                                     (v128.const i64x2 506097522914230528 0))
+                                                     (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_0_align_4" (i32.const 0)
+                                                     (v128.const i64x2 506097522914230528 0))
+                                                     (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_0_align_8" (i32.const 0)
+                                                     (v128.const i64x2 506097522914230528 0))
+                                                     (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_1_align_1" (i32.const 1)
+                                                     (v128.const i64x2 0 578437695752307201))
+                                                     (i64.const 578437695752307201))
+(assert_return (invoke "v128.store64_lane_1_align_2" (i32.const 1)
+                                                     (v128.const i64x2 0 578437695752307201))
+                                                     (i64.const 578437695752307201))
+(assert_return (invoke "v128.store64_lane_1_align_4" (i32.const 1)
+                                                     (v128.const i64x2 0 578437695752307201))
+                                                     (i64.const 578437695752307201))
+(assert_return (invoke "v128.store64_lane_1_align_8" (i32.const 1)
+                                                     (v128.const i64x2 0 578437695752307201))
+                                                     (i64.const 578437695752307201))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store64_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store64_lane 2 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.store64_lane align=16 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/tests/wast/spec/simd_store8_lane.wast b/tests/wast/spec/simd_store8_lane.wast
new file mode 100644
index 0000000000..b4e4a583f1
--- /dev/null
+++ b/tests/wast/spec/simd_store8_lane.wast
@@ -0,0 +1,427 @@
+;; Tests for store lane operations.
+
+
+(module
+  (memory 1)
+  (global $zero (mut v128) (v128.const i32x4 0 0 0 0))
+  (func (export "v128.store8_lane_0")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_3")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 4 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_5")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 5 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_6")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 6 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_7")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 7 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_8")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 8 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_9")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 9 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_10")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 10 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_11")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 11 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_12")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 12 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_13")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 13 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_14")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 14 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_15")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 15 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_0_offset_0")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=0 0 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=0 (i32.const 0)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_1_offset_1")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=1 1 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=1 (i32.const 0)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_2_offset_2")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=2 2 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=2 (i32.const 0)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_3_offset_3")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=3 3 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=3 (i32.const 0)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_4_offset_4")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=4 4 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=4 (i32.const 0)))
+    (v128.store offset=4 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_5_offset_5")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=5 5 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=5 (i32.const 0)))
+    (v128.store offset=5 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_6_offset_6")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=6 6 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=6 (i32.const 0)))
+    (v128.store offset=6 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_7_offset_7")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=7 7 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=7 (i32.const 0)))
+    (v128.store offset=7 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_8_offset_8")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=8 8 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=8 (i32.const 0)))
+    (v128.store offset=8 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_9_offset_9")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=9 9 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=9 (i32.const 0)))
+    (v128.store offset=9 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_10_offset_10")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=10 10 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=10 (i32.const 0)))
+    (v128.store offset=10 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_11_offset_11")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=11 11 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=11 (i32.const 0)))
+    (v128.store offset=11 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_12_offset_12")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=12 12 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=12 (i32.const 0)))
+    (v128.store offset=12 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_13_offset_13")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=13 13 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=13 (i32.const 0)))
+    (v128.store offset=13 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_14_offset_14")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=14 14 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=14 (i32.const 0)))
+    (v128.store offset=14 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_15_offset_15")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=15 15 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=15 (i32.const 0)))
+    (v128.store offset=15 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_0_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_1_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_2_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_3_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_4_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 4 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=4 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_5_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 5 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=5 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_6_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 6 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=6 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_7_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 7 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=7 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_8_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 8 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=8 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_9_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 9 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=9 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_10_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 10 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=10 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_11_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 11 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=11 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_12_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 12 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=12 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_13_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 13 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=13 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_14_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 14 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=14 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_15_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 15 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=15 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+)
+
+(assert_return (invoke "v128.store8_lane_0" (i32.const 0)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 0))
+(assert_return (invoke "v128.store8_lane_1" (i32.const 1)
+                                            (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 1))
+(assert_return (invoke "v128.store8_lane_2" (i32.const 2)
+                                            (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 2))
+(assert_return (invoke "v128.store8_lane_3" (i32.const 3)
+                                            (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 3))
+(assert_return (invoke "v128.store8_lane_4" (i32.const 4)
+                                            (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 4))
+(assert_return (invoke "v128.store8_lane_5" (i32.const 5)
+                                            (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 5))
+(assert_return (invoke "v128.store8_lane_6" (i32.const 6)
+                                            (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 6))
+(assert_return (invoke "v128.store8_lane_7" (i32.const 7)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+                                            (i64.const 7))
+(assert_return (invoke "v128.store8_lane_8" (i32.const 8)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+                                            (i64.const 8))
+(assert_return (invoke "v128.store8_lane_9" (i32.const 9)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+                                            (i64.const 9))
+(assert_return (invoke "v128.store8_lane_10" (i32.const 10)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+                                             (i64.const 10))
+(assert_return (invoke "v128.store8_lane_11" (i32.const 11)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+                                             (i64.const 11))
+(assert_return (invoke "v128.store8_lane_12" (i32.const 12)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+                                             (i64.const 12))
+(assert_return (invoke "v128.store8_lane_13" (i32.const 13)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+                                             (i64.const 13))
+(assert_return (invoke "v128.store8_lane_14" (i32.const 14)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+                                             (i64.const 14))
+(assert_return (invoke "v128.store8_lane_15" (i32.const 15)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+                                             (i64.const 15))
+(assert_return (invoke "v128.store8_lane_0_offset_0" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 0))
+(assert_return (invoke "v128.store8_lane_1_offset_1" (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 1))
+(assert_return (invoke "v128.store8_lane_2_offset_2" (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 2))
+(assert_return (invoke "v128.store8_lane_3_offset_3" (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 3))
+(assert_return (invoke "v128.store8_lane_4_offset_4" (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 4))
+(assert_return (invoke "v128.store8_lane_5_offset_5" (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 5))
+(assert_return (invoke "v128.store8_lane_6_offset_6" (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 6))
+(assert_return (invoke "v128.store8_lane_7_offset_7" (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+                                                     (i64.const 7))
+(assert_return (invoke "v128.store8_lane_8_offset_8" (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+                                                     (i64.const 8))
+(assert_return (invoke "v128.store8_lane_9_offset_9" (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+                                                     (i64.const 9))
+(assert_return (invoke "v128.store8_lane_10_offset_10" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+                                                       (i64.const 10))
+(assert_return (invoke "v128.store8_lane_11_offset_11" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+                                                       (i64.const 11))
+(assert_return (invoke "v128.store8_lane_12_offset_12" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+                                                       (i64.const 12))
+(assert_return (invoke "v128.store8_lane_13_offset_13" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+                                                       (i64.const 13))
+(assert_return (invoke "v128.store8_lane_14_offset_14" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+                                                       (i64.const 14))
+(assert_return (invoke "v128.store8_lane_15_offset_15" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+                                                       (i64.const 15))
+(assert_return (invoke "v128.store8_lane_0_align_1" (i32.const 0)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 0))
+(assert_return (invoke "v128.store8_lane_1_align_1" (i32.const 1)
+                                                    (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 1))
+(assert_return (invoke "v128.store8_lane_2_align_1" (i32.const 2)
+                                                    (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 2))
+(assert_return (invoke "v128.store8_lane_3_align_1" (i32.const 3)
+                                                    (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 3))
+(assert_return (invoke "v128.store8_lane_4_align_1" (i32.const 4)
+                                                    (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 4))
+(assert_return (invoke "v128.store8_lane_5_align_1" (i32.const 5)
+                                                    (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 5))
+(assert_return (invoke "v128.store8_lane_6_align_1" (i32.const 6)
+                                                    (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 6))
+(assert_return (invoke "v128.store8_lane_7_align_1" (i32.const 7)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+                                                    (i64.const 7))
+(assert_return (invoke "v128.store8_lane_8_align_1" (i32.const 8)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+                                                    (i64.const 8))
+(assert_return (invoke "v128.store8_lane_9_align_1" (i32.const 9)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+                                                    (i64.const 9))
+(assert_return (invoke "v128.store8_lane_10_align_1" (i32.const 10)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+                                                     (i64.const 10))
+(assert_return (invoke "v128.store8_lane_11_align_1" (i32.const 11)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+                                                     (i64.const 11))
+(assert_return (invoke "v128.store8_lane_12_align_1" (i32.const 12)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+                                                     (i64.const 12))
+(assert_return (invoke "v128.store8_lane_13_align_1" (i32.const 13)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+                                                     (i64.const 13))
+(assert_return (invoke "v128.store8_lane_14_align_1" (i32.const 14)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+                                                     (i64.const 14))
+(assert_return (invoke "v128.store8_lane_15_align_1" (i32.const 15)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+                                                     (i64.const 15))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store8_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store8_lane 16 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.store8_lane align=2 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
diff --git a/tests/wast/spec/table_fill.wast b/tests/wast/spec/table_fill.wast
index 3df64da1ab..a8e2225520 100644
--- a/tests/wast/spec/table_fill.wast
+++ b/tests/wast/spec/table_fill.wast
@@ -5,6 +5,10 @@
     (table.fill $t (local.get $i) (local.get $r) (local.get $n))
   )
 
+  (func (export "fill-abbrev") (param $i i32) (param $r externref) (param $n i32)
+    (table.fill (local.get $i) (local.get $r) (local.get $n))
+  )
+
   (func (export "get") (param $i i32) (result externref)
     (table.get $t (local.get $i))
   )
@@ -39,7 +43,7 @@
 (assert_return (invoke "get" (i32.const 8)) (ref.extern 4))
 (assert_return (invoke "get" (i32.const 9)) (ref.extern 4))
 
-(assert_return (invoke "fill" (i32.const 9) (ref.null extern) (i32.const 1)))
+(assert_return (invoke "fill-abbrev" (i32.const 9) (ref.null extern) (i32.const 1)))
 (assert_return (invoke "get" (i32.const 8)) (ref.extern 4))
 (assert_return (invoke "get" (i32.const 9)) (ref.null extern))
 
diff --git a/tests/wast/spec/table_get.wast b/tests/wast/spec/table_get.wast
index 5d57c31983..0dedb19f51 100644
--- a/tests/wast/spec/table_get.wast
+++ b/tests/wast/spec/table_get.wast
@@ -10,7 +10,7 @@
   )
 
   (func (export "get-externref") (param $i i32) (result externref)
-    (table.get $t2 (local.get $i))
+    (table.get (local.get $i))
   )
   (func $f3 (export "get-funcref") (param $i i32) (result funcref)
     (table.get $t3 (local.get $i))
diff --git a/tests/wast/spec/table_grow.wast b/tests/wast/spec/table_grow.wast
index 7d5b5630fc..5345a800ff 100644
--- a/tests/wast/spec/table_grow.wast
+++ b/tests/wast/spec/table_grow.wast
@@ -7,6 +7,9 @@
   (func (export "grow") (param $sz i32) (param $init externref) (result i32)
     (table.grow $t (local.get $init) (local.get $sz))
   )
+  (func (export "grow-abbrev") (param $sz i32) (param $init externref) (result i32)
+    (table.grow (local.get $init) (local.get $sz))
+  )
   (func (export "size") (result i32) (table.size $t))
 )
 
@@ -22,7 +25,7 @@
 (assert_trap (invoke "set" (i32.const 1) (ref.extern 2)) "out of bounds table access")
 (assert_trap (invoke "get" (i32.const 1)) "out of bounds table access")
 
-(assert_return (invoke "grow" (i32.const 4) (ref.extern 3)) (i32.const 1))
+(assert_return (invoke "grow-abbrev" (i32.const 4) (ref.extern 3)) (i32.const 1))
 (assert_return (invoke "size") (i32.const 5))
 (assert_return (invoke "get" (i32.const 0)) (ref.extern 2))
 (assert_return (invoke "set" (i32.const 0) (ref.extern 2)))
@@ -105,6 +108,27 @@
 (assert_return (invoke "check-table-null" (i32.const 0) (i32.const 19)) (ref.null func))
 
 
+(module $Tgt
+  (table (export "table") 1 funcref) ;; initial size is 1
+  (func (export "grow") (result i32) (table.grow (ref.null func) (i32.const 1)))
+)
+(register "grown-table" $Tgt)
+(assert_return (invoke $Tgt "grow") (i32.const 1)) ;; now size is 2
+(module $Tgit1
+  ;; imported table limits should match, because external table size is 2 now
+  (table (export "table") (import "grown-table" "table") 2 funcref)
+  (func (export "grow") (result i32) (table.grow (ref.null func) (i32.const 1)))
+)
+(register "grown-imported-table" $Tgit1)
+(assert_return (invoke $Tgit1 "grow") (i32.const 2)) ;; now size is 3
+(module $Tgit2
+  ;; imported table limits should match, because external table size is 3 now
+  (import "grown-imported-table" "table" (table 3 funcref))
+  (func (export "size") (result i32) (table.size))
+)
+(assert_return (invoke $Tgit2 "size") (i32.const 3))
+
+
 ;; Type errors
 
 (assert_invalid
diff --git a/tests/wast/spec/table_set.wast b/tests/wast/spec/table_set.wast
index 5a9cfa3715..3362f95673 100644
--- a/tests/wast/spec/table_set.wast
+++ b/tests/wast/spec/table_set.wast
@@ -12,7 +12,7 @@
   )
 
   (func (export "set-externref") (param $i i32) (param $r externref)
-    (table.set $t2 (local.get $i) (local.get $r))
+    (table.set (local.get $i) (local.get $r))
   )
   (func (export "set-funcref") (param $i i32) (param $r funcref)
     (table.set $t3 (local.get $i) (local.get $r))
diff --git a/tests/wast/spec/table_size.wast b/tests/wast/spec/table_size.wast
index ad293b5ee4..83fef02b33 100644
--- a/tests/wast/spec/table_size.wast
+++ b/tests/wast/spec/table_size.wast
@@ -4,7 +4,7 @@
   (table $t2 0 2 externref)
   (table $t3 3 8 externref)
 
-  (func (export "size-t0") (result i32) (table.size $t0))
+  (func (export "size-t0") (result i32) table.size)
   (func (export "size-t1") (result i32) (table.size $t1))
   (func (export "size-t2") (result i32) (table.size $t2))
   (func (export "size-t3") (result i32) (table.size $t3))
diff --git a/tests/wast/spec/token.wast b/tests/wast/spec/token.wast
index 1dcd32e7f7..624bdca6d8 100644
--- a/tests/wast/spec/token.wast
+++ b/tests/wast/spec/token.wast
@@ -8,3 +8,279 @@
   (module quote "(func br 0drop)")
   "unknown operator"
 )
+
+
+;; Tokens can be delimited by parentheses
+
+(module
+  (func(nop))
+)
+(module
+  (func (nop)nop)
+)
+(module
+  (func nop(nop))
+)
+(module
+  (func(nop)(nop))
+)
+(module
+  (func $f(nop))
+)
+(module
+  (func br 0(nop))
+)
+(module
+  (table 1 funcref)
+  (func)
+  (elem (i32.const 0)0)
+)
+(module
+  (table 1 funcref)
+  (func $f)
+  (elem (i32.const 0)$f)
+)
+(module
+  (memory 1)
+  (data (i32.const 0)"a")
+)
+(module
+  (import "spectest" "print"(func))
+)
+
+
+;; Tokens can be delimited by comments
+
+(module
+  (func;;bla
+  )
+)
+(module
+  (func (nop);;bla
+  )
+)
+(module
+  (func nop;;bla
+  )
+)
+(module
+  (func $f;;bla
+  )
+)
+(module
+  (func br 0;;bla
+  )
+)
+(module
+  (data "a";;bla
+  )
+)
+
+
+;; Space required between symbols and non-parenthesis tokens
+
+(module
+  (func (block $l (i32.const 0) (br_table 0 $l)))
+)
+(assert_malformed
+  (module quote
+    "(func (block $l (i32.const 0) (br_table 0$l)))"
+  )
+  "unknown operator"
+)
+
+(module
+  (func (block $l (i32.const 0) (br_table $l 0)))
+)
+(assert_malformed
+  (module quote
+    "(func (block $l (i32.const 0) (br_table $l0)))"
+  )
+  "unknown label"
+)
+
+(module
+  (func (block $l (i32.const 0) (br_table $l $l)))
+)
+(assert_malformed
+  (module quote
+    "(func (block $l (i32.const 0) (br_table $l$l)))"
+  )
+  "unknown label"
+)
+
+(module
+  (func (block $l0 (i32.const 0) (br_table $l0)))
+)
+(module
+  (func (block $l$l (i32.const 0) (br_table $l$l)))
+)
+
+
+;; Space required between strings and non-parenthesis tokens
+
+(module
+  (data "a")
+)
+(assert_malformed
+  (module quote
+    "(data\"a\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data $l "a")
+)
+(assert_malformed
+  (module quote
+    "(data $l\"a\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data $l " a")
+)
+(assert_malformed
+  (module quote
+    "(data $l\" a\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data $l "a ")
+)
+(assert_malformed
+  (module quote
+    "(data $l\"a \")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data $l "a " "b")
+)
+(assert_malformed
+  (module quote
+    "(data $l\"a \"\"b\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data $l "")
+)
+(assert_malformed
+  (module quote
+    "(data $l\"\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data $l " ")
+)
+(assert_malformed
+  (module quote
+    "(data $l\" \")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data $l " ")
+)
+(assert_malformed
+  (module quote
+    "(data $l\" \")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data "a" "b")
+)
+(assert_malformed
+  (module quote
+    "(data \"a\"\"b\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data "a" " b")
+)
+(assert_malformed
+  (module quote
+    "(data \"a\"\" b\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data "a " "b")
+)
+(assert_malformed
+  (module quote
+    "(data \"a \"\"b\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data "" "")
+)
+(assert_malformed
+  (module quote
+    "(data \"\"\"\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data "" " ")
+)
+(assert_malformed
+  (module quote
+    "(data \"\"\" \")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data " " "")
+)
+(assert_malformed
+  (module quote
+    "(data \" \"\"\")"
+  )
+  "unknown operator"
+)
+
+
+(assert_malformed
+  (module quote
+    "(func \"a\"x)"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(func \"a\"0)"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(func 0\"a\")"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(func \"a\"$x)"
+  )
+  "unknown operator"
+)
diff --git a/tests/wast/spec/type.wast b/tests/wast/spec/type.wast
index b94063e6a0..aad40dd16f 100644
--- a/tests/wast/spec/type.wast
+++ b/tests/wast/spec/type.wast
@@ -42,7 +42,7 @@
 
 (assert_malformed
   (module quote "(type (func (result i32) (param i32)))")
-  "result before parameter"
+  "unexpected token"
 )
 (assert_malformed
   (module quote "(type (func (result $x i32)))")
diff --git a/tests/wast/spec/unreachable.wast b/tests/wast/spec/unreachable.wast
index 3074847a3e..19f661be1d 100644
--- a/tests/wast/spec/unreachable.wast
+++ b/tests/wast/spec/unreachable.wast
@@ -6,8 +6,8 @@
   (func $dummy3 (param i32 i32 i32))
 
   (func (export "type-i32") (result i32) (unreachable))
-  (func (export "type-i64") (result i32) (unreachable))
-  (func (export "type-f32") (result f64) (unreachable))
+  (func (export "type-i64") (result i64) (unreachable))
+  (func (export "type-f32") (result f32) (unreachable))
   (func (export "type-f64") (result f64) (unreachable))
 
   (func (export "as-func-first") (result i32)
diff --git a/tests/wast/spec/unreached-invalid.wast b/tests/wast/spec/unreached-invalid.wast
index 3ddd77385f..5889ba1149 100644
--- a/tests/wast/spec/unreached-invalid.wast
+++ b/tests/wast/spec/unreached-invalid.wast
@@ -693,3 +693,58 @@
   )
  "type mismatch"
 )
+
+;; The first two operands should have the same type as each other
+(assert_invalid
+  (module (func (unreachable) (select (i32.const 1) (i64.const 1) (i32.const 1)) (drop)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func (unreachable) (select (i64.const 1) (i32.const 1) (i32.const 1)) (drop)))
+  "type mismatch"
+)
+
+;; Third operand must be i32
+(assert_invalid
+  (module (func (unreachable) (select (i32.const 1) (i32.const 1) (i64.const 1)) (drop)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func (unreachable) (select (i32.const 1) (i64.const 1)) (drop)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func (unreachable) (select (i64.const 1)) (drop)))
+  "type mismatch"
+)
+
+;; Result of select has type of first two operands (type of second operand when first one is omitted)
+(assert_invalid
+  (module (func (result i32) (unreachable) (select (i64.const 1) (i32.const 1))))
+  "type mismatch"
+)
+
+
+;; select always has non-empty result
+(assert_invalid
+  (module (func (unreachable) (select)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $meet-bottom (param i32) (result externref)
+    (block $l1 (result externref)
+      (drop
+        (block $l2 (result i32)
+          (br_table $l2 $l1 $l2 (ref.null extern) (local.get 0))
+        )
+      )
+      (ref.null extern)
+    )
+  ))
+  "type mismatch"
+)
+
diff --git a/tests/wast/spec/unreached-valid.wast b/tests/wast/spec/unreached-valid.wast
new file mode 100644
index 0000000000..b7ebabfdb1
--- /dev/null
+++ b/tests/wast/spec/unreached-valid.wast
@@ -0,0 +1,63 @@
+(module
+
+  ;; Check that both sides of the select are evaluated
+  (func (export "select-trap-left") (param $cond i32) (result i32)
+    (select (unreachable) (i32.const 0) (local.get $cond))
+  )
+  (func (export "select-trap-right") (param $cond i32) (result i32)
+    (select (i32.const 0) (unreachable) (local.get $cond))
+  )
+
+  (func (export "select-unreached")
+    (unreachable) (select)
+    (unreachable) (i32.const 0) (select)
+    (unreachable) (i32.const 0) (i32.const 0) (select)
+    (unreachable) (i32.const 0) (i32.const 0) (i32.const 0) (select)
+    (unreachable) (f32.const 0) (i32.const 0) (select)
+    (unreachable)
+  )
+
+  (func (export "select_unreached_result_1") (result i32)
+    (unreachable) (i32.add (select))
+  )
+
+  (func (export "select_unreached_result_2") (result i64)
+    (unreachable) (i64.add (select (i64.const 0) (i32.const 0)))
+  )
+
+  (func (export "unreachable-num")
+    (unreachable)
+    (select)
+    (i32.eqz)
+    (drop)
+  )
+  (func (export "unreachable-ref")
+    (unreachable)
+    (select)
+    (ref.is_null)
+    (drop)
+  )
+)
+
+(assert_trap (invoke "select-trap-left" (i32.const 1)) "unreachable")
+(assert_trap (invoke "select-trap-left" (i32.const 0)) "unreachable")
+(assert_trap (invoke "select-trap-right" (i32.const 1)) "unreachable")
+(assert_trap (invoke "select-trap-right" (i32.const 0)) "unreachable")
+
+;; Validation after unreachable
+
+(module
+  (func (export "meet-bottom")
+    (block (result f64)
+      (block (result f32)
+        (unreachable)
+        (br_table 0 1 1 (i32.const 1))
+      )
+      (drop)
+      (f64.const 0)
+    )
+    (drop)
+  )
+)
+
+(assert_trap (invoke "meet-bottom") "unreachable")
diff --git a/tests/wast/spec/utf8-custom-section-id.wast b/tests/wast/spec/utf8-custom-section-id.wast
index ee5fd7ccb7..c3765d9da8 100644
--- a/tests/wast/spec/utf8-custom-section-id.wast
+++ b/tests/wast/spec/utf8-custom-section-id.wast
@@ -136,7 +136,7 @@
   "malformed UTF-8 encoding"
 )
 
-;; byte after (first) 2-byte prefix not a contination byte
+;; byte after (first) 2-byte prefix not a continuation byte
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
diff --git a/tests/wast/spec/utf8-import-field.wast b/tests/wast/spec/utf8-import-field.wast
index 0d030dabb1..330ecf61c8 100644
--- a/tests/wast/spec/utf8-import-field.wast
+++ b/tests/wast/spec/utf8-import-field.wast
@@ -201,7 +201,7 @@
   "malformed UTF-8 encoding"
 )
 
-;; byte after (first) 2-byte prefix not a contination byte
+;; byte after (first) 2-byte prefix not a continuation byte
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
diff --git a/tests/wast/spec/utf8-import-module.wast b/tests/wast/spec/utf8-import-module.wast
index 5a092da08a..8f509159d7 100644
--- a/tests/wast/spec/utf8-import-module.wast
+++ b/tests/wast/spec/utf8-import-module.wast
@@ -201,7 +201,7 @@
   "malformed UTF-8 encoding"
 )
 
-;; byte after (first) 2-byte prefix not a contination byte
+;; byte after (first) 2-byte prefix not a continuation byte
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
diff --git a/tests/wast/wasmer/README.md b/tests/wast/wasmer/README.md
index 17d398c6aa..2d8c82332b 100644
--- a/tests/wast/wasmer/README.md
+++ b/tests/wast/wasmer/README.md
@@ -36,3 +36,7 @@ This is a simple test to check that a divide by zero is correctly trapped
 ## Atomic Load: `atomic_load.wast`
 
 This is a simple test to check that load an atomic "to far" in memory trigger a OutOfBound trap
+
+## Nested Unreachable Blocks: `nested_unreachable_blocks.wast`
+
+This was broken at one point in our LLVM backend. Otherwise, it's nothing specific.
diff --git a/tests/wast/wasmer/nan-canonicalization.wast b/tests/wast/wasmer/nan-canonicalization.wast
index 748029bf5d..ff24dc1bfa 100644
--- a/tests/wast/wasmer/nan-canonicalization.wast
+++ b/tests/wast/wasmer/nan-canonicalization.wast
@@ -19,137 +19,137 @@
   (memory 1)
 
   (func (export "nan-canonicalization-f32-add") (param i32) (result i32)
-    (i32.reinterpret_f32 (f32.add (f32.reinterpret_i32 (get_local 0)) (f32.const 0)))
+    (i32.reinterpret_f32 (f32.add (f32.reinterpret_i32 (local.get 0)) (f32.const 0)))
   )
   (func (export "nan-canonicalization-f32-sub") (param i32) (result i32)
-    (i32.reinterpret_f32 (f32.sub (f32.reinterpret_i32 (get_local 0)) (f32.const 0)))
+    (i32.reinterpret_f32 (f32.sub (f32.reinterpret_i32 (local.get 0)) (f32.const 0)))
   )
   (func (export "nan-canonicalization-f32-mul") (param i32) (result i32)
-    (i32.reinterpret_f32 (f32.mul (f32.reinterpret_i32 (get_local 0)) (f32.const 0)))
+    (i32.reinterpret_f32 (f32.mul (f32.reinterpret_i32 (local.get 0)) (f32.const 0)))
   )
   (func (export "nan-canonicalization-f32-div") (param i32) (result i32)
-    (i32.reinterpret_f32 (f32.div (f32.reinterpret_i32 (get_local 0)) (f32.const 1)))
+    (i32.reinterpret_f32 (f32.div (f32.reinterpret_i32 (local.get 0)) (f32.const 1)))
   )
   (func (export "nan-canonicalization-f32-max") (param i32) (result i32)
-    (i32.reinterpret_f32 (f32.max (f32.reinterpret_i32 (get_local 0)) (f32.const 1)))
+    (i32.reinterpret_f32 (f32.max (f32.reinterpret_i32 (local.get 0)) (f32.const 1)))
   )
   (func (export "nan-canonicalization-f32-min") (param i32) (result i32)
-    (i32.reinterpret_f32 (f32.min (f32.reinterpret_i32 (get_local 0)) (f32.const 1)))
+    (i32.reinterpret_f32 (f32.min (f32.reinterpret_i32 (local.get 0)) (f32.const 1)))
   )
   (func (export "nan-canonicalization-f32-nearest") (param i32) (result i32)
-    (i32.reinterpret_f32 (f32.nearest (f32.reinterpret_i32 (get_local 0))))
+    (i32.reinterpret_f32 (f32.nearest (f32.reinterpret_i32 (local.get 0))))
   )
   (func (export "nan-canonicalization-f32-floor") (param i32) (result i32)
-    (i32.reinterpret_f32 (f32.floor (f32.reinterpret_i32 (get_local 0))))
+    (i32.reinterpret_f32 (f32.floor (f32.reinterpret_i32 (local.get 0))))
   )
   (func (export "nan-canonicalization-f32-ceil") (param i32) (result i32)
-    (i32.reinterpret_f32 (f32.ceil (f32.reinterpret_i32 (get_local 0))))
+    (i32.reinterpret_f32 (f32.ceil (f32.reinterpret_i32 (local.get 0))))
   )
   (func (export "nan-canonicalization-f32-trunc") (param i32) (result i32)
-    (i32.reinterpret_f32 (f32.trunc (f32.reinterpret_i32 (get_local 0))))
+    (i32.reinterpret_f32 (f32.trunc (f32.reinterpret_i32 (local.get 0))))
   )
   (func (export "nan-canonicalization-f32-sqrt") (param i32) (result i32)
-    (i32.reinterpret_f32 (f32.sqrt (f32.reinterpret_i32 (get_local 0))))
+    (i32.reinterpret_f32 (f32.sqrt (f32.reinterpret_i32 (local.get 0))))
   )
   (func (export "nan-canonicalization-f32-mem") (param i32) (result i32)
-    (f32.store (i32.const 0) (f32.reinterpret_i32 (get_local 0)))
+    (f32.store (i32.const 0) (f32.reinterpret_i32 (local.get 0)))
     (i32.reinterpret_f32 (f32.load (i32.const 0)))
   )
   (func (export "nan-canonicalization-f32-mem-cncl") (param i32) (result i32)
-    (f32.store (i32.const 0) (f32.add (f32.reinterpret_i32 (get_local 0)) (f32.const 0)))
+    (f32.store (i32.const 0) (f32.add (f32.reinterpret_i32 (local.get 0)) (f32.const 0)))
     (i32.reinterpret_f32 (f32.load (i32.const 0)))
   )
   (func (export "nan-canonicalization-f32-local") (param i32) (result i32)
     (local f32)
-    (set_local 1 (f32.reinterpret_i32 (get_local 0)))
-    (i32.reinterpret_f32 (get_local 1))
+    (local.set 1 (f32.reinterpret_i32 (local.get 0)))
+    (i32.reinterpret_f32 (local.get 1))
   )
   (func (export "nan-canonicalization-f32-local-cncl") (param i32) (result i32)
     (local f32)
-    (set_local 1 (f32.add (f32.reinterpret_i32 (get_local 0)) (f32.const 0)))
-    (i32.reinterpret_f32 (get_local 1))
+    (local.set 1 (f32.add (f32.reinterpret_i32 (local.get 0)) (f32.const 0)))
+    (i32.reinterpret_f32 (local.get 1))
   )
   (func $nan-canonicalization-f32-func-call-target (param f32) (result f32)
-    (get_local 0)
+    (local.get 0)
   )
   (func (export "nan-canonicalization-f32-func-call") (param i32) (result i32)
-    (i32.reinterpret_f32 (call $nan-canonicalization-f32-func-call-target (f32.reinterpret_i32 (get_local 0))))
+    (i32.reinterpret_f32 (call $nan-canonicalization-f32-func-call-target (f32.reinterpret_i32 (local.get 0))))
   )
   (func (export "nan-canonicalization-f32-func-call-cncl") (param i32) (result i32)
-    (i32.reinterpret_f32 (call $nan-canonicalization-f32-func-call-target (f32.add (f32.reinterpret_i32 (get_local 0)) (f32.const 0))))
+    (i32.reinterpret_f32 (call $nan-canonicalization-f32-func-call-target (f32.add (f32.reinterpret_i32 (local.get 0)) (f32.const 0))))
   )
   (func (export "nan-canonicalization-f32-func-call-indirect") (param i32) (result i32)
-    (i32.reinterpret_f32 (call_indirect (type $f32-id) (f32.reinterpret_i32 (get_local 0)) (i32.const 0)))
+    (i32.reinterpret_f32 (call_indirect (type $f32-id) (f32.reinterpret_i32 (local.get 0)) (i32.const 0)))
   )
   (func (export "nan-canonicalization-f32-func-call-indirect-cncl") (param i32) (result i32)
-    (i32.reinterpret_f32 (call_indirect (type $f32-id) (f32.add (f32.reinterpret_i32 (get_local 0)) (f32.const 0)) (i32.const 0)))
+    (i32.reinterpret_f32 (call_indirect (type $f32-id) (f32.add (f32.reinterpret_i32 (local.get 0)) (f32.const 0)) (i32.const 0)))
   )
 
   (func (export "nan-canonicalization-f64-add") (param i64) (result i64)
-    (i64.reinterpret_f64 (f64.add (f64.reinterpret_i64 (get_local 0)) (f64.const 0)))
+    (i64.reinterpret_f64 (f64.add (f64.reinterpret_i64 (local.get 0)) (f64.const 0)))
   )
   (func (export "nan-canonicalization-f64-sub") (param i64) (result i64)
-    (i64.reinterpret_f64 (f64.sub (f64.reinterpret_i64 (get_local 0)) (f64.const 0)))
+    (i64.reinterpret_f64 (f64.sub (f64.reinterpret_i64 (local.get 0)) (f64.const 0)))
   )
   (func (export "nan-canonicalization-f64-mul") (param i64) (result i64)
-    (i64.reinterpret_f64 (f64.mul (f64.reinterpret_i64 (get_local 0)) (f64.const 0)))
+    (i64.reinterpret_f64 (f64.mul (f64.reinterpret_i64 (local.get 0)) (f64.const 0)))
   )
   (func (export "nan-canonicalization-f64-div") (param i64) (result i64)
-    (i64.reinterpret_f64 (f64.div (f64.reinterpret_i64 (get_local 0)) (f64.const 1)))
+    (i64.reinterpret_f64 (f64.div (f64.reinterpret_i64 (local.get 0)) (f64.const 1)))
   )
   (func (export "nan-canonicalization-f64-max") (param i64) (result i64)
-    (i64.reinterpret_f64 (f64.max (f64.reinterpret_i64 (get_local 0)) (f64.const 1)))
+    (i64.reinterpret_f64 (f64.max (f64.reinterpret_i64 (local.get 0)) (f64.const 1)))
   )
   (func (export "nan-canonicalization-f64-min") (param i64) (result i64)
-    (i64.reinterpret_f64 (f64.min (f64.reinterpret_i64 (get_local 0)) (f64.const 1)))
+    (i64.reinterpret_f64 (f64.min (f64.reinterpret_i64 (local.get 0)) (f64.const 1)))
   )
   (func (export "nan-canonicalization-f64-nearest") (param i64) (result i64)
-    (i64.reinterpret_f64 (f64.nearest (f64.reinterpret_i64 (get_local 0))))
+    (i64.reinterpret_f64 (f64.nearest (f64.reinterpret_i64 (local.get 0))))
   )
   (func (export "nan-canonicalization-f64-floor") (param i64) (result i64)
-    (i64.reinterpret_f64 (f64.floor (f64.reinterpret_i64 (get_local 0))))
+    (i64.reinterpret_f64 (f64.floor (f64.reinterpret_i64 (local.get 0))))
   )
   (func (export "nan-canonicalization-f64-ceil") (param i64) (result i64)
-    (i64.reinterpret_f64 (f64.ceil (f64.reinterpret_i64 (get_local 0))))
+    (i64.reinterpret_f64 (f64.ceil (f64.reinterpret_i64 (local.get 0))))
   )
   (func (export "nan-canonicalization-f64-trunc") (param i64) (result i64)
-    (i64.reinterpret_f64 (f64.trunc (f64.reinterpret_i64 (get_local 0))))
+    (i64.reinterpret_f64 (f64.trunc (f64.reinterpret_i64 (local.get 0))))
   )
   (func (export "nan-canonicalization-f64-sqrt") (param i64) (result i64)
-    (i64.reinterpret_f64 (f64.sqrt (f64.reinterpret_i64 (get_local 0))))
+    (i64.reinterpret_f64 (f64.sqrt (f64.reinterpret_i64 (local.get 0))))
   )
   (func (export "nan-canonicalization-f64-mem") (param i64) (result i64)
-    (f64.store (i32.const 0) (f64.reinterpret_i64 (get_local 0)))
+    (f64.store (i32.const 0) (f64.reinterpret_i64 (local.get 0)))
     (i64.reinterpret_f64 (f64.load (i32.const 0)))
   )
   (func (export "nan-canonicalization-f64-mem-cncl") (param i64) (result i64)
-    (f64.store (i32.const 0) (f64.add (f64.reinterpret_i64 (get_local 0)) (f64.const 0)))
+    (f64.store (i32.const 0) (f64.add (f64.reinterpret_i64 (local.get 0)) (f64.const 0)))
     (i64.reinterpret_f64 (f64.load (i32.const 0)))
   )
   (func (export "nan-canonicalization-f64-local") (param i64) (result i64)
     (local f64)
-    (set_local 1 (f64.reinterpret_i64 (get_local 0)))
-    (i64.reinterpret_f64 (get_local 1))
+    (local.set 1 (f64.reinterpret_i64 (local.get 0)))
+    (i64.reinterpret_f64 (local.get 1))
   )
   (func (export "nan-canonicalization-f64-local-cncl") (param i64) (result i64)
     (local f64)
-    (set_local 1 (f64.add (f64.reinterpret_i64 (get_local 0)) (f64.const 0)))
-    (i64.reinterpret_f64 (get_local 1))
+    (local.set 1 (f64.add (f64.reinterpret_i64 (local.get 0)) (f64.const 0)))
+    (i64.reinterpret_f64 (local.get 1))
   )
   (func $nan-canonicalization-f64-func-call-target (param f64) (result f64)
-    (get_local 0)
+    (local.get 0)
   )
   (func (export "nan-canonicalization-f64-func-call") (param i64) (result i64)
-    (i64.reinterpret_f64 (call $nan-canonicalization-f64-func-call-target (f64.reinterpret_i64 (get_local 0))))
+    (i64.reinterpret_f64 (call $nan-canonicalization-f64-func-call-target (f64.reinterpret_i64 (local.get 0))))
   )
   (func (export "nan-canonicalization-f64-func-call-cncl") (param i64) (result i64)
-    (i64.reinterpret_f64 (call $nan-canonicalization-f64-func-call-target (f64.add (f64.reinterpret_i64 (get_local 0)) (f64.const 0))))
+    (i64.reinterpret_f64 (call $nan-canonicalization-f64-func-call-target (f64.add (f64.reinterpret_i64 (local.get 0)) (f64.const 0))))
   )
   (func (export "nan-canonicalization-f64-func-call-indirect") (param i64) (result i64)
-    (i64.reinterpret_f64 (call_indirect (type $f64-id) (f64.reinterpret_i64 (get_local 0)) (i32.const 1)))
+    (i64.reinterpret_f64 (call_indirect (type $f64-id) (f64.reinterpret_i64 (local.get 0)) (i32.const 1)))
   )
   (func (export "nan-canonicalization-f64-func-call-indirect-cncl") (param i64) (result i64)
-    (i64.reinterpret_f64 (call_indirect (type $f64-id) (f64.add (f64.reinterpret_i64 (get_local 0)) (f64.const 0)) (i32.const 1)))
+    (i64.reinterpret_f64 (call_indirect (type $f64-id) (f64.add (f64.reinterpret_i64 (local.get 0)) (f64.const 0)) (i32.const 1)))
   )
 )
 
diff --git a/tests/wast/wasmer/nested-unreachable-blocks.wast b/tests/wast/wasmer/nested-unreachable-blocks.wast
new file mode 100644
index 0000000000..9a59560c08
--- /dev/null
+++ b/tests/wast/wasmer/nested-unreachable-blocks.wast
@@ -0,0 +1,18 @@
+;; This doesn't test anything in particular; this is just something
+;; that was broken in our LLVM backend at one point.
+
+(module
+  (func (export "f") (result i32)
+    i32.const 1
+    i32.const 2
+    (block $outer (param i32) (result i32)
+      (block (param i32) (result i32)
+        br $outer
+      )
+      unreachable
+    )
+    i32.add
+  )
+)
+
+(assert_return (invoke "f") (i32.const 3))
\ No newline at end of file
diff --git a/tests/wast/wasmer/problematic_names.wast b/tests/wast/wasmer/problematic_names.wast
new file mode 100644
index 0000000000..b6df460a11
--- /dev/null
+++ b/tests/wast/wasmer/problematic_names.wast
@@ -0,0 +1,17 @@
+(module
+    (func $.L_oops_llvm_local
+        return
+    )
+
+    (func $llvm.oops_llvm_intrinsic
+        return
+    )
+
+    (func (export "test_it") (result i32)
+        call $llvm.oops_llvm_intrinsic
+        call $.L_oops_llvm_local
+        i32.const 1
+    )
+)
+
+(assert_return (invoke "test_it") (i32.const 1))
diff --git a/tests/wast/wasmer/stack-overflow.wast b/tests/wast/wasmer/stack-overflow.wast
index fc11c085b1..43a322d95d 100644
--- a/tests/wast/wasmer/stack-overflow.wast
+++ b/tests/wast/wasmer/stack-overflow.wast
@@ -3,7 +3,7 @@
       (func (;0;) (type 0)
         i32.const 0
         call_indirect (type 0))
-      (table (;0;) 1 anyfunc)
+      (table (;0;) 1 funcref)
       (export "stack-overflow" (func 0))
       (elem (;0;) (i32.const 0) 0))